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()); }
