コード例 #1
0
 /// <summary>  Constructs a SifDataObject with XML content</summary>
 /// <param name="version">The version of SIF to associate with this object</param>
 /// <param name="def">The ElementDef constant from the SifDtd class identifying
 /// the data object represented by the XML</param>
 /// <param name="xml">The XML content</param>
 public SifDataObjectXml( SifVersion version,
                          IElementDef def,
                          String xml )
     : base(version, def)
 {
     fXml = xml;
 }
コード例 #2
0
ファイル: QueryTests.cs プロジェクト: rafidzal/OpenADK-csharp
        public static Query SaveToXMLAndReparse(Query query, SifVersion version)
        {
            String sifQueryXML = query.ToXml(version);
            Console.WriteLine(sifQueryXML);

            SifParser parser = SifParser.NewInstance();
            SIF_Request sifR = (SIF_Request)parser.Parse("<SIF_Request>" + sifQueryXML + "</SIF_Request>", null);

            Query newQuery = new Query(sifR.SIF_Query);
            return newQuery;
        }
コード例 #3
0
 private static 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();
 }
コード例 #4
0
        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;
        }
コード例 #5
0
        /// <summary>
        /// Reads a source SIF Data object from a file, using the specified SIF
        /// Version
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="version"></param>
        /// <returns></returns>
        protected SifElement readElementFromFile(String fileName, SifVersion version)
        {
            // NOTE: This method expects the source files to be located in the project
            // the unit tests were compiled from and makes an assumption about where that
            // project is relative to where the unit test assembly is located. That
            // makes any test based on this method less portable and may need to be adjusted in the future.

            fileName = "..\\..\\" + fileName;

            SifElement se;
            SifParser parser = SifParser.NewInstance();

            using ( StreamReader reader = new StreamReader( fileName ) )
            {
                se = parser.Parse( reader, null, 0, version );
                reader.Close();
            }
            return se;
        }
コード例 #6
0
        public static SchemaValidator NewInstance( SifVersion schemaVersion )
        {
            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();
            }

            return sv;
        }
コード例 #7
0
 /// <summary>
 /// Creates an instance of a SIF_ServiceNotify
 /// </summary>
 ///  <param name="sifVersion">The version of SIF to render this message in</param>
 ///
 public SIF_ServiceNotify( SifVersion sifVersion )
     : base(sifVersion, InfraDTD.SIF_SERVICENOTIFY)
 {
 }
コード例 #8
0
 static AdkExamples()
 {
     Version = SifVersion.LATEST;
 }
コード例 #9
0
ファイル: SIFParser.cs プロジェクト: rafidzal/OpenADK-csharp
        private void SetFieldValueFromElement( IElementDef def,
                                               SifElement element,
                                               XmlReader reader,
                                               SifVersion version,
                                               SifFormatter formatter,
                                               IZone zone )
        {
            // Check for xsi:nill
            if ( reader.IsEmptyElement )
            {
                // no data to set
                return;
            }

            // Look for the xsi:nill attribute that signals a null value
            while ( reader.MoveToNextAttribute() )
            {
                if (reader.LocalName == SifWriter.NIL && reader.NamespaceURI == XmlSchema.InstanceNamespace)
                {
                    SifSimpleType val = def.TypeConverter.GetSifSimpleType( null );
                    element.SetField( def, val );
                    while (reader.NodeType != XmlNodeType.EndElement)
                    {
                        reader.Read();
                    }
                    return;
                }
                else
                {
                    // TODO: This is an unknown attribute. Log and continue
                }
            }

            while ( reader.NodeType == XmlNodeType.Element )
            {
                reader.Read();
            }

            if ( reader.NodeType == XmlNodeType.Text )
            {
                SifSimpleType val = ParseValue( def, reader.Value.Trim(), version, formatter, zone );
                element.SetField( def, val );
            }
            // TODO: Not sure if this will always advance as expected.
            while ( reader.NodeType != XmlNodeType.EndElement )
            {
                reader.Read();
            }
        }
コード例 #10
0
ファイル: SIFParser.cs プロジェクト: rafidzal/OpenADK-csharp
        /// <summary>
        /// Reads a SIF_Message element, which sets the version and namespace scope for the rest of the 
        /// xml parsing
        /// </summary>
        /// <param name="reader"></param>
        /// <param name="dtd"></param>
        /// <param name="zone"></param>
        /// <param name="flags"></param>
        /// <param name="defaultVersion"></param>
        /// <returns></returns>
        /// <exception cref="OpenADK.Library.AdkParsingException">AdkParsingException is thrown if unable to 
        /// parse the message</exception>
        /// <exception cref="System.IO.IOException"> IOException is thrown if an error is reported while reading 
        /// the message content</exception>
        private SifElement ReadSIFMessageElement(
            XmlReader reader,
            IDtd dtd,
            IZone zone,
            SifParserFlags flags,
            SifVersion defaultVersion )
        {
            SifVersion version = ParseVersion( reader, dtd, zone, flags, defaultVersion );

            SIF_Message message = new SIF_Message();
            // Set the namespace from our working version
            message.SetXmlns( version.Xmlns );
            if ( version.CompareTo( SifVersion.SIF11 ) >= 0 )
            {
                // If we are at SifVersion 1.1 or greater, set the version attribute
                message.SetVersionAttribute( version.ToString() );
            }

            // Advance to the next element
            if ( reader.Read() )
            {
                while ( reader.NodeType != XmlNodeType.Element )
                {
                    if ( !reader.Read() )
                    {
                        break;
                    }
                }
                if ( reader.NodeType == XmlNodeType.Element )
                {
                    SifElement element = ParseElementStream( reader, version, dtd, zone, flags );
                    message.AddChild( element );
                }
            }

            return message;
        }
