mcs/class/Commons.Xml.Relaxng/Commons.Xml.Relaxng.Derivative/Util.cs

   1 //
   2 // Commons.Xml.Relaxng.Derivative.Util.cs
   3 //
   4 // Author:
   5 //      Atsushi Enomoto <ginga@kit.hi-ho.ne.jp>
   6 //
   7 // 2003 Atsushi Enomoto "No rights reserved."
   8 //
   9 // Copyright (c) 2004 Novell Inc.
  10 // All rights reserved
  11 //
  12
  13 //
  14 // Permission is hereby granted, free of charge, to any person obtaining
  15 // a copy of this software and associated documentation files (the
  16 // "Software"), to deal in the Software without restriction, including
  17 // without limitation the rights to use, copy, modify, merge, publish,
  18 // distribute, sublicense, and/or sell copies of the Software, and to
  19 // permit persons to whom the Software is furnished to do so, subject to
  20 // the following conditions:
  21 //
  22 // The above copyright notice and this permission notice shall be
  23 // included in all copies or substantial portions of the Software.
  24 //
  25 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  26 // EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  27 // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  28 // NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  29 // LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  30 // OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  31 // WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  32 //
  33
  34 using System;
  35 using System.Collections;
  36 using System.Xml;
  37
  38 namespace Commons.Xml.Relaxng.Derivative
  39 {
  40         public class RdpUtil
  41         {
  42                 public static char[] WhitespaceChars = " \t\r\n".ToCharArray ();
  43
  44                 // Generating simplified pattern status (similar to XML representation).
  45                 #region Debug
  46                 private static string DebugNameClass (RdpNameClass n)
  47                 {
  48                         switch (n.NameClassType) {
  49                         case RdpNameClassType.Name:
  50                                 RdpName nm = (RdpName)n;
  51                                 return "<name ns='" + nm.NamespaceURI + "'>"
  52                                         + nm.LocalName + "</name>\n";
  53                         case RdpNameClassType.NsName:
  54                                 return "<nsName ns='" + ((RdpNsName)n).NamespaceURI + "'/>\n";
  55                         default:
  56                                 return "<" + n.NameClassType.ToString () + "/>";
  57                         }
  58                 }
  59
  60                 internal static string DebugRdpPattern (RdpPattern p, Hashtable visitedPattern)
  61                 {
  62                         if (p is RdpText)
  63                                 return "<text/>\n";
  64                         if (p is RdpEmpty)
  65                                 return "<empty/>\n";
  66                         if (p is RdpNotAllowed)
  67                                 return "<notAllowed/>\n";
  68
  69                         if (visitedPattern.Contains (p))
  70                                 return "<" + p.PatternType + " ref='" + p.GetHashCode () + "'/>";
  71                         visitedPattern.Add (p, p);
  72                         string intl = "(id=" + p.GetHashCode () + ") ";
  73
  74                         RdpAbstractSingleContent s = p as RdpAbstractSingleContent;
  75                         if (s != null)
  76                                 intl = DebugRdpPattern (s.Child, visitedPattern);
  77                         RdpAbstractBinary b = p as RdpAbstractBinary;
  78                         if (b != null)
  79                                 intl = DebugRdpPattern (b.LValue, visitedPattern) +
  80                                         DebugRdpPattern (b.RValue, visitedPattern);
  81
  82                         RdpElement el = p as RdpElement;
  83                         if (el != null)
  84                                 intl = DebugNameClass (el.NameClass) +
  85                                         DebugRdpPattern (el.Children, visitedPattern);
  86
  87                         RdpAttribute at = p as RdpAttribute;
  88                         if (at != null)
  89                                 intl = DebugNameClass (at.NameClass) +
  90                                         DebugRdpPattern (at.Children, visitedPattern);
  91
  92                         string str = String.Format ("<{0} id='id{1}'>\n{2}\n</{0}>",
  93                                 p.PatternType.ToString (),
  94                                 p.GetHashCode (),
  95                                 intl);
  96
  97                         return str;
  98                 }
  99                 #endregion
 100
 101                 // contains :: NameClass -> QName -> Bool
 102                 internal static bool Contains (RdpNameClass nc, string name, string ns)
 103                 {
 104                         return nc.Contains (name, ns);
 105                 }
 106
 107                 // nullable :: Pattern -> Bool
 108                 internal static bool Nullable (RdpPattern p)
 109                 {
 110                         return p.Nullable;
 111                 }
 112
 113                 /*
 114                 // childDeriv :: Context -> Pattern -> ChildNode -> Pattern
 115                 internal static RdpPattern ChildDeriv (RdpContext ctx, RdpPattern p, RdpChildNode child)
 116                 {
 117                         return p.ChildDeriv (child);
 118                 }
 119                 */
 120
 121                 // textDeriv :: Context -> Pattern -> String -> Pattern
 122                 internal static RdpPattern TextDeriv (XmlReader reader, RdpPattern p, string s)
 123                 {
 124                         return p.TextDeriv (s, reader);
 125                 }
 126
 127                 // listDeriv :: Context -> Pattern -> [String] -> Pattern
 128                 internal static RdpPattern ListDeriv (XmlReader reader, RdpPattern p, string [] list)
 129                 {
 130                         return p.ListDeriv (list, 0, reader);
 131                 }
 132
 133                 // choice :: Pattern -> Pattern -> Pattern
 134                 internal static RdpPattern Choice (RdpPattern p1, RdpPattern p2)
 135                 {
 136                         return p1.Choice (p2);
 137                 }
 138
 139                 // group :: Pattern -> Pattern -> Pattern
 140                 internal static RdpPattern Group (RdpPattern p1, RdpPattern p2)
 141                 {
 142                         return p1.Group (p2);
 143                 }
 144
 145                 // interleave :: Pattern -> Pattern -> Pattern
 146                 internal static RdpPattern Interleave (RdpPattern p1, RdpPattern p2)
 147                 {
 148                         return p1.Interleave (p2);
 149                 }
 150
 151                 // after :: Pattern -> Pattern -> Pattern
 152                 internal static RdpPattern After (RdpPattern p1, RdpPattern p2)
 153                 {
 154                         return p1.After (p2);
 155                 }
 156
 157                 // datatypeAllows :: Datatype -> ParamList -> String -> Context -> Bool
 158
 159                 internal static bool DatatypeAllows (RdpDatatype dt, string value, XmlReader reader)
 160                 {
 161                         return dt.IsAllowed (value, reader);
 162                 }
 163
 164                 // datatypeEqual :: Datatype -> String -> Context -> String -> Context -> Bool
 165                 internal static bool DatatypeEqual (RdpDatatype dt, string value1, string value2, XmlReader reader)
 166                 {
 167                         return dt.IsTypeEqual (value1, value2, reader);
 168                 }
 169
 170 #if false
 171                 // normalizeWhitespace :: String -> String
 172                 internal static string NormalizeString (string s)
 173                 {
 174                         throw new NotImplementedException ();
 175                 }
 176 #endif
 177
 178 #if false
 179                 // applyAfter :: (Pattern -> Pattern) -> Pattern -> Pattern
 180                 internal static RdpPattern ApplyAfter (RdpApplyAfterHandler h, RdpPattern p)
 181                 {
 182                         if (p is RdpAfter)
 183                                 return After (p.LValue, h (p.RValue));
 184                 }
 185 #endif
 186
 187                 #region Validation Core
 188                 // startTagOpenDeriv :: Pattern -> QName -> Pattern
 189                 // TODO remains: Interleave, OneOrMore, Group, After
 190                 internal static RdpPattern StartTagOpenDeriv (RdpPattern pattern, string name, string ns)
 191                 {
 192                         return pattern.StartTagOpenDeriv (name, ns);
 193                 }
 194
 195                 /*
 196                 // attsDeriv :: Context -> Pattern -> [AttributeNode] -> Pattern
 197                 // [implemented in RdpPattern]
 198                 internal static RdpPattern AttsDeriv (RdpPattern p, RdpAttributes attributes)
 199                 {
 200                         return p.AttsDeriv (attributes);
 201                 }
 202                 */
 203
 204                 // attDeriv :: Context -> Pattern -> AttributeNode -> Pattern
 205                 // [all implemented]
 206                 internal static RdpPattern AttDeriv (XmlReader reader,
 207                         RdpPattern p, string name, string ns, string value)
 208                 {
 209                         return p.AttDeriv (name, ns, value, reader);
 210                 }
 211
 212                 // valueMatch :: Context -> Pattern -> String -> Bool
 213                 // [implemented in RdpPattern]
 214                 internal static bool ValueMatch (RdpPattern p, string s, XmlReader reader)
 215                 {
 216                         return p.ValueMatch (s, reader);
 217                 }
 218
 219                 // startTagCloseDeriv :: Pattern -> Pattern
 220                 // [implemented]
 221                 internal static RdpPattern StartTagCloseDeriv (RdpPattern p)
 222                 {
 223                         return p.StartTagCloseDeriv ();
 224                 }
 225
 226                 // oneOrMore :: Pattern -> Pattern
 227                 // [implemented in RdpPattern]
 228                 internal static RdpPattern OneOrMore (RdpPattern p)
 229                 {
 230                         return p.OneOrMore ();
 231                 }
 232
 233                 // writespace :: String -> Bool
 234                 // [implemented here]
 235                 internal static bool Whitespace (string s)
 236                 {
 237                         return s.Trim (WhitespaceChars).Length == 0;
 238                 }
 239
 240                 // endTagDeriv :: Pattern -> Pattern
 241                 // [implemented]
 242                 internal static RdpPattern EndTagDeriv (RdpPattern p)
 243                 {
 244                         return p.EndTagDeriv ();
 245                 }
 246                 #endregion
 247         }
 248
 249         public delegate RdpPattern RdpBinaryFunction (RdpPattern p1, RdpPattern p2);
 250
 251         class RdpFlip
 252         {
 253                 RdpBinaryFunction func;
 254                 RdpPattern arg;
 255
 256                 public RdpFlip (RdpBinaryFunction func, RdpPattern p)
 257                 {
 258                         this.func = func;
 259                         this.arg = p;
 260                 }
 261
 262                 public RdpPattern Apply (RdpPattern p)
 263                 {
 264                         return func (p, arg);
 265                 }
 266         }
 267 }
 268