Data Struct Reference

#include <Data.h>

Overview

Data buffers.

Definition at line 50 of file Data.h.

Inheritance diagram for Data:

Properties
uint8_t *	bytes
	The bytes.
DataDestructor	destroy
	An optional destructor that, if set, is called on dealloc.
size_t	length
	The length of bytes.
Object	object
	The superclass.
Properties inherited from Object
Class *	clazz
	Every instance of Object begins with a pointer to its Class.
unsigned int	magic
	A header to allow introspection of Object types.

Methods
Class *	_Data (void)
	The Data archetype.
void	appendBytes (Data *self, const uint8_t *bytes, size_t length)
	Appends the given bytes to this Data.
void	appendData (Data *self, const Data *data)
	Appends the given data to this Data.
Data *	data (void)
	Returns a new Data.
Data *	dataWithBytes (const uint8_t *bytes, size_t length)
	Returns a new Data by copying length of bytes.
Data *	dataWithCapacity (size_t capacity)
	Returns a new Data with the given capacity.
Data *	dataWithConstMemory (const ident mem, size_t length)
	Returns a new Data, backed by the given const memory.
Data *	dataWithContentsOfFile (const char *path)
	Returns a new Data with the contents of the file at path.
Data *	dataWithMemory (ident mem, size_t length)
	Returns a new Data, taking ownership of the specified memory.
Data *	init (Data *self)
	Initializes this Data with length 0.
Data *	initWithBytes (Data *self, const uint8_t *bytes, size_t length)
	Initializes this Data by copying length of bytes.
Data *	initWithCapacity (Data *self, size_t capacity)
	Initializes this Data with the given capacity.
Data *	initWithConstMemory (Data *self, const ident mem, size_t length)
	Initializes this Data with the given const memory.
Data *	initWithContentsOfFile (Data *self, const char *path)
	Initializes this Data with the contents of the file at path.
Data *	initWithData (Data *self, const Data *data)
	Initializes this Data with the contents of data.
Data *	initWithMemory (Data *self, ident mem, size_t length)
	Initializes this Data, taking ownership of the specified memory.
void	setLength (Data *self, size_t length)
	Sets the length of this Data, truncating or expanding it.
bool	writeToFile (const Data *self, const char *path)
	Writes this Data to path.
Methods inherited from Object
Class *	_Object (void)
	The Object archetype.
Object *	copy (const Object *self)
	Creates a shallow copy of this Object.
void	dealloc (Object *self)
	Frees all resources held by this Object.
String *	description (const Object *self)
int	hash (const Object *self)
Object *	init (Object *self)
	Initializes this Object.
bool	isEqual (const Object *self, const Object *other)
	Tests equality of the other Object.
bool	isKindOfClass (const Object *self, const Class *clazz)
	Tests for Class hierarchy membership.

Protected Attributes
DataInterface *	interface
	The interface.
Protected Attributes inherited from Object
ObjectInterface *	interface
	The interface.

Property Details

bytes

uint8_t* Data::bytes

The bytes.

Definition at line 66 of file Data.h.

destroy

DataDestructor Data::destroy

An optional destructor that, if set, is called on dealloc.

Definition at line 71 of file Data.h.

interface

DataInterface* Data::interface

protected

The interface.

Definition at line 61 of file Data.h.

length

size_t Data::length

The length of bytes.

Definition at line 76 of file Data.h.

object

Object Data::object

The superclass.

Definition at line 55 of file Data.h.

Method Details

_Data()

Class * _Data

(

void

)

The Data archetype.

Returns

The Data Class.

Definition at line 419 of file Data.c.

                   {
  static Class *clazz;
  static Once once;
 
  do_once(&once, {
    clazz = _initialize(&(const ClassDef) {
      .name = "Data",
      .superclass = _Object(),
      .instanceSize = sizeof(Data),
      .interfaceOffset = offsetof(Data, interface),
      .interfaceSize = sizeof(DataInterface),
      .initialize = initialize,
    });
  });
 
  return clazz;
}

appendBytes()

void appendBytes	(	Data *	self,
		const uint8_t *	bytes,
		size_t	length
	)

Appends the given bytes to this Data.

Parameters

self	The Data.
bytes	The bytes to append.
length	The length of bytes to append.

Remarks