コード例 #11
0
ファイル: SIFParser.cs プロジェクト: rafidzal/OpenADK-csharp
        /// <summary>
        /// Parses the SIF Version from the version attribute or namespace. If not able
        /// to parse the version, the default version is returned.
        /// </summary>
        /// <param name="reader"></param>
        /// <param name="dtd"></param>
        /// <param name="zone"></param>
        /// <param name="flags"></param>
        /// <param name="defaultVersion"></param>
        /// <returns></returns>
        private SifVersion ParseVersion(
            XmlReader reader,
            IDtd dtd,
            IZone zone,
            SifParserFlags flags,
            SifVersion defaultVersion)
        {
            SifVersion version;
            String verAttr = reader.GetAttribute( "Version" );

            // Order of precedence:
            // 1) Version attribute of message
            // 2) The version passed in (if not null)
            // 3) The namespace version (if able to parse)
            // 4) The ADK SIF Version

            if ( verAttr != null )
            {
                version = SifVersion.Parse( verAttr );
            }
            else if ( defaultVersion != null )
            {
                version = defaultVersion;
            }
            else
            {
                String namespc = reader.NamespaceURI;
                version = SifVersion.ParseXmlns( namespc );
                if ( version == null )
                {
                    version = Adk.SifVersion;
                }
            }

            // Do validation on the version
            if ( !Adk.IsSIFVersionSupported( version ) )
            {
                throw new SifException(
                    SifErrorCategoryCode.Generic,
                    SifErrorCodes.GENERIC_VERSION_NOT_SUPPORTED_3,
                    string.Format( "SIF {0} not supported", version.ToString() ), reader.NamespaceURI, zone );
            }
            else if ( zone != null && zone.Properties.StrictVersioning )
            {
                if ( version.CompareTo( Adk.SifVersion ) != 0 )
                {
                    throw new SifException(
                        SifErrorCategoryCode.Generic,
                        SifErrorCodes.GENERIC_VERSION_NOT_SUPPORTED_3,
                        "SIF " + version.ToString() + " message support disabled by this agent",
                        string.Format( "This agent is running in strict SIF {0} mode", Adk.SifVersion.ToString() ), zone );
                }
            }
            return version;
        }
コード例 #12
0
ファイル: SIFParser.cs プロジェクト: rafidzal/OpenADK-csharp
        private void ParseLegacyXML(
                XmlReader reader, 
                SifVersion version,
			    IZone zone, 
                SifElement currentElement, 
                SifFormatter formatter,
			    String xmlName )
        {
            bool handled = false;

            // Determine if any surrogate formatters that are defined as children
            // of the current element can resolve it
            // NOTE: Until we fix this in the ADK, elements from the common package loose their
            // metadata information that was originally defined.
            IElementDef currentDef = currentElement.ElementDef;
            IList<IElementDef> children = currentDef.Children;
            if ( children == null || children.Count == 0 )
            {
                // try to get the actual element def
                // WARNING! this is somewhat of a hack until
                // we get support for what we need in the ADK metadata

                try
                {
                    SifElement copy =
                        (SifElement) ClassFactory.CreateInstance( currentDef.FQClassName );
                    children = copy.ElementDef.Children;
                }
                catch ( Exception cnfe )
                {
                    throw new SifException(
                        SifErrorCategoryCode.Xml,
                        SifErrorCodes.XML_GENERIC_VALIDATION_3,
                        "Unable to parse" + xmlName + "  " + version.ToString() + cnfe.Message, zone );
                }
            }
            using (XmlReader subtreeReader = reader.ReadSubtree())
            {
                subtreeReader.Read();
                foreach ( IElementDef candidate in children )
                {
                    if ( candidate.EarliestVersion.CompareTo( version ) > 0 )
                    {
                        continue;
                    }
                    IElementVersionInfo evi = candidate.GetVersionInfo( version );
                    if ( evi != null )
                    {
                        IRenderSurrogate rs = evi.GetSurrogate();
                        if ( rs != null )
                        {
                            try
                            {
                                bool surrogateHandled = rs.ReadRaw( subtreeReader, version, currentElement, formatter );
                                if ( surrogateHandled )
                                {
                                    handled = true;
                                    break;
                                }
                            }
                            catch ( AdkTypeParseException e )
                            {
                                HandleTypeParseException( "Unable to parse element or attribute value: " + e.Message, e,
                                                          zone );
                                handled = true;
                                break;
                            }
                            catch ( AdkParsingException e )
                            {
                                throw new SifException( SifErrorCategoryCode.Xml,
                                                        SifErrorCodes.XML_GENERIC_VALIDATION_3,
                                                        "unable to parse xml: " + e.Message
                                                        + version.ToString(), zone );
                            }
                        }
                    }
                }

                subtreeReader.Close();
            }
            // advance to the next tag
            reader.Read();

            if ( !handled )
            {
                String _tag = currentElement != null
                                  ? currentElement.ElementDef.Name + "/" + xmlName
                                  : xmlName;
                throw new SifException(
                    SifErrorCategoryCode.Xml,
                    SifErrorCodes.XML_GENERIC_VALIDATION_3, "Unknown element or attribute",
                    _tag + " is not a recognized element of SIF " + version.ToString(), zone );
            }
        }
