nmap.hpp

Go to the documentation of this file.

// LICENSE: (Please see the file COPYING for details)
//
// NUS - Nemesis Utilities System: A C++ application development framework 
// Copyright (C) 2006, 2008 Otavio Rodolfo Piske
//
//  This file is part of NUS
//
//  This library is free software; you can redistribute it and/or
//  modify it under the terms of the GNU Lesser General Public
//  License as published by the Free Software Foundation version 2.1
//  of the License.
//
//  This library is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
//  Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with this library; if not, write to the Free Software
//  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef NMAP_HPP
#define NMAP_HPP

template <typename K, typename V>
class NMap {
      public:
            class iterator;   
            typedef const iterator const_iterator;    
            NMap(void);
            
            ~NMap(void);
            
            bool contains(const K &keyname) const;
            
            bool contains(const K &keyname, const V &val) const;
            
            nuint64 size(void) const;
            
            nuint64 count(void) const;
            
            nuint64 count(const K &keyname) const;
            
            iterator begin(void);
            
            const_iterator constBegin(void) const;
            
            iterator end(void);
            
            const_iterator constEnd(void) const;
            
            bool erase(iterator pos);
            
            iterator find(const K &keyname);
            
            iterator find(const K &keyname, const V &val);
            
            const_iterator constFind(const K &keyname) const;
            
            const_iterator constFind(const K &keyname, const V &val) const;
      
            iterator insert(const K &keyname, const V &val);
            
            bool isEmpty(void) const;
            
            const K key(const V val) const;
            
            NList<K> keys(void) const;
            
            NList<K> keys(const V val);
            
            nuint64 remove(const K &keyname);
            
            V take(const K &keyname);
            
            V value(const K &keyname) const;
            
            V value(const K &keyname, const V &defaultValue) const;
            
            NList<V> values(void) const;
            
            NList<V> values(const K &keyname) const;
            
            void clear(void);
            
            void copy(const NMap<K, V> &rhs);
            
            NMap<K, V> &operator=(const NMap<K, V> &rhs);
            
            bool operator!=(const NMap<K, V> &rhs) const;
            
            bool operator==(const NMap<K, V> &rhs) const;
            
            V operator[](const K &keyname);
            
            const V &operator[](const K &keyname) const;
      
      private:
            typedef NSkipList<NMapItem<K, V> > NMapSkip;
            NMapSkip m_skip;
};


template <typename K, typename V>
NMap<K, V>::NMap(void)
      : m_skip()
{

}

template <typename K, typename V>
NMap<K, V>::~NMap(void) {

}


template <typename K, typename V>
nuint64 NMap<K, V>::size(void) const {
      return m_skip.count();
}


template <typename K, typename V>
nuint64 NMap<K, V>::count(void) const {
      return m_skip.count();
}


template <typename K, typename V>
nuint64 NMap<K, V>::count(const K &keyname) const {
      nuint64 items = 0;
      
      for (typename NMapSkip::iterator i = m_skip.begin(); 
                i != m_skip.end();
                i++)
      {
            if ((*i).key == keyname) {
                  items++;
            }
      }
      
      return items;
}


template <typename K, typename V>
class NMap<K, V>::iterator { 
      public:
            iterator(void): m_it(NULL) { }
            
            iterator(const iterator &other): m_it(NULL) {
                  m_it = other.m_it;
            }
            
            iterator(const typename NMapSkip::iterator &it): m_it(it) {
            
            }
            
            K key(void) const {
                  return (*m_it).key;
            }
            
            V value(void) const {
                  return (*m_it).value;
            }
            
            iterator &operator=(const iterator &rhs) {
                  m_it = rhs.m_it;
                  
                  return *this;
            }
            
            bool operator==(const iterator &rhs) const {
                  if (m_it == rhs.m_it) {
                        return true;
                  }
                  
                  return false;
            }
            
            
            bool operator!=(const iterator &rhs) const {
                  if (m_it != rhs.m_it) {
                        return true;
                  }
                  
                  return false;
            }
            
            NMapItem<K, V> operator*(void) const {
                  return *m_it;
            }
            
            iterator inc(void) {
                  iterator tmp(*this);
                  
                  m_it++;
                  return tmp;
            }
            
