blob: 3dff58c17ef777429359d85f01deff5e9373807c (
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
|
/*
* Copyright (C) 2010 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef __SESSIONMAP_H__
#define __SESSIONMAP_H__
#include <utils/KeyedVector.h>
namespace android {
/**
* A wrapper template class for handling DRM Engine sessions.
*/
template <typename NODE>
class SessionMap {
public:
KeyedVector<int, NODE> map;
SessionMap() {}
virtual ~SessionMap() {
destroyMap();
}
/**
* Adds a new value in the session map table. It expects memory to be allocated already
* for the session object
*
* @param key - key or Session ID
* @param value - session object to add
*
* @return boolean result of adding value. returns false if key is already exist.
*/
bool addValue(int key, NODE value) {
bool result = false;
if (!isCreated(key)) {
map.add(key, value);
result = true;
}
return result;
}
/**
* returns the session object by the key
*
* @param key - key or Session ID
*
* @return session object as per the key
*/
NODE getValue(int key) {
NODE value = NULL;
if (isCreated(key)) {
value = (NODE) map.valueFor(key);
}
return value;
}
/**
* returns the number of objects in the session map table
*
* @return count of number of session objects.
*/
int getSize() {
return map.size();
}
/**
* returns the session object by the index in the session map table
*
* @param index - index of the value required
*
* @return session object as per the index
*/
NODE getValueAt(unsigned int index) {
NODE value = NULL;
if (map.size() > index) {
value = map.valueAt(index);
}
return value;
}
/**
* deletes the object from session map. It also frees up memory for the session object.
*
* @param key - key of the value to be deleted
*
*/
void removeValue(int key) {
deleteValue(getValue(key));
map.removeItem(key);
}
/**
* decides if session is already created.
*
* @param key - key of the value for the session
*
* @return boolean result of whether session is created
*/
bool isCreated(int key) {
return (0 <= map.indexOfKey(key));
}
/**
* empty the entire session table. It releases all the memory for session objects.
*/
void destroyMap() {
int size = map.size();
int i = 0;
for (i = 0; i < size; i++) {
deleteValue(map.valueAt(i));
}
map.clear();
}
/**
* free up the memory for the session object.
* Make sure if any reference to the session object anywhere, otherwise it will be a
* dangle pointer after this call.
*
* @param value - session object to free
*
*/
void deleteValue(NODE value) {
delete value;
}
};
};
#endif /* __SESSIONMAP_H__ */
|