コード例 #13
0
ファイル: SIFParser.cs プロジェクト: rafidzal/OpenADK-csharp
        private IElementDef LookupElementDef( SifElement parent,
                                              XmlReader reader,
                                              IDtd dtd,
                                              SifVersion version,
                                              IZone zone )
        {
            //  Lookup the ElementDef metadata in the SifDtd object for the
            //  version of SIF we are parsing. First try looking up a ElementDef
            //  for a field or complex object that is a child of another element,
            //  such as StudentPersonal_Name, SIF_Ack_SIF_Header, etc. If none
            //  found then look for a root-level element such as StudentPersonal,
            //  SIF_Ack, etc. If still nothing is found we don't know how to
            //  parse this element -- it is neither a top-level object element
            //  nor a child field element for this version of SIF.
            String elementName = reader.LocalName;
            IElementDef def = null;
            if ( parent != null )
            {
                def = dtd.LookupElementDef( parent.ElementDef, elementName );
            }

            if ( def == null )
            {
                def = dtd.LookupElementDef( elementName );
            }

            //	Beginning with SIF 1.5 *any* object can have a SIF_ExtendedElements
            //	child, so we need to check for that case since the Adk metadata
            //	does not add SIF_ExtendedElements to all object types
            if ( def == null && elementName.Equals( "SIF_ExtendedElements" ) )
            {
                def = GlobalDTD.SIF_EXTENDEDELEMENTS;
            }

            //	Beginning with SIF 2.0 *any* object can have a SIF_ExtendedElements
            //	child, so we need to check for that case since the Adk metadata
            //	does not add SIF_ExtendedElements to all object types
            if ( def == null && elementName.Equals( "SIF_Metadata" ) )
            {
                // TODO: Add support for SIF_Metadata back in to the .NET ADK
                def = null; // DatamodelDTD.SIF_METADATA;
            }

            // Note: def returned can be null.
            return def;
        }
コード例 #14
0
ファイル: SIFParser.cs プロジェクト: rafidzal/OpenADK-csharp
 /// <summary>
 /// Parses a SIF object from the binary data stream
 /// </summary>
 /// <param name="msg">The stream containing the Xml content to parse</param>
 /// <param name="zone">The Zone from which the message was received, or null if
 /// not applicable or not known</param>
 /// <param name="flags">The flags to use for parsing</param>
 /// <param name="version">The SifVersion to use for this parsing operation</param>
 /// <returns> A SifElement object encapsulating the message payload (e.g.
 /// a OpenADK.Library.us.Student.StudentPersonal object)</returns>
 /// <exception cref="OpenADK.Library.AdkParsingException">AdkParsingException is thrown if unable to 
 /// parse the message</exception>
 /// <exception cref="System.IO.IOException"> IOException is thrown if an error is reported while reading 
 /// the message content</exception>
 public SifElement Parse( Stream msg, IZone zone, SifParserFlags flags, SifVersion version )
 {
     XmlTextReader reader =
         new XmlTextReader( new StreamReader( msg, SifIOFormatter.ENCODING ) );
     reader.WhitespaceHandling = WhitespaceHandling.None;
     return Parse( reader, zone, flags, version );
 }
コード例 #15
0
ファイル: SIFVersion.cs プロジェクト: rubitek/OpenADK-csharp
        /// <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 (revision == 0)
                {
                    if (minor == 1)
                    {
                        return(SIF21);
                    }
                    else if (minor == 2)
                    {
                        return(SIF22);
                    }
                    else if (minor == 3)
                    {
                        return(SIF23);
                    }
                    else if (minor == 4)
                    {
                        return(SIF24);
                    }
                    else if (minor == 5)
                    {
                        return(SIF25);
                    }
                    else if (minor == 6)
                    {
                        return(SIF26);
                    }
                }
            }
            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);
        }
