1/*
2 * Copyright (C) 2015 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#pragma once
18
19#include "Element.h"
20#include "Stream.h"
21#include "Strategy.h"
22#include "Usage.h"
23#include "InputSource.h"
24#include <utils/Errors.h>
25#include <system/audio.h>
26#include <utils/Log.h>
27#include <map>
28#include <stdint.h>
29#include <string>
30
31namespace android
32{
33namespace audio_policy
34{
35
36/**
37 * Collection of policy element as a map indexed with a their UID type.
38 *
39 * @tparam Key type of the policy element indexing the collection.
40 *         Policy Element supported are:
41 *                      - Strategy
42 *                      - Stream
43 *                      - InputSource
44 *                      - Usage.
45 */
46template <typename Key>
47class Collection : public std::map<Key, Element<Key> *>
48{
49private:
50    typedef std::map<Key, Element<Key> *> Base;
51    typedef Element<Key> T;
52    typedef typename std::map<Key, T *>::iterator CollectionIterator;
53    typedef typename std::map<Key, T *>::const_iterator CollectionConstIterator;
54
55public:
56    Collection()
57    {
58        collectionSupported();
59    }
60
61    /**
62     * Add a policy element to the collection. Policy elements are streams, strategies, input
63     * sources, ... Compile time error generated if called with not supported collection.
64     * It also set the key as the unique identifier of the policy element.
65     *
66     * @tparam Key indexing the collection of policy element.
67     * @param[in] name of the policy element to find.
68     * @param[in] key to be used to index this new policy element.
69     *
70     * @return NO_ERROR if the policy element has been successfully added to the collection.
71     */
72    status_t add(const std::string &name, Key key)
73    {
74        if ((*this).find(key) != (*this).end()) {
75            ALOGW("%s: element %s already added", __FUNCTION__, name.c_str());
76            return BAD_VALUE;
77        }
78        (*this)[key] = new T(name);
79        ALOGD("%s: adding element %s to collection", __FUNCTION__, name.c_str());
80        return (*this)[key]->setIdentifier(key);
81    }
82
83    /**
84     * Get a policy element from the collection by its key. Policy elements are streams, strategies,
85     * input sources, ... Compile time error generated if called with not supported collection.
86     *
87     * @tparam Key indexing the collection of policy element.
88     * @param[in] key of the policy element to find.
89     *
90     * @return valid pointer on policy element if found, NULL otherwise.
91     */
92    T *get(Key key) const
93    {
94        CollectionConstIterator it = (*this).find(key);
95        return (it == (*this).end()) ? NULL : it->second;
96    }
97
98    /**
99     * Find a policy element from the collection by its name. Policy elements are streams,
100     * strategies, input sources, ...
101     * Compile time error generated if called with not supported collection.
102     *
103     * @tparam Key indexing the collection of policy element.
104     * @param[in] name of the policy element to find.
105     * @param[in] elementsMap maps of policy elements to search into.
106     *
107     * @return valid pointer on element if found, NULL otherwise.
108     */
109    T *findByName(const std::string &name) const
110    {
111
112        CollectionConstIterator it;
113        for (it = (*this).begin(); it != (*this).end(); ++it) {
114            T *element = it->second;
115            if (element->getName() == name) {
116                return element;
117            }
118        }
119        return NULL;
120    }
121
122    /**
123     * Removes all the elements from the list and destroy them.
124     */
125    void clear()
126    {
127        CollectionIterator it;
128        for (it = (*this).begin(); it != (*this).end(); ++it) {
129            delete it->second;
130        }
131        Base::clear();
132    }
133
134private:
135    /**
136     * provide a compile time error if no specialization is provided for a given type.
137     *
138     * @tparam T: type of the policyElement. Policy Element supported are:
139     *                      - Strategy
140     *                      - Stream
141     *                      - InputSource
142     *                      - Usage.
143     */
144    struct collectionSupported;
145};
146
147template <>
148struct Collection<audio_stream_type_t>::collectionSupported {};
149template <>
150struct Collection<std::string>::collectionSupported {};
151template <>
152struct Collection<audio_usage_t>::collectionSupported {};
153template <>
154struct Collection<audio_source_t>::collectionSupported {};
155template <>
156struct Collection<routing_strategy>::collectionSupported {};
157
158typedef Collection<routing_strategy> StrategyCollection;
159typedef Collection<audio_stream_type_t> StreamCollection;
160typedef Collection<audio_usage_t> UsageCollection;
161typedef Collection<audio_source_t> InputSourceCollection;
162
163} // namespace audio_policy
164} // namespace android
165