source: cfg_itronx+oil_gcc/toppers/oil/oil_object.cpp@ 165

Last change on this file since 165 was 54, checked in by ertl-ishikawa, 12 years ago

cfg+oil対応コンフィギュレータを追加
File size: 24.1 KB
Line 
1/*
2 * TOPPERS Software
3 * Toyohashi Open Platform for Embedded Real-Time Systems
4 *
5 * Copyright (C) 2010 by Meika Sugimoto
6 *
7 * 上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
8 * ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
9 * 変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
10 * (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
11 * 権表示，この利用条件および下記の無保証規定が，そのままの形でソー
12 * スコード中に含まれていること．
13 * (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
14 * 用できる形で再配布する場合には，再配布に伴うドキュメント（利用
15 * 者マニュアルなど）に，上記の著作権表示，この利用条件および下記
16 * の無保証規定を掲載すること．
17 * (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
18 * 用できない形で再配布する場合には，次のいずれかの条件を満たすこ
19 * と．
20 * (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
21 * 作権表示，この利用条件および下記の無保証規定を掲載すること．
22 * (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
23 * 報告すること．
24 * (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
25 * 害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
26 * また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
27 * 由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
28 * 免責すること．
29 *
30 * 本ソフトウェアは，無保証で提供されているものである．上記著作権者お
31 * よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
32 * に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
33 * アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
34 * の責任を負わない．
35 *
36 */
37
38#include <boost/regex.hpp>
39#include <boost/lexical_cast.hpp>
40#include <boost/cast.hpp>
41#include <algorithm>
42#include <functional>
43
44#include "toppers/oil/oil_object.hpp"
45#include "toppers/diagnostics.hpp"
46
47namespace toppers
48{
49 namespace oil
50 {
51 // デバッグ用関数
52 void dump(boost::smatch *r)
53 {
54 unsigned int i;
55
56 for(i = 0 ; i < r->size() ; i++)
57 {
58 cout << "Match[" << i << "] : " << r->str(i) << endl;
59 }
60 }
61
62 namespace oil_implementation
63 {
64 int oil_object_impl::add_parameter(string param_name , string parameter_description)
65 {
66 if((parameter_description.find("UINT32") == 0)
67 || (parameter_description.find("UINT64") == 0))
68 {
69 this->params.push_back(
70 (object_parameter_impl *)(new parameter_uint_impl(param_name , parameter_description)));
71 }
72 else if((parameter_description.find("INT32") == 0)
73 || (parameter_description.find("INT64") == 0))
74 {
75 this->params.push_back(
76 (object_parameter_impl *)(new parameter_int_impl(param_name , parameter_description)));
77 }
78 else if(parameter_description.find("ENUM") == 0)
79 {
80 this->params.push_back(
81 (object_parameter_impl *)(new parameter_enum_impl(param_name , parameter_description)));
82 }
83 else if(parameter_description.find("BOOLEAN") == 0)
84 {
85 boost::regex bool_with_option("\\[\\s*TRUE");
86 string::const_iterator start = parameter_description.begin();
87 string::const_iterator end = parameter_description.end();
88
89 // [ TRUE , FALSE ]がある場合はENUMと同じ扱い、ない場合はSTRINGと同じ扱いとする
90 if(regex_search(start , end , bool_with_option))
91 {
92 this->params.push_back(
93 (object_parameter_impl *)(new parameter_enum_impl(param_name , parameter_description)));
94 }
95 else
96 {
97 this->params.push_back(
98 (object_parameter_impl *)(new parameter_boolean_impl(param_name , parameter_description)));
99 }
100 }
101 else if(parameter_description.find("STRING") == 0)
102 {
103 this->params.push_back(
104 (object_parameter_impl *)(new parameter_string_impl(param_name , parameter_description)));
105 }
106 else if(parameter_description.find("FLOAT") == 0)
107 {
108 this->params.push_back(
109 (object_parameter_impl *)(new parameter_float_impl(param_name , parameter_description)));
110 }
111 else if(parameter_description.find("_TYPE") != string::npos)
112 {
113 this->params.push_back(
114 (object_parameter_impl *)(new parameter_object_ref_impl(param_name , parameter_description)));
115 }
116 else
117 {
118 // ありえない
119 }
120
121 return 0;
122 }
123
124 oil_object_impl::~oil_object_impl()
125 {
126 std::vector<object_parameter_impl*>::iterator p;
127
128 for(p = params.begin() ; p != params.end() ; p++)
129 {
130 delete (*p);
131 }
132 }
133
134 bool oil_object_impl::validate_object_parameter
135 (oil_definition::object_parameter_def *obj_param , bool *multiple ,
136 std::vector<object_ref> *references)
137 {
138 std::vector<object_parameter_impl*>::iterator match;
139 bool result = false;
140
141 // 同じ名前を持つパラメータがあるか検索
142 // ※find_ifだとダウンキャストに失敗した
143 for(match = params.begin() ; match != params.end() ; match++)
144 {
145 if((*match)->validate_parameter_name(obj_param->get_parameter_name())
146 == true)
147 {
148 break;
149 }
150 }
151
152 // パラメータの属性チェック
153 if(match != params.end())
154 {
155 parameter_object_ref_impl *ref_param;
156 parameter_enum_impl *enum_param;
157
158 ref_param = dynamic_cast<parameter_object_ref_impl*>(*match);
159 if(ref_param != NULL)
160 {
161 if(ref_param->validate_object_parameter(obj_param , references) == true)
162 {
163 *multiple = (*match)->get_multiple();
164 result = true;
165 }
166 }
167 else
168 {
169 // enumの場合、子要素で参照が出てくる可能性がある
170 enum_param = dynamic_cast<parameter_enum_impl*>(*match);
171 if(enum_param != NULL)
172 {
173 if(enum_param->validate_object_parameter(obj_param , references) == true)
174 {
175 *multiple = (*match)->get_multiple();
176 result = true;
177 }
178 else
179 {
180 // エラー出力はvalidate_object_parameterで行っているため不要．
181 //toppers::error("Object %1%'s parameter %2% can't set %3%." ,
182 // obj_param->get_parent_name() , obj_param->get_parameter_name() , obj_param->get_value());
183 }
184 }
185 else
186 {
187 if((*match)->validate_object_parameter(obj_param) == true)
188 {
189 *multiple = (*match)->get_multiple();
190 result = true;
191 }
192 else
193 {
194 // エラー出力はvalidate_object_parameterで行っているため不要．
195 //toppers::error("Object %1%'s parameter %2% can't set %3%." ,
196 // obj_param->get_parent_name() , obj_param->get_parameter_name() , obj_param->get_value());
197 }
198 }
199 }
200 }
201 else
202 {
203 // エラー処理
204 toppers::error("Object %1% can't define parameter %2%." ,
205 obj_param->get_parent_name() , obj_param->get_parameter_name());
206 }
207
208 return result;
209 }
210
211 // 基本パラメータのチェック
212 bool object_parameter_impl::validate_object_parameter
213 (oil_definition::object_parameter_def *obj , bool *auto_param)
214 {
215 // 複数定義はオブジェクト解析側でしか行えない
216 // デフォルト定義かどうかもオブジェクトでしか行えない
217 set_parameter_type(obj);
218
219 // AUTO属性のチェック
220 if(obj->get_value() == "AUTO")
221 {
222 if(assign_auto == false)
223 {
224 toppers::error("Object %1% : %2% can't use \"AUTO\"" ,
225 obj->get_parent_name().c_str() , obj->get_parameter_name().c_str());
226 return false;
227 }
228 else
229 {
230 *auto_param = true;
231 }
232 }
233 else
234 {
235 *auto_param = false;
236 }
237
238 return true;
239 }
240
241 template<typename T>
242 bool validate_number_paremeter
243 (VALUE_LIMIT_TYPE type ,T value , T min , T max , vector<T> *value_list)
244 {
245 bool result = true;
246
247 if(type == LIMIT_RANGE)
248 {
249 if((value < min) || (value > max))
250 {
251 result = false;
252 }
253 }
254 else if(type == LIMIT_LIST)
255 {
256 // modified by takuya
257 //std::vector<T>::iterator p;
258 typename std::vector<T>::iterator p;
259
260 // 値のリストに存在するかを検索
261 p = find(value_list->begin() , value_list->end() , value);
262 if(p >= value_list->end())
263 {
264 result = false;
265 }
266 }
267 else
268 {
269 // チェックは必要ない
270 }
271
272 return result;
273 }
274
275 template<typename T>
276 void val2string(std::vector<T> *list , std::string *str)
277 {
278 // modified by takuya 110823
279 //std::vector<T>::iterator p;
280 typename std::vector<T>::iterator p;
281
282 for(p = list->begin() ; p != list->end() ; p++)
283 {
284 try
285 {
286 *str += boost::lexical_cast<string>(*p) + " , ";
287 }
288 catch( ... )
289 {
290 toppers::error("cast error");
291 }
292 }
293 }
294
295 bool parameter_int_impl::validate_object_parameter
296 (oil_definition::object_parameter_def *obj)
297 {
298 bool result = false , assign_auto;
299 int64_t value;
300
301 // 基本属性のチェック
302 if(object_parameter_impl::validate_object_parameter(obj , &assign_auto)
303 == false)
304 {
305 return false;
306 }
307
308 // AUTOパラメータならすぐに抜ける
309 if(assign_auto == true)
310 {
311 return true;
312 }
313
314 // 値に変換
315 if(obj->get_value().find("0x") != string::npos)
316 {
317 // modified by takuya 110823
318 //(void)sscanf_s(obj->get_value().c_str() , "0x%I64x" , &value);
319 (void)sscanf(obj->get_value().c_str() , "0x%llx" , &value);
320 }
321 else if(obj->get_value().find("0X") != string::npos)
322 {
323 // modified by takuya 110823
324 //(void)sscanf_s(obj->get_value().c_str() , "0X%I64x" , &value);
325 (void)sscanf(obj->get_value().c_str() , "0X%llx" , &value);
326 }
327 else
328 {
329 try
330 {
331 value = boost::lexical_cast<int64_t>(obj->get_value());
332 }
333 catch(std::exception& exception)
334 {
335 toppers::error("%1%'s %2% is not INT16/INT32." ,
336 obj->get_parent_name() , obj->get_parameter_name());
337
338 return false;
339 }
340 }
341
342 if(validate_number_paremeter
343 (limit_type , value , min , max , &value_list) == false)
344 {
345 if(limit_type == LIMIT_RANGE)
346 {
347 toppers::error("Object %1%'s %2% is \"%3%\" not in range [%4% - %5%]" ,
348 obj->get_parent_name().c_str() , obj->get_parameter_name().c_str() ,
349 obj->get_value() , min , max);
350 }
351 else // if(limit_type == LIMIT_LIST)
352 {
353 std::string str;
354 val2string(&value_list , &str);
355
356 toppers::error("Object %1%'s %2% is \"%3%\" not in range [%4% - %5%]" ,
357 obj->get_parent_name().c_str() , obj->get_parameter_name().c_str() ,
358 obj->get_value() , min , max);
359 }
360 }
361 else
362 {
363 result = true;
364 }
365
366 return result;
367 }
368
369 void parameter_int_impl::set_parameter_type(oil_definition::object_parameter_def *obj)
370 {
371 obj->set_type(TYPE_INT);
372 }
373
374 bool parameter_uint_impl::validate_object_parameter
375 (oil_definition::object_parameter_def *obj)
376 {
377 bool result = false , assign_auto;
378 uint64_t value;
379
380 // 基本属性のチェック
381 if(object_parameter_impl::validate_object_parameter(obj , &assign_auto)
382 == false)
383 {
384 return false;
385 }
386
387 // AUTOパラメータならすぐに抜ける
388 if(assign_auto == true)
389 {
390 return true;
391 }
392
393 // 値に変換
394 if(obj->get_value().find("0x") != string::npos)
395 {
396 // modified by takuya 110823
397 //(void)sscanf_s(obj->get_value().c_str() , "0x%I64x" , &value);
398 (void)sscanf(obj->get_value().c_str() , "0x%llx" , &value);
399 }
400 else if(obj->get_value().find("0X") != string::npos)
401 {
402 // modified by takuya 110823
403 //(void)sscanf_s(obj->get_value().c_str() , "0X%I64x" , &value);
404 (void)sscanf(obj->get_value().c_str() , "0X%llx" , &value);
405 }
406 else
407 {
408 try
409 {
410 value = boost::lexical_cast<uint64_t>(obj->get_value());
411 }
412 catch(std::exception& exception)
413 {
414 toppers::error("%1% : %2% is not UINT16/UINT32." ,
415 obj->get_parent_name() , obj->get_parameter_name());
416 return false;
417 }
418 }
419
420 if(validate_number_paremeter
421 (limit_type , value , min , max , &value_list) == false)
422 {
423 if(limit_type ==LIMIT_RANGE)
424 {
425 toppers::error("Object %1%'s %2% : %3% is not in range [%4% - %5%]" ,
426 obj->get_parent_name().c_str() , obj->get_parameter_name().c_str() ,
427 obj->get_value() , min , max);
428 }
429 else // if(limit_type == LIMIT_LIST)
430 {
431 std::string str;
432 val2string(&value_list , &str);
433
434 toppers::error("Object %1%'s %2% : %3% is not in range value list [%4%]" ,
435 obj->get_parent_name().c_str() , obj->get_parameter_name().c_str() ,
436 obj->get_value() , str);
437 }
438 }
439 else
440 {
441 result = true;
442 }
443
444 return result;
445 }
446
447 void parameter_uint_impl::set_parameter_type(oil_definition::object_parameter_def *obj)
448 {
449 obj->set_type(TYPE_UINT);
450 }
451
452 bool parameter_float_impl::validate_object_parameter
453 (oil_definition::object_parameter_def *obj)
454 {
455 bool result = false , assign_auto;
456 double value;
457
458 // 基本属性のチェック
459 if(object_parameter_impl::validate_object_parameter(obj , &assign_auto)
460 == false)
461 {
462 return false;
463 }
464
465 // AUTOパラメータならすぐに抜ける
466 if(assign_auto == true)
467 {
468 return true;
469 }
470
471 // 値に変換
472 try
473 {
474 value = boost::lexical_cast<double>(obj->get_value().c_str());
475 }
476 catch(std::exception& exception)
477 {
478 toppers::error("%1% : %2% is not FLOAT." ,
479 obj->get_parent_name() , obj->get_parameter_name());
480
481 return false;
482 }
483
484 if(validate_number_paremeter
485 (limit_type , value , min , max , &value_list) == false)
486 {
487 if(limit_type ==LIMIT_RANGE)
488 {
489 toppers::error("Object %1%'s %2% : %3% is not in range [%4% - %5%]" ,
490 obj->get_parent_name().c_str() , obj->get_parameter_name().c_str() ,
491 obj->get_value().c_str() , min , max);
492 }
493 else // if(limit_type == LIMIT_LIST)
494 {
495 std::string str;
496 val2string(&value_list , &str);
497
498 toppers::error("Object %1%' %2% : %3% is not in range value list [%4%]" ,
499 obj->get_parent_name().c_str() , obj->get_parameter_name().c_str() ,
500 obj->get_value().c_str() , str.c_str());
501 }
502 }
503 else
504 {
505 result = true;
506 }
507
508 return result;
509 }
510
511 void parameter_float_impl::set_parameter_type(oil_definition::object_parameter_def *obj)
512 {
513 obj->set_type(TYPE_FLOAT);
514 }
515
516 bool parameter_enum_impl::validate_object_parameter
517 (oil_definition::object_parameter_def *obj , std::vector<toppers::oil::object_ref> *object_refs)
518 {
519 std::map<std::string , oil_object_impl*>::iterator p;
520 bool result = true , assign_auto;
521
522 // 基本属性のチェック
523 if(object_parameter_impl::validate_object_parameter(obj , &assign_auto)
524 == false)
525 {
526 return false;
527 }
528
529 // AUTOパラメータならすぐに抜ける
530 if(assign_auto == true)
531 {
532 return true;
533 }
534
535 // パラメータがENUMのリストにあるか検索(総当たり）
536 std::vector<oil_definition::object_definition*>::iterator s;
537 std::string str;
538 bool hit = false;
539
540 for(p = sub_params.begin() ; p != sub_params.end(); p++)
541 {
542 // エラー処理用のリスト
543 str += (*p).first + " , ";
544 // パラメータ名が一致していなければ先の処理は行わない
545 if(obj->get_value() == (*p).first)
546 {
547 hit = true;
548 }
549 }
550 // リストになかった場合の処理
551 if(hit == false)
552 {
553 toppers::error("Object %1%'s %2% : %3% is not in range [%4%]" ,
554 obj->get_parent_name().c_str() , obj->get_parameter_name().c_str() ,
555 obj->get_value().c_str() , str);
556
557 return false;
558 }
559
560 // サブパラメータについてもチェック
561 for(s = obj->get_subparams()->begin() ; s != obj->get_subparams()->end() ; s++)
562 {
563 for(p = sub_params.begin() ; p != sub_params.end(); p++)
564 {
565 /* 同名の設定の定義部を見つけたら再帰で検査 */
566 if((*s)->get_parent()->get_value() == (*p).first)
567 {
568 if((*p).second->validate_object_configuration((*s) , object_refs) == true)
569 {
570 result = true;
571 }
572 }
573 }
574 if(result == true)
575 {
576 break;
577 }
578 }
579 // 見つからなければエラー
580 if((obj->get_subparams()->empty() == false)
581 && (s == obj->get_subparams()->end()))
582 {
583 result = false;
584 }
585
586 return result;
587 }
588
589 bool parameter_object_ref_impl::validate_object_parameter
590 (oil_definition::object_parameter_def *obj , std::vector<toppers::oil::object_ref> *object_refs)
591 {
592 // 基本属性のチェック
593 // リファレンス先のチェックもここで行うべきだが、
594 // リファレンス先のオブジェクト種類を取得できないため後で行う
595 if(object_parameter_impl::validate_object_parameter(obj , &assign_auto)
596 == false)
597 {
598 return false;
599 }
600
601 // チェックするべきリファレンスの代入
602 object_ref ref = { reftype_name , obj->get_value() };
603 object_refs->push_back(ref);
604
605 return true;
606 }
607
608 void parameter_string_impl::set_parameter_type
609 (oil_definition::object_parameter_def *obj)
610 {
611 obj->set_type(TYPE_STRING);
612 }
613
614 void parameter_boolean_impl::set_parameter_type
615 (oil_definition::object_parameter_def *obj)
616 {
617 obj->set_type(TYPE_BOOLEAN);
618 }
619
620 void parameter_enum_impl::set_parameter_type(oil_definition::object_parameter_def *obj)
621 {
622 obj->set_type(TYPE_ENUM);
623 }
624
625 void parameter_object_ref_impl::set_parameter_type(oil_definition::object_parameter_def *obj)
626 {
627 obj->set_type(TYPE_REF);
628 }
629
630 bool oil_object_impl::validate_object_configuration
631 (oil_definition::object_definition * obj_def , std::vector<object_ref> *references)
632 {
633 std::vector<oil_definition::object_parameter_def*>::iterator p;
634 std::vector<oil_definition::object_parameter_def*> *obj_params;
635 std::vector<object_parameter_impl*>::iterator q;
636 std::vector<string> defined_parameter;
637 std::vector<object_parameter_impl*> undefined_parameter;
638 std::vector<string>::iterator found , s;
639 bool result = true;
640 bool multiple;
641
642 // オブジェクト名が合っているかチェック
643 if(name != obj_def->get_object_type())
644 {
645 return false;
646 }
647
648 // パラメータの整合性チェック
649 obj_params = obj_def->get_params();
650 for(p = obj_params->begin() ; p != obj_params->end() ; p++)
651 {
652 if(validate_object_parameter(*p , &multiple , references) == false)
653 {
654 result = false;
655 }
656
657 // 複数定義可能かのチェック
658 if(((found = find(defined_parameter.begin() , defined_parameter.end() ,
659 (*p)->get_parameter_name())) != defined_parameter.end())
660 && (multiple == false))
661 {
662 toppers::error("Object %1% : %2% can define once." ,
663 obj_def->get_name().c_str() , (*p)->get_parameter_name().c_str());
664
665 result = false;
666 }
667 else
668 {
669 defined_parameter.push_back((*p)->get_parameter_name());
670 }
671 }
672
673 if(result == true)
674 {
675 //
676 // デフォルトパラメータの補完
677 //
678
679 // オブジェクト定義に記載されていないパラメータの探索
680 for(q = params.begin() ; q != params.end() ; q++)
681 {
682 s = find(defined_parameter.begin() ,
683 defined_parameter.end() , (*q)->get_name());
684
685 if(s == defined_parameter.end())
686 {
687 undefined_parameter.push_back((*q));
688 }
689 }
690
691 // 探索したパラメータに対してのデフォルトパラメータの補完
692 for(q = undefined_parameter.begin() ; q != undefined_parameter.end() ; q++)
693 {
694 string default_value;
695 DEFAULT_TYPE deftype = (*q)->get_default(&default_value);
696
697 if((deftype == HAVE_DEFAULT)
698 || (deftype == AUTO))
699 {
700 obj_def->add_parameter((*q)->get_name() , default_value);
701 }
702 else if(deftype == NO_DEFAULT)
703 {
704 toppers::error("Object %1% : Parmeter %2% is not defined. %2% doesn't have default value." ,
705 obj_def->get_name().c_str() , (*q)->get_name().c_str());
706
707 result = false;
708 }
709 else /* deftype == HAVE_NOT_DEFINE */
710 {
711 }
712
713 }
714 }
715
716 return result;
717 }
718
719 bool parameter_string_impl::validate_object_parameter
720 (oil_definition::object_parameter_def *obj)
721 {
722 // 文字属性は特に制約がないため常にtrue
723 return true;
724 }
725
726 bool parameter_boolean_impl::validate_object_parameter
727 (oil_definition::object_parameter_def *obj)
728 {
729 // TRUEかFALSEでないとならない
730 if((obj->get_value() == "TRUE")
731 || (obj->get_value() == "FALSE"))
732 {
733 return true;
734 }
735
736 toppers::error("Object %1%'s %2% is \"%3%\" , but can not set [TRUE , FALSE , ]." ,
737 obj->get_parent_name() , obj->get_parameter_name() , obj->get_value());
738
739 return false;
740 }
741
742 void oil_object_impl::display_implementation(void)
743 {
744 std::vector<object_parameter_impl*>::iterator p;
745
746 cout << "=========== Object Name : " << name << "===========" << endl << endl;
747 for(p = params.begin() ; p != params.end() ; p++)
748 {
749 (*p)->display_implementation();
750 }
751 cout << endl << "==================================" << endl;
752
753 }
754
755 void object_parameter_impl::set_parameter_type
756 (oil_definition::object_parameter_def *obj)
757 {
758 obj->set_type(TYPE_UNKNOWN);
759 }
760 }
761
762 namespace oil_definition
763 {
764 object_definition* find_object(string name)
765 {
766 return NULL;
767 }
768
769 int object_definition::add_parameter(string param_name , string param_value)
770 {
771 try
772 {
773 object_parameter_def* param_def =
774 new object_parameter_def(param_name , param_value , name);
775 params.push_back(param_def);
776 }
777 catch(...)
778 {
779 // エラー処理
780 }
781
782 return 0;
783 }
784
785 object_definition::~object_definition()
786 {
787 std::vector<object_parameter_def*>::iterator p;
788
789 for(p = params.begin() ; p != params.end() ; p++)
790 {
791 delete (*p);
792 }
793 }
794
795 void object_definition::display_definition(void)
796 {
797 std::vector<object_parameter_def*>::iterator p;
798
799 for(p = params.begin() ; p != params.end() ; p++)
800 {
801 (*p)->display_definition();
802 }
803 cout << endl << endl;
804 }
805
806
807 /*!
808 * \brief オブジェクトID番号の割付け
809 * \param[in] api_map ソースに記述された静的APIを登録したコンテナ
810 */
811 void assign_id( cfg_obj_map obj_def_map , long fixed_id)
812 {
813 using namespace toppers;
814 using namespace toppers::oil::oil_definition;
815
816 // modified by takuya 110823
817 //std::map<std::string, std::vector< object_definition* >>::iterator p;
818 std::map<std::string, std::vector< object_definition* > >::iterator p;
819 std::vector<object_definition*>::iterator q;
820 int serial;
821
822 for(p = obj_def_map.begin() ; p != obj_def_map.end() ; p++)
823 {
824 serial = 0;
825 // オブジェクトごとにID割当て
826 for(q = (*p).second.begin() ; q != (*p).second.end() ; q++)
827 {
828 if(fixed_id == UINT_MAX)
829 {
830 (*q)->set_id(serial++);
831 }
832 else
833 {
834 (*q)->set_id(fixed_id);
835 }
836 }
837 }
838
839 }
840
841 cfg_obj_map merge(std::vector<object_definition*> *obj_defs ,
842 cfg_obj_map& out , string prefix , string suffix , long fixed_id)
843 {
844 std::vector<object_definition*>::iterator p , q;
845 std::vector<object_definition*> *sub_objects;
846 std::vector<object_parameter_def*>::iterator r;
847 std::vector<object_parameter_def*> *subparams;
848
849 for(p = obj_defs->begin() ; p != obj_defs->end() ; p++)
850 {
851 string s(prefix + (*p)->get_object_type() + suffix);
852 out[ s ].push_back(*p);
853 }
854
855 // IDを一度割付ける
856 assign_id(out , fixed_id);
857
858 for(p = obj_defs->begin() ; p != obj_defs->end() ; p++)
859 {
860 long id;
861 subparams = (*p)->get_params();
862 // サブパラメータも登録
863 for(r = subparams->begin() ; r != subparams->end() ; r++)
864 {
865 sub_objects = (*r)->get_subparams();
866 id = (*p)->get_id();
867
868 string s = "." + (*r)->get_value();
869
870 // サブパラメータの持つ属性は再帰で登録する
871 if(sub_objects->empty() == false)
872 {
873 cfg_obj_map temp;
874 std::string subparam_name =
875 (*p)->get_object_type() + ".";
876 temp = merge(sub_objects , temp , subparam_name , s , id);
877
878 // 結果をコピー(ちょうどいいメソッドが無い)
879 // modified by takuya 110823
880 // std::map< std::string, std::vector< object_definition* >>::iterator x;
881 std::map< std::string, std::vector< object_definition* > >::iterator x;
882 for(x = temp.begin() ; x != temp.end() ; x++ )
883 {
884 std::vector< object_definition* >::iterator y;
885 for(y = (*x).second.begin() ; y != (*x).second.end() ; y++)
886 {
887 out[(*x).first].push_back((*y));
888 }
889 //out[(*x).first] = (*x).second;
890 //out[(*x).first].push_back((*x).second);
891 }
892 }
893 }
894 }
895
896 return out;
897 }
898 }
899 } /* oil */
900
901}
Note: See TracBrowser for help on using the repository browser.