resource-assignment/provider/src/main/java/org/openecomp/sdnc/util/str/StrUtil.java

   1 /*-
   2  * ============LICENSE_START=======================================================
   3  * openECOMP : SDN-C
   4  * ================================================================================
   5  * Copyright (C) 2017 ONAP Intellectual Property. All rights
   6  *                                              reserved.
   7  * ================================================================================
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  *      http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  * ============LICENSE_END=========================================================
  20  */
  21
  22 package org.openecomp.sdnc.util.str;
  23
  24 import java.lang.reflect.Array;
  25 import java.lang.reflect.Field;
  26 import java.util.Arrays;
  27 import java.util.Collection;
  28 import java.util.Date;
  29 import java.util.Iterator;
  30 import java.util.List;
  31 import java.util.Map;
  32 import java.util.SortedSet;
  33 import java.util.TreeSet;
  34
  35 import org.slf4j.Logger;
  36 import org.slf4j.LoggerFactory;
  37
  38 public class StrUtil {
  39
  40         private static final Logger log = LoggerFactory.getLogger(StrUtil.class);
  41
  42         public static final String INDENT_STR = "    ";
  43
  44         public static void indent(StringBuilder ss, int ind) {
  45                 for (int i = 0; i < ind; i++)
  46                         ss.append(INDENT_STR);
  47         }
  48
  49         public static void info(Logger log, Object o) {
  50                 if (log.isInfoEnabled()) {
  51                         StringBuilder ss = new StringBuilder();
  52                         struct(ss, o);
  53                         log.info(ss.toString());
  54                 }
  55         }
  56
  57         public static void debug(Logger log, Object o) {
  58                 if (log.isDebugEnabled()) {
  59                         StringBuilder ss = new StringBuilder();
  60                         struct(ss, o);
  61                         log.debug(ss.toString());
  62                 }
  63         }
  64
  65         public static void struct(StringBuilder ss, Object o) {
  66                 struct(ss, o, 0);
  67         }
  68
  69         public static void struct(StringBuilder ss, Object o, int ind) {
  70                 if (o == null) {
  71                         ss.append("null");
  72                         return;
  73                 }
  74
  75                 if (isSimple(o)) {
  76                         ss.append(o);
  77                         return;
  78                 }
  79
  80                 Class<? extends Object> cls = o.getClass();
  81
  82                 if (cls.isEnum()) {
  83                         ss.append(o);
  84                         return;
  85                 }
  86
  87                 if (cls.isArray()) {
  88                         int n = Array.getLength(o);
  89                         if (n == 0) {
  90                                 ss.append("[]");
  91                                 return;
  92                         }
  93
  94                         Object o1 = Array.get(o, 0);
  95                         if (isSimple(o1)) {
  96                                 ss.append('[').append(o1);
  97                                 for (int i = 1; i < n; i++) {
  98                                         o1 = Array.get(o, i);
  99                                         ss.append(", ").append(o1);
 100                                 }
 101                                 ss.append(']');
 102                                 return;
 103                         }
 104
 105                         ss.append('\n');
 106                         indent(ss, ind + 1);
 107                         ss.append('[');
 108                         struct(ss, o1, ind + 1);
 109                         for (int i = 1; i < n; i++) {
 110                                 o1 = Array.get(o, i);
 111                                 struct(ss, o1, ind + 1);
 112                         }
 113                         ss.append('\n');
 114                         indent(ss, ind + 1);
 115                         ss.append(']');
 116                         return;
 117                 }
 118
 119                 if (o instanceof Collection<?>) {
 120                         Collection<?> ll = (Collection<?>) o;
 121
 122                         int n = ll.size();
 123                         if (n == 0) {
 124                                 ss.append("[]");
 125                                 return;
 126                         }
 127
 128                         Iterator<?> ii = ll.iterator();
 129                         Object o1 = ii.next();
 130                         if (isSimple(o1)) {
 131                                 ss.append('[').append(o1);
 132                                 while (ii.hasNext()) {
 133                                         o1 = ii.next();
 134                                         ss.append(", ").append(o1);
 135                                 }
 136                                 ss.append(']');
 137                                 return;
 138                         }
 139
 140                         ss.append('\n');
 141                         indent(ss, ind + 1);
 142                         ss.append('[');
 143                         struct(ss, o1, ind + 1);
 144                         while (ii.hasNext()) {
 145                                 o1 = ii.next();
 146                                 struct(ss, o1, ind + 1);
 147                         }
 148                         ss.append('\n');
 149                         indent(ss, ind + 1);
 150                         ss.append(']');
 151                         return;
 152
 153                 }
 154
 155                 if (o instanceof Map<?, ?>) {
 156                         Map<?, ?> mm = (Map<?, ?>) o;
 157
 158                         int n = mm.size();
 159                         if (n == 0) {
 160                                 ss.append("{}");
 161                                 return;
 162                         }
 163
 164                         ss.append('{');
 165
 166                         for (Object k : mm.keySet()) {
 167                                 ss.append('\n');
 168                                 indent(ss, ind + 1);
 169                                 ss.append(k).append(": ");
 170
 171                                 Object o1 = mm.get(k);
 172                                 struct(ss, o1, ind + 2);
 173                         }
 174
 175                         ss.append('\n');
 176                         indent(ss, ind);
 177                         ss.append('}');
 178
 179                         return;
 180                 }
 181
 182                 Field[] fields = cls.getFields();
 183
 184                 if (fields.length == 0) {
 185                         ss.append(o);
 186                         return;
 187                 }
 188
 189                 ss.append('\n');
 190                 indent(ss, ind + 1);
 191                 ss.append('<').append(cls.getSimpleName()).append("> {");
 192                 for (Field f : fields) {
 193                         ss.append('\n');
 194                         indent(ss, ind + 2);
 195                         ss.append(f.getName()).append(": ");
 196                         Object v = null;
 197                         try {
 198                                 v = f.get(o);
 199                         } catch (IllegalAccessException e) {
 200                                 v = "*** Cannot obtain value *** : " + e.getMessage();
 201                         }
 202                         struct(ss, v, ind + 2);
 203                 }
 204                 ss.append('\n');
 205                 indent(ss, ind + 1);
 206                 ss.append('}');
 207         }
 208
 209         public static SortedSet<Integer> listInt(String ss, String warning) {
 210                 if (ss == null || ss.length() == 0)
 211                         return null;
 212
 213                 SortedSet<Integer> ll = new TreeSet<Integer>();
 214                 String[] str = ss.split(",");
 215                 for (String s : str) {
 216                         try {
 217                                 int i1 = s.indexOf('-');
 218                                 int start, end;
 219                                 if (i1 > 0) {
 220                                         String s1 = s.substring(0, i1);
 221                                         String s2 = s.substring(i1 + 1);
 222                                         start = Integer.parseInt(s1);
 223                                         end = Integer.parseInt(s2);
 224                                 } else
 225                                         start = end = Integer.parseInt(s);
 226                                 for (int i = start; i <= end; i++)
 227                                         ll.add(i);
 228                         } catch (NumberFormatException e) {
 229                                 // Skip this - bad data in DB
 230                                 log.warn(warning + " [" + s + "].", e);
 231                         }
 232                 }
 233                 return ll;
 234         }
 235
 236         public static String listInt(SortedSet<Integer> ll) {
 237                 if (ll == null || ll.size() == 0)
 238                         return null;
 239
 240                 StringBuilder sb = new StringBuilder(2000);
 241                 Iterator<Integer> i = ll.iterator();
 242                 int n = i.next();
 243                 int start = n;
 244                 int end = n;
 245                 boolean first = true;
 246                 while (i.hasNext()) {
 247                         n = i.next();
 248                         if (n != end + 1) {
 249                                 if (!first)
 250                                         sb.append(',');
 251                                 first = false;
 252
 253                                 if (start == end)
 254                                         sb.append(start);
 255                                 else if (start == end - 1)
 256                                         sb.append(start).append(',').append(end);
 257                                 else
 258                                         sb.append(start).append('-').append(end);
 259
 260                                 start = n;
 261                         }
 262                         end = n;
 263                 }
 264
 265                 if (!first)
 266                         sb.append(',');
 267
 268                 if (start == end)
 269                         sb.append(start);
 270                 else if (start == end - 1)
 271                         sb.append(start).append(',').append(end);
 272                 else
 273                         sb.append(start).append('-').append(end);
 274
 275                 return sb.toString();
 276         }
 277
 278         public static List<String> listStr(String s) {
 279                 if (s == null || s.length() == 0)
 280                         return null;
 281                 String[] ss = s.split(",");
 282                 return Arrays.asList(ss);
 283         }
 284
 285         public static String listStr(Collection<String> ll) {
 286                 if (ll == null || ll.isEmpty())
 287                         return null;
 288                 StringBuilder ss = new StringBuilder(1000);
 289                 Iterator<String> i = ll.iterator();
 290                 ss.append(i.next());
 291                 while (i.hasNext())
 292                         ss.append(',').append(i.next());
 293                 return ss.toString();
 294         }
 295
 296         private static boolean isSimple(Object o) {
 297                 if (o == null)
 298                         return true;
 299
 300                 if (o instanceof Number || o instanceof String || o instanceof Boolean || o instanceof Date)
 301                         return true;
 302
 303                 return false;
 304         }
 305 }