private bool IsConflicting(VersionedDependency installed, VersionedDependency required)
 {
     return(installed.Name.Equals(required.Name, StringComparison.OrdinalIgnoreCase) && IncompatibilityExistsBetween(
                installed.Name,
                new System.Version(installed.Version),
                new System.Version(required.Version)
                ));
 }
Exemplo n.º 2
0
 private bool IsConflicting(VersionedDependency installed, VersionedDependency required)
 {
     return installed.Name.Equals (required.Name, StringComparison.OrdinalIgnoreCase) && IncompatibilityExistsBetween (
         installed.Name,
         new System.Version (installed.Version),
         new System.Version (required.Version)
     );
 }
Exemplo n.º 3
0
        private List<string> Resolve(VersionedDependency requiredDependency, Dictionary<string, HashSet<VersionedDependency>> installed)
        {
            List<string> flagged = new List<string> ();

            foreach (var kitChain in installed) {
                flagged.AddRange (Resolve (requiredDependency, kitChain));
            }

            return flagged;
        }
        private List <string> Resolve(VersionedDependency requiredDependency, Dictionary <string, HashSet <VersionedDependency> > installed)
        {
            List <string> flagged = new List <string> ();

            foreach (var kitChain in installed)
            {
                flagged.AddRange(Resolve(requiredDependency, kitChain));
            }

            return(flagged);
        }
            public override bool Equals(object obj)
            {
                if (obj == null || GetType() != obj.GetType())
                {
                    return(false);
                }

                VersionedDependency dep = obj as VersionedDependency;

                return
                    (this.Name.Equals(dep.Name, StringComparison.OrdinalIgnoreCase) &&
                     this.Version.Equals(dep.Version, StringComparison.OrdinalIgnoreCase));
            }
        private List <string> Resolve(VersionedDependency requiredDependency, KeyValuePair <string, HashSet <VersionedDependency> > installed)
        {
            List <string> flagged = new List <string> ();

            foreach (VersionedDependency installedDependency in installed.Value)
            {
                if (IsConflicting(installedDependency, requiredDependency))
                {
                    flagged.Add(installed.Key);
                }
            }

            return(flagged);
        }
Exemplo n.º 7
0
        private List<string> Resolve(VersionedDependency requiredDependency, KeyValuePair<string, HashSet<VersionedDependency>> installed)
        {
            List<string> flagged = new List<string> ();

            foreach (VersionedDependency installedDependency in installed.Value) {
                if (IsConflicting (installedDependency, requiredDependency)) {
                    flagged.Add (installed.Key);
                }
            }

            return flagged;
        }