/// <summary>
/// if there is no conversion method between source and target units, creates one otherwise fails
/// </summary>
/// <param name="description"></param>
/// <param name="formula"></param>
/// <param name="source"></param>
/// <param name="target"></param>
/// <returns></returns>
public ConversionMethod CreateConversionMethod(string formula, string description, Unit source, Unit target)
{
Contract.Requires(!string.IsNullOrWhiteSpace(formula), "formula can not be empty");
Contract.Requires(formula.Contains("s"), "Formula must use \'s\' as the representative for the source unit");
Contract.Requires(source != null, "source unit can not be null");
Contract.Requires(source.Id >= 0, "source unit must be persisted before this call");
Contract.Requires(target != null, "target unit can not be null");
Contract.Requires(target.Id >= 0, "target unit must be persisted before this call");
Contract.Ensures(Contract.Result <ConversionMethod>() != null && Contract.Result <ConversionMethod>().Id >= 0, "No Conversion Method persisted!");
ConversionMethod cm = new ConversionMethod()
{
Formula = formula,
Description = description,
Source = source,
Target = target,
};
source.ConversionsIamTheSource.Add(cm);
target.ConversionsIamTheTarget.Add(cm);
using (IUnitOfWork uow = this.GetUnitOfWork())
{
IRepository <ConversionMethod> repoCM = uow.GetRepository <ConversionMethod>();
ConversionMethod temp = repoCM.Get(c => c.Source.Id == source.Id && c.Target.Id == target.Id).FirstOrDefault(); // change it to Count instead of Get
if (temp != null)
{
throw new Exception(string.Format("There is already a conversion method between {0} and {1} having [{2}] formula", cm.Source.Name, cm.Target.Name, cm.Formula));
}
repoCM.Put(cm);
uow.Commit();
}
return(cm);
}
public Conversion Add(Metric from, Metric to, ConversionMethod method)
{
Conversion conversion = new Conversion(from, to, method);
conversions.Add(conversion);
return(conversion);
}
public void CreateConversionsBetweenUnitsTest()
{
UnitManager um = new UnitManager();
try
{
var dummyDimension = um.DimensionRepo.Query().First();
Unit km = um.Create("KilometerTest", "KmTest", "This is the Kilometer", dummyDimension, MeasurementSystem.Metric);
Unit m = um.Create("MeterTest", "MTest", "This is the Meter", dummyDimension, MeasurementSystem.Metric);
ConversionMethod cm2 = um.CreateConversionMethod("s*1000", "Converts kilometer to meter", km, m);
ConversionMethod cm3 = um.CreateConversionMethod("s/1000", "Converts meter to kilometer", m, km);
km.ConversionsIamTheSource.First().Target.Should().BeEquivalentTo(m);
cm3.Source.Name.Should().BeEquivalentTo(m.Name);
cm3.Target.Name.Should().BeEquivalentTo(cm2.Source.Name);
// cleanup the DB.
um.DeleteConversionMethod(new List <ConversionMethod>()
{
cm2, cm3
});
um.Delete(new List <Unit>()
{
km, m
});
}
finally
{
um.Dispose();
}
}
/// <summary>
/// Adds a conversion rule to the system
/// </summary>
/// <param name="symbolfrom">A single unit symbol that is known in the system</param>
/// <param name="symbolto">A formula containing numbers and unit symbols defining the target units</param>
/// <param name="method">A delegate that does the actual conversion of an Exponential</param>
/// <returns></returns>
public Conversion AddConversion(string symbolfrom, string symbolto, ConversionMethod method)
{
Metric from = Metrics.ParseMetric(symbolfrom);
Metric to = Metrics.ParseMetric(symbolto);
return(Conversions.Add(from, to, method));
}
public override void Execute(string[] args)
{
string file = QuotationRemover(args[0]);
string ext = Path.GetExtension(file).ToLower();
string method = args.Length > 1 ? "." + args[1] : ext;
ConversionMethod converter = ConversionMethod.FindConvertor(method);
string outputFile = Path.GetFileNameWithoutExtension(file);
if (converter == null)
{
Console.WriteLine("These are not the formats we are looking for...");
}
else if (converter.Inputs.Contains(ext))
{
Convert(file, outputFile + converter.Outputs[0], converter, true);
}
else if (converter.Outputs.Contains(ext))
{
Convert(file, outputFile + converter.Inputs[0], converter, false);
}
else
{
Console.WriteLine("These are not the formats we are looking for...");
}
}
public AbstractColor this[ConversionMethod type]
{
get
{
switch (type)
{
case ConversionMethod.toCIELab:
return toCIELab();
case ConversionMethod.toCIELCh:
return toCIELCh();
case ConversionMethod.toCMY:
return toCMY();
case ConversionMethod.toCMYK:
return toCMYK();
case ConversionMethod.toHex:
return toHex();
case ConversionMethod.toHSV:
return toHSV();
case ConversionMethod.toRGB:
return toRGB();
case ConversionMethod.toXYZ:
return toXYZ();
case ConversionMethod.toYxy:
return toYxy();
default:
return toRGB();
}
}
}
private static void RunStringTrimTests(ConversionMethod <string, string> trimString)
{
Console.WriteLine("Testing {0}...", trimString.Method.Name);
ConversionTest(trimString, "AAA BBB AAA", "A B A");
ConversionTest(trimString, "ABC", "ABC");
Console.WriteLine("{0} is OK.", trimString.Method.Name);
}
private static void RunBinaryConversionTests(ConversionMethod <int, string> decToBin)
{
Console.WriteLine("Testing {0}...", decToBin.Method.Name);
ConversionTest(decToBin, 0, Convert.ToString(0, 2));
ConversionTest(decToBin, 1, Convert.ToString(1, 2));
ConversionTest(decToBin, 58, Convert.ToString(58, 2));
ConversionTest(decToBin, -58, Convert.ToString(-58, 2));
Console.WriteLine("{0} is OK.", decToBin.Method.Name);
}
public void AddConversion(SystemOfUnits system, string from, string formula, Exponential number)
{
Metric metricfrom = system.Metrics.ParseMetric(from);
Metric metricto = system.Metrics.ParseMetric(Parser.ToUnaryTokens(formula).NonNumerics());
if ((metricfrom != null) && (metricto != null))
{
ConversionMethod method = BuildConversion(formula, number);
system.Conversions.Add(metricfrom, metricto, method);
}
}
private static void ConversionTest <S, R>(ConversionMethod <S, R> method, S source, R expected)
{
R result = method.Invoke(source);
if (result.Equals(expected))
{
Console.WriteLine("OK: {0} -> {1}", source, result);
return;
}
string message = String.Format("FAIL: {0} -> {1}, but expected {2}", source, result, expected);
throw new Exception(message);
}
public static void Main(string[] args)
{
CompressionMethod.Load();
ConversionMethod.Load();
ArchiveMethod.Load();
Console.ForegroundColor = ConsoleColor.White;
Command root = new CommandRouter("", new Command[] {
new CompressCommand(),
new ConvertCommand(),
new PackCommand()
});
if (args.Length > 0)
{
root.Execute(args);
return;
}
while (true)
{
Console.Write("> ");
string junk = Console.ReadLine();
Stopwatch watch = new Stopwatch();
watch.Start();
try
{
root.Execute(junk.Split(' '));
}
catch (CommandParseException ex)
{
Console.WriteLine(ex.Message);
}
catch (Exception ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(ex.Message);
Console.ForegroundColor = ConsoleColor.White;
}
watch.Stop();
Console.WriteLine();
Console.WriteLine("Command took " + watch.ElapsedMilliseconds + "ms to execute.");
}
}
public ConversionMethod UpdateConversionMethod(ConversionMethod entity)
{
Contract.Requires(entity != null, "provided entity can not be null");
Contract.Requires(entity.Id >= 0, "provided entity must have a permant ID");
Contract.Ensures(Contract.Result <ConversionMethod>() != null && Contract.Result <ConversionMethod>().Id >= 0, "No entity is persisted!");
using (IUnitOfWork uow = this.GetUnitOfWork())
{
IRepository <ConversionMethod> repo = uow.GetRepository <ConversionMethod>();
repo.Merge(entity);
var merged = repo.Get(entity.Id);
repo.Put(merged);
uow.Commit();
}
return(entity);
}
private void GetConversionMethod()
{
bool swapRedBlue = false;
_conversionMethod = ConversionMethod.UnityScript;
//#if UNITY_4_3 || UNITY_4_2 || UNITY_4_1 || UNITY_4_0_1 || UNITY_4_0
#if !UNITY_3_5 && !UNITY_3_4 && !UNITY_3_3 && !UNITY_3_2 && !UNITY_3_1 && !UNITY_3_0
_conversionMethod = ConversionMethod.Unity4;
if (SystemInfo.graphicsDeviceVersion.StartsWith("Direct3D 11"))
{
swapRedBlue = true;
}
#elif UNITY_3_5 || UNITY3_4
if (SystemInfo.graphicsDeviceVersion.StartsWith("OpenGL"))
{
#if UNITY_3_4
_conversionMethod = ConversionMethod.Unity34_OpenGL;
#elif UNITY_3_5
_conversionMethod = ConversionMethod.Unity35_OpenGL;
#endif
}
else
{
swapRedBlue = true;
}
#else
_conversionMethod = ConversionMethod.UnityScript;
swapRedBlue = true;
#endif
if (swapRedBlue)
{
Shader.DisableKeyword("SWAP_RED_BLUE_OFF");
Shader.EnableKeyword("SWAP_RED_BLUE_ON");
}
else
{
Shader.DisableKeyword("SWAP_RED_BLUE_ON");
Shader.EnableKeyword("SWAP_RED_BLUE_OFF");
}
}
public AbstractColor this[ConversionMethod type]
{
get
{
switch (type)
{
case ConversionMethod.toCIELab:
return(toCIELab());
case ConversionMethod.toCIELCh:
return(toCIELCh());
case ConversionMethod.toCMY:
return(toCMY());
case ConversionMethod.toCMYK:
return(toCMYK());
case ConversionMethod.toHex:
return(toHex());
case ConversionMethod.toHSV:
return(toHSV());
case ConversionMethod.toRGB:
return(toRGB());
case ConversionMethod.toXYZ:
return(toXYZ());
case ConversionMethod.toYxy:
return(toYxy());
default:
return(toRGB());
}
}
}
private static void Convert(string file, string outputFile, ConversionMethod converter, bool to)
{
FileStream input, output;
try
{
input = new FileStream(file, FileMode.Open);
output = new FileStream(outputFile, FileMode.Create);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return;
}
try
{
if (to)
{
converter.ConvertTo(input, output);
}
else
{
converter.ConvertFrom(input, output);
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return;
}
finally
{
input.Close();
output.Close();
}
}
/// <summary>
/// Deletes the proveded conversion method, but does not touch the source and target units
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public bool DeleteConversionMethod(ConversionMethod entity)
{
Contract.Requires(entity != null, "provided unit can not be null");
Contract.Requires(entity.Id >= 0, "Id can not be empty");
using (IUnitOfWork uow = this.GetUnitOfWork())
{
IRepository <ConversionMethod> repoCM = uow.GetRepository <ConversionMethod>();
entity = repoCM.Reload(entity);
// remove all associations
entity.Source = null;
entity.Target = null;
//delete the entity
repoCM.Delete(entity);
// commit changes
uow.Commit();
}
// if any problem was detected during the commit, an exception will be thrown!
return(true);
}
public static ConversionMethod BuildConversion(string formula, Exponential number)
{
ParameterExpression param = Expression.Parameter(typeof(Exponential), "value");
Expression body = Expression.Multiply(param, Expression.Constant(number));
foreach (Unary u in Parser.ToUnaryTokens(formula).Numerics())
{
Exponential factor = u.Numeric();
if (u.Exponent == 1)
{
body = Expression.Multiply(body, Expression.Constant(factor));
}
else if (u.Exponent == -1)
{
body = Expression.Divide(body, Expression.Constant(factor));
}
}
Expression <ConversionMethod> expression = Expression.Lambda <ConversionMethod>(body, param);
ConversionMethod method = expression.Compile();
return(method);
}
public Conversion Add(Metric from, Metric to, ConversionMethod method)
{
Conversion conversion = new Conversion(from, to, method);
conversions.Add(conversion);
return conversion;
}
public Conversion(Metric from, Metric to, ConversionMethod method)
{
this.From = from;
this.To = to;
this.method = method;
}
/// <summary>
/// Constructor used to setup method and decimal value.
/// </summary>
/// <param name="val">Decimal value</param>
/// <param name="method">Conversion method (<seealso cref="ConversionMethod"/> enum) </param>
public BinaryUInt(uint val, ConversionMethod method = ConversionMethod.StandardMethod)
{
Method = method;
DecimalValue = val;
}
public Conversion(Metric from, Metric to, ConversionMethod method)
{
this.From = from;
this.To = to;
this.method = method;
}
private void GetConversionMethod()
{
bool swapRedBlue = false;
_conversionMethod = ConversionMethod.UnityScript;
#if AVPRO_UNITY_4_X
_conversionMethod = ConversionMethod.Unity4;
if (SystemInfo.graphicsDeviceVersion.StartsWith("Direct3D 11"))
swapRedBlue = true;
#elif UNITY_3_5 || UNITY3_4
if (SystemInfo.graphicsDeviceVersion.StartsWith("OpenGL"))
{
#if UNITY_3_4
_conversionMethod = ConversionMethod.Unity34_OpenGL;
#elif UNITY_3_5
_conversionMethod = ConversionMethod.Unity35_OpenGL;
#endif
}
else
{
swapRedBlue = true;
}
#else
_conversionMethod = ConversionMethod.UnityScript;
swapRedBlue = true;
#endif
if (swapRedBlue)
{
Shader.DisableKeyword("SWAP_RED_BLUE_OFF");
Shader.EnableKeyword("SWAP_RED_BLUE_ON");
}
else
{
Shader.DisableKeyword("SWAP_RED_BLUE_ON");
Shader.EnableKeyword("SWAP_RED_BLUE_OFF");
}
}
/// <summary>
/// Adds a conversion rule to the system
/// </summary>
/// <param name="symbolfrom">A single unit symbol that is known in the system</param>
/// <param name="symbolto">A formula containing numbers and unit symbols defining the target units</param>
/// <param name="method">A delegate that does the actual conversion of an Exponential</param>
/// <returns></returns>
public Conversion AddConversion(string symbolfrom, string symbolto, ConversionMethod method)
{
Metric from = Metrics.ParseMetric(symbolfrom);
Metric to = Metrics.ParseMetric(symbolto);
return Conversions.Add(from, to, method);
}
