Filters/HtmlAgilityPack/Header.cs

   1 /*
   2 Copyright (C) 2003 Simon Mourier <simonm@microsoft.com>
   3 All rights reserved.
   4
   5 Redistribution and use in source and binary forms, with or without
   6 modification, are permitted provided that the following conditions
   7 are met:
   8 1. Redistributions of source code must retain the above copyright
   9    notice, this list of conditions and the following disclaimer.
  10 2. Redistributions in binary form must reproduce the above copyright
  11    notice, this list of conditions and the following disclaimer in the
  12    documentation and/or other materials provided with the distribution.
  13 3. The name of the author may not be used to endorse or promote products
  14    derived from this software without specific prior written permission.
  15
  16 THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  17 IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  18 OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  19 IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  20 INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  21 NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22 DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25 THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26 */
  27
  28 using System;
  29 using System.Collections;
  30
  31 namespace HtmlAgilityPack
  32 {
  33         internal class NameValuePair
  34         {
  35                 internal readonly string Name;
  36                 internal string Value;
  37
  38                 internal NameValuePair()
  39                 {
  40                 }
  41
  42                 internal NameValuePair(string name):
  43                         this()
  44                 {
  45                         Name = name;
  46                 }
  47
  48                 internal NameValuePair(string name, string value):
  49                         this(name)
  50                 {
  51                         Value = value;
  52                 }
  53         }
  54
  55         internal class NameValuePairList
  56         {
  57                 internal readonly string Text;
  58                 private ArrayList _allPairs;
  59                 private Hashtable _pairsWithName;
  60
  61                 internal NameValuePairList():
  62                         this(null)
  63                 {
  64                 }
  65
  66                 internal NameValuePairList(string text)
  67                 {
  68                         Text = text;
  69                         _allPairs = new ArrayList();
  70                         _pairsWithName = new Hashtable();
  71
  72                         Parse(text);
  73                 }
  74
  75                 internal string GetNameValuePairValue(string name)
  76                 {
  77                         if (name==null)
  78                                 throw new ArgumentNullException();
  79                         ArrayList al = GetNameValuePairs(name);
  80                         if (al==null)
  81                                 return null;
  82
  83                         // return first item
  84                         NameValuePair nvp = al[0] as NameValuePair;
  85                         return nvp.Value;
  86                 }
  87
  88                 internal ArrayList GetNameValuePairs(string name)
  89                 {
  90                         if (name==null)
  91                                 return _allPairs;
  92                         return _pairsWithName[name] as ArrayList;
  93                 }
  94
  95                 private void Parse(string text)
  96                 {
  97                         _allPairs.Clear();
  98                         _pairsWithName.Clear();
  99                         if (text==null)
 100                                 return;
 101
 102                         string[] p = text.Split(';');
 103                         if (p==null)
 104                                 return;
 105                         foreach(string pv in p)
 106                         {
 107                                 if (pv.Length==0)
 108                                         continue;
 109                                 string[] onep = pv.Split(new char[]{'='}, 2);
 110                                 if (onep==null)
 111                                         continue;
 112                                 NameValuePair nvp = new NameValuePair(onep[0].Trim().ToLower());
 113                                 if (onep.Length<2)
 114                                         nvp.Value = "";
 115                                 else
 116                                         nvp.Value = onep[1];
 117
 118                                 _allPairs.Add(nvp);
 119
 120                                 // index by name
 121                                 ArrayList al = _pairsWithName[nvp.Name] as ArrayList;
 122                                 if (al==null)
 123                                 {
 124                                         al = new ArrayList();
 125                                         _pairsWithName[nvp.Name] = al;
 126                                 }
 127                                 al.Add(nvp);
 128                         }
 129                 }
 130
 131                 internal static string GetNameValuePairsValue(string text, string name)
 132                 {
 133                         NameValuePairList l = new NameValuePairList(text);
 134                         return l.GetNameValuePairValue(name);
 135                 }
 136         }
 137 }