License Header change: Removed the LICENSE_END before beta
[scilab.git] / scilab / modules / atoms / macros / atoms_internals / atomsDESCRIPTIONcat.sci
1 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
2 // Copyright (C) 2009 - DIGITEO - Pierre MARECHAL <pierre.marechal@scilab.org>
3 //
4 // Copyright (C) 2012 - 2016 - Scilab Enterprises
5 //
6 // This file is hereby licensed under the terms of the GNU GPL v2.0,
7 // pursuant to article 5.3.4 of the CeCILL v.2.1.
8 // This file was originally licensed under the terms of the CeCILL v2.1,
9 // and continues to be available under such terms.
10 // For more information, see the COPYING file which you should have received
11 // along with this program.
12
13 // Internal function
14
15 // Merge two descriptions structures ( created by atomsDESCRIPTIONread() )
16 //
17 // DESCRIPTION
18 // |
19 // |-- packages                              [1x1 struct]
20 // |   |-- toolbox_1                         [1x1 struct]
21 // |   |   |-- 2.0                           [1x1 struct]
22 // |   |   |   |-- Toolbox: "toolbox_2"
23 // |   |   |   |-- Title: "Toolbox Test 2"
24 // |   |   |   |-- Version: "2.0"
25 // |   |   |   `-- ..
26 // |   |   `-- 1.0                           [1x1 struct]
27 // |   |   |   |-- Toolbox: "toolbox_2"
28 // |   |   |   |-- Title: "Toolbox Test 2"
29 // |   |   |   |-- Version: "1.0"
30 // |   |   |   `-- ..
31 // |   |-- module_lycee
32 // |   `-- ..
33 // |
34 // |-- categories                            [1x1 struct]
35 // |   |-- Optimization                      [1x1 struct]
36 // |   |   |-- Linear
37 // |   |   `-- General
38 // |   `-- ..
39 // |
40 // |-- categories_flat                       [1x1 struct]
41 //     |-- Optimization - Linear
42 //     |   `-- [ "Optimization" ; "Linear" ]
43 //     |-- Optimization - General
44 //     `-- Optimization - General
45 //
46
47 function tree_out = atomsDESCRIPTIONcat( tree_in_1 , tree_in_2 )
48
49     rhs = argn(2);
50
51     // Check number of input arguments
52     // =========================================================================
53
54     if rhs <> 2 then
55         error(msprintf(gettext("%s: Wrong number of input argument: %d expected.\n"),"atomsDESCRIPTIONcat",1));
56     end
57
58     // Check input arguments type
59     // =========================================================================
60
61     if type(tree_in_1) <> 17 then
62         error(msprintf(gettext("%s: Wrong type for input argument #%d: matrix oriented typed list expected.\n"),"atomsDESCRIPTIONcat",1));
63     end
64
65     if type(tree_in_2) <> 17 then
66         error(msprintf(gettext("%s: Wrong type for input argument #%d: matrix oriented typed list expected.\n"),"atomsDESCRIPTIONcat",2));
67     end
68
69     // Check the presence of needed fields in the first input argument
70     // =========================================================================
71
72     needed_fields = ["packages";"categories";"categories_flat"];
73
74     for i=1:size(needed_fields,"*")
75         if ~ isfield(tree_in_2,needed_fields(i)) then
76             error(msprintf(gettext("%s: Wrong value for input argument #%d: It should have a field named ''%s''.\n"),"atomsDESCRIPTIONcat",2,needed_fields(i)));
77         end
78     end
79
80     // tree_in_1 is the master tree :
81     // =========================================================================
82
83     tree_out  = tree_in_1;
84
85     // Fill needed fields with empty structs if they don't exist
86
87     for i=1:size(needed_fields,"*")
88         if ~ isfield(tree_out,needed_fields(i)) then
89             tree_out(needed_fields(i)) = struct();
90         end
91     end
92
93     // Now do merges
94     // =========================================================================
95
96     // packages
97     // -------------------------------------------------------------------------
98
99     packages_out           = tree_out("packages");
100     packages_in_2          = tree_in_2("packages");
101     packages_out           = atomsPackagesCat(packages_out,packages_in_2);
102     tree_out("packages")   = packages_out;
103
104
105     // categories
106     // -------------------------------------------------------------------------
107
108     categories_out         = tree_out("categories");
109     categories_in_2        = tree_in_2("categories");
110     categories_out         = atomsCategoriesCat(categories_out,categories_in_2);
111     tree_out("categories") = categories_out;
112
113
114     // categories_flat
115     // -------------------------------------------------------------------------
116
117     categories_flat_out  = tree_out("categories_flat");
118     categories_flat_in_2 = tree_in_2("categories_flat");
119     category_names       = getfield(1,categories_flat_in_2);
120     category_names(1:2)  = [];
121
122     for i=1:size(category_names,"*")
123         if ~ isfield(categories_flat_out,category_names(i)) then
124             categories_flat_out(category_names(i)) = categories_flat_in_2(category_names(i));
125         end
126     end
127
128     tree_out("categories_flat") = categories_flat_out;
129
130 endfunction
131
132 // =============================================================================
133 // atomsCategoriesCat
134 // =============================================================================
135
136 function tree_out = atomsCategoriesCat( tree_in_1 , tree_in_2 )
137
138     rhs = argn(2);
139
140     // Check number of input arguments
141     // =========================================================================
142
143     if rhs <> 2 then
144         error(msprintf(gettext("%s: Wrong number of input argument: %d expected.\n"),"atomsCategoriesCat",1));
145     end
146
147     // Check input arguments type
148     // =========================================================================
149
150     if type(tree_in_1) <> 17 then
151         error(msprintf(gettext("%s: Wrong type for input argument #%d: matrix oriented typed list expected.\n"),"atomsCategoriesCat",1));
152     end
153
154     if type(tree_in_2) <> 17 then
155         error(msprintf(gettext("%s: Wrong type for input argument #%d: matrix oriented typed list expected.\n"),"atomsCategoriesCat",2));
156     end
157
158     // tree_in_1 is the master tree :
159     // =========================================================================
160
161     tree_out  = tree_in_1;
162
163     // Loop on tree_in_2 fields
164     // =========================================================================
165
166     category_names      = getfield(1,tree_in_2);
167     category_names(1:2) = [];
168
169     for i=1:size(category_names,"*")
170
171         if isfield(tree_out,category_names(i)) then
172
173             // The category already exists in tree_in_1
174
175             subcategories_2   = tree_in_2(category_names(i));
176             subcategories_out = tree_out(category_names(i));
177
178             for j=1:size(subcategories_2,"*")
179                 if find( subcategories_2(j) == subcategories_out ) == [] then
180                     subcategories_out = [ subcategories_out ; subcategories_2(j) ];
181                 end
182             end
183
184             tree_out(category_names(i)) = subcategories_out;
185         else
186             // The category doesn't exist in tree_in_1
187             tree_out(category_names(i)) = tree_in_2(category_names(i));
188         end
189
190     end
191
192 endfunction
193
194 // =============================================================================
195 // atomsPackagesCat
196 // =============================================================================
197
198 function tree_out = atomsPackagesCat( tree_in_1 , tree_in_2 )
199
200     rhs = argn(2);
201
202     // Check number of input arguments
203     // =========================================================================
204
205     if rhs <> 2 then
206         error(msprintf(gettext("%s: Wrong number of input argument: %d expected.\n"),"atomsPackagesCat",1));
207     end
208
209     // Check input arguments type
210     // =========================================================================
211
212     if type(tree_in_1) <> 17 then
213         error(msprintf(gettext("%s: Wrong type for input argument #%d: matrix oriented typed list expected.\n"),"atomsPackagesCat",1));
214     end
215
216     if type(tree_in_2) <> 17 then
217         error(msprintf(gettext("%s: Wrong type for input argument #%d: matrix oriented typed list expected.\n"),"atomsPackagesCat",2));
218     end
219
220     // tree_in_1 is the master tree :
221     // =========================================================================
222
223     tree_out  = tree_in_1;
224
225     // Loop on tree_in_2 fields
226     // =========================================================================
227
228     package_names      = getfield(1,tree_in_2);
229     package_names(1:2) = [];
230
231     for i=1:size(package_names,"*")
232
233         if isfield(tree_out,package_names(i)) then
234
235             // The package already exists in tree_in_1
236             package_versions_struct = tree_in_2(package_names(i));
237
238             if type(package_versions_struct) <> 17 then
239                 error(msprintf(gettext("%s: Wrong value for input argument #%d: The matrix oriented typed list is not well formatted.\n"),"atomsPackagesCat",1));
240             end
241
242             package_versions      = getfield(1,package_versions_struct);
243             package_versions(1:2) = [];
244             package_versions_out  = tree_out(package_names(i));
245
246             for j=1:size(package_versions,"*")
247                 package_versions_out(package_versions(j)) = package_versions_struct(package_versions(j));
248             end
249
250             tree_out(package_names(i)) = package_versions_out;
251
252         else
253             // The package doesn't exist in tree_in_1
254             tree_out(package_names(i)) = tree_in_2(package_names(i));
255         end
256
257     end
258
259 endfunction