element() scheme based XPointer pointer part.
Inheritance: Mvp.Xml.XPointer.PointerPart
        /// <summary>
        /// Parses element() based pointer part and builds instance of <c>ElementSchemaPointerPart</c> class.
        /// </summary>
        /// <param name="lexer">Lexical analizer.</param>
        /// <returns>Newly created <c>ElementSchemaPointerPart</c> object.</returns>
        public static ElementSchemaPointerPart ParseSchemaData(XPointerLexer lexer)
        {
            //Productions:
            //[1]       ElementSchemeData	   ::=      (NCName ChildSequence?) | ChildSequence
            //[2]       ChildSequence	   ::=      ('/' [1-9] [0-9]*)+
            StringBuilder            xpathBuilder = new StringBuilder();
            ElementSchemaPointerPart part         = new ElementSchemaPointerPart();

            lexer.NextLexeme();
            if (lexer.Kind == XPointerLexer.LexKind.NCName)
            {
                part.NCName = lexer.NCName;
                xpathBuilder.Append("id('");
                xpathBuilder.Append(lexer.NCName);
                xpathBuilder.Append("')");
                lexer.NextLexeme();
            }
            part.ChildSequence = new ArrayList();
            while (lexer.Kind == XPointerLexer.LexKind.Slash)
            {
                lexer.NextLexeme();
                if (lexer.Kind != XPointerLexer.LexKind.Number)
                {
                    Debug.WriteLine(SR.InvalidTokenInElementSchemeWhileNumberExpected);
                    return(null);
                }
                if (lexer.Number == 0)
                {
                    Debug.WriteLine(SR.ZeroIndexInElementSchemechildSequence);
                    return(null);
                }
                part.ChildSequence.Add(lexer.Number);
                xpathBuilder.Append("/*[");
                xpathBuilder.Append(lexer.Number);
                xpathBuilder.Append("]");
                lexer.NextLexeme();
            }
            if (lexer.Kind != XPointerLexer.LexKind.RRBracket)
            {
                throw new XPointerSyntaxException(SR.InvalidTokenInElementSchemeWhileClosingRoundBracketExpected);
            }
            if (part.NCName == null && part.ChildSequence.Count == 0)
            {
                Debug.WriteLine(SR.EmptyElementSchemeXPointer);
                return(null);
            }
            part.XPath = xpathBuilder.ToString();
            return(part);
        }
        /// <summary>
        /// Parses element() based pointer part and builds instance of <c>ElementSchemaPointerPart</c> class.
        /// </summary>
        /// <param name="lexer">Lexical analizer.</param>
        /// <returns>Newly created <c>ElementSchemaPointerPart</c> object.</returns>
        public static ElementSchemaPointerPart ParseSchemaData(XPointerLexer lexer)
        {
            //Productions:
            //[1]       ElementSchemeData	   ::=      (NCName ChildSequence?) | ChildSequence
            //[2]       ChildSequence	   ::=      ('/' [1-9] [0-9]*)+
            StringBuilder            xpathBuilder = new StringBuilder();
            ElementSchemaPointerPart part         = new ElementSchemaPointerPart();

            lexer.NextLexeme();
            if (lexer.Kind == XPointerLexer.LexKind.NCName)
            {
                xpathBuilder.Append("id('");
                xpathBuilder.Append(lexer.NCName);
                xpathBuilder.Append("')");
                lexer.NextLexeme();
            }
            int childSequenceLen = 0;

            while (lexer.Kind == XPointerLexer.LexKind.Slash)
            {
                lexer.NextLexeme();
                if (lexer.Kind != XPointerLexer.LexKind.Number)
                {
                    Debug.WriteLine(Monobjc.Tools.Sdp.Properties.Resources.InvalidTokenInElementSchemeWhileNumberExpected);
                    return(null);
                }
                if (lexer.Number == 0)
                {
                    Debug.WriteLine(Monobjc.Tools.Sdp.Properties.Resources.ZeroIndexInElementSchemechildSequence);
                    return(null);
                }
                childSequenceLen++;
                xpathBuilder.Append("/*[");
                xpathBuilder.Append(lexer.Number);
                xpathBuilder.Append("]");
                lexer.NextLexeme();
            }
            if (lexer.Kind != XPointerLexer.LexKind.RRBracket)
            {
                throw new XPointerSyntaxException(Monobjc.Tools.Sdp.Properties.Resources.InvalidTokenInElementSchemeWhileClosingRoundBracketExpected);
            }
            if (xpathBuilder.Length == 0 && childSequenceLen == 0)
            {
                Debug.WriteLine(Monobjc.Tools.Sdp.Properties.Resources.EmptyElementSchemeXPointer);
                return(null);
            }
            part.XPath = xpathBuilder.ToString();
            return(part);
        }
 /// <summary>
 /// Parses element() based pointer part and builds instance of <c>ElementSchemaPointerPart</c> class.
 /// </summary>
 /// <param name="lexer">Lexical analizer.</param>
 /// <returns>Newly created <c>ElementSchemaPointerPart</c> object.</returns>
 public static ElementSchemaPointerPart ParseSchemaData(XPointerLexer lexer)
 {
   //Productions:
   //[1]   	ElementSchemeData	   ::=   	(NCName ChildSequence?) | ChildSequence
   //[2]   	ChildSequence	   ::=   	('/' [1-9] [0-9]*)+                        
   StringBuilder xpathBuilder = new StringBuilder();
   ElementSchemaPointerPart part = new ElementSchemaPointerPart();
   lexer.NextLexeme();
   if (lexer.Kind == XPointerLexer.LexKind.NCName)
   {
     xpathBuilder.Append("id('");
     xpathBuilder.Append(lexer.NCName);
     xpathBuilder.Append("')");
     lexer.NextLexeme();
   }
   int childSequenceLen = 0;
   while (lexer.Kind == XPointerLexer.LexKind.Slash)
   {
     lexer.NextLexeme();
     if (lexer.Kind != XPointerLexer.LexKind.Number)
     {
       Debug.WriteLine(SR.InvalidTokenInElementSchemeWhileNumberExpected);
       return null;
     }
     if (lexer.Number == 0)
     {
       Debug.WriteLine(SR.ZeroIndexInElementSchemechildSequence);
       return null;
     }
     childSequenceLen++;
     xpathBuilder.Append("/*[");
     xpathBuilder.Append(lexer.Number);
     xpathBuilder.Append("]");
     lexer.NextLexeme();
   }
   if (lexer.Kind != XPointerLexer.LexKind.RRBracket)
   {
     throw new XPointerSyntaxException(SR.InvalidTokenInElementSchemeWhileClosingRoundBracketExpected);
   }
   if (xpathBuilder.Length == 0 && childSequenceLen == 0)
   {
     Debug.WriteLine(SR.EmptyElementSchemeXPointer);
     return null;
   }
   part.XPath = xpathBuilder.ToString();
   return part;
 }
