adaptor.cc

Go to the documentation of this file.

// Copyright (C) 2018-2022 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#include <config.h>
 
#include <yang/adaptor.h>
 
#include <iostream>
 
using namespace std;
using namespace isc::data;
 
namespace isc {
namespace yang {
 
ConstElementPtr
Adaptor::getContext(ConstElementPtr parent) {
    ConstElementPtr context = parent->get("user-context");
    ConstElementPtr comment = parent->get("comment");
    if (!comment) {
        return (context);
    }
    ElementPtr result;
    if (context) {
        result = copy(context);
    } else {
        result = Element::createMap();
    }
    result->set("comment", comment);
    return (result);
}
 
void
Adaptor::fromParent(const string& name, ConstElementPtr parent,
                    ConstElementPtr list) {
    ConstElementPtr param = parent->get(name);
    if (!param) {
        return;
    }
    for (ElementPtr const& item : list->listValue()) {
        // don't override. Skip this entry if it already has the parameter.
        if (item->contains(name)) {
            continue;
        }
        item->set(name, param);
    }
}
 
void
Adaptor::toParent(const string& name, ElementPtr parent,
                  ConstElementPtr list) {
    ConstElementPtr param;
    bool first = true;
    for (ElementPtr const& item : list->listValue()) {
        if (first) {
            first = false;
            param = item->get(name);
        } else if ((!param && item->contains(name)) ||
                   (param && !item->contains(name)) ||
                   (param && item->contains(name) &&
                    !param->equals(*item->get(name)))) {
            isc_throw(BadValue,
                      "inconsistent value of " << name
                      << " in " << list->str());
        }
    }
    if (!first && param) {
        for (ElementPtr const& item : list->listValue()) {
            if (param) {
                item->remove(name);
            }
        }
        parent->set(name, param);
    }
}
 
namespace {
 
void applyInsert(ConstElementPtr key, ConstElementPtr value,
                 ElementPtr scope) {
    if (scope->getType() == Element::map) {
        if (!key || !value || (key->getType() != Element::string)) {
            return;
        }
        string name = key->stringValue();
        if (!name.empty() && !scope->contains(name)) {
            scope->set(name, copy(value));
        }
    } else if (scope->getType() == Element::list) {
        if (value) {
            scope->add(copy(value));
        }
    }
}
 
void applyReplace(ConstElementPtr key, ConstElementPtr value,
                   ElementPtr scope) {
    if ((scope->getType() != Element::map) ||
        !key || !value || (key->getType() != Element::string)) {
            return;
    }
    string name = key->stringValue();
    if (!name.empty()) {
        scope->set(name, copy(value));
    }
}
 
void applyDelete(ConstElementPtr key, ElementPtr scope) {
    if (scope->getType() == Element::map) {
        if (!key || (key->getType() != Element::string)) {
            return;
        }
        string name = key->stringValue();
        if (!name.empty()) {
            scope->remove(name);
        }
    } else if (scope->getType() == Element::list) {
        if (!key) {
            return;
        } else if (key->getType() == Element::integer) {
            int index = key->intValue();
            if ((index >= 0) && (index < scope->size())) {
                scope->remove(index);
            }
        } else if (key->getType() == Element::map) {
            ConstElementPtr entry = key->get("key");
            ConstElementPtr value = key->get("value");
            if (!entry || !value || (entry->getType() != Element::string)) {
                return;
            }
            string name = entry->stringValue();
            if (name.empty()) {
                return;
            }
            for (int i = 0; i < scope->size(); ++i) {
                ElementPtr item = scope->getNonConst(i);
                if (!item || (item->getType() != Element::map)) {
                    continue;
                }
                ConstElementPtr compare = item->get(name);
                if (compare && value->equals(*compare)) {
                    scope->remove(i);
                    return;
                }
            }
        }
    }
}
 
void applyAction(ConstElementPtr actions, ElementPtr scope, size_t next) {
    if (next == actions->size()) {
        return;
    }
    ConstElementPtr action = actions->get(next);
    ++next;
    if (!action || (action->getType() != Element::map) ||
        !action->contains("action")) {
        applyAction(actions, scope, next);
        return;
    }
    string name = action->get("action")->stringValue();
    if (name == "insert") {
        applyInsert(action->get("key"), action->get("value"), scope);
    } else if (name == "replace") {
        applyReplace(action->get("key"), action->get("value"), scope);
    } else if (name == "delete") {
        applyDelete(action->get("key"), scope);
    }
    applyAction(actions, scope, next);
}
 
void applyDown(ConstElementPtr path, ConstElementPtr actions, ElementPtr scope,
               size_t next) {
    if (!scope) {
        return;
    }
    if (next == path->size()) {
        applyAction(actions, scope, 0);
        return;
    }
    ConstElementPtr step = path->get(next);
    ++next;
    if (scope->getType() == Element::map) {
        if (!step || (step->getType() != Element::string)) {
            return;
        }
        string name = step->stringValue();
        if (name.empty() || !scope->contains(name)) {
            return;
        }
        ConstElementPtr down(scope->get(name));
        if (down) {
            ElementPtr mutable_down(copy(down, 0));
            applyDown(path, actions, mutable_down, next);
            scope->set(name, mutable_down);
        }
    } else if (scope->getType() == Element::list) {
        if (!step) {
            return;
        }
        auto downs = scope->listValue();
        if (step->getType() == Element::map) {
            ConstElementPtr key = step->get("key");
            ConstElementPtr value = step->get("value");
            if (!key || !value || (key->getType() != Element::string)) {
                return;
            }
            string name = key->stringValue();
            if (name.empty()) {
                return;
            }
            for (ElementPtr down : downs) {
                if (!down || (down->getType() != Element::map)) {
                    continue;
                }
                ConstElementPtr compare = down->get(name);
                if (compare && value->equals(*compare)) {
                    applyDown(path, actions, down, next);
                    return;
                }
            }
        } else if (step->getType() != Element::integer) {
            return;
        }
        int index = step->intValue();
        if (index == -1) {
            for (ElementPtr down : downs) {
                applyDown(path, actions, down, next);
            }
        } else if ((index >= 0) && (index < scope->size())) {
            applyDown(path, actions, scope->getNonConst(index), next);
        }
    }
}
 
}  //anonymous namespace
 
void
Adaptor::modify(ConstElementPtr path, ConstElementPtr actions,
                ElementPtr config) {
    applyDown(path, actions, config, 0);
}
 
}  // namespace yang
}  // namespace isc