basic.rs example added

examples/advanced.rs

@@ -69,7 +69,6 @@ fn process_cmdopts(opts: &mut Options) -> Result<(), ParseError>
 
     #[derive(Clone)]
     #[derive(Copy)]
-    #[derive(Debug)]
     enum OptId {
         OptA,
         OptB,

examples/basic.rs

@@ -0,0 +1,78 @@
+//
+// Copyright (c) 2023 Piotr Stolarz
+// GNU-like Command line options parser.
+//
+// Distributed under the 2-clause BSD License (the License)
+// see accompanying file LICENSE for details.
+//
+// This software is distributed WITHOUT ANY WARRANTY; without even the
+// implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+// See the License for more information.
+//
+
+use cmdopts::{parse_opts, InfoCode, ProcessCode, ParseError, CmdOpt};
+
+#[allow(unused_imports)]
+#[allow(unused_must_use)]
+pub fn main()
+{
+    use CmdOpt::*;
+    use InfoCode::*;
+    use ProcessCode::*;
+    use ParseError::*;
+    use OptId::*;
+    use std::cell::Cell;
+
+    #[derive(Clone)]
+    #[derive(Copy)]
+    enum OptId { OptA, OptB }
+    impl Default for OptId { fn default() -> Self { OptA } }
+    let opt_id: Cell<OptId> = Default::default();
+
+    let rc = parse_opts(
+        // Options info provider
+        //
+        |opt| {
+            match opt {
+                Short(c) => {
+                    match c {
+                        // -a, option w/o value
+                        'a' => { opt_id.set(OptA); NoValueOpt },
+                        // -b, option w/value
+                        'b' => { opt_id.set(OptB); ValueOpt },
+                        _ => InfoCode::InvalidOpt,
+                    }
+                },
+                Long(s) => {
+                    match s.as_str() {
+                        // long counterpart of the short options
+                        "long_a" => { opt_id.set(OptA); NoValueOpt },
+                        "long_b" => { opt_id.set(OptB); ValueOpt },
+                        _ => InfoCode::InvalidOpt,
+                    }
+                },
+            }
+        },
+
+        // Options handler
+        //
+        |opt, val| {
+            // all parsed tokens must form options
+            opt.as_ref().ok_or(GenericErr("Non-option detected".to_string()))?;
+
+            match opt_id.get() {
+                OptA => {
+                    println!("A option");
+                }
+                OptB => {
+                    println!("B option with {}", val.as_ref().unwrap().val);
+                },
+            };
+
+            Ok(ProcessCode::Continue)
+        });
+
+    if rc.is_err() {
+        eprintln!("[ERROR] {}", rc.unwrap_err());
+    }
+}

src/lib.rs

@@ -10,7 +10,6 @@
 // See the License for more information.
 //
 
-//!
 //! GNU-like command line options parser with long and short formats. Optional
 //! argument (aka option's value) may be associated with an option. The parsing
 //! routine `parse_opts()` accepts two user callbacks:
@@ -362,6 +361,7 @@ where
 /// retrieve information about parsed option followed by call to `opt_h()` to
 /// handle that option.
 ///
+#[inline]
 pub fn parse_opts<Fi, Fh>(opt_i: Fi, opt_h: Fh) -> Result<(), ParseError>
 where
     Fi: FnMut(&CmdOpt) -> InfoCode,