Core/Castle.Core/Resource/CustomUri.cs

   1 // Copyright 2004-2008 Castle Project - http://www.castleproject.org/
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14
  15 namespace Castle.Core.Resource
  16 {
  17         using System;
  18         using System.Text;
  19
  20         [Serializable]
  21         public sealed class CustomUri
  22         {
  23                 public static readonly String SchemeDelimiter = "://";
  24                 public static readonly String UriSchemeFile = "file";
  25                 public static readonly String UriSchemeAssembly = "assembly";
  26
  27                 private String scheme, host, path;
  28                 private bool isUnc, isFile, isAssembly;
  29
  30                 public CustomUri(String resourceIdentifier)
  31                 {
  32                         SanityCheck(resourceIdentifier);
  33
  34                         ParseIdentifier(resourceIdentifier);
  35                 }
  36
  37                 public bool IsUnc
  38                 {
  39                         get { return isUnc; }
  40                 }
  41
  42                 public bool IsFile
  43                 {
  44                         get { return isFile; }
  45                 }
  46
  47                 public bool IsAssembly
  48                 {
  49                         get { return isAssembly; }
  50                 }
  51
  52                 public String AbsolutePath
  53                 {
  54                         get { throw new NotImplementedException(); }
  55                 }
  56
  57                 public string Scheme
  58                 {
  59                         get { return scheme; }
  60                 }
  61
  62                 public string Host
  63                 {
  64                         get { return host; }
  65                 }
  66
  67                 public String Path
  68                 {
  69                         get { return path; }
  70                 }
  71
  72                 private void ParseIdentifier(String identifier)
  73                 {
  74                         int comma = identifier.IndexOf(':');
  75
  76                         if (comma == -1 && !(identifier[0] == '\\' && identifier[1] == '\\') && !(identifier[0] == '/'))
  77                         {
  78                                 throw new ArgumentException("Invalid Uri: no scheme delimiter found on " + identifier);
  79                         }
  80
  81                         bool translateSlashes = true;
  82
  83                         if (identifier[0] == '\\' && identifier[1] == '\\')
  84                         {
  85                                 // Unc
  86
  87                                 isUnc = true;
  88                                 isFile = true;
  89                                 scheme = UriSchemeFile;
  90                                 translateSlashes = false;
  91                         }
  92                         else if (identifier[comma + 1] == '/' && identifier[comma + 2] == '/')
  93                         {
  94                                 // Extract scheme
  95
  96                                 scheme = identifier.Substring(0, comma);
  97
  98                                 isFile = (scheme == UriSchemeFile);
  99                                 isAssembly = (scheme == UriSchemeAssembly);
 100
 101                                 identifier = identifier.Substring(comma + SchemeDelimiter.Length);
 102                         }
 103                         else
 104                         {
 105                                 isFile = true;
 106                                 scheme = UriSchemeFile;
 107                         }
 108
 109                         StringBuilder sb = new StringBuilder();
 110
 111                         foreach(char ch in identifier.ToCharArray())
 112                         {
 113                                 if (translateSlashes && (ch == '\\' || ch == '/'))
 114                                 {
 115                                         if (host == null && !IsFile)
 116                                         {
 117                                                 host = sb.ToString();
 118                                                 sb.Length = 0;
 119                                         }
 120
 121                                         sb.Append('/');
 122                                 }
 123                                 else
 124                                 {
 125                                         sb.Append(ch);
 126                                 }
 127                         }
 128
 129                         path = sb.ToString();
 130                 }
 131
 132                 private static void SanityCheck(String resourceIdentifier)
 133                 {
 134                         if (resourceIdentifier == null)
 135                         {
 136                                 throw new ArgumentNullException("resourceIdentifier");
 137                         }
 138                         if (resourceIdentifier == String.Empty)
 139                         {
 140                                 throw new ArgumentException("Empty resource identifier is not allowed", "resourceIdentifier");
 141                         }
 142                 }
 143         }
 144 }