trunk/posUpdate/ParametersParser.cs

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Text;
using CLAP;
using CLAP.Interception;
using CLAP.Validation;

namespace xmlTools
{
    // Define a class to receive parsed values
    class ParametersParser
    {
        private static string globalFileName="";
        private static string globalElement="";
        private static string globalParentElement="";
        private static bool globalNoBackups = false;

        [Verb]
        public static void addValue(
            [Parameter(Required = true, Description = "Values to add to Element. Separated multiple by spaces.")] string value
            )
        {
            initialChecks();
            XmlTools myTools = new XmlTools(globalElement, globalParentElement, globalNoBackups);
            List<string> filesToProcess = getFilesToProcess(globalFileName);
            foreach (string currentFile in filesToProcess)
            {
                myTools.addValues(currentFile, value);
            }
            printProcessedMessage(filesToProcess.Count, MethodBase.GetCurrentMethod().Name);
        }

        [Verb]
        public static void removeValue(
            [Parameter(Required = true, Description = "Values to remove of Element. Separated multiple by spaces.")] string value
            )
        {
            initialChecks();
            XmlTools myTools = new XmlTools(globalElement, globalParentElement, globalNoBackups);
            List<string> filesToProcess = getFilesToProcess(globalFileName);
            foreach (string currentFile in filesToProcess)
            {
                myTools.removeValues(currentFile, value);
            }
            printProcessedMessage(filesToProcess.Count, MethodBase.GetCurrentMethod().Name);
        }

        [Verb]
        public static void updateChainValues(
            [Parameter(Required = true, Description = "The new first value of the chain. All the chain will be updated based on this value")] string newValue,
            [Parameter(Description = "Value which have some kind of relation with -newVal \n Together with -newVal updates all the values based on the" +
                "-newVal and another position specified on -valRelation parameter (basically starts with (newVal-valRelation) ) Is especially useful when" +
                "updating multiple related chains (on different files), like multiple objects from one position to another. Don't use with -filename, because" +
                "it will only update one file. \nExample: xmlTools.exe -newVal \"1 1 1\" -valRelation \"4 4 4\" -valElement Translation -valParentElement" +
                "OBANKeyFrame")] string valRelation,
            [Parameter(Description = "Only update specific positions. Positions starts with 0, separted multiple positions with space. Example: valPositions=0 1 4")] [MoreThan(-1)]  string valPositions
            )
        {
            initialChecks();
            XmlTools myTools = new XmlTools(globalElement, globalParentElement, globalNoBackups);
            List<string> filesToProcess = getFilesToProcess(globalFileName);
            foreach (string currentFile in filesToProcess)
            {
                myTools.changeValue(currentFile, newValue, valRelation, valPositions);
            }
            printProcessedMessage(filesToProcess.Count, MethodBase.GetCurrentMethod().Name);
        }

        [Verb(Description = "Inverts a chain (like an OBAN animation). Example: xmlTools.exe -filename OBANheli_rotorblades08.xml -invert -valElement Translation -valParentElement OBANKeyFrame (inverts translation chain)")]
        public static void Invert()
        {
            initialChecks();
            XmlTools myTools = new XmlTools(globalElement, globalParentElement, globalNoBackups);
            List<string> filesToProcess = getFilesToProcess(globalFileName);
            foreach (string currentFile in filesToProcess)
            {
                myTools.invert(currentFile); //Inverting the element order
            }
            printProcessedMessage(filesToProcess.Count, MethodBase.GetCurrentMethod().Name);
        }

        [Verb]
        public static void replaceValue(
            [Parameter(Required = true, Description = "Old value to replace in Element.")] string oldValue,
            [Parameter(Required = true, Description = "New value to replace in Element.")] string newValue
            )
        {
            XmlTools myTools = new XmlTools(globalElement, globalParentElement, globalNoBackups);
            List<string> filesToProcess = getFilesToProcess(globalFileName);
            foreach (string currentFile in filesToProcess)
            {
                myTools.replaceValue(currentFile, oldValue, newValue);
            }
            printProcessedMessage(filesToProcess.Count, MethodBase.GetCurrentMethod().Name);
        }