Data are grown in blocks as bytes are appended. This provides a significant performance gain when frequently appending small chunks of bytes.

Definition at line 262 of file Data.c.

                                                                         {
 
  const size_t oldLength = self->length;
 
  $(self, setLength, self->length + length);
 
  if (length) {
    memcpy(self->bytes + oldLength, bytes, length);
  }
}

appendData()

void appendData	(	Data *	self,
		const Data *	data
	)

Appends the given data to this Data.

Parameters

self	The Data.
data	The Data to append.

Definition at line 277 of file Data.c.

                                                     {
 
  $(self, appendBytes, data->bytes, data->length);
}

data()

Data * data

(

void

)

Returns a new Data.

Returns

The new Data, or NULL on error.

Definition at line 286 of file Data.c.

                        {
 
  return $(alloc(Data), init);
}

dataWithBytes()

Data * dataWithBytes	(	const uint8_t *	bytes,
		size_t	length
	)

Returns a new Data by copying length of bytes.

Parameters

bytes	The bytes.
length	The length of bytes to copy.

Returns

The new Data, or NULL on error.

Definition at line 115 of file Data.c.

                                                                {
 
  return $(alloc(Data), initWithBytes, bytes, length);
}

dataWithCapacity()

Data * dataWithCapacity

(

size_t

capacity

)

Returns a new Data with the given capacity.

Parameters

capacity

The desired capacity in bytes.

Returns

The new Data, or NULL on error.

Definition at line 295 of file Data.c.

                                               {
 
  return $(alloc(Data), initWithCapacity, capacity);
}

dataWithConstMemory()

Data * dataWithConstMemory	(	const ident	mem,
		size_t	length
	)

Returns a new Data, backed by the given const memory.

Parameters

mem	The constant memory to back this Data.
length	The length of mem in bytes.

Returns

The new Data, or NULL on error.

Definition at line 124 of file Data.c.

                                                                 {
 
  return $(alloc(Data), initWithConstMemory, mem, length);
}

dataWithContentsOfFile()

Data * dataWithContentsOfFile

(

const char *

path

)

Returns a new Data with the contents of the file at path.

Parameters

path	The path of the file to read into memory.

Returns

The new Data, or NULL on error.

Definition at line 133 of file Data.c.

                                                      {
 
  return $(alloc(Data), initWithContentsOfFile, path);
}

dataWithMemory()

Data * dataWithMemory	(	ident	mem,
		size_t	length
	)

Returns a new Data, taking ownership of the specified memory.

Parameters

mem	The dynamically allocated memory to back this Data.
length	The length of mem in bytes.

Returns

The new Data, or NULL on error.

Definition at line 142 of file Data.c.

                                                      {
 
  return $(alloc(Data), initWithMemory, mem, length);
}

init()

Data * init

(

Data *

self

)

Initializes this Data with length 0.

Parameters

self

The Data.

Returns

The initialized Data, or NULL on error.

Definition at line 304 of file Data.c.

                              {
 
  return $(self, initWithCapacity, 0);
}

initWithBytes()

Data * initWithBytes	(	Data *	self,
		const uint8_t *	bytes,
		size_t	length
	)

Initializes this Data by copying length of bytes.

Parameters

self	The Data.
bytes	The bytes.
length	The length of bytes to copy.

Returns

The initialized Data, or NULL on error.

Definition at line 151 of file Data.c.

                                                                            {
 
  ident mem = NULL;
  if (length) {
    mem = malloc(length);
    assert(mem);
 
    memcpy(mem, bytes, length);
  }
 
  return $(self, initWithMemory, mem, length);
}

initWithCapacity()

Data * initWithCapacity	(	Data *	self,
		size_t	capacity
	)

Initializes this Data with the given capacity.

Parameters

self	The Data.
capacity	The capacity in bytes.

Returns

The initialized Data, or NULL on error.

Definition at line 313 of file Data.c.

                                                           {
 
  self = (Data *) super(Object, self, init);
  if (self) {
 
    self->capacity = capacity;
    if (self->capacity) {
 
      self->bytes = calloc(capacity, sizeof(uint8_t));
      assert(self->bytes);
    }
 
    self->destroy = free;
  }
 
  return self;
}

initWithConstMemory()

