Split pkg-build.cxx

1 files changed, 0 insertions, 269 deletions

diff --git a/bpkg/package.cxx b/bpkg/package.cxx
index 44eff01..6cd555e 100644
--- a/bpkg/package.cxx
+++ b/bpkg/package.cxx
@@ -116,275 +116,6 @@ namespace bpkg
                       sp != nullptr ? sp->authoritative : false);
   }
 
-  odb::result<available_package>
-  query_available (database& db,
-                   const package_name& name,
-                   const optional<version_constraint>& c,
-                   bool order,
-                   bool revision)
-  {
-    using query = query<available_package>;
-
-    query q (query::id.name == name);
-    const auto& vm (query::id.version);
-
-    // If there is a constraint, then translate it to the query. Otherwise,
-    // get the latest version or stub versions if present.
-    //
-    if (c)
-    {
-      assert (c->complete ());
-
-      query qs (compare_version_eq (vm,
-                                    canonical_version (wildcard_version),
-                                    false /* revision */,
-                                    false /* iteration */));
-
-      if (c->min_version &&
-          c->max_version &&
-          *c->min_version == *c->max_version)
-      {
-        const version& v (*c->min_version);
-
-        q = q &&
-            (compare_version_eq (vm,
-                                 canonical_version (v),
-                                 revision || v.revision.has_value (),
-                                 revision /* iteration */) ||
-             qs);
-      }
-      else
-      {
-        query qr (true);
-
-        if (c->min_version)
-        {
-          const version& v (*c->min_version);
-          canonical_version cv (v);
-          bool rv (revision || v.revision);
-
-          if (c->min_open)
-            qr = compare_version_gt (vm, cv, rv, revision /* iteration */);
-          else
-            qr = compare_version_ge (vm, cv, rv, revision /* iteration */);
-        }
-
-        if (c->max_version)
-        {
-          const version& v (*c->max_version);
-          canonical_version cv (v);
-          bool rv (revision || v.revision);
-
-          if (c->max_open)
-            qr = qr && compare_version_lt (vm, cv, rv, revision);
-          else
-            qr = qr && compare_version_le (vm, cv, rv, revision);
-        }
-
-        q = q && (qr || qs);
-      }
-    }
-
-    if (order)
-      q += order_by_version_desc (vm);
-
-    return db.query<available_package> (q);
-  }
-
-  // Check if the package is available from the specified repository fragment,
-  // its prerequisite repositories, or one of their complements, recursively.
-  // Return the first repository fragment that contains the package or NULL if
-  // none are.
-  //
-  // Note that we can end up with a repository dependency cycle since the
-  // root repository can be the default complement for dir and git
-  // repositories (see rep_fetch() implementation for details). Thus we need
-  // to make sure that the repository fragment is not in the dependency chain
-  // yet.
-  //
-  using repository_fragments =
-    vector<reference_wrapper<const shared_ptr<repository_fragment>>>;
-
-  static shared_ptr<repository_fragment>
-  find (const shared_ptr<repository_fragment>& rf,
-        const shared_ptr<available_package>& ap,
-        repository_fragments& chain,
-        bool prereq)
-  {
-    // Prerequisites are not searched through recursively.
-    //
-    assert (!prereq || chain.empty ());
-
-    if (find_if (chain.begin (), chain.end (),
-                 [&rf] (const shared_ptr<repository_fragment>& i) -> bool
-                 {
-                   return i == rf;
-                 }) != chain.end ())
-      return nullptr;
-
-    chain.emplace_back (rf);
-
-    unique_ptr<repository_fragments, void (*)(repository_fragments*)> deleter (
-      &chain, [] (repository_fragments* rf) {rf->pop_back ();});
-
-    const auto& cs (rf->complements);
-    const auto& ps (rf->prerequisites);
-
-    for (const package_location& pl: ap->locations)
-    {
-      const lazy_shared_ptr<repository_fragment>& lrf (pl.repository_fragment);
-
-      // First check the repository itself.
-      //
-      if (lrf.object_id () == rf->name)
-        return rf;
-
-      // Then check all the complements and prerequisites repository fragments
-      // without loading them. Though, we still need to load complement and
-      // prerequisite repositories.
-      //
-      auto pr = [&lrf] (const repository::fragment_type& i)
-      {
-        return i.fragment == lrf;
-      };
-
-      for (const lazy_weak_ptr<repository>& r: cs)
-      {
-        const auto& frs (r.load ()->fragments);
-
-        if (find_if (frs.begin (), frs.end (), pr) != frs.end ())
-          return lrf.load ();
-      }
-
-      if (prereq)
-      {
-        for (const lazy_weak_ptr<repository>& r: ps)
-        {
-          const auto& frs (r.load ()->fragments);
-
-          if (find_if (frs.begin (), frs.end (), pr) != frs.end ())
-            return lrf.load ();
-        }
-      }
-
-      // Finally, load the complements and prerequisites and check them
-      // recursively.
-      //
-      for (const lazy_weak_ptr<repository>& cr: cs)
-      {
-        for (const auto& fr: cr.load ()->fragments)
-        {
-          // Should we consider prerequisites of our complements as our
-          // prerequisites? I'd say not.
-          //
-          if (shared_ptr<repository_fragment> r =
-              find (fr.fragment.load (), ap, chain, false))
-            return r;
-        }
-      }
-
-      if (prereq)
-      {
-        for (const lazy_weak_ptr<repository>& pr: ps)
-        {
-          for (const auto& fr: pr.load ()->fragments)
-          {
-            if (shared_ptr<repository_fragment> r =
-                find (fr.fragment.load (), ap, chain, false))
-              return r;
-          }
-        }
-      }
-    }
-
-    return nullptr;
-  }
-
-  shared_ptr<repository_fragment>
-  filter (const shared_ptr<repository_fragment>& r,
-          const shared_ptr<available_package>& ap,
-          bool prereq)
-  {
-    repository_fragments chain;
-    return find (r, ap, chain, prereq);
-  }
-
-  vector<shared_ptr<available_package>>
-  filter (const shared_ptr<repository_fragment>& r,
-          result<available_package>&& apr,
-          bool prereq)
-  {
-    vector<shared_ptr<available_package>> aps;
-
-    for (shared_ptr<available_package> ap: pointer_result (apr))
-    {
-      if (filter (r, ap, prereq) != nullptr)
-        aps.push_back (move (ap));
-    }
-
-    return aps;
-  }
-
-  pair<shared_ptr<available_package>, shared_ptr<repository_fragment>>
-  filter_one (const shared_ptr<repository_fragment>& r,
-              result<available_package>&& apr,
-              bool prereq)
-  {
-    using result = pair<shared_ptr<available_package>,
-                        shared_ptr<repository_fragment>>;
-
-    for (shared_ptr<available_package> ap: pointer_result (apr))
-    {
-      if (shared_ptr<repository_fragment> pr = filter (r, ap, prereq))
-        return result (move (ap), move (pr));
-    }
-
-    return result ();
-  }
-
-  vector<pair<shared_ptr<available_package>, shared_ptr<repository_fragment>>>
-  filter (const vector<shared_ptr<repository_fragment>>& rps,
-          odb::result<available_package>&& apr,
-          bool prereq)
-  {
-    vector<pair<shared_ptr<available_package>,
-                shared_ptr<repository_fragment>>> aps;
-
-    for (shared_ptr<available_package> ap: pointer_result (apr))
-    {
-      for (const shared_ptr<repository_fragment>& r: rps)
-      {
-        if (shared_ptr<repository_fragment> rf = filter (r, ap, prereq))
-        {
-          aps.emplace_back (move (ap), move (rf));
-          break;
-        }
-      }
-    }
-
-    return aps;
-  }
-
-  pair<shared_ptr<available_package>, shared_ptr<repository_fragment>>
-  filter_one (const vector<shared_ptr<repository_fragment>>& rps,
-              odb::result<available_package>&& apr,
-              bool prereq)
-  {
-    using result = pair<shared_ptr<available_package>,
-                        shared_ptr<repository_fragment>>;
-
-    for (shared_ptr<available_package> ap: pointer_result (apr))
-    {
-      for (const shared_ptr<repository_fragment>& r: rps)
-      {
-        if (shared_ptr<repository_fragment> rf = filter (r, ap, prereq))
-          return result (move (ap), move (rf));
-      }
-    }
-
-    return result ();
-  }
-
   void
   check_any_available (const linked_databases& dbs,
                        transaction&,