dict.h

Go to the documentation of this file.

/*
 *  dict.h
 *
 *  This file is part of NEST.
 *
 *  Copyright (C) 2004 The NEST Initiative
 *
 *  NEST is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  NEST 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 General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with NEST.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef DICT_H
#define DICT_H
/* 
    SLI's dictionary class
*/
#include "name.h"
#include "token.h"

#include <map>
#include "sliexceptions.h"


typedef  std::map<Name, Token, std::less<Name> > TokenMap;

inline bool operator==(const TokenMap & x, const TokenMap &y)
{
  return (x.size() == y.size()) && equal(x.begin(), x.end(), y.begin());
}

class Dictionary: private TokenMap
{
  class DictItemLexicalOrder {
  private:
    static bool nocase_compare(char c1, char c2);

  public:
    bool operator() (const std::pair<Name, Token>& lhs, 
             const std::pair<Name, Token>& rhs) const
      {
    const std::string& ls = lhs.first.toString();
    const std::string& rs = rhs.first.toString();

    return std::lexicographical_compare(ls.begin(), ls.end(),
                        rs.begin(), rs.end(),
                        nocase_compare);
      }
  };
  
public:
  Dictionary(): refs_on_dictstack_(0) {}
  Dictionary(const Dictionary &d) : TokenMap(d), refs_on_dictstack_(0) {}
  ~Dictionary();
  
  using TokenMap::erase;
  using TokenMap::size;
  using TokenMap::begin;
  using TokenMap::end;
  using TokenMap::iterator;
  using TokenMap::find;

  void clear();

  const Token & lookup(const Name &n) const;

  const Token & lookup2(const Name &n) const; //throws UndefinedName
  bool known(const Name &) const;
  
  bool known_but_not_accessed(const Name&) const;

  Token & insert(const Name &n, const Token &t);
  Token & insert_move(const Name &, Token &);

  void remove(const Name& n);  

  const Token& operator[](const Name&) const;
  Token& operator[](const Name &);
  const Token& operator[](const char*) const;
  Token& operator[](const char *);
  
  bool empty(void) const { return TokenMap::empty(); }
      
  void info(std::ostream &) const;
  
  bool operator==(const Dictionary &d) const { return ::operator==(*this, d); }
  
  void add_dict(const std::string&, SLIInterpreter&);

  void remove_dict(const std::string&, SLIInterpreter&);

  void clear_access_flags();
  
  bool all_accessed(std::string& missed) const { return all_accessed_(missed); }
     
  friend std::ostream & operator<<(std::ostream &, const Dictionary &);
  
  typedef TokenMap::const_iterator const_iterator;
  
  //  const_iterator begin() const;

  //const_iterator end() const;

  void initialize_property_array(Name propname);
  
  void add_dictstack_reference()
  {
    ++refs_on_dictstack_;
  }

  void remove_dictstack_reference()
  {
    --refs_on_dictstack_;
  }

  bool is_on_dictstack() const
  {
    return refs_on_dictstack_ >0;
  }

  
 private:
  int refs_on_dictstack_; 
  bool all_accessed_(std::string&, std::string prefix = std::string()) const;
  static const Token VoidToken;
};

inline
const Token& Dictionary::lookup(const Name &n) const
{
  TokenMap::const_iterator where = find(n);
  if(where != end())
    return (*where).second;
  else
    return Dictionary::VoidToken;
}

inline
const Token& Dictionary::lookup2(const Name &n) const
{      
  TokenMap::const_iterator where = find(n);
  if(where != end())
    return (*where).second;
  else
    throw UndefinedName(n.toString());
}

inline
bool Dictionary::known(const Name &n) const
{
  TokenMap::const_iterator where = find(n);
  if(where != end())
    return true;
  else
    return false;
}

inline
bool Dictionary::known_but_not_accessed(const Name &n) const
{
  TokenMap::const_iterator where = find(n);
  if(where != end())
    return not where->second.accessed();
  else
    return false;
}

inline
Token& Dictionary::insert(const Name &n, const Token &t)  
{ 
  return TokenMap::operator[](n) = t; 
}


inline
const Token& Dictionary::operator[](const Name &n) const
{      
  TokenMap::const_iterator where = find(n);
  if(where != end())
    return (*where).second;
  else
    throw UndefinedName(n.toString());
}


inline
Token& Dictionary::operator[](const Name &n)
{  
  return TokenMap::operator[](n);
}

inline
Token& Dictionary::insert_move(const Name &n, Token &t)
{
  Token &result=TokenMap::operator[](n);
  result.move(t);
  return result;
}


#endif