public DB( SifVersion version,
String namespace_Renamed,
string schemaTagName )
{
InitBlock();
fVersion = version;
fNamespace = namespace_Renamed;
fSchemaName = schemaTagName;
}
/// <summary> Gets the DB object associated with the specified version of SIF (or
/// creates a new object if none currently exists).
/// </summary>
/// <param name="version">The SIF version (e.g. "1.0r1")
/// </param>
public static DB getDB( SifVersion version )
{
DB db = (DB) fDBs[version.ToString()];
if ( db == null ) {
db = new DB( version, version.Xmlns, "Edustructures MetaData" );
fDBs[version.ToString()] = db;
}
return db;
}
/// <summary> Constructor
/// </summary>
/// <param name="id">Sequence number of this object
/// </param>
/// <param name="name">Element name (e.g. "StudentPersonal", "OtherId", etc.)
/// </param>
/// <param name="localPackage">Package name (e.g. "common", "student", "food", etc.)
/// </param>
/// <param name="version">Version of SIF this object is being defined for
///
/// </param>
public ObjectDef( int id,
string name,
string srcLocation,
string localPackage,
SifVersion version )
: base(name)
{
this.SourceLocation = srcLocation;
this.LocalPackage = localPackage;
//this.LatestVersion =
}
public static SifDataObject WriteParseAndReturn( SifDataObject o,
SifVersion version )
{
SifDataObject returnVal = null;
try
{
// Write the object to System.out
Console.WriteLine( "Writing object : " + o.ObjectTag
+ " using SifVersion: " + version.ToString() );
SifWriter echo = new SifWriter( Console.Out );
echo.Write( o, version );
o.SetChanged( false );
echo.Write( o );
// Write the object to a file
Console.WriteLine( "Writing to file..." );
using(Stream fos = File.Open( "test.xml", FileMode.Create, FileAccess.Write ) )
{
SifWriter writer = new SifWriter( fos );
o.SetChanged( true );
writer.Write( o, version );
writer.Flush();
fos.Close();
}
// Parse the object from the file
Console.WriteLine( "Parsing from file..." );
SifParser p = SifParser.NewInstance();
using( Stream fis = File.OpenRead( "test.xml"))
{
returnVal = (SifDataObject) p.Parse( fis, null );
}
// Write the parsed object to System.out
returnVal.SetChanged( true );
Console.WriteLine( "Read object : " + returnVal.ObjectTag );
echo.Write( returnVal, version );
}
catch (Exception e)
{
Console.WriteLine( e );
Assert.Fail( "Exception: " + e.Message );
}
return returnVal;
}
public virtual void addAlias( SifVersion version,
string tag,
int sequence )
{
if ( fAliases == null ) {
fAliases = new Hashtable();
}
Alias a = (Alias) fAliases[version.ToString()];
if ( a != null ) {
throw new MergeException( Tag + " alias already defined for " + version );
}
a = new Alias();
a.tag = tag;
a.sequence = sequence;
string verStr = version.Major + version.Minor.ToString() +
(version.Revision == 0 ? "" : "r" + version.Revision);
fAliases[verStr] = a;
}
/// <summary> Gets a SifVersion instance</summary>
/// <remarks>
/// <para>
/// This method always returns the same version instance for the given version
/// numbers. If the version number match on official version supported by the ADK,
/// that version instance is returned. Otherwise, a new SIFVersion instance is
/// created and returned. The sam SifVersion instance will always be returned for
/// the same paramters
/// </para>
/// </remarks>
/// <returns> A SifVersion instance to encapsulate the version information
/// provided to this method. If the <i>major</i>, <i>minor</i>, and
/// <i>revision</i> numbers match one of the versions supported by the
/// Adk (e.g. SifVersion.SIF10r1, SifVersion.SIF10r2, etc.), that object
/// is returned. Otherwise, a new instance is created. Thus, you are
/// guaranteed to always receive the same SifVersion instance or a given
/// version number supported by the Adk.
/// </returns>
private static SifVersion GetInstance(int major,
int minor,
int revision)
{
// Check for versions explicitly supported by the ADK first
if (major == 2)
{
if (minor == 0)
{
if (revision == 0)
{
return SIF20;
}
else if (revision == 1)
{
return SIF20r1;
}
}
if (minor == 1 && revision == 0)
{
return SIF21;
}
}
else if (major == 1)
{
if (minor == 5 && revision == 1)
{
return SIF15r1;
}
else if (minor == 1 && revision == 0)
{
return SIF11;
}
}
// No explicit support found. Return a newly-fabricated instance
// to support this version of SIF
String tag = ToString(major, minor, revision, '.');
SifVersion ver;
if (sVersions == null)
{
sVersions = new Dictionary<string, SifVersion>();
}
if (!sVersions.TryGetValue(tag, out ver))
{
ver = new SifVersion(major, minor, revision);
sVersions[tag] = ver;
}
return ver;
}
private XmlDocument getDocument( string localPackage,
SifVersion version )
{
string path = Path.Combine( fsrcLocation, "autogen." + localPackage + ".xml" );
XmlDocument doc = packageFiles[path] as XmlDocument;
if ( doc == null ) {
doc = new XmlDocument();
if ( File.Exists( path ) ) {
doc.Load( path );
}
else {
// TODO: generate a more concise xml string, based on version
string xml = "<adk package=\"" + localPackage + "\" version=\"" +
version.ToString() + "\" namespace=\"" + version.Xmlns + "\"/>";
doc.PreserveWhitespace = false;
doc.LoadXml( xml );
}
packageFiles[path] = doc;
}
return doc;
}
private void AddUndefinedObject( ObjectDef def,
SifVersion version )
{
XmlDocument doc = getDocument( def.LocalPackage, version );
DefinitionFile.WriteObjectToDom( def, doc );
}
private void AddUndefinedEnum( EnumDef def,
SifVersion version )
{
XmlDocument doc = getDocument( def.LocalPackage, version );
DefinitionFile.WriteEnumToDom( def, doc );
}
protected internal virtual void onRoot( XmlElement node )
{
fLocalPackage = getAttr( node, "package" );
String ver = getAttr( node, "version" );
fNamespace = getAttr( node, "namespace" );
if ( fLocalPackage == null || ver == null || fNamespace == null ) {
throw new ParseException
( "<adk> must specify the package=, version=, and namespace= attributes" );
}
fVersion = SifVersion.Parse( ver );
fPackage = "Edustructures.SifWorks." + fLocalPackage;
Console.Out.WriteLine( " Package=" + fPackage );
Console.Out.WriteLine( " Version=" + ver + " (" + this.fVersion + ")" );
Console.Out.WriteLine( " Namespace=" + fNamespace );
fDB = MetaDataSchema.getDB( fVersion );
}
private void RunVersioningTests(SifVersion dataVersion, SifVersion schemaVersion, bool ignoreEnumerationErrors)
{
// Tests assume that the schema files are embedded in the test assembly
DirectoryInfo workingDirectory = new DirectoryInfo(Environment.CurrentDirectory);
Type rootNamespaceType = typeof ( UsAdkTest );
String schemaVersionStr = getShortenedVersion(schemaVersion);
String schemaResourcePath = rootNamespaceType.Namespace + ".schemas." + schemaVersionStr;
AssemblyResourceResolver asr = new AssemblyResourceResolver(rootNamespaceType.Assembly, schemaResourcePath );
SchemaValidator sv = null;
using( Stream rootSchema = rootNamespaceType.Assembly.GetManifestResourceStream( schemaResourcePath + ".SIF_Message.xsd" ))
using( TextReader textReader = new StreamReader( rootSchema ) )
{
sv = SchemaValidator.NewInstance( textReader, asr );
textReader.Close();
rootSchema.Close();
}
sv.IgnoreEnumerationErrors = ignoreEnumerationErrors;
String dataVersionStr = getShortenedVersion(dataVersion);
// Warning, slight hack. Move up two directories to the project root directory (assumes the project directory is still there)
workingDirectory = workingDirectory.Parent.Parent;
DirectoryInfo dataDir = new DirectoryInfo(workingDirectory.FullName + "\\data\\" + dataVersionStr);
int errorCount = RunDirectoryTest(dataVersion, schemaVersion, dataDir, Console.Out, sv);
Assert.AreEqual(0, errorCount, "Tests Failed. See System.out for details");
}
private bool RunSingleTest(
SifVersion parseVersion,
SifVersion writeVersion,
string fileName,
TextWriter output,
SchemaValidator sv)
{
sv.Clear();
if (VERBOSE)
{
output.Write("Running test on " + fileName + "\r\n");
}
// 1) Read the object into memory
SifElement se = null;
try
{
se = AdkObjectParseHelper.ParseFile(fileName, parseVersion);
}
catch (AdkException adke)
{
// Parsing failed. However, since this unit test is a complete
// test of all available objects, just emit the problem and allow
// the test to continue (with a notification of false)
output
.WriteLine("Error parsing file " + fileName + "\r\n - "
+ adke);
output.WriteLine();
return false;
}
catch (Exception re)
{
output.WriteLine("Error parsing file " + fileName + "\r\n - " + re);
output.WriteLine();
return false;
}
// if (VERBOSE)
// {
// SifWriter writer = new SifWriter(output);
// writer.Write(se,parseVersion);
// output.Flush();
// }
// Before we can validate with the schema, we need to ensure that the
// data object is wrapped in a SIF_Message elements, because the SIF
// Schema makes that assumption
SifMessagePayload smp = SchemaValidator.MakeSIFMessagePayload(se);
String tmpFileName = fileName + "." + writeVersion.ToString() + ".adk";
// 2) Write the message out to a file
SchemaValidator.WriteObject(writeVersion, tmpFileName, smp);
// 3) Validate the file
bool validated = sv.Validate(tmpFileName);
// 4) If validation failed, write the object out for tracing purposes
if (!validated)
{
if (VERBOSE)
{
SifWriter outWriter = new SifWriter(output);
outWriter.Write(se, writeVersion );
outWriter.Flush();
}
output.WriteLine("Validation failed on " + tmpFileName );
sv.PrintProblems(output);
return false;
}
// 5) Read the object again into memory
try
{
se = AdkObjectParseHelper.ParseFile(fileName, parseVersion);
}
catch (AdkException adke)
{
// Parsing failed. However, since this unit test is a complete
// test of all available objects, just emit the problem and allow
// the test to continue (with a notification of false)
output.WriteLine("Error parsing file " + fileName + ": "
+ adke.Message );
return false;
}
catch (Exception re)
{
output.Write("Error parsing file " + fileName + ": "
+ re.Message + "\r\n");
return false;
}
return validated;
}
private int RunDirectoryTest(SifVersion parseVersion, SifVersion writeVersion, DirectoryInfo dir, TextWriter output, SchemaValidator sv)
{
int errorCount = 0;
foreach (DirectoryInfo childDir in dir.GetDirectories())
{
errorCount += RunDirectoryTest(parseVersion, writeVersion, childDir, output, sv);
}
foreach (FileInfo fileInfo in dir.GetFiles("*.xml"))
{
if (!RunSingleTest(parseVersion, writeVersion, fileInfo.FullName, output, sv))
{
errorCount++;
}
}
output.Flush();
return errorCount;
}
private String getShortenedVersion(SifVersion version)
{
StringBuilder builder = new StringBuilder();
builder.Append("SIF");
builder.Append(version.Major);
builder.Append(version.Minor);
if (version.Revision > 0)
{
builder.Append('r');
builder.Append(version.Revision);
}
return builder.ToString();
}
public ISchemaDefinition GetSchemaDefinition( SifVersion version )
{
return getDB( version );
}