コード例 #16
0
 /// <summary>
 /// Returns a string representation of the value, formatted for the specified version of SIF
 /// </summary>
 /// <param name="version"></param>
 /// <returns></returns>
 public virtual String ToString(SifVersion version)
 {
     return(ToString(Adk.Dtd.GetFormatter(version)));
 }
コード例 #17
0
ファイル: ElementRef.cs プロジェクト: rubitek/OpenADK-csharp
 /// <summary>
 /// Creates an ElementRef instance using the specified IElementDef as the reference path
 /// </summary>
 /// <param name="root"></param>
 /// <param name="referencedField"></param>
 /// <param name="version"></param>
 public ElementRef(IElementDef root, IElementDef referencedField, SifVersion version)
 {
     fField = referencedField;
     fXPath = referencedField.GetSQPPath(version);
 }
コード例 #18
0
ファイル: ElementRef.cs プロジェクト: rubitek/OpenADK-csharp
 /// <summary>
 /// Creates an ElementRef instance by XPath
 /// </summary>
 /// <param name="root"></param>
 /// <param name="xPath"></param>
 /// <param name="version"></param>
 public ElementRef(IElementDef root, String xPath, SifVersion version)
 {
     fField = Adk.Dtd.LookupElementDefBySQP(root, xPath);
     fXPath = xPath;
 }
コード例 #19
0
ファイル: SIFParser.cs プロジェクト: rafidzal/OpenADK-csharp
 /// <summary>
 /// Parses the source of the XmlReader into a SifElement object.
 /// </summary>
 /// <param name="reader">The reader containing the Xml data to be parsed</param>
 /// <param name="zone">The Zone from which the message was received, or null if
 /// not applicable or not known</param>
 /// <param name="flags">The flags to use for parsing</param>
 /// <param name="version">The version of SIF that will be associated with the
 /// returned object.</param>
 /// <returns> A SifElement object encapsulating the message payload (e.g.
 /// a OpenADK.Library.us.Student.StudentPersonal object)</returns>
 /// <exception cref="OpenADK.Library.AdkParsingException">AdkParsingException is thrown if unable to 
 /// parse the message</exception>
 /// <exception cref="System.IO.IOException"> IOException is thrown if an error is reported while reading 
 /// the message content</exception>
 public SifElement Parse( XmlReader reader,
                          IZone zone,
                          SifParserFlags flags,
                          SifVersion version )
 {
     try
     {
         reader.MoveToContent();
         if ( reader.LocalName == "SIF_Message" )
         {
             SifElement element = ReadSIFMessageElement( reader, Adk.Dtd, zone, flags, version );
             return element.GetChildList()[0];
         }
         else
         {
             version = ParseVersion( reader, Adk.Dtd, zone, flags, version );
             return ParseElementStream( reader, version, Adk.Dtd, zone, flags );
         }
     }
     catch( XmlException xmle )
     {
         throw new AdkParsingException( xmle.Message, zone, xmle );
     }
 }
コード例 #20
0
        private void testSIFPingWithZISVersion( InMemoryProtocolHandler handler, SifVersion testVersion )
        {
            SIF_SystemControl ssc;
            Zone.Properties.ZisVersion = testVersion.ToString();
            Zone.SifPing();
            ssc = (SIF_SystemControl) handler.readMsg();

            Assert.AreEqual( testVersion, ssc.SifVersion, "SifVersion" );
            Assert.AreEqual( testVersion.Xmlns, ssc.GetXmlns(), "SifVersion->Xmlns" );
        }
