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

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

final touches to release as first official version 3.0.0 (to be copied to trunk)

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