            iterator operator++(int) {
                  iterator tmp(*this);
                  
                  inc();
                  return tmp;
            }
            
            
            const iterator &operator++(void) const {
                  iterator tmp(*this);
                  
                  m_it++;
                  return *this;
            }
            
            
            const iterator operator++(int) const {
                  iterator tmp(*this);
                  
                  ++(*this);
                  return tmp;
            }
            
      private:
            typename NMapSkip::iterator m_it;
};

template <typename K, typename V>
typename NMap<K, V>::iterator NMap<K, V>::begin(void) {
      return typename NMap<K, V>::iterator(m_skip.begin());
}


template <typename K, typename V>
NMAPITERATOR_CONST NMap<K, V>::constBegin(void) const {
      return typename NMap<K, V>::const_iterator(m_skip.constBegin());
}     




template <typename K, typename V>
typename NMap<K, V>::iterator NMap<K, V>::end(void) {
      return typename NMap<K, V>::iterator(m_skip.end());
}


template <typename K, typename V>
NMAPITERATOR_CONST NMap<K, V>::constEnd(void) const {
      return typename NMap<K, V>::const_iterator(m_skip.constEnd());
}


template <typename K, typename V>
bool NMap<K, V>::erase(iterator pos) {
      return m_skip.erase(*pos);
}


template <typename K, typename V>
typename NMap<K, V>::iterator NMap<K, V>::find(const K &keyname) {
      for (typename NMapSkip::iterator i = m_skip.begin(); i != m_skip.end(); i++) {
            if ((*i).key == keyname) {
                  return typename NMap<K, V>::iterator(i);
            }
            
      }
      
      return typename NMap<K, V>::iterator(m_skip.end());
}


template <typename K, typename V>
NMAPITERATOR_CONST NMap<K, V>::constFind(const K &keyname) const {
      for (typename NMapSkip::const_iterator i = m_skip.constBegin(); 
                i != m_skip.constEnd(); i++) 
      {
            if ((*i).key == keyname) {
                  return typename NMap<K, V>::const_iterator(i);
            }
            
      }
      
      return typename NMap<K, V>::const_iterator(m_skip.constEnd());
}


template <typename K, typename V>
typename NMap<K, V>::iterator NMap<K, V>::find(const K &keyname, const V &val) {
      for (typename NMapSkip::iterator i = m_skip.begin(); i != m_skip.end(); i++) {
            if ((*i).key == keyname && (*i).value == val) {
                  return typename NMap<K, V>::iterator(i);
            }
      }
      
      return typename NMap<K, V>::iterator(m_skip.end());
}


template <typename K, typename V>
NMAPITERATOR_CONST NMap<K, V>::constFind(const K &keyname, const V &val) const {
      for (typename NMapSkip::const_iterator i = m_skip.constBegin(); 
                i != m_skip.constEnd(); i++) 
      {
            if ((*i).key == keyname && (*i).value == val) {
                  return typename NMap<K, V>::const_iterator(i);
            }
      }
      
      return typename NMap<K, V>::const_iterator(m_skip.constEnd());
}


template <typename K, typename V>
typename NMap<K, V>::iterator NMap<K, V>::insert(const K &keyname, const V &val) {
      NMapItem<K, V> item;
      
      item.key = keyname;
      item.value = val;
      
      return typename NMap<K, V>::iterator(m_skip.insert(item));
}

template <typename K, typename V>
bool NMap<K, V>::isEmpty(void) const {
      return m_skip.isEmpty();
}


template <typename K, typename V>
const K NMap<K, V>::key(const V val) const {
      K tmp;
      
      for (typename NMapSkip::iterator i = m_skip.begin(); i != m_skip.end(); i++) {
            if ((*i).value == val) {
                  tmp = (*i).key;
                  break;
            }
      }
      
      return tmp;
}


template <typename K, typename V>
NList<K> NMap<K, V>::keys(void) const {
      NList<K> ret;
      
      
      for (typename NMapSkip::const_iterator i = m_skip.constBegin(); 
                i != m_skip.constEnd(); i++) 
      {
            ret.append((*i).key);
      }
      
      return ret;
}


