public override bool CanExecute()
{
if (!(newClassGuid != Guid.Empty &&
Project.VerifyComponentType <PSMClass>(newClassGuid) &&
attributeGuid != Guid.Empty &&
Project.VerifyComponentType <PSMAttribute>(attributeGuid)))
{
ErrorDescription = CommandErrors.CMDERR_INPUT_TYPE_MISMATCH;
return(false);
}
PSMClass newClass = Project.TranslateComponent <PSMClass>(newClassGuid);
PSMClass oldClass = Project.TranslateComponent <PSMAttribute>(attributeGuid).PSMClass;
//the two classes connected by an association path across containers (atomic operation)
if (newClass.NearestParentClass() == oldClass)
{
return(true);
}
if (oldClass.NearestParentClass() == newClass)
{
return(true);
}
if (newClass.RepresentedClass == oldClass || oldClass.RepresentedClass == newClass)
{
return(true);
}
ErrorDescription = CommandErrors.CMDERR_NO_COMMON_ASSOCIATION_OR_REPR;
return(false);
}
internal override void GenerateSubCommands()
{
PSMAttribute attribute = Project.TranslateComponent <PSMAttribute>(AttributeGuid);
PSMClass sourceClass = attribute.PSMClass;
PSMClass targetClass = Project.TranslateComponent <PSMClass>(ClassGuid);
if (sourceClass.GetSRs().Contains(targetClass))
{
List <PSMClass> intermediateClasses = new List <PSMClass>();
PSMClass current = sourceClass;
while (current != targetClass)
{
current = current.RepresentedClass;
intermediateClasses.Add(current);
}
foreach (PSMClass i in intermediateClasses)
{
Commands.Add(new acmdMovePSMAttribute(Controller, AttributeGuid, i)
{
Propagate = Propagate
});
}
}
else if (targetClass.GetSRs().Contains(sourceClass))
{
List <PSMClass> intermediateClasses = new List <PSMClass>();
PSMClass current = targetClass;
while (current != sourceClass)
{
intermediateClasses.Add(current);
current = current.RepresentedClass;
}
foreach (PSMClass i in intermediateClasses.Reverse <PSMClass>())
{
Commands.Add(new acmdMovePSMAttribute(Controller, AttributeGuid, i)
{
Propagate = Propagate
});
}
}
else
{
List <PSMClass> intermediateClasses = new List <PSMClass>();
PSMClass common = sourceClass.GetNearestCommonAncestorClass(targetClass);
Debug.Assert(common != null, "Common Ancestor Class Null");
if (common != sourceClass)
{
//move up to common class
PSMClass parent = sourceClass.NearestParentClass();
while (parent != common)
{
intermediateClasses.Add(parent);
parent = parent.NearestParentClass();
}
intermediateClasses.Add(common);
}
if (common.IsDescendantFrom(targetClass))
{
//move up
PSMClass parent = common.NearestParentClass();
while (parent != targetClass)
{
intermediateClasses.Add(parent);
parent = parent.NearestParentClass();
}
intermediateClasses.Add(targetClass);
}
else if (targetClass.IsDescendantFrom(common))
{
//move down
List <PSMClass> intermediateClasses2 = new List <PSMClass>();
intermediateClasses2.Add(targetClass);
PSMClass parent = targetClass.NearestParentClass();
while (parent != common)
{
intermediateClasses2.Add(parent);
parent = parent.NearestParentClass();
}
intermediateClasses2.Reverse();
intermediateClasses.AddRange(intermediateClasses2);
}
else if (targetClass == common)
{
//nothing
}
else
{
Debug.Assert(false, "error - common class not reachable?");
}
foreach (PSMClass psmClass in intermediateClasses)
{
Commands.Add(new acmdMovePSMAttribute(Controller, AttributeGuid, psmClass)
{
Propagate = Propagate
});
}
}
}