コード例 #21
0
ファイル: SIFParser.cs プロジェクト: rafidzal/OpenADK-csharp
        private SifElement ParseElementStream( XmlReader reader,
                                               SifVersion version,
                                               IDtd dtd,
                                               IZone zone,
                                               SifParserFlags flags )
        {
            bool legacyParse = version.CompareTo( SifVersion.SIF20 ) < 0;

            // The current SIFElement being parsed
            SifElement currentElement = null;
            // The actual tag name of the current element
            SifFormatter formatter = Adk.Dtd.GetFormatter( version );
            reader.MoveToContent();
            bool doneParsing = false;
            while ( !(reader.EOF || doneParsing) )
            {
                switch ( reader.NodeType )
                {
                    case XmlNodeType.Element:
                        if ( reader.LocalName == "SIF_Message" )
                        {
                            // Special case for embedded SIF_Message envelopes
                            if ( (flags & SifParserFlags.ExpectInnerEnvelope) != 0 )
                            {
                                SifElement msgElement =
                                    ReadSIFMessageElement( reader, dtd, zone, SifParserFlags.None, version );
                                currentElement.AddChild( msgElement );
                                currentElement = msgElement;
                            }
                            else
                            {
                                throw new AdkParsingException
                                    ( "Unexpected SIF_Message encountered in parsing", zone );
                            }
                        }
                        else
                        {
                            String xmlName = reader.LocalName;
                            if( xmlName == "Teacher" )
                            {
                                Console.WriteLine( "Ready to break" );
                            }

                            IElementDef foundDef = LookupElementDef( currentElement, reader, dtd, version, zone );
                            if (foundDef == null)
                            {
                                if (legacyParse)
                                {
                                    ParseLegacyXML(reader, version, zone, currentElement, formatter, xmlName);
                                    continue;
                                }
                                else if (currentElement != null && currentElement.ElementDef.Name.Equals("XMLData"))
                                {
                                    // Parse this into a DOM and set on the XMLData
                                    // element
                                    XmlReader nestedReader = reader.ReadSubtree();
                                    XmlDocument doc = new XmlDocument();
                                    doc.Load( nestedReader );
                                    ((XMLData)currentElement).Xml = doc;
                                    continue;
                                }
                                else
                                {
                                    String _tag = currentElement != null ? currentElement.ElementDef.Name
                                            + "/" + xmlName
                                            : xmlName;
                                    throw new SifException( SifErrorCategoryCode.Xml, SifErrorCodes.XML_GENERIC_VALIDATION_3, "Unknown element or attribute", _tag
                                            + " is not a recognized element of SIF "
                                            + version.ToString(), zone);
                                }
                            }

                            if ( legacyParse )
                            {
                                IElementVersionInfo evi = foundDef.GetVersionInfo( version );
                                if (evi != null)
                                {
                                    IRenderSurrogate rs = evi.GetSurrogate();
                                    if (rs != null)
                                    {

                                        using (XmlReader subtreeReader = reader.ReadSubtree())
                                        {
                                            bool shouldContinue = true;
                                            subtreeReader.Read();
                                            try
                                            {
                                                shouldContinue = rs.ReadRaw( subtreeReader, version, currentElement, formatter );
                                            }
                                            catch ( AdkTypeParseException atpe )
                                            {
                                                HandleTypeParseException( "Unable to parse value: " + atpe.Message, atpe,
                                                                          zone );
                                            }
                                            subtreeReader.Close();
                                            // advance to the next tag
                                            reader.Read();
                                            if ( shouldContinue )
                                            {
                                                continue;
                                            }
                                            else
                                            {
                                                throw new SifException( SifErrorCategoryCode.Xml,
                                                                        SifErrorCodes.XML_GENERIC_VALIDATION_3,
                                                                        "Unknown element or attribute", reader.LocalName
                                                                                                        +
                                                                                                        " was not able to be parsed by "
                                                                                                        + rs, zone );
                                            }
                                        }
                                    }
                                }
                            }

                            if ( foundDef.Field )
                            {
                                SetFieldValueFromElement
                                    ( foundDef, currentElement, reader, version, formatter, zone );
                                // Advance to the next tag
                                do
                                {
                                    reader.Read();
                                } while (
                                    !(reader.EOF || reader.NodeType == XmlNodeType.Element ||
                                      reader.NodeType == XmlNodeType.EndElement) );
                                continue;
                            }
                            else if ( reader.IsEmptyElement )
                            {
                                // The .Net XmlReader does not return an EndElement event for
                                // tags with empty content. Therefore, this region of the code is
                                // slightly different from Java
                                ReadSifElementFromElementNode( foundDef, reader, dtd, currentElement, formatter,
                                                               version, zone );
                            }
                            else
                            {
                                currentElement =
                                    ReadSifElementFromElementNode( foundDef, reader, dtd, currentElement, formatter,
                                                                   version, zone );
                            }
                        }
                        break;
                    case XmlNodeType.Text:
                        if ( currentElement.ElementDef.HasSimpleContent )
                        {
                            SetFieldValueFromElement( currentElement.ElementDef, currentElement, reader, version,
                                                      formatter, zone );
                            // The XML Reader cursor is automatically advanced by this method, so we
                            // need to continue on without calling read()
                            continue;
                        }
                        break;
                    case XmlNodeType.EndElement:
                        if ( currentElement.Parent != null )
                        {
                            currentElement = (SifElement) currentElement.Parent;
                            while ( legacyParse && currentElement.ElementDef.IsCollapsed( version ) )
                            {
                                currentElement = (SifElement) currentElement.Parent;
                            }
                        }
                        if ( reader.LocalName == "SIF_Message" )
                        {
                            // We need to return here. If we let the reader keep reading, and we are reading an embedded
                            // SIF_Message, it will keep parsing the end tags and not let the stack of SifElement objects
                            // propertly unwind. We're done anyway.
                            doneParsing = true;
                        }
                        break;
                }

                // Advance the cursor
                reader.Read();
            }

            if ( currentElement == null )
            {
                return null;
            }
            else
            {
                // Now, unwind and pop off the top element parsed
                Element top = currentElement;
                Element current;
                while ( (current = top.Parent) != null )
                {
                    top = current;
                }
                return (SifElement) top;
            }
        }
