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

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