// Create a local alias for a matched discID // static void Dbase::MakeAlias(const Cddb::Album& album, const Cddb::discid_t discID) { LOG(VB_MEDIA, LOG_DEBUG, QString("Cddb MakeAlias %1 for %2 ") .arg(discID,0,16).arg(album.discID,0,16) + album.genre + " " + album.artist + " / " + album.title); s_cache.insert(discID, album)->discID = discID; }
typename std::enable_if<(sizeof...(Args), std::is_same<cache_t, cache_vector_t>::value) && tp == timeout_policy_t::NEVER, std::remove_const_t<std::decay_t<R>>>::type const& call(Args const&... args) { decayed_key_t new_keys(getKey(args)...); auto&& it(cache.find(new_keys)); if (it == cache.end()) // not cached { if (cache.size() == LRU_MAX) // cache is full, time to overwrite old objects { if (internal_it == internal_cache.end()) { assert(cache_it == cache.end()); internal_it = internal_cache.begin(); cache_it = cache.begin(); } *internal_it = fptr(args...); cache.erase(cache_it); cache.insert(cache_it, std::pair<key_t, internal_cache_it_t>(new_keys, internal_it)); ++cache_it; return *internal_it++; } else { // Maybe emplace_back internal_cache.push_back(fptr(args...)); cache[new_keys] = internal_cache.end(); return internal_cache.back(); } } else // was cached return *it->second; };
typename std::enable_if<(sizeof...(Args), std::is_same<cache_t, cache_map_t>::value) && tp == timeout_policy_t::NEVER, std::remove_const_t<std::decay_t<R>>>::type const& call(Args const&... args) { decayed_key_t new_keys(getKey(args)...); auto&& it(cache.find(new_keys)); if (it == cache.end()) //not cached { auto&& pos(cache.insert(std::pair<key_t, R>(std::move(new_keys), fptr(args...)))); return pos.first->second; } else //was cached return it->second; };
// Create a new entry for a discID // static void Dbase::New(const Cddb::discid_t discID, const Cddb::Toc& toc) { s_cache.insert(discID, Cddb::Album(discID))->toc = toc; }
expr_ref bind_variables::abstract(expr* term, cache_t& cache, unsigned scope) { unsigned sz = m_todo.size(); m_todo.push_back(term); m_args.reset(); expr* b, *arg; while (m_todo.size() > sz) { expr* e = m_todo.back(); if (cache.contains(e)) { m_todo.pop_back(); continue; } switch(e->get_kind()) { case AST_VAR: { SASSERT(to_var(e)->get_idx() < scope); // mixing bound variables and free is possible for the caller, // but not proper use. // So we assert here even though we don't check for it. cache.insert(e, e); m_todo.pop_back(); break; } case AST_APP: { app* a = to_app(e); var2bound::obj_map_entry* w = m_var2bound.find_core(a); if (w) { var* v = w->get_data().m_value; if (!v) { // allocate a bound index. v = m.mk_var(m_names.size(), m.get_sort(a)); m_names.push_back(a->get_decl()->get_name()); m_bound.push_back(m.get_sort(a)); w->get_data().m_value = v; m_pinned.push_back(v); } if (scope == 0) { cache.insert(e, v); } else { var* v1 = m.mk_var(scope + v->get_idx(), m.get_sort(v)); m_pinned.push_back(v1); cache.insert(e, v1); } m_todo.pop_back(); break; } bool all_visited = true; bool some_diff = false; m_args.reset(); for (unsigned i = 0; i < a->get_num_args(); ++i) { arg = a->get_arg(i); if (!cache.find(arg, b)) { m_todo.push_back(arg); all_visited = false; } else if (all_visited) { m_args.push_back(b); if (b != arg) { some_diff = true; } } } if (all_visited) { if (some_diff) { b = m.mk_app(a->get_decl(), m_args.size(), m_args.c_ptr()); m_pinned.push_back(b); } else { b = a; } cache.insert(e, b); m_todo.pop_back(); } break; } case AST_QUANTIFIER: { quantifier* q = to_quantifier(e); expr_ref_buffer patterns(m); expr_ref result1(m); unsigned new_scope = scope + q->get_num_decls(); cache_t new_cache; for (unsigned i = 0; i < q->get_num_patterns(); ++i) { patterns.push_back(abstract(q->get_pattern(i), new_cache, new_scope)); } result1 = abstract(q->get_expr(), new_cache, new_scope); b = m.update_quantifier(q, patterns.size(), patterns.c_ptr(), result1.get()); m_pinned.push_back(b); cache.insert(e, b); m_todo.pop_back(); break; } default: UNREACHABLE(); } } return expr_ref(cache.find(term), m); }