typename cop<KeyT,DataT,CompareT,AllocT>::iterator cop<KeyT,DataT,CompareT,AllocT>::subtract(const key_type& key) { iterator it_ = find(key); if(it_ != end()) erase(it_); return end(); }
const T & operator[] (const T &key) const { typename base_type::const_iterator it; it = base.find(key); if (it == base.end()) { return (base[key] = key); } return it->second; }
cop<KeyT,DataT,CompareT,AllocT>& cop<KeyT,DataT,CompareT,AllocT> ::keep_if(const property<value_type>& hasProperty) { iterator it = begin(), victim; while(it != end()) if ( !hasProperty(*it) ) { victim = it++; erase(victim); } else ++it; return *this; }
bool operator== (const lazy_substring<T>& that) const { if (this == &that) return true; if (m_string == that.m_string) return m_start == that.m_start and m_end == that.m_end; return size() == that.size() and std::equal(begin(), end(), that.begin()); }
bool operator< (const lazy_substring<T>& that) const { if (this == &that) return false; return std::lexicographical_compare( begin() , end() , that.begin() , that.end() ); }
typename cop<KeyT,DataT,CompareT,AllocT>::iterator cop<KeyT,DataT,CompareT,AllocT>::subtract(const value_type& val) { iterator it_ = find(val.KEY_VALUE); if(it_ != end()) { (*it_).CONT_VALUE -= val.CONT_VALUE; if((*it_).CONT_VALUE == DataT()) //neutron absorbtion { erase(it_); return end(); } else return it_; } //JODO inverse subtraction violates LAW: symmetric difference //else //{ // DataT inverse = DataT(); // inverse -= val.CONT_VALUE; // return insert(value_type(val.KEY_VALUE, inverse)).ITERATOR; //} }
typename cop<KeyT,DataT,CompareT,AllocT>::iterator cop<KeyT,DataT,CompareT,AllocT>::add(const value_type& val) { if(val.CONT_VALUE == DataT()) return end(); pair<iterator, bool> insertionAttempt = insert(val); if( insertionAttempt.WAS_SUCCESSFUL ) return insertionAttempt.ITERATOR ; else { iterator it = insertionAttempt.ITERATOR; (*it).CONT_VALUE += val.CONT_VALUE ; if((*it).CONT_VALUE == DataT()) //neutron absorbtion { erase(it); return end(); } else return it ; } }
template <typename Iter> inline typename range_base<Iter, std::bidirectional_iterator_tag>::const_reverse_iterator range_base<Iter, std::bidirectional_iterator_tag>::rbegin() const { return const_reverse_iterator(end()); }
//JODO concept set /// Checks if a key element is in the cop bool contains(const KeyT& x)const { return !(find(x) == end()); }
Wave& append(const Wave& other) { base_type::insert(end(), other.begin(), other.end()); return *this; }
Wave& append(const Array<WaveSample>& other) { base_type::insert(end(), other.begin(), other.end()); return *this; }
string_type string(void) const { return string_type(begin(), end()); }