Exemple #4
0
        public static Pointer ParseXPointer(string xpointer)
        {
            var lexer = new XPointerLexer(xpointer);

            lexer.NextLexeme();
            if (lexer.Kind == XPointerLexer.LexKind.NcName && !lexer.CanBeSchemaName)
            {
                //Shorthand pointer
                Pointer ptr = new ShorthandPointer(lexer.NcName);
                lexer.NextLexeme();
                if (lexer.Kind != XPointerLexer.LexKind.Eof)
                {
                    throw new XPointerSyntaxException(Properties.Resources.InvalidTokenAfterShorthandPointer);
                }

                return(ptr);
            }

            //SchemaBased pointer
            IList <PointerPart> parts = new List <PointerPart>();

            while (lexer.Kind != XPointerLexer.LexKind.Eof)
            {
                if ((lexer.Kind == XPointerLexer.LexKind.NcName ||
                     lexer.Kind == XPointerLexer.LexKind.QName) &&
                    lexer.CanBeSchemaName)
                {
                    XPointerSchema.SchemaType schemaType = GetSchema(lexer, parts);
                    //Move to '('
                    lexer.NextLexeme();
                    switch (schemaType)
                    {
                    case XPointerSchema.SchemaType.Element:
                        ElementSchemaPointerPart elemPart = ElementSchemaPointerPart.ParseSchemaData(lexer);
                        if (elemPart != null)
                        {
                            parts.Add(elemPart);
                        }

                        break;

                    case XPointerSchema.SchemaType.Xmlns:
                        XmlnsSchemaPointerPart xmlnsPart = XmlnsSchemaPointerPart.ParseSchemaData(lexer);
                        if (xmlnsPart != null)
                        {
                            parts.Add(xmlnsPart);
                        }

                        break;

                    case XPointerSchema.SchemaType.XPath1:
                        XPath1SchemaPointerPart xpath1Part = XPath1SchemaPointerPart.ParseSchemaData(lexer);
                        if (xpath1Part != null)
                        {
                            parts.Add(xpath1Part);
                        }

                        break;

                    case XPointerSchema.SchemaType.XPointer:
                        XPointerSchemaPointerPart xpointerPart = XPointerSchemaPointerPart.ParseSchemaData(lexer);
                        if (xpointerPart != null)
                        {
                            parts.Add(xpointerPart);
                        }

                        break;

                    default:
                        //Unknown scheme
                        lexer.ParseEscapedData();
                        break;
                    }
                    //Skip ')'
                    lexer.NextLexeme();
                    //Skip possible whitespace
                    if (lexer.Kind == XPointerLexer.LexKind.Space)
                    {
                        lexer.NextLexeme();
                    }
                }
                else
                {
                    throw new XPointerSyntaxException(Properties.Resources.InvalidToken);
                }
            }
            return(new SchemaBasedPointer(parts, xpointer));
        }