        [Verb]
        public static void replaceAll(
            [Parameter(Required = true, Description = "Value to replace in Element. Replace all values of a element by another value.")] string value,
            [Parameter(Description = "Only replace specific positions. Positions starts with 0, separted multiple positions with space. Example: valPositions=0 1 4")] [MoreThan(-1)] string valPositions
            )
        {
            initialChecks();
            XmlTools myTools = new XmlTools(globalElement, globalParentElement, globalNoBackups);
            List<string> filesToProcess = getFilesToProcess(globalFileName);
            foreach (string currentFile in filesToProcess)
            {
                if (valPositions != null)
                {
                    myTools.replaceAll(currentFile, value, valPositions);
                }
                else
                {
                    myTools.replaceAll(currentFile, value);
                }
            }
            printProcessedMessage(filesToProcess.Count, MethodBase.GetCurrentMethod().Name);
        }

        /// <summary>
        /// Patch in files can be used with wildcard or empty filename instead
        /// </summary>
        /// <param name="filename"></param>
        [Verb]
        public static void patchFile(
            [Parameter(Description = "Force the specified patch to run in specified files")] string forceInFiles
            )
        {
            XmlPatch myPatch;

            if (forceInFiles != "")
            {
                myPatch = new XmlPatch(globalFileName, forceInFiles, globalNoBackups);
            }
            else
            {
                myPatch = new XmlPatch(globalFileName, globalNoBackups);
            }

            myPatch.startPatch();
        }

        [Verb]
        public static void version()
        {
            Console.WriteLine("xmlTools v" + Program.toolsVersion);
            Console.WriteLine("\nWritten by s10k");
        }

        // Global Parameters
        [Global(Description = "Filename to apply the operations (with patchFile specifies the patch filename). Wildcards accepted for multiple files. No filename = search all .xml files in current path.")]
        public static void fileName(
             [Parameter(Required = true)] string filename // xml filename. Wildcards accepted.
            )
        {
            globalFileName = filename;
        }

        [Global(Description = "Element to apply the operation.")]
        public static void element(
             [Parameter(Required = true)] string element
            )
        {
            globalElement = element;
        }

        [Global(Description = "Parent of the Element to apply the operation.")]
        public static void parElement(
             [Parameter(Required = true)] string parentElement
            )
        {
            globalParentElement = parentElement;
        }

        [Global(Description = "Don't make backup of the files modified. Improves the overall program processing performance.")]
        public static void noBackups()
        {
            globalNoBackups = true;
        }

        // Private functions
        private static List<String> getFilesToProcess(String filename)
        {
            List<String> filesToProccess = new List<String>();

            if (filename == "") // No filename? Process everything xml file found.
            {
                List<string> allXmlFiles = Util.getAllXmlFiles();
                foreach (String file in allXmlFiles)
                {
                    filesToProccess.Add(file);
                }
            }
            else if (Util.containsWildcard(filename)) // Contains wildcards? Get all files that match it.
            {
                List<string> matchingWildcardFiles = Util.getXmlFilesWildcard(filename);
                foreach (String file in matchingWildcardFiles)
                {
                    filesToProccess.Add(file);
                }
            }
            else // Add the file specified
            {
                if (System.IO.File.Exists(filename))
                {
                    filesToProccess.Add(filename);
                }
                else
                {
                    Program.printAppError(Program.appErrors.FILE_NOT_FOUND, "The file specified: " + filename + " doesn't exists.", true);
                }
            }
            return filesToProccess;
        }

        private static void printProcessedMessage(int count, string methodName)
        {
            Console.WriteLine(count + " files processed with " + methodName + " command.");
        }

