Subversion Repositories riscv_vhdl

/**
 * @file
 * @copyright  Copyright 2016 GNSS Sensor Ltd. All right reserved.
 * @author     Sergey Khabarov - sergeykhbr@gmail.com
 * @brief      Core Service interface declaration.
 */
 
#ifndef __DEBUGGER_SERVICE_H__
#define __DEBUGGER_SERVICE_H__
 
#include "iface.h"
#include "attribute.h"
#include "api_utils.h"
 
namespace debugger {
 
static const char *const IFACE_SERVICE = "IService";
 
class IService : public IFace {
public:
    IService(const char *obj_name) 
        : IFace(IFACE_SERVICE) {
        listInterfaces_ = AttributeType(Attr_List);
        listAttributes_ = AttributeType(Attr_List);
        registerInterface(static_cast<IService *>(this));
        registerAttribute("LogLevel", &logLevel_);
        obj_name_ = obj_name;
        logLevel_.make_int64(LOG_ERROR);
    }
    virtual ~IService() {}
 
    virtual void initService(const AttributeType *args) {
        if (!args || !args->is_list()) {
            return;
        }
        AttributeType *cur_attr;
        for (unsigned i = 0; i < args->size(); i++) {
            const AttributeType &item = (*args)[i];
            if (item.size() < 2 || !item[0u].is_string()) {
                continue;
            }
            cur_attr = static_cast<AttributeType *>(
                                getAttribute(item[0u].to_string()));
            if (cur_attr == NULL) {
                RISCV_error("Attribute '%s' not found", item[0u].to_string());
                continue;
            }
            (*cur_attr) = item[1];
            if (item.size() >= 3 && item[2].is_string()) {
                static_cast<IAttribute *>(cur_attr)->setAttrDescription(
                    item[2].to_string());
            }
        }
    }
 
    virtual void postinitService() {}
    virtual void predeleteService() {}
 
    virtual void registerInterface(IFace *iface) {
        AttributeType item(iface);
        listInterfaces_.add_to_list(&item);
    }
 
    virtual void unregisterInterface(IFace *iface) {
        for (unsigned i = 0; i < listInterfaces_.size(); i++) {
            if (listInterfaces_[i].to_iface() == iface) {
                listInterfaces_.remove_from_list(i);
                break;
            }
        }
    }
 
    virtual IFace *getInterface(const char *name) {
        IFace *tmp;
        for (unsigned i = 0; i < listInterfaces_.size(); i++) {
            tmp = listInterfaces_[i].to_iface();
            if (strcmp(name, tmp->getFaceName()) == 0) {
                return tmp;
            }
        }
        return NULL;
    }
 
    virtual void registerAttribute(const char *name, IAttribute *iface) {
        AttributeType item(iface);
        iface->setAttrName(name);
        listAttributes_.add_to_list(&item);
    }
 
    virtual IAttribute *getAttribute(const char *name) {
        IAttribute *tmp;
        for (unsigned i = 0; i < listAttributes_.size(); i++) {
            tmp = static_cast<IAttribute *>(listAttributes_[i].to_iface());
            if (strcmp(name, tmp->getAttrName()) == 0) {
                return tmp;
            }
        }
        return NULL;
    }
 
    virtual const char *getObjName() { return obj_name_; }
 
    virtual AttributeType getConfiguration() {
        AttributeType ret(Attr_Dict);
        ret["Name"] = AttributeType(getObjName());
        ret["Attr"] = AttributeType(Attr_List);
 
        IAttribute *tmp = NULL;
        for (unsigned i = 0; i < listAttributes_.size(); i++) {
            tmp = static_cast<IAttribute *>(listAttributes_[i].to_iface());
            AttributeType item;
            item.make_list(2);
            item[0u].make_string(tmp->getAttrName());
            item[1] = *static_cast<AttributeType *>(tmp);
            ret["Attr"].add_to_list(&item);
        }
        return ret;
    }
 
protected:
    AttributeType listInterfaces_;
    AttributeType listAttributes_;
    AttributeType logLevel_;
    const char *obj_name_;
};
 
}  // namespace debugger
 
#endif  // __DEBUGGER_SERVICE_H__