25 #ifndef TG_TAGGABLES_H
26 #define TG_TAGGABLES_H
42 assert(m_elements.empty());
51 tgTaggables(std::vector<T>& elements) : m_elements(elements) {
53 assertUniqueElements(
"All elements must be unique.");
63 std::vector<T*>
find(std::string tags)
65 std::vector<T*> result;
66 for(
int i = 0; i < m_elements.size(); i++) {
67 if(_taggable(&m_elements[i])->hasAllTags(tags)) {
68 result.push_back(&(m_elements[i]));
76 return m_elements.size();
79 std::vector<T*> findAll()
81 std::vector<T*> result;
82 for(
int i = 0; i < m_elements.size(); i++) {
83 result.push_back(&(m_elements[i]));
88 std::vector<T*> findUntagged()
90 std::vector<T*> result;
91 for(
int i = 0; i < m_elements.size(); i++) {
94 result.push_back(&(m_elements[i]));
100 static bool contains(std::vector<T*> haystack,
const T* needle)
102 return std::find(haystack.begin(), haystack.end(), needle) != haystack.end();
105 bool contains(
const T& needle)
const
108 for(
typename std::vector<T>::const_iterator it = m_elements.begin(); it != m_elements.end(); it++) {
109 if(&(*it) == &needle)
123 assertKeyExists(key);
124 return m_elements[key];
128 assertKeyExists(key);
129 return m_elements[key];
136 this->removeElements(other.getElements());
141 this->removeElements(other);
145 T& operator+=(
const T& other) {
146 this->addElement(other);
150 T& operator+=(
const std::vector<T*> other) {
151 this->addElements(other);
159 int addElement(T element)
162 assert(!elementExists(element));
163 assertUnique(element);
164 m_elements.push_back(element);
165 return m_elements.size();
168 void addElements(std::vector<T*> elements)
170 for(
int i = 0; i < elements.size(); i++) {
171 this->addElement(elements[i]);
175 void setElement(
int key, T element) {
176 assert((0 <= key) && (key <= m_elements.size()));
177 m_elements[key] = element;
180 std::vector<T>& getElements()
185 const std::vector<T>& getElements()
const
190 void removeElement(
const T& element) {
191 m_elements.erase(std::remove(m_elements.begin(), m_elements.end(), element), m_elements.end());
194 void removeElement(
const T* element) {
195 m_elements.erase(std::remove(m_elements.begin(), m_elements.end(), *element), m_elements.end());
198 void removeElements(
const std::vector<T>& elements) {
199 for(
int i = 0; i < elements.size(); i++) {
200 removeElement(elements[i]);
204 void removeElements(
const std::vector<T*>& elements) {
205 for(
int i = 0; i < elements.size(); i++) {
206 removeElement(elements[i]);
211 T& getElement(
int key)
213 return m_elements[key];
217 const T& getElement(
int key)
const
219 return m_elements[key];
230 return (0 <= key) && (key < m_elements.size());
234 bool elementExists(
const T& element)
const
237 for(
int i = 0; i < m_elements.size(); i++) {
239 const T* elem =& m_elements[i];
240 if (elem == &element) {
247 void assertKeyExists(
int key, std::string message =
"Element at index does not exist")
const
250 std::stringstream ss;
252 throw std::out_of_range(message +
" (index "+ ss.str() +
").");
256 void assertUnique(T& element, std::string message =
"Taggable elements must be unique.") {
257 if(elementExists(element)) {
258 throw std::logic_error(message);
262 void assertUniqueElements(std::string message =
"Taggable elements must be unique.")
const
268 if(! std::set<T>(m_elements.begin(), m_elements.end()).size() ==
270 throw std::logic_error(message);
282 std::vector<T> m_elements;
T & operator-=(const T &other)
std::vector< T * > find(std::string tags)
Contains the definition of class tgTaggable $Id$.
tgTaggables(std::vector< T > &elements)
bool keyExists(int key) const