name.h

Go to the documentation of this file.

/*
 *  name.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 NAME_H
#define NAME_H

#include <cassert>
#include <map>
#include <string>
#include <deque>
#include <iostream>

class Name
{
  
 public:
  typedef unsigned int handle_t;
 Name()                     : handle_(0) {}

 Name(const char s[])       : handle_(insert(std::string(s))) {} 
 Name(const std::string &s) : handle_(insert(s)) {}
 Name(const Name &n)        : handle_(n.handle_) {}

  const std::string& toString(void) const;
  
  handle_t toIndex(void)  const 
  {
    return handle_;
  }
  
  bool operator== (const Name &n) const
  {
    return handle_ == n.handle_;
  }
  
  bool operator!= (const Name &n) const
  {
    return !(handle_ == n.handle_);
  }
  
  bool operator< (const Name &n) const
  {
    return handle_ < n.handle_;
  }
  
  static bool lookup(const std::string &s)
  {
    HandleMap_ &table=handleMapInstance_();
    return (table.find(s) != table.end());
  }
  
  static
    size_t capacity();
  static 
    size_t num_handles();

  void print_handle(std::ostream&) const;

  static void list_handles(std::ostream &);
  static void list(std::ostream &);
  static void info(std::ostream &);
  
 private:
  handle_t insert(const std::string&);  
  
  typedef std::map<std::string, handle_t> HandleMap_;
  typedef std::deque<std::string> HandleTable_;
  
  static HandleMap_& handleMapInstance_();
  static HandleTable_& handleTableInstance_();
  
  handle_t handle_;
};

std::ostream& operator<<(std::ostream&, const Name&);


inline
Name::HandleTable_& Name::handleTableInstance_()
{
  // Meyers singleton, created first time function is invoked.

  static HandleTable_ handleTable(1,"0");

  return handleTable;
}

inline
Name::HandleMap_& Name::handleMapInstance_()
{
  // Meyers singleton, created first time function is invoked.
  static HandleMap_ handleMap;

  handleTableInstance_();

  return handleMap;
}



#endif