/// <summary>
/// Indication of whether or not an ISequenceItem is in the alphabet. This is
/// a simple lookup and will only match exactly with items of this alphabet. It
/// will not compare items from other alphabets that match the same amino acid.
/// </summary>
/// <param name="item">Item whose presence is to be checked</param>
/// <returns>True if this contains input item</returns>
public bool Contains(ISequenceItem item)
{
AminoAcid aa = item as AminoAcid;
if (aa == null)
{
return(false);
}
return(values.Contains(aa));
}
/// <summary>
/// Overrides Object Equals.
/// Two nucleotides are judged equal, if they have the same symbol
/// </summary>
/// <param name="obj">Object to be compared with</param>
/// <returns>True if equal</returns>
public override bool Equals(object obj)
{
AminoAcid other = obj as AminoAcid;
if (other != null)
{
return(this.Symbol == other.Symbol);
}
else
{
return(false);
}
}
/// <summary>
/// Returns a new copy of the AminoAcid object.
/// </summary>
/// <returns>Clone of this amino acid</returns>
public AminoAcid Clone()
{
AminoAcid amminoAcid = new AminoAcid();
amminoAcid.val = val;
amminoAcid.symbol = symbol;
amminoAcid.extSymbol = extSymbol;
amminoAcid.Name = name;
amminoAcid.IsGap = IsGap;
amminoAcid.IsAmbiguous = IsAmbiguous;
amminoAcid.IsTermination = IsTermination;
return(amminoAcid);
}
/// <summary>
/// Find the set of symbols that is represented by input symbol
/// </summary>
/// <param name="symbol">Symbol to look up</param>
/// <returns>Set of symbols</returns>
public HashSet <ISequenceItem> GetBasicSymbols(ISequenceItem symbol)
{
if (symbol == null)
{
throw new ArgumentNullException("symbol");
}
// Validate input symbol
AminoAcid aa = symbol as AminoAcid;
if (aa == null || !values.Contains(aa))
{
throw new ArgumentException(string.Format(
CultureInfo.CurrentCulture, Properties.Resource.INVALID_SYMBOL, symbol.Symbol, Name));
}
if (symbol == Xxx)
{
// Return all unambiguous symbols
return(new HashSet <ISequenceItem>(values.Where(AA => !AA.IsAmbiguous).Select(AA => (ISequenceItem)AA)));
}
else
{
if (ambiguousToBasicSymbolMap.ContainsKey(symbol))
{
return(ambiguousToBasicSymbolMap[symbol]);
}
else
{
// It is base / unambiguous character
return(new HashSet <ISequenceItem>()
{
symbol
});
}
}
}