WebSVN – HomeAutomation – Diff – /branches/modules/PcSoftware/csharp-lib/Arguments.cs


//http://www.codeproject.com/csharp/Command_Line.asp
 
using System;
using System.Collections.Specialized;
using System.Text.RegularExpressions;
 
//namespace CommandLine.Utility
//{
    /// <summary>
    /// Arguments class
    /// </summary>
    public class Arguments{
        // Variables
        private StringDictionary Parameters;
 
        // Constructor
        public Arguments(string[] Args)
        {
            Parameters = new StringDictionary();
            Regex Spliter = new Regex(@"^-{1,2}|^/|=|:",
                RegexOptions.IgnoreCase|RegexOptions.Compiled);
 
            Regex Remover = new Regex(@"^['""]?(.*?)['""]?$",
                RegexOptions.IgnoreCase|RegexOptions.Compiled);
 
            string Parameter = null;
            string[] Parts;
 
            // Valid parameters forms:
            // {-,/,--}param{ ,=,:}((",')value(",'))
            // Examples: 
            // -param1 value1 --param2 /param3:"Test-:-work" 
            //   /param4=happy -param5 '--=nice=--'
            foreach(string Txt in Args)
            {
                // Look for new parameters (-,/ or --) and a
                // possible enclosed value (=,:)
                Parts = Spliter.Split(Txt,3);
 
                switch(Parts.Length){
                // Found a value (for the last parameter 
                // found (space separator))
                case 1:
                    if(Parameter != null)
                    {
                        if(!Parameters.ContainsKey(Parameter))
                        {
                            Parts[0] =
                                Remover.Replace(Parts[0], "$1");
 
                            Parameters.Add(Parameter, Parts[0]);
                        }
                        Parameter=null;
                    }
                    // else Error: no parameter waiting for a value (skipped)
                    break;
 
                // Found just a parameter
                case 2:
                    // The last parameter is still waiting. 
                    // With no value, set it to true.
                    if(Parameter!=null)
                    {
                        if(!Parameters.ContainsKey(Parameter))
                            Parameters.Add(Parameter, "true");
                    }
                    Parameter=Parts[1];
                    break;
 
                // Parameter with enclosed value
                case 3:
                    // The last parameter is still waiting. 
                    // With no value, set it to true.
                    if(Parameter != null)
                    {
                        if(!Parameters.ContainsKey(Parameter))
                            Parameters.Add(Parameter, "true");
                    }
 
                    Parameter = Parts[1];
 
                    // Remove possible enclosing characters (",')
                    if(!Parameters.ContainsKey(Parameter))
                    {
                        Parts[2] = Remover.Replace(Parts[2], "$1");
                        Parameters.Add(Parameter, Parts[2]);
                    }
 
                    Parameter=null;
                    break;
                }
            }
            // In case a parameter is still waiting
            if(Parameter != null)
            {
                if(!Parameters.ContainsKey(Parameter))
                    Parameters.Add(Parameter, "true");
            }
        }
       
        // Retrieve a parameter value if it exists 
        // (overriding C# indexer property)
        public string this [string Param]
        {
            get
            {
                return(Parameters[Param]);
            }
        }
    }
//}

