enlightenment/efl
enlightenment
/
efl
8
7
Fork 14
Code Issues 13 Pull Requests 3 Projects Releases Wiki Activity

efl_task: remove efl.io.* interfaces 

Remove efl.io.* interfaces from efl_task, and make other extended
classes properly.

ref T7657

Reviewed-by: Marcel Hollerbach <marcel-hollerbach@t-online.de>
Reviewed-by: Cedric BAIL <cedric.bail@free.fr>
Reviewed-by: Derek Foreman <derekf@osg.samsung.com>
Differential Revision: https://phab.enlightenment.org/D7747
This commit is contained in:
WooHyun Jung 2019-01-25 08:57:54 +00:00 committed by Derek Foreman
parent d47688ba27
commit 0b0ff33f2f
6 changed files with 9 additions and 315 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

306
src/lib/ecore/efl_app.c
View File

@ -2,10 +2,6 @@
# include <config.h>
#endif
#define EFL_IO_READER_PROTECTED 1
#define EFL_IO_WRITER_PROTECTED 1
#define EFL_IO_CLOSER_PROTECTED 1
#include <Ecore.h>
#include "ecore_private.h"
@ -16,24 +12,8 @@
#define MY_CLASS EFL_APP_CLASS
typedef struct _Efl_App_Data Efl_App_Data;
struct _Efl_App_Data
{
struct {
int in, out;
Eo *in_handler, *out_handler;
Eina_Bool can_read : 1;
Eina_Bool eos_read : 1;
Eina_Bool can_write : 1;
} fd;
int read_listeners;
};
Efl_Version _app_efl_version = { 0, 0, 0, 0, NULL, NULL };
//////////////////////////////////////////////////////////////////////////
EOLIAN static Efl_App*
_efl_app_app_main_get(const Eo *obj EINA_UNUSED, void *pd EINA_UNUSED)
{
@ -43,81 +23,14 @@ _efl_app_app_main_get(const Eo *obj EINA_UNUSED, void *pd EINA_UNUSED)
return _mainloop_singleton;
}
//////////////////////////////////////////////////////////////////////////
static void
_parent_read_listeners_modify(Efl_App_Data *pd, int mod)
{
pd->read_listeners += mod;
if (pd->fd.out_handler)
{
if ((pd->read_listeners == 0) && (mod < 0))
efl_loop_handler_active_set
(pd->fd.out_handler, EFL_LOOP_HANDLER_FLAGS_NONE);
else if ((pd->read_listeners == 1) && (mod > 0))
efl_loop_handler_active_set
(pd->fd.out_handler, EFL_LOOP_HANDLER_FLAGS_READ);
}
}
static void
_cb_event_callback_add(void *data, const Efl_Event *event)
{
Efl_App_Data *pd = data;
const Efl_Callback_Array_Item_Full *array = event->info;
int i;
for (i = 0; array[i].desc != NULL; i++)
{
if (array[i].desc == EFL_IO_READER_EVENT_CAN_READ_CHANGED)
_parent_read_listeners_modify(pd, 1);
}
}
static void
_cb_event_callback_del(void *data, const Efl_Event *event)
{
Efl_App_Data *pd = data;
const Efl_Callback_Array_Item_Full *array = event->info;
int i;
for (i = 0; array[i].desc != NULL; i++)
{
if (array[i].desc == EFL_IO_READER_EVENT_CAN_READ_CHANGED)
_parent_read_listeners_modify(pd, -1);
}
}
static void
_cb_out(void *data, const Efl_Event *event EINA_UNUSED)
{
Eo *obj = data;
efl_io_reader_can_read_set(obj, EINA_TRUE);
}
static void
_cb_in(void *data, const Efl_Event *event EINA_UNUSED)
{
Eo *obj = data;
efl_io_writer_can_write_set(obj, EINA_TRUE);
}
EFL_CALLBACKS_ARRAY_DEFINE(_event_callback_watch,
{ EFL_EVENT_CALLBACK_ADD, _cb_event_callback_add },
{ EFL_EVENT_CALLBACK_DEL, _cb_event_callback_del });
//////////////////////////////////////////////////////////////////////////
EOLIAN static const Efl_Version *
_efl_app_build_efl_version_get(const Eo *obj EINA_UNUSED, Efl_App_Data *pd EINA_UNUSED)
_efl_app_build_efl_version_get(const Eo *obj EINA_UNUSED, void *pd EINA_UNUSED)
{
return &_app_efl_version;
}
EOLIAN static const Efl_Version *
_efl_app_efl_version_get(const Eo *obj EINA_UNUSED, Efl_App_Data *pd EINA_UNUSED)
_efl_app_efl_version_get(const Eo *obj EINA_UNUSED, void *pd EINA_UNUSED)
{
/* vanilla EFL: flavor = NULL */
static const Efl_Version version = {
@ -131,217 +44,6 @@ _efl_app_efl_version_get(const Eo *obj EINA_UNUSED, Efl_App_Data *pd EINA_UNUSED
return &version;
}
EOLIAN static Efl_Object *
_efl_app_efl_object_constructor(Eo *obj, Efl_App_Data *pd)
{
obj = efl_constructor(efl_super(obj, MY_CLASS));
efl_event_callback_array_add(obj, _event_callback_watch(), pd);
pd->fd.in = 1;
pd->fd.out = 0;
pd->fd.can_write = EINA_TRUE;
pd->fd.in_handler =
efl_add(EFL_LOOP_HANDLER_CLASS, obj,
efl_loop_handler_fd_set(efl_added, pd->fd.in),
efl_event_callback_add(efl_added, EFL_LOOP_HANDLER_EVENT_WRITE, _cb_in, obj));
pd->fd.out_handler =
efl_add(EFL_LOOP_HANDLER_CLASS, obj,
efl_loop_handler_fd_set(efl_added, pd->fd.out),
efl_event_callback_add(efl_added, EFL_LOOP_HANDLER_EVENT_READ, _cb_out, obj));
return obj;
}
EOLIAN static void
_efl_app_efl_object_invalidate(Eo *obj, Efl_App_Data *pd)
{
pd->fd.in_handler = NULL;
pd->fd.out_handler = NULL;
pd->fd.in = -1;
pd->fd.out = -1;
efl_invalidate(efl_super(obj, MY_CLASS));
}
EOLIAN static Eina_Error
_efl_app_efl_io_closer_close(Eo *obj, Efl_App_Data *pd)
{
EINA_SAFETY_ON_TRUE_RETURN_VAL(efl_io_closer_closed_get(obj), EBADF);
efl_io_writer_can_write_set(obj, EINA_FALSE);
efl_io_reader_can_read_set(obj, EINA_FALSE);
efl_io_reader_eos_set(obj, EINA_TRUE);
if (pd->fd.in_handler) efl_del(pd->fd.in_handler);
if (pd->fd.out_handler) efl_del(pd->fd.out_handler);
pd->fd.in = -1;
pd->fd.out = -1;
pd->fd.in_handler = NULL;
pd->fd.out_handler = NULL;
return 0;
}
EOLIAN static Eina_Bool
_efl_app_efl_io_closer_closed_get(const Eo *obj EINA_UNUSED, Efl_App_Data *pd)
{
if ((pd->fd.in == -1) && (pd->fd.out == -1)) return EINA_TRUE;
return EINA_FALSE;
}
EOLIAN static Eina_Error
_efl_app_efl_io_reader_read(Eo *obj, Efl_App_Data *pd, Eina_Rw_Slice *rw_slice)
{
ssize_t r;
errno = 0;
if (pd->fd.out == -1) goto err;
do
{
errno = 0;
r = read(pd->fd.out, rw_slice->mem, rw_slice->len);
if (r == -1)
{
if (errno == EINTR) continue;
goto err;
}
}
while (r == -1);
rw_slice->len = r;
if (r == 0)
{
efl_io_reader_can_read_set(obj, EINA_FALSE);
efl_io_reader_eos_set(obj, EINA_TRUE);
close(pd->fd.out);
pd->fd.out = -1;
efl_del(pd->fd.out_handler);
pd->fd.out_handler = NULL;
return EPIPE;
}
return 0;
err:
if ((pd->fd.out != -1) && (errno != EAGAIN))
{
close(pd->fd.out);
pd->fd.out = -1;
efl_del(pd->fd.out_handler);
pd->fd.out_handler = NULL;
}
rw_slice->len = 0;
rw_slice->mem = NULL;
efl_io_reader_can_read_set(obj, EINA_FALSE);
return EINVAL;
}
EOLIAN static void
_efl_app_efl_io_reader_can_read_set(Eo *obj, Efl_App_Data *pd, Eina_Bool can_read)
{
Eina_Bool old = efl_io_reader_can_read_get(obj);
if (old == can_read) return;
pd->fd.can_read = can_read;
if (can_read)
efl_loop_handler_active_set(pd->fd.in_handler, 0);
else
efl_loop_handler_active_set(pd->fd.in_handler,
EFL_LOOP_HANDLER_FLAGS_READ);
efl_event_callback_call(obj, EFL_IO_READER_EVENT_CAN_READ_CHANGED, NULL);
}
EOLIAN static Eina_Bool
_efl_app_efl_io_reader_can_read_get(const Eo *obj EINA_UNUSED, Efl_App_Data *pd)
{
return pd->fd.can_read;
}
EOLIAN static void
_efl_app_efl_io_reader_eos_set(Eo *obj, Efl_App_Data *pd, Eina_Bool is_eos)
{
Eina_Bool old = efl_io_reader_eos_get(obj);
if (old == is_eos) return;
pd->fd.eos_read = is_eos;
if (!is_eos) return;
if (pd->fd.out_handler)
efl_loop_handler_active_set(pd->fd.out_handler, 0);
efl_event_callback_call(obj, EFL_IO_READER_EVENT_EOS, NULL);
}
EOLIAN static Eina_Bool
_efl_app_efl_io_reader_eos_get(const Eo *obj EINA_UNUSED, Efl_App_Data *pd)
{
return pd->fd.eos_read;
}
EOLIAN static Eina_Error
_efl_app_efl_io_writer_write(Eo *obj, Efl_App_Data *pd, Eina_Slice *slice, Eina_Slice *remaining)
{
ssize_t r;
errno = 0;
if (pd->fd.in == -1) goto err;
do
{
errno = 0;
r = write(pd->fd.in, slice->mem, slice->len);
if (r == -1)
{
if (errno == EINTR) continue;
goto err;
}
}
while (r == -1);
if (remaining)
{
remaining->len = slice->len - r;
remaining->bytes = slice->bytes + r;
}
slice->len = r;
if ((slice) && (slice->len > 0))
efl_io_writer_can_write_set(obj, EINA_FALSE);
if (r == 0)
{
close(pd->fd.in);
pd->fd.in = -1;
efl_del(pd->fd.in_handler);
pd->fd.in_handler = NULL;
return EPIPE;
}
return 0;
err:
if ((pd->fd.in != -1) && (errno != EAGAIN))
{
close(pd->fd.in);
pd->fd.in = -1;
efl_del(pd->fd.in_handler);
pd->fd.in_handler = NULL;
}
if (remaining) *remaining = *slice;
slice->len = 0;
slice->mem = NULL;
efl_io_writer_can_write_set(obj, EINA_FALSE);
return EINVAL;
}
EOLIAN static void
_efl_app_efl_io_writer_can_write_set(Eo *obj, Efl_App_Data *pd, Eina_Bool can_write)
{
Eina_Bool old = efl_io_writer_can_write_get(obj);
if (old == can_write) return;
pd->fd.can_write = can_write;
if (can_write)
efl_loop_handler_active_set(pd->fd.in_handler, 0);
else
efl_loop_handler_active_set(pd->fd.in_handler,
EFL_LOOP_HANDLER_FLAGS_WRITE);
efl_event_callback_call(obj, EFL_IO_WRITER_EVENT_CAN_WRITE_CHANGED, NULL);
}
EOLIAN static Eina_Bool
_efl_app_efl_io_writer_can_write_get(const Eo *obj EINA_UNUSED, Efl_App_Data *pd)
{
return pd->fd.can_write;
}
#ifdef _WIN32
#else
static const signed char primap[EFL_TASK_PRIORITY_ULTRA + 1] =
@ -355,7 +57,7 @@ static const signed char primap[EFL_TASK_PRIORITY_ULTRA + 1] =
#endif
EOLIAN static void
_efl_app_efl_task_priority_set(Eo *obj, Efl_App_Data *pd EINA_UNUSED, Efl_Task_Priority priority)
_efl_app_efl_task_priority_set(Eo *obj, void *pd EINA_UNUSED, Efl_Task_Priority priority)
{
efl_task_priority_set(efl_super(obj, MY_CLASS), priority);
#ifdef _WIN32
@ -371,7 +73,7 @@ _efl_app_efl_task_priority_set(Eo *obj, Efl_App_Data *pd EINA_UNUSED, Efl_Task_P
}
EOLIAN static Efl_Task_Priority
_efl_app_efl_task_priority_get(const Eo *obj, Efl_App_Data *pd EINA_UNUSED)
_efl_app_efl_task_priority_get(const Eo *obj, void *pd EINA_UNUSED)
{
Efl_Task_Priority pri = EFL_TASK_PRIORITY_NORMAL;
#ifdef _WIN32

10
src/lib/ecore/efl_app.eo
View File

@ -3,6 +3,7 @@ import efl_types;
class Efl.App extends Efl.Loop
{
[[ ]]
data: null;
methods {
@property app_main @class {
[[ Returns the app object that is representing this process
@ -46,15 +47,6 @@ class Efl.App extends Efl.Loop
signal,hup: void; [[System specific, but on unix maps to SIGHUP signal to the process - only called on main loop object]]
}
implements {
Efl.Object.constructor;
Efl.Object.invalidate;
Efl.Io.Closer.close;
Efl.Io.Closer.closed { get; }
Efl.Io.Reader.read;
Efl.Io.Reader.can_read { get; set; }
Efl.Io.Reader.eos { get; set; }
Efl.Io.Writer.write;
Efl.Io.Writer.can_write { get; set; }
Efl.Task.priority { get; set; }
}
}

2
src/lib/ecore/efl_appthread.eo
View File

@ -1,4 +1,4 @@
class Efl.Appthread extends Efl.Loop implements Efl.ThreadIO
class Efl.Appthread extends Efl.Loop implements Efl.ThreadIO, Efl.Io.Reader, Efl.Io.Writer, Efl.Io.Closer
{
[[ ]]
methods {

2
src/lib/ecore/efl_exe.eo
View File

@ -19,7 +19,7 @@ enum Efl.Exe_Flags {
hide_io = 4
}
class Efl.Exe extends Efl.Task
class Efl.Exe extends Efl.Task implements Efl.Io.Reader, Efl.Io.Writer, Efl.Io.Closer
{
[[ ]]
methods {

2
src/lib/ecore/efl_task.eo
View File

@ -15,7 +15,7 @@ enum Efl.Task_Flags {
no_exit_code_error = 4,
}
abstract Efl.Task extends Efl.Object implements Efl.Io.Reader, Efl.Io.Writer, Efl.Io.Closer
abstract Efl.Task extends Efl.Object
{
[[ ]]
methods {

2
src/lib/ecore/efl_thread.eo
View File

@ -1,4 +1,4 @@
class Efl.Thread extends Efl.Task implements Efl.ThreadIO
class Efl.Thread extends Efl.Task implements Efl.ThreadIO, Efl.Io.Reader, Efl.Io.Writer, Efl.Io.Closer
{
methods {
}