summaryrefslogtreecommitdiff
path: root/Build/source/libs/poppler/poppler-src/poppler/PopplerCache.h
blob: ecc983ac6cac2b0470306837f83cc726505f0cce (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
//========================================================================
//
// PopplerCache.h
//
// This file is licensed under the GPLv2 or later
//
// Copyright (C) 2009 Koji Otani <sho@bbr.jp>
// Copyright (C) 2009, 2010, 2017, 2018 Albert Astals Cid <aacid@kde.org>
// Copyright (C) 2010 Carlos Garcia Campos <carlosgc@gnome.org>
//
//========================================================================

#ifndef POPPLER_CACHE_H
#define POPPLER_CACHE_H

#include "Object.h"

class PopplerCacheItem
{
  public:
   PopplerCacheItem() = default;
   virtual ~PopplerCacheItem();

   PopplerCacheItem(const PopplerCacheItem &) = delete;
   PopplerCacheItem& operator=(const PopplerCacheItem &other) = delete;
};

class PopplerCacheKey
{
  public:
    PopplerCacheKey() = default;
    virtual ~PopplerCacheKey();
    virtual bool operator==(const PopplerCacheKey &key) const = 0;

    PopplerCacheKey(const PopplerCacheKey &) = delete;
    PopplerCacheKey& operator=(const PopplerCacheKey &other) = delete;
};

class PopplerCache
{
  public:
    PopplerCache(int cacheSizeA);
    ~PopplerCache();
    
    PopplerCache(const PopplerCache &) = delete;
    PopplerCache& operator=(const PopplerCache &other) = delete;

    /* The item returned is owned by the cache */
    PopplerCacheItem *lookup(const PopplerCacheKey &key);
    
    /* The key and item pointers ownership is taken by the cache */
    void put(PopplerCacheKey *key, PopplerCacheItem *item);
    
    /* The max size of the cache */
    int size();
    
    /* The number of items in the cache */
    int numberOfItems();
    
    /* The n-th item in the cache */
    PopplerCacheItem *item(int index);
    
    /* The n-th key in the cache */
    PopplerCacheKey *key(int index);
  
  private:
    PopplerCacheKey **keys;
    PopplerCacheItem **items;
    int lastValidCacheIndex;
    int cacheSize;
};

class PopplerObjectCache
{
  public:
    PopplerObjectCache (int cacheSizeA, XRef *xrefA);
    ~PopplerObjectCache();

    PopplerObjectCache(const PopplerObjectCache &) = delete;
    PopplerObjectCache& operator=(const PopplerObjectCache &other) = delete;

    Object *put(const Ref &ref);
    Object lookup(const Ref &ref);

  private:
    XRef *xref;
    PopplerCache *cache;
};

#endif