--- /dev/null
+//{{{ Banner
+
+//============================================================================
+//
+// transaction.cxx
+//
+// Implementation of the CdlTransaction class
+//
+//============================================================================
+//####COPYRIGHTBEGIN####
+//
+// ----------------------------------------------------------------------------
+// Copyright (C) 1999, 2000, 2001, 2002 Red Hat, Inc.
+//
+// This file is part of the eCos host tools.
+//
+// This program is free software; you can redistribute it and/or modify it
+// under the terms of the GNU General Public License as published by the Free
+// Software Foundation; either version 2 of the License, or (at your option)
+// any later version.
+//
+// This program is distributed in the hope that it will be useful, but WITHOUT
+// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+// more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// this program; if not, write to the Free Software Foundation, Inc.,
+// 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+// ----------------------------------------------------------------------------
+//
+//####COPYRIGHTEND####
+//============================================================================
+//#####DESCRIPTIONBEGIN####
+//
+// Author(s): bartv
+// Contact(s): bartv
+// Date: 1999/07/16
+// Version: 0.01
+//
+//####DESCRIPTIONEND####
+//============================================================================
+
+//}}}
+//{{{ #include's
+
+// ----------------------------------------------------------------------------
+#include "cdlconfig.h"
+
+// Get the infrastructure types, assertions, tracing and similar
+// facilities.
+#include <cyg/infra/cyg_ass.h>
+#include <cyg/infra/cyg_trac.h>
+
+// <cdlcore.hxx> defines everything implemented in this module.
+// It implicitly supplies <string>, <vector> and <map> because
+// the class definitions rely on these headers.
+#include <cdlcore.hxx>
+
+//}}}
+
+//{{{ CdlTransactionCallback class
+
+// ----------------------------------------------------------------------------
+// The callback class is very straightforward. The hard work is done in
+// the transaction class.
+
+CdlTransactionCallback::CdlTransactionCallback(CdlTransaction transact_arg)
+{
+ CYG_REPORT_FUNCNAME("CdlTransactionCallback:: constructor");
+ CYG_REPORT_FUNCARG2XV(this, transact_arg);
+ CYG_PRECONDITION_CLASSC(transact_arg);
+
+ // The vectors etc. will take care of themselves.
+ transact = transact_arg;
+ cdltransactioncallback_cookie = CdlTransactionCallback_Magic;
+
+ CYG_POSTCONDITION_THISC();
+ CYG_REPORT_RETURN();
+}
+
+CdlTransactionCallback::~CdlTransactionCallback()
+{
+ CYG_REPORT_FUNCNAME("CdlTransactionCallback:: destructor");
+ CYG_REPORT_FUNCARG1XV(this);
+ CYG_PRECONDITION_THISC();
+
+ cdltransactioncallback_cookie = CdlTransactionCallback_Invalid;
+ transact = 0;
+ value_changes.clear();
+ active_changes.clear();
+ legal_values_changes.clear();
+ value_source_changes.clear();
+ new_conflicts.clear();
+ new_structural_conflicts.clear();
+ nodes_with_resolved_conflicts.clear();
+ nodes_with_resolved_structural_conflicts.clear();
+
+ CYG_REPORT_RETURN();
+}
+
+void
+CdlTransactionCallback::set_callback_fn(void (*fn)(const CdlTransactionCallback&))
+{
+ CYG_REPORT_FUNCNAME("CdlTransactionCallback::set_callback_fn");
+ CYG_REPORT_FUNCARG1XV(fn);
+
+ CdlTransactionBody::set_callback_fn(fn);
+
+ CYG_REPORT_RETURN();
+}
+
+void (*CdlTransactionCallback::get_callback_fn())(const CdlTransactionCallback&)
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlTransactionCallback::get_callback_fn", "result %p");
+
+ void (*result)(const CdlTransactionCallback&) = CdlTransactionBody::get_callback_fn();
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+CdlTransaction
+CdlTransactionCallback::get_transaction() const
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlTransactionCallback::get_transaction", "result %p");
+ CYG_PRECONDITION_THISC();
+
+ CdlTransaction result = transact;
+ CYG_POSTCONDITION_CLASSC(result);
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+CdlToplevel
+CdlTransactionCallback::get_toplevel() const
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlTransactionCallback::get_toplevel", "result %p");
+ CYG_PRECONDITION_THISC();
+
+ CdlToplevel result = transact->get_toplevel();
+ CYG_POSTCONDITION_CLASSC(result);
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+bool
+CdlTransactionCallback::check_this(cyg_assert_class_zeal zeal) const
+{
+ if (CdlTransactionCallback_Magic != cdltransactioncallback_cookie) {
+ return false;
+ }
+ return true;
+}
+
+//}}}
+//{{{ CdlTransaction statics
+
+// ----------------------------------------------------------------------------
+void (*CdlTransactionBody::callback_fn)(const CdlTransactionCallback&) = 0;
+CdlInferenceCallback CdlTransactionBody::inference_callback = 0;
+bool CdlTransactionBody::inference_enabled = true;
+int CdlTransactionBody::inference_recursion_limit = 3;
+CdlValueSource CdlTransactionBody::inference_override = CdlValueSource_Inferred;
+CYGDBG_DEFINE_MEMLEAK_COUNTER(CdlTransactionBody);
+
+//}}}
+//{{{ Transaction creation and destruction
+
+// ----------------------------------------------------------------------------
+CdlTransaction
+CdlTransactionBody::make(CdlToplevel toplevel)
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlTransaction::make", "result %p");
+ CYG_REPORT_FUNCARG1XV(toplevel);
+ CYG_PRECONDITION_CLASSC(toplevel);
+ CYG_PRECONDITIONC(0 == toplevel->transaction);
+
+ CdlTransaction result = new CdlTransactionBody(toplevel, 0, 0);
+ toplevel->transaction = result;
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+CdlTransaction
+CdlTransactionBody::make(CdlConflict conflict)
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlTransaction::make (sub-transaction)", "result %p");
+ CYG_REPORT_FUNCARG2XV(this, conflict);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_ZERO_OR_CLASSC(conflict);
+
+ CdlTransaction result = new CdlTransactionBody(0, this, conflict);
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+CdlTransactionBody::CdlTransactionBody(CdlToplevel toplevel_arg, CdlTransaction parent_arg, CdlConflict conflict_arg)
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction:: constructor");
+ CYG_REPORT_FUNCARG4XV(this, toplevel_arg, parent_arg, conflict_arg);
+ CYG_PRECONDITION_ZERO_OR_CLASSC(toplevel_arg);
+ CYG_PRECONDITION_ZERO_OR_CLASSC(parent_arg);
+ CYG_PRECONDITION_ZERO_OR_CLASSC(conflict_arg);
+ CYG_PRECONDITIONC( ((0 == toplevel_arg) && (0 != parent_arg)) || ((0 == parent_arg) && (0 != toplevel_arg)));
+
+ // The containers will take care of themselves, as will all_changes
+ toplevel = toplevel_arg;
+ parent = parent_arg;
+ conflict = conflict_arg;
+ dirty = false;
+ cdltransactionbody_cookie = CdlTransactionBody_Magic;
+ CYGDBG_MEMLEAK_CONSTRUCTOR();
+
+ CYG_POSTCONDITION_THISC();
+ CYG_REPORT_RETURN();
+}
+
+// ----------------------------------------------------------------------------
+CdlTransactionBody::~CdlTransactionBody()
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction:: destructor");
+ CYG_REPORT_FUNCARG1XV(this);
+ CYG_PRECONDITION_THISC();
+
+ // The transaction must have been either committed or cancelled.
+ // This means that various of the STL containers should be empty
+ CYG_ASSERTC(0 == commit_cancel_ops.size());
+ CYG_ASSERTC(0 == changes.size());
+ CYG_ASSERTC(0 == deleted_conflicts.size());
+ CYG_ASSERTC(0 == deleted_structural_conflicts.size());
+ CYG_ASSERTC(0 == new_conflicts.size());
+ CYG_ASSERTC(0 == new_structural_conflicts.size());
+ CYG_ASSERTC(0 == resolved_conflicts.size());
+ CYG_ASSERTC(0 == global_conflicts_with_solutions.size());
+ CYG_ASSERTC(0 == activated.size());
+ CYG_ASSERTC(0 == deactivated.size());
+ CYG_ASSERTC(0 == legal_values_changes.size());
+ CYG_ASSERTC(0 == value_changes.size());
+ CYG_ASSERTC(0 == active_changes.size());
+
+ // If this was a toplevel transaction, the toplevel knows
+ // about the transaction.
+ if (0 != toplevel) {
+ CYG_ASSERTC(toplevel->transaction == this);
+ toplevel->transaction = 0;
+ }
+ cdltransactionbody_cookie = CdlTransactionBody_Invalid;
+ toplevel = 0;
+ parent = 0;
+ conflict = 0;
+ dirty = false;
+
+ CYGDBG_MEMLEAK_DESTRUCTOR();
+
+ CYG_REPORT_RETURN();
+}
+
+//}}}
+//{{{ check_this()
+
+// ----------------------------------------------------------------------------
+
+bool
+CdlTransactionBody::check_this(cyg_assert_class_zeal zeal) const
+{
+ if (CdlTransactionBody_Magic != cdltransactionbody_cookie) {
+ return false;
+ }
+ CYGDBG_MEMLEAK_CHECKTHIS();
+
+ //zeal = cyg_extreme;
+ switch(zeal) {
+ case cyg_system_test:
+ case cyg_extreme :
+ {
+ std::map<CdlValuable,CdlValue>::const_iterator map_i;
+ for (map_i = changes.begin(); map_i != changes.end(); map_i++) {
+ if (!map_i->first->check_this(cyg_quick) || !map_i->second.check_this(cyg_quick)) {
+ return false;
+ }
+ }
+
+ std::list<CdlConflict>::const_iterator conf_i;
+ for (conf_i = new_conflicts.begin(); conf_i != new_conflicts.end(); conf_i++) {
+ if (!(*conf_i)->check_this(cyg_quick)) {
+ return false;
+ }
+ }
+ for (conf_i = new_structural_conflicts.begin(); conf_i != new_structural_conflicts.end(); conf_i++) {
+ if (!(*conf_i)->check_this(cyg_quick)) {
+ return false;
+ }
+ }
+
+ std::vector<CdlConflict>::const_iterator conf_i2;
+ for (conf_i2 = deleted_conflicts.begin(); conf_i2 != deleted_conflicts.end(); conf_i2++) {
+ if (!(*conf_i2)->check_this(cyg_quick)) {
+ return false;
+ }
+ }
+ for (conf_i2 = resolved_conflicts.begin(); conf_i2 != resolved_conflicts.end(); conf_i2++) {
+ if (!(*conf_i2)->check_this(cyg_quick)) {
+ return false;
+ }
+ }
+ for (conf_i2 = deleted_structural_conflicts.begin(); conf_i2 != deleted_structural_conflicts.end(); conf_i2++) {
+ if (!(*conf_i2)->check_this(cyg_quick)) {
+ return false;
+ }
+ }
+ for (conf_i = global_conflicts_with_solutions.begin(); conf_i != global_conflicts_with_solutions.end(); conf_i++) {
+ if (!(*conf_i)->check_this(cyg_quick)) {
+ return false;
+ }
+ if (0 != (*conf_i)->transaction) {
+ return false;
+ }
+ }
+
+ // Nodes cannot have been both activated and deactivated in one transaction
+ std::set<CdlNode>::const_iterator node_i;
+ for (node_i = activated.begin(); node_i != activated.end(); node_i++) {
+ if (!(*node_i)->check_this(cyg_quick)) {
+ return false;
+ }
+ if (deactivated.end() != deactivated.find(*node_i)) {
+ return false;
+ }
+ }
+ for (node_i = deactivated.begin(); node_i != deactivated.end(); node_i++) {
+ if (!(*node_i)->check_this(cyg_quick)) {
+ return false;
+ }
+ if (activated.end() != activated.find(*node_i)) {
+ return false;
+ }
+ }
+ std::set<CdlValuable>::const_iterator val_i;
+ for (val_i = legal_values_changes.begin(); val_i != legal_values_changes.end(); val_i++) {
+ if (!(*val_i)->check_this(cyg_quick)) {
+ return false;
+ }
+ }
+
+ std::deque<CdlValuable>::const_iterator val_i2;
+ for (val_i2 = value_changes.begin(); val_i2 != value_changes.end(); val_i2++) {
+ if (!(*val_i2)->check_this(cyg_quick)) {
+ return false;
+ }
+ }
+
+ std::deque<CdlNode>::const_iterator active_i;
+ for (active_i = active_changes.begin(); active_i != active_changes.end(); active_i++) {
+ if (!(*active_i)->check_this(cyg_quick)) {
+ return false;
+ }
+ }
+ }
+ case cyg_thorough:
+ if ((0 != toplevel) && !toplevel->check_this(cyg_quick)) {
+ return false;
+ }
+ if ((0 != parent) && !parent->check_this(cyg_quick)) {
+ return false;
+ }
+ if ((0 != conflict) && !conflict->check_this(cyg_quick)) {
+ return false;
+ }
+
+ case cyg_quick:
+ case cyg_trivial :
+ if ((0 == toplevel) && (0 == parent)) {
+ return false;
+ }
+ if (this == parent) {
+ return false;
+ }
+
+ case cyg_none :
+ break;
+ }
+
+ return true;
+}
+
+//}}}
+//{{{ Misc
+
+// ----------------------------------------------------------------------------
+CdlToplevel
+CdlTransactionBody::get_toplevel() const
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlTransaction::get_toplevel", "result %p");
+ CYG_REPORT_FUNCARG1XV(this);
+ CYG_PRECONDITION_THISC();
+
+ CdlToplevel result = toplevel;
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+CdlTransaction
+CdlTransactionBody::get_parent() const
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlTransaction::get_parent", "result %p");
+ CYG_REPORT_FUNCARG1XV(this);
+ CYG_PRECONDITION_THISC();
+
+ CdlTransaction result = parent;
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+CdlConflict
+CdlTransactionBody::get_conflict() const
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlTransaction::get_conflict", "result %p");
+ CYG_REPORT_FUNCARG1XV(this);
+ CYG_PRECONDITION_THISC();
+
+ CdlConflict result = conflict;
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+
+// ----------------------------------------------------------------------------
+void (*CdlTransactionBody::get_callback_fn())(const CdlTransactionCallback&)
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlTransaction::get_callback_fn", "result %p");
+
+ void (*result)(const CdlTransactionCallback&) = callback_fn;
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+void
+CdlTransactionBody::set_callback_fn(void (*fn)(const CdlTransactionCallback&))
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::set_callback_fn");
+ CYG_REPORT_FUNCARG1XV(fn);
+
+ callback_fn = fn;
+
+ CYG_REPORT_RETURN();
+}
+
+CdlInferenceCallback
+CdlTransactionBody::get_inference_callback_fn()
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlTransaction::get_inference_callback_fn", "result %p");
+
+ CdlInferenceCallback result = inference_callback;
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+void
+CdlTransactionBody::set_inference_callback_fn(CdlInferenceCallback fn)
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::set_inference_callback");
+ CYG_REPORT_FUNCARG1XV(fn);
+
+ inference_callback = fn;
+
+ CYG_REPORT_RETURN();
+}
+
+void
+CdlTransactionBody::enable_automatic_inference()
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::enable_automatic_inference");
+
+ inference_enabled = true;
+
+ CYG_REPORT_RETURN();
+}
+
+void
+CdlTransactionBody::disable_automatic_inference()
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::disable_automatic_inference");
+
+ inference_enabled = false;
+
+ CYG_REPORT_RETURN();
+}
+
+bool
+CdlTransactionBody::is_automatic_inference_enabled()
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlTransaction::is_automatic_inference_enabled", "result %d");
+
+ bool result = inference_enabled;
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+void
+CdlTransactionBody::set_inference_recursion_limit(int limit)
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::set_inference_recursion_limit");
+ CYG_REPORT_FUNCARG1XV(limit);
+ CYG_PRECONDITIONC(0 < limit);
+ CYG_PRECONDITIONC(limit < 16); // arbitrary number
+
+ inference_recursion_limit = limit;
+
+ CYG_REPORT_RETURN();
+}
+
+int
+CdlTransactionBody::get_inference_recursion_limit()
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlTransaction::get_inference_recursion_limit", "result %d");
+
+ int result = inference_recursion_limit;
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+void
+CdlTransactionBody::set_inference_override(CdlValueSource source)
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::set_inference_override");
+ CYG_REPORT_FUNCARG1XV(source);
+ CYG_PRECONDITIONC((CdlValueSource_Invalid == source) || Cdl::is_valid_value_source(source));
+
+ inference_override = source;
+
+ CYG_REPORT_RETURN();
+}
+
+CdlValueSource
+CdlTransactionBody::get_inference_override()
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlTransaction::get_inference_override", "result %d");
+
+ CdlValueSource result = inference_override;
+
+ CYG_REPORT_RETVAL((int) result);
+ return result;
+}
+
+//}}}
+//{{{ Value access and updates
+
+// ----------------------------------------------------------------------------
+const CdlValue&
+CdlTransactionBody::get_whole_value(CdlConstValuable valuable_arg) const
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlTransaction::get_whole_value", "result %p");
+ CYG_REPORT_FUNCARG2XV(this, valuable_arg);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_CLASSC(valuable_arg);
+
+ // Unfortunately I need a valuable rather than a const-valuable when
+ // accessing the STL containers.
+ CdlValuable valuable = const_cast<CdlValuable>(valuable_arg);
+
+ // If we are trying to find a solution, keep track of all valuables
+ // that were accessed.
+ const CdlValue* result = 0;
+ if (0 != conflict) {
+ conflict->solution_references.insert(valuable);
+ }
+
+ std::map<CdlValuable,CdlValue>::const_iterator val_i;
+ val_i = changes.find(valuable);
+ if (val_i != changes.end()) {
+ result = &(val_i->second);
+ } else if (0 != parent) {
+ result = &(parent->get_whole_value(valuable));
+ } else {
+ result = &(valuable->get_whole_value());
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return *result;
+}
+
+void
+CdlTransactionBody::set_whole_value(CdlValuable valuable, const CdlValue& old_value, const CdlValue& new_value)
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::set_whole_value");
+ CYG_REPORT_FUNCARG3XV(this, valuable, &new_value);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_CLASSC(valuable);
+ CYG_PRECONDITION_CLASSOC(old_value);
+ CYG_PRECONDITION_CLASSOC(new_value);
+ CYG_PRECONDITIONC(&old_value != &new_value);
+
+ CdlValueFlavor flavor = old_value.get_flavor();
+ CYG_ASSERTC(flavor == new_value.get_flavor());
+ CYG_ASSERTC(CdlValueFlavor_None != flavor);
+
+ bool value_changed = false;
+ bool bool_changed = false;
+
+ if ((CdlValueFlavor_Bool == flavor) || (CdlValueFlavor_BoolData == flavor)) {
+ if (old_value.is_enabled() != new_value.is_enabled()) {
+ value_changed = true;
+ bool_changed = true;
+ }
+ }
+ if (!value_changed && ((CdlValueFlavor_BoolData == flavor) || (CdlValueFlavor_Data == flavor))) {
+ if (old_value.get_simple_value() != new_value.get_simple_value()) {
+ value_changed = true;
+ }
+ }
+ if (value_changed) {
+ std::deque<CdlValuable>::const_iterator change_i;
+ change_i = std::find(value_changes.begin(), value_changes.end(), valuable);
+ if (change_i == value_changes.end()) {
+ value_changes.push_back(valuable);
+ }
+ }
+
+ // Actually do the update. This may modify old_value, so has to be
+ // left to the end.
+ changes[valuable] = new_value;
+
+ // If there was a change to the boolean part of the value and the valuable
+ // implements an interface, the interface value needs to be recalculated.
+ if (bool_changed && valuable->has_property(CdlPropertyId_Implements)) {
+ std::vector<CdlInterface> interfaces;
+ std::vector<CdlInterface>::const_iterator interface_i;
+ valuable->get_implemented_interfaces(interfaces);
+ for (interface_i = interfaces.begin(); interface_i != interfaces.end(); interface_i++) {
+ (*interface_i)->recalculate(this);
+ }
+ }
+
+ CYG_REPORT_RETURN();
+}
+
+const std::map<CdlValuable, CdlValue>&
+CdlTransactionBody::get_changes() const
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::get_changes");
+ CYG_REPORT_FUNCARG1XV(this);
+ CYG_PRECONDITION_THISC();
+
+ CYG_REPORT_RETURN();
+ return changes;
+}
+
+//}}}
+//{{{ Active access and updates
+
+// ----------------------------------------------------------------------------
+// Nodes can become active or inactive during transactions, and this affects
+// propagation and expression evaluation
+
+bool
+CdlTransactionBody::is_active(CdlNode node) const
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlTransaction::is_active", "result %d");
+ CYG_REPORT_FUNCARG2XV(this, node);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_CLASSC(node);
+
+ bool result = false;
+ if (activated.end() != activated.find(node)) {
+ result = true;
+ } else if (deactivated.end() != deactivated.find(node)) {
+ result = false;
+ } else if (0 != parent) {
+ result = parent->is_active(node);
+ } else {
+ result = node->is_active();
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+void
+CdlTransactionBody::set_active(CdlNode node, bool state)
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::set_active");
+ CYG_REPORT_FUNCARG3XV(this, node, state);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_CLASSC(node);
+
+ if (state) {
+ activated.insert(node);
+ std::set<CdlNode>::iterator node_i = deactivated.find(node);
+ if (deactivated.end() != node_i) {
+ deactivated.erase(node_i);
+ }
+ } else {
+ deactivated.insert(node);
+ std::set<CdlNode>::iterator node_i = activated.find(node);
+ if (activated.end() != node_i) {
+ activated.erase(node_i);
+ }
+ }
+ active_changes.push_back(node);
+
+ CdlValuable valuable = dynamic_cast<CdlValuable>(node);
+ if ((0 != valuable) && valuable->has_property(CdlPropertyId_Implements)) {
+ std::vector<CdlInterface> interfaces;
+ std::vector<CdlInterface>::const_iterator interface_i;
+ valuable->get_implemented_interfaces(interfaces);
+ for (interface_i = interfaces.begin(); interface_i != interfaces.end(); interface_i++) {
+ (*interface_i)->recalculate(this);
+ }
+ }
+
+ CYG_REPORT_RETURN();
+}
+
+//}}}
+//{{{ Conflict access and updates
+
+//{{{ get_conflict() etc.
+
+// ----------------------------------------------------------------------------
+bool
+CdlTransactionBody::has_conflict(CdlNode node, bool (*pFn)(CdlConflict))
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlTransaction::has_conflict", "result %d");
+ CYG_REPORT_FUNCARG3XV(this, node, pFn);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_CLASSC(node);
+
+ // Because it is necessary to check whether or not any given
+ // conflict has been cleared in the current transaction or any
+ // parent transaction, recursion into the parent is not
+ // appropriate.
+ bool result = false;
+ std::list<CdlConflict>::const_iterator conf_i;
+ CdlTransaction current_transaction = this;
+ CdlToplevel toplevel = this->toplevel;
+ do {
+ CYG_LOOP_INVARIANT_CLASSC(current_transaction);
+
+ for (conf_i = current_transaction->new_conflicts.begin();
+ conf_i != current_transaction->new_conflicts.end();
+ conf_i++) {
+
+ if ((node == (*conf_i)->get_node()) &&
+ !(this->has_conflict_been_cleared(*conf_i)) && (*pFn)(*conf_i)) {
+ result = true;
+ break;
+ }
+ }
+
+ toplevel = current_transaction->toplevel;
+ current_transaction = current_transaction->parent;
+ } while (!result && (0 != current_transaction));
+
+ if (!result) {
+ CYG_ASSERT_CLASSC(toplevel);
+ for (conf_i = toplevel->conflicts.begin(); conf_i != toplevel->conflicts.end(); conf_i++) {
+ if ((node == (*conf_i)->get_node()) && !(this->has_conflict_been_cleared(*conf_i)) && (*pFn)(*conf_i)) {
+ result = true;
+ break;
+ }
+ }
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+CdlConflict
+CdlTransactionBody::get_conflict(CdlNode node, bool (*pFn)(CdlConflict))
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlTransaction::get_conflict", "result %p");
+ CYG_REPORT_FUNCARG3XV(this, node, pFn);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_CLASSC(node);
+
+ CdlConflict result = 0;
+ std::list<CdlConflict>::const_iterator conf_i;
+ CdlTransaction current_transaction = this;
+ CdlToplevel toplevel = this->toplevel;
+ do {
+ CYG_LOOP_INVARIANT_CLASSC(current_transaction);
+
+ for (conf_i = current_transaction->new_conflicts.begin();
+ conf_i != current_transaction->new_conflicts.end();
+ conf_i++) {
+
+ if ((node == (*conf_i)->get_node()) &&
+ !(this->has_conflict_been_cleared(*conf_i)) && (*pFn)(*conf_i)) {
+ result = *conf_i;
+ break;
+ }
+ }
+
+ toplevel = current_transaction->toplevel;
+ current_transaction = current_transaction->parent;
+ } while ((0 == result) && (0 != current_transaction));
+
+ if (0 == result) {
+ CYG_ASSERT_CLASSC(toplevel);
+ for (conf_i = toplevel->conflicts.begin(); conf_i != toplevel->conflicts.end(); conf_i++) {
+ if ((node == (*conf_i)->get_node()) && !(this->has_conflict_been_cleared(*conf_i)) && (*pFn)(*conf_i)) {
+ result = *conf_i;
+ break;
+ }
+ }
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+void
+CdlTransactionBody::get_conflicts(CdlNode node, bool (*pFn)(CdlConflict), std::vector<CdlConflict>& result)
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::get_conflicts");
+ CYG_REPORT_FUNCARG3XV(this, node, pFn);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_CLASSC(node);
+
+ std::list<CdlConflict>::const_iterator conf_i;
+ CdlTransaction current_transaction = this;
+ CdlToplevel toplevel = this->toplevel;
+ do {
+ CYG_LOOP_INVARIANT_CLASSC(current_transaction);
+
+ for (conf_i = current_transaction->new_conflicts.begin();
+ conf_i != current_transaction->new_conflicts.end();
+ conf_i++) {
+
+ if ((node == (*conf_i)->get_node()) &&
+ !(this->has_conflict_been_cleared(*conf_i)) && (*pFn)(*conf_i)) {
+ result.push_back(*conf_i);
+ }
+ }
+
+ toplevel = current_transaction->toplevel;
+ current_transaction = current_transaction->parent;
+ } while (0 != current_transaction);
+
+ CYG_ASSERT_CLASSC(toplevel);
+ for (conf_i = toplevel->conflicts.begin(); conf_i != toplevel->conflicts.end(); conf_i++) {
+ if ((node == (*conf_i)->get_node()) && !(this->has_conflict_been_cleared(*conf_i)) && (*pFn)(*conf_i)) {
+ result.push_back(*conf_i);
+ }
+ }
+
+ CYG_REPORT_RETURN();
+}
+
+bool
+CdlTransactionBody::has_conflict(CdlNode node, CdlProperty prop, bool (*pFn)(CdlConflict))
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlTransaction::has_conflict", "result %d");
+ CYG_REPORT_FUNCARG4XV(this, node, prop, pFn);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_CLASSC(node);
+ CYG_PRECONDITION_CLASSC(prop);
+
+ bool result = false;
+ std::list<CdlConflict>::const_iterator conf_i;
+ CdlTransaction current_transaction = this;
+ CdlToplevel toplevel = this->toplevel;
+ do {
+ CYG_LOOP_INVARIANT_CLASSC(current_transaction);
+
+ for (conf_i = current_transaction->new_conflicts.begin();
+ conf_i != current_transaction->new_conflicts.end();
+ conf_i++) {
+
+ if ((node == (*conf_i)->get_node()) && (prop == (*conf_i)->get_property()) &&
+ !(this->has_conflict_been_cleared(*conf_i)) && (*pFn)(*conf_i)) {
+
+ result = true;
+ break;
+ }
+ }
+
+ toplevel = current_transaction->toplevel;
+ current_transaction = current_transaction->parent;
+ } while (!result && (0 != current_transaction));
+
+ if (!result) {
+ CYG_ASSERT_CLASSC(toplevel);
+ for (conf_i = toplevel->conflicts.begin(); conf_i != toplevel->conflicts.end(); conf_i++) {
+ if ((node == (*conf_i)->get_node()) && (prop == (*conf_i)->get_property()) &&
+ !(this->has_conflict_been_cleared(*conf_i)) && (*pFn)(*conf_i)) {
+
+ result = true;
+ break;
+ }
+ }
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+CdlConflict
+CdlTransactionBody::get_conflict(CdlNode node, CdlProperty prop, bool (*pFn)(CdlConflict))
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlTransaction::get_conflict", "result %p");
+ CYG_REPORT_FUNCARG4XV(this, node, prop, pFn);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_CLASSC(node);
+ CYG_PRECONDITION_CLASSC(prop);
+
+ CdlConflict result = 0;
+ std::list<CdlConflict>::const_iterator conf_i;
+ CdlTransaction current_transaction = this;
+ CdlToplevel toplevel = this->toplevel;
+ do {
+ CYG_LOOP_INVARIANT_CLASSC(current_transaction);
+
+ for (conf_i = current_transaction->new_conflicts.begin();
+ conf_i != current_transaction->new_conflicts.end();
+ conf_i++) {
+
+ if ((node == (*conf_i)->get_node()) && (prop == (*conf_i)->get_property()) &&
+ !(this->has_conflict_been_cleared(*conf_i)) && (*pFn)(*conf_i)) {
+ result = *conf_i;
+ break;
+ }
+ }
+
+ toplevel = current_transaction->toplevel;
+ current_transaction = current_transaction->parent;
+ } while ((0 == result) && (0 != current_transaction));
+
+ if (0 == result) {
+ CYG_ASSERT_CLASSC(toplevel);
+ for (conf_i = toplevel->conflicts.begin(); conf_i != toplevel->conflicts.end(); conf_i++) {
+ if ((node == (*conf_i)->get_node()) && (prop == (*conf_i)->get_property()) &&
+ !(this->has_conflict_been_cleared(*conf_i)) && (*pFn)(*conf_i)) {
+
+ result = *conf_i;
+ break;
+ }
+ }
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+void
+CdlTransactionBody::get_conflicts(CdlNode node, CdlProperty prop, bool (*pFn)(CdlConflict), std::vector<CdlConflict>& result)
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::get_conflict");
+ CYG_REPORT_FUNCARG4XV(this, node, prop, pFn);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_CLASSC(node);
+ CYG_PRECONDITION_CLASSC(prop);
+
+ std::list<CdlConflict>::const_iterator conf_i;
+ CdlTransaction current_transaction = this;
+ CdlToplevel toplevel = this->toplevel;
+ do {
+ CYG_LOOP_INVARIANT_CLASSC(current_transaction);
+
+ for (conf_i = current_transaction->new_conflicts.begin();
+ conf_i != current_transaction->new_conflicts.end();
+ conf_i++) {
+
+ if ((node == (*conf_i)->get_node()) && (prop == (*conf_i)->get_property()) &&
+ !(this->has_conflict_been_cleared(*conf_i)) && (*pFn)(*conf_i)) {
+ result.push_back(*conf_i);
+ }
+ }
+
+ toplevel = current_transaction->toplevel;
+ current_transaction = current_transaction->parent;
+ } while (0 != current_transaction);
+
+ CYG_ASSERT_CLASSC(toplevel);
+ for (conf_i = toplevel->conflicts.begin(); conf_i != toplevel->conflicts.end(); conf_i++) {
+ if ((node == (*conf_i)->get_node()) && (prop == (*conf_i)->get_property()) &&
+ !(this->has_conflict_been_cleared(*conf_i)) && (*pFn)(*conf_i)) {
+
+ result.push_back(*conf_i);
+ }
+ }
+
+ CYG_REPORT_RETURN();
+}
+
+//}}}
+//{{{ get_structural_conflict() etc
+
+// ----------------------------------------------------------------------------
+bool
+CdlTransactionBody::has_structural_conflict(CdlNode node, bool (*pFn)(CdlConflict))
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlTransaction::has_structural_conflict", "result %d");
+ CYG_REPORT_FUNCARG3XV(this, node, pFn);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_CLASSC(node);
+
+ // Because it is necessary to check whether or not any given
+ // conflict has been cleared in the current transaction or any
+ // parent transaction, recursion into the parent is not
+ // appropriate.
+ bool result = false;
+ std::list<CdlConflict>::const_iterator conf_i;
+ CdlTransaction current_transaction = this;
+ CdlToplevel toplevel = this->toplevel;
+ do {
+ CYG_LOOP_INVARIANT_CLASSC(current_transaction);
+
+ for (conf_i = current_transaction->new_structural_conflicts.begin();
+ conf_i != current_transaction->new_structural_conflicts.end();
+ conf_i++) {
+
+ if ((node == (*conf_i)->get_node()) &&
+ !(this->has_conflict_been_cleared(*conf_i)) && (*pFn)(*conf_i)) {
+ result = true;
+ break;
+ }
+ }
+
+ toplevel = current_transaction->toplevel;
+ current_transaction = current_transaction->parent;
+ } while (!result && (0 != current_transaction));
+
+ if (!result) {
+ CYG_ASSERT_CLASSC(toplevel);
+ for (conf_i = toplevel->structural_conflicts.begin(); conf_i != toplevel->structural_conflicts.end(); conf_i++) {
+ if ((node == (*conf_i)->get_node()) && !(this->has_conflict_been_cleared(*conf_i)) && (*pFn)(*conf_i)) {
+ result = true;
+ break;
+ }
+ }
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+CdlConflict
+CdlTransactionBody::get_structural_conflict(CdlNode node, bool (*pFn)(CdlConflict))
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlTransaction::get_structural_conflict", "result %p");
+ CYG_REPORT_FUNCARG3XV(this, node, pFn);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_CLASSC(node);
+
+ CdlConflict result = 0;
+ std::list<CdlConflict>::const_iterator conf_i;
+ CdlTransaction current_transaction = this;
+ CdlToplevel toplevel = this->toplevel;
+ do {
+ CYG_LOOP_INVARIANT_CLASSC(current_transaction);
+
+ for (conf_i = current_transaction->new_structural_conflicts.begin();
+ conf_i != current_transaction->new_structural_conflicts.end();
+ conf_i++) {
+
+ if ((node == (*conf_i)->get_node()) &&
+ !(this->has_conflict_been_cleared(*conf_i)) && (*pFn)(*conf_i)) {
+ result = *conf_i;
+ break;
+ }
+ }
+
+ toplevel = current_transaction->toplevel;
+ current_transaction = current_transaction->parent;
+ } while ((0 == result) && (0 != current_transaction));
+
+ if (0 == result) {
+ CYG_ASSERT_CLASSC(toplevel);
+ for (conf_i = toplevel->structural_conflicts.begin(); conf_i != toplevel->structural_conflicts.end(); conf_i++) {
+ if ((node == (*conf_i)->get_node()) && !(this->has_conflict_been_cleared(*conf_i)) && (*pFn)(*conf_i)) {
+ result = *conf_i;
+ break;
+ }
+ }
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+void
+CdlTransactionBody::get_structural_conflicts(CdlNode node, bool (*pFn)(CdlConflict), std::vector<CdlConflict>& result)
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::get_structural_conflicts");
+ CYG_REPORT_FUNCARG3XV(this, node, pFn);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_CLASSC(node);
+
+ std::list<CdlConflict>::const_iterator conf_i;
+ CdlTransaction current_transaction = this;
+ CdlToplevel toplevel = this->toplevel;
+ do {
+ CYG_LOOP_INVARIANT_CLASSC(current_transaction);
+
+ for (conf_i = current_transaction->new_structural_conflicts.begin();
+ conf_i != current_transaction->new_structural_conflicts.end();
+ conf_i++) {
+
+ if ((node == (*conf_i)->get_node()) &&
+ !(this->has_conflict_been_cleared(*conf_i)) && (*pFn)(*conf_i)) {
+ result.push_back(*conf_i);
+ }
+ }
+
+ toplevel = current_transaction->toplevel;
+ current_transaction = current_transaction->parent;
+ } while (0 != current_transaction);
+
+ CYG_ASSERT_CLASSC(toplevel);
+ for (conf_i = toplevel->structural_conflicts.begin(); conf_i != toplevel->structural_conflicts.end(); conf_i++) {
+ if ((node == (*conf_i)->get_node()) && !(this->has_conflict_been_cleared(*conf_i)) && (*pFn)(*conf_i)) {
+ result.push_back(*conf_i);
+ }
+ }
+
+ CYG_REPORT_RETURN();
+}
+
+bool
+CdlTransactionBody::has_structural_conflict(CdlNode node, CdlProperty prop, bool (*pFn)(CdlConflict))
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlTransaction::has_structural_conflict", "result %d");
+ CYG_REPORT_FUNCARG4XV(this, node, prop, pFn);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_CLASSC(node);
+ CYG_PRECONDITION_CLASSC(prop);
+
+ bool result = false;
+ std::list<CdlConflict>::const_iterator conf_i;
+ CdlTransaction current_transaction = this;
+ CdlToplevel toplevel = this->toplevel;
+ do {
+ CYG_LOOP_INVARIANT_CLASSC(current_transaction);
+
+ for (conf_i = current_transaction->new_structural_conflicts.begin();
+ conf_i != current_transaction->new_structural_conflicts.end();
+ conf_i++) {
+
+ if ((node == (*conf_i)->get_node()) && (prop == (*conf_i)->get_property()) &&
+ !(this->has_conflict_been_cleared(*conf_i)) && (*pFn)(*conf_i)) {
+
+ result = true;
+ break;
+ }
+ }
+
+ toplevel = current_transaction->toplevel;
+ current_transaction = current_transaction->parent;
+ } while (!result && (0 != current_transaction));
+
+ if (!result) {
+ CYG_ASSERT_CLASSC(toplevel);
+ for (conf_i = toplevel->structural_conflicts.begin(); conf_i != toplevel->structural_conflicts.end(); conf_i++) {
+ if ((node == (*conf_i)->get_node()) && (prop == (*conf_i)->get_property()) &&
+ !(this->has_conflict_been_cleared(*conf_i)) && (*pFn)(*conf_i)) {
+
+ result = true;
+ break;
+ }
+ }
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+CdlConflict
+CdlTransactionBody::get_structural_conflict(CdlNode node, CdlProperty prop, bool (*pFn)(CdlConflict))
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlTransaction::get_structural_conflict", "result %p");
+ CYG_REPORT_FUNCARG4XV(this, node, prop, pFn);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_CLASSC(node);
+ CYG_PRECONDITION_CLASSC(prop);
+
+ CdlConflict result = 0;
+ std::list<CdlConflict>::const_iterator conf_i;
+ CdlTransaction current_transaction = this;
+ CdlToplevel toplevel = this->toplevel;
+ do {
+ CYG_LOOP_INVARIANT_CLASSC(current_transaction);
+
+ for (conf_i = current_transaction->new_structural_conflicts.begin();
+ conf_i != current_transaction->new_structural_conflicts.end();
+ conf_i++) {
+
+ if ((node == (*conf_i)->get_node()) && (prop == (*conf_i)->get_property()) &&
+ !(this->has_conflict_been_cleared(*conf_i)) && (*pFn)(*conf_i)) {
+ result = *conf_i;
+ break;
+ }
+ }
+
+ toplevel = current_transaction->toplevel;
+ current_transaction = current_transaction->parent;
+ } while ((0 == result) && (0 != current_transaction));
+
+ if (0 == result) {
+ CYG_ASSERT_CLASSC(toplevel);
+ for (conf_i = toplevel->structural_conflicts.begin(); conf_i != toplevel->structural_conflicts.end(); conf_i++) {
+ if ((node == (*conf_i)->get_node()) && (prop == (*conf_i)->get_property()) &&
+ !(this->has_conflict_been_cleared(*conf_i)) && (*pFn)(*conf_i)) {
+
+ result = *conf_i;
+ break;
+ }
+ }
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+void
+CdlTransactionBody::get_structural_conflicts(CdlNode node, CdlProperty prop, bool (*pFn)(CdlConflict),
+ std::vector<CdlConflict>& result)
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::get_structural_conflict");
+ CYG_REPORT_FUNCARG4XV(this, node, prop, pFn);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_CLASSC(node);
+ CYG_PRECONDITION_CLASSC(prop);
+
+ std::list<CdlConflict>::const_iterator conf_i;
+ CdlTransaction current_transaction = this;
+ CdlToplevel toplevel = this->toplevel;
+ do {
+ CYG_LOOP_INVARIANT_CLASSC(current_transaction);
+
+ for (conf_i = current_transaction->new_structural_conflicts.begin();
+ conf_i != current_transaction->new_structural_conflicts.end();
+ conf_i++) {
+
+ if ((node == (*conf_i)->get_node()) && (prop == (*conf_i)->get_property()) &&
+ !(this->has_conflict_been_cleared(*conf_i)) && (*pFn)(*conf_i)) {
+ result.push_back(*conf_i);
+ }
+ }
+
+ toplevel = current_transaction->toplevel;
+ current_transaction = current_transaction->parent;
+ } while (0 != current_transaction);
+
+ CYG_ASSERT_CLASSC(toplevel);
+ for (conf_i = toplevel->structural_conflicts.begin(); conf_i != toplevel->structural_conflicts.end(); conf_i++) {
+ if ((node == (*conf_i)->get_node()) && (prop == (*conf_i)->get_property()) &&
+ !(this->has_conflict_been_cleared(*conf_i)) && (*pFn)(*conf_i)) {
+
+ result.push_back(*conf_i);
+ }
+ }
+
+ CYG_REPORT_RETURN();
+}
+
+//}}}
+//{{{ clear_conflicts()
+
+// ----------------------------------------------------------------------------
+// Clearing a conflict. This can only happen in the context of a
+// transaction.
+void
+CdlTransactionBody::clear_conflicts(CdlNode node, bool (*pFn)(CdlConflict))
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::clear_conflicts");
+ CYG_REPORT_FUNCARG3XV(this, node, pFn);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_CLASSC(node);
+
+ // Recursing into the parent is the wrong thing to do here, it
+ // would result in the conflict being cleared in the parent rather
+ // than in the current transaction.
+ std::list<CdlConflict>::iterator conf_i;
+ CdlTransaction current_transaction = this;
+ CdlToplevel toplevel = this->toplevel;
+ do {
+ CYG_LOOP_INVARIANT_CLASSC(current_transaction);
+
+ for (conf_i = current_transaction->new_conflicts.begin(); conf_i != current_transaction->new_conflicts.end(); ) {
+ CdlConflict conflict = *conf_i++;
+ if ((node == conflict->get_node()) && !(this->has_conflict_been_cleared(conflict)) && (*pFn)(conflict)) {
+ this->clear_conflict(conflict);
+ }
+ }
+ toplevel = current_transaction->toplevel;
+ current_transaction = current_transaction->parent;
+ } while (0 != current_transaction);
+
+ CYG_ASSERT_CLASSC(toplevel);
+ for (conf_i = toplevel->conflicts.begin(); conf_i != toplevel->conflicts.end(); ) {
+ CdlConflict conflict = *conf_i++;
+ if ((node == conflict->get_node()) && !(this->has_conflict_been_cleared(conflict)) && (*pFn)(conflict)) {
+ this->clear_conflict(conflict);
+ }
+ }
+
+ CYG_REPORT_RETURN();
+}
+
+void
+CdlTransactionBody::clear_conflicts(CdlNode node, CdlProperty prop, bool (*pFn)(CdlConflict))
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::clear_conflicts");
+ CYG_REPORT_FUNCARG4XV(this, node, prop, pFn);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_CLASSC(node);
+
+ std::list<CdlConflict>::iterator conf_i;
+ CdlTransaction current_transaction = this;
+ CdlToplevel toplevel = this->toplevel;
+ do {
+ CYG_LOOP_INVARIANT_CLASSC(current_transaction);
+
+ for (conf_i = current_transaction->new_conflicts.begin(); conf_i != current_transaction->new_conflicts.end(); ) {
+ CdlConflict conflict = *conf_i++;
+ if ((node == conflict->get_node()) && (prop == conflict->get_property()) &&
+ !(this->has_conflict_been_cleared(conflict)) && (*pFn)(conflict)) {
+ this->clear_conflict(conflict);
+ }
+ }
+ toplevel = current_transaction->toplevel;
+ current_transaction = current_transaction->parent;
+ } while (0 != current_transaction);
+
+ CYG_ASSERT_CLASSC(toplevel);
+ for (conf_i = toplevel->conflicts.begin(); conf_i != toplevel->conflicts.end(); ) {
+ CdlConflict conflict = *conf_i++;
+ if ((node == conflict->get_node()) && (prop == conflict->get_property()) &&
+ !(this->has_conflict_been_cleared(conflict)) && (*pFn)(conflict)) {
+ this->clear_conflict(conflict);
+ }
+ }
+
+ CYG_REPORT_RETURN();
+}
+
+void
+CdlTransactionBody::clear_structural_conflicts(CdlNode node, bool (*pFn)(CdlConflict))
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::clear_structural_conflicts");
+ CYG_REPORT_FUNCARG3XV(this, node, pFn);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_CLASSC(node);
+
+ std::list<CdlConflict>::iterator conf_i;
+ CdlTransaction current_transaction = this;
+ CdlToplevel toplevel = this->toplevel;
+ do {
+ CYG_LOOP_INVARIANT_CLASSC(current_transaction);
+
+ for (conf_i = current_transaction->new_structural_conflicts.begin();
+ conf_i != current_transaction->new_structural_conflicts.end();
+ ) {
+
+ CdlConflict conflict = *conf_i++;
+ if ((node == conflict->get_node()) && !(this->has_conflict_been_cleared(conflict)) && (*pFn)(conflict)) {
+ this->clear_conflict(conflict);
+ }
+ }
+ toplevel = current_transaction->toplevel;
+ current_transaction = current_transaction->parent;
+ } while (0 != current_transaction);
+
+ CYG_ASSERT_CLASSC(toplevel);
+ for (conf_i = toplevel->structural_conflicts.begin(); conf_i != toplevel->structural_conflicts.end(); ) {
+ CdlConflict conflict = *conf_i++;
+ if ((node == conflict->get_node()) && !(this->has_conflict_been_cleared(conflict)) && (*pFn)(conflict)) {
+ this->clear_conflict(conflict);
+ }
+ }
+
+ CYG_REPORT_RETURN();
+}
+
+void
+CdlTransactionBody::clear_structural_conflicts(CdlNode node, CdlProperty prop, bool (*pFn)(CdlConflict))
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::clear_structural_conflicts");
+ CYG_REPORT_FUNCARG4XV(this, node, prop, pFn);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_CLASSC(node);
+
+ std::list<CdlConflict>::iterator conf_i;
+ CdlTransaction current_transaction = this;
+ CdlToplevel toplevel = this->toplevel;
+ do {
+ CYG_LOOP_INVARIANT_CLASSC(current_transaction);
+
+ for (conf_i = current_transaction->new_structural_conflicts.begin();
+ conf_i != current_transaction->new_structural_conflicts.end();
+ ) {
+
+ CdlConflict conflict = *conf_i++;
+ if ((node == conflict->get_node()) && (prop == conflict->get_property()) &&
+ !(this->has_conflict_been_cleared(conflict)) && (*pFn)(conflict)) {
+
+ this->clear_conflict(conflict);
+ }
+ }
+ toplevel = current_transaction->toplevel;
+ current_transaction = current_transaction->parent;
+ } while (0 != current_transaction);
+
+ CYG_ASSERT_CLASSC(toplevel);
+ for (conf_i = toplevel->structural_conflicts.begin(); conf_i != toplevel->structural_conflicts.end(); ) {
+ CdlConflict conflict = *conf_i++;
+ if ((node == conflict->get_node()) && (prop == conflict->get_property()) &&
+ !(this->has_conflict_been_cleared(conflict)) && (*pFn)(conflict)) {
+ this->clear_conflict(conflict);
+ }
+ }
+
+ CYG_REPORT_RETURN();
+}
+
+//}}}
+//{{{ clear_conflict()
+
+// ----------------------------------------------------------------------------
+void
+CdlTransactionBody::clear_conflict(CdlConflict conflict)
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::clear_conflict");
+ CYG_REPORT_FUNCARG2XV(this, conflict);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_CLASSC(conflict);
+
+ // If this conflict was created during the transaction, it should
+ // be on the new_conflicts or new_structural_conflicts container
+ if (this == conflict->transaction) {
+ // The conflict should be on one of the two new_conflicts deques.
+ if (conflict->structural) {
+ std::list<CdlConflict>::iterator conf_i = std::find(new_structural_conflicts.begin(),
+ new_structural_conflicts.end(), conflict);
+ CYG_ASSERTC(conf_i != new_structural_conflicts.end());
+ new_structural_conflicts.erase(conf_i);
+ } else {
+ std::list<CdlConflict>::iterator conf_i = std::find(new_conflicts.begin(), new_conflicts.end(), conflict);
+ CYG_ASSERTC(conf_i != new_conflicts.end());
+ new_conflicts.erase(conf_i);
+ }
+ delete conflict;
+
+ } else {
+ if (conflict->structural) {
+ deleted_structural_conflicts.push_back(conflict);
+ } else {
+ deleted_conflicts.push_back(conflict);
+ }
+ }
+
+ CYG_REPORT_RETURN();
+}
+
+// ----------------------------------------------------------------------------
+bool
+CdlTransactionBody::has_conflict_been_cleared(CdlConflict conf)
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlTransaction::has_conflict_been_cleared", "result %d");
+ CYG_REPORT_FUNCARG2XV(this, conf);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_CLASSC(conf);
+
+ bool result = false;
+ CdlTransaction current_transaction = this;
+ do {
+ if (conf->structural) {
+ if (std::find(current_transaction->deleted_structural_conflicts.begin(),
+ current_transaction->deleted_structural_conflicts.end(), conf) !=
+ current_transaction->deleted_structural_conflicts.end()) {
+
+ result = true;
+ }
+ } else {
+ if (std::find(current_transaction->deleted_conflicts.begin(), current_transaction->deleted_conflicts.end(),
+ conf) != current_transaction->deleted_conflicts.end()) {
+ result = true;
+ }
+ }
+
+ current_transaction = current_transaction->parent;
+ } while (!result && (0 != current_transaction));
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+//}}}
+//{{{ per-transaction data
+
+// ----------------------------------------------------------------------------
+// Accessing the per-transaction conflict data.
+
+const std::list<CdlConflict>&
+CdlTransactionBody::get_new_conflicts() const
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::get_new_conflicts");
+ CYG_REPORT_FUNCARG1XV(this);
+ CYG_PRECONDITION_THISC();
+
+ CYG_REPORT_RETURN();
+ return new_conflicts;
+}
+
+const std::list<CdlConflict>&
+CdlTransactionBody::get_new_structural_conflicts() const
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::get_new_structural_conflicts");
+ CYG_REPORT_FUNCARG1XV(this);
+ CYG_PRECONDITION_THISC();
+
+ CYG_REPORT_RETURN();
+ return new_structural_conflicts;
+}
+
+const std::vector<CdlConflict>&
+CdlTransactionBody::get_deleted_conflicts() const
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::get_deleted_conflicts");
+ CYG_REPORT_FUNCARG1XV(this);
+ CYG_PRECONDITION_THISC();
+
+ CYG_REPORT_RETURN();
+ return deleted_conflicts;
+}
+
+const std::vector<CdlConflict>&
+CdlTransactionBody::get_deleted_structural_conflicts() const
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::get_deleted_structural_conflicts");
+ CYG_REPORT_FUNCARG1XV(this);
+ CYG_PRECONDITION_THISC();
+
+ CYG_REPORT_RETURN();
+ return deleted_structural_conflicts;
+}
+
+const std::vector<CdlConflict>&
+CdlTransactionBody::get_resolved_conflicts() const
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::get_resolved_conflicts");
+ CYG_REPORT_FUNCARG1XV(this);
+ CYG_PRECONDITION_THISC();
+
+ CYG_REPORT_RETURN();
+ return resolved_conflicts;
+}
+
+const std::list<CdlConflict>&
+CdlTransactionBody::get_global_conflicts_with_solutions() const
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::get_global_conflicts_with_solutions");
+ CYG_REPORT_FUNCARG1XV(this);
+ CYG_PRECONDITION_THISC();
+
+ CYG_REPORT_RETURN();
+ return global_conflicts_with_solutions;
+}
+
+//}}}
+
+//}}}
+//{{{ Commit/cancel operations
+
+// ----------------------------------------------------------------------------
+void
+CdlTransactionBody::add_commit_cancel_op(CdlTransactionCommitCancelOp* op)
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::add_commit_cancel_op");
+ CYG_REPORT_FUNCARG2XV(this, op);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITIONC(0 != op);
+
+ commit_cancel_ops.push_back(op);
+
+ CYG_REPORT_RETURN();
+}
+
+void
+CdlTransactionBody::cancel_last_commit_cancel_op()
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::cancel_last_commit_cancel_op");
+ CYG_REPORT_FUNCARG1XV(this);
+ CYG_PRECONDITION_THISC();
+
+ CdlTransactionCommitCancelOp* op = *(commit_cancel_ops.rbegin());
+ commit_cancel_ops.pop_back();
+ op->cancel(this);
+ delete op;
+
+ CYG_REPORT_RETURN();
+}
+
+CdlTransactionCommitCancelOp*
+CdlTransactionBody::get_last_commit_cancel_op() const
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlTransaction::get_last_commit_cancel_op", "result %p");
+ CYG_REPORT_FUNCARG1XV(this);
+ CYG_PRECONDITION_THISC();
+
+ CdlTransactionCommitCancelOp* op = *(commit_cancel_ops.rbegin());
+
+ CYG_REPORT_RETVAL(op);
+ return op;
+}
+
+const std::vector<CdlTransactionCommitCancelOp*>&
+CdlTransactionBody::get_commit_cancel_ops() const
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::get_commit_cancel_ops");
+ CYG_REPORT_FUNCARG1XV(this);
+ CYG_PRECONDITION_THISC();
+
+ CYG_REPORT_RETURN();
+ return commit_cancel_ops;
+}
+
+//}}}
+//{{{ Propagation
+
+// ----------------------------------------------------------------------------
+// Propagation should happen whenever one or more changes have been applied,
+// so that the impact of these changes on other parts of the configuration
+// can be fully assessed. The transaction keeps track of all the changes
+// to date and invokes appropriate node and property update handlers.
+
+void
+CdlTransactionBody::propagate()
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::propagate");
+ CYG_REPORT_FUNCARG1XV(this);
+ CYG_INVARIANT_THISC(CdlTransactionBody);
+
+ // Now it is time to worry about value and active changes.
+ // Propagation may result in new entries, so only the
+ // front item of one of the vectors is modified.
+ while ((0 < value_changes.size()) || (0 < active_changes.size())) {
+
+ if (0 != value_changes.size()) {
+
+ CdlValuable valuable = value_changes.front();
+ value_changes.pop_front();
+
+ // A value change may invalidate one or more solutions.
+ // This happens during propagation rather than at the time
+ // that the value is actually changed, so that multiple
+ // solutions can be applied in one go.
+ std::list<CdlConflict>::iterator conf_i, conf_j;
+ for (conf_i = new_conflicts.begin(); conf_i != new_conflicts.end(); conf_i++) {
+ CYG_LOOP_INVARIANT_CLASSC(*conf_i);
+ (*conf_i)->update_solution_validity(valuable);
+ }
+ for (conf_i = global_conflicts_with_solutions.begin();
+ conf_i != global_conflicts_with_solutions.end();
+ ) {
+
+ CYG_LOOP_INVARIANT_CLASSC(*conf_i);
+ conf_j = conf_i++;
+
+ (*conf_j)->update_solution_validity(valuable);
+ if (!(*conf_j)->has_known_solution()) {
+ global_conflicts_with_solutions.erase(conf_j);
+ }
+ }
+
+ // If the valuable is no longer loaded then there is
+ // no need to worry about propagation
+ if (0 != valuable->get_toplevel()) {
+
+ // Inform the valuable itself about the update, so that
+ // e.g. the value can be checked against legal_values
+ valuable->update(this, CdlUpdate_ValueChange);
+
+ std::vector<CdlReferrer>& referrers = valuable->referrers;
+ std::vector<CdlReferrer>::iterator ref_i;
+ for (ref_i = referrers.begin(); ref_i != referrers.end(); ref_i++) {
+ ref_i->update(this, valuable, CdlUpdate_ValueChange);
+ }
+ }
+
+ } else {
+
+ CdlNode node = active_changes.front();
+ active_changes.pop_front();
+
+ if (0 != node->get_toplevel()) {
+ node->update(this, CdlUpdate_ActiveChange);
+
+ std::vector<CdlReferrer>& referrers = node->referrers;
+ std::vector<CdlReferrer>::iterator ref_i;
+ for (ref_i = referrers.begin(); ref_i != referrers.end(); ref_i++) {
+ ref_i->update(this, node, CdlUpdate_ActiveChange);
+ }
+ }
+ }
+ }
+
+ CYG_REPORT_RETURN();
+}
+
+// ----------------------------------------------------------------------------
+bool
+CdlTransactionBody::is_propagation_required() const
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlTransaction::is_propagation_required", "result %d");
+ CYG_REPORT_FUNCARG1XV(this);
+ CYG_PRECONDITION_THISC();
+
+ bool result = false;
+
+ if ((0 != value_changes.size()) || (0 != active_changes.size())) {
+ result = true;
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+
+// ----------------------------------------------------------------------------
+void
+CdlTransactionBody::add_legal_values_change(CdlValuable valuable)
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::add_legal_values_change");
+ CYG_REPORT_FUNCARG2XV(this, valuable);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_CLASSC(valuable);
+
+ legal_values_changes.insert(valuable);
+
+ CYG_REPORT_RETURN();
+}
+
+const std::set<CdlValuable>&
+CdlTransactionBody::get_legal_values_changes() const
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::get_legal_values_changes");
+ CYG_REPORT_FUNCARG1XV(this);
+ CYG_PRECONDITION_THISC();
+
+ CYG_REPORT_RETURN();
+ return legal_values_changes;
+}
+
+//}}}
+//{{{ Cancel
+
+// ----------------------------------------------------------------------------
+// Cancellation is straightforward, essentially it just involves clearing
+// out all of the STL containers. The transaction object can then be-used,
+// so fields like parent and toplevel must not change.
+void
+CdlTransactionBody::cancel()
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::cancel");
+ CYG_REPORT_FUNCARG1XV(this);
+ CYG_INVARIANT_THISC(CdlTransactionBody);
+
+ // First take care of the cancel ops, if any, in case a cancel op
+ // depends on some of the other transaction state.
+ std::vector<CdlTransactionCommitCancelOp*>::reverse_iterator cancel_i;
+ for (cancel_i = commit_cancel_ops.rbegin(); cancel_i != commit_cancel_ops.rend(); cancel_i++) {
+ (*cancel_i)->cancel(this);
+ delete *cancel_i;
+ *cancel_i = 0;
+ }
+ commit_cancel_ops.clear();
+
+ this->changes.clear();
+ std::list<CdlConflict>::iterator conf_i;
+ for (conf_i = this->new_conflicts.begin(); conf_i != this->new_conflicts.end(); conf_i++) {
+ CYG_LOOP_INVARIANT_CLASSC(*conf_i);
+ delete *conf_i;
+ }
+ this->new_conflicts.clear();
+ for (conf_i = this->new_structural_conflicts.begin(); conf_i != this->new_structural_conflicts.end(); conf_i++) {
+ CYG_LOOP_INVARIANT_CLASSC(*conf_i);
+ delete *conf_i;
+ }
+ this->new_structural_conflicts.clear();
+
+ this->deleted_structural_conflicts.clear();
+ this->deleted_conflicts.clear();
+
+ // Any conflicts created and resolved during this transaction will
+ // still be present in resolved_conflicts. Some global conflicts
+ // may be there as well.
+ std::vector<CdlConflict>::iterator conf_i2;
+ for (conf_i2 = this->resolved_conflicts.begin(); conf_i2 != this->resolved_conflicts.end(); conf_i2++) {
+ if (this == (*conf_i2)->transaction) {
+ delete (*conf_i2);
+ }
+ }
+ this->resolved_conflicts.clear();
+
+ // Any global conflicts which have been updated with a solution need
+ // to have that solution cleared. Currently no attempt is made to
+ // keep solutions valid for global conflicts.
+ for (conf_i = this->global_conflicts_with_solutions.begin();
+ conf_i != this->global_conflicts_with_solutions.end();
+ conf_i++) {
+
+ CYG_LOOP_INVARIANT_CLASSC(*conf_i);
+ (*conf_i)->clear_solution();
+ }
+ this->global_conflicts_with_solutions.clear();
+
+ this->activated.clear();
+ this->deactivated.clear();
+ this->legal_values_changes.clear();
+ this->value_changes.clear();
+ this->active_changes.clear();
+
+ CYG_REPORT_RETURN();
+}
+
+//}}}
+//{{{ Commit
+
+// ----------------------------------------------------------------------------
+// The commit operation. There are two main branches for this code. The
+// first branch deals with sub-transactions, and basically involves
+// transferring changes from the sub-transaction to the parent. It is
+// assumed that the sub-transaction has been fully propagated, so
+// data can just be transferred from the child to the parent.
+//
+// The second branch involves committing changes from a transaction to
+// the toplevel, invoking the transaction callback if necessary.
+
+void
+CdlTransactionBody::commit()
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::commit");
+ CYG_REPORT_FUNCARG1XV(this);
+ CYG_INVARIANT_THISC(CdlTransactionBody);
+
+ std::map<CdlValuable, CdlValue>::iterator map_i;
+ std::list<CdlConflict>::iterator conf_i, conf_j;
+ std::vector<CdlConflict>::const_iterator conf_i2, conf_j2;
+ std::set<CdlNode>::iterator set_i, set_j, set_k;
+ std::set<CdlValuable>::iterator set_i2, set_j2;
+
+ if (0 != parent) {
+ // Any conflicts that were solved by the inference engine further
+ // down are still resolved.
+ // Great care has to be taken with conflict ownership. The following
+ // cases have to be considered.
+ // 1) the resolved conflict is global, its transaction is zero, this
+ // conflict must only be destroyed if the toplevel transaction
+ // is committed - at which time time the conflict should appear
+ // on the deleted_conflicts lists.
+ // 2) the conflict belongs to a higher level transaction, we have
+ // recursed a certain amount trying to resolve it e.g. to explore
+ // OR branches of the tree. Again the resolved conflict can only
+ // be destroyed when the appropriate higher-level commit happens,
+ // and should appear on the deleted conflicts list.
+ // 3) the conflict was created and resolved further down the tree.
+ // We are keeping it around for informational purposes only.
+ // Associating it with this transaction allows the code to
+ // distinguish this case from (1) and (2).
+ for (conf_i2 = resolved_conflicts.begin(); conf_i2 != resolved_conflicts.end(); conf_i2++) {
+ CdlConflict conf = *conf_i2;
+ CYG_LOOP_INVARIANT_CLASSC(conf);
+ CYG_LOOP_INVARIANTC(parent->resolved_conflicts.end() == \
+ std::find(parent->resolved_conflicts.begin(), \
+ parent->resolved_conflicts.end(), conf));
+ parent->resolved_conflicts.push_back(conf);
+ parent->dirty = true;
+ if (this == conf->transaction) {
+ conf->transaction = parent;
+ }
+ }
+ resolved_conflicts.clear();
+
+ // Any global conflicts for which solutions were found in the
+ // sub-transaction still have solutions in the parent.
+ for (conf_i = global_conflicts_with_solutions.begin(); conf_i != global_conflicts_with_solutions.end(); conf_i++) {
+
+ CdlConflict conf = *conf_i;
+ CYG_LOOP_INVARIANT_CLASSC(conf);
+
+ // It is not clear that this search is actually useful, especially
+ // given that the solution is currently stored with the conflict
+ // rather than with the transaction.
+ conf_j = std::find(parent->global_conflicts_with_solutions.begin(),
+ parent->global_conflicts_with_solutions.end(),
+ conf);
+ if (conf_j == parent->global_conflicts_with_solutions.end()) {
+ parent->global_conflicts_with_solutions.push_back(conf);
+ parent->dirty = true;
+ }
+ }
+ global_conflicts_with_solutions.clear();
+
+ // Now take care of deleted conflicts.
+ for (conf_i2 = deleted_conflicts.begin(); conf_i2 != deleted_conflicts.end(); conf_i2++) {
+ CdlConflict conf = *conf_i2;
+ CYG_LOOP_INVARIANT_CLASSC(conf);
+ // Possibilities to consider:
+ // 1) the conflict may have been local to the parent transaction,
+ // in which case it can be deleted.
+ // 2) the conflict may have been created in a higher-level
+ // transaction, in which case it has to be moved to the
+ // parent's deleted_conflicts vector.
+ // 3) the conflict may also have been global, again it needs
+ // to be propagated into the parent's deleted_conflicts vector.
+ //
+ // But that is not the whole story. If this sub-transaction was
+ // created specifically to resolve the conflict then the latter
+ // should appear on the resolved vector and not be destroyed
+ // immediately. This is true for both global and per-transaction
+ // conflicts.
+ //
+ // For global conflicts it is also necessary to worry about
+ // the global_conflicts_with_solutions list, that has to be
+ // kept in synch with the rest of the world.
+ conf_i = std::find(parent->new_conflicts.begin(), parent->new_conflicts.end(), conf);
+ bool can_delete = false;
+ if (conf_i != parent->new_conflicts.end()) {
+ parent->new_conflicts.erase(conf_i);
+ can_delete = true;
+ } else {
+ parent->deleted_conflicts.push_back(conf);
+ }
+ if (0 == conf->transaction) {
+ conf_j = std::find(parent->global_conflicts_with_solutions.begin(),
+ parent->global_conflicts_with_solutions.end(),
+ conf);
+ if (conf_j != parent->global_conflicts_with_solutions.end()) {
+ parent->global_conflicts_with_solutions.erase(conf_j);
+ }
+ }
+ if (conf == this->conflict) {
+ // The conflict may have been fortuitously resolved lower down,
+ // in which case it will have appeared in this->resolved_conflicts()
+ // and copied already.
+ conf_j2 = std::find(parent->resolved_conflicts.begin(), parent->resolved_conflicts.end(), conf);
+ if (conf_j2 == parent->resolved_conflicts.end()) {
+ parent->resolved_conflicts.push_back(conf);
+ parent->dirty = true;
+ }
+ } else if (can_delete) {
+ delete conf;
+ }
+ }
+ // Unnecessary, but let's keep things clean.
+ deleted_conflicts.clear();
+
+ // Deleted structural conflicts. For now the inference engine can do nothing with
+ // these so they are a bit simpler.
+ for (conf_i2 = deleted_structural_conflicts.begin(); conf_i2 != deleted_structural_conflicts.end(); conf_i2++) {
+
+ CdlConflict conf = *conf_i2;
+ CYG_LOOP_INVARIANT_CLASSC(conf);
+ conf_i = std::find(parent->new_structural_conflicts.begin(), parent->new_structural_conflicts.end(), conf);
+ if (conf_i != parent->new_structural_conflicts.end()) {
+ parent->new_structural_conflicts.erase(conf_i);
+ delete conf;
+ } else {
+ parent->deleted_structural_conflicts.push_back(conf);
+ }
+ }
+ deleted_structural_conflicts.clear();
+
+ // All value changes need to be propagated from the child to the parent.
+ // Also, these value changes may invalidate existing solutions.
+ for (map_i = changes.begin(); map_i != changes.end(); map_i++) {
+ CYG_LOOP_INVARIANT_CLASSC(map_i->first);
+ CYG_LOOP_INVARIANT_CLASSOC(map_i->second);
+ parent->changes[map_i->first] = map_i->second;
+ for (conf_i = parent->new_conflicts.begin(); conf_i != parent->new_conflicts.end(); conf_i++) {
+ CYG_LOOP_INVARIANT_CLASSC(*conf_i);
+ (*conf_i)->update_solution_validity(map_i->first);
+ }
+ for (conf_i = parent->global_conflicts_with_solutions.begin();
+ conf_i != parent->global_conflicts_with_solutions.end();
+ ) {
+
+ conf_j = conf_i++;
+ CYG_LOOP_INVARIANT_CLASSC(*conf_j);
+
+ (*conf_j)->update_solution_validity(map_i->first);
+ if (!(*conf_j)->has_known_solution()) {
+ parent->global_conflicts_with_solutions.erase(conf_j);
+ }
+ }
+ }
+ changes.clear();
+
+ // Continue propagating the conflicts.New conflicts can just
+ // be added.
+ for (conf_i = new_conflicts.begin(); conf_i != new_conflicts.end(); conf_i++) {
+ CYG_LOOP_INVARIANT_CLASSC(*conf_i);
+ parent->new_conflicts.push_back(*conf_i);
+ parent->dirty = true;
+ (*conf_i)->transaction = parent;
+ }
+ for (conf_i = new_structural_conflicts.begin(); conf_i != new_structural_conflicts.end(); conf_i++) {
+ CYG_LOOP_INVARIANT_CLASSC(*conf_i);
+ parent->new_structural_conflicts.push_back(*conf_i);
+ parent->dirty = true;
+ (*conf_i)->transaction = parent;
+ }
+ // The cancel operation at the end will delete new conflicts, so the
+ // containers had better be cleared here.
+ new_conflicts.clear();
+ new_structural_conflicts.clear();
+
+
+ // Also keep track of nodes that have become active or inactive.
+ set_j = parent->activated.begin();
+ for (set_i = activated.begin(); set_i != activated.end(); set_i++) {
+ set_j = parent->activated.insert(set_j, *set_i);
+ set_k = parent->deactivated.find(*set_i);
+ if (set_k != parent->deactivated.end()) {
+ parent->deactivated.erase(set_k);
+ }
+ }
+
+ set_j = parent->deactivated.begin();
+ for (set_i = deactivated.begin(); set_i != deactivated.end(); set_i++) {
+ set_j = parent->deactivated.insert(set_j, *set_i);
+ set_k = parent->activated.find(*set_i);
+ if (set_k != parent->activated.end()) {
+ parent->activated.erase(set_k);
+ }
+ }
+ activated.clear();
+ deactivated.clear();
+
+ // Keep track of other property changes.
+ set_j2 = parent->legal_values_changes.begin();
+ for (set_i2 = legal_values_changes.begin(); set_i2 != legal_values_changes.end(); set_i2++) {
+ set_j2 = parent->legal_values_changes.insert(set_j2, *set_i2);
+ }
+ legal_values_changes.clear();
+
+ // Any pending commit/cancel ops needs to be transferred to the parent
+ parent->commit_cancel_ops.insert(parent->commit_cancel_ops.end(),
+ this->commit_cancel_ops.begin(), this->commit_cancel_ops.end());
+ this->commit_cancel_ops.clear();
+
+ } else {
+
+ CYG_ASSERT_CLASSC(toplevel);
+
+ // If there is a registered callback function, it is necessary to fill
+ // in the remaining fields of the all_changes callback structure. This
+ // should happen before any conflicts get deleted. The actual callback
+ // is invoked at the end, once all the changes have been moved to
+ // the toplevel.
+ CdlTransactionCallback all_changes(this);
+ if (0 != callback_fn) {
+
+ for (map_i = changes.begin(); map_i != changes.end(); map_i++) {
+ if (0 == map_i->first->get_toplevel()) {
+ continue;
+ }
+ CdlValueFlavor flavor = map_i->second.get_flavor();
+ const CdlValue& old_value = map_i->first->get_whole_value();
+ CYG_LOOP_INVARIANTC(flavor == old_value.get_flavor());
+ bool value_changed = false;
+
+ if (old_value.get_source() != map_i->second.get_source()) {
+ all_changes.value_source_changes.push_back(map_i->first);
+ }
+ if ((CdlValueFlavor_Bool == flavor) || (CdlValueFlavor_BoolData == flavor)) {
+ if (old_value.is_enabled() != map_i->second.is_enabled()) {
+ value_changed = true;
+ }
+ }
+ if (!value_changed && ((CdlValueFlavor_BoolData == flavor) || (CdlValueFlavor_Data == flavor))) {
+ if (old_value.get_simple_value() != map_i->second.get_simple_value()) {
+ value_changed = true;
+ }
+ }
+ if (value_changed) {
+ all_changes.value_changes.push_back(map_i->first);
+ }
+ }
+ for (conf_i = new_conflicts.begin(); conf_i != new_conflicts.end(); conf_i++) {
+ all_changes.new_conflicts.push_back(*conf_i);
+ }
+ for (conf_i = new_structural_conflicts.begin(); conf_i != new_structural_conflicts.end(); conf_i++) {
+ all_changes.new_structural_conflicts.push_back(*conf_i);
+ }
+ for (conf_i2 = deleted_conflicts.begin(); conf_i2 != deleted_conflicts.end(); conf_i2++) {
+ CdlNode node = (*conf_i2)->get_node();
+ CYG_LOOP_INVARIANT_CLASSC(node);
+
+ all_changes.nodes_with_resolved_conflicts.push_back(node);
+ }
+ for (conf_i2 = deleted_structural_conflicts.begin(); conf_i2 != deleted_structural_conflicts.end(); conf_i2++) {
+ CdlNode node = (*conf_i2)->get_node();
+ CYG_LOOP_INVARIANT_CLASSC(node);
+
+ all_changes.nodes_with_resolved_structural_conflicts.push_back(node);
+ }
+ for (set_i = activated.begin(); set_i != activated.end(); set_i++) {
+ if (0 != (*set_i)->get_toplevel()) {
+ all_changes.active_changes.push_back(*set_i);
+ }
+ }
+ for (set_i = deactivated.begin(); set_i != deactivated.end(); set_i++) {
+ if (0 != (*set_i)->get_toplevel()) {
+ all_changes.active_changes.push_back(*set_i);
+ }
+ }
+ for (set_i2 = legal_values_changes.begin(); set_i2 != legal_values_changes.end(); set_i2++) {
+ if (0 != (*set_i)->get_toplevel()) {
+ all_changes.legal_values_changes.push_back(*set_i2);
+ }
+ }
+ legal_values_changes.clear();
+ }
+
+ // All new values need to be installed in the appropriate valuable.
+ for (map_i = changes.begin(); map_i != changes.end(); map_i++) {
+ CYG_LOOP_INVARIANT_CLASSC(map_i->first);
+ CYG_LOOP_INVARIANT_CLASSOC(map_i->second);
+ map_i->first->value = map_i->second;
+ }
+ changes.clear();
+
+ // Sort out the conflicts. New conflicts can just be added, although
+ // care has to be taken to clear state - currently no attempt is
+ // made to check solution validity for global conflicts.
+ for (conf_i = new_conflicts.begin(); conf_i != new_conflicts.end(); conf_i++) {
+ CYG_LOOP_INVARIANT_CLASSC(*conf_i);
+ toplevel->conflicts.push_back(*conf_i);
+ (*conf_i)->transaction = 0;
+ (*conf_i)->clear_solution();
+ }
+ new_conflicts.clear();
+ for (conf_i = new_structural_conflicts.begin(); conf_i != new_structural_conflicts.end(); conf_i++) {
+ CYG_LOOP_INVARIANT_CLASSC(*conf_i);
+ toplevel->structural_conflicts.push_back(*conf_i);
+ (*conf_i)->transaction = 0;
+ (*conf_i)->clear_solution();
+ }
+ new_structural_conflicts.clear();
+
+ // Resolved conflicts can be either global or per-transaction
+ // ones. If the former then the conflict will also be present
+ // in deleted_conflicts and will get deleted shortly.
+ for (conf_i2 = resolved_conflicts.begin(); conf_i2 != resolved_conflicts.end(); conf_i2++) {
+ CYG_LOOP_INVARIANT_CLASSC(*conf_i2);
+ if (0 != (*conf_i2)->transaction) {
+ delete *conf_i2;
+ }
+ }
+ resolved_conflicts.clear();
+
+ // Now process conflicts that have gone away. These must actually
+ // be deleted.
+ for (conf_i2 = deleted_conflicts.begin(); conf_i2 != deleted_conflicts.end(); conf_i2++) {
+ CYG_LOOP_INVARIANT_CLASSC(*conf_i2);
+ std::list<CdlConflict>::iterator tmp;
+ tmp = std::find(toplevel->conflicts.begin(), toplevel->conflicts.end(), *conf_i2);
+ CYG_LOOP_INVARIANTC(tmp != toplevel->conflicts.end());
+ toplevel->conflicts.erase(tmp);
+ delete *conf_i2;
+ }
+ deleted_conflicts.clear();
+ for (conf_i2 = deleted_structural_conflicts.begin(); conf_i2 != deleted_structural_conflicts.end(); conf_i2++) {
+ CYG_LOOP_INVARIANT_CLASSC(*conf_i2);
+ std::list<CdlConflict>::iterator tmp;
+ tmp = std::find(toplevel->structural_conflicts.begin(), toplevel->structural_conflicts.end(), *conf_i2);
+ CYG_LOOP_INVARIANTC(tmp != toplevel->structural_conflicts.end());
+ toplevel->structural_conflicts.erase(tmp);
+ delete *conf_i2;
+ }
+ deleted_structural_conflicts.clear();
+
+ // Any global conflicts with solutions need to have their solutions cleared,
+ // since currently no attempt is made to preserve their accuracy.
+ for (conf_i = global_conflicts_with_solutions.begin(); conf_i != global_conflicts_with_solutions.end(); conf_i++) {
+ CYG_LOOP_INVARIANT_CLASSC(*conf_i);
+ (*conf_i)->clear_solution();
+ }
+ global_conflicts_with_solutions.clear();
+
+ for (set_i = activated.begin(); set_i != activated.end(); set_i++) {
+ (*set_i)->active = true;
+ }
+ for (set_i = deactivated.begin(); set_i != deactivated.end(); set_i++) {
+ (*set_i)->active = false;
+ }
+ activated.clear();
+ deactivated.clear();
+
+ // Invoke all pending commit operations
+ std::vector<CdlTransactionCommitCancelOp*>::iterator commit_i;
+ for (commit_i = commit_cancel_ops.begin(); commit_i != commit_cancel_ops.end(); commit_i++) {
+ (*commit_i)->commit(this);
+ delete *commit_i;
+ *commit_i = 0;
+ }
+ commit_cancel_ops.clear();
+
+ // Finally take care of the callback.
+ if (0 != callback_fn) {
+ (*callback_fn)(all_changes);
+ }
+ }
+
+ CYG_REPORT_RETURN();
+}
+
+//}}}
+//{{{ Solution support
+
+// ----------------------------------------------------------------------------
+// Saving a solution basically involves remembering what changes took place
+// in the corresponding sub-transaction. There is no need to worry about
+// other data in the sub-transaction such as conflicts, because there
+// are no actual value changes.
+
+void
+CdlTransactionBody::save_solution()
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::save_solution");
+ CYG_REPORT_FUNCARG1XV(this);
+ CYG_PRECONDITION_THISC();
+ // Solutions should only be applicable to sub-transactions immediately
+ // below the main transaction, since that is the only level at which
+ // inference callbacks occur
+ CYG_PRECONDITIONC((0 != parent) && (0 == parent->parent));
+
+ CYG_PRECONDITION_CLASSC(conflict);
+ CYG_PRECONDITIONC(0 == conflict->solution.size());
+
+ std::map<CdlValuable, CdlValue>::const_iterator map_i;
+ for (map_i = changes.begin(); map_i != changes.end(); map_i++) {
+ // If the valuable was calculated or is otherwise non-modifiable,
+ // there is no point in storing it with the solution since the
+ // information is unlikely to be of interest to the user.
+ CdlValuable valuable = map_i->first;
+ if (valuable->is_modifiable()) {
+ conflict->solution.push_back(*map_i);
+ }
+ }
+
+ // save_solution() should operate like commit() or cancel(), i.e.
+ // it leaves an empty sub-transaction. This sub-transaction cannot
+ // actually be re-used at present because it still references a
+ // conflict for which a solution is now already in place, but that
+ // may get cleaned up in future.
+ this->cancel();
+ CYG_REPORT_RETURN();
+}
+
+// ----------------------------------------------------------------------------
+// Can a solution be applied without e.g. overwriting a user value with
+// an inferred value. There is a setting inference_override which controls
+// this. Making a previously enabled option inactive also requires
+// user confirmation, thus preventing the inference engine from disabling
+// entire components.
+bool
+CdlTransactionBody::user_confirmation_required() const
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlTransaction::user_confirmation_required", "result %d");
+ CYG_REPORT_FUNCARG1XV(this);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_CLASSC(this->parent);
+
+ bool result = false;
+
+ std::map<CdlValuable, CdlValue>::const_iterator val_i;
+ for (val_i = changes.begin(); val_i != changes.end(); val_i++) {
+ const CdlValue& old_value = parent->get_whole_value(val_i->first);
+ if (old_value.get_source() > CdlTransactionBody::inference_override) {
+ result = true;
+ break;
+ }
+ }
+ std::set<CdlNode>::const_iterator val_j;
+ for (val_j = deactivated.begin(); val_j != deactivated.end(); val_j++) {
+ CdlValuable valuable = dynamic_cast<CdlValuable>(*val_j);
+ if (0 != valuable) {
+ const CdlValue& old_value = parent->get_whole_value(valuable);
+ if ((old_value.get_source() > CdlTransactionBody::inference_override) && old_value.is_enabled()) {
+ result = true;
+ break;
+ }
+ }
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+// ----------------------------------------------------------------------------
+// The inference engine is considering modifying a particular valuable. If
+// the user has explicitly changed this valuable during the transaction then
+// it would be inappropriate to suggest changing it again.
+bool
+CdlTransactionBody::changed_by_user(CdlValuable valuable) const
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlTransaction::changed_by_user", "result %d");
+ CYG_REPORT_FUNCARG2XV(this, valuable);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_CLASSC(valuable);
+
+ bool result = false;
+ std::map<CdlValuable, CdlValue>::const_iterator change_i = changes.find(valuable);
+ if (change_i != changes.end()) {
+ CdlValueSource source = change_i->second.get_source();
+ if (CdlValueSource_User == source) {
+ result = true;
+ }
+ }
+ if (!result && (0 != parent)) {
+ result = parent->changed_by_user(valuable);
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+// ----------------------------------------------------------------------------
+// A variant which takes into account the hierarchy: disabling a container
+// when a sub-node has just been changed by the user is also a no-no.
+bool
+CdlTransactionBody::subnode_changed_by_user(CdlContainer container) const
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlTransaction::subnode_changed_by_user", "result %d");
+ CYG_REPORT_FUNCARG2XV(this, container);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_CLASSC(container);
+
+ bool result = false;
+
+ const std::vector<CdlNode>& contents = container->get_contents();
+ std::vector<CdlNode>::const_iterator node_i;
+ for (node_i = contents.begin(); node_i != contents.end(); node_i++) {
+ CdlValuable valuable = dynamic_cast<CdlValuable>(*node_i);
+ if ((0 != valuable) && this->changed_by_user(valuable)) {
+ result = true;
+ break;
+ }
+ CdlContainer container = dynamic_cast<CdlContainer>(*node_i);
+ if ((0 != container) && this->subnode_changed_by_user(container)) {
+ result = true;
+ break;
+ }
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+// ----------------------------------------------------------------------------
+// Is one solution preferable to another? This code assumes that
+// user_confirmation_required() and changed_by_user() have already
+// been considered, so the only issue at stake here is the changes
+// themselves.
+//
+// For now a simple metric of the number of changes is used. A more
+// intelligent approach would take into account how much of the
+// hierarchy is affected, e.g. how many other items would end
+// up being disabled. Arguably the calling code should be able to
+// supply an additional weighting.
+
+bool
+CdlTransactionBody::is_preferable_to(CdlTransaction other) const
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlTransactionBody::preferable_to", "result %d");
+ CYG_REPORT_FUNCARG2XV(this, other);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_CLASSC(other);
+ CYG_PRECONDITIONC(this != other);
+
+ bool result = false;
+ unsigned int this_changes = this->changes.size() + this->activated.size() + this->deactivated.size();
+ unsigned int other_changes = other->changes.size() + other->activated.size() + other->deactivated.size();
+
+ if (this_changes <= other_changes) {
+ result = true;
+ }
+
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+// ----------------------------------------------------------------------------
+// Applying solutions. Multiple solutions can be applied in one go. If there
+// is any overlap, tough. Propagation needs to happen after solutions are
+// applied.
+
+void
+CdlTransactionBody::apply_solution(CdlConflict conflict)
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::apply_solution");
+ CYG_REPORT_FUNCARG2XV(this, conflict);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_CLASSC(conflict);
+
+ // The solution can be for either a per-transaction conflict
+ // or a global one. There are two lists to search.
+ std::list<CdlConflict>::const_iterator conf_i;
+ conf_i = std::find(this->new_conflicts.begin(), this->new_conflicts.end(), conflict);
+ if (conf_i == this->new_conflicts.end()) {
+ conf_i = std::find(this->global_conflicts_with_solutions.begin(),
+ this->global_conflicts_with_solutions.end(),
+ conflict);
+ CYG_ASSERTC(conf_i != this->global_conflicts_with_solutions.end());
+ }
+
+ std::vector<std::pair<CdlValuable, CdlValue> >::const_iterator val_i;
+ for (val_i = conflict->solution.begin(); val_i != conflict->solution.end(); val_i++) {
+ CdlValuable valuable = val_i->first;
+ CYG_LOOP_INVARIANT_CLASSC(valuable);
+
+ const CdlValue& old_value = this->get_whole_value(valuable);
+ this->set_whole_value(valuable, old_value, val_i->second);
+ }
+
+ CYG_REPORT_RETURN();
+}
+
+void
+CdlTransactionBody::apply_solutions(const std::vector<CdlConflict>& solutions)
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::apply_solutions");
+ CYG_REPORT_FUNCARG1XV(this);
+ CYG_PRECONDITION_THISC();
+
+ std::vector<CdlConflict>::const_iterator conf_i;
+ for (conf_i = solutions.begin(); conf_i != solutions.end(); conf_i++) {
+
+ std::list<CdlConflict>::const_iterator conf_j;
+ conf_j = std::find(this->new_conflicts.begin(), this->new_conflicts.end(), conflict);
+ if (conf_j == this->new_conflicts.end()) {
+ conf_j = std::find(this->global_conflicts_with_solutions.begin(),
+ this->global_conflicts_with_solutions.end(),
+ conflict);
+ CYG_ASSERTC(conf_j != this->global_conflicts_with_solutions.end());
+ }
+
+ std::vector<std::pair<CdlValuable, CdlValue> >::const_iterator val_i;
+ for (val_i = conflict->solution.begin(); val_i != conflict->solution.end(); val_i++) {
+ CdlValuable valuable = val_i->first;
+ CYG_LOOP_INVARIANT_CLASSC(valuable);
+ const CdlValue& old_value = this->get_whole_value(valuable);
+ this->set_whole_value(valuable, old_value, val_i->second);
+ }
+ }
+
+ CYG_REPORT_RETURN();
+}
+
+void
+CdlTransactionBody::apply_all_solutions()
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::apply_all_solutions");
+ CYG_REPORT_FUNCARG1XV(this);
+ CYG_PRECONDITION_THISC();
+
+ std::list<CdlConflict>::const_iterator conf_i;
+ for (conf_i = this->new_conflicts.begin(); conf_i != this->new_conflicts.end(); conf_i++) {
+ if ((*conf_i)->has_known_solution()) {
+
+ std::vector<std::pair<CdlValuable, CdlValue> >::const_iterator val_i;
+ for (val_i = conflict->solution.begin(); val_i != conflict->solution.end(); val_i++) {
+ CdlValuable valuable = val_i->first;
+ CYG_LOOP_INVARIANT_CLASSC(valuable);
+ const CdlValue& old_value = this->get_whole_value(valuable);
+ this->set_whole_value(valuable, old_value, val_i->second);
+ }
+ }
+ }
+ for (conf_i = this->global_conflicts_with_solutions.begin();
+ conf_i != this->global_conflicts_with_solutions.end();
+ conf_i++) {
+
+ CYG_ASSERTC((*conf_i)->has_known_solution());
+
+ std::vector<std::pair<CdlValuable, CdlValue> >::const_iterator val_i;
+ for (val_i = conflict->solution.begin(); val_i != conflict->solution.end(); val_i++) {
+ CdlValuable valuable = val_i->first;
+ CYG_LOOP_INVARIANT_CLASSC(valuable);
+ const CdlValue& old_value = this->get_whole_value(valuable);
+ this->set_whole_value(valuable, old_value, val_i->second);
+ }
+ }
+
+ CYG_REPORT_RETURN();
+}
+
+//}}}
+//{{{ Inference
+
+// ----------------------------------------------------------------------------
+//{{{ resolve() - all per-transaction conflicts
+
+void
+CdlTransactionBody::resolve(int level)
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::resolve");
+ CYG_REPORT_FUNCARG2XV(this, level);
+ CYG_PRECONDITION_THISC();
+
+ while(1) {
+ // Resolving one conflict may affect others, so iterating down the list
+ // is not safe. Instead we need to loop as long as there are conflicts
+ // to be considered.
+ std::list<CdlConflict>::iterator conf_i;
+ for (conf_i = new_conflicts.begin(); conf_i != new_conflicts.end(); conf_i++) {
+ CYG_LOOP_INVARIANT_CLASSC(*conf_i);
+
+ // Is there any point in attempt to resolve this conflict?
+ if ((*conf_i)->has_known_solution() ||
+ (*conf_i)->has_no_solution() ||
+ !(*conf_i)->resolution_implemented()) {
+ continue;
+ }
+ this->resolve(*conf_i, level);
+ break;
+ }
+ if (conf_i == new_conflicts.end()) {
+ break;
+ }
+ }
+
+ CYG_REPORT_RETURN();
+}
+
+//}}}
+//{{{ resolve() - vector
+
+// ----------------------------------------------------------------------------
+void
+CdlTransactionBody::resolve(const std::vector<CdlConflict>& conflicts, int level)
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::resolve");
+ CYG_REPORT_FUNCARG2XV(this, level);
+ CYG_PRECONDITION_THISC();
+
+ std::vector<CdlConflict>::const_iterator conf_i;
+ for (conf_i = conflicts.begin(); conf_i != conflicts.end(); conf_i++) {
+ CYG_LOOP_INVARIANT_CLASSC(*conf_i);
+
+ // Is there any point in attempt to resolve this conflict?
+ if (!(*conf_i)->has_known_solution() &&
+ !(*conf_i)->has_no_solution() &&
+ (*conf_i)->resolution_implemented()) {
+ this->resolve(*conf_i, level);
+ }
+ }
+
+ CYG_REPORT_RETURN();
+}
+
+//}}}
+//{{{ resolve() - single conflict
+
+// ----------------------------------------------------------------------------
+// There is a conflict that may have a solution. The resolution
+// attempt needs to happen in the context of a sub-transaction
+//
+// The conflict may have been created during this transaction,
+// or it may be a global conflict left over from a previous
+// transaction. This can be detected using the conflict's
+// transaction field. The commit() code, amongst others, needs
+// to handle global and per-transaction conflicts differently.
+
+void
+CdlTransactionBody::resolve(CdlConflict conflict, int level)
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::resolve");
+ CYG_REPORT_FUNCARG3XV(this, conflict, level);
+ CYG_PRECONDITION_THISC();
+ CYG_PRECONDITION_CLASSC(conflict);
+ CYG_PRECONDITIONC(0 == conflict->solution.size());
+ CYG_PRECONDITIONC((0 <= level) && (level <= inference_recursion_limit));
+
+ CdlTransaction sub_transaction = this->make(conflict);
+ CYG_PRECONDITION_CLASSC(sub_transaction);
+ if (!conflict->inner_resolve(sub_transaction, level)) {
+ CYG_ASSERTC(0 == sub_transaction->changes.size());
+ sub_transaction->cancel();
+ delete sub_transaction;
+ conflict->no_solution = true;
+ CYG_REPORT_RETURN();
+ return;
+ }
+ // Is the inference engine lying? The conflict should be resolved
+ // in the sub-transaction.
+ if (conflict->is_structural()) {
+ if (std::find(sub_transaction->deleted_structural_conflicts.begin(),
+ sub_transaction->deleted_structural_conflicts.end(),
+ conflict) == sub_transaction->deleted_structural_conflicts.end()) {
+
+ CYG_FAIL("The inference engine has proved too optimistic.");
+ sub_transaction->cancel();
+ delete sub_transaction;
+ conflict->no_solution = true;
+ CYG_REPORT_RETURN();
+ return;
+ }
+ } else {
+ if (std::find(sub_transaction->deleted_conflicts.begin(), sub_transaction->deleted_conflicts.end(), conflict)
+ == sub_transaction->deleted_conflicts.end()) {
+
+ CYG_FAIL("The inference engine has proved too optimistic.");
+ sub_transaction->cancel();
+ delete sub_transaction;
+ conflict->no_solution = true;
+ CYG_REPORT_RETURN();
+ return;
+ }
+ }
+
+ // Even if there is a solution it cannot always be applied
+ // automatically because that would affect existing user
+ // values. Instead the solution needs to be saved so that
+ // the user can inspect it later. This should only happen
+ // at level 0. If we have recursed into the inference
+ // engine then we should only worry about this right at
+ // the end, not at every stage (although internally the
+ // inference code may worry about this when choosing
+ // between alternatives).
+ if ((0 == level) && sub_transaction->user_confirmation_required()) {
+ sub_transaction->save_solution();
+ sub_transaction->cancel();
+ delete sub_transaction;
+ this->dirty = true;
+
+ if (0 == conflict->transaction) {
+ // This is a global conflict, not a per-transaction one.
+ // There is a separate list of these conflicts.
+ std::list<CdlConflict>::const_iterator conf_i;
+ conf_i = std::find(this->global_conflicts_with_solutions.begin(),
+ this->global_conflicts_with_solutions.end(),
+ conflict);
+ if (conf_i == this->global_conflicts_with_solutions.end()) {
+ this->global_conflicts_with_solutions.push_back(conflict);
+ }
+ }
+ } else {
+
+ // This sub-transaction is safe, it can be applied
+ // immediately. The commit code detects that the
+ // solution being committed is for a particular
+ // resolved conflict and will take care of moving that
+ // conflict to the resolved list.
+ conflict->solution_references.clear(); // No point in preserving this information
+ conflict->no_solution = false; // Redundant
+ std::map<CdlValuable, CdlValue>::const_iterator soln_i;
+ for (soln_i = sub_transaction->changes.begin(); soln_i != sub_transaction->changes.end(); soln_i++) {
+ conflict->solution.push_back(*soln_i);
+ }
+ sub_transaction->commit();
+ delete sub_transaction;
+ }
+
+ CYG_REPORT_RETURN();
+}
+
+//}}}
+//{{{ resolve_recursion()
+
+// ----------------------------------------------------------------------------
+// resolve_recursion()
+//
+// The inference engine has tried one or more changes in the context of
+// a sub-transaction. It is now necessary to check whether these changes
+// are beneficial, i.e. whether or not any new problems are introduced
+// that cannot be resolved.
+bool
+CdlTransactionBody::resolve_recursion(int level)
+{
+ CYG_REPORT_FUNCNAMETYPE("CdlTransaction::resolve_recursion", "result %d");
+ CYG_REPORT_FUNCARG2XV(this, level);
+ CYG_PRECONDITION_THISC();
+
+ bool result = false;
+ this->propagate();
+ if (0 == new_conflicts.size()) {
+ result = true;
+ CYG_REPORT_RETVAL(result);
+ return result;
+ }
+ if (level >= inference_recursion_limit) {
+ result = false;
+ CYG_REPORT_RETVAL(result);
+ return result;
+ }
+
+ // There are new conflicts, but it may be possible to resolve them
+ // by a recursive invocation of the inference engine.
+ bool solutions_possible = false;
+ do {
+ this->resolve(level + 1);
+ std::list<CdlConflict>::const_iterator conf_i;
+ solutions_possible = false;
+ for (conf_i = this->new_conflicts.begin(); conf_i != this->new_conflicts.end(); conf_i++) {
+ if (!(*conf_i)->has_no_solution()) {
+ solutions_possible = true;
+ }
+ }
+ } while(solutions_possible);
+
+ result = (0 == new_conflicts.size());
+ CYG_REPORT_RETVAL(result);
+ return result;
+}
+
+//}}}
+
+//}}}
+//{{{ Body
+
+// ----------------------------------------------------------------------------
+// The majority of transactions involve the same set of steps. First one
+// or more values are modified. Then there has to be propagation, inference,
+// an inference callback, ... There may be a number of iterations. It is
+// convenient to have a single transaction body function which takes care
+// of all of that.
+//
+// If automatic inference is disabled then life is pretty simple, there
+// should be one propagate() operation followed by a commit.
+//
+// If automatic inference is enabled but there is no inference callback
+// then we need a loop consisting of propagation and inference, while
+// progress is made. Progress can be detected by value changes.
+//
+// If there is an inference callback then life gets pretty complicated.
+// The problem is figuring out exactly when the inference callback
+// should be invoked:
+//
+// 1) any new conflicts should certainly result in a callback, to give
+// the user a chance to cancel the changes.
+// 2) any new solutions that have been applied automatically need to
+// be shown to the user, again so that it is possible to cancel
+// the changes.
+// 3) any existing conflicts with a new solution, albeit one that cannot
+// be applied automatically, should result in a callback. This is
+// somewhat problematical since the new solution may in fact be
+// identical to a previous one that the user has already decided
+// against committing.
+//
+// It is not easy to keep track of when new conflicts or solutions get
+// added to a transaction. Simply counting the entries in the
+// appropriate STL containers is insufficient, as conflicts come and
+// go. Instead it is necessary to have a "dirty" flag. Unfortunately
+// this too is not fool-proof: a new conflict may have been created,
+// resulting in the dirty flag being set, and then the conflict may
+// have disappeared.
+
+void
+CdlTransactionBody::body()
+{
+ CYG_REPORT_FUNCNAME("CdlTransaction::body");
+ CYG_REPORT_FUNCARG1XV(this);
+ CYG_PRECONDITION_THISC();
+
+ // The Body() member function can only be applied to a toplevel
+ // transaction, it does not really make sense to apply it to
+ // a sub-transaction (at least, not yet);
+ CYG_PRECONDITIONC((0 == parent) && (0 != toplevel));
+
+ if (!inference_enabled) {
+ this->propagate();
+ this->commit();
+ CYG_REPORT_RETURN();
+ return;
+ }
+
+ if (0 == inference_callback) {
+ bool progress = false;
+ do {
+ progress = false;
+ this->propagate();
+ CYG_LOOP_INVARIANTC(0 == value_changes.size());
+ this->resolve();
+ if (0 != value_changes.size()) {
+ progress = true;
+ }
+ } while(progress);
+
+ this->commit();
+ CYG_REPORT_RETURN();
+ return;
+ }
+
+ bool cancel = false;
+
+ unsigned int resolved_size = 0;
+ unsigned int globals_with_solutions_size = 0;
+
+ do {
+ bool progress = false;
+ do {
+ progress = false;
+ this->propagate();
+ CYG_LOOP_INVARIANTC(0 == value_changes.size());
+ this->resolve();
+ if (0 != value_changes.size()) {
+ progress = true;
+ }
+ } while(progress);
+
+ // Sanity check: if there are no conflicts and no new entries in
+ // the resolved vector, then stop here. The user has already seen
+ // and taken care of everything of interest.
+ if ((0 == new_conflicts.size()) &&
+ (resolved_size == resolved_conflicts.size()) &&
+ (globals_with_solutions_size == global_conflicts_with_solutions.size())) {
+ cancel = false;
+ break;
+ }
+
+ // Also, if no conflicts have been added, no new solutions
+ // have been identified, and no new solutions have been applied,
+ // then there is no point in asking for user feedback.
+ if (!this->dirty) {
+ cancel = false;
+ break;
+ }
+
+ // Clear state before invoking the callback. If the user does not
+ // change anything else then we should get out of the loop next
+ // time around.
+ this->dirty = false;
+ resolved_size = resolved_conflicts.size();
+ globals_with_solutions_size = global_conflicts_with_solutions.size();
+
+ // Invoke the callback. If the result is cancel, do so. Otherwise
+ // we need to spin while things are changing.
+ if (CdlInferenceCallbackResult_Cancel == (*inference_callback)(this)) {
+ cancel = true;
+ }
+ } while(!cancel);
+
+ if (cancel) {
+ this->cancel();
+ } else {
+ this->commit();
+ }
+
+ CYG_REPORT_RETURN();
+}
+
+//}}}
+
projects / karo-tx-redboot.git / blobdiff