Ticket #2982: patch_ticket2982_2.diff

boost/program_options/errors.hpp

@@ -38 +38 @@
         std::string tokens, msg;
     };
 
+    /** Class thrown when a required/mandatory option is missing */
+    class BOOST_PROGRAM_OPTIONS_DECL required_option : public error {
+    public:
+       required_option(const std::string& name)
+       : error(std::string("missing required option ").append(name))
+       {}
+    };
+
     /** Class thrown when option name is not recognized. */
     class BOOST_PROGRAM_OPTIONS_DECL unknown_option : public error {
     public:

boost/program_options/value_semantic.hpp

@@ -44 +44 @@
         */
         virtual bool is_composing() const = 0;
         
+        /** Returns true if value must be given. Non-optional value
+
+        */
+        virtual bool is_required() const = 0;
+
         /** Parses a group of tokens that specify a value of option.
             Stores the result in 'value_store', using whatever representation
             is desired. May be be called several times if value of the same
@@ -132 +137 @@
 
         bool is_composing() const { return false; }
         
+        bool is_required() const { return false; }
+
         /** If 'value_store' is already initialized, or new_tokens
             has more than one elements, throws. Otherwise, assigns
             the first string from 'new_tokens' to 'value_store', without
@@ -177 +184 @@
             the value when it's known. The parameter can be NULL. */
         typed_value(T* store_to) 
         : m_store_to(store_to), m_composing(false),
-          m_multitoken(false), m_zero_tokens(false)
+          m_multitoken(false), m_zero_tokens(false),
+          m_required(false)
         {} 
 
         /** Specifies default value, which will be used
@@ -265 +273 @@
             m_zero_tokens = true;
             return this;
         }
+
+        typed_value* required()
+        {
+            m_required = true;
+            return this;
+        }
             
 
     public: // value semantic overrides
@@ -292 +306 @@
             }
         }
 
+        bool is_required() const { return m_required; }
 
+
         /** Creates an instance of the 'validator' class and calls
             its operator() to perform the actual conversion. */
         void xparse(boost::any& value_store, 
@@ -335 +351 @@
         std::string m_default_value_as_text;
         boost::any m_implicit_value;
         std::string m_implicit_value_as_text;
-        bool m_composing, m_implicit, m_multitoken, m_zero_tokens;
+        bool m_composing, m_implicit, m_multitoken, m_zero_tokens, m_required;
         boost::function1<void, const T&> m_notifier;
     };
 

boost/program_options/variables_map.hpp

@@ -120 +120 @@
         */
         const variable_value& operator[](const std::string& name) const;
 
+        /** Returns number of non-empty value of variable 'name' */
+        std::size_t count(const std::string& name) const;
+        
         /** Sets next variable map, which will be used to find
            variables not found in *this. */
         void next(abstract_variables_map* next);
@@ -147 +150 @@
         // Resolve conflict between inherited operators.
         const variable_value& operator[](const std::string& name) const
         { return abstract_variables_map::operator[](name); }
-
+        
+        std::size_t count(const std::string& name) const
+        { return abstract_variables_map::count(name); }
+        
     private:
         /** Implementation of abstract_variables_map::get
             which does 'find' in *this. */

libs/program_options/src/variables_map.cpp

@@ -12 +12 @@
 #include <boost/program_options/variables_map.hpp>
 
 #include <cassert>
+#include <iostream>
 
 namespace boost { namespace program_options {
 
@@ -95 +96 @@
 
         
         
-        // Second, apply default values.
+        // Second, apply default values and required options
         const vector<shared_ptr<option_description> >& all = desc.options();
         for(i = 0; i < all.size(); ++i)
         {
@@ -117 +118 @@
                     m[key] = variable_value(def, true);
                     m[key].m_value_semantic = d.semantic();
                 }
-            }        
+            }
+            
+            // add empty value if this is an required option
+            if (d.semantic()->is_required()) {
+               if (m.count(key) == 0) {
+                  m[key] = variable_value();
+                  m[key].m_value_semantic = d.semantic();
+               }
+            }
         }
     }
 
@@ -145 +154 @@
             */
             if (k->second.m_value_semantic)
                 k->second.m_value_semantic->notify(k->second.value());
-        }               
+        }
+        
+        // This checks if all required options occur
+        for (map<string, variable_value>::const_iterator k = vm.begin();
+             k != vm.end(); 
+             ++k)
+        {
+           if (k->second.empty() && k->second.m_value_semantic
+                  &&  k->second.m_value_semantic->is_required()) {
+              boost::throw_exception(required_option(
+                                                  k->first));
+
+           }
+        }
     }
 
     abstract_variables_map::abstract_variables_map()
@@ -178 +200 @@
     {
         m_next = next;
     }
+    
+    std::size_t abstract_variables_map::count(const std::string& name) const
+    {
+       const variable_value& v = get(name);
+       std::size_t c = (v.empty() ? 0 : 1);
+       return (m_next ? (c + (*m_next).count(name)) : c);    
+    }
 
     variables_map::variables_map()
     {}

libs/program_options/src/cmdline.cpp

@@ -309 +309 @@
             }
         }
         result.swap(result2);
-        
 
         // Assign position keys to positional options.
         int position_key = 0;