/********************************************************************
* FUNCTION output_one_typedef_diff
*
* Output the differences report for one typedef definition
*
* INPUTS:
* cp == parameter block to use
* oldtyp == old typedef
* newtyp == new typedef
*
*********************************************************************/
static void
output_one_typedef_diff (yangdiff_diffparms_t *cp,
typ_template_t *oldtyp,
typ_template_t *newtyp)
{
yangdiff_cdb_t typcdb[5];
uint32 changecnt, i;
boolean isrev, tchanged;
isrev = (cp->edifftype==YANGDIFF_DT_REVISION) ? TRUE : FALSE;
tchanged = FALSE;
changecnt = 0;
if (type_changed(cp, &oldtyp->typdef, &newtyp->typdef)) {
tchanged = TRUE;
changecnt++;
}
changecnt += str_field_changed(YANG_K_UNITS,
oldtyp->units, newtyp->units,
isrev, &typcdb[0]);
changecnt += str_field_changed(YANG_K_DEFAULT,
oldtyp->defval, newtyp->defval,
isrev, &typcdb[1]);
changecnt += status_field_changed(YANG_K_STATUS,
oldtyp->status, newtyp->status,
isrev, &typcdb[2]);
changecnt += str_field_changed(YANG_K_DESCRIPTION,
oldtyp->descr, newtyp->descr,
isrev, &typcdb[3]);
changecnt += str_field_changed(YANG_K_REFERENCE,
oldtyp->ref, newtyp->ref,
isrev, &typcdb[4]);
if (changecnt == 0) {
return;
}
/* generate the diff output, based on the requested format */
output_mstart_line(cp, YANG_K_TYPEDEF, oldtyp->name, TRUE);
if (cp->edifftype == YANGDIFF_DT_TERSE) {
return;
}
indent_in(cp);
for (i=0; i<5; i++) {
if (typcdb[i].changed) {
output_cdb_line(cp, &typcdb[i]);
}
}
if (tchanged) {
output_one_type_diff(cp, &oldtyp->typdef, &newtyp->typdef);
}
indent_out(cp);
} /* output_one_typedef_diff */
/********************************************************************
* FUNCTION unQ_match
*
* Find the specified type in the unionnode Q
*
* INPUTS:
* cp == comparison parameters to use
* oldval == old typ_unionnode_t struct to check
* newQ == Q of new typ_unionnode_t structs to check
* idx == address of return index
*
* OUTPUTS:
* *idx == index of the unionnode entry found [0..N-1 numbering]
*
* RETURNS:
* pointer to the found entry
* NULL if not found
*********************************************************************/
static typ_unionnode_t *
unQ_match (yangdiff_diffparms_t *cp,
typ_unionnode_t *oldval,
dlq_hdr_t *newQ,
uint32 *idx)
{
typ_unionnode_t *newval;
typ_def_t *olddef, *newdef;
*idx = 0;
olddef = typ_get_unionnode_ptr(oldval);
for (newval = (typ_unionnode_t *)dlq_firstEntry(newQ);
newval != NULL;
newval = (typ_unionnode_t *)dlq_nextEntry(newval)) {
if (!newval->seen) {
newdef = typ_get_unionnode_ptr(newval);
if (!type_changed(cp, olddef, newdef)) {
return newval;
}
}
(*idx)++;
}
return NULL;
} /* unQ_match */
/********************************************************************
* FUNCTION typedef_changed
*
* Check if a (nested) typedef changed
*
* INPUTS:
* cp == parameter block to use
* oldtyp == old typ_template_t to use
* newtyp == new typ_template_t to use
*
* RETURNS:
* 1 if field changed
* 0 if field not changed
*********************************************************************/
uint32
typedef_changed (yangdiff_diffparms_t *cp,
typ_template_t *oldtyp,
typ_template_t *newtyp)
{
if (type_changed(cp, &oldtyp->typdef, &newtyp->typdef)) {
return 1;
}
if (str_field_changed(YANG_K_UNITS,
oldtyp->units,
newtyp->units,
FALSE,
NULL)) {
return 1;
}
if (str_field_changed(YANG_K_DEFAULT,
oldtyp->defval,
newtyp->defval,
FALSE,
NULL)) {
return 1;
}
if (status_field_changed(YANG_K_STATUS,
oldtyp->status,
newtyp->status,
FALSE,
NULL)) {
return 1;
}
if (str_field_changed(YANG_K_DESCRIPTION,
oldtyp->descr,
newtyp->descr,
FALSE,
NULL)) {
return 1;
}
if (str_field_changed(YANG_K_REFERENCE,
oldtyp->ref,
newtyp->ref,
FALSE,
NULL)) {
return 1;
}
return 0;
} /* typedef_changed */
void ClassInstanceDialog::menu_class()
{
QMenu m(0);
MenuFactory::addItem(m, tr("Choose"), -1);
m.addSeparator();
int index = list.indexOf(edtype->currentText().trimmed());
if (index != -1)
MenuFactory::addItem(m, tr("Select in browser"), 0);
BrowserNode * bn = 0;
if (! visit) {
bn = BrowserView::selected_item();
if ((bn != 0) && (bn->get_type() == UmlClass) && !bn->deletedp())
MenuFactory::addItem(m, tr("Choose class selected in browser"), 1);
else
bn = 0;
if (cl_container != 0)
MenuFactory::addItem(m, tr("Create class and choose it"), 2);
}
if ((index != -1) || (bn != 0) || (cl_container != 0)) {
QAction* retAction = m.exec(QCursor::pos());
if(retAction)
{
switch (retAction->data().toInt()) {
case 0:
nodes.at(index)->select_in_browser();
break;
case 2:
bn = BrowserClass::add_class(FALSE, cl_container);
if (bn == 0)
return;
bn->select_in_browser();
// no break
case 1: {
if ((index = nodes.indexOf(bn)) == -1) {
// new class, may be created through an other dialog
QStringList::Iterator iter = list.begin();
QStringList::Iterator iter_end = list.end();
QString s = bn->full_name(TRUE);
index = 0;
while ((iter != iter_end) && (*iter < s)) {
++iter;
index += 1;
}
nodes.insert((unsigned) index, bn);
list.insert(iter, s);
edtype->insertItem(index,s);
}
}
edtype->setCurrentIndex(index);
type_changed(index);
break;
default:
break;
}
}
}
}
ClassInstanceDialog::ClassInstanceDialog(ClassInstanceData * i)
: TabDialog(0, "class instance dialog", FALSE, Qt::WA_DeleteOnClose),
inst(i), atbl(0), rtbl(0)
{
setWindowTitle(tr("Class instance dialog"));
BrowserNode * bn = inst->get_browser_node();
bn->edit_start();
if (bn->is_writable()) {
setOkButton(tr("OK"));
setCancelButton(tr("Cancel"));
}
else {
setOkButton(QString());
setCancelButton(tr("Close"));
}
visit = !hasOkButton();
GridBox * grid;
// general tab
grid = new GridBox(2, this);
grid->setMargin(5);
grid->setSpacing(5);
grid->addWidget(new QLabel(tr("name : "), grid));
grid->addWidget(edname = new LineEdit(bn->get_name(), grid));
if (visit)
edname->setReadOnly(TRUE);
grid->addWidget(new QLabel(tr("stereotype :"), grid));
grid->addWidget(edstereotype = new QComboBox( grid));
edstereotype->setEditable(!visit);
edstereotype->addItem(toUnicode(bn->get_stereotype()));
if (! visit) {
edstereotype->addItems(ProfiledStereotypes::defaults(UmlClassInstance));
edstereotype->setAutoCompletion(completion());
}
SmallPushButton * b;
grid->addWidget(b = new SmallPushButton(tr("class :"), grid));
connect(b, SIGNAL(clicked()), this, SLOT(menu_class()));
grid->addWidget(edtype = new QComboBox(grid));
if (visit) {
edtype->addItem(inst->get_class()->full_name());
nodes.append(inst->get_class());
}
else {
BrowserClass::instances(nodes);
nodes.full_names(list);
edtype->addItems(list);
edtype->setCurrentIndex(nodes.indexOf(inst->get_class()));
connect(edtype, SIGNAL(activated(int)), this, SLOT(type_changed(int)));
}
if (visit)
cl_container = 0;
else {
cl_container = (BrowserNode *) bn->parent();
if ((cl_container != 0) && !cl_container->is_writable())
cl_container = 0;
}
VVBox * vtab;
grid->addWidget(vtab = new VVBox(grid));
vtab->addWidget(new QLabel(tr("description :"), vtab));
if (! visit) {
connect(b =new SmallPushButton(tr("Editor"), vtab), SIGNAL(clicked()),
this, SLOT(edit_description()));
vtab->addWidget(b);
}
grid->addWidget(comment = new MultiLineEdit(grid));
comment->setReadOnly(visit);
comment->setText(bn->get_comment());
QFont font = comment->font();
if (! hasCodec())
font.setFamily("Courier");
font.setFixedPitch(TRUE);
comment->setFont(font);
addTab(grid, "Uml");
// attributes tab
atbl = new MyTable(this);
atbl->setColumnCount(3);
//atbl->setSortingEnabled(true);
atbl->setSelectionMode(QTableWidget::NoSelection); // single does not work
atbl->verticalHeader()->setSectionsMovable(true);
atbl->verticalHeader()->setSectionsMovable(true);
atbl->setHorizontalHeaderLabel(0, tr(" Attribute "));
atbl->setHorizontalHeaderLabel(1, tr(" Class "));
atbl->setHorizontalHeaderLabel(2, tr(" Value "));
addTab(atbl, tr("Attributes"));
// relation tab
if (! inst->relations.isEmpty()) {
rtbl = new RelTable(this, inst, visit);
addTab(rtbl, tr("Relations"));
}
// USER : list key - value
grid = new GridBox(2, this);
grid->setMargin(5);
grid->setSpacing(5);
grid->addWidget(kvtable = new KeyValuesTable(bn, grid, visit));
addTab(grid, tr("Properties"));
type_changed(edtype->currentIndex());
connect(m_tabWidget, SIGNAL(currentChanged(int)),
this, SLOT(update_all_tabs(int)));
open_dialog(this);
}
//*******************************************************************
// QBtPackDialog CONSTRUCTOR
//*******************************************************************
QBtPackDialog::QBtPackDialog( QWidget* const in_parent ) : QDialog( in_parent )
, name_ ( QString() )
, dst_dir_ ( QString() )
, dst_path_ ( QString() )
, source_ ( new QBtInfoField )
, destination_ ( new QBtInfoField )
, compression_ ( new QCheckBox( tr( COMPRESSION ) ) )
, remove_ ( new QCheckBox( tr( REMOVE ) ) )
, ratio_ ( new QComboBox )
, run_ ( new QPushButton( tr( RUN ) ) )
, cancel_ ( new QPushButton( tr( CANCEL ) ) )
, tool_gbox_ ( new QGroupBox( tr( TOOL ) ) )
, gzip_ ( new QRadioButton( tr( GZIP ) ) )
, bzip2_ ( new QRadioButton( tr( BZIP2 ) ) )
, zip_ ( new QRadioButton( tr( ZIP ) ) )
, started_ ( false )
, break_ ( false )
, compress_type_ ( USE_TAR )
, fm_ ( font() )
, data_ ( SelectionsSet() )
{
setWindowTitle( tr( CAPTION ) );
QGroupBox* const src_dst_gbox = new QGroupBox( tr( SRC_AND_DST ) );
QGridLayout* src_dst_layout = new QGridLayout( src_dst_gbox );
src_dst_layout->setMargin( 4 );
src_dst_layout->setSpacing( 2 );
src_dst_layout->addWidget( new QLabel( tr( SOURCE ) ), 0, 0, Qt::AlignRight );
src_dst_layout->addWidget( new QLabel( tr( DESTINATION ) ), 1, 0, Qt::AlignRight );
src_dst_layout->addWidget( source_, 0, 1 );
src_dst_layout->addWidget( destination_, 1, 1 );
QGridLayout* const btn_layout = new QGridLayout;
btn_layout->addWidget( compression_, 0, 0 );
btn_layout->addWidget( remove_, 1, 0 );
btn_layout->addWidget( ratio_, 0, 1 );
btn_layout->addWidget( run_, 0, 2 );
btn_layout->addWidget( cancel_, 1, 2 );
btn_layout->setColumnStretch( 0, 100 );
btn_layout->setColumnStretch( 1, 30 );
QHBoxLayout* const tool_layout = new QHBoxLayout( tool_gbox_ );
tool_layout->addWidget( gzip_ );
tool_layout->addWidget( bzip2_ );
tool_layout->addWidget( zip_ );
QVBoxLayout* const main_layout = new QVBoxLayout;
main_layout->addWidget( src_dst_gbox );
main_layout->addLayout( btn_layout );
main_layout->addWidget( tool_gbox_ );
setLayout( main_layout );
for( qint32 i = 9; i >= 1; --i ) {
ratio_->addItem( QString::number( i ) );
}
gzip_->setChecked( true );
tool_gbox_->setEnabled( false );
ratio_->setEnabled( false );
connect( run_ , SIGNAL( clicked() ) , this, SLOT( run() ) );
connect( cancel_ , SIGNAL( clicked() ) , this, SLOT( reject() ) );
connect( compression_, SIGNAL( toggled( bool ) ), this, SLOT( compression( bool ) ) );
connect( gzip_ , SIGNAL( clicked() ) , this, SLOT( type_changed() ) );
connect( bzip2_ , SIGNAL( clicked() ) , this, SLOT( type_changed() ) );
connect( zip_ , SIGNAL( clicked() ) , this, SLOT( type_changed() ) );
}
/********************************************************************
* FUNCTION type_changed
*
* Check if the type clause and sub-clauses changed at all
*
* INPUTS:
* cp == compare parameters to use
* oldtypdef == old type def struct to check
* newtypdef == new type def struct to check
*
* RETURNS:
* 1 if field changed
* 0 if field not changed
*********************************************************************/
uint32
type_changed (yangdiff_diffparms_t *cp,
typ_def_t *oldtypdef,
typ_def_t *newtypdef)
{
typ_def_t *oldtest, *newtest;
const xmlChar *oldpath, *newpath;
ncx_btype_t oldbtyp, newbtyp;
#ifdef DEBUG
if (!oldtypdef || !newtypdef) {
SET_ERROR(ERR_INTERNAL_PTR);
return 1;
}
#endif
if (oldtypdef->tclass != newtypdef->tclass) {
return 1;
}
if (prefix_field_changed(cp->oldmod,
cp->newmod,
oldtypdef->prefix,
newtypdef->prefix)) {
return 1;
}
if (str_field_changed(NULL,
oldtypdef->typenamestr,
newtypdef->typenamestr,
FALSE,
NULL)) {
return 1;
}
switch (oldtypdef->tclass) {
case NCX_CL_BASE:
return (uint32)((oldtypdef->def.base == newtypdef->def.base) ? 0 : 1);
case NCX_CL_SIMPLE:
oldbtyp = typ_get_basetype(oldtypdef);
newbtyp = typ_get_basetype(newtypdef);
if (oldbtyp != newbtyp) {
return 1;
}
if (oldbtyp == NCX_BT_LEAFREF) {
oldpath = typ_get_leafref_path(oldtypdef);
newpath = typ_get_leafref_path(newtypdef);
return str_field_changed(YANG_K_PATH,
oldpath,
newpath,
FALSE,
NULL);
} else if (typ_is_string(oldbtyp)) {
if (patternQ_changed(oldtypdef, newtypdef)) {
return 1;
}
if (range_changed(oldtypdef, newtypdef)) {
return 1;
}
} else if (typ_is_number(oldbtyp)) {
if (range_changed(oldtypdef, newtypdef)) {
return 1;
}
} else {
switch (oldbtyp) {
case NCX_BT_BITS:
return ebQ_changed(&oldtypdef->def.simple.valQ,
&newtypdef->def.simple.valQ,
TRUE);
case NCX_BT_ENUM:
return ebQ_changed(&oldtypdef->def.simple.valQ,
&newtypdef->def.simple.valQ,
FALSE);
case NCX_BT_UNION:
return unQ_changed(cp,
&oldtypdef->def.simple.unionQ,
&newtypdef->def.simple.unionQ);
default:
;
}
}
return 0;
case NCX_CL_COMPLEX:
/* not supported for NCX complex types!!! */
return 0;
case NCX_CL_NAMED:
oldtest = typ_get_new_named(oldtypdef);
newtest = typ_get_new_named(newtypdef);
if ((!oldtest && newtest) || (oldtest && !newtest)) {
return 1;
} else if (oldtest && newtest) {
if (type_changed(cp, oldtest, newtest)) {
return 1;
}
}
return 0;
/*** do not look deep into named typed
*** add switch to check this
*** type_changed(cp, &oldtypdef->def.named.typ->typdef,
*** &newtypdef->def.named.typ->typdef);
***/
case NCX_CL_REF:
return type_changed(cp,
oldtypdef->def.ref.typdef,
newtypdef->def.ref.typdef);
default:
SET_ERROR(ERR_INTERNAL_VAL);
return 0;
}
/*NOTREACHED*/
} /* type_changed */
/********************************************************************
* FUNCTION output_union_diff
*
* Output the differences report for one union sub-clauses
* within a leaf, leaf-list, or typedef definition
*
* INPUTS:
* cp == parameter block to use
* oldtypdef == old internal typedef
* newtypdef == new internal typedef
*********************************************************************/
static void
output_union_diff (yangdiff_diffparms_t *cp,
typ_def_t *oldtypdef,
typ_def_t *newtypdef)
{
typ_unionnode_t *oldval, *newval, *curnew;
dlq_hdr_t *oldQ, *newQ;
typ_def_t *olddef, *newdef;
uint32 oldid, newid;
char oldnum[NCX_MAX_NUMLEN];
char newnum[NCX_MAX_NUMLEN];
olddef = typ_get_base_typdef(oldtypdef);
newdef = typ_get_base_typdef(newtypdef);
oldQ = &olddef->def.simple.unionQ,
newQ = &newdef->def.simple.unionQ;
if (!unQ_changed(cp, oldQ, newQ)) {
return;
}
oldid = 0;
newid = 0;
/* clear the seen flag to be safe */
for (newval = (typ_unionnode_t *)dlq_firstEntry(newQ);
newval != NULL;
newval = (typ_unionnode_t *)dlq_nextEntry(newval)) {
newval->seen = FALSE;
}
/* start the diff output */
output_mstart_line(cp, YANG_K_UNION, NULL, FALSE);
if (cp->edifftype == YANGDIFF_DT_TERSE) {
return;
}
indent_in(cp);
/* check for matching unionnode entries */
for (oldval = (typ_unionnode_t *)dlq_firstEntry(oldQ);
oldval != NULL;
oldval = (typ_unionnode_t *)dlq_nextEntry(oldval), oldid++) {
curnew = NULL;
sprintf(oldnum, "[%u]", oldid);
olddef = typ_get_unionnode_ptr(oldval);
/* first try the corresponded entry if available */
newval = unQ_match_id(oldid, newQ);
if (newval) {
curnew = newval;
newid = oldid;
sprintf(newnum, "[%u]", newid);
newdef = typ_get_unionnode_ptr(newval);
/* if the corresponding entry did not change
* then this is a match and continue to next type
*/
if (!type_changed(cp, olddef, newdef)) {
newval->seen = TRUE;
continue;
}
}
/* did not match the corresponding entry,
* so see if the typdef moved in the new union
*/
newval = unQ_match(cp, oldval, newQ, &newid);
if (newval) {
newval->seen = TRUE;
if (oldid != newid) {
sprintf(newnum, "[%u]", newid);
/* old union node was moved in new version */
output_diff(cp, YANG_K_TYPE,
(const xmlChar *)oldnum,
(const xmlChar *)newnum, TRUE);
}
} else if (curnew) {
/* type node was changed in the new union */
curnew->seen = TRUE;
newdef = typ_get_unionnode_ptr(curnew);
sprintf(newnum, "[%u]", oldid);
output_one_type_diff(cp, olddef, newdef);
} else {
/* old union node was removed in new version */
output_diff(cp, YANG_K_TYPE,
(const xmlChar *)oldnum, NULL, TRUE);
}
}
indent_out(cp);
/* check for new entries */
newid = 0;
for (newval = (typ_unionnode_t *)dlq_firstEntry(newQ);
newval != NULL;
newval = (typ_unionnode_t *)dlq_nextEntry(newval)) {
if (!newval->seen) {
sprintf(newnum, "[%u]", newid);
output_diff(cp, YANG_K_TYPE, NULL,
(const xmlChar *)newnum, TRUE);
}
newid++;
}
} /* output_union_diff */
/********************************************************************
* FUNCTION unQ_changed
*
* Check if the union Q in the typdef has changed
*
* INPUTS:
* cp == comparison parameter block to use
* oldQ == Q of old typ_unionnode_t structs to check
* newQ == Q of new typ_unionnode_t structs to check
*
* RETURNS:
* 1 if field changed
* 0 if field not changed
*********************************************************************/
static uint32
unQ_changed (yangdiff_diffparms_t *cp,
dlq_hdr_t *oldQ,
dlq_hdr_t *newQ)
{
typ_unionnode_t *oldval, *newval;
typ_def_t *olddef, *newdef;
boolean done;
if (dlq_count(oldQ) != dlq_count(newQ)) {
return 1;
}
/* clear the seen flag to be safe */
for (newval = (typ_unionnode_t *)dlq_firstEntry(newQ);
newval != NULL;
newval = (typ_unionnode_t *)dlq_nextEntry(newval)) {
newval->seen = FALSE;
}
oldval = (typ_unionnode_t *)dlq_firstEntry(oldQ);
newval = (typ_unionnode_t *)dlq_firstEntry(newQ);
/* check for matching entries */
done = FALSE;
while (!done) {
if (!oldval && !newval) {
return 0;
} else if (!oldval && newval) {
return 1;
} else if (oldval && !newval) {
return 1;
} /* else both old val and new val exist */
olddef = typ_get_unionnode_ptr(oldval);
newdef = typ_get_unionnode_ptr(newval);
if (type_changed(cp, olddef, newdef)) {
return 1;
}
newval->seen = TRUE;
oldval = (typ_unionnode_t *)dlq_nextEntry(oldval);
newval = (typ_unionnode_t *)dlq_nextEntry(newval);
}
/* check for new entries */
for (newval = (typ_unionnode_t *)dlq_firstEntry(newQ);
newval != NULL;
newval = (typ_unionnode_t *)dlq_nextEntry(newval)) {
if (!newval->seen) {
return 1;
}
}
return 0;
} /* unQ_changed */
