public override bool Equals(object anObject)
 {
     if (this == anObject)
     {
         return(true);
     }
     if (anObject is PeptideModificationState)
     {
         PeptideModificationState other = (PeptideModificationState)anObject;
         if (other.NTermModification != NTermModification)
         {
             return(false);
         }
         if (other.CTermModification != CTermModification)
         {
             return(false);
         }
         if (other.Length != Length)
         {
             return(false);
         }
         for (int i = 0; i < Length; i++)
         {
             if (other.GetModificationAt(i) != GetModificationAt(i))
             {
                 return(false);
             }
         }
         return(true);
     }
     return(false);
 }
        public PeptideModificationState GetTrueModifications()
        {
            PeptideModificationState result = GetFreshCopy(Length);

            if (NTermModification != ushort.MaxValue && Modification.IsStandardVarMod(NTermModification))
            {
                result.NTermModification = NTermModification;
            }
            if (CTermModification != ushort.MaxValue && Modification.IsStandardVarMod(CTermModification))
            {
                result.CTermModification = CTermModification;
            }
            for (int i = 0; i < Length; i++)
            {
                ushort m = GetModificationAt(i);
                if (m == ushort.MaxValue || !Modification.IsStandardVarMod(m))
                {
                    result.SetModificationAt(i, ushort.MaxValue);
                }
                else
                {
                    result.SetModificationAt(i, GetModificationAt(i));
                }
            }
            return(result);
        }
        public PeptideModificationState GetLabelModifications(ushort[] labelMods, string sequence)
        {
            PeptideModificationState result = GetFreshCopy(Length);

            if (NTermModification != ushort.MaxValue && !Modification.IsStandardVarMod(NTermModification))
            {
                result.NTermModification = NTermModification;
            }
            if (CTermModification != ushort.MaxValue && !Modification.IsStandardVarMod(CTermModification))
            {
                result.CTermModification = CTermModification;
            }
            for (int i = 0; i < Length; i++)
            {
                ushort m = GetModificationAt(i);
                if (m != ushort.MaxValue && !Modification.IsStandardVarMod(m))
                {
                    result.SetModificationAt(i, m);
                }
                else
                {
                    result.SetModificationAt(i, ushort.MaxValue);
                }
            }
            foreach (ushort labelMod in labelMods)
            {
                if (!Modification.IsStandardVarMod(labelMod))
                {
                    Modification mod = Tables.ModificationList[labelMod];
                    if (mod.IsInternal)
                    {
                        for (int j = 0; j < mod.AaCount; j++)
                        {
                            char c = mod.GetAaAt(j);
                            for (int i = 0; i < Length; i++)
                            {
                                if (sequence[i] == c)
                                {
                                    result.SetModificationAt(i, mod.Index);
                                }
                            }
                        }
                    }
                    else
                    {
                        if (mod.IsNterminal)
                        {
                            result.NTermModification = mod.Index;
                        }
                        else
                        {
                            result.CTermModification = mod.Index;
                        }
                    }
                }
            }
            return(result);
        }
        public PeptideModificationState Revert()
        {
            PeptideModificationState result = Clone();

            for (int i = 1; i < Modifications.Length - 1; i++)
            {
                result.Modifications[i] = Modifications[Modifications.Length - 1 - i];
            }
            result.Modifications[Modifications.Length - 1] = Modifications[Modifications.Length - 1];
            result.Modifications[0] = Modifications[0];
            return(result);
        }
        FillFixedModifications(string sequence, IDictionary <char, ushort> fmods)
        {
            PeptideModificationState result = new PeptideModificationState(sequence.Length);

            for (int i = 0; i < sequence.Length; i++)
            {
                if (fmods.ContainsKey(sequence[i]))
                {
                    result.Modifications[i] = fmods[sequence[i]];
                }
            }
            return(result);
        }
        public PeptideModificationState GetFreshCopy(int len)
        {
            PeptideModificationState result = new PeptideModificationState {
                NTermModification = ushort.MaxValue,
                CTermModification = ushort.MaxValue,
                Modifications     = new ushort[len]
            };

            for (int i = 0; i < len; i++)
            {
                result.Modifications[i] = ushort.MaxValue;
            }
            return(result);
        }
        public static PeptideModificationState Read(BinaryReader reader)
        {
            PeptideModificationState result = new PeptideModificationState {
                CTermModification = reader.ReadUInt16(), NTermModification = reader.ReadUInt16()
            };
            int len = reader.ReadInt32();

            result.Modifications = new ushort[len];
            for (int i = 0; i < result.Modifications.Length; i++)
            {
                result.Modifications[i] = reader.ReadUInt16();
            }
            return(result);
        }
        private static (string, PeptideModificationState) FromString(string nt, string ct, string[] q)
        {
            PeptideModificationState result = new PeptideModificationState(q.Length);

            (char _, ushort mod)     = GetAaAndMod(nt);
            result.NTermModification = mod;
            (_, mod) = GetAaAndMod(ct);
            result.CTermModification = mod;
            char[] sequence = new char[q.Length];
            for (int i = 0; i < q.Length; i++)
            {
                (sequence[i], result.Modifications[i]) = GetAaAndMod(ct);
            }
            return(new string(sequence), result);
        }
        public PeptideModificationState RemoveLabelModifications()
        {
            PeptideModificationState result = Clone();

            if (NTermModification != ushort.MaxValue && !Modification.IsStandardVarMod(NTermModification))
            {
                result.NTermModification = ushort.MaxValue;
            }
            if (CTermModification != ushort.MaxValue && !Modification.IsStandardVarMod(CTermModification))
            {
                result.CTermModification = ushort.MaxValue;
            }
            for (int i = 0; i < Modifications.Length; i++)
            {
                if (Modifications[i] != ushort.MaxValue && !Modification.IsStandardVarMod(Modifications[i]))
                {
                    result.Modifications[i] = ushort.MaxValue;
                }
            }
            return(result);
        }
        public PeptideModificationState RemoveNonCompositionMods()
        {
            PeptideModificationState result = Clone();
            const ushort             m      = ushort.MaxValue - 10;

            if (result.NTermModification >= m)
            {
                result.NTermModification = ushort.MaxValue;
            }
            if (result.CTermModification >= m)
            {
                result.CTermModification = ushort.MaxValue;
            }
            for (int i = 0; i < Modifications.Length; i++)
            {
                if (result.Modifications[i] >= m)
                {
                    result.Modifications[i] = ushort.MaxValue;
                }
            }
            return(result);
        }
 public PeptideModificationState GetFreshCopy(int len)
 {
     PeptideModificationState result = new PeptideModificationState{
         NTermModification = ushort.MaxValue,
         CTermModification = ushort.MaxValue,
         Modifications = new ushort[len]
     };
     for (int i = 0; i < len; i++){
         result.Modifications[i] = ushort.MaxValue;
     }
     return result;
 }
 public static PeptideModificationState Read(BinaryReader reader)
 {
     PeptideModificationState result = new PeptideModificationState{
         CTermModification = reader.ReadUInt16(),
         NTermModification = reader.ReadUInt16()
     };
     int len = reader.ReadInt32();
     result.Modifications = new ushort[len];
     for (int i = 0; i < result.Modifications.Length; i++){
         result.Modifications[i] = reader.ReadUInt16();
     }
     return result;
 }
 public static PeptideModificationState FillFixedModifications(string sequence, IDictionary<char, ushort> fmods)
 {
     PeptideModificationState result = new PeptideModificationState(sequence.Length);
     for (int i = 0; i < sequence.Length; i++){
         if (fmods.ContainsKey(sequence[i])){
             result.Modifications[i] = fmods[sequence[i]];
         }
     }
     return result;
 }