1/*
2 * Copyright 2005 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef ANDROID_PIXELFLINGER_KEYED_VECTOR_H
18#define ANDROID_PIXELFLINGER_KEYED_VECTOR_H
19
20#include <assert.h>
21#include <stdint.h>
22#include <sys/types.h>
23
24#include "Errors.h"
25#include "SortedVector.h"
26#include "TypeHelpers.h"
27
28// ---------------------------------------------------------------------------
29
30namespace android {
31namespace tinyutils {
32
33template <typename KEY, typename VALUE>
34class KeyedVector
35{
36public:
37    typedef KEY    key_type;
38    typedef VALUE  value_type;
39
40    inline                  KeyedVector();
41
42    /*
43     * empty the vector
44     */
45
46    inline  void            clear()                     { mVector.clear(); }
47
48    /*!
49     * vector stats
50     */
51
52    //! returns number of items in the vector
53    inline  size_t          size() const                { return mVector.size(); }
54    //! returns wether or not the vector is empty
55    inline  bool            isEmpty() const             { return mVector.isEmpty(); }
56    //! returns how many items can be stored without reallocating the backing store
57    inline  size_t          capacity() const            { return mVector.capacity(); }
58    //! setst the capacity. capacity can never be reduced less than size()
59    inline ssize_t          setCapacity(size_t size)    { return mVector.setCapacity(size); }
60
61    /*!
62     * accessors
63     */
64            const VALUE&    valueFor(const KEY& key) const;
65            const VALUE&    valueAt(size_t index) const;
66            const KEY&      keyAt(size_t index) const;
67            ssize_t         indexOfKey(const KEY& key) const;
68
69    /*!
70     * modifing the array
71     */
72
73            VALUE&          editValueFor(const KEY& key);
74            VALUE&          editValueAt(size_t index);
75
76            /*!
77             * add/insert/replace items
78             */
79
80            ssize_t         add(const KEY& key, const VALUE& item);
81            ssize_t         replaceValueFor(const KEY& key, const VALUE& item);
82            ssize_t         replaceValueAt(size_t index, const VALUE& item);
83
84    /*!
85     * remove items
86     */
87
88            ssize_t         removeItem(const KEY& key);
89            ssize_t         removeItemsAt(size_t index, size_t count = 1);
90
91private:
92            SortedVector< key_value_pair_t<KEY, VALUE> >    mVector;
93};
94
95// ---------------------------------------------------------------------------
96
97/**
98 * Variation of KeyedVector that holds a default value to return when
99 * valueFor() is called with a key that doesn't exist.
100 */
101template <typename KEY, typename VALUE>
102class DefaultKeyedVector : public KeyedVector<KEY, VALUE>
103{
104public:
105    inline                  DefaultKeyedVector(const VALUE& defValue = VALUE());
106            const VALUE&    valueFor(const KEY& key) const;
107
108private:
109            VALUE                                           mDefault;
110};
111
112// ---------------------------------------------------------------------------
113
114template<typename KEY, typename VALUE> inline
115KeyedVector<KEY,VALUE>::KeyedVector()
116{
117}
118
119template<typename KEY, typename VALUE> inline
120ssize_t KeyedVector<KEY,VALUE>::indexOfKey(const KEY& key) const {
121    return mVector.indexOf( key_value_pair_t<KEY,VALUE>(key) );
122}
123
124template<typename KEY, typename VALUE> inline
125const VALUE& KeyedVector<KEY,VALUE>::valueFor(const KEY& key) const {
126    ssize_t i = indexOfKey(key);
127    assert(i>=0);
128    return mVector.itemAt(i).value;
129}
130
131template<typename KEY, typename VALUE> inline
132const VALUE& KeyedVector<KEY,VALUE>::valueAt(size_t index) const {
133    return mVector.itemAt(index).value;
134}
135
136template<typename KEY, typename VALUE> inline
137const KEY& KeyedVector<KEY,VALUE>::keyAt(size_t index) const {
138    return mVector.itemAt(index).key;
139}
140
141template<typename KEY, typename VALUE> inline
142VALUE& KeyedVector<KEY,VALUE>::editValueFor(const KEY& key) {
143    ssize_t i = indexOfKey(key);
144    assert(i>=0);
145    return mVector.editItemAt(i).value;
146}
147
148template<typename KEY, typename VALUE> inline
149VALUE& KeyedVector<KEY,VALUE>::editValueAt(size_t index) {
150    return mVector.editItemAt(index).value;
151}
152
153template<typename KEY, typename VALUE> inline
154ssize_t KeyedVector<KEY,VALUE>::add(const KEY& key, const VALUE& value) {
155    return mVector.add( key_value_pair_t<KEY,VALUE>(key, value) );
156}
157
158template<typename KEY, typename VALUE> inline
159ssize_t KeyedVector<KEY,VALUE>::replaceValueFor(const KEY& key, const VALUE& value) {
160    key_value_pair_t<KEY,VALUE> pair(key, value);
161    mVector.remove(pair);
162    return mVector.add(pair);
163}
164
165template<typename KEY, typename VALUE> inline
166ssize_t KeyedVector<KEY,VALUE>::replaceValueAt(size_t index, const VALUE& item) {
167    if (index<size()) {
168        mVector.editValueAt(index).value = item;
169        return index;
170    }
171    return BAD_INDEX;
172}
173
174template<typename KEY, typename VALUE> inline
175ssize_t KeyedVector<KEY,VALUE>::removeItem(const KEY& key) {
176    return mVector.remove(key_value_pair_t<KEY,VALUE>(key));
177}
178
179template<typename KEY, typename VALUE> inline
180ssize_t KeyedVector<KEY, VALUE>::removeItemsAt(size_t index, size_t count) {
181    return mVector.removeItemsAt(index, count);
182}
183
184// ---------------------------------------------------------------------------
185
186template<typename KEY, typename VALUE> inline
187DefaultKeyedVector<KEY,VALUE>::DefaultKeyedVector(const VALUE& defValue)
188    : mDefault(defValue)
189{
190}
191
192template<typename KEY, typename VALUE> inline
193const VALUE& DefaultKeyedVector<KEY,VALUE>::valueFor(const KEY& key) const {
194    ssize_t i = indexOfKey(key);
195    return i >= 0 ? KeyedVector<KEY,VALUE>::valueAt(i) : mDefault;
196}
197
198} // namespace tinyutils
199} // namespace android
200
201// ---------------------------------------------------------------------------
202
203#endif // ANDROID_PIXELFLINGER_KEYED_VECTOR_H
204