bundles/org.simantics.databoard/src/org/simantics/databoard/util/StringUtil.java

   1 /*******************************************************************************\r
   2  * Copyright (c) 2007 VTT Technical Research Centre of Finland and others.\r
   3  * All rights reserved. This program and the accompanying materials\r
   4  * are made available under the terms of the Eclipse Public License v1.0\r
   5  * which accompanies this distribution, and is available at\r
   6  * http://www.eclipse.org/legal/epl-v10.html\r
   7  *\r
   8  * Contributors:\r
   9  *     VTT Technical Research Centre of Finland - initial API and implementation\r
  10  *******************************************************************************/\r
  11 package org.simantics.databoard.util;\r
  12 \r
  13 import java.io.IOException;\r
  14 import java.io.UnsupportedEncodingException;\r
  15 import java.util.regex.Matcher;\r
  16 import java.util.regex.Pattern;\r
  17 import java.util.regex.PatternSyntaxException;\r
  18 \r
  19 import org.simantics.databoard.Bindings;\r
  20 import org.simantics.databoard.Datatypes;\r
  21 import org.simantics.databoard.binding.Binding;\r
  22 import org.simantics.databoard.binding.NumberBinding;\r
  23 import org.simantics.databoard.binding.StringBinding;\r
  24 import org.simantics.databoard.binding.error.BindingException;\r
  25 import org.simantics.databoard.binding.error.RuntimeBindingException;\r
  26 import org.simantics.databoard.binding.mutable.Variant;\r
  27 import org.simantics.databoard.file.RuntimeIOException;\r
  28 import org.simantics.databoard.serialization.Serializer;\r
  29 import org.simantics.databoard.serialization.SerializerConstructionException;\r
  30 \r
  31 public class StringUtil {\r
  32 \r
  33         /**\r
  34          * Convert variant to string\r
  35          * \r
  36          * @param v\r
  37          * @return string representation\r
  38          */\r
  39         public static String variantToString(Variant v) {\r
  40                 try {\r
  41                         return (String) Bindings.STR_VARIANT.create(v.getBinding(), v.getValue());\r
  42                 } catch (BindingException e) {\r
  43                         throw new RuntimeBindingException(e);\r
  44                 }\r
  45         }\r
  46         \r
  47         /**\r
  48          * Convert variant's string representation to variant\r
  49          * \r
  50          * @param str\r
  51          * @return variant\r
  52          * @throws BindingException\r
  53          */\r
  54         public static Variant stringToVariant(String str) throws BindingException {\r
  55                 return (Variant) Bindings.VARIANT.create(Bindings.STR_VARIANT, str);\r
  56         }\r
  57         \r
  58         /**\r
  59          * Convert variant to nice user readable string.\r
  60          * The string is not convertible back to variant without type information. \r
  61          * \r
  62          * @param v\r
  63          * @return string representation of the variant\r
  64          */\r
  65         public static String variantToUserReadableString(Variant v) {\r
  66                 try {\r
  67                         Binding binding = v.getBinding();\r
  68                         Object value = v.getValue();\r
  69                         if ( binding == Bindings.STRING ) return (String) value;\r
  70                         if ( binding.type().equals(Datatypes.STRING)) {\r
  71                                 StringBinding sb = (StringBinding) binding;\r
  72                                 return sb.getValue(value);\r
  73                         }\r
  74                 \r
  75                         if (binding instanceof NumberBinding) {\r
  76                                 return binding.toString(value);\r
  77                         }\r
  78                         \r
  79                         Serializer s = Bindings.getSerializer( Bindings.VARIANT );\r
  80                         byte[] bytes = s.serialize( v );\r
  81                         return Base64.encodeBytes(bytes, Base64.URL_SAFE);\r
  82                 } catch (BindingException e) {\r
  83                         // UNEXPECTED\r
  84                         throw new RuntimeBindingException(e);\r
  85                 } catch (SerializerConstructionException e) {\r
  86                         throw new RuntimeException(e);\r
  87                 } catch (IOException e) {\r
  88                         throw new RuntimeIOException(e);\r
  89                 }\r
  90         }    \r
  91         \r
  92         /**\r
  93          * Create escaped filename from a string\r
  94          * \r
  95          * @param name any string\r
  96          * @return file compatible string\r
  97          */\r
  98         public static String escapeToFileName(String name) {\r
  99                 try {\r
 100                         return java.net.URLEncoder.encode(name, "UTF-8");\r
 101                 } catch (UnsupportedEncodingException e) {\r
 102                         // never expected\r
 103                         throw new RuntimeException(e);\r
 104                 }\r
 105         }\r
 106         \r
 107         /**\r
 108          * Unescape filename into string \r
 109          * \r
 110          * @param filename \r
 111          * @return any string\r
 112          */\r
 113         public static String unescapeFileName(String filename) {\r
 114                 try {\r
 115                         return java.net.URLDecoder.decode(filename, "UTF-8");\r
 116                 } catch (UnsupportedEncodingException e) {\r
 117                         // never expected\r
 118                         throw new RuntimeException(e);\r
 119                 }\r
 120         }\r
 121         \r
 122     public static boolean simplePatternMatch(String str, String simplePattern)\r
 123     {\r
 124         try {\r
 125             Pattern ptr = compileSimplePattern(simplePattern);\r
 126             Matcher m = ptr.matcher(str);\r
 127             return m.matches();\r
 128         } catch (PatternSyntaxException pse) {\r
 129             return false;\r
 130         }\r
 131     }\r
 132     \r
 133     /**\r
 134      * Compiles pattern from simple pattern. Simple pattern is normal\r
 135      * wild card compare that supports * and ? wild cards.\r
 136      * \r
 137      * @param patternStr simple pattern\r
 138      * @return Regexp pattern\r
 139      */\r
 140     public static Pattern compileSimplePattern(String patternStr)\r
 141     throws PatternSyntaxException\r
 142     {\r
 143         String str ="";\r
 144         for (int i=0; i<patternStr.length(); i++)\r
 145         {\r
 146             char c = patternStr.charAt(i);\r
 147             if ( (c>='a'&&c<='z') || (c>='A'&&c<='Z') || (c>='0'&&c<='9'))\r
 148                 str += c;\r
 149             else if ( c=='?' )\r
 150                 str += ".?";\r
 151             else if ( c=='*' )\r
 152                 str += ".*";\r
 153             else str += "\\"+c;\r
 154         }\r
 155         return Pattern.compile(str);\r
 156     }    \r
 157                 \r
 158 }\r
 159 \r