Rev 450	Rev 800
1	//http://www.codeproject.com/csharp/Command_Line.asp	1	//http://www.codeproject.com/csharp/Command_Line.asp
2		2
3	using System;	3	using System;
4	using System.Collections.Specialized;	4	using System.Collections.Specialized;
5	using System.Text.RegularExpressions;	5	using System.Text.RegularExpressions;
6		6
7	//namespace CommandLine.Utility	7	//namespace CommandLine.Utility
8	//{	8	//{
9	/// <summary>	9	/// <summary>
10	/// Arguments class	10	/// Arguments class
11	/// </summary>	11	/// </summary>
12	public class Arguments{	12	public class Arguments{
13	// Variables	13	// Variables
14	private StringDictionary Parameters;	14	private StringDictionary Parameters;
15		15
16	// Constructor	16	// Constructor
17	public Arguments(string[] Args)	17	public Arguments(string[] Args)
18	{	18	{
19	Parameters = new StringDictionary();	19	Parameters = new StringDictionary();
20	Regex Spliter = new Regex(@"^-{1,2}\|^/\|=\|:",	20	Regex Spliter = new Regex(@"^-{1,2}\|^/\|=\|:",
21	RegexOptions.IgnoreCase\|RegexOptions.Compiled);	21	RegexOptions.IgnoreCase\|RegexOptions.Compiled);
22		22
23	Regex Remover = new Regex(@"^['""]?(.*?)['""]?$",	23	Regex Remover = new Regex(@"^['""]?(.*?)['""]?$",
24	RegexOptions.IgnoreCase\|RegexOptions.Compiled);	24	RegexOptions.IgnoreCase\|RegexOptions.Compiled);
25		25
26	string Parameter = null;	26	string Parameter = null;
27	string[] Parts;	27	string[] Parts;
28		28
29	// Valid parameters forms:	29	// Valid parameters forms:
30	// {-,/,--}param{ ,=,:}((",')value(",'))	30	// {-,/,--}param{ ,=,:}((",')value(",'))
31	// Examples:	31	// Examples:
32	// -param1 value1 --param2 /param3:"Test-:-work"	32	// -param1 value1 --param2 /param3:"Test-:-work"
33	// /param4=happy -param5 '--=nice=--'	33	// /param4=happy -param5 '--=nice=--'
34	foreach(string Txt in Args)	34	foreach(string Txt in Args)
35	{	35	{
36	// Look for new parameters (-,/ or --) and a	36	// Look for new parameters (-,/ or --) and a
37	// possible enclosed value (=,:)	37	// possible enclosed value (=,:)
38	Parts = Spliter.Split(Txt,3);	38	Parts = Spliter.Split(Txt,3);
39		39
40	switch(Parts.Length){	40	switch(Parts.Length){
41	// Found a value (for the last parameter	41	// Found a value (for the last parameter
42	// found (space separator))	42	// found (space separator))
43	case 1:	43	case 1:
44	if(Parameter != null)	44	if(Parameter != null)
45	{	45	{
46	if(!Parameters.ContainsKey(Parameter))	46	if(!Parameters.ContainsKey(Parameter))
47	{	47	{
48	Parts[0] =	48	Parts[0] =
49	Remover.Replace(Parts[0], "$1");	49	Remover.Replace(Parts[0], "$1");
50		50
51	Parameters.Add(Parameter, Parts[0]);	51	Parameters.Add(Parameter, Parts[0]);
52	}	52	}
53	Parameter=null;	53	Parameter=null;
54	}	54	}
55	// else Error: no parameter waiting for a value (skipped)	55	// else Error: no parameter waiting for a value (skipped)
56	break;	56	break;
57		57
58	// Found just a parameter	58	// Found just a parameter
59	case 2:	59	case 2:
60	// The last parameter is still waiting.	60	// The last parameter is still waiting.
61	// With no value, set it to true.	61	// With no value, set it to true.
62	if(Parameter!=null)	62	if(Parameter!=null)
63	{	63	{
64	if(!Parameters.ContainsKey(Parameter))	64	if(!Parameters.ContainsKey(Parameter))
65	Parameters.Add(Parameter, "true");	65	Parameters.Add(Parameter, "true");
66	}	66	}
67	Parameter=Parts[1];	67	Parameter=Parts[1];
68	break;	68	break;
69		69
70	// Parameter with enclosed value	70	// Parameter with enclosed value
71	case 3:	71	case 3:
72	// The last parameter is still waiting.	72	// The last parameter is still waiting.
73	// With no value, set it to true.	73	// With no value, set it to true.
74	if(Parameter != null)	74	if(Parameter != null)
75	{	75	{
76	if(!Parameters.ContainsKey(Parameter))	76	if(!Parameters.ContainsKey(Parameter))
77	Parameters.Add(Parameter, "true");	77	Parameters.Add(Parameter, "true");
78	}	78	}
79		79
80	Parameter = Parts[1];	80	Parameter = Parts[1];
81		81
82	// Remove possible enclosing characters (",')	82	// Remove possible enclosing characters (",')
83	if(!Parameters.ContainsKey(Parameter))	83	if(!Parameters.ContainsKey(Parameter))
84	{	84	{
85	Parts[2] = Remover.Replace(Parts[2], "$1");	85	Parts[2] = Remover.Replace(Parts[2], "$1");
86	Parameters.Add(Parameter, Parts[2]);	86	Parameters.Add(Parameter, Parts[2]);
87	}	87	}
88		88
89	Parameter=null;	89	Parameter=null;
90	break;	90	break;
91	}	91	}
92	}	92	}
93	// In case a parameter is still waiting	93	// In case a parameter is still waiting
94	if(Parameter != null)	94	if(Parameter != null)
95	{	95	{
96	if(!Parameters.ContainsKey(Parameter))	96	if(!Parameters.ContainsKey(Parameter))
97	Parameters.Add(Parameter, "true");	97	Parameters.Add(Parameter, "true");
98	}	98	}
99	}	99	}
100		100
101	// Retrieve a parameter value if it exists	101	// Retrieve a parameter value if it exists
102	// (overriding C# indexer property)	102	// (overriding C# indexer property)
103	public string this [string Param]	103	public string this [string Param]
104	{	104	{
105	get	105	get
106	{	106	{
107	return(Parameters[Param]);	107	return(Parameters[Param]);
108	}	108	}
109	}	109	}
110	}	110	}
111	//}	111	//}

Subversion Repositories HomeAutomation

(root)/branches/modules/PcSoftware/csharp-lib/Arguments.cs – Rev 450 → 800