URL https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [ecos-3.0/] [host/] [libcdl/] [transact.cxx] - Blame information for rev 790

Go to most recent revision | Details | Compare with Previous | View Log

//{{{  Banner                                   
 
//============================================================================
//
//      transaction.cxx
//
//      Implementation of the CdlTransaction class
//
//============================================================================
// ####ECOSHOSTGPLCOPYRIGHTBEGIN####                                        
// -------------------------------------------                              
// This file is part of the eCos host tools.                                
// Copyright (C) 1999, 2000, 2001, 2002 Free Software Foundation, Inc.      
//
// 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 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., 51 Franklin Street,                      
// Fifth Floor, Boston, MA  02110-1301, USA.                                
// -------------------------------------------                              
// ####ECOSHOSTGPLCOPYRIGHTEND####                                          
//============================================================================
//#####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();
}
 
//}}}
 
Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [rtos/] [ecos-3.0/] [host/] [libcdl/] [transact.cxx] - Blame information for rev 790

Line No.	Rev	Author	Line
1	786	skrzyp	`//{{{ Banner`
2
3			`//============================================================================`
4			`//`
5			`// transaction.cxx`
6			`//`
7			`// Implementation of the CdlTransaction class`
8			`//`
9			`//============================================================================`
10			`// ####ECOSHOSTGPLCOPYRIGHTBEGIN####`
11			`// -------------------------------------------`
12			`// This file is part of the eCos host tools.`
13			`// Copyright (C) 1999, 2000, 2001, 2002 Free Software Foundation, Inc.`
14			`//`
15			`// This program is free software; you can redistribute it and/or modify`
16			`// it under the terms of the GNU General Public License as published by`
17			`// the Free Software Foundation; either version 2 or (at your option) any`
18			`// later version.`
19			`//`
20			`// This program is distributed in the hope that it will be useful, but`
21			`// WITHOUT ANY WARRANTY; without even the implied warranty of`
22			`// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU`
23			`// General Public License for more details.`
24			`//`
25			`// You should have received a copy of the GNU General Public License`
26			`// along with this program; if not, write to the`
27			`// Free Software Foundation, Inc., 51 Franklin Street,`
28			`// Fifth Floor, Boston, MA 02110-1301, USA.`
29			`// -------------------------------------------`
30			`// ####ECOSHOSTGPLCOPYRIGHTEND####`
31			`//============================================================================`
32			`//#####DESCRIPTIONBEGIN####`
33			`//`
34			`// Author(s): bartv`
35			`// Contact(s): bartv`
36			`// Date: 1999/07/16`
37			`// Version: 0.01`
38			`//`
39			`//####DESCRIPTIONEND####`
40			`//============================================================================`