template <typename K, typename V>
NList<K> NMap<K, V>::keys(const V val) {
      NList<K> ret;
      
      for (typename NMapSkip::iterator i = m_skip.begin(); i != m_skip.end(); i++) {
            if ((*i).value == val) {
                  ret.append((*i).key);
                  break;
            }
      }
      
      return ret;
}


template <typename K, typename V>
nuint64 NMap<K, V>::remove(const K &keyname) {
      nuint64 items = 0;
      
      for (typename NMapSkip::iterator i = m_skip.begin(); i != m_skip.end(); i++) {
            if ((*i).key == keyname) {
                  if (m_skip.remove((*i))) {
                        items++;
                  }
            }
      }
      
      return items;
}

template <typename K, typename V>
V NMap<K, V>::take(const K &keyname) {
      V tmp;
      
      for (typename NMapSkip::iterator i = m_skip.begin(); i != m_skip.end(); i++) {
            if ((*i).key == keyname) {
                  tmp = (*i).value;
                  m_skip.remove((*i));
            }
      }
}


template <typename K, typename V>
V NMap<K, V>::value(const K &keyname) const {
      V tmp;
      
      for (typename NMapSkip::const_iterator i = m_skip.constBegin(); 
                i != m_skip.constEnd(); i++) 
      {
            if ((*i).key == keyname) {
                  tmp = (*i).value;
                  break;
            }
      }
      
      return tmp;

}

template <typename K, typename V>
V NMap<K, V>::value(const K &keyname, const V &defaultValue) const {
      V tmp = defaultValue;
      
      for (typename NMapSkip::const_iterator i = m_skip.constBegin(); 
                i != m_skip.constEnd(); i++) 
      {
            if ((*i).key == keyname) {
                  tmp = (*i).value;
                  break;
            }
      }
      
      return tmp;
}


template <typename K, typename V>
NList<V> NMap<K, V>::values(void) const {
      NList<V> ret;
      
      for (typename NMapSkip::const_iterator i = m_skip.constBegin(); 
                i != m_skip.constEnd(); i++) 
      {
            ret.append((*i).value);
      }
      
      return ret;
}

template <typename K, typename V>
NList<V> NMap<K, V>::values(const K &keyname) const {
      NList<V> ret;
      
      for (typename NMapSkip::const_iterator i = m_skip.constBegin(); 
                i != m_skip.constEnd(); i++) 
      {
            if ((*i).key == keyname) {
                  ret.append((*i).value);
            }
      }
      
      return ret;
}


template <typename K, typename V>
void NMap<K, V>::copy(const NMap<K, V> &rhs) {
      m_skip.clear();
      
      for (typename NMapSkip::iterator i = rhs.begin(); i != rhs.end(); i++) {
            insert((*i).key, (*i).value);
      }
}


template <typename K, typename V>
bool NMap<K, V>::contains(const K &keyname) const {
      if (constFind(keyname) != constEnd()) {
            return true;
      }
      
      return false;
}


template <typename K, typename V>
bool NMap<K, V>::contains(const K &keyname, const V &val) const {
      if (constFind(keyname, val) != constEnd()) {
            return true;      
      }
      
      return false;
}



template <typename K, typename V>
NMap<K, V> &NMap<K, V>::operator=(const NMap<K, V> &rhs) {
      copy(rhs);
      
      return *this;
}


template <typename K, typename V>
bool NMap<K, V>::operator!=(const NMap<K, V> &rhs) const {
      for (typename NMapSkip::iterator i = rhs.begin(); i != rhs.end(); i++) {
            if (contains((*i).key, (*i).value)) {
                  return false;
            }
      }
      
      return true;
}


template <typename K, typename V>
bool NMap<K, V>::operator==(const NMap<K, V> &rhs) const {
      for (typename NMapSkip::iterator i = rhs.begin(); i != rhs.end(); i++) {
            if (!contains((*i).key, (*i).value)) {
                  return false;
            }
      }
      
      return true;
}


template <typename K, typename V>
V NMap<K, V>::operator[](const K &keyname) {
      return value(keyname);
}


template <typename K, typename V>
const V &NMap<K, V>::operator[](const K &keyname) const {
      return value(keyname);
}

#endif // NMAP_HPP

---