/// <summary>
/// Update references to paragraphs
/// </summary>
/// <param name="obj"></param>
/// <param name="visitSubNodes"></param>
public override void visit(Generated.ReqRef obj, bool visitSubNodes)
{
ReqRef reqRef = (ReqRef)obj;
if (UpdateGuid)
{
Specification.Paragraph paragraph = reqRef.Paragraph;
if (paragraph != null)
{
// Updates the paragraph Guid
if (paragraph.Guid != reqRef.getId())
{
reqRef.setId(paragraph.getGuid());
}
// Updates the specification Guid
Specification.Specification specification =
EnclosingFinder <Specification.Specification> .find(paragraph);
if (specification.Guid != reqRef.getSpecId())
{
reqRef.setSpecId(specification.Guid);
}
}
}
base.visit(obj, visitSubNodes);
}
public override void visit(Generated.Specification obj, bool visitSubNodes)
{
Specification.Specification specification = (Specification.Specification)obj;
if (specification.allChapterRefs() != null)
{
foreach (ChapterRef chapterRef in specification.allChapterRefs())
{
Chapter chapter = chapterRef.LoadChapter(LockFiles, AllowErrorsDuringLoad);
if (chapter != null)
{
specification.appendChapters(chapter);
chapter.ChapterRef = chapterRef;
}
else
{
ErrorsDuringLoad.Add(new ElementLog(ElementLog.LevelEnum.Error,
"Cannot load file " + chapterRef.FileName));
}
}
specification.allChapterRefs().Clear();
}
base.visit(obj, visitSubNodes);
}
public override void visit(Generated.Specification obj, bool visitSubNodes)
{
base.visit(obj, visitSubNodes);
Specification.Specification specification = (Specification.Specification)obj;
if (_beforeSave)
{
specification.ClearTempFiles();
specification.allChapterRefs().Clear();
if (specification.allChapters() != null)
{
foreach (Chapter chapter in specification.allChapters())
{
specification.appendChapterRefs(referenceChapter(specification, chapter));
}
}
specification.StoreInfo();
}
else
{
specification.RestoreInfo();
}
}
public override Generated.Specification createSpecification()
{
Generated.Specification retVal = new Specification.Specification();
_defaultValueSetter.SetDefaultValue(retVal);
return(retVal);
}
/// <summary>
/// Loads a specification and lock the file
/// </summary>
/// <param name="filePath">The name of the file which holds the dictionary data</param>
/// <param name="dictionary">The dictionary for which the specification is loaded</param>
/// <param name="lockFiles">Indicates that the files should be locked</param>
/// <returns></returns>
public static Specification.Specification LoadSpecification(String filePath, Dictionary dictionary,
bool lockFiles)
{
Specification.Specification retVal = LoadFile <Specification.Specification>(filePath, dictionary, lockFiles);
if (retVal == null)
{
throw new Exception("Cannot read file " + filePath);
}
return(retVal);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="originalFilePath"></param>
/// <param name="newFilePath"></param>
/// <param name="specifications"></param>
public Importer(string originalFilePath, string newFilePath, Specification specifications)
{
OriginalFilePath = originalFilePath;
NewFilePath = newFilePath;
Specifications = specifications;
}
/// <summary>
/// Performs the delta on the specification provided
/// </summary>
/// <param name="delta"></param>
/// <param name="specifications"></param>
private void PerformDelta(DataDictionary.Specification.Specification specifications)
{
foreach (Paragraph p in NewDocument.ChangedParagraphs)
{
DataDictionary.Specification.Paragraph par = specifications.FindParagraph(p.Id);
if (par != null)
{
par.Text = p.Text;
par.AddInfo("Paragraph has been changed");
par.setImplementationStatus(DataDictionary.Generated.acceptor.SPEC_IMPLEMENTED_ENUM.Impl_NewRevisionAvailable);
par.setReviewed(false);
foreach (DataDictionary.ReqRef reqRef in par.Implementations)
{
DataDictionary.ReqRelated reqRelated = reqRef.Model as DataDictionary.ReqRelated;
if (reqRelated != null)
{
reqRelated.setImplemented(false);
reqRelated.setVerified(false);
}
}
}
else
{
AddError(specifications, p, "Cannot find paragraph " + p.Id + " for modification");
}
}
foreach (Paragraph p in NewDocument.NewParagraphs)
{
DataDictionary.Specification.Paragraph par = specifications.FindParagraph(p.Id);
if (par != null)
{
AddError(specifications, p, "Paragraph " + p.Id + " already exists, whereas it has been detected as a new paragraph in the release");
}
else
{
par = specifications.FindParagraph(p.Id, true);
if (par != null)
{
par.setText(p.Text);
par.AddInfo("New paragraph");
}
else
{
AddError(specifications, p, "Paragraph " + p.Id + " cannot be found in the specification");
}
}
}
foreach (Paragraph p in NewDocument.RemovedParagraphs)
{
DataDictionary.Specification.Paragraph par = specifications.FindParagraph(p.Id);
if (par != null)
{
par.Text = "<Removed in current release>";
par.AddInfo("Paragraph has been removed");
}
else
{
AddError(specifications, p, "Cannot find paragraph " + p.Id + " for removal");
}
}
}
/// <summary>
/// Adds an importation error
/// </summary>
/// <param name="specifications"></param>
/// <param name="p"></param>
/// <param name="error"></param>
private void AddError(DataDictionary.Specification.Specification specifications, Paragraph p, string error)
{
specifications.AddError(error);
NewDocument.Errors.Add(new ImportationError(error, p));
}
public override Generated.Specification createSpecification()
{
Generated.Specification retVal = new Specification.Specification();
_defaultValueSetter.SetDefaultValue(retVal);
return retVal;
}
/// <summary>
/// Loads a specification and lock the file
/// </summary>
/// <param name="filePath">The name of the file which holds the dictionary data</param>
/// <param name="dictionary">The dictionary for which the specification is loaded</param>
/// <returns></returns>
public static Specification.Specification loadSpecification(String filePath, Dictionary dictionary)
{
Specification.Specification retVal = DocumentLoader <Specification.Specification> .loadFile(filePath, dictionary);
return(retVal);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="aSpecification">The specification to be exported</param>
public FunctionalBlockExporter(Specification aSpecification)
{
specification = aSpecification;
}
/// <summary>
/// Constructor
/// </summary>
public NotImplementedButImplementationExistsVisitor(Specification specification)
{
Implementations = new AllReferences();
foreach (DataDictionary.Dictionary dictionary in EFSSystem.INSTANCE.Dictionaries)
{
Implementations.Initialize(dictionary);
}
}
/// <summary>
/// Constructor
/// </summary>
public ImplementedWithNoFunctionalTestVisitor(Specification specification)
{
FunctionalTests = new AllReferences();
foreach (DataDictionary.Dictionary dictionary in EFSSystem.INSTANCE.Dictionaries)
{
FunctionalTests.Initialize(dictionary);
}
}
