NamedO.C

Go to the documentation of this file.

#include "jbltools/sfh/NamedO.h"

#include <iostream>
#include <sstream>

#include <cassert>
#include <vector>
#include <map>
#include <algorithm>
#include <string>

// #ifdef DEBUG
// #undef DEBUG
// #endif
// #define DEBUG 2

static const char *ident="@(#)$Id: NamedO.C,v 1.11 2006/06/30 11:05:00 blist Exp $";

typedef std::map<std::string, NamedO *>  NamedObjectsType;
static NamedObjectsType                 *namedObjects = 0;
class MapValueEquals {
  public:
    MapValueEquals (NamedO *p_) : p(p_) {};
    bool operator() (std::pair<std::string, NamedO *> elem) {return elem.second == p;}
  private:
    NamedO *p;
};

int NamedO::Init::count = 0;

void NamedO::initMap() {
  namedObjects = new NamedObjectsType;
#if DEBUG>0
  std::cout << "NamedO::Init::count: Initialization finished." << std::endl;
#endif
}

NamedO::NamedO(const char * name_)
: name (name_ ? name_ : ""), 
  definition (name)
{
  reg(); 
}

NamedO::NamedO(const std::string& name_)
: name (name_), 
  definition (name)
{
  reg(); 
}

NamedO::NamedO(const std::string& name_, const std::string& definition_)
: name (name_), 
  definition (definition_)
{
  reg(); 
}

NamedO::~NamedO() { 
  unreg(); 
}

void NamedO::destroy() { 
  delete this; 
} 

void NamedO::reg() 
{
  // Because reg() is called within the constructor of 
  // NamedO, we cannot yet call "getName()", because 
  // getName will only work after the whole constructor has been completed.
  // So for the time being we just register the object in the list.
  // All objects such registered will be transferred to the namedObjects map
  // with the updateMap function before the map is used to search for an object.
  if (!namedObjects) {
    std::cerr << "NamedO::reg(): namedObjects don't exist yet!" << std::endl;
    initMap();
  }
  if (name != "" && name != "?" && name != " ") {
#if DEBUG>1 
    std::cout << "NamedO::reg(): registering " << getName() << std::endl;
#endif /* #if DEBUG>1 */
    if (namedObjects->find(name) != namedObjects->end()) {
#if DEBUG>0 
      std::cerr << "NamedO::reg(): Trying to overwrite named object " << name << std::endl;
      // assert (namedObjects->find(name) == namedObjects->end());
#endif /* #if DEBUG>1 */
    }
    else {
      (*namedObjects)[name]=this; 
    }
  }
  else {
#if DEBUG>1 
    std::cout << "NamedO::reg(): will not register " << getName() << std::endl;
#endif /* #if DEBUG>1 */
  
  }
}

void NamedO::unreg() {
  NamedObjectsType::iterator i = find_if (namedObjects->begin(), namedObjects->end(), MapValueEquals(this));
  if (i != namedObjects->end()) {
#if DEBUG>1
      std::cout << "NamedO::unreg: removing " << (i->second ? i->second->getName() : "?") 
                << " from namedObjects " << std::endl;
#endif /* #if DEBUG>1 */
    namedObjects->erase(i);
  }                                                   
}

const char *NamedO::getName() const {
  return name.c_str();
}

const char *NamedO::getDefinition() const {
  return definition.c_str();
}

NamedO& NamedO::setName(const std::string& newname) {
  // don't remove object from map
  // unreg();
  name = newname;
  // prepare registration under new name
  reg();
  return *this;
}

NamedO& NamedO::setName(const char *newname) {
  return setName (std::string(newname ? newname : ""));
}

NamedO& NamedO::setDefinition(const std::string& newdef) {
  definition = newdef;
  return *this;
}

std::ostream& NamedO::print (std::ostream& os) const {
  os << getName() << ": " << getDefinition();
  return os;
}                       


NamedO *NamedO::getObject (const std::string& name) {
  NamedObjectsType::iterator it = namedObjects->find(name);
  //if (it == namedObjects->end()) return 0;
  //return it-second;
  NamedO *result = (it == namedObjects->end() ? 0 : it->second);
#if DEBUG>1
    std::cout << "NamedO::getObject: returning " << (result ? result->getName() : "NONE") 
              << " for " << name << std::endl;
#endif /* #if DEBUG>1 */
  return result;
}

NamedO *NamedO::getObject (const char *name) {
  if (!name) return 0;
  return getObject (std::string (name));
}

std::string NamedO::str (char c) {
  std::ostringstream os;
  os << c;
  return os.str();
}

std::string NamedO::str (const char *s) {
  return std::string(s);
}

std::string NamedO::str (int i) {
  std::ostringstream os;
  os << i;
  return os.str();
}

std::string NamedO::str (int i, int wide) {
  std::ostringstream os;
  os.width(wide);
  os.fill('0');
  os << i;
  return os.str();
}

std::string NamedO::str (float f) {
  std::ostringstream os;
  os << f;
  return os.str();
}

std::string NamedO::str (double d) {
  std::ostringstream os;
  os << d;
  return os.str();
}

std::string NamedO::str (bool b) {
  return b ? "true" : "false";
}

std::ostream& NamedO::listObjects(std::ostream& os) {
  if (!namedObjects) {
    std::cerr << "NamedO::listObjects: newObjects don't exist!\n";
    return os;
  }
  os << "List of NamedO objects:\n";
  for (NamedObjectsType::const_iterator it = namedObjects->begin(); it!=namedObjects->end(); ++it) {
    os << it->first << ": " << it->second->getName() << " = " << it->second->getDefinition() << '\n';
  }
  return os;
}

std::ostream& operator<< (std::ostream& os, const NamedO& rhs) {
  rhs.print(os);
  return os;
}

---