libbeagle/beagle/beagle-scheduler-information.c

   1 /*
   2  * beagle-scheduler-information.c
   3  *
   4  * Copyright (C) 2006 Debajyoti Bera <dbera.web@gmail.com>
   5  *
   6  */
   7
   8 /*
   9  * Permission is hereby granted, free of charge, to any person obtaining a
  10  * copy of this software and associated documentation files (the "Software"),
  11  * to deal in the Software without restriction, including without limitation
  12  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  13  * and/or sell copies of the Software, and to permit persons to whom the
  14  * Software is furnished to do so, subject to the following conditions:
  15  *
  16  * The above copyright notice and this permission notice shall be included in
  17  * all copies or substantial portions of the Software.
  18  *
  19  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  20  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  21  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  22  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  23  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  24  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  25  * DEALINGS IN THE SOFTWARE.
  26  */
  27
  28 #include "beagle-scheduler-information.h"
  29 #include "beagle-private.h"
  30
  31 BeagleSchedulerInformation *
  32 _beagle_scheduler_information_new ()
  33 {
  34         BeagleSchedulerInformation *sched_info;
  35
  36         sched_info = g_new0 (BeagleSchedulerInformation, 1);
  37
  38         sched_info->ref_count = 1;
  39
  40         sched_info->total_task_count = -1;
  41         sched_info->status_string = NULL;
  42         sched_info->pending_task = NULL;
  43         sched_info->future_task = NULL;
  44         sched_info->blocked_task = NULL;
  45
  46         return sched_info;
  47 }
  48
  49 /**
  50  * beagle_scheduler_information_ref:
  51  * @sched_info: a #BeagleSchedulerInformation
  52  *
  53  * Increases the reference count of the #BeagleSchedulerInformation.
  54  *
  55  * Return value: the #BeagleSchedulerInformation
  56  **/
  57 BeagleSchedulerInformation *
  58 beagle_scheduler_information_ref (BeagleSchedulerInformation *sched_info)
  59 {
  60         g_return_if_fail (sched_info != NULL);
  61
  62         sched_info->ref_count ++;
  63
  64         return sched_info;
  65 }
  66
  67 /**
  68  * beagle_scheduler_information_unref:
  69  * @sched_info: a #BeagleSchedulerInformation
  70  *
  71  * Decreases the reference count of the #BeagleSchedulerInformation. When the reference count drops to 0, it is freed.
  72  **/
  73 void
  74 beagle_scheduler_information_unref (BeagleSchedulerInformation *sched_info)
  75 {
  76         g_return_if_fail (sched_info != NULL);
  77         g_return_if_fail (sched_info->ref_count > 0);
  78
  79         sched_info->ref_count --;
  80
  81         if (sched_info->ref_count == 0) {
  82                 g_free (sched_info->status_string);
  83
  84                 if (sched_info->pending_task) {
  85                         g_slist_foreach (sched_info->pending_task, (GFunc) g_free, NULL);
  86                         g_slist_free (sched_info->pending_task);
  87                 }
  88
  89                 if (sched_info->future_task) {
  90                         g_slist_foreach (sched_info->future_task, (GFunc) g_free, NULL);
  91                         g_slist_free (sched_info->future_task);
  92                 }
  93
  94                 if (sched_info->blocked_task) {
  95                         g_slist_foreach (sched_info->blocked_task, (GFunc) g_free, NULL);
  96                         g_slist_free (sched_info->blocked_task);
  97                 }
  98
  99                 g_free (sched_info);
 100         }
 101 }
 102
 103 /**
 104  * beagle_scheduler_information_get_total_task_count:
 105  * @sched_info: a #BeagleSchedulerInformation
 106  *
 107  * Fetches the total number of tasks from the given #BeagleSchedulerInformation.
 108  *
 109  * Return value: the number of tasks from the #BeagleSchedulerInformation.
 110  **/
 111 int
 112 beagle_scheduler_information_get_total_task_count (BeagleSchedulerInformation *sched_info)
 113 {
 114         g_return_val_if_fail (sched_info != NULL, -1);
 115
 116         return sched_info->total_task_count;
 117 }
 118
 119 /**
 120  * beagle_scheduler_information_get_status_string:
 121  * @sched_info: a #BeagleSchedulerInformation
 122  *
 123  * Fetches the status string from the given #BeagleSchedulerInformation.
 124  *
 125  * Return value: the status string from the #BeagleSchedulerInformation.
 126  **/
 127 G_CONST_RETURN char *
 128 beagle_scheduler_information_get_status_string (BeagleSchedulerInformation *sched_info)
 129 {
 130         g_return_val_if_fail (sched_info != NULL, NULL);
 131
 132         return sched_info->status_string;
 133 }
 134
 135 /**
 136  * beagle_scheduler_information_get_pending_tasks:
 137  * @sched_info: a #BeagleSchedulerInformation
 138  *
 139  * Fetches the list of pending tasks as strings from the given #BeagleSchedulerInformation.
 140  *
 141  * Return value: the list of pending tasks from the #BeagleSchedulerInformation.
 142  **/
 143 GSList *
 144 beagle_scheduler_information_get_pending_tasks (BeagleSchedulerInformation *sched_info)
 145 {
 146         g_return_val_if_fail (sched_info != NULL, NULL);
 147
 148         return sched_info->pending_task;
 149 }
 150
 151 /**
 152  * beagle_scheduler_information_get_future_tasks:
 153  * @sched_info: a #BeagleSchedulerInformation
 154  *
 155  * Fetches the list of future tasks as strings from the given #BeagleSchedulerInformation.
 156  *
 157  * Return value: the list of future tasks from the #BeagleSchedulerInformation.
 158  **/
 159 GSList *
 160 beagle_scheduler_information_get_future_tasks (BeagleSchedulerInformation *sched_info)
 161 {
 162         g_return_val_if_fail (sched_info != NULL, NULL);
 163
 164         return sched_info->future_task;
 165 }
 166
 167 /**
 168  * beagle_scheduler_information_get_blocked_tasks:
 169  * @sched_info: a #BeagleSchedulerInformation
 170  *
 171  * Fetches the list of blocked tasks as strings from the given #BeagleSchedulerInformation.
 172  *
 173  * Return value: the list of blocked tasks from the #BeagleSchedulerInformation.
 174  **/
 175 GSList *
 176 beagle_scheduler_information_get_blocked_tasks (BeagleSchedulerInformation *sched_info)
 177 {
 178         g_return_val_if_fail (sched_info != NULL, NULL);
 179
 180         return sched_info->blocked_task;
 181 }
 182
 183 /**
 184  * beagle_scheduler_information_to_human_readable_string:
 185  * @sched_info: a #BeagleSchedulerInformation
 186  *
 187  * Fetches a string version of the given #BeagleSchedulerInformation.
 188  *
 189  * Return value: a string version from the #BeagleSchedulerInformation.
 190  **/
 191 G_CONST_RETURN char *
 192 beagle_scheduler_information_to_human_readable_string (BeagleSchedulerInformation *sched_info)
 193 {
 194         int pos;
 195         char *task;
 196         GSList *iter;
 197         GString *tmp = g_string_new (NULL);
 198
 199         g_string_append_printf (tmp, "Scheduler:\nCount: %d\n", sched_info->total_task_count);
 200
 201         if (sched_info->status_string)
 202                 g_string_append_printf (tmp, "Status: %s\n", sched_info->status_string);
 203
 204         pos = 1;
 205
 206         g_string_append (tmp, "\nPending Tasks:\n");
 207         if (g_slist_length (sched_info->pending_task) > 0) {
 208                 iter = sched_info->pending_task;
 209                 while (iter != NULL) {
 210                         task = iter->data;
 211                         g_string_append_printf (tmp, "%d %s\n", pos, task);
 212                         iter = iter->next;
 213                         pos ++;
 214                 }
 215         } else
 216                 g_string_append (tmp, "Scheduler queue is empty.\n");
 217
 218         if (g_slist_length (sched_info->future_task) > 0) {
 219                 g_string_append (tmp, "\nFuture Tasks:\n");
 220                 iter = sched_info->future_task;
 221                 while (iter != NULL) {
 222                         task = iter->data;
 223                         g_string_append_printf (tmp, "%s\n", task);
 224                         iter = iter->next;
 225                 }
 226         }
 227
 228         if (g_slist_length (sched_info->blocked_task) > 0) {
 229                 g_string_append (tmp, "\nBlocked Tasks:\n");
 230                 iter = sched_info->blocked_task;
 231                 while (iter != NULL) {
 232                         task = iter->data;
 233                         g_string_append_printf (tmp, "%s\n", task);
 234                         iter = iter->next;
 235                 }
 236         }
 237
 238         return g_string_free (tmp, FALSE);
 239 }
 240
 241 void _task_to_xml (GSList *task_list, const char *list_name, const char *list_item_name, GString *data)
 242 {
 243         char *task_data;
 244         GSList *iter;
 245
 246         g_string_append_printf (data, "<%s>", list_name);
 247
 248         if (task_list != NULL) {
 249                 iter = task_list;
 250                 while (iter != NULL) {
 251                         task_data = iter->data;
 252                         g_string_append_printf (data, "<%s>%s</%s>", list_item_name, task_data, list_item_name);
 253                         iter = iter->next;
 254                 }
 255         }
 256
 257         g_string_append_printf (data, "</%s>", list_name);
 258 }
 259
 260 void
 261 _beagle_scheduler_information_to_xml (BeagleSchedulerInformation *sched_info, GString *data)
 262 {
 263         char *tmp, *task;
 264         GSList *iter;
 265
 266         g_string_append_printf (data, "<SchedulerInformation");
 267
 268         g_string_append_printf (data, " TotalTaskCount=\"%d\"", sched_info->total_task_count);
 269
 270         if (sched_info->status_string)
 271                 g_string_append_printf (data, " StatusString=\"%s\"", sched_info->status_string);
 272
 273         g_string_append (data, ">");
 274
 275         _task_to_xml (sched_info->pending_task, "PendingTasks", "PendingTask", data);
 276         _task_to_xml (sched_info->future_task, "FutureTasks", "FutureTask", data);
 277         _task_to_xml (sched_info->blocked_task, "BlockedTasks", "BlockedTask", data);
 278
 279         g_string_append (data, "</SchedulerInformation>");
 280 }