Generic In-memory buffer of data to be used as I/O.
This class offers both input and output, which can be used at the same time since Efl.Io.Reader.read and Efl.Io.Writer.write use different offsets/position internally.
One can get temporary direct access to internal buffer with Efl.Io.Buffer.slice or steal the buffer with Efl.Io.Buffer.binbuf_steal.
A fixed sized buffer can be implemented by setting Efl.Io.Buffer.limit followed by Efl.Io.Buffer.preallocate
⇒ Efl.Object (class)
Adopt a read-only slice as buffer's backing store.
void efl_io_buffer_adopt_readonly(Eo *obj, const Eina_Slice slice);
Adopt a read-write slice as buffer's backing store.
void efl_io_buffer_adopt_readwrite(Eo *obj, Eina_Rw_Slice slice);
Steals the internal buffer memory and returns it as a binbuf.
Eina_Binbuf *efl_io_buffer_binbuf_steal(Eo *obj);
can_read (get, set) protected set
[Overridden from Efl.Io.Reader]
Iftrue
will notify Efl.Io.Reader.read can be called without blocking or failing.
Eina_Bool efl_io_reader_can_read_get(const Eo *obj); void efl_io_reader_can_read_set(Eo *obj, Eina_Bool can_read);
can_write (get, set) protected set
[Overridden from Efl.Io.Writer]
Iftrue
will notify Efl.Io.Writer.write can be called without blocking or failing.
Eina_Bool efl_io_writer_can_write_get(const Eo *obj); void efl_io_writer_can_write_set(Eo *obj, Eina_Bool can_write);
close [Overridden from Efl.Io.Closer]
Closes the Input/Output object.
Eina_Error efl_io_closer_close(Eo *obj);
close_on_exec (get, set) [Overridden from Efl.Io.Closer]
If true will automatically close resources on exec() calls.
Eina_Bool efl_io_closer_close_on_exec_get(const Eo *obj); Eina_Bool efl_io_closer_close_on_exec_set(Eo *obj, Eina_Bool close_on_exec);
close_on_invalidate (get, set) [Overridden from Efl.Io.Closer]
If true will automatically close() on object invalidate.
Eina_Bool efl_io_closer_close_on_invalidate_get(const Eo *obj); void efl_io_closer_close_on_invalidate_set(Eo *obj, Eina_Bool close_on_invalidate);
closed (get) [Overridden from Efl.Io.Closer]
Eina_Bool efl_io_closer_closed_get(const Eo *obj);
destructor [Overridden from Efl.Object]
Implement this method to provide deinitialization code for your object if you need it.
void efl_destructor(Eo *obj);
eos (get, set) protected set
[Overridden from Efl.Io.Reader]
Iftrue
will notify end of stream.
Eina_Bool efl_io_reader_eos_get(const Eo *obj); void efl_io_reader_eos_set(Eo *obj, Eina_Bool is_eos);
finalize [Overridden from Efl.Object]
Implement this method to finish the initialization of your object after all (if any) user-provided configuration methods have been executed.
Efl_Object *efl_finalize(Eo *obj);
limit (get, set)
Limit how big the buffer can grow.
size_t efl_io_buffer_limit_get(const Eo *obj); void efl_io_buffer_limit_set(Eo *obj, size_t size);
position (get, set) [Overridden from Efl.Io.Positioner]
Position property
uint64_t efl_io_positioner_position_get(const Eo *obj); Eina_Bool efl_io_positioner_position_set(Eo *obj, uint64_t position);
position_read (get, set)
The position used by Efl.Io.Reader.read.
uint64_t efl_io_buffer_position_read_get(const Eo *obj); Eina_Bool efl_io_buffer_position_read_set(Eo *obj, uint64_t position);
position_write (get, set)
The position used by Efl.Io.Writer.write.
uint64_t efl_io_buffer_position_write_get(const Eo *obj); Eina_Bool efl_io_buffer_position_write_set(Eo *obj, uint64_t position);
Immediately pre-allocate a buffer of at least a given size.
void efl_io_buffer_preallocate(Eo *obj, size_t size);
read [Overridden from Efl.Io.Reader]
Reads data into a pre-allocated buffer.
Eina_Error efl_io_reader_read(Eo *obj, Eina_Rw_Slice rw_slice);
resize [Overridden from Efl.Io.Sizer]
Resize object
Eina_Error efl_io_sizer_resize(Eo *obj, uint64_t size);
seek [Overridden from Efl.Io.Positioner]
Seek in data
Eina_Error efl_io_positioner_seek(Eo *obj, int64_t offset, Efl_Io_Positioner_Whence whence);
size (get, set) [Overridden from Efl.Io.Sizer]
Size property
uint64_t efl_io_sizer_size_get(const Eo *obj); Eina_Bool efl_io_sizer_size_set(Eo *obj, uint64_t size);
slice (get)
Eina_Slice efl_io_buffer_slice_get(const Eo *obj);
write [Overridden from Efl.Io.Writer]
Writes data from a pre-populated buffer.
Eina_Error efl_io_writer_write(Eo *obj, Eina_Slice slice, Eina_Slice *remaining);
Efl.Object | ||
---|---|---|
allow_parent_unref (get, set) | Allow an object to be deleted by unref even if it has a parent. | |
children_iterator_new | Get an iterator on all children. | |
comment (get, set) | A human readable comment for the object. | |
composite_attach | Make an object a composite object of another. | |
composite_detach | Detach a composite object from another object. | |
composite_part_is | Check if an object is part of a composite object. | |
constructor | Implement this method to provide optional initialization code for your object. | |
debug_name_override | Build a read-only name for this object used for debugging. | |
event_callback_forwarder_del | Remove an event callback forwarder for a specified event and object. | |
event_callback_forwarder_priority_add | Add an event callback forwarder that will make this object emit an event whenever another object (source ) emits it. The event is said to be forwarded from source to this object. |
|
event_callback_stop | Stop the current callback call. | |
event_freeze | Freeze events of this object. | |
event_freeze_count (get) | ||
static | event_global_freeze | Globally freeze events for ALL EFL OBJECTS. |
static | event_global_freeze_count (get) | |
static | event_global_thaw | Globally thaw events for ALL EFL OBJECTS. |
event_thaw | Thaw events of object. | |
finalized (get) | ||
invalidate | Implement this method to perform special actions when your object loses its parent, if you need to. | |
invalidated (get) | ||
invalidating (get) | ||
name (get, set) | The name of the object. | |
name_find | Find a child object with the given name and return it. | |
parent (get, set) | The parent of an object. | |
provider_find | Searches upwards in the object tree for a provider which knows the given class/interface. | |
provider_register | Will register a manager of a specific class to be answered by Efl.Object.provider_find. | |
provider_unregister | Will unregister a manager of a specific class that was previously registered and answered by Efl.Object.provider_find. |
Notifies Efl.Io.Buffer.position_read changed
EFL_IO_BUFFER_EVENT_POSITION_READ_CHANGED(void)
Notifies Efl.Io.Buffer.position_write changed
EFL_IO_BUFFER_EVENT_POSITION_WRITE_CHANGED(void)
Notifies the internal buffer was reallocated, thus whatever was returned by Efl.Io.Buffer.slice becomes invalid.
EFL_IO_BUFFER_EVENT_REALLOCATED(void)
Efl.Io.Closer | ||
---|---|---|
closed | Notifies closed, when property is marked as true | |
Efl.Io.Positioner | ||
position,changed | Notifies position changed | |
Efl.Io.Reader | ||
can_read,changed | Notifies can_read property changed. | |
eos | Notifies end of stream, when property is marked as true. | |
Efl.Io.Sizer | ||
size,changed | Notifies size changed | |
Efl.Io.Writer | ||
can_write,changed | Notifies can_write property changed. | |
Efl.Object | ||
del | Object is being deleted. See Efl.Object.destructor. | |
destruct | Object has been fully destroyed. It can not be used beyond this point. This event should only serve to clean up any reference you keep to the object. | |
invalidate | Object is being invalidated and losing its parent. See Efl.Object.invalidate. | |
noref | Object has lost its last reference, only parent relationship is keeping it alive. Advanced usage. | |
ownership,shared | Object has acquired a second reference. It has multiple owners now. Triggered whenever increasing the refcount from one to two, it will not trigger by further increasing the refcount beyond two. | |
ownership,unique | Object has lost a reference and only one is left. It has just one owner now. Triggered whenever the refcount goes from two to one. |