private string SolveExpressionPrevValues()
{
string exp = _expression;
foreach (Function func in _functions)
{
switch (func.Type)
{
case Function.FunctionType.SequentialIntFunction:
SequentialIntFunction sif = (SequentialIntFunction)func;
exp = exp.Replace(sif.Name, sif.PrevVal().ToString().PadLeft(sif.Padding, '0'));
break;
case Function.FunctionType.SequentialCharFunction:
SequentialCharFunction scf = (SequentialCharFunction)func;
exp = exp.Replace(scf.Name, scf.PrevVal().ToString());
break;
case Function.FunctionType.ConstantTextFunction:
ConstantTextFunction ctf = (ConstantTextFunction)func;
exp = exp.Replace(ctf.Name, ctf.Constant);
break;
case Function.FunctionType.ConstantFileFunction:
ConstantFileFunction cff = (ConstantFileFunction)func;
exp = exp.Replace(cff.Name, cff.NextVal());
break;
case Function.FunctionType.ConstantFileFunctionEx:
ConstantFileFunctionEx cffe = (ConstantFileFunctionEx)func;
exp = exp.Replace(cffe.Name, cffe.NextVal());
break;
case Function.FunctionType.ConstantFileExtFunction:
ConstantFileExtFunction cfef = (ConstantFileExtFunction)func;
exp = exp.Replace(cfef.Name, cfef.NextVal());
break;
}
}
return(exp);
}
public string SolveExpressionFromBeginning(int iteration)
{
string exp = _expression;
foreach (Function func in _functions)
{
switch (func.Type)
{
case Function.FunctionType.SequentialIntFunction:
SequentialIntFunction sif = (SequentialIntFunction)func;
exp = exp.Replace(sif.Name, sif.AllVals(iteration).Last <int>().ToString().PadLeft(sif.Padding, '0'));
break;
case Function.FunctionType.SequentialCharFunction:
SequentialCharFunction scf = (SequentialCharFunction)func;
exp = exp.Replace(scf.Name, scf.AllVals(iteration).Last <char>().ToString());
break;
case Function.FunctionType.ConstantTextFunction:
ConstantTextFunction ctf = (ConstantTextFunction)func;
exp = exp.Replace(ctf.Name, ctf.Constant);
break;
case Function.FunctionType.ConstantFileFunction:
ConstantFileFunction cff = (ConstantFileFunction)func;
exp = exp.Replace(cff.Name, cff.NextVal());
break;
case Function.FunctionType.ConstantFileFunctionEx:
ConstantFileFunctionEx cffe = (ConstantFileFunctionEx)func;
exp = exp.Replace(cffe.Name, cffe.NextVal());
break;
case Function.FunctionType.ConstantFileExtFunction:
ConstantFileExtFunction cfef = (ConstantFileExtFunction)func;
exp = exp.Replace(cfef.Name, cfef.NextVal());
break;
}
}
return(exp);
}
public static Generalization[] Generate(string str1, string str2, TimeSpan time)
{
List <Generalization> gens = new List <Generalization>();
bool is_file;
string folder1, folder2;
if (Directory.Exists(str2))
{
is_file = false;
folder1 = Directory.GetParent(str1).FullName;
folder2 = Directory.GetParent(str2).FullName;
}
else
{
is_file = true;
folder1 = Path.GetDirectoryName(str1);
folder2 = Path.GetDirectoryName(str2);
}
// if both files have the same directory, then there might be a generalization
if (folder1 == folder2)
{
List <ConstantFileFunction> cff = new List <ConstantFileFunction>();
List <ConstantFileFunctionEx> cffe = new List <ConstantFileFunctionEx>();
List <SequentialIntFunction> sifs = new List <SequentialIntFunction>();
List <SequentialCharFunction> scfs = new List <SequentialCharFunction>();
List <ConstantFileExtFunction> cfef = new List <ConstantFileExtFunction>();
List <ConstantTextFunction> ctfs = new List <ConstantTextFunction>();
string expression = string.Empty;
string file1 = Path.GetFileNameWithoutExtension(str1);
string file2 = Path.GetFileNameWithoutExtension(str2);
List <string> extensions = new List <string>();
// detect which file extensions show the operations be applied to
if (is_file)
{
if (Path.GetExtension(str1) == Path.GetExtension(str2) && Path.GetExtension(str1) != string.Empty)
{
extensions.Add(Path.GetExtension(str2));
}
extensions.Add(".*");
}
// SequentialIntFunction
if (SequentialIntFunction.Generate(file1, file2, out expression, out sifs))
{
gens.Add(new FileDeleteGeneralization(expression, sifs.ToArray(), str2, time, 2));
}
// SequentialCharFunction
if (SequentialCharFunction.Generate(file1, file2, out expression, out scfs))
{
gens.Add(new FileDeleteGeneralization(expression, scfs.ToArray(), str2, time, 2));
}
// ConstantFileFunction
if (ConstantFileFunction.Generate(file1, file2, folder2, extensions.ToArray(), out expression, out cff))
{
gens.Add(new FileDeleteGeneralization(expression, cff.ToArray(), str2, time, 2));
}
// ConstantFileFunctionEx
if (ConstantFileFunctionEx.Generate(file1, file2, folder2, extensions.ToArray(), out expression, out cffe))
{
gens.Add(new FileDeleteGeneralization(expression, cffe.ToArray(), str2, time, 2));
}
// ConstantFileExtFunction
if (ConstantFileExtFunction.Generate(folder2, extensions.ToArray(), out expression, out cfef))
{
gens.Add(new FileDeleteGeneralization(expression, cfef.ToArray(), str2, time, 2));
}
// ConstantTextFunction
if (ConstantTextFunction.Generate(file1, file2, out expression, out ctfs))
{
gens.Add(new FileDeleteGeneralization(expression, ctfs.ToArray(), str2, time, 2));
}
}
return(gens.ToArray());
}
public static bool Generate(string file1, string file2, string folder, string[] extensions, out string expression, out List <ConstantFileFunctionEx> functions)
{
expression = string.Empty;
functions = new List <ConstantFileFunctionEx>();
List <Pair <Pair <int, string>, Pair <int, string> > > diffs = Diff.DiffString(file1, file2);
if (diffs.Count > 0)
{
//int file1_last_token_beginning = 0, file2_last_token_beginning = 0;
string token = string.Empty;
HashSet <string> file1_tokens = new HashSet <string>();
HashSet <string> file2_tokens = new HashSet <string>();
HashSet <string> common_tokens = new HashSet <string>();
char[] splitter = new char[] { ' ', '_', '-', '.', '\'', ',' };
//// grab the constant tokens
//for (int i = 0; i < diffs.Count; i++)
//{
// Pair<Pair<int, string>, Pair<int, string>> diff = diffs[i];
// if (diff.First.First > file1_last_token_beginning)
// {
// token = file1.Substring(file1_last_token_beginning, diff.First.First - file1_last_token_beginning);
// file1_tokens.Add(token);
// }
// file1_last_token_beginning = diff.First.First + diff.First.Second.Length;
// if (diff.Second.First > file2_last_token_beginning)
// {
// token = file2.Substring(file2_last_token_beginning, diff.Second.First - file2_last_token_beginning);
// file2_tokens.Add(token);
// }
// file2_last_token_beginning = diff.Second.First + diff.Second.Second.Length;
//}
//if (file1_last_token_beginning < file1.Length)
//{
// token = file1.Substring(file1_last_token_beginning, file1.Length - file1_last_token_beginning);
// file1_tokens.Add(token);
//}
//if (file2_last_token_beginning < file2.Length)
//{
// token = file2.Substring(file2_last_token_beginning, file2.Length - file2_last_token_beginning);
// file2_tokens.Add(token);
//}
//// refine file1 tokens
//HashSet<string> refined_tokens = new HashSet<string>();
//foreach (string t in file1_tokens)
//{
// string[] ref_ts = t.Trim().Split(new char[] { ' ' });
// foreach (string ref_t in ref_ts)
// if (ref_t.Trim() != string.Empty)
// refined_tokens.Add(ref_t.ToLower());
//}
//file1_tokens = refined_tokens;
//// refine file2 tokens
//refined_tokens.Clear();
//foreach (string t in file2_tokens)
//{
// string[] ref_ts = t.Trim().Split(new char[] { ' ' });
// foreach (string ref_t in ref_ts)
// if (ref_t.Trim() != string.Empty)
// refined_tokens.Add(ref_t.ToLower());
//}
//file2_tokens = refined_tokens;
file1_tokens = new HashSet <string>(file1.Split(splitter, StringSplitOptions.RemoveEmptyEntries));
file2_tokens = new HashSet <string>(file2.Split(splitter, StringSplitOptions.RemoveEmptyEntries));
foreach (string token1 in file1_tokens)
{
foreach (string token2 in file2_tokens)
{
if (token1.ToLower() == token2.ToLower())
{
if (token1.Length > 1)
{
common_tokens.Add(token1.ToLower());
break;
}
}
}
}
// if there is more than one common token, there's a generalization
if (common_tokens.Count > 0)
{
string f_name = "§1";
expression = f_name;
ConstantFileFunctionEx cffe = new ConstantFileFunctionEx(f_name, common_tokens.ToArray <string>(), folder, extensions);
functions.Add(cffe);
}
}
if (functions.Count > 0)
{
return(true);
}
else
{
return(false);
}
}
