object.cpp

Go to the documentation of this file.

#include <assert.h>
#include <map>
#include <sstream>
#include "object.h"

const Object::id_t Object::empty_id;

typedef std::map<Object::id_t, _creator_t> _creator_map_t;

static _creator_map_t& _creator_map () {
    static _creator_map_t cmap;
    return cmap;
}

inline static bool _creator_registered (const Object::id_t& id) {
    return _creator_map().find(id) != _creator_map().end();
}

_register_creator::_register_creator (const Object::id_t& id, _creator_t cf) {
    assert(!_creator_registered(id));
    _creator_map()[id] = cf;
}

bool Object::serialize (std::ostream& os, ver_list& vl) const {
    assert(vl.size() > 0);
    ver_list::const_iterator p = vl.begin();
    os << "# " << id() << " v" << *p;
    for (++p; p != vl.end(); ++p)
        os << '.' << *p;
    os << '\n';
    return true;
}

static bool _get_id_ver (std::istream& is, Object::id_t& id,
                         std::vector<UINT>& vl) {
    assert(vl.empty());
    const UINT ignore_size = 512;

    // get the comment char #
    char c;
    if (!(is >> c)) return false;
    if (c != '#') {
        std::cerr << "_get_id_ver: Warning: # expected\n";
        is.ignore(ignore_size, '#');
    }

    // get the rest of the line
    char line[ignore_size];
    is.getline(line, ignore_size);
    std::istringstream iss(line);

    // get the identity (class name)
    if (!(iss >> id)) {
        std::cerr << "_get_id_ver: Error: no class id?\n";
        return false;
    }

    // get the version
    iss.ignore(ignore_size, 'v');
    UINT v;
    while (iss >> v) {
        assert(v > 0);
        vl.push_back(v);
        iss.ignore(1);
    }
    if (vl.empty()) {
        std::cerr << "_get_id_ver: Warning: pre-0.1 file format\n";
        if (id == "AdaBoost.M1") id = "AdaBoost";
        if (id.substr(0, 7) != "lemga::") id.insert(0, "lemga::");
        vl.push_back(0);
    }

    return true;
}

Object* Object::create (std::istream& is) {
    id_t _id;
    ver_list vl;
    if (!_get_id_ver(is, _id, vl)) return 0;

    if (_creator_registered(_id)) {
        Object* p = _creator_map()[_id]();
        p->unserialize(is, vl, _id);
        return p;
    }

    std::cerr << "Class (" << _id << ") not regiestered\n";
    return 0;
}

std::istream& operator>> (std::istream& is, Object& obj) {
    Object::id_t id;
    Object::ver_list vl;

    // unserialize() judges whether id and obj are compatible
    if (!_get_id_ver(is, id, vl) || !obj.unserialize(is, vl, id)) {
        std::cerr << "operator>>: something wrong...\n";
        is.setstate(std::ios::badbit);
    }
    assert(vl.empty() || vl[0] == 0);

    return is;
}

---