source: branches/dev/Common/IpRegOptions.cpp @ 539

Last change on this file since 539 was 539, checked in by andreasw, 15 years ago

Corrected includes for ctype and stdio (the old OLD_C_HEADER was used).
(this bug was reported by Steven Dirkse)

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 33.7 KB
Line 
1// Copyright (C) 2005 International Business Machines and others.
2// All Rights Reserved.
3// This code is published under the Common Public License.
4//
5// $Id: IpRegOptions.cpp 539 2005-10-12 17:42:11Z andreasw $
6//
7// Authors:  Carl Laird, Andreas Waechter     IBM    2005-06-18
8
9#include "IpRegOptions.hpp"
10#include <set>
11
12#ifdef HAVE_CCTYPE
13# include <cctype>
14#else
15# ifdef HAVE_CTYPE_H
16#  include <ctype.h>
17# else
18#  error "don't have header file for ctype"
19# endif
20#endif
21
22namespace Ipopt
23{
24
25  Index RegisteredOption::next_counter_ = 1;
26
27  void RegisteredOption::OutputDescription(const Journalist& jnlst) const
28  {
29    std::string type_str = "Unknown";
30    if (type_ ==OT_Number) {
31      type_str = "Real Number";
32    }
33    else if (type_ ==OT_Integer) {
34      type_str = "Integer";
35    }
36    else if (type_ ==OT_String) {
37      type_str = "String";
38    }
39
40    jnlst.Printf(J_SUMMARY, J_DOCUMENTATION,
41                 "\n### %s (%s) ###\nCategory: %s\nDescription: %s\n",
42                 name_.c_str(), type_str.c_str(),
43                 registering_category_.c_str(), short_description_.c_str());
44
45    if (type_ ==OT_Number) {
46      if (has_lower_) {
47        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "%g", lower_);
48      }
49      else {
50        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "-inf");
51      }
52
53      if (lower_strict_) {
54        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, " < ");
55      }
56      else {
57        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, " <= ");
58      }
59
60      jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "(%g)", default_number_);
61
62      if (has_upper_ && upper_strict_) {
63        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, " < ");
64      }
65      else {
66        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, " <= ");
67      }
68
69      if (has_upper_) {
70        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "%g\n", upper_);
71      }
72      else {
73        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "+inf\n");
74      }
75    }
76    else if (type_ ==OT_Integer) {
77      if (has_lower_) {
78        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "%d", (Index)lower_);
79      }
80      else {
81        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "-inf");
82      }
83
84      jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, " <= (%d) <= ", (Index)default_number_);
85
86      if (has_upper_) {
87        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "%d\n", (Index)upper_);
88      }
89      else {
90        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "+inf\n");
91      }
92    }
93    else if (type_ ==OT_String) {
94      std::vector<string_entry>::const_iterator i;
95      jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "Valid Settings:\n");
96      for (i = valid_strings_.begin(); i != valid_strings_.end(); i++) {
97        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "\t%s (%s)\n",
98                     (*i).value_.c_str(), (*i).description_.c_str());
99      }
100      jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "Default: \"%s\"\n",
101                   default_string_.c_str());
102    }
103  }
104
105  void RegisteredOption::OutputLatexDescription(const Journalist& jnlst) const
106  {
107    std::string latex_name;
108    MakeValidLatexString(name_, latex_name);
109    std::string latex_desc;
110    MakeValidLatexString(short_description_, latex_desc);
111    jnlst.Printf(J_SUMMARY, J_DOCUMENTATION,
112                 "\\paragraph{%s:} %s $\\;$ \\\\\n",
113                 latex_name.c_str(),
114                 latex_desc.c_str());
115
116    //    Index length = name_.length() + short_description_.length();
117    //    DBG_ASSERT(length <= 80);
118    //    jnlst.PrintStringOverLines(J_SUMMARY, J_DOCUMENTATION, 0, 50,
119    //                               latex_desc.c_str());
120
121    if (long_description_ != "") {
122      latex_desc = "";
123      MakeValidLatexString(long_description_, latex_desc);
124      jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, " ");
125      jnlst.PrintStringOverLines(J_SUMMARY, J_DOCUMENTATION, 0, 50,
126                                 latex_desc.c_str());
127    }
128
129    if (type_ == OT_Number) {
130      jnlst.Printf(J_SUMMARY, J_DOCUMENTATION,
131                   " The valid range for this real option is \n$");
132      std::string buff;
133      if (has_lower_) {
134        buff = MakeValidLatexNumber(lower_);
135        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "%s", buff.c_str());
136      }
137      else {
138        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "%s", "{\\tt -inf}");
139      }
140
141      if (has_lower_ && !lower_strict_) {
142        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, " \\le ");
143      }
144      else {
145        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, " <  ");
146      }
147
148      jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "{\\tt %s }", latex_name.c_str());
149
150      if (has_upper_ && !upper_strict_) {
151        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, " \\le ");
152      }
153      else {
154        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, " <  ");
155      }
156
157      if (has_upper_) {
158        buff = MakeValidLatexNumber(upper_);
159        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "%s", buff.c_str());
160      }
161      else {
162        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "%s", "{\\tt +inf}");
163      }
164
165      buff = MakeValidLatexNumber(default_number_);
166      jnlst.Printf(J_SUMMARY, J_DOCUMENTATION,
167                   "$\nand its default value is $%s$.\n\n", buff.c_str());
168
169    }
170    else if (type_ == OT_Integer) {
171      jnlst.Printf(J_SUMMARY, J_DOCUMENTATION,
172                   " The valid range for this integer option is\n$");
173      if (has_lower_) {
174        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "%d \\le ", (Index)lower_);
175      }
176      else {
177        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "%s <  ", "{\\tt -inf}");
178      }
179
180      jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "{\\tt %s }", latex_name.c_str());
181
182      if (has_upper_) {
183        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, " \\le %d", (Index)upper_);
184      }
185      else {
186        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, " <  %s", "{\\tt +inf}");
187      }
188
189      jnlst.Printf(J_SUMMARY, J_DOCUMENTATION,
190                   "$\nand its default value is $%d$.\n\n",
191                   (Index)default_number_);
192    }
193    else if (type_ == OT_String) {
194      std::string buff;
195      MakeValidLatexString(default_string_, buff);
196      jnlst.Printf(J_SUMMARY, J_DOCUMENTATION,
197                   "\nThe default value for this string option is \"%s\".\n",
198                   buff.c_str());
199
200      jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "\\\\ \nPossible values:\n");
201      jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "\\begin{itemize}\n");
202      for (std::vector<string_entry>::const_iterator
203           i = valid_strings_.begin();
204           i != valid_strings_.end(); i++) {
205        std::string latex_value;
206        MakeValidLatexString((*i).value_, latex_value);
207        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "   \\item %s: ",
208                     latex_value.c_str());
209
210        std::string latex_desc;
211        MakeValidLatexString((*i).description_, latex_desc);
212        jnlst.PrintStringOverLines(J_SUMMARY, J_DOCUMENTATION, 0, 48,
213                                   latex_desc.c_str());
214        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "\n");
215      }
216      jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "\\end{itemize}\n");
217    }
218    jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "\n");
219  }
220
221  void RegisteredOption::MakeValidLatexString(std::string source, std::string& dest) const
222  {
223    std::string::iterator c;
224    for (c=source.begin(); c!=source.end(); c++) {
225      if (*c == '_') {
226        dest.append("\\_");
227      }
228      else if (*c == '^') {
229        dest.append("\\^");
230      }
231      else {
232        dest.push_back(*c);
233      }
234    }
235  }
236
237  std::string RegisteredOption::MakeValidLatexNumber(Number value) const
238  {
239    char buffer[256];
240    sprintf(buffer, "%g", value);
241    std::string source = buffer;
242    std::string dest;
243
244    std::string::iterator c;
245    bool found_e = false;
246    for (c=source.begin(); c!=source.end(); c++) {
247      if (*c == 'e') {
248        found_e = true;
249        dest.append(" \\cdot 10^{");
250      }
251      else {
252        dest.push_back(*c);
253      }
254    }
255    if (found_e) {
256      dest.append("}");
257    }
258
259    return dest;
260  }
261
262  void RegisteredOption::OutputShortDescription(const Journalist& jnlst) const
263  {
264    jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "%-30s",  name_.c_str());
265
266
267    if (type_ == OT_Number) {
268      if (has_lower_) {
269        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "%10g", lower_);
270      }
271      else {
272        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "%10s", "-inf");
273      }
274
275      if (has_lower_ && !lower_strict_) {
276        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, " <= ");
277      }
278      else {
279        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, " <  ");
280      }
281
282      jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "(%11g)", default_number_);
283
284      if (has_upper_ && !upper_strict_) {
285        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, " <= ");
286      }
287      else {
288        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, " <  ");
289      }
290
291      if (has_upper_) {
292        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "%-10g\n", upper_);
293      }
294      else {
295        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "%-10s\n", "+inf");
296      }
297    }
298    else if (type_ == OT_Integer) {
299      if (has_lower_) {
300        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "%10d <= ", (Index)lower_);
301      }
302      else {
303        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "%10s <  ", "-inf");
304      }
305
306      jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "(%11d)",
307                   (Index)default_number_);
308
309      if (has_upper_) {
310        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, " <= %-10d\n", (Index)upper_);
311      }
312      else {
313        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, " <  %-10s\n", "+inf");
314      }
315    }
316    else if (type_ == OT_String) {
317      jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "(\"%s\")\n",
318                   default_string_.c_str());
319    }
320    jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "   ");
321    jnlst.PrintStringOverLines(J_SUMMARY, J_DOCUMENTATION, 3, 76,
322                               short_description_.c_str());
323    if (long_description_ != "") {
324      jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "\n     ");
325      jnlst.PrintStringOverLines(J_SUMMARY, J_DOCUMENTATION, 5, 74,
326                                 long_description_.c_str());
327    }
328    if (type_ == OT_String) {
329      jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "\n   Possible values:\n");
330      for (std::vector<string_entry>::const_iterator
331           i = valid_strings_.begin();
332           i != valid_strings_.end(); i++) {
333        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "    - %-23s [",
334                     (*i).value_.c_str());
335
336        jnlst.PrintStringOverLines(J_SUMMARY, J_DOCUMENTATION, 31, 48,
337                                   (*i).description_.c_str());
338        jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "]\n");
339      }
340    }
341    else {
342      jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "\n");
343    }
344    jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "\n");
345  }
346
347  bool RegisteredOption::IsValidStringSetting(const std::string& value) const
348  {
349    DBG_ASSERT(type_ == OT_String);
350
351    std::vector<string_entry>::const_iterator i;
352    for (i = valid_strings_.begin(); i != valid_strings_.end(); i++) {
353      if (i->value_ == "*" || string_equal_insensitive(i->value_, value)) {
354        return true;
355      }
356    }
357    return false;
358  }
359
360  std::string
361  RegisteredOption::MapStringSetting(const std::string& value) const
362  {
363    DBG_ASSERT(type_ == OT_String);
364
365    std::string matched_setting = "";
366
367    std::vector<string_entry>::const_iterator i;
368    for (i = valid_strings_.begin(); i != valid_strings_.end(); i++) {
369      if (i->value_ == "*") {
370        matched_setting = value;
371      }
372      else if (string_equal_insensitive(i->value_, value)) {
373        matched_setting = i->value_;
374      }
375    }
376    return matched_setting;
377  }
378
379  Index
380  RegisteredOption::MapStringSettingToEnum(const std::string& value) const
381  {
382    DBG_ASSERT(type_ == OT_String);
383
384    Index matched_setting = -1;
385
386    Index cnt = 0;
387    std::vector<string_entry>::const_iterator i;
388    for (i = valid_strings_.begin(); i != valid_strings_.end(); i++) {
389      ASSERT_EXCEPTION(i->value_ != "*", IpoptException,
390                       "Cannot map a wildcard setting to an enumeration");
391      if (string_equal_insensitive(i->value_, value)) {
392        matched_setting = cnt;
393        break;
394      }
395      cnt++;
396    }
397
398    ASSERT_EXCEPTION(matched_setting != -1, ERROR_CONVERTING_STRING_TO_ENUM,
399                     std::string("Could not find a match for setting ") + value +
400                     " in option: " + name_);
401    return matched_setting;
402  }
403
404  bool
405  RegisteredOption::string_equal_insensitive(const std::string& s1,
406      const std::string& s2) const
407  {
408    using namespace std;
409
410    if (s1.size()!=s2.size())
411      return false;
412
413    string::const_iterator i1 = s1.begin();
414    string::const_iterator i2 = s2.begin();
415
416    while(i1!=s1.end()) {
417      if (toupper(*i1)!=toupper(*i2))
418        return false;
419      i1++;
420      i2++;
421    }
422    return true;
423  }
424
425  void
426  RegisteredOptions::AddNumberOption(const std::string& name,
427                                     const std::string& short_description,
428                                     Number default_value,
429                                     const std::string& long_description)
430  {
431    SmartPtr<RegisteredOption> option =
432      new RegisteredOption(name, short_description, long_description,
433                           current_registering_category_);
434    option->SetType(OT_Number);
435    option->SetDefaultNumber(default_value);
436    ASSERT_EXCEPTION(registered_options_.find(name) == registered_options_.end(),
437                     OPTION_ALREADY_REGISTERED,
438                     std::string("The option: ") + option->Name() + " has already been registered by someone else");
439    registered_options_[name] = option;
440  }
441
442  void
443  RegisteredOptions::AddLowerBoundedNumberOption(const std::string& name,
444      const std::string& short_description,
445      Number lower, bool strict,
446      Number default_value,
447      const std::string& long_description)
448  {
449    SmartPtr<RegisteredOption> option =
450      new RegisteredOption(name, short_description, long_description,
451                           current_registering_category_);
452    option->SetType(OT_Number);
453    option->SetDefaultNumber(default_value);
454    option->SetLowerNumber(lower, strict);
455    ASSERT_EXCEPTION(registered_options_.find(name) == registered_options_.end(), OPTION_ALREADY_REGISTERED,
456                     std::string("The option: ") + option->Name() + " has already been registered by someone else");
457    registered_options_[name] = option;
458  }
459
460  void
461  RegisteredOptions::AddUpperBoundedNumberOption(const std::string& name,
462      const std::string& short_description,
463      Number upper, bool strict,
464      Number default_value,
465      const std::string& long_description)
466  {
467    SmartPtr<RegisteredOption> option =
468      new RegisteredOption(name, short_description, long_description,
469                           current_registering_category_);
470    option->SetType(OT_Number);
471    option->SetDefaultNumber(default_value);
472    option->SetUpperNumber(upper, strict);
473    ASSERT_EXCEPTION(registered_options_.find(name) == registered_options_.end(), OPTION_ALREADY_REGISTERED,
474                     std::string("The option: ") + option->Name() + " has already been registered by someone else");
475    registered_options_[name] = option;
476  }
477
478  void
479  RegisteredOptions::AddBoundedNumberOption(const std::string& name,
480      const std::string& short_description,
481      Number lower, bool lower_strict,
482      Number upper, bool upper_strict,
483      Number default_value,
484      const std::string& long_description)
485  {
486    SmartPtr<RegisteredOption> option =
487      new RegisteredOption(name, short_description, long_description,
488                           current_registering_category_);
489    option->SetType(OT_Number);
490    option->SetDefaultNumber(default_value);
491    option->SetLowerNumber(lower, lower_strict);
492    option->SetUpperNumber(upper, upper_strict);
493    ASSERT_EXCEPTION(registered_options_.find(name) == registered_options_.end(), OPTION_ALREADY_REGISTERED,
494                     std::string("The option: ") + option->Name() + " has already been registered by someone else");
495    registered_options_[name] = option;
496  }
497
498  void
499  RegisteredOptions::AddIntegerOption(const std::string& name,
500                                      const std::string& short_description,
501                                      Index default_value,
502                                      const std::string& long_description)
503  {
504    SmartPtr<RegisteredOption> option =
505      new RegisteredOption(name, short_description, long_description,
506                           current_registering_category_);
507    option->SetType(OT_Integer);
508    option->SetDefaultInteger(default_value);
509    ASSERT_EXCEPTION(registered_options_.find(name) == registered_options_.end(), OPTION_ALREADY_REGISTERED,
510                     std::string("The option: ") + option->Name() + " has already been registered by someone else");
511    registered_options_[name] = option;
512  }
513
514  void
515  RegisteredOptions::AddLowerBoundedIntegerOption(const std::string& name,
516      const std::string& short_description,
517      Index lower, Index default_value,
518      const std::string& long_description)
519  {
520    SmartPtr<RegisteredOption> option =
521      new RegisteredOption(name, short_description, long_description,
522                           current_registering_category_);
523    option->SetType(OT_Integer);
524    option->SetDefaultInteger(default_value);
525    option->SetLowerInteger(lower);
526    ASSERT_EXCEPTION(registered_options_.find(name) == registered_options_.end(), OPTION_ALREADY_REGISTERED,
527                     std::string("The option: ") + option->Name() + " has already been registered by someone else");
528    registered_options_[name] = option;
529  }
530
531  void
532  RegisteredOptions::AddUpperBoundedIntegerOption(const std::string& name,
533      const std::string& short_description,
534      Index upper, Index default_value,
535      const std::string& long_description)
536  {
537    SmartPtr<RegisteredOption> option =
538      new RegisteredOption(name, short_description, long_description,
539                           current_registering_category_);
540    option->SetType(OT_Integer);
541    option->SetDefaultInteger(default_value);
542    option->SetUpperInteger(upper);
543    ASSERT_EXCEPTION(registered_options_.find(name) == registered_options_.end(), OPTION_ALREADY_REGISTERED,
544                     std::string("The option: ") + option->Name() + " has already been registered by someone else");
545    registered_options_[name] = option;
546  }
547
548  void
549  RegisteredOptions::AddBoundedIntegerOption(const std::string& name,
550      const std::string& short_description,
551      Index lower, Index upper,
552      Index default_value,
553      const std::string& long_description)
554  {
555    SmartPtr<RegisteredOption> option =
556      new RegisteredOption(name, short_description, long_description,
557                           current_registering_category_);
558    option->SetType(OT_Integer);
559    option->SetDefaultInteger(default_value);
560    option->SetLowerInteger(lower);
561    option->SetUpperInteger(upper);
562    ASSERT_EXCEPTION(registered_options_.find(name) == registered_options_.end(), OPTION_ALREADY_REGISTERED,
563                     std::string("The option: ") + option->Name() + " has already been registered by someone else");
564    registered_options_[name] = option;
565  }
566
567  void
568  RegisteredOptions::AddStringOption(const std::string& name,
569                                     const std::string& short_description,
570                                     const std::string& default_value,
571                                     const std::vector<std::string>& settings,
572                                     const std::vector<std::string>& descriptions,
573                                     const std::string& long_description)
574  {
575    SmartPtr<RegisteredOption> option =
576      new RegisteredOption(name, short_description, long_description,
577                           current_registering_category_);
578    option->SetType(OT_String);
579    option->SetDefaultString(default_value);
580    DBG_ASSERT(settings.size() == descriptions.size());
581    for (int i=0; i<(int)settings.size(); i++) {
582      option->AddValidStringSetting(settings[i], descriptions[i]);
583    }
584    ASSERT_EXCEPTION(registered_options_.find(name) == registered_options_.end(), OPTION_ALREADY_REGISTERED,
585                     std::string("The option: ") + option->Name() + " has already been registered by someone else");
586    registered_options_[name] = option;
587  }
588
589  void
590  RegisteredOptions::AddStringOption1(const std::string& name,
591                                      const std::string& short_description,
592                                      const std::string& default_value,
593                                      const std::string& setting1,
594                                      const std::string& description1,
595                                      const std::string& long_description)
596  {
597    SmartPtr<RegisteredOption> option =
598      new RegisteredOption(name, short_description, long_description,
599                           current_registering_category_);
600    option->SetType(OT_String);
601    option->SetDefaultString(default_value);
602    option->AddValidStringSetting(setting1, description1);
603    ASSERT_EXCEPTION(registered_options_.find(name) == registered_options_.end(), OPTION_ALREADY_REGISTERED,
604                     std::string("The option: ") + option->Name() + " has already been registered by someone else");
605    registered_options_[name] = option;
606  }
607
608  void
609  RegisteredOptions::AddStringOption2(const std::string& name,
610                                      const std::string& short_description,
611                                      const std::string& default_value,
612                                      const std::string& setting1,
613                                      const std::string& description1,
614                                      const std::string& setting2,
615                                      const std::string& description2,
616                                      const std::string& long_description)
617  {
618    SmartPtr<RegisteredOption> option =
619      new RegisteredOption(name, short_description, long_description,
620                           current_registering_category_);
621    option->SetType(OT_String);
622    option->SetDefaultString(default_value);
623    option->AddValidStringSetting(setting1, description1);
624    option->AddValidStringSetting(setting2, description2);
625    ASSERT_EXCEPTION(registered_options_.find(name) == registered_options_.end(), OPTION_ALREADY_REGISTERED,
626                     std::string("The option: ") + option->Name() + " has already been registered by someone else");
627    registered_options_[name] = option;
628  }
629
630  void
631  RegisteredOptions::AddStringOption3(const std::string& name,
632                                      const std::string& short_description,
633                                      const std::string& default_value,
634                                      const std::string& setting1,
635                                      const std::string& description1,
636                                      const std::string& setting2,
637                                      const std::string& description2,
638                                      const std::string& setting3,
639                                      const std::string& description3,
640                                      const std::string& long_description)
641  {
642    SmartPtr<RegisteredOption> option =
643      new RegisteredOption(name, short_description, long_description,
644                           current_registering_category_);
645    option->SetType(OT_String);
646    option->SetDefaultString(default_value);
647    option->AddValidStringSetting(setting1, description1);
648    option->AddValidStringSetting(setting2, description2);
649    option->AddValidStringSetting(setting3, description3);
650    ASSERT_EXCEPTION(registered_options_.find(name) == registered_options_.end(), OPTION_ALREADY_REGISTERED,
651                     std::string("The option: ") + option->Name() + " has already been registered by someone else");
652    registered_options_[name] = option;
653  }
654
655  void
656  RegisteredOptions::AddStringOption4(const std::string& name,
657                                      const std::string& short_description,
658                                      const std::string& default_value,
659                                      const std::string& setting1,
660                                      const std::string& description1,
661                                      const std::string& setting2,
662                                      const std::string& description2,
663                                      const std::string& setting3,
664                                      const std::string& description3,
665                                      const std::string& setting4,
666                                      const std::string& description4,
667                                      const std::string& long_description)
668  {
669    SmartPtr<RegisteredOption> option =
670      new RegisteredOption(name, short_description, long_description,
671                           current_registering_category_);
672    option->SetType(OT_String);
673    option->SetDefaultString(default_value);
674    option->AddValidStringSetting(setting1, description1);
675    option->AddValidStringSetting(setting2, description2);
676    option->AddValidStringSetting(setting3, description3);
677    option->AddValidStringSetting(setting4, description4);
678    ASSERT_EXCEPTION(registered_options_.find(name) == registered_options_.end(), OPTION_ALREADY_REGISTERED,
679                     std::string("The option: ") + option->Name() + " has already been registered by someone else");
680    registered_options_[name] = option;
681  }
682
683  void
684  RegisteredOptions::AddStringOption5(const std::string& name,
685                                      const std::string& short_description,
686                                      const std::string& default_value,
687                                      const std::string& setting1,
688                                      const std::string& description1,
689                                      const std::string& setting2,
690                                      const std::string& description2,
691                                      const std::string& setting3,
692                                      const std::string& description3,
693                                      const std::string& setting4,
694                                      const std::string& description4,
695                                      const std::string& setting5,
696                                      const std::string& description5,
697                                      const std::string& long_description)
698  {
699    SmartPtr<RegisteredOption> option =
700      new RegisteredOption(name, short_description, long_description,
701                           current_registering_category_);
702    option->SetType(OT_String);
703    option->SetDefaultString(default_value);
704    option->AddValidStringSetting(setting1, description1);
705    option->AddValidStringSetting(setting2, description2);
706    option->AddValidStringSetting(setting3, description3);
707    option->AddValidStringSetting(setting4, description4);
708    option->AddValidStringSetting(setting5, description5);
709    ASSERT_EXCEPTION(registered_options_.find(name) == registered_options_.end(), OPTION_ALREADY_REGISTERED,
710                     std::string("The option: ") + option->Name() + " has already been registered by someone else");
711    registered_options_[name] = option;
712  }
713
714  void
715  RegisteredOptions::AddStringOption6(const std::string& name,
716                                      const std::string& short_description,
717                                      const std::string& default_value,
718                                      const std::string& setting1,
719                                      const std::string& description1,
720                                      const std::string& setting2,
721                                      const std::string& description2,
722                                      const std::string& setting3,
723                                      const std::string& description3,
724                                      const std::string& setting4,
725                                      const std::string& description4,
726                                      const std::string& setting5,
727                                      const std::string& description5,
728                                      const std::string& setting6,
729                                      const std::string& description6,
730                                      const std::string& long_description)
731  {
732    SmartPtr<RegisteredOption> option =
733      new RegisteredOption(name, short_description, long_description,
734                           current_registering_category_);
735    option->SetType(OT_String);
736    option->SetDefaultString(default_value);
737    option->AddValidStringSetting(setting1, description1);
738    option->AddValidStringSetting(setting2, description2);
739    option->AddValidStringSetting(setting3, description3);
740    option->AddValidStringSetting(setting4, description4);
741    option->AddValidStringSetting(setting5, description5);
742    option->AddValidStringSetting(setting6, description6);
743    ASSERT_EXCEPTION(registered_options_.find(name) == registered_options_.end(), OPTION_ALREADY_REGISTERED,
744                     std::string("The option: ") + option->Name() + " has already been registered by someone else");
745    registered_options_[name] = option;
746  }
747
748  void
749  RegisteredOptions::AddStringOption7(const std::string& name,
750                                      const std::string& short_description,
751                                      const std::string& default_value,
752                                      const std::string& setting1,
753                                      const std::string& description1,
754                                      const std::string& setting2,
755                                      const std::string& description2,
756                                      const std::string& setting3,
757                                      const std::string& description3,
758                                      const std::string& setting4,
759                                      const std::string& description4,
760                                      const std::string& setting5,
761                                      const std::string& description5,
762                                      const std::string& setting6,
763                                      const std::string& description6,
764                                      const std::string& setting7,
765                                      const std::string& description7,
766                                      const std::string& long_description)
767  {
768    SmartPtr<RegisteredOption> option =
769      new RegisteredOption(name, short_description, long_description,
770                           current_registering_category_);
771    option->SetType(OT_String);
772    option->SetDefaultString(default_value);
773    option->AddValidStringSetting(setting1, description1);
774    option->AddValidStringSetting(setting2, description2);
775    option->AddValidStringSetting(setting3, description3);
776    option->AddValidStringSetting(setting4, description4);
777    option->AddValidStringSetting(setting5, description5);
778    option->AddValidStringSetting(setting6, description6);
779    option->AddValidStringSetting(setting7, description7);
780    ASSERT_EXCEPTION(registered_options_.find(name) == registered_options_.end(), OPTION_ALREADY_REGISTERED,
781                     std::string("The option: ") + option->Name() + " has already been registered by someone else");
782    registered_options_[name] = option;
783  }
784
785  SmartPtr<const RegisteredOption> RegisteredOptions::GetOption(const std::string& name)
786  {
787    std::string tag_only = name;
788    std::string::size_type pos = name.rfind(".", name.length());
789    if (pos != std::string::npos) {
790      tag_only = name.substr(pos+1, name.length()-pos);
791    }
792    SmartPtr<const RegisteredOption> option;
793    std::map< std::string, SmartPtr<RegisteredOption> >::iterator reg_option = registered_options_.find(tag_only);
794    if (reg_option == registered_options_.end()) {
795      option = NULL;
796    }
797    else {
798      option = ConstPtr(reg_option->second);
799    }
800
801    return option;
802  }
803
804  void RegisteredOptions::OutputOptionDocumentation(const Journalist& jnlst, std::list<std::string>& categories)
805  {
806    // create a set to print sorted output
807    //     std::set
808    //       <std::string> classes;
809    //     std::map <std::string, SmartPtr<RegisteredOption> >::iterator option;
810    //     for (option = registered_options_.begin(); option != registered_options_.end(); option++) {
811    //       classes.insert(option->second->RegisteringCategory());
812    //     }
813
814
815    std::list
816    <std::string>::iterator i;
817    for (i = categories.begin(); i != categories.end(); i++) {
818      jnlst.Printf(J_SUMMARY, J_DOCUMENTATION,
819                   "\n### %s ###\n\n", (*i).c_str());
820      std::map<Index, SmartPtr<RegisteredOption> > class_options;
821      std::map <std::string, SmartPtr<RegisteredOption> >::iterator option;
822      for (option = registered_options_.begin();
823           option != registered_options_.end(); option++) {
824        if (option->second->RegisteringCategory() == (*i)) {
825
826          class_options[option->second->Counter()] = option->second;
827        }
828      }
829      std::map<Index, SmartPtr<RegisteredOption> >::const_iterator co;
830      for (co = class_options.begin(); co != class_options.end(); co++) {
831        co->second->OutputShortDescription(jnlst);
832      }
833      jnlst.Printf(J_SUMMARY, J_DOCUMENTATION, "\n");
834    }
835  }
836
837  void RegisteredOptions::OutputLatexOptionDocumentation(
838    const Journalist& jnlst,
839    std::list<std::string>& options_to_print)
840  {
841
842    if (!options_to_print.empty()) {
843      std::list<std::string>::iterator coption;
844      for (coption = options_to_print.begin();
845           coption != options_to_print.end();
846           coption++) {
847        //      std::map <std::string, SmartPtr<RegisteredOption> >::iterator option;
848        SmartPtr<RegisteredOption> option = registered_options_[*coption];
849        DBG_ASSERT(IsValid(option));
850        option->OutputLatexDescription(jnlst);
851      }
852    }
853    else {
854      std::map <std::string, SmartPtr<RegisteredOption> >::iterator option;
855      for (option = registered_options_.begin();
856           option != registered_options_.end();
857           option++) {
858        option->second->OutputLatexDescription(jnlst);
859      }
860    }
861  }
862} // namespace Ipopt
Note: See TracBrowser for help on using the repository browser.