ObjSelector.h

Go to the documentation of this file.

#ifndef   oo_ObjSelector_H__
#define   oo_ObjSelector_H__

#include "ObjBase.h"

#include <utility>
#include <vector>
#include <string>
#include <map>

#include <cstdlib>
#include <cstdio>

namespace meow {

template<size_t id> 
class ObjSelector {
private:
  struct Info {
    ObjSelector*       parent_;
    ObjBase const*    pointer_;
    bool           autoDelete_;

    Info(ObjSelector*   parent,
         ObjBase const* ptr,
         bool           autoDelete) {
      parent_     = parent;
      pointer_    = ptr;
      autoDelete_ = autoDelete;
    }

    ~Info() {
      if (autoDelete_) {
        delete pointer_;
      }
      if (parent_ != NULL) {
        parent_->me_.second = NULL;
      }
    }
  };
  friend struct Info;

  typedef typename std::map<std::string, Info*>           Infos;
  typedef typename std::map<std::string, Info*>::iterator InfosIterator;

  static Infos& funcs() {
    static Infos f;
    return f;
  }
  static Info* add(std::string  name,
                   ObjSelector* parent,
                   ObjBase*     ptr,
                   bool         autoDelete) {
    Info* info = new Info(parent, ptr, autoDelete);
    del(name);
    funcs()[name] = info;
    return info;
  }

  std::pair<std::string, Info*> me_;
public:
  static void add(std::string name, ObjBase* obj, bool autoDelete) {
    add(name, NULL, obj, autoDelete);
  }

  static void add(ObjBase* obj, bool autoDelete) {
    add(obj->type(), NULL, obj, autoDelete);
  }

  static void del(std::string name) {
    if (funcs().find(name) != funcs().end()) {
      delete funcs()[name];
      funcs().erase(name);
    }
  }

  static ObjBase const* get(std::string name) {
    if (funcs().find(name) == funcs().end()) return NULL;
    return funcs()[name]->pointer_;
  }

  static ObjBase* create(std::string name) {
    ObjBase const* ptr = get(name);
    if(ptr == NULL) return NULL;
    return ptr->create();
  }

  static bool exist(ObjBase* obj) {
    for (InfosIterator it = funcs().begin(); it != funcs().end(); it++) {
      if (it->second->pointer_ == obj ||
          (it->second->pointer_ != NULL &&
           it->second->pointer_->type() == obj->type())) {
        return true;
      }
    }
    return false;
  }

  static std::string name(ObjBase* obj) {
    for (InfosIterator it = funcs().begin(); it != funcs().end(); it++) {
      if (it->second->pointer_ == obj ||
          (it->second->pointer_ != NULL &&
           it->second->pointer_->type() == obj->type())) {
        return it->first;
      }
    }
    return std::string();
  }

  static std::vector<std::string> names() {
    std::vector<std::string> ret;
    for (InfosIterator it = funcs().begin(); it != funcs().end(); it++)
      ret.push_back(it->first);
    return ret;
  }

  ObjSelector(std::string name, ObjBase* obj, bool autoDelete) {
    me_.first  = name;
    me_.second = add(me_.first, this, obj, autoDelete);
  }

  ObjSelector(ObjBase* obj, bool autoDelete) {
    me_.first  = obj->type();
    me_.second = add(me_.first, this, obj, autoDelete);
  }

  ~ObjSelector() {
    if (me_.second != NULL) {
      del(me_.first);
    }
  }

  static bool write(FILE* f, bool binary, ObjBase* obj, unsigned int fg) {
    if (!exist(obj)) return false;
    char const* nme = name(obj).c_str();
    size_t len = strlen(nme);
    if (binary) {
      if (fwrite(&len, sizeof(size_t      ),   1, f) <   1) return false;
      if (fwrite(nme , sizeof(char        ), len, f) < len) return false;
      if (fwrite(&fg , sizeof(unsigned int),   1, f) <   1) return false;
    } else {
      if (fprintf(f, "%s %u\n", nme, fg) < 2) return false;
    }
    return obj->write(f, binary, fg);
  }

  static ObjBase* read(FILE* f, bool binary) {
    static char name[2048];
    size_t len;
    unsigned int fg;
    if (binary) {
      if (fread(&len, sizeof(size_t      ),   1, f) <   1) return NULL;
      if (fread(name, sizeof(char        ), len, f) < len) return NULL;
      if (fread(&fg , sizeof(unsigned int),   1, f) <   1) return NULL;
      name[len] = '\0';
    } else {
      if (fscanf(f, "%s %u", name, &fg) < 2) return NULL;
    }
    ObjBase* ret = create(std::string(name));
    if (ret != NULL && ret->read(f, binary, fg) == false) {
      delete ret;
      ret = NULL;
    }
    return ret;
  }
};

static const size_t kGlobalSeletorID = 0;

} // meow

#endif // oo_ObjSelector_H__