aboutsummaryrefslogtreecommitdiff
path: root/paludis/util/pool.hh
blob: 58e919b3846d8c84efb59fbb2483f68110da47e3 (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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
/* vim: set sw=4 sts=4 et foldmethod=syntax : */

/*
 * Copyright (c) 2011 Ciaran McCreesh
 *
 * This file is part of the Paludis package manager. Paludis is free software;
 * you can redistribute it and/or modify it under the terms of the GNU General
 * Public License version 2, as published by the Free Software Foundation.
 *
 * Paludis is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 * Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef PALUDIS_GUARD_PALUDIS_UTIL_POOL_HH
#define PALUDIS_GUARD_PALUDIS_UTIL_POOL_HH 1

#include <paludis/util/singleton.hh>
#include <paludis/util/pimp.hh>
#include <memory>

namespace paludis
{
    class PoolKeysHasher;
    class PoolKeysComparator;

    template <typename T_>
    class PALUDIS_VISIBLE Pool :
        public Singleton<Pool<T_> >
    {
        friend class Singleton<Pool<T_> >;

        private:
            Pimp<Pool<T_> > _imp;

            Pool();
            ~Pool();

        public:
            template <typename... Args_>
            const std::shared_ptr<const T_> create(Args_ ...) const PALUDIS_ATTRIBUTE((warn_unused_result));
    };

    class PALUDIS_VISIBLE PoolKey
    {
        private:
            int _tc;

        protected:
            explicit PoolKey(int tc);

            virtual bool same_value(const PoolKey &) const = 0;

        public:
            virtual ~PoolKey() = 0;

            virtual std::size_t hash() const = 0;

            bool same_type_and_value(const PoolKey &) const;
    };

    template <typename T_>
    class PALUDIS_VISIBLE ConcretePoolKey :
        public PoolKey
    {
        friend class PoolKeysHasher;
        friend class PoolKeysComparator;

        private:
            T_ _value;

        public:
            explicit ConcretePoolKey(const T_ &);

            virtual ~ConcretePoolKey();

            virtual std::size_t hash() const;

            bool same_value(const PoolKey &) const;
    };

    class PALUDIS_VISIBLE PoolKeys
    {
        friend class PoolKeysHasher;
        friend class PoolKeysComparator;

        private:
            Pimp<PoolKeys> _imp;

            void add_one(const std::shared_ptr<const PoolKey> &);
            void add();

        public:
            PoolKeys();
            PoolKeys(const PoolKeys &);
            ~PoolKeys();

            template <typename Arg_, typename... Args_>
            void add(const Arg_ &, const Args_ & ...);
    };

    class PALUDIS_VISIBLE PoolKeysHasher
    {
        public:
            std::size_t operator() (const PoolKeys &) const PALUDIS_VISIBLE;
    };

    class PALUDIS_VISIBLE PoolKeysComparator
    {
        public:
            bool operator() (const PoolKeys &, const PoolKeys &) const PALUDIS_VISIBLE;
    };

    class PALUDIS_VISIBLE PoolKeyTypeCodes
    {
        private:
            static int next();

        public:
            template <typename T_>
            static int get();
    };

    extern template class Pimp<PoolKeys>;
}

#endif