ITreeLoader.h

Go to the documentation of this file.

#pragma once

#include "common/Thread.h"
#include <memory>
#include <string>
#include <vector>
#include <map>
#include <cstdarg>
#include <cstdio>

namespace ai {

class IAIFactory;
class TreeNode;
typedef std::shared_ptr<TreeNode> TreeNodePtr;

class ITreeLoader {
protected:
    const IAIFactory& _aiFactory;
    typedef std::map<std::string, TreeNodePtr> TreeMap;
    TreeMap _treeMap;
    ReadWriteLock _lock = {"treeloader"};

    inline void resetError() {
        ScopedWriteLock scopedLock(_lock);
        _error = "";
    }
private:
    std::string _error;     
public:
    explicit ITreeLoader(const IAIFactory& aiFactory) :
            _aiFactory(aiFactory) {
    }

    virtual ~ITreeLoader() {
        _error = "";
        _treeMap.clear();
    }

    void shutdown() {
        ScopedWriteLock scopedLock(_lock);
        _error = "";
        _treeMap.clear();
    }

    inline const IAIFactory& getAIFactory() const {
        return _aiFactory;
    }

    void getTrees(std::vector<std::string>& trees) const {
        ScopedReadLock scopedLock(_lock);
        trees.reserve(_treeMap.size());
        for (TreeMap::const_iterator it = _treeMap.begin(); it != _treeMap.end(); ++it) {
            trees.push_back(it->first);
        }
    }

    bool addTree(const std::string& name, const TreeNodePtr& root) {
        if (!root) {
            return false;
        }
        {
            ScopedReadLock scopedLock(_lock);
            TreeMap::const_iterator i = _treeMap.find(name);
            if (i != _treeMap.end()) {
                return false;
            }
        }
        {
            ScopedWriteLock scopedLock(_lock);
            _treeMap.insert(std::make_pair(name, root));
        }
        return true;
    }

    TreeNodePtr load(const std::string &name) {
        ScopedReadLock scopedLock(_lock);
        TreeMap::const_iterator i = _treeMap.find(name);
        if (i != _treeMap.end())
            return i->second;
        return TreeNodePtr();
    }

    void setError(const char* msg, ...) __attribute__((format(printf, 2, 3)));

    inline std::string getError() const {
        return _error;
    }
};

inline void ITreeLoader::setError(const char* msg, ...) {
    va_list args;
    va_start(args, msg);
    char buf[1024];
    std::vsnprintf(buf, sizeof(buf), msg, args);
    va_end(args);
    if (buf[0] != '\0') {
        ai_log_debug("%s", buf);
    }
    ScopedWriteLock scopedLock(_lock);
    _error = buf;
}

}