コード例 #22
0
 /// <summary>
 /// Gets the fields from the SIFElement for the specified version of SIF. Only
 /// the fields that apply to the requested version of SIF will be returned.
 /// </summary>
 /// <param name="element"></param>
 /// <param name="version"></param>
 /// <returns></returns>
 public virtual ICollection<SimpleField> GetFields(SifElement element, SifVersion version)
 {
     ICollection<SimpleField> fields = element.GetFields();
     List<SimpleField> returnValue = new List<SimpleField>();
     // remove any fields that do not belong in this version of SIF
     foreach(SimpleField field in fields )
     {
         IElementDef def = field.ElementDef;
         if (version.CompareTo(def.EarliestVersion) > -1 &&
                 version.CompareTo(def.LatestVersion) < 1)
         {
             returnValue.Add( field );
         }
     }
     returnValue.Sort( ElementSorter<SimpleField>.GetInstance( version ) );
     return returnValue;
 }
コード例 #23
0
ファイル: SIFParser.cs プロジェクト: rafidzal/OpenADK-csharp
 private SifSimpleType ParseValue(
     IElementDef def,
     String value,
     SifVersion version,
     SifFormatter formatter,
     IZone zone )
 {
     try
     {
         TypeConverter converter = def.TypeConverter;
         if (converter == null)
         {
             // TODO: Should we not allow this in "STRICT" mode?
             converter = SifTypeConverters.STRING;
         }
         return converter.Parse(formatter, value);
     }
     catch (AdkTypeParseException pe)
     {
         String errorMessage = "Unable to parse element or attribute '"
                               + def.Name + "'" + pe.Message + " (SIF "
                               + version.ToString() + ")";
         HandleTypeParseException( errorMessage, pe, zone );
         return null;
     }
 }
コード例 #24
0
 /// <summary>
 /// Adds a SimpleField parsed from a specific version of SIF to the parent.
 /// </summary>
 /// <param name="contentParent">The element to add content to</param>
 /// <param name="fieldDef">The metadata definition of the field to set</param>
 /// <param name="data">The value to set to the field</param>
 /// <param name="version">The version of SIF that the SIFElement is being constructed
 /// from</param>
 /// <returns></returns>
 public virtual SimpleField SetField(SifElement contentParent,
     IElementDef fieldDef,
     SifSimpleType data,
     SifVersion version)
 {
     return contentParent.SetField(fieldDef, data);
 }
コード例 #25
0
ファイル: SIFParser.cs プロジェクト: rafidzal/OpenADK-csharp
        private SifElement ReadSifElementFromElementNode(
            IElementDef def,
            XmlReader reader,
            IDtd dtd,
            SifElement parent,
            SifFormatter formatter,
            SifVersion version,
            IZone zone )
        {
            SifElement element;
            try
            {
                element = SifElement.Create( parent, def );
            }
            catch ( TypeLoadException tle )
            {
                throw new AdkParsingException
                    ( "Could not create an instance of " + def.FQClassName + " to wrap a " +
                      reader.LocalName + " element because that class doesn't exist", zone, tle );
            }
            catch ( Exception ex )
            {
                throw new AdkParsingException
                    ( "Could not create an instance of " + def.FQClassName, zone, ex );
            }

            element.ElementDef = def;
            element.SifVersion = version;

            if ( parent != null )
            {
                element = formatter.AddChild( parent, element, version );
            }

            // Set the attributes to fields of the SifElement
            while ( reader.MoveToNextAttribute() )
            {
                SetFieldValueFromAttribute( element, reader, dtd, version, formatter, zone );
            }

            return element;
        }
コード例 #26
0
 public virtual SifElement AddChild(SifElement contentParent, SifElement content, SifVersion version)
 {
     return contentParent.AddChild(content);
 }
コード例 #27
0
ファイル: SIFParser.cs プロジェクト: rafidzal/OpenADK-csharp
        private void SetFieldValueFromAttribute(
            SifElement element,
            XmlReader reader,
            IDtd dtd,
            SifVersion version,
            SifFormatter formatter,
            IZone zone )
        {
            IElementDef elementDef = element.ElementDef;
            IElementDef field = dtd.LookupElementDef( element.ElementDef, reader.LocalName );
            if ( field == null && reader.Prefix != null )
            {
                if(reader.LocalName == SifWriter.NIL && reader.NamespaceURI == XmlSchema.InstanceNamespace )
                {
                    TypeConverter converter = elementDef.TypeConverter;
                    if ( converter != null )
                    {
                        SifSimpleType sst = converter.GetSifSimpleType( null );
                        element.SetField(elementDef, sst);
                    }
                    return;
                }
                else if( reader.Name.StartsWith( "xmlns" ) )
                {
                    return;
                }
                else
                {
                    field = dtd.LookupElementDef(elementDef, reader.Prefix + ":" + reader.LocalName);
                }
            }

            if( field != null )
            {
                string strVal = reader.Value.Trim();
                SifSimpleType val = ParseValue( field, strVal, version, formatter, zone );
                element.SetField( field, val );
            }
            else if (element.ElementDef.EarliestVersion >= SifVersion.SIF20 && version < SifVersion.SIF20)
            {
                Adk.Log.Warn("Field " + element.ElementDef.ClassName + "." + (reader.Prefix == null ? reader.LocalName : reader.Prefix + ":" + reader.LocalName ) + " does not exist in the sif 2.0 specification onwards.  It may or may not be valid in sif 1.5r1.  It will be ignored."  );
            }
            else
            {
                // TODO: Log and gracefully ignore, depending on whether the ADK is set to strict or loose parsing
                throw new SifException
                    (SifErrorCategoryCode.Xml, SifErrorCodes.XML_GENERIC_VALIDATION_3,
                      "Unknown element or attribute",
                      reader.LocalName + " is not a recognized attribute of the " +
                      elementDef.Name + " element (SIF " +
                      element.EffectiveSIFVersion.ToString() + ")", zone);
            }
        }
