Example #1
0
        // 获取最近的符合筛选条件的父类群。
        public static Taxon GetNearestParent(this Taxon taxon, TaxonFilter filter)
        {
            if (taxon is null)
            {
                throw new ArgumentNullException();
            }

            //

            Taxon parent = taxon.Parent;

            while (parent is not null)
            {
                if (taxon._IsMatched(filter))
                {
                    return(parent);
                }
                else
                {
                    parent = parent.Parent;
                }
            }

            return(null);
        }
Example #2
0
        // 获取所有符合筛选条件的父类群。
        public static IReadOnlyList <Taxon> GetParents(this Taxon taxon, TaxonFilter filter, TaxonFilter terminationCondition = TaxonFilter.None, bool includeTermination = true, bool skipParaphyly = true)
        {
            if (taxon is null)
            {
                throw new ArgumentNullException();
            }

            //

            List <Taxon> result = new List <Taxon>();

            if (!taxon.IsRoot)
            {
                Taxon parent = skipParaphyly ? taxon._GetParentSkipParaphyly() : taxon.Parent;

                while (parent is not null)
                {
                    if (parent._IsMatched(terminationCondition))
                    {
                        if (includeTermination)
                        {
                            result.Add(parent);
                        }

                        break;
                    }

                    if (parent._IsMatched(filter))
                    {
                        result.Add(parent);
                    }

                    parent = skipParaphyly ? parent._GetParentSkipParaphyly() : parent.Parent;
                }
            }

            return(result);
        }
Example #3
0
        //

        private static bool _IsMatched(this Taxon taxon, TaxonFilter filter)
        {
            if (taxon is null)
            {
                throw new ArgumentNullException();
            }

            //

            if (filter == TaxonFilter.None)
            {
                return(false);
            }
            else if (filter == TaxonFilter.Any)
            {
                return(true);
            }
            else
            {
                bool nameIsMatched = false;
                bool rankIsMatched = false;

                if (filter.HasFlag(TaxonFilter.NamedOrAnonymous))
                {
                    nameIsMatched = true;
                }
                else if (taxon.IsNamed && filter.HasFlag(TaxonFilter.Named))
                {
                    nameIsMatched = true;
                }
                else if (taxon.IsAnonymous && filter.HasFlag(TaxonFilter.Anonymous))
                {
                    nameIsMatched = true;
                }

                if (nameIsMatched)
                {
                    if (filter.HasFlag(TaxonFilter.AnyRank))
                    {
                        rankIsMatched = true;
                    }
                    else if (taxon.Rank.IsUnranked() && filter.HasFlag(TaxonFilter.Unranked))
                    {
                        rankIsMatched = true;
                    }
                    else if (taxon.Rank.IsClade() && filter.HasFlag(TaxonFilter.Clade))
                    {
                        rankIsMatched = true;
                    }
                    else if (taxon.Rank.IsBasicSecondaryRank() && filter.HasFlag(TaxonFilter.BasicSecondaryRank))
                    {
                        rankIsMatched = true;
                    }
                    else if (taxon.Rank.IsSecondaryRank() && filter.HasFlag(TaxonFilter.SecondaryRank))
                    {
                        rankIsMatched = true;
                    }
                    else if (taxon.Rank.IsBasicPrimaryRank() && filter.HasFlag(TaxonFilter.BasicPrimaryRank))
                    {
                        rankIsMatched = true;
                    }
                    else if (taxon.Rank.IsPrimaryRank() && filter.HasFlag(TaxonFilter.PrimaryRank))
                    {
                        rankIsMatched = true;
                    }
                }

                return(nameIsMatched && rankIsMatched);
            }
        }