/// <summary> Constructor</summary>
public Sequence(string sequence, string id, string description, SequenceType type)
: base()
{
this.aalist = sequence;
this.id = id;
this.description = description;
this.type = type;
}
public Sequence (List<ContentList> sequenceElements, SequenceType sequenceType)
{
this.sequenceType = sequenceType;
this.sequenceElements = sequenceElements;
foreach (var sequenceContentList in sequenceElements) {
AddContent (sequenceContentList);
}
}
/// <summary>
/// Initializes a new Sequence object with the given sequence type.
/// </summary>
/// <param name="seqType">The sequence type.</param>
public Sequence(SequenceType seqType)
{
SequenceType = seqType;
id = idSource;
++idSource;
executionState = SequenceExecutionState.NotYet;
}
public MultiplicationTableViewModel Create(SequenceType sequenceType, int tableSize)
{
if(tableSize <= 0)
{
throw new ArgumentOutOfRangeException("tableSize", "tableSize must be greater than zero");
}
ISequenceGenerator sequenceGenerator;
if (!sequenceGenerators.TryGetValue(sequenceType, out sequenceGenerator))
{
var msg = string.Format("No {0} has been registered for {1}.{2}", typeof(ISequenceGenerator).Name, typeof(SequenceType).Name, sequenceType);
throw new NotSupportedException(msg);
}
var sequence = sequenceGenerator.CreateSequence(tableSize);
var table = tableCalculator.CreateTable(sequence);
return new MultiplicationTableViewModel()
{
TableSize = tableSize,
Table = table
};
}
public byte[] GetNextSequence(SequenceType type, PropertyInt64 property)
{
return(GetSequence(type, (uint)property).NextBytes);
}
public SequenceModel SequenceModel(SequenceType type, StringBuilder str, int loadNumber, int inputNumber)
{
SequenceModel model = new SequenceModel();
if (str != null)
{
model.Str = str;
model.NextSequenceUrl = NextSequenceUrl(type, loadNumber + 1, inputNumber);
model.IsMoreResult = true;
}
else
{
model.IsMoreResult = false;
}
return model;
}
public SequenceAssignToVar(SequenceVariable destVar, SequenceType seqType)
: base(seqType)
{
DestVar = destVar;
}
public SequenceNAry(List<Sequence> sequences, bool choice, SequenceType seqType)
: base(seqType)
{
Sequences = sequences;
this.choice = choice;
}
public SequenceForFunction(SequenceVariable var, SequenceType sequenceType,
List<SequenceExpression> argExprs, Sequence seq,
List<SequenceVariable> variablesFallingOutOfScopeOnLeavingFor)
: base(seq, sequenceType)
{
Var = var;
ArgExprs = argExprs;
VariablesFallingOutOfScopeOnLeavingFor = variablesFallingOutOfScopeOnLeavingFor;
}
/// <summary>
/// Creates an action based on another action's sequence number
/// </summary>
/// <param name="sequenceType">Sequence table the action belongs to.</param>
/// <param name="id">Name of the action.</param>
/// <param name="condition">Any condition on the action.</param>
/// <param name="sequence">Sequence number for action</param>
/// <param name="before">Action this action should be sequenced before.</param>
/// <param name="after">Action this action should be sequenced after.</param>
public Action(SequenceType sequenceType, string id, string condition, int sequence, string before, string after)
{
this.sequenceType = sequenceType;
this.id = id;
this.condition = condition;
this.sequence = sequence;
this.before = before;
this.after = after;
}
/// <summary>
/// Creates an action with a specified sequence number.
/// </summary>
/// <param name="sequenceType">Sequence table the action belongs to.</param>
/// <param name="id">Name of the action.</param>
/// <param name="condition">Any condition on the action.</param>
/// <param name="sequence">Sequence number for action</param>
public Action(SequenceType sequenceType, string id, string condition, int sequence)
: this(sequenceType, id, condition, sequence, null, null)
{
}
/// <summary>
/// Converts a sequence type to the string table name for it.
/// </summary>
/// <param name="sequenceType">Sequence type to convert.</param>
/// <returns>String name of table for sequence type.</returns>
public static string SequenceTypeToString(SequenceType sequenceType)
{
return sequenceNames[(int)sequenceType];
}
public SequenceFieldMapper(string name, Func<ProcessingScope, IEnumerable> selector, SequenceType type = SequenceType.Path)
{
Name = name;
Selector = selector;
Type = type;
}
public byte[] GetCurrentSequence(SequenceType type, PropertyString property)
{
return(GetSequence(type, (uint)property).CurrentBytes);
}
public byte[] GetCurrentSequence(SequenceType type)
{
return(GetSequence(type, 0).CurrentBytes);
}
/// <summary>
/// Initializes a new instance of the SequenceSpecial class.
/// </summary>
/// <param name="special">The initial value for the "Special" flag.</param>
/// <param name="seqType">The sequence type.</param>
public SequenceSpecial(bool special, SequenceType seqType)
: base(seqType)
{
Special = special;
}
public SequenceUnary(Sequence seq, SequenceType seqType) : base(seqType)
{
Seq = seq;
}
/// <summary>
/// Populates the hashtable from the Xml reader.
/// </summary>
/// <param name="reader">Xml reader that contains serialized actions.</param>
private void ParseAction(XmlReader reader)
{
string id = null;
string condition = null;
int sequence = 0;
SequenceType[] sequenceTypes = new SequenceType[5];
int sequenceCount = 0;
while (reader.MoveToNextAttribute())
{
switch (reader.Name)
{
case "name":
id = reader.Value;
break;
case "condition":
condition = reader.Value;
break;
case "sequence":
sequence = Convert.ToInt32(reader.Value);
break;
case "AdminExecuteSequence":
if (Common.IsYes(reader.Value, null, reader.Name, null, null))
{
sequenceTypes[sequenceCount] = SequenceType.adminExecute;
++sequenceCount;
}
break;
case "AdminUISequence":
if (Common.IsYes(reader.Value, null, reader.Name, null, null))
{
sequenceTypes[sequenceCount] = SequenceType.adminUI;
++sequenceCount;
}
break;
case "AdvtExecuteSequence":
if (Common.IsYes(reader.Value, null, reader.Name, null, null))
{
sequenceTypes[sequenceCount] = SequenceType.advertiseExecute;
++sequenceCount;
}
break;
case "InstallExecuteSequence":
if (Common.IsYes(reader.Value, null, reader.Name, null, null))
{
sequenceTypes[sequenceCount] = SequenceType.installExecute;
++sequenceCount;
}
break;
case "InstallUISequence":
if (Common.IsYes(reader.Value, null, reader.Name, null, null))
{
sequenceTypes[sequenceCount] = SequenceType.installUI;
++sequenceCount;
}
break;
}
}
if (null == id)
{
throw new ApplicationException("cannot have null id attribute on action element");
}
else if (0 == sequence)
{
throw new ApplicationException("must have sequence attribute with value greater than zero on action element");
}
else if (0 == sequenceCount)
{
throw new ApplicationException("must have one sequence allowed on action element");
}
// now add all the sequences
for (int i = 0; i < sequenceCount; i++)
{
Action action = new Action(sequenceTypes[i], id, condition, sequence);
this.actions.Add(String.Concat(sequenceTypes[i].ToString(), id), action);
}
}
public SequenceBinary(Sequence left, Sequence right, bool random, bool choice, SequenceType seqType)
: base(seqType)
{
Left = left;
Right = right;
this.random = random;
this.choice = choice;
}
/// <summary>
/// Gets an action out of the table by action table and action name.
/// </summary>
/// <param name="sequenceType">Sequence the action belongs to.</param>
/// <param name="actionId">Name of the action to find.</param>
/// <value>Action matching description.</value>
public Action this[SequenceType sequenceType, string actionId]
{
get { return (Action)this.actions[String.Concat(sequenceType.ToString(), actionId)]; }
}
public SequenceDefinition(SequenceType seqType, String sequenceName)
: base(seqType)
{
SequenceName = sequenceName;
SequenceAnnotations = new Dictionary<String, String>();
}
void ValidateFindFormatterByName(SequenceType type)
{
string filename = null;
string formatterName = null;
string expectedFomatter = null;
switch (type)
{
case SequenceType.FastA:
filename = Constants.FastaTempFileName;
formatterName = SequenceType.FastA.ToString();
expectedFomatter = Constants.FastAFormatter;
break;
case SequenceType.FastQ:
filename = Constants.FastQTempFileName;
formatterName = SequenceType.FastQ.ToString();
expectedFomatter = Constants.FastQFormatter;
break;
case SequenceType.GenBank:
filename = Constants.GenBankTempFileName;
formatterName = SequenceType.GenBank.ToString();
expectedFomatter = Constants.GenBankFormatter;
break;
case SequenceType.GFF:
filename = Constants.GffTempFileName;
formatterName = SequenceType.GFF.ToString();
expectedFomatter = Constants.GffFormatter;
break;
}
ISequenceFormatter formatter = SequenceFormatters.FindFormatterByName(filename, formatterName);
System.Type formatterTypes = formatter.GetType();
Assert.AreEqual(formatterTypes.ToString(), expectedFomatter);
ApplicationLog.WriteLine("Sequence Formatter BVT : Successfully validated the FindFormatterByName() method");
}
void ValidateFindParserByName(SequenceType type)
{
string filename = null;
string parserName = null;
switch (type)
{
case SequenceType.FastA:
filename = @"TestUtils\Small_Size.fasta";
parserName = SequenceType.FastA.ToString();
break;
case SequenceType.FastQ:
filename = @"TestUtils\Simple_Fastq_Sequence.fastq";
parserName = SequenceType.FastQ.ToString();
break;
case SequenceType.GenBank:
filename = @"TestUtils\Small_Size.gbk";
parserName = SequenceType.GenBank.ToString();
break;
case SequenceType.GFF:
filename = @"TestUtils\Simple_Gff_Dna.gff";
parserName = SequenceType.GFF.ToString();
break;
}
ISequenceParser parser = SequenceParsers.FindParserByName(filename, parserName);
Assert.AreEqual(parserName, parser.Name);
ApplicationLog.WriteLine("Sequence parser BVT : Successfully validated the FindParserByName() method");
}
public SequenceReceivedEventArgs(SequenceType type, string sequence)
{
Type = type;
Sequence = sequence;
}
/// <summary>
/// 设置通讯协议规约
/// </summary>
/// <param name="frameH">帧头字节</param>
/// <param name="frameF">帧尾字节</param>
/// <param name="keyIndex">键值索引号</param>
/// <param name="keyLen">键值字节长度</param>
/// <param name="seq">执行序列</param>
/// <returns>返回设置的协议</returns>
public Protocol setProtocol(byte[] frameH, byte[] frameF, int keyIndex, int keyLen, SequenceType seq)
{
Protocol p = new Protocol();
p.FrameHeader = frameH;
p.FrameFoot = frameF;
p.KeyIndexStart = keyIndex;
p.KeyLength = keyLen;
p.ExecuteSequence = seq;
return this.ptl = p;
}
void endSequence(SequenceType type)
{
if (partial.Length > 0)
{
if (SequenceReceived != null)
SequenceReceived(this, new SequenceReceivedEventArgs(type, partial.ToString()));
partial.Clear();
}
}
private SequenceInfo(ObjectName sequenceName, SequenceType sequenceType)
{
if (sequenceName == null)
throw new ArgumentNullException("sequenceName");
SequenceName = sequenceName;
Type = sequenceType;
}
public SequenceAssignSequenceResultToVar(SequenceType seqType, SequenceVariable destVar, Sequence sequence)
: base(destVar, seqType)
{
Seq = sequence;
}
private string NextSequenceUrl(SequenceType type, int nextLoadNumber, int inputNumber)
{
string url = string.Empty;
switch (type)
{
case SequenceType.Evens:
url = String.Format("/Home/EvensSequence/?loadNumber={0}&inputNumber={1}", nextLoadNumber, inputNumber);
break;
case SequenceType.Odds:
url = String.Format("/Home/OddsSequence/?loadNumber={0}&inputNumber={1}", nextLoadNumber, inputNumber);
break;
case SequenceType.ZCE:
url = String.Format("/Home/ZCESequence/?loadNumber={0}&inputNumber={1}", nextLoadNumber, inputNumber);
break;
case SequenceType.Fibonacci:
url = "";
break;
default:
url = String.Format("/Home/Sequence/?loadNumber={0}&inputNumber={1}", nextLoadNumber, inputNumber);
break;
}
return url;
}
private IType NormalizeSequenceType(SequenceType sequenceType)
{
sequenceType.ElementType = NormalizeTypeReference(sequenceType.ElementType);
sequenceType.NameFormat = "IList<{0}>";
return(sequenceType);
}