コード例 #28
0
        /// <summary>
        /// Gets the content from the SIFElement for the specified version of SIF. Only
        /// elements that apply to the requested version of SIF will be returned.
        /// </summary>
        /// <param name="element">The element to retrieve content from</param>
        /// <param name="version"></param>
        /// <returns></returns>
        public virtual IList<Element> GetContent( SifElement element, SifVersion version )
        {
            List<Element> returnValue = new List<Element>();
            ICollection<SimpleField> fields = element.GetFields();
            foreach (SimpleField val in fields) {
                IElementDef def = val.ElementDef;
                if (def.IsSupported(version) &&
                    !def.IsAttribute(version) &&
                    def.Field)
                {
                    returnValue.Add(val);
                }
            }

               IList<SifElement> children = element.GetChildList();
            foreach(SifElement val in children ) {
                IElementDef def = val.ElementDef;
                if (def.IsSupported(version))
                {
                    returnValue.Add(val);
                }
            }

            MergeSort.Sort<Element>(returnValue, ElementSorter<Element>.GetInstance(version));
            //returnValue.Sort( ElementSorter<Element>.GetInstance( version ) );
            return returnValue;
        }
コード例 #29
0
        private static void ParseGlobalProperties()
        {
            //  Look for options that do not affect the AgentProperties...
            for( int i = 0; i < sArguments.Length; i++ )
            {
                if( sArguments[ i ].ToUpper().Equals( "/debug".ToUpper() ) )
                {
                    if( i < sArguments.Length - 1 )
                    {
                        try
                        {
                            Adk.Debug = AdkDebugFlags.None;
                            int k = Int32.Parse( sArguments[ ++i ] );
                            if( k == 1 )
                            {
                                Adk.Debug = AdkDebugFlags.Minimal;
                            }
                            else if( k == 2 )
                            {
                                Adk.Debug = AdkDebugFlags.Moderate;
                            }
                            else if( k == 3 )
                            {
                                Adk.Debug = AdkDebugFlags.Detailed;
                            }
                            else if( k == 4 )
                            {
                                Adk.Debug = AdkDebugFlags.Very_Detailed;
                            }
                            else if( k == 5 )
                            {
                                Adk.Debug = AdkDebugFlags.All;
                            }
                        }
                        catch( Exception )
                        {
                            Adk.Debug = AdkDebugFlags.All;
                        }
                    }
                    else
                    {
                        Adk.Debug = AdkDebugFlags.All;
                    }
                }
                else if( sArguments[ i ].StartsWith( "/D" ) )
                {
                    string prop = sArguments[ i ].Substring( 2 );
                    if( i != sArguments.Length - 1 )
                    {
                        Properties.SetProperty( prop, sArguments[ ++i ] );
                    }
                    else
                    {
                        Console.WriteLine( "Usage: /Dproperty value" );
                    }
                }
                else if( sArguments[ i ].ToUpper().Equals( "/log".ToUpper() ) &&
                          i != sArguments.Length - 1 )
                {
                    try
                    {
                        Adk.SetLogFile( sArguments[ ++i ] );
                    }
                    catch( IOException ioe )
                    {
                        Console.WriteLine( "Could not redirect debug output to log file: " + ioe );
                    }
                }
                else if( sArguments[ i ].ToUpper().Equals( "/ver".ToUpper() ) &&
                          i != sArguments.Length - 1 )
                {
                    Version = SifVersion.Parse( sArguments[ ++i ] );
                }
                else if( sArguments[ i ].Equals( "/?" ) )
                {
                    Console.WriteLine();
                    Console.WriteLine
                        ( "These options are common to all Adk Example agents. For help on the usage" );
                    Console.WriteLine
                        ( "of this agent in particular, run the agent without any parameters. Note that" );
                    Console.WriteLine
                        ( "most agents support multiple zones if a zones.properties file is found in" );
                    Console.WriteLine( "the current directory." );
                    Console.WriteLine();
                    printHelp();

                    Environment.Exit( 0 );
                }
            }
        }