        private static void initialChecks()
        {
            if (String.IsNullOrEmpty(globalElement.Trim()))
            {
                Program.printAppError(Program.appErrors.ELEMENT_NOT_FOUND, "You must specify the element parameter where the operations will be processed.", true);
            }

        }
    }
}
Revision:	742
Committed:	Tue Mar 26 02:30:48 2013 UTC (12 years, 7 months ago) by s10k
File size:	10072 byte(s)
Log Message:	0.8
#	Content
1	using System;
2	using System.Collections.Generic;
3	using System.Reflection;
4	using System.Text;
5	using CLAP;
6	using CLAP.Interception;
7	using CLAP.Validation;
8
9	namespace xmlTools
10	{
11	// Define a class to receive parsed values
12	class ParametersParser
13	{
14	private static string globalFileName="";
15	private static string globalElement="";
16	private static string globalParentElement="";
17	private static bool globalNoBackups = false;
18
19	[Verb]
20	public static void addValue(
21	[Parameter(Required = true, Description = "Values to add to Element. Separated multiple by spaces.")] string value
22	)
23	{
24	initialChecks();
25	XmlTools myTools = new XmlTools(globalElement, globalParentElement, globalNoBackups);
26	List<string> filesToProcess = getFilesToProcess(globalFileName);
27	foreach (string currentFile in filesToProcess)
28	{
29	myTools.addValues(currentFile, value);
30	}
31	printProcessedMessage(filesToProcess.Count, MethodBase.GetCurrentMethod().Name);
32	}
33
34	[Verb]
35	public static void removeValue(
36	[Parameter(Required = true, Description = "Values to remove of Element. Separated multiple by spaces.")] string value
37	)
38	{
39	initialChecks();
40	XmlTools myTools = new XmlTools(globalElement, globalParentElement, globalNoBackups);
41	List<string> filesToProcess = getFilesToProcess(globalFileName);
42	foreach (string currentFile in filesToProcess)
43	{
44	myTools.removeValues(currentFile, value);
45	}
46	printProcessedMessage(filesToProcess.Count, MethodBase.GetCurrentMethod().Name);
47	}
48
49	[Verb]
50	public static void updateChainValues(
51	[Parameter(Required = true, Description = "The new first value of the chain. All the chain will be updated based on this value")] string newValue,
52	[Parameter(Description = "Value which have some kind of relation with -newVal \n Together with -newVal updates all the values based on the" +
53	"-newVal and another position specified on -valRelation parameter (basically starts with (newVal-valRelation) ) Is especially useful when" +
54	"updating multiple related chains (on different files), like multiple objects from one position to another. Don't use with -filename, because" +
55	"it will only update one file. \nExample: xmlTools.exe -newVal \"1 1 1\" -valRelation \"4 4 4\" -valElement Translation -valParentElement" +
56	"OBANKeyFrame")] string valRelation,
57	[Parameter(Description = "Only update specific positions. Positions starts with 0, separted multiple positions with space. Example: valPositions=0 1 4")] [MoreThan(-1)] string valPositions
58	)
59	{
60	initialChecks();
61	XmlTools myTools = new XmlTools(globalElement, globalParentElement, globalNoBackups);
62	List<string> filesToProcess = getFilesToProcess(globalFileName);
63	foreach (string currentFile in filesToProcess)
64	{
65	myTools.changeValue(currentFile, newValue, valRelation, valPositions);
66	}
67	printProcessedMessage(filesToProcess.Count, MethodBase.GetCurrentMethod().Name);
68	}
69
70	[Verb(Description = "Inverts a chain (like an OBAN animation). Example: xmlTools.exe -filename OBANheli_rotorblades08.xml -invert -valElement Translation -valParentElement OBANKeyFrame (inverts translation chain)")]
71	public static void Invert()
72	{
73	initialChecks();
74	XmlTools myTools = new XmlTools(globalElement, globalParentElement, globalNoBackups);
75	List<string> filesToProcess = getFilesToProcess(globalFileName);
76	foreach (string currentFile in filesToProcess)
77	{
78	myTools.invert(currentFile); //Inverting the element order
79	}
80	printProcessedMessage(filesToProcess.Count, MethodBase.GetCurrentMethod().Name);
81	}
82
83	[Verb]
84	public static void replaceValue(
85	[Parameter(Required = true, Description = "Old value to replace in Element.")] string oldValue,
86	[Parameter(Required = true, Description = "New value to replace in Element.")] string newValue
87	)
88	{
89	XmlTools myTools = new XmlTools(globalElement, globalParentElement, globalNoBackups);
90	List<string> filesToProcess = getFilesToProcess(globalFileName);
91	foreach (string currentFile in filesToProcess)
92	{
93	myTools.replaceValue(currentFile, oldValue, newValue);
94	}
95	printProcessedMessage(filesToProcess.Count, MethodBase.GetCurrentMethod().Name);
96	}
97
98	[Verb]
99	public static void replaceAll(
100	[Parameter(Required = true, Description = "Value to replace in Element. Replace all values of a element by another value.")] string value,
101	[Parameter(Description = "Only replace specific positions. Positions starts with 0, separted multiple positions with space. Example: valPositions=0 1 4")] [MoreThan(-1)] string valPositions
102	)
103	{
104	initialChecks();
105	XmlTools myTools = new XmlTools(globalElement, globalParentElement, globalNoBackups);
106	List<string> filesToProcess = getFilesToProcess(globalFileName);
107	foreach (string currentFile in filesToProcess)
108	{
109	if (valPositions != null)
110	{
111	myTools.replaceAll(currentFile, value, valPositions);
112	}
113	else
114	{
115	myTools.replaceAll(currentFile, value);
116	}
117	}
118	printProcessedMessage(filesToProcess.Count, MethodBase.GetCurrentMethod().Name);
119	}
120
121	/// <summary>
122	/// Patch in files can be used with wildcard or empty filename instead
123	/// </summary>
124	/// <param name="filename"></param>
125	[Verb]
126	public static void patchFile(
127	[Parameter(Description = "Force the specified patch to run in specified files")] string forceInFiles
128	)
129	{
130	XmlPatch myPatch;
131
132	if (forceInFiles != "")
133	{
134	myPatch = new XmlPatch(globalFileName, forceInFiles, globalNoBackups);
135	}
136	else
137	{
138	myPatch = new XmlPatch(globalFileName, globalNoBackups);
139	}
140
141	myPatch.startPatch();
142	}
143
144	[Verb]
145	public static void version()
146	{
147	Console.WriteLine("xmlTools v" + Program.toolsVersion);
148	Console.WriteLine("\nWritten by s10k");
149	}
150
151	// Global Parameters
152	[Global(Description = "Filename to apply the operations (with patchFile specifies the patch filename). Wildcards accepted for multiple files. No filename = search all .xml files in current path.")]
153	public static void fileName(
154	[Parameter(Required = true)] string filename // xml filename. Wildcards accepted.
155	)
156	{
157	globalFileName = filename;
158	}
159
160	[Global(Description = "Element to apply the operation.")]
161	public static void element(
162	[Parameter(Required = true)] string element
163	)
164	{
165	globalElement = element;
166	}
167
168	[Global(Description = "Parent of the Element to apply the operation.")]
169	public static void parElement(
170	[Parameter(Required = true)] string parentElement
171	)
172	{
173	globalParentElement = parentElement;
174	}
175
176	[Global(Description = "Don't make backup of the files modified. Improves the overall program processing performance.")]
177	public static void noBackups()
178	{
179	globalNoBackups = true;
180	}
181
182	// Private functions
183	private static List<String> getFilesToProcess(String filename)
184	{
185	List<String> filesToProccess = new List<String>();
186
187	if (filename == "") // No filename? Process everything xml file found.
188	{
189	List<string> allXmlFiles = Util.getAllXmlFiles();
190	foreach (String file in allXmlFiles)
191	{
192	filesToProccess.Add(file);
193	}
194	}
195	else if (Util.containsWildcard(filename)) // Contains wildcards? Get all files that match it.
196	{
197	List<string> matchingWildcardFiles = Util.getXmlFilesWildcard(filename);
198	foreach (String file in matchingWildcardFiles)
199	{
200	filesToProccess.Add(file);
201	}
202	}
203	else // Add the file specified
204	{
205	if (System.IO.File.Exists(filename))
206	{
207	filesToProccess.Add(filename);
208	}
209	else
210	{
211	Program.printAppError(Program.appErrors.FILE_NOT_FOUND, "The file specified: " + filename + " doesn't exists.", true);
212	}
213	}
214	return filesToProccess;
215	}
216
217	private static void printProcessedMessage(int count, string methodName)
218	{
219	Console.WriteLine(count + " files processed with " + methodName + " command.");
220	}
221
222	private static void initialChecks()
223	{
224	if (String.IsNullOrEmpty(globalElement.Trim()))
225	{
226	Program.printAppError(Program.appErrors.ELEMENT_NOT_FOUND, "You must specify the element parameter where the operations will be processed.", true);
227	}
228
229	}
230	}
231	}