public static void Save(Command command, Trimmer trimmer, string assemblyName, string fileName)
{
AssemblyBuilder assembly;
Compiler compiler;
MethodBuilder method;
ModuleBuilder module;
TypeBuilder program;
#if NETSTANDARD1_5 || NETSTANDARD2_0
assembly = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName(assemblyName), AssemblyBuilderAccess.Run);
module = assembly.DefineDynamicModule(fileName);
#else
assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName(assemblyName), AssemblyBuilderAccess.RunAndSave);
module = assembly.DefineDynamicModule(assemblyName, fileName);
#endif
program = module.DefineType("Program", TypeAttributes.Public);
method = program.DefineMethod("Main", MethodAttributes.Public | MethodAttributes.Static, typeof(Value), new [] { typeof(Storage), typeof(IList <Value>), typeof(IStore), typeof(TextWriter) });
compiler = new Compiler(method.GetILGenerator(), trimmer);
compiler.Compile(Enumerable.Empty <string> (), command);
#if NETSTANDARD1_5 || NETSTANDARD2_0
program.CreateTypeInfo();
#else
program.CreateType();
assembly.Save(fileName);
#endif
}
private INode CompileCommand(Command command, Trimmer trimmer)
{
List <KeyValuePair <IEvaluator, INode> > branches;
List <INode> nodes;
switch (command.Type)
{
case CommandType.AssignFunction:
return(new FunctionAssignNode(command.Name, command.Arguments, this.CompileCommand(command.Body, trimmer), command.Mode));
case CommandType.AssignRender:
return(new RenderAssignNode(command.Name, this.CompileCommand(command.Body, trimmer), command.Mode));
case CommandType.AssignValue:
return(new ValueAssignNode(command.Name, this.CompileExpression(command.Operand), command.Mode));
case CommandType.Composite:
nodes = new List <INode> ();
for (; command.Type == CommandType.Composite; command = command.Next)
{
nodes.Add(this.CompileCommand(command.Body, trimmer));
}
nodes.Add(this.CompileCommand(command, trimmer));
return(new CompositeNode(nodes));
case CommandType.Dump:
return(new DumpNode(this.CompileExpression(command.Operand)));
case CommandType.Echo:
return(new EchoNode(this.CompileExpression(command.Operand)));
case CommandType.For:
return(new ForNode(this.CompileExpression(command.Operand), command.Key, command.Name, this.CompileCommand(command.Body, trimmer), command.Next != null ? this.CompileCommand(command.Next, trimmer) : null));
case CommandType.If:
branches = new List <KeyValuePair <IEvaluator, INode> > ();
for (; command != null && command.Type == CommandType.If; command = command.Next)
{
branches.Add(new KeyValuePair <IEvaluator, INode> (this.CompileExpression(command.Operand), this.CompileCommand(command.Body, trimmer)));
}
return(new IfNode(branches, command != null ? this.CompileCommand(command, trimmer) : null));
case CommandType.Literal:
return(new LiteralNode(trimmer(command.Text)));
case CommandType.Return:
return(new ReturnNode(this.CompileExpression(command.Operand)));
case CommandType.While:
return(new WhileNode(this.CompileExpression(command.Operand), this.CompileCommand(command.Body, trimmer)));
default:
return(new LiteralNode(string.Empty));
}
}
private void Save(IEnumerable <string> arguments, Command command, Trimmer trimmer, string name)
{
AssemblyBuilder assembly;
Compiler compiler;
MethodBuilder method;
ModuleBuilder module;
TypeBuilder program;
#if CORECLR
assembly = AssemblyBuilder.DefineDynamicAssembly(new AssemblyName(name), AssemblyBuilderAccess.Run);
module = assembly.DefineDynamicModule(name);
#else
assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName(name), AssemblyBuilderAccess.RunAndSave);
module = assembly.DefineDynamicModule(name, name + ".dll");
#endif
program = module.DefineType("Program", TypeAttributes.Public);
method = program.DefineMethod("Main", MethodAttributes.Public | MethodAttributes.Static, typeof(Value), new [] { typeof(Storage), typeof(IList <Value>), typeof(IStore), typeof(TextWriter) });
compiler = new Compiler(method.GetILGenerator(), trimmer);
compiler.Compile(arguments, command);
#if CORECLR
program.CreateTypeInfo();
#else
program.CreateType();
assembly.Save(name + ".dll");
#endif
}
static void Main(string[] args)
{
try
{
if (args.Length == 0)
{
throw new InvalidOperationException(
"No solution folder path was provided. Please provide a folder path as the first parameter to this executable.");
}
string path = args[0];
if (!Directory.Exists(path))
{
string message = string.Format("Solution folder path '{0}' doesn't exist.", path);
throw new InvalidOperationException(message);
}
var commandLineArgs = new List <string>(
from string arg in args
select arg.ToLower(CultureInfo.CurrentCulture));
commandLineArgs.RemoveAt(0);
IDiscoverPlugins pluginDiscoverer = new DiscoverPluginsInAssemblyDirectory( );
Trimmer.TrimTree(
new TaskCollection(pluginDiscoverer.DiscoveredPlugins, commandLineArgs),
path);
}
catch (Exception exception)
{
System.Console.WriteLine(getExceptionMessage(exception));
}
}
private void buttonTrim_Click(object sender, EventArgs e)
{
if (!Trimmer.IsTrimming)
{
Trimmer.IsTrimming = true;
buttonTrimCancel.Visible = true;
buttonTrim.Text = "Start Time";
labelCurrentTime.ForeColor = Color.LightGreen;
}
else if (Trimmer.IsTrimming && Trimmer.StartTime == null)
{
buttonTrim.Text = "End Time";
labelCurrentTime.ForeColor = new System.Drawing.Color();
labelTotalTime.ForeColor = Color.LightGreen;
Trimmer.StartTime = AudioFile.CurrentTime;
}
else if (Trimmer.IsTrimming)
{
Trimmer.EndTime = AudioFile.CurrentTime;
Trimmer.SongFile = GetSongFileLocation(CurrentSong);
var outputSong = Trimmer.TrimAudio();
ResetTrimmingUI();
LoadStartupSong(outputSong, true);
}
}
private void ResetTrimmingUI()
{
labelCurrentTime.ForeColor = new System.Drawing.Color();
labelTotalTime.ForeColor = new System.Drawing.Color();
Trimmer.ResetTrimmer();
buttonTrim.Text = "Trim";
buttonTrimCancel.Visible = false;
}
public Compiler(ILGenerator generator, Trimmer trimmer)
{
this.constants = new List <Value> ();
this.generator = generator;
this.indices = new Dictionary <Value, int> ();
this.locals = new Dictionary <Type, Queue <LocalBuilder> > ();
this.trimmer = trimmer;
}
public Compiler(ILGenerator generator, Trimmer trimmer)
{
this.generator = generator;
this.locals = new Dictionary <Type, Queue <LocalBuilder> > ();
this.stringList = new List <string> ();
this.stringMap = new Dictionary <string, int> ();
this.trimmer = trimmer;
this.valueList = new List <Value> ();
this.valueMap = new Dictionary <Value, int> ();
}
public Function(IEnumerable <string> arguments, Command command, Trimmer trimmer)
{
Compiler compiler;
DynamicMethod method;
method = new DynamicMethod(string.Empty, typeof(Value), new [] { typeof(Storage), typeof(IList <Value>), typeof(IStore), typeof(TextWriter) }, this.GetType());
compiler = new Compiler(method.GetILGenerator(), trimmer);
this.storage = compiler.Compile(arguments, command);
this.renderer = (Renderer)method.CreateDelegate(typeof(Renderer));
}
public void Trim_GivenComplexStringWithSpacesInBetween_ShouldReturnStringWithoutSpaces()
{
// Arrange
var input = "ab\r\n cd \r\n";
var expectedOutput = "ab\r\ncd\r\n";
// Act
var actualOutput = Trimmer.Trim(input);
// Assert
Assert.AreEqual(expectedOutput, actualOutput);
}
public override void Run()
{
try
{
ControlInput.IsOpenLoop = true;
Settings settings = Settings.GetInstance();
settings.GetDefaultSettings();
logger.Info($"Ligral (R) Simulation Engine version {Program.Version}.\nCopyright (C) Ligral Tech. All rights reserved.");
PluginLoader pluginLoader = new PluginLoader();
pluginLoader.Load();
if (IsJsonFile is bool isJsonFile && isJsonFile)
{
JsonLoader jsonLoader = new JsonLoader();
jsonLoader.Load(FileName);
}
else
{
Interpreter interpreter = Interpreter.GetInstance(FileName);
interpreter.Interpret();
}
Inspector inspector = new Inspector();
List <Model> routine = inspector.Inspect(ModelManager.ModelPool);
string problemName = Path.GetFileNameWithoutExtension(FileName);
Problem problem = new Problem(problemName, routine);
Trimmer trimmer = new Trimmer();
if (settings.TrimmerConfiguration != null)
{
trimmer.Configure(settings.TrimmerConfiguration);
}
else
{
logger.Warn("No trimming configuration is set. The model will be trimmed at zero.");
}
settings.ApplySetting();
trimmer.GetCondition();
trimmer.Trim(problem);
if (OutputFile is string outputFile)
{
try
{
File.WriteAllText(outputFile, trimmer.ToString());
}
catch (Exception e)
{
logger.Prompt(trimmer.ToString());
throw logger.Error(new LigralException($"Cannot write to {outputFile}, got error: {e.Message}"));
}
}
else
{
logger.Prompt(trimmer.ToString());
}
}
public void Trim_GivenAbc_ShouldReturnAbc()
{
// Arrange
var input = "abc";
var expectedOutput = "abc";
// Act
var actualOutput = Trimmer.Trim(input);
// Assert
Assert.AreEqual(expectedOutput, actualOutput);
}
public static BitArray Decompose(IDemodulator demodulator, WavFile wavFile)
{
var samples = wavFile.Data.ToShortArray();
samples = new Trimmer().Trim(samples);
var hpFilter = new HighPassFilter(
cutoffFrequency: demodulator.CarrierFrequency / 2.0,
sampleRate: demodulator.SampleRate
);
// samples = hpFilter.FilterSamples(samples);
samples = new Normalizer().PeakNormalize(samples);
// samples = new PhaseFixer().FixPhase(samples, (int)demodulator.SampleRate, 2);
//
var soundBytes = samples.ToByteArray();
var processedSound = new WavFile(wavFile.SampleRate, soundBytes);
using (FileStream fs = new FileStream($"PROCESSED.wav", FileMode.Create)) {
BinaryWriter bw = new BinaryWriter(fs);
bw.Write(processedSound.ToBytes());
}
//
var waveDecomposer = new WaveDecomposer(demodulator);
var dataSegments = waveDecomposer.FindDataSegments(samples);
BitArray data = null;
foreach (var segment in dataSegments)
{
var bits = demodulator.ReadBits(segment.DataSamples, segment.ZerosValue, segment.OnesValue, segment.BytesToRead);
if (data == null)
{
data = new BitArray(bits);
}
else
{
data = data.MergeWith(bits);
}
}
return(data);
}
static void Main(string[] args)
{
var a = new A();
var b = new B();
Trimmer t = a.Trim;
t += b.Trim;
Console.WriteLine($"Delagate target is of type {((MulticastDelegate)t).Target.GetType().Name}");
foreach (Delegate d in t.GetInvocationList())
{
Console.WriteLine($"Delagate target from invocation list is of type {d.Target.GetType().Name}");
}
}
static void Main()
{
/**
* Application tools
*/
var config = new ConfigSerialization().Model;
var youtube = new YoutubeHandler(config);
var trimmer = new Trimmer(config);
/**
* MVC
*/
var model = new ConsoleModel();
var view = new ConsoleView();
var controller = new ConsoleController(model, view);
model.Setup(config, youtube, trimmer);
view.OnReady();
}
public void DrawTrimMap(WriteableBitmap bitmap)
{
if (Trimmer == null)
{
return;
}
for (var y = 0; y < PreviewSize; ++y)
{
for (var x = 0; x < PreviewSize; ++x)
{
var u = ((double)x) / PreviewSize;
var v = ((double)y) / PreviewSize;
var color = Trimmer.VerifyParametrisation(u, v)
? Colors.Green
: Colors.LightGray;
bitmap.SetPixel(Offset + x, Offset + y, color);
}
}
}
/// <summary>
/// This executes the trimming of reads as a background thread.
/// </summary>
/// <param name="sender">BackgoundWorker instance</param>
/// <param name="e">DoWorkEvent arguments</param>
private void DoTrimReads(object sender, DoWorkEventArgs e)
{
BackgroundWorker worker = sender as BackgroundWorker;
if (worker != null)
{
try
{
Trimmer myTrimmer = null;
FilterToolArgs args = null;
if (e.Argument is TrimByLengthArgs)
{
args = e.Argument as TrimByLengthArgs;
myTrimmer = (e.Argument as TrimByLengthArgs).trimmer;
// If possible, verify that the trim length is not larger than the maximum read length, if it
// is known (e.g. if a QC analysis was run just before Trim was called).
if ((myTrimmer as TrimByLength).TrimLength >= 1)
{
MessageBoxResult tooLargeReadLength = TryConfirmLargeReadLength(args.InputInfo.Filename,
Convert.ToInt64(Math.Round((myTrimmer as TrimByLength).TrimLength)));
if (tooLargeReadLength == MessageBoxResult.Cancel)
{
e.Cancel = true;
return;
}
}
}
else if (e.Argument is TrimByQualityArgs)
{
args = e.Argument as TrimByQualityArgs;
myTrimmer = (e.Argument as TrimByQualityArgs).trimmer;
}
else
{
args = e.Argument as TrimByRegexArgs;
myTrimmer = (e.Argument as TrimByRegexArgs).trimmer;
}
myTrimmer.Worker = worker;
myTrimmer.WorkerArgs = e;
myTrimmer.TrimAll();
// Report results
StringBuilder report = new StringBuilder();
report.AppendLine(string.Format(Resource.TrimReport, myTrimmer.TrimCount, myTrimmer.Counted));
report.AppendLine(string.Format(Resource.DiscardReport, myTrimmer.DiscardCount, myTrimmer.Counted));
this.OpenInExplorer(args.OutputFilename);
e.Result = report.ToString();
}
catch (ArgumentNullException ex)
{
e.Cancel = true;
if (worker.CancellationPending)
{
return;
}
MessageBox.Show(ex.TargetSite + ": " + ex.Message);
}
catch (Exception ex)
{
e.Cancel = true;
if (worker.CancellationPending)
{
return;
}
MessageBox.Show(ex.TargetSite + ": " + ex.Message);
}
}
}
public override void Trim()
{
bool fcs = FCS.enabled;
FCS.enabled = false;
bool mainDynamicInflow = MainRotor.useDynamicInflow;
MainRotor.useDynamicInflow = false;
bool tailDynamicInflow = TailRotor.useDynamicInflow;
TailRotor.useDynamicInflow = false;
bool engineModel = UseEngineModel;
UseEngineModel = false;
bool gravity = Gravity.Enabled;
Gravity.Enabled = true;
Vector <double> initialGuess = Vector <double> .Build.DenseOfArray(new double[] {
Collective, LatCyclic, LongCyclic, Pedal, Attitude[0], Attitude[1]
});
try {
Trimmer.Trim(
initialGuess,
Vector <double> .Build.DenseOfArray(new double[] { 1e-3, 1e-3, 1e-3, 1e-3, 1e-3, 1e-3 }),
delegate(Vector <double> x) {
// Set input variables from input vector, x=(t0 ts tc tp phi theta)
Collective = x[0];
LongCyclic = x[1];
LatCyclic = x[2];
Pedal = x[3];
Attitude = Vector <double> .Build.DenseOfArray(new double[] { x[4], x[5], Attitude[2] });
// Update
for (int i = 0; i < 10; i++)
{
Update(0.01);
}
// Set output vector
return(Vector <double> .Build.DenseOfArray(new double[] {
Force[0], Force[1], Force[2],
Torque[0], Torque[1], Torque[2]
}));
}
);
FCS.TrimCollective = Collective;
FCS.TrimLongCyclic = LongCyclic;
FCS.TrimLatCyclic = LatCyclic;
FCS.TrimPedal = Pedal;
FCS.TrimAttitude = Attitude.Clone();
if (FCS.trimControl)
{
FCS.CollectiveInput = 0;
FCS.LongInput = 0;
FCS.LatInput = 0;
FCS.PedalInput = 0;
}
} finally {
FCS.enabled = fcs;
MainRotor.useDynamicInflow = mainDynamicInflow;
TailRotor.useDynamicInflow = tailDynamicInflow;
UseEngineModel = engineModel;
Gravity.Enabled = gravity;
}
}
public TrimmerTest()
{
_config = new ConfigSerialization().Model;
_ytHandler = new YoutubeHandler(_config);
_trimmer = new Trimmer(_config);
}
public static void RunBclRewriter(string[] args)
{
#region Parse the command-line arguments.
if (!Parser.ParseArgumentsWithUsage(args, typeof(Program)))
{
throw new UsageException();
}
#endregion
#region Figure out paths
s_assemblyName = Path.GetFullPath(s_assemblyName); // this has to be specified
string outputBaseName = null;
if (!String.IsNullOrEmpty(s_output))
{
s_output = Path.GetFullPath(s_output);
outputBaseName = Path.GetFileNameWithoutExtension(s_output);
}
else
{
s_output = Path.Combine(Directory.GetCurrentDirectory(), Path.GetFileNameWithoutExtension(s_assemblyName) + ".small" + Path.GetExtension(s_assemblyName));
outputBaseName = s_assemblyName;
}
string pdbSourceFile = Path.ChangeExtension(s_assemblyName, "pdb");
string outputPdb = Path.ChangeExtension(s_output, "pdb");
string outputFolder = Path.GetDirectoryName(s_output);
// if the user wants to do an in-place rewrite, we copy the file to a temp file
if (s_output == s_assemblyName)
{
String tempPath = s_assemblyName + TempExtension;
String tempPdbPath = pdbSourceFile + TempExtension;
File.Copy(s_assemblyName, tempPath, true);
s_assemblyName = tempPath;
if (File.Exists(pdbSourceFile))
{
File.Copy(pdbSourceFile, tempPdbPath, true);
pdbSourceFile = tempPdbPath;
}
}
if (!Directory.Exists(outputFolder))
{
Directory.CreateDirectory(outputFolder);
}
#endregion
#region Load input files
HostEnvironment host = new HostEnvironment(new NameTable(), s_assemblyDependencyPaths, s_referencedAssemblies);
IAssembly /*?*/ assembly = host.LoadUnitFrom(s_assemblyName) as IAssembly;
// TODO: Handle multimodule assemblies
if (assembly == null || assembly == Dummy.Assembly)
{
throw new UsageException(args[0] + " is not a PE file containing a CLR assembly, or an error occurred when loading it.");
}
if (!File.Exists(s_includeListFile))
{
throw new UsageException(String.Format("ERROR: Can't find code model file '{0}'", s_includeListFile));
}
ThinModel model = new ThinModel(new ThinnerOptions(host, new AssemblyIdentity[] { assembly.AssemblyIdentity }));
model.LoadModel(s_includeListFile, new ModelReaderOptions(s_platform, s_architecture, s_flavor, s_treatFxInternalAsPublic, s_defines));
#endregion
#region Calculate api closure.
ConsoleTimer.StartTimer("Calculating api closure");
model.LoadMetadataFrom(assembly);
ThinModel apiClosure = model.CalculateApiClosure();
if (s_keepTempFiles)
{
apiClosure.SaveModel(Path.ChangeExtension(s_output, ".apiClosure.xml"));
}
ConsoleTimer.EndTimer("Calculating api closure");
#endregion
#region Calculate impl closure.
ConsoleTimer.StartTimer("Calculating implementation closure");
apiClosure.LoadMetadataFrom(assembly);
ThinModel implClosure = apiClosure.CalculateImplementationClosure(true, FieldOptions.KeepAll);
if (s_keepTempFiles)
{
implClosure.SaveModel(Path.ChangeExtension(s_output, ".implClosure.xml"));
}
ConsoleTimer.EndTimer("Calculating implementation closure");
#endregion
#region Trim.
ConsoleTimer.StartTimer("Trimming assembly");
IncludeSet includeSet = new IncludeSet();
includeSet.LoadFrom(implClosure);
var copier = new MetadataDeepCopier(host);
Assembly copiedAssembly = copier.Copy(assembly);
Trimmer trimmer = new Trimmer(includeSet, true, false, true, host, s_removeSerializable);
trimmer.RewriteChildren(copiedAssembly);
Assembly mutableAssembly = copiedAssembly;
assembly = mutableAssembly;
ConsoleTimer.EndTimer("Trimming assembly");
#endregion
#region Update assembly name.
ConsoleTimer.StartTimer("Updating assembly name");
// If the output assembly name is different, update the internal assembly name to match.
AssemblyIdentity originalAssemblyIdentity = mutableAssembly.AssemblyIdentity;
if (!outputBaseName.Equals(originalAssemblyIdentity.Name.ToString(), StringComparison.OrdinalIgnoreCase))
{
mutableAssembly.Name = host.NameTable.GetNameFor(outputBaseName);
mutableAssembly.ModuleName = mutableAssembly.Name;
}
// If we changed the assembly identity, update references to it.
if (!mutableAssembly.AssemblyIdentity.Equals(originalAssemblyIdentity))
{
trimmer.UpdateAssemblyReferences(originalAssemblyIdentity, mutableAssembly.AssemblyIdentity);
}
ConsoleTimer.EndTimer("Updating assembly name");
#endregion
#region Write out the assembly
ConsoleTimer.StartTimer("Writing assembly");
PdbReader pdbReader = null;
PdbWriter pdbWriter = null;
if (File.Exists(pdbSourceFile))
{
Stream pdbStream = File.OpenRead(pdbSourceFile);
pdbReader = new PdbReader(pdbStream, host);
pdbWriter = new PdbWriter(outputPdb, pdbReader);
Console.WriteLine("Writing pdb: {0}", outputPdb);
}
Console.WriteLine("Writing assembly: {0}", s_output);
FileStream file = File.Create(s_output);
try
{
PeWriter.WritePeToStream(assembly, host, file, pdbReader, pdbReader, pdbWriter);
}
finally
{
if (file != null)
{
file.Dispose();
}
if (pdbWriter != null)
{
pdbWriter.Dispose();
}
}
ConsoleTimer.EndTimer("Writing assembly");
#endregion
}
/// <summary>
/// usage: SeqcosTrimmerUtil.exe [options] <input> <output>
/// </summary>
/// <param name="args">Command line arguments</param>
static void Main(string[] args)
{
Console.Error.WriteLine(SplashString());
CommandLineOptions myArgs = ProcessCommandLine(args);
#region Trimming
// Determine parser
InputSubmission input = new InputSubmission(myArgs.InputFile);
input.DetermineParserUtil();
// Create a sequence filteredFormatter object
ISequenceFormatter filteredFormatter;
ISequenceFormatter discardedFormatter = null;
// If the format is FASTA, then output will be FASTA.
// Everything else (assuming quality scores are available)
// will be outputted to FASTQ.
if (input.Parser is FastAParser)
{
if (myArgs.TrimByQuality > 0)
{
Console.Error.WriteLine("Cannot trim by quality using a FASTA file.");
Environment.Exit(-1);
}
if (myArgs.DiscardedFile != null)
{
discardedFormatter = new FastAFormatter(myArgs.DiscardedFile);
}
filteredFormatter = new FastAFormatter(myArgs.OutputFile);
}
else
{
if (myArgs.DiscardedFile != null)
{
discardedFormatter = new FastQFormatter(myArgs.DiscardedFile);
}
filteredFormatter = new FastQFormatter(myArgs.OutputFile);
}
// Initialize a Trimmer object
Trimmer myTrimmer = null;
// By now, we should have sanity checked the command line arguments. So we should be able to
// figure out what mode is being used simply by checking the properties.
if (myArgs.TrimByLength > 0)
{
Console.Error.WriteLine("Trimming reads to length {0}", myArgs.TrimByLength);
myTrimmer = new TrimByLength(input.Parser, filteredFormatter, discardedFormatter, myArgs.TrimByLength, myArgs.Left);
}
else if (myArgs.TrimByQuality > 0)
{
if (!(input.Parser is FastQParser))
{
throw new ArgumentException("Input file must be in FASTQ format.");
}
Console.Error.WriteLine("Trimming reads based on quality score {0}", myArgs.TrimByQuality);
myTrimmer = new TrimByQuality(input.Parser, filteredFormatter, discardedFormatter, (byte)myArgs.TrimByQuality, myArgs.Left, (int)Math.Round(myArgs.TrimByLength));
}
else if (myArgs.TrimByRegex != null)
{
Console.Error.WriteLine("Trimming reads based on the regular expression pattern {0}", myArgs.TrimByRegex);
myTrimmer = new TrimByRegex(input.Parser, filteredFormatter, discardedFormatter, myArgs.TrimByRegex);
}
else
{
// Should never reach this line.
Console.Error.WriteLine("Invalid trim mode. Use '-l' or '-q'.");
Environment.Exit(-1);
}
myTrimmer.TrimAll();
#endregion
if (myArgs.Verbose)
{
Console.Error.WriteLine("Trimmed {0}/{1} sequences.", myTrimmer.TrimCount, myTrimmer.Counted);
Console.Error.WriteLine("Discarded {0}/{1} sequences.", myTrimmer.DiscardCount, myTrimmer.Counted);
Console.Error.WriteLine("Output saved in {0}.", Path.GetFullPath(myArgs.OutputFile));
Console.Error.WriteLine("Warning: Output may not be in the same order as the original input.");
}
input.Parser.Close();
filteredFormatter.Close();
if (discardedFormatter != null)
{
discardedFormatter.Close();
}
}
public virtual void Setup(ConfigModel config, YoutubeHandler youtube, Trimmer trimmer)
{
Config = config;
Youtube = youtube;
TrimTool = trimmer;
}
public DateTimeOffsetInstruction(Trimmer trimmer, StandardFormat format)
{
_trimmer = trimmer;
_format = format;
}