コード例 #30
0
 /// <summary>  Constructor</summary>
 /// <param name="version">The SIFVersion to render this message in</param>
 /// <param name="metadata">The ElementDef representing this object in the ADK metadata</param>
 public SifMessagePayload(SifVersion version, IElementDef metadata)
     : base(metadata)
 {
     SifVersion = version;
 }
コード例 #31
0
ファイル: SIF_Event.cs プロジェクト: pgodwin/OpenADK-csharp
 /// <summary>
 /// Creates an instance of a SIF_Event
 /// </summary>
 ///  <param name="sifVersion">The version of SIF to render this message in</param>
 ///
 public SIF_Event( SifVersion sifVersion )
     : base(sifVersion, InfraDTD.SIF_EVENT)
 {
 }
コード例 #32
0
ファイル: SIFParser.cs プロジェクト: rafidzal/OpenADK-csharp
 /// <summary>  Parses a SIF data element into a <c>SifElement</c>.
 /// 
 /// </summary>
 /// <param name="msg">The content to parse
 /// </param>
 /// <param name="zone">The Zone from which the message was received, or null if
 /// not applicable or not known
 /// </param>
 /// <param name="flags">One or more <c>FLG_</c> constants, or zero if no
 /// flags are applicable
 /// </param>
 /// <param name="version">The version of SIF that will be associated with the
 /// returned object. By default, SifParser uses the default version of
 /// SIF in effect for the agent when parsing messages that do not have
 /// a SIF_Message envelope. By specifying a value to this parameter, you
 /// can change the version of SIF associated with the returned object in
 /// the event there is no SIF_Message envelope present in the XML
 /// content. Note that when parsing XML content with a SIF_Message
 /// envelope, SifParser ignores this parameter and instead uses the
 /// version indicated by the <i>Version</i> and <i>xmlns</i> attributes
 /// 
 /// </param>
 /// <returns> A SifElement object encapsulating the message payload (e.g.
 /// a OpenADK.Library.us.Student.StudentPersonal object)
 /// 
 /// </returns>
 /// <exception cref="OpenADK.Library.AdkParsingException">AdkParsingException is thrown if unable to 
 /// parse the message</exception>
 /// <exception cref="System.IO.IOException"> IOException is thrown if an error is reported while reading 
 /// the message content</exception>
 public SifElement Parse( string msg,
                          IZone zone,
                          SifParserFlags flags,
                          SifVersion version )
 {
     using ( StringReader reader = new StringReader( msg ) )
     {
         SifElement element = Parse( reader, zone, flags, version );
         reader.Close();
         return element;
     }
 }
コード例 #33
0
 /// <summary>
 /// Creates an instance of a SIF_Register
 /// </summary>
 ///  <param name="sifVersion">The version of SIF to render this message in</param>
 ///
 public SIF_Register( SifVersion sifVersion )
     : base(sifVersion, InfraDTD.SIF_REGISTER)
 {
 }
コード例 #34
0
ファイル: SIFParser.cs プロジェクト: rafidzal/OpenADK-csharp
 /// <summary>  Parses a SIF data element into a <c>SifElement</c>.</summary>
 /// <param name="msg">The content to parse</param>
 /// <param name="zone">The Zone from which the message was received, or null if
 /// not applicable or not known</param>
 /// <param name="flags">The flags to use for parsing</param>
 /// <param name="version">The version of SIF that will be associated with the
 /// returned object.</param>
 /// <returns> A SifElement object encapsulating the message payload (e.g.
 /// a OpenADK.Library.us.Student.StudentPersonal object)
 /// </returns>
 /// <remarks>
 /// <note type="note">In order to be SIF Compliant, the TextReader must be set to use UTF-8 encoding</note>
 ///  By default, SifParser uses the default version of
 /// SIF in effect for the agent when parsing messages that do not have
 /// a SIF_Message envelope. By specifying a value to this parameter, you
 /// can change the version of SIF associated with the returned object in
 /// the event there is no SIF_Message envelope present in the XML
 /// content. Note that when parsing XML content with a SIF_Message
 /// envelope, SifParser ignores this parameter and instead uses the
 /// version indicated by the <c>Version</c> and <c>xmlns</c> attributes
 /// </remarks>
 /// <exception cref="OpenADK.Library.AdkParsingException">AdkParsingException is thrown if unable to 
 /// parse the message</exception>
 /// <exception cref="System.IO.IOException"> IOException is thrown if an error is reported while reading 
 /// the message content</exception>
 public SifElement Parse( TextReader msg,
                          IZone zone,
                          SifParserFlags flags,
                          SifVersion version )
 {
     // TODO: Document the fact that encoding needs to be properly set on the TextReader for SIF Support
     XmlTextReader reader = new XmlTextReader( msg );
     reader.WhitespaceHandling = WhitespaceHandling.None;
     return Parse( reader, zone, flags, version );
 }