platforma/static/filebrowser/uploadify/com/adobe/utils/.svn/text-base/StringUtil.as.svn-base

   1 /*
   2   Copyright (c) 2008, Adobe Systems Incorporated
   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 are
   7   met:
   8
   9   * Redistributions of source code must retain the above copyright notice,
  10     this list of conditions and the following disclaimer.
  11
  12   * Redistributions in binary form must reproduce the above copyright
  13     notice, this list of conditions and the following disclaimer in the
  14     documentation and/or other materials provided with the distribution.
  15
  16   * Neither the name of Adobe Systems Incorporated nor the names of its
  17     contributors may be used to endorse or promote products derived from
  18     this software without specific prior written permission.
  19
  20   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  21   IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  22   THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  23   PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  24   CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  25   EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  26   PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  27   PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  28   LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  29   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  30   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  31 */
  32
  33 package com.adobe.utils
  34 {
  35
  36         /**
  37         *       Class that contains static utility methods for manipulating Strings.
  38         *
  39         *       @langversion ActionScript 3.0
  40         *       @playerversion Flash 9.0
  41         *       @tiptext
  42         */
  43         public class StringUtil
  44         {
  45
  46
  47                 /**
  48                 *       Does a case insensitive compare or two strings and returns true if
  49                 *       they are equal.
  50                 *
  51                 *       @param s1 The first string to compare.
  52                 *
  53                 *       @param s2 The second string to compare.
  54                 *
  55                 *       @returns A boolean value indicating whether the strings' values are
  56                 *       equal in a case sensitive compare.
  57                 *
  58                 *       @langversion ActionScript 3.0
  59                 *       @playerversion Flash 9.0
  60                 *       @tiptext
  61                 */
  62                 public static function stringsAreEqual(s1:String, s2:String,
  63                                                                                         caseSensitive:Boolean):Boolean
  64                 {
  65                         if(caseSensitive)
  66                         {
  67                                 return (s1 == s2);
  68                         }
  69                         else
  70                         {
  71                                 return (s1.toUpperCase() == s2.toUpperCase());
  72                         }
  73                 }
  74
  75                 /**
  76                 *       Removes whitespace from the front and the end of the specified
  77                 *       string.
  78                 *
  79                 *       @param input The String whose beginning and ending whitespace will
  80                 *       will be removed.
  81                 *
  82                 *       @returns A String with whitespace removed from the begining and end
  83                 *
  84                 *       @langversion ActionScript 3.0
  85                 *       @playerversion Flash 9.0
  86                 *       @tiptext
  87                 */
  88                 public static function trim(input:String):String
  89                 {
  90                         return StringUtil.ltrim(StringUtil.rtrim(input));
  91                 }
  92
  93                 /**
  94                 *       Removes whitespace from the front of the specified string.
  95                 *
  96                 *       @param input The String whose beginning whitespace will will be removed.
  97                 *
  98                 *       @returns A String with whitespace removed from the begining
  99                 *
 100                 *       @langversion ActionScript 3.0
 101                 *       @playerversion Flash 9.0
 102                 *       @tiptext
 103                 */
 104                 public static function ltrim(input:String):String
 105                 {
 106                         var size:Number = input.length;
 107                         for(var i:Number = 0; i < size; i++)
 108                         {
 109                                 if(input.charCodeAt(i) > 32)
 110                                 {
 111                                         return input.substring(i);
 112                                 }
 113                         }
 114                         return "";
 115                 }
 116
 117                 /**
 118                 *       Removes whitespace from the end of the specified string.
 119                 *
 120                 *       @param input The String whose ending whitespace will will be removed.
 121                 *
 122                 *       @returns A String with whitespace removed from the end
 123                 *
 124                 *       @langversion ActionScript 3.0
 125                 *       @playerversion Flash 9.0
 126                 *       @tiptext
 127                 */
 128                 public static function rtrim(input:String):String
 129                 {
 130                         var size:Number = input.length;
 131                         for(var i:Number = size; i > 0; i--)
 132                         {
 133                                 if(input.charCodeAt(i - 1) > 32)
 134                                 {
 135                                         return input.substring(0, i);
 136                                 }
 137                         }
 138
 139                         return "";
 140                 }
 141
 142                 /**
 143                 *       Determines whether the specified string begins with the spcified prefix.
 144                 *
 145                 *       @param input The string that the prefix will be checked against.
 146                 *
 147                 *       @param prefix The prefix that will be tested against the string.
 148                 *
 149                 *       @returns True if the string starts with the prefix, false if it does not.
 150                 *
 151                 *       @langversion ActionScript 3.0
 152                 *       @playerversion Flash 9.0
 153                 *       @tiptext
 154                 */
 155                 public static function beginsWith(input:String, prefix:String):Boolean
 156                 {
 157                         return (prefix == input.substring(0, prefix.length));
 158                 }
 159
 160                 /**
 161                 *       Determines whether the specified string ends with the spcified suffix.
 162                 *
 163                 *       @param input The string that the suffic will be checked against.
 164                 *
 165                 *       @param prefix The suffic that will be tested against the string.
 166                 *
 167                 *       @returns True if the string ends with the suffix, false if it does not.
 168                 *
 169                 *       @langversion ActionScript 3.0
 170                 *       @playerversion Flash 9.0
 171                 *       @tiptext
 172                 */
 173                 public static function endsWith(input:String, suffix:String):Boolean
 174                 {
 175                         return (suffix == input.substring(input.length - suffix.length));
 176                 }
 177
 178                 /**
 179                 *       Removes all instances of the remove string in the input string.
 180                 *
 181                 *       @param input The string that will be checked for instances of remove
 182                 *       string
 183                 *
 184                 *       @param remove The string that will be removed from the input string.
 185                 *
 186                 *       @returns A String with the remove string removed.
 187                 *
 188                 *       @langversion ActionScript 3.0
 189                 *       @playerversion Flash 9.0
 190                 *       @tiptext
 191                 */
 192                 public static function remove(input:String, remove:String):String
 193                 {
 194                         return StringUtil.replace(input, remove, "");
 195                 }
 196
 197                 /**
 198                 *       Replaces all instances of the replace string in the input string
 199                 *       with the replaceWith string.
 200                 *
 201                 *       @param input The string that instances of replace string will be
 202                 *       replaces with removeWith string.
 203                 *
 204                 *       @param replace The string that will be replaced by instances of
 205                 *       the replaceWith string.
 206                 *
 207                 *       @param replaceWith The string that will replace instances of replace
 208                 *       string.
 209                 *
 210                 *       @returns A new String with the replace string replaced with the
 211                 *       replaceWith string.
 212                 *
 213                 *       @langversion ActionScript 3.0
 214                 *       @playerversion Flash 9.0
 215                 *       @tiptext
 216                 */
 217                 public static function replace(input:String, replace:String, replaceWith:String):String
 218                 {
 219                         //change to StringBuilder
 220                         var sb:String = new String();
 221                         var found:Boolean = false;
 222
 223                         var sLen:Number = input.length;
 224                         var rLen:Number = replace.length;
 225
 226                         for (var i:Number = 0; i < sLen; i++)
 227                         {
 228                                 if(input.charAt(i) == replace.charAt(0))
 229                                 {
 230                                         found = true;
 231                                         for(var j:Number = 0; j < rLen; j++)
 232                                         {
 233                                                 if(!(input.charAt(i + j) == replace.charAt(j)))
 234                                                 {
 235                                                         found = false;
 236                                                         break;
 237                                                 }
 238                                         }
 239
 240                                         if(found)
 241                                         {
 242                                                 sb += replaceWith;
 243                                                 i = i + (rLen - 1);
 244                                                 continue;
 245                                         }
 246                                 }
 247                                 sb += input.charAt(i);
 248                         }
 249                         //TODO : if the string is not found, should we return the original
 250                         //string?
 251                         return sb;
 252                 }
 253
 254                 /**
 255                 *       Specifies whether the specified string is either non-null, or contains
 256                 *       characters (i.e. length is greater that 0)
 257                 *
 258                 *       @param s The string which is being checked for a value
 259                 *
 260                 *       @langversion ActionScript 3.0
 261                 *       @playerversion Flash 9.0
 262                 *       @tiptext
 263                 */
 264                 public static function stringHasValue(s:String):Boolean
 265                 {
 266                         //todo: this needs a unit test
 267                         return (s != null && s.length > 0);
 268                 }
 269         }
 270 }