------------------------------------------------------------------------------
------------------------------------------------------------------------------
-- Cheddar is a GNU GPL real-time scheduling analysis tool.
-- This program provides services to automatically check schedulability and
-- other performance criteria of real-time architecture models.
--
-- Copyright (C) 2002-2023, Frank Singhoff, Alain Plantec, Jerome Legrand,
--                          Hai Nam Tran, Stephane Rubini
--
-- The Cheddar project was started in 2002 by
-- Frank Singhoff, Lab-STICC UMR 6285, Université de Bretagne Occidentale
--
-- Cheddar has been published in the "Agence de Protection des Programmes/France" in 2008.
-- Since 2008, Ellidiss technologies also contributes to the development of
-- Cheddar and provides industrial support.
--
-- The full list of contributors and sponsors can be found in README.md
--
-- This program is free software; you can redistribute it and/or modify
-- it under the terms of the GNU General Public License as published by
-- the Free Software Foundation; either version 2 of the License, or
-- (at your option) any later version.
--
-- This program is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-- GNU General Public License for more details.
--
-- You should have received a copy of the GNU General Public License
-- along with this program; if not, write to the Free Software
-- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
--
--
-- Contact : cheddar@listes.univ-brest.fr
--
------------------------------------------------------------------------------
-- Last update :
--    $Rev: 3657 $
--    $Date: 2020-12-13 13:25:49 +0100 (dim., 13 déc. 2020) $
--    $Author: singhoff $
------------------------------------------------------------------------------
------------------------------------------------------------------------------

-- this package should be automatically generated.
--
--
-- we provide functions to converted the attributes of entity, in order
-- to have a lisible presentation on Man Machine Interface: this include
-- the label written with underscore, with lowercas and/or uppercase characters

-- we consider by example the entity Scheduling_Parameters of the meta model.
-- the attributes scheduler_type and preemptive_type have a list of parameters
-- with undescores

-- In accordance with meta model, scheduler_type may be Compiled_User_Defined_Protocol,
-- Automata_User_Defined_Protocol, Pipeline_User_Defined_Protocol, ....

-- In Man Machine Interface, scheduler_type should be Compiled User Defined Protocol,
-- Automata User Defined Protocol, Pipeline User Defined Protocol, ....

-- This package provide two functions, to_label and to_type to manage this kind of attributes

with Gtkada.Builder; use Gtkada.Builder;
with Glib;           use Glib;
with Glib.Object;    use Glib.Object;
with Glib.Values;    use Glib.Values;

with scheduler_interface;      use scheduler_interface;
with processor_interface;      use processor_interface;
with queueing_systems;         use queueing_systems;
with buffers;                  use buffers;
with dependencies;             use dependencies;
with messages;                 use messages;
with networks;                 use networks;
with resources;                use resources;
with tasks;                    use tasks;
with parameters;               use parameters;
with caches;                   use caches;
with task_groups;              use task_groups;
with call_framework_interface; use call_framework_interface;

with Gtk.Tree_Model; use Gtk.Tree_Model;
with graphical_editor.generic_callbacks;
with graphical_editor.generic_package_widget;
use graphical_editor.generic_package_widget;

package graphical_editor.convert_text is

   type all_enumeration_type is
     (schedulers, preemptives, processors_enum, queueings, roles, trigerres,
      dependencies_enum, orientations, message_protocol, messages_enum,
      migrations, multiprocessors_type_enum, networks_architecture_enum,
      networks_delay_enum, switching_type_enum, routing_enum, protocols,
      assignments, predictables, policies_enum, tasks_enum, parameters_enum,
      cache_replacement_policy_enum, cache_coherence_protocol_enum,
      crpd_computation_approach_enum,
      memory_interference_computation_approach_enum, task_group_types_enum,
      resources_synchronization_enum);

   type t_all_enumeration_type
     (enum_type : all_enumeration_type := preemptives) is record
      case enum_type is

         when crpd_computation_approach_enum =>
            crpd_computation_approach_value : crpd_computation_approach_type;

         when memory_interference_computation_approach_enum =>
            memory_interference_computation_approach_value : memory_interference_computation_approach_type;

         when cache_coherence_protocol_enum =>
            cache_coherence_protocol_value : cache_coherence_protocol_type;

         when cache_replacement_policy_enum =>
            cache_replacement_policy_value : cache_replacement_policy_type;

         when preemptives =>
            preemptives_value : preemptives_type;

         when schedulers =>
            schedulers_value : schedulers_type;

         when processors_enum =>
            processors_value : processors_type;

         when queueings =>
            queueings_value : queueing_systems_type;

         when roles =>
            roles_value : buffer_role_type;

         when trigerres =>
            trigerres_value : time_triggered_communication_timing_property_type;

         when dependencies_enum =>
            dependencies_value : dependency_type;

         when orientations =>
            orientations_value : orientation_dependency_type;

         when message_protocol =>
            message_protocol_value : asynchronous_communication_protocol_property_type;

         when messages_enum =>
            messages_value : messages_type;

         when migrations =>
            migrations_value : migrations_type;

         when multiprocessors_type_enum =>
            multiprocessors_type_value : multiprocessors_type;

         when networks_architecture_enum =>
            networks_architecture_value : networks_architecture_type;

         when networks_delay_enum =>
            networks_delay_value : networks_delay_type;

         when switching_type_enum =>
            switching_type_value : switching_type;

         when routing_enum =>
            routing_value : routing_type;

         when protocols =>
            protocols_value : resources_type;

         when assignments =>
            assignments_value : priority_assignment_type;

         when predictables =>
            predictables_value : Boolean;

         when policies_enum =>
            policies_value : policies;

         when tasks_enum =>
            tasks_value : tasks_type;

         when parameters_enum =>
            params_value : parameters.parameter_type;

         when task_group_types_enum =>
            task_group_types_value : task_groups_type;

         when resources_synchronization_enum =>
            resource_synchronization_value : resources_synchronization_type;

      end case;
   end record;

   type all_enumeration_type_ptr is access t_all_enumeration_type;

   function to_label
     (my_type : all_enumeration_type_ptr) return Unbounded_String;

   function to_type (my_gvalue : gvalue) return all_enumeration_type_ptr;

   function to_type
     (my_label : Unbounded_String) return all_enumeration_type_ptr;

end graphical_editor.convert_text;