Data * initWithConstMemory	(	Data *	self,
		const ident	mem,
		size_t	length
	)

Initializes this Data with the given const memory.

Parameters

self	The Data.
mem	The const memory to back this Data.
length	The length of mem in bytes.

Returns

The initialized Data, or NULL on error.

Definition at line 168 of file Data.c.

                                                                             {
 
  self = (Data *) super(Object, self, init);
  if (self) {
    self->bytes = mem;
    self->length = length;
    self->capacity = length;
  }
 
  return self;
}

initWithContentsOfFile()

Data * initWithContentsOfFile	(	Data *	self,
		const char *	path
	)

Initializes this Data with the contents of the file at path.

Parameters

self	The Data.
path	The path of the file to read into memory.

Returns

The initialized Data, or NULL on error.

Definition at line 184 of file Data.c.

                                                                  {
 
  assert(path);
 
  FILE *file = fopen(path, "rb");
  if (file) {
    ident mem = NULL;
 
    int err = fseek(file, 0, SEEK_END);
    assert(err == 0);
 
    const size_t length = ftell(file);
    if (length) {
 
      mem = malloc(length);
      assert(mem);
 
      err = fseek(file, 0, SEEK_SET);
      assert(err == 0);
 
      const size_t read = fread(mem, length, 1, file);
      assert(read == 1);
    }
 
    fclose(file);
    return $(self, initWithMemory, mem, length);
  }
 
  return release(self);
}

initWithData()

Data * initWithData	(	Data *	self,
		const Data *	data
	)

Initializes this Data with the contents of data.

Parameters

self	The Data.
data	A Data.

Returns

The initialized Data, or NULL on error.

Definition at line 335 of file Data.c.

                                                        {
 
  self = $(self, initWithCapacity, data->length);
  if (self) {
    $(self, appendData, data);
  }
 
  return self;
}

initWithMemory()

Data * initWithMemory	(	Data *	self,
		ident	mem,
		size_t	length
	)

Initializes this Data, taking ownership of the specified memory.

Parameters

self	The Data.
mem	The dynamically allocated memory to back this Data.
length	The length of mem in bytes.

Returns

The initialized Data, or NULL on error.

Definition at line 219 of file Data.c.

                                                                  {
 
  self = $(self, initWithConstMemory, mem, length);
  if (self) {
    self->destroy = free;
  }
 
  return self;
}

setLength()

void setLength	(	Data *	self,
		size_t	length
	)

Sets the length of this Data, truncating or expanding it.

Parameters

self	The Data.
length	The new desired length.

Remarks

If the data is expanded, the newly allocated bytes are filled with zeros.

Definition at line 349 of file Data.c.

                                                 {
 
  const size_t newCapacity = (length / _pageSize + 1) * _pageSize;
  if (newCapacity > self->capacity) {
 
    if (self->bytes == NULL) {
      self->bytes = calloc(newCapacity, sizeof(uint8_t));
      assert(self->bytes);
    } else {
      if (self->destroy != free) {
        uint8_t *owned = malloc(newCapacity);
        assert(owned);
        memcpy(owned, self->bytes, self->length);
        if (length > self->length) {
          memset(owned + self->length, 0, length - self->length);
        }
        self->bytes = owned;
        self->destroy = free;
      } else {
        self->bytes = realloc(self->bytes, newCapacity);
        assert(self->bytes);
        if (length > self->length) {
          memset(self->bytes + self->length, 0, length - self->length);
        }
      }
    }
 
    self->capacity = newCapacity;
  } else if (length > self->length) {
    memset(self->bytes + self->length, 0, length - self->length);
  }
 
  self->length = length;
}

writeToFile()

bool writeToFile	(	const Data *	self,
		const char *	path
	)

Writes this Data to path.

Parameters

self	The Data.
path	The path of the file to write.

Returns

true on success, false on error.

Definition at line 233 of file Data.c.

                                                            {
 
  assert(path);
 
  FILE *file = fopen(path, "w");
  if (file) {
 
    size_t count = 1;
 
    if (self->length) {
      count = fwrite(self->bytes, self->length, 1, file);
    }
 
    fclose(file);
 
    if (count == 1) {
      return true;
    }
  }
 
  return false;
}

---

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

• Sources/Objectively/Data.h
• Sources/Objectively/Data.c