Coverage Report

Created: 2025-10-10 06:18

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/aspell/common/cache-t.hpp
Line
Count
Source
1
#ifndef ACOMMON_CACHE_T__HPP
2
#define ACOMMON_CACHE_T__HPP
3
4
#include "lock.hpp"
5
#include "cache.hpp"
6
7
//#include "iostream.hpp"
8
9
namespace acommon {
10
11
class GlobalCacheBase
12
{
13
public:
14
  mutable Mutex lock;
15
public: // but don't use
16
  const char * name;
17
  GlobalCacheBase * next;
18
  GlobalCacheBase * * prev;
19
  // The global cache lock must exist while any cache instance is active
20
  static Mutex global_cache_lock;
21
protected:
22
  Cacheable * first;
23
  void del(Cacheable * d);
24
  void add(Cacheable * n);
25
  GlobalCacheBase(const char * n);
26
  ~GlobalCacheBase();
27
public:
28
  void release(Cacheable * d);
29
  void detach(Cacheable * d);
30
  void detach_all();
31
};
32
33
template <class D>
34
class GlobalCache : public GlobalCacheBase
35
{
36
public:
37
  typedef D Data;
38
  typedef typename Data::CacheKey Key;
39
public:
40
16
  GlobalCache(const char * n) : GlobalCacheBase(n) {}
acommon::GlobalCache<acommon::Decode>::GlobalCache(char const*)
Line
Count
Source
40
2
  GlobalCache(const char * n) : GlobalCacheBase(n) {}
acommon::GlobalCache<acommon::Encode>::GlobalCache(char const*)
Line
Count
Source
40
2
  GlobalCache(const char * n) : GlobalCacheBase(n) {}
acommon::GlobalCache<acommon::NormTables>::GlobalCache(char const*)
Line
Count
Source
40
2
  GlobalCache(const char * n) : GlobalCacheBase(n) {}
acommon::GlobalCache<acommon::ConfigFilterModule>::GlobalCache(char const*)
Line
Count
Source
40
2
  GlobalCache(const char * n) : GlobalCacheBase(n) {}
acommon::GlobalCache<acommon::FilterModeList>::GlobalCache(char const*)
Line
Count
Source
40
2
  GlobalCache(const char * n) : GlobalCacheBase(n) {}
acommon::GlobalCache<aspeller::Language>::GlobalCache(char const*)
Line
Count
Source
40
2
  GlobalCache(const char * n) : GlobalCacheBase(n) {}
acommon::GlobalCache<aspeller::Dictionary>::GlobalCache(char const*)
Line
Count
Source
40
2
  GlobalCache(const char * n) : GlobalCacheBase(n) {}
acommon::GlobalCache<aspeller::TypoEditDistanceInfo>::GlobalCache(char const*)
Line
Count
Source
40
2
  GlobalCache(const char * n) : GlobalCacheBase(n) {}
41
  // "find" and "add" will _not_ acquire a lock
42
46.8k
  Data * find(const Key & key) {
43
46.8k
    D * cur = static_cast<D *>(first);
44
52.9k
    while (cur && !cur->cache_key_eq(key))
45
6.18k
      cur = static_cast<D *>(cur->next);
46
46.8k
    return cur;
47
46.8k
  }
acommon::GlobalCache<acommon::Decode>::find(acommon::ConvKey const&)
Line
Count
Source
42
3.84k
  Data * find(const Key & key) {
43
3.84k
    D * cur = static_cast<D *>(first);
44
6.65k
    while (cur && !cur->cache_key_eq(key))
45
2.80k
      cur = static_cast<D *>(cur->next);
46
3.84k
    return cur;
47
3.84k
  }
acommon::GlobalCache<acommon::Encode>::find(acommon::ConvKey const&)
Line
Count
Source
42
9.93k
  Data * find(const Key & key) {
43
9.93k
    D * cur = static_cast<D *>(first);
44
11.6k
    while (cur && !cur->cache_key_eq(key))
45
1.68k
      cur = static_cast<D *>(cur->next);
46
9.93k
    return cur;
47
9.93k
  }
acommon::GlobalCache<acommon::NormTables>::find(char const* const&)
Line
Count
Source
42
12.2k
  Data * find(const Key & key) {
43
12.2k
    D * cur = static_cast<D *>(first);
44
12.2k
    while (cur && !cur->cache_key_eq(key))
45
0
      cur = static_cast<D *>(cur->next);
46
12.2k
    return cur;
47
12.2k
  }
acommon::GlobalCache<acommon::ConfigFilterModule>::find(acommon::String const&)
Line
Count
Source
42
5.38k
  Data * find(const Key & key) {
43
5.38k
    D * cur = static_cast<D *>(first);
44
5.38k
    while (cur && !cur->cache_key_eq(key))
45
0
      cur = static_cast<D *>(cur->next);
46
5.38k
    return cur;
47
5.38k
  }
acommon::GlobalCache<acommon::FilterModeList>::find(acommon::String const&)
Line
Count
Source
42
3.58k
  Data * find(const Key & key) {
43
3.58k
    D * cur = static_cast<D *>(first);
44
4.22k
    while (cur && !cur->cache_key_eq(key))
45
631
      cur = static_cast<D *>(cur->next);
46
3.58k
    return cur;
47
3.58k
  }
acommon::GlobalCache<aspeller::Language>::find(acommon::String const&)
Line
Count
Source
42
7.53k
  Data * find(const Key & key) {
43
7.53k
    D * cur = static_cast<D *>(first);
44
7.53k
    while (cur && !cur->cache_key_eq(key))
45
0
      cur = static_cast<D *>(cur->next);
46
7.53k
    return cur;
47
7.53k
  }
acommon::GlobalCache<aspeller::Dictionary>::find(aspeller::Dictionary::Id const&)
Line
Count
Source
42
2.14k
  Data * find(const Key & key) {
43
2.14k
    D * cur = static_cast<D *>(first);
44
3.21k
    while (cur && !cur->cache_key_eq(key))
45
1.06k
      cur = static_cast<D *>(cur->next);
46
2.14k
    return cur;
47
2.14k
  }
acommon::GlobalCache<aspeller::TypoEditDistanceInfo>::find(char const* const&)
Line
Count
Source
42
2.14k
  Data * find(const Key & key) {
43
2.14k
    D * cur = static_cast<D *>(first);
44
2.14k
    while (cur && !cur->cache_key_eq(key))
45
0
      cur = static_cast<D *>(cur->next);
46
2.14k
    return cur;
47
2.14k
  }
48
12.4k
  void add(Data * n) {GlobalCacheBase::add(n);}
acommon::GlobalCache<acommon::Decode>::add(acommon::Decode*)
Line
Count
Source
48
2.21k
  void add(Data * n) {GlobalCacheBase::add(n);}
acommon::GlobalCache<acommon::Encode>::add(acommon::Encode*)
Line
Count
Source
48
2.24k
  void add(Data * n) {GlobalCacheBase::add(n);}
acommon::GlobalCache<acommon::NormTables>::add(acommon::NormTables*)
Line
Count
Source
48
1.02k
  void add(Data * n) {GlobalCacheBase::add(n);}
Unexecuted instantiation: acommon::GlobalCache<acommon::ConfigFilterModule>::add(acommon::ConfigFilterModule*)
acommon::GlobalCache<acommon::FilterModeList>::add(acommon::FilterModeList*)
Line
Count
Source
48
2.65k
  void add(Data * n) {GlobalCacheBase::add(n);}
acommon::GlobalCache<aspeller::Language>::add(aspeller::Language*)
Line
Count
Source
48
1.09k
  void add(Data * n) {GlobalCacheBase::add(n);}
acommon::GlobalCache<aspeller::Dictionary>::add(aspeller::Dictionary*)
Line
Count
Source
48
2.14k
  void add(Data * n) {GlobalCacheBase::add(n);}
acommon::GlobalCache<aspeller::TypoEditDistanceInfo>::add(aspeller::TypoEditDistanceInfo*)
Line
Count
Source
48
1.06k
  void add(Data * n) {GlobalCacheBase::add(n);}
49
  // "release" and "detach" _will_ acquire a lock
50
  void release(Data * d) {GlobalCacheBase::release(d);}
51
  void detach(Data * d) {GlobalCacheBase::detach(d);}
52
};
53
54
template <class Data>
55
PosibErr<Data *> get_cache_data(GlobalCache<Data> * cache, 
56
                                typename Data::CacheConfig * config, 
57
                                const typename Data::CacheKey & key)
58
42.5k
{
59
42.5k
  LOCK(&cache->lock);
60
42.5k
  Data * n = cache->find(key);
61
  //CERR << "Getting " << key << " for " << cache->name << "\n";
62
42.5k
  if (n) {
63
27.9k
    n->refcount++;
64
27.9k
    return n;
65
27.9k
  }
66
14.6k
  PosibErr<Data *> res = Data::get_new(key, config);
67
14.6k
  if (res.has_err()) {
68
    //CERR << "ERROR\n"; 
69
5.39k
    return res;
70
5.39k
  }
71
9.22k
  n = res.data;
72
9.22k
  cache->add(n);
73
  //CERR << "LOADED FROM DISK\n";
74
9.22k
  return n;
75
14.6k
}
acommon::PosibErr<acommon::Decode*> acommon::get_cache_data<acommon::Decode>(acommon::GlobalCache<acommon::Decode>*, acommon::Decode::CacheConfig*, acommon::Decode::CacheKey const&)
Line
Count
Source
58
3.84k
{
59
3.84k
  LOCK(&cache->lock);
60
3.84k
  Data * n = cache->find(key);
61
  //CERR << "Getting " << key << " for " << cache->name << "\n";
62
3.84k
  if (n) {
63
1.62k
    n->refcount++;
64
1.62k
    return n;
65
1.62k
  }
66
2.22k
  PosibErr<Data *> res = Data::get_new(key, config);
67
2.22k
  if (res.has_err()) {
68
    //CERR << "ERROR\n"; 
69
11
    return res;
70
11
  }
71
2.21k
  n = res.data;
72
2.21k
  cache->add(n);
73
  //CERR << "LOADED FROM DISK\n";
74
2.21k
  return n;
75
2.22k
}
acommon::PosibErr<acommon::Encode*> acommon::get_cache_data<acommon::Encode>(acommon::GlobalCache<acommon::Encode>*, acommon::Encode::CacheConfig*, acommon::Encode::CacheKey const&)
Line
Count
Source
58
9.93k
{
59
9.93k
  LOCK(&cache->lock);
60
9.93k
  Data * n = cache->find(key);
61
  //CERR << "Getting " << key << " for " << cache->name << "\n";
62
9.93k
  if (n) {
63
7.69k
    n->refcount++;
64
7.69k
    return n;
65
7.69k
  }
66
2.24k
  PosibErr<Data *> res = Data::get_new(key, config);
67
2.24k
  if (res.has_err()) {
68
    //CERR << "ERROR\n"; 
69
0
    return res;
70
0
  }
71
2.24k
  n = res.data;
72
2.24k
  cache->add(n);
73
  //CERR << "LOADED FROM DISK\n";
74
2.24k
  return n;
75
2.24k
}
acommon::PosibErr<acommon::NormTables*> acommon::get_cache_data<acommon::NormTables>(acommon::GlobalCache<acommon::NormTables>*, acommon::NormTables::CacheConfig*, acommon::NormTables::CacheKey const&)
Line
Count
Source
58
12.2k
{
59
12.2k
  LOCK(&cache->lock);
60
12.2k
  Data * n = cache->find(key);
61
  //CERR << "Getting " << key << " for " << cache->name << "\n";
62
12.2k
  if (n) {
63
11.2k
    n->refcount++;
64
11.2k
    return n;
65
11.2k
  }
66
1.02k
  PosibErr<Data *> res = Data::get_new(key, config);
67
1.02k
  if (res.has_err()) {
68
    //CERR << "ERROR\n"; 
69
0
    return res;
70
0
  }
71
1.02k
  n = res.data;
72
1.02k
  cache->add(n);
73
  //CERR << "LOADED FROM DISK\n";
74
1.02k
  return n;
75
1.02k
}
acommon::PosibErr<acommon::ConfigFilterModule*> acommon::get_cache_data<acommon::ConfigFilterModule>(acommon::GlobalCache<acommon::ConfigFilterModule>*, acommon::ConfigFilterModule::CacheConfig*, acommon::ConfigFilterModule::CacheKey const&)
Line
Count
Source
58
5.38k
{
59
5.38k
  LOCK(&cache->lock);
60
5.38k
  Data * n = cache->find(key);
61
  //CERR << "Getting " << key << " for " << cache->name << "\n";
62
5.38k
  if (n) {
63
0
    n->refcount++;
64
0
    return n;
65
0
  }
66
5.38k
  PosibErr<Data *> res = Data::get_new(key, config);
67
5.38k
  if (res.has_err()) {
68
    //CERR << "ERROR\n"; 
69
5.38k
    return res;
70
5.38k
  }
71
0
  n = res.data;
72
0
  cache->add(n);
73
  //CERR << "LOADED FROM DISK\n";
74
0
  return n;
75
5.38k
}
acommon::PosibErr<acommon::FilterModeList*> acommon::get_cache_data<acommon::FilterModeList>(acommon::GlobalCache<acommon::FilterModeList>*, acommon::FilterModeList::CacheConfig*, acommon::FilterModeList::CacheKey const&)
Line
Count
Source
58
3.58k
{
59
3.58k
  LOCK(&cache->lock);
60
3.58k
  Data * n = cache->find(key);
61
  //CERR << "Getting " << key << " for " << cache->name << "\n";
62
3.58k
  if (n) {
63
937
    n->refcount++;
64
937
    return n;
65
937
  }
66
2.65k
  PosibErr<Data *> res = Data::get_new(key, config);
67
2.65k
  if (res.has_err()) {
68
    //CERR << "ERROR\n"; 
69
0
    return res;
70
0
  }
71
2.65k
  n = res.data;
72
2.65k
  cache->add(n);
73
  //CERR << "LOADED FROM DISK\n";
74
2.65k
  return n;
75
2.65k
}
acommon::PosibErr<aspeller::Language*> acommon::get_cache_data<aspeller::Language>(acommon::GlobalCache<aspeller::Language>*, aspeller::Language::CacheConfig*, aspeller::Language::CacheKey const&)
Line
Count
Source
58
7.53k
{
59
7.53k
  LOCK(&cache->lock);
60
7.53k
  Data * n = cache->find(key);
61
  //CERR << "Getting " << key << " for " << cache->name << "\n";
62
7.53k
  if (n) {
63
6.44k
    n->refcount++;
64
6.44k
    return n;
65
6.44k
  }
66
1.09k
  PosibErr<Data *> res = Data::get_new(key, config);
67
1.09k
  if (res.has_err()) {
68
    //CERR << "ERROR\n"; 
69
0
    return res;
70
0
  }
71
1.09k
  n = res.data;
72
1.09k
  cache->add(n);
73
  //CERR << "LOADED FROM DISK\n";
74
1.09k
  return n;
75
1.09k
}
76
77
template <class Data>
78
PosibErr<Data *> get_cache_data(GlobalCache<Data> * cache, 
79
                                typename Data::CacheConfig * config, 
80
                                typename Data::CacheConfig2 * config2,
81
                                const typename Data::CacheKey & key)
82
2.14k
{
83
2.14k
  LOCK(&cache->lock);
84
2.14k
  Data * n = cache->find(key);
85
  //CERR << "Getting " << key << "\n";
86
2.14k
  if (n) {
87
1.06k
    n->refcount++;
88
1.06k
    return n;
89
1.06k
  }
90
1.07k
  PosibErr<Data *> res = Data::get_new(key, config, config2);
91
1.07k
  if (res.has_err()) {
92
    //CERR << "ERROR\n"; 
93
7
    return res;
94
7
  }
95
1.06k
  n = res.data;
96
1.06k
  cache->add(n);
97
  //CERR << "LOADED FROM DISK\n";
98
1.06k
  return n;
99
1.07k
}
100
101
}
102
103
#endif