src/org/mxchange/jcore/BaseFrameworkSystem.java

   1 /*
   2  * Copyright (C) 2015 Roland Haeder
   3  *
   4  * This program is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 3 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17 package org.mxchange.jcore;
  18
  19 import java.io.BufferedReader;
  20 import java.io.FileInputStream;
  21 import java.io.FileNotFoundException;
  22 import java.io.IOException;
  23 import java.io.InputStreamReader;
  24 import java.io.PrintWriter;
  25 import java.lang.reflect.Field;
  26 import java.lang.reflect.InvocationTargetException;
  27 import java.lang.reflect.Method;
  28 import java.text.MessageFormat;
  29 import java.util.Arrays;
  30 import java.util.HashMap;
  31 import java.util.Iterator;
  32 import java.util.Map;
  33 import java.util.Properties;
  34 import java.util.ResourceBundle;
  35 import java.util.StringTokenizer;
  36 import java.util.logging.Level;
  37 import org.apache.logging.log4j.LogManager;
  38 import org.apache.logging.log4j.Logger;
  39 import org.mxchange.jcore.application.Application;
  40 import org.mxchange.jcore.client.Client;
  41 import org.mxchange.jcore.contact.Contact;
  42 import org.mxchange.jcore.database.backend.DatabaseBackend;
  43 import org.mxchange.jcore.database.frontend.DatabaseFrontend;
  44 import org.mxchange.jcore.database.storage.Storeable;
  45 import org.mxchange.jcore.manager.Manageable;
  46
  47 /**
  48  * General class
  49  *
  50  * @author Roland Haeder
  51  */
  52 public class BaseFrameworkSystem implements FrameworkInterface {
  53
  54         /**
  55          * Bundle instance
  56          */
  57         private static ResourceBundle bundle;
  58
  59         /**
  60          * Instance for own properties
  61          */
  62         private static final Properties properties = new Properties(System.getProperties());
  63
  64         /**
  65          * Self instance
  66          */
  67         private static FrameworkInterface selfInstance;
  68
  69         /**
  70          * Class' logger
  71          */
  72         private final Logger LOG;
  73
  74         /**
  75          * Application instance
  76          */
  77         private Application application;
  78
  79         /**
  80          * Instance for database backend
  81          */
  82         private DatabaseBackend backend;
  83
  84         /**
  85          * Client instance
  86          */
  87         private Client client;
  88
  89         /**
  90          * Contact instance
  91          */
  92         private Contact contact;
  93
  94         /**
  95          * Manager instance
  96          */
  97         private Manageable manager;
  98
  99         /**
 100          * Name of used database table, handled over to backend
 101          */
 102         private String tableName;
 103
 104         /**
 105          * DatabaseFrontend instance
 106          */
 107         private DatabaseFrontend wrapper;
 108
 109         /**
 110          * Initialize object
 111          */
 112         {
 113                 LOG = LogManager.getLogger(this);
 114         }
 115
 116         /**
 117          * No instances can be created of this class
 118          */
 119         protected BaseFrameworkSystem () {
 120                 // Set own instance
 121                 this.setSelfInstance();
 122         }
 123
 124         /**
 125          * Getter for this application
 126          *
 127          * @return Instance from this application
 128          */
 129         public static final FrameworkInterface getInstance () {
 130                 // Return it
 131                 return selfInstance;
 132         }
 133
 134         /**
 135          * Application instance
 136          *
 137          * @return the application
 138          */
 139         @Override
 140         public final Application getApplication () {
 141                 return this.application;
 142         }
 143
 144         /**
 145          * Getter for logger
 146          *
 147          * @return Logger
 148          */
 149         @Override
 150         public final Logger getLogger () {
 151                 return this.LOG;
 152         }
 153
 154         /**
 155          * Manager instance
 156          *
 157          * @return the contactManager
 158          */
 159         @Override
 160         public final Manageable getManager () {
 161                 return this.manager;
 162         }
 163
 164         /**
 165          * Getter for human-readable string from given key
 166          *
 167          * @param key Key to return
 168          * @return Human-readable message
 169          */
 170         @Override
 171         public final String getMessageStringFromKey (final String key) {
 172                 // Return message
 173                 return this.getBundle().getString(key);
 174         }
 175
 176         /**
 177          * Some "getter" for target class instance from given name.
 178          *
 179          * @param instance Instance to iterate on
 180          * @param targetClass Class name to look for
 181          * @return Class instance
 182          */
 183         @SuppressWarnings("unchecked")
 184         private Class<? extends FrameworkInterface> getClassFromTarget (final FrameworkInterface instance, final String targetClass) {
 185                 // Trace message
 186                 this.getLogger().debug(MessageFormat.format("instance={0},targetClass={1}", instance, targetClass)); //NOI18N
 187
 188                 // Instance reflaction of this class
 189                 Class<? extends FrameworkInterface> c = instance.getClass();
 190
 191                 // Analyze class
 192                 while (!targetClass.equals(c.getSimpleName())) {
 193                         // Debug message
 194                         this.getLogger().debug(MessageFormat.format("c={0}", c.getSimpleName())); //NOI18N
 195
 196                         // Get super class (causes unchecked warning)
 197                         c = (Class<? extends FrameworkInterface>) c.getSuperclass();
 198                 }
 199
 200                 // Trace message
 201                 this.getLogger().trace(MessageFormat.format("c={0} - EXIT!", c)); //NOI18N
 202
 203                 // Return it
 204                 return c;
 205         }
 206
 207         /**
 208          * Some "getter" for a Method instance from given method name
 209          *
 210          * @param instance Actual instance to call
 211          * @param targetClass Target class name
 212          * @param methodName Method name
 213          * @return A Method instance
 214          */
 215         private Method getMethodFromName (final FrameworkInterface instance, final String targetClass, final String methodName) throws NoSuchMethodException {
 216                 // Trace messahe
 217                 this.getLogger().trace(MessageFormat.format("targetClass={0},methodName={1}", targetClass, methodName)); //NOI18N
 218
 219                 // Get target class instance
 220                 Class<? extends FrameworkInterface> c = this.getClassFromTarget(instance, targetClass);
 221
 222                 // Init field instance
 223                 Method method = c.getDeclaredMethod(methodName, new Class<?>[0]);
 224
 225                 // Assert on field
 226                 assert (method instanceof Method) : "method is not a Method instance"; //NOI18N
 227
 228                 // Trace message
 229                 this.getLogger().trace(MessageFormat.format("method={0} - EXIT!", method)); //NOI18N
 230
 231                 // Return it
 232                 return method;
 233         }
 234
 235         /**
 236          * Some "getter" for a Method instance from given method name
 237          *
 238          * @param instance Actual instance to call
 239          * @param targetClass Target class name
 240          * @param methodName Method name
 241          * @param type Type reflection to check type from
 242          * @return A Method instance
 243          */
 244         private Method getMethodFromName (final FrameworkInterface instance, final String targetClass, final String methodName, final Class<?> type) throws NoSuchMethodException {
 245                 // Trace messahe
 246                 this.getLogger().trace(MessageFormat.format("targetClass={0},methodName={1},type={2}", targetClass, methodName, type)); //NOI18N
 247
 248                 // Get target class instance
 249                 Class<? extends FrameworkInterface> c = this.getClassFromTarget(instance, targetClass);
 250
 251                 // Init field instance
 252                 Method method = c.getDeclaredMethod(methodName, type);
 253
 254                 // Assert on field
 255                 assert (method instanceof Method) : "method is not a Method instance"; //NOI18N
 256
 257                 // Trace message
 258                 this.getLogger().trace(MessageFormat.format("method={0} - EXIT!", method)); //NOI18N
 259
 260                 // Return it
 261                 return method;
 262         }
 263
 264         /**
 265          * Setter for self instance
 266          */
 267         private void setSelfInstance () {
 268                 // Need to set it here
 269                 selfInstance = this;
 270         }
 271
 272         /**
 273          * Aborts program with given exception
 274          *
 275          * @param throwable Any type of Throwable
 276          */
 277         protected final void abortProgramWithException (final Throwable throwable) {
 278                 // Log exception ...
 279                 this.getLogger().catching(throwable);
 280
 281                 // .. and exit
 282                 System.exit(1);
 283         }
 284
 285         /**
 286          * Application instance
 287          *
 288          * @param application the application to set
 289          */
 290         protected final void setApplication (final Application application) {
 291                 this.application = application;
 292         }
 293
 294         /**
 295          * Client instance
 296          *
 297          * @return the client
 298          */
 299         @Override
 300         public final Client getClient () {
 301                 return this.client;
 302         }
 303
 304         /**
 305          * Getter for bundle instance
 306          *
 307          * @return Resource bundle
 308          */
 309         protected final ResourceBundle getBundle () {
 310                 return BaseFrameworkSystem.bundle;
 311         }
 312
 313         /**
 314          * Client instance
 315          *
 316          * @param client the client to set
 317          */
 318         protected final void setClient (final Client client) {
 319                 this.client = client;
 320         }
 321
 322         /**
 323          * Name of used database table, handled over to backend
 324          *
 325          * @return the tableName
 326          */
 327         public final String getTableName () {
 328                 return this.tableName;
 329         }
 330
 331         /**
 332          * Checks if given boolean field is available and set to same value
 333          *
 334          * @param columnName Column name to check
 335          * @param bool Boolean value
 336          * @return Whether all conditions are met
 337          * @throws NoSuchMethodException May be thrown by some implementations
 338          * @throws java.lang.IllegalAccessException If the method cannot be accessed
 339          * @throws java.lang.reflect.InvocationTargetException Any other problems?
 340          */
 341         @Override
 342         public boolean isFieldValueEqual (final String columnName, final boolean bool) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException {
 343                 // Not implemented
 344                 throw new UnsupportedOperationException(MessageFormat.format("Not implemented. columnName={0},bool={1}", columnName, bool)); //NOI18N
 345         }
 346
 347         /**
 348          * Log exception
 349          *
 350          * @param exception Exception to log
 351          */
 352         @Override
 353         public final void logException (final Throwable exception) {
 354                 // Log this exception
 355                 this.getLogger().catching(exception);
 356         }
 357
 358         /**
 359          * Initializes properties with default values
 360          */
 361         private void initPropertiesWithDefault () {
 362                 // Trace message
 363                 this.getLogger().trace("CALLED!"); //NOI18N
 364
 365                 // Init default values:
 366                 // Default database backend
 367                 BaseFrameworkSystem.properties.put("org.mxchange.database.backend.class", "org.mxchange.jcore.database.backend.base64.Base64CsvDatabaseBackend"); //NOI18N
 368                 BaseFrameworkSystem.properties.put("database.backend.storagepath", "data/"); //NOI18N
 369
 370                 // For MySQL backend
 371                 BaseFrameworkSystem.properties.put("org.mxchange.database.mysql.host", "localhost"); //NOI18N
 372                 BaseFrameworkSystem.properties.put("org.mxchange.database.mysql.dbname", "test"); //NOI18N
 373                 BaseFrameworkSystem.properties.put("org.mxchange.database.mysql.login", ""); //NOI18N
 374                 BaseFrameworkSystem.properties.put("org.mxchange.database.mysql.password", ""); //NOI18N
 375
 376                 // Trace message
 377                 this.getLogger().trace("EXIT!"); //NOI18N
 378         }
 379
 380         /**
 381          * Writes the properties file to disk
 382          */
 383         private void writePropertiesFile () throws IOException {
 384                 // Trace message
 385                 this.getLogger().trace("CALLED!"); //NOI18N
 386
 387                 // Write it
 388                 BaseFrameworkSystem.properties.store(new PrintWriter(FrameworkInterface.PROPERTIES_CONFIG_FILE), "This file is automatically generated. You may wish to alter it."); //NOI18N
 389
 390                 // Trace message
 391                 this.getLogger().trace("EXIT!"); //NOI18N
 392         }
 393
 394         /**
 395          * Converts a column name like "foo_bar" to an attribute name like "fooBar"
 396          *
 397          * @param columnName Column name to convert
 398          * @return Attribute name
 399          */
 400         protected String convertColumnNameToAttribute (final String columnName) {
 401                 // Trace message
 402                 this.getLogger().trace(MessageFormat.format("columnName={0} - CALLED!", columnName)); //NOI18N
 403
 404                 // First all lower case
 405                 String lower = columnName.toLowerCase();
 406
 407                 // Then split on "_"
 408                 StringTokenizer tokenizer = new StringTokenizer(lower, "_"); //NOI18N
 409
 410                 // Resulting string
 411                 StringBuilder builder = new StringBuilder(tokenizer.countTokens());
 412
 413                 // Init counter
 414                 int count = 0;
 415
 416                 // Walk through all
 417                 while (tokenizer.hasMoreTokens()) {
 418                         // Get token
 419                         String token = tokenizer.nextToken();
 420
 421                         // Is later than first element?
 422                         if (count > 0) {
 423                                 // Make first character upper-case
 424                                 char c = token.charAt(0);
 425                                 token = String.valueOf(c).toUpperCase() + token.substring(1);
 426                         }
 427
 428                         // Add token
 429                         builder.append(token);
 430
 431                         // Increment counter
 432                         count++;
 433                 }
 434
 435                 // Trace message
 436                 this.getLogger().trace(MessageFormat.format("builder={0} - EXIT!", builder)); //NOI18N
 437
 438                 // Return result
 439                 return builder.toString();
 440         }
 441
 442         /**
 443          * Converts a column name like "foo_bar" to a method name like "getFooBar"
 444          * for non-booleans and to "isFooBar" for boolean fields.
 445          *
 446          * @param columnName Column name to convert
 447          * @param isBool Whether the parameter is boolean
 448          * @return Attribute name
 449          */
 450         protected String convertColumnNameToGetterMethod (final String columnName, boolean isBool) {
 451                 // Trace message
 452                 this.getLogger().trace(MessageFormat.format("columnName={0},isBool={1} - CALLED!", columnName, isBool)); //NOI18N
 453
 454                 // Then split on "_"
 455                 StringTokenizer tokenizer = new StringTokenizer(columnName, "_"); //NOI18N
 456
 457                 // Resulting string
 458                 StringBuilder builder = new StringBuilder(tokenizer.countTokens());
 459
 460                 // Is it boolean?
 461                 if (isBool) {
 462                         // Append "is"
 463                         builder.append("is"); //NOI18N
 464                 } else {
 465                         // Append "get"
 466                         builder.append("get"); //NOI18N
 467                 }
 468
 469                 // Walk through all
 470                 while (tokenizer.hasMoreTokens()) {
 471                         // Get token
 472                         String token = tokenizer.nextToken();
 473
 474                         // Debug message
 475                         this.getLogger().debug(MessageFormat.format("token={0}", token)); //NOI18N
 476
 477                         // Make it upper-case
 478                         char c = token.charAt(0);
 479                         token = String.valueOf(c).toUpperCase() + token.substring(1);
 480
 481                         // Add token
 482                         builder.append(token);
 483                 }
 484
 485                 // Trace message
 486                 this.getLogger().trace(MessageFormat.format("builder={0} - EXIT!", builder)); //NOI18N
 487
 488                 // Return result
 489                 return builder.toString();
 490         }
 491
 492         /**
 493          * Converts a column name like "foo_bar" to a method name like "getFooBar"
 494          * for non-booleans and to "isFooBar" for boolean fields.
 495          *
 496          * @param columnName Column name to convert
 497          * @return Attribute name
 498          */
 499         protected String convertColumnNameToSetterMethod (final String columnName) {
 500                 // Trace message
 501                 this.getLogger().trace(MessageFormat.format("columnName={0} - CALLED!", columnName)); //NOI18N
 502
 503                 // Then split on "_"
 504                 StringTokenizer tokenizer = new StringTokenizer(columnName, "_"); //NOI18N
 505
 506                 // Resulting string
 507                 StringBuilder builder = new StringBuilder(tokenizer.countTokens());
 508
 509                 // Append "set"
 510                 builder.append("set"); //NOI18N
 511
 512                 // Walk through all
 513                 while (tokenizer.hasMoreTokens()) {
 514                         // Get token
 515                         String token = tokenizer.nextToken();
 516
 517                         // Debug message
 518                         this.getLogger().debug(MessageFormat.format("token={0}", token)); //NOI18N
 519
 520                         // Make it upper-case
 521                         char c = token.charAt(0);
 522                         token = String.valueOf(c).toUpperCase() + token.substring(1);
 523
 524                         // Add token
 525                         builder.append(token);
 526                 }
 527
 528                 // Trace message
 529                 this.getLogger().trace(MessageFormat.format("builder={0} - EXIT!", builder)); //NOI18N
 530
 531                 // Return result
 532                 return builder.toString();
 533         }
 534
 535         /**
 536          * Some "getter" for an array from given string and tokenizer
 537          *
 538          * @param str String to tokenize and get array from
 539          * @param delimiter Delimiter
 540          * @param size Size of array
 541          * @return Array from tokenized string
 542          * @todo Get rid of size parameter
 543          */
 544         protected String[] getArrayFromString (final String str, final String delimiter, final int size) {
 545                 // Trace message
 546                 this.getLogger().trace(MessageFormat.format("str={0},delimiter={1},size={2} - CALLED!", str, delimiter, size)); //NOI18N
 547
 548                 // Get tokenizer
 549                 StringTokenizer tokenizer = new StringTokenizer(str, delimiter);
 550
 551                 // Init array and index
 552                 String[] tokens = new String[size];
 553                 int index = 0;
 554
 555                 // Run through all tokens
 556                 while (tokenizer.hasMoreTokens()) {
 557                         // Get current token and add it
 558                         tokens[index] = tokenizer.nextToken();
 559
 560                         // Debug message
 561                         this.getLogger().debug(MessageFormat.format("Token at index{0}: {1}", index, tokens[1])); //NOI18N
 562
 563                         // Increment index
 564                         index++;
 565                 }
 566
 567                 // Trace message
 568                 this.getLogger().trace(MessageFormat.format("tokens({0})={1} - EXIT!", tokens.length, Arrays.toString(tokens))); //NOI18N
 569
 570                 // Return it
 571                 return tokens;
 572         }
 573
 574         /**
 575          * Returns boolean field value from given method name by invoking it
 576          *
 577          * @param instance The instance to call
 578          * @param targetClass Target class to look in
 579          * @param methodName Method name to look for
 580          * @return Boolean value from field
 581          * @throws java.lang.NoSuchMethodException If the method was not found
 582          * @throws java.lang.IllegalAccessException If the method cannot be accessed
 583          * @throws java.lang.reflect.InvocationTargetException Some other problems?
 584          */
 585         protected boolean getBooleanField (final FrameworkInterface instance, final String targetClass, final String methodName) throws NoSuchMethodException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
 586                 // Trace messahe
 587                 this.getLogger().trace(MessageFormat.format("targetClass={0},methodName={1}", targetClass, methodName)); //NOI18N
 588
 589                 // Get method instance
 590                 Method method = this.getMethodFromName(instance, targetClass, methodName);
 591
 592                 // Get value from field
 593                 Boolean value = (Boolean) method.invoke(instance);
 594
 595                 // Trace message
 596                 this.getLogger().trace("value=" + value + " - EXIT!");
 597
 598                 // Return value
 599                 return value;
 600         }
 601
 602         /**
 603          * Sets boolean field value with given method name by invoking it
 604          *
 605          * @param instance The instance to call
 606          * @param targetClass Target class to look in
 607          * @param methodName Method name to look for
 608          * @param columnName Column name
 609          * @param value Boolean value from field
 610          * @throws java.lang.NoSuchMethodException If the method was not found
 611          * @throws java.lang.IllegalAccessException If the method cannot be accessed
 612          * @throws java.lang.reflect.InvocationTargetException Some other problems?
 613          */
 614         protected void setBooleanField (final FrameworkInterface instance, final String targetClass, final String methodName, final String columnName, final Boolean value) throws NoSuchMethodException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
 615                 // Trace messahe
 616                 this.getLogger().trace(MessageFormat.format("targetClass={0},methodName={1}", targetClass, methodName)); //NOI18N
 617
 618                 // Get field type
 619                 Class<?> type = this.getType(instance, targetClass, columnName);
 620
 621                 // Get method instance
 622                 Method method = this.getMethodFromName(instance, targetClass, methodName, type);
 623
 624                 // Try to get the value by invoking the method
 625                 method.invoke(instance, value);
 626
 627                 // Trace message
 628                 this.getLogger().trace("EXIT!");
 629         }
 630
 631         /**
 632          * Manager instance
 633          *
 634          * @param manager the manager instance to set
 635          */
 636         protected final void setContactManager (final Manageable manager) {
 637                 this.manager = manager;
 638         }
 639
 640         /**
 641          * Returns any field value from given method name by invoking it
 642          *
 643          * @param instance The instance to call
 644          * @param targetClass Target class to look in
 645          * @param methodName Method name to look for
 646          * @return Any value from field
 647          * @throws java.lang.NoSuchMethodException If the method was not found
 648          * @throws java.lang.IllegalAccessException If the method cannot be accessed
 649          * @throws java.lang.reflect.InvocationTargetException Some other problems?
 650          */
 651         protected Object getField (final FrameworkInterface instance, final String targetClass, final String methodName) throws NoSuchMethodException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
 652                 // Trace messahe
 653                 this.getLogger().trace(MessageFormat.format("instance={0},targetClass={1},methodName={2}", instance, targetClass, methodName)); //NOI18N
 654
 655                 // Get method to call
 656                 Method method = this.getMethodFromName(instance, targetClass, methodName);
 657
 658                 // Debug message
 659                 this.getLogger().debug("method=" + method + ",instance=" + instance);
 660
 661                 // Get value from field
 662                 Object value = method.invoke(instance);
 663
 664                 // Trace messahe
 665                 this.getLogger().trace("value=" + value + " - EXIT!");
 666
 667                 // Return value
 668                 return value;
 669         }
 670
 671         /**
 672          * Sets any field value with given method name by invoking it
 673          *
 674          * @param instance The instance to call
 675          * @param targetClass Target class to look in
 676          * @param methodName Method name to look for
 677          * @param columnName Column name
 678          * @param value Any value from field
 679          * @throws java.lang.NoSuchMethodException If the method was not found
 680          * @throws java.lang.IllegalAccessException If the method cannot be accessed
 681          * @throws java.lang.reflect.InvocationTargetException Some other problems?
 682          */
 683         protected void setField (final FrameworkInterface instance, final String targetClass, final String methodName, final String columnName, final Object value) throws NoSuchMethodException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
 684                 // Trace messahe
 685                 this.getLogger().trace(MessageFormat.format("instance={0},targetClass={1},methodName={2},value={3}", instance, targetClass, methodName, value)); //NOI18N
 686
 687                 // Get field type
 688                 Class<?> type = this.getType(instance, targetClass, columnName);
 689
 690                 // Debug message
 691                 this.getLogger().debug("type=" + type);
 692
 693                 // Init object
 694                 Object object = value;
 695
 696                 // Hard-coded "cast" again ... :-(
 697                 // @TODO Can't we get rid of this???
 698                 switch (type.getSimpleName()) {
 699                         case "Long": // Long object
 700                                 object = Long.parseLong((String) value);
 701                                 break;
 702
 703                         case "Float": // Float object
 704                                 object = Float.parseFloat((String) value);
 705                                 break;
 706
 707                         case "Object": // General object
 708                         case "String": // String object
 709                                 break;
 710
 711                         default: // Unsupported type
 712                                 throw new IllegalArgumentException("value " + value + " has unsupported type " + type.getSimpleName());
 713                 }
 714
 715                 // Debug message
 716                 this.getLogger().debug("object[" + object.getClass().getSimpleName() + "]=" + object);
 717
 718                 // Get method to call
 719                 Method method = this.getMethodFromName(instance, targetClass, methodName, type);
 720
 721                 // Debug message
 722                 this.getLogger().debug("method=" + method + ",instance=" + instance + ",value[" + value.getClass().getSimpleName() + "]=" + value);
 723
 724                 // Get value from field
 725                 method.invoke(instance, object);
 726
 727                 // Trace messahe
 728                 this.getLogger().trace("EXIT!");
 729         }
 730
 731         /**
 732          * Getter for property which must exist
 733          *
 734          * @param key Key to get
 735          * @return Propety value
 736          */
 737         protected final String getProperty (final String key) {
 738                 return BaseFrameworkSystem.properties.getProperty(String.format("org.mxchange.%s", key)); //NOI18N
 739         }
 740
 741         /**
 742          * Name of used database table, handled over to backend
 743          *
 744          * @param tableName the tableName to set
 745          */
 746         protected final void setTableName (final String tableName) {
 747                 this.tableName = tableName;
 748         }
 749
 750         /**
 751          * Converts null to empty string or leaves original string.
 752          *
 753          * @param str Any string
 754          * @return Empty string if null or original string
 755          */
 756         protected Object convertNullToEmpty (final Object str) {
 757                 // Trace message
 758                 this.getLogger().trace(MessageFormat.format("str={0}", str)); //NOI18N
 759
 760                 // Is it null?
 761                 if (str == null) {
 762                         // Return empty string
 763                         return ""; //NOI18N
 764                 }
 765
 766                 // Trace message
 767                 this.getLogger().trace(MessageFormat.format("str={0} - EXIT!", str)); //NOI18N
 768
 769                 // Return it
 770                 return str;
 771         }
 772
 773         /**
 774          * Creates an iterator from given instance and class name.
 775          *
 776          * @param instance Instance to run getter calls on
 777          * @param className Class name to iterate over
 778          * @return An iterator over all object's fields
 779          * @throws java.lang.NoSuchMethodException If the called method does not exist
 780          * @throws java.lang.IllegalAccessException If the method cannot be accessed
 781          * @throws java.lang.reflect.InvocationTargetException Any other problems?
 782          */
 783         protected Iterator<Map.Entry<Field, Object>> fieldIterator (final Storeable instance, final String className) throws IllegalArgumentException, NoSuchMethodException, IllegalAccessException, InvocationTargetException {
 784                 // Trace message
 785                 this.getLogger().trace(MessageFormat.format("instance={0},className={1} - CALLED!", instance, className)); //NOI18N
 786
 787                 // Get all attributes from given instance
 788                 Field[] fields = this.getClassFromTarget(instance, className).getDeclaredFields();
 789
 790                 // Debug message
 791                 this.getLogger().debug(MessageFormat.format("Found {0} fields.", fields.length)); //NOI18N
 792
 793                 // A simple map with K=fieldName and V=Value is fine
 794                 Map<Field, Object> map = new HashMap<>(fields.length);
 795
 796                 // Walk through all
 797                 for (final Field field : fields) {
 798                         // Debug log
 799                         this.getLogger().debug(MessageFormat.format("field={0}", field.getName())); //NOI18N
 800
 801                         // Does the field start with "$"?
 802                         if (field.getName().startsWith("$")) { //NOI18N
 803                                 // Debug message
 804                                 this.getLogger().debug(MessageFormat.format("Skipping field={0} as it starts with a dollar character.", field.getName())); //NOI18N
 805
 806                                 // Skip it silently
 807                                 continue;
 808                         }
 809
 810                         // Debug message
 811                         this.getLogger().debug(MessageFormat.format("Calling getValueFromColumn({0}) on instance {1} ...", field.getName(), instance)); //NOI18N
 812
 813                         // Get value from it
 814                         Object value = instance.getValueFromColumn(field.getName());
 815
 816                         // Debug message
 817                         this.getLogger().debug(MessageFormat.format("Adding field={0},value={1}", field.getName(), value)); //NOI18N
 818
 819                         // Add it to list
 820                         map.put(field, value);
 821                 }
 822
 823                 // Debug message
 824                 this.getLogger().debug(MessageFormat.format("Returning iterator for {0} entries ...", map.size())); //NOI18N
 825
 826                 // Return list iterator
 827                 return map.entrySet().iterator();
 828         }
 829
 830         /**
 831          * Instance for database backend
 832          *
 833          * @return the backend
 834          */
 835         protected final DatabaseBackend getBackend () {
 836                 return this.backend;
 837         }
 838
 839         /**
 840          * Instance for database backend
 841          *
 842          * @param backend the backend to set
 843          */
 844         protected final void setBackend (final DatabaseBackend backend) {
 845                 this.backend = backend;
 846         }
 847
 848         /**
 849          * Getter for Contact instance
 850          *
 851          * @return Contact instance
 852          */
 853         protected final Contact getContact () {
 854                 return this.contact;
 855         }
 856
 857         /**
 858          * Setter for Contact instance
 859          *
 860          * @param contact A Contact instance
 861          */
 862         protected final void setContact (final Contact contact) {
 863                 this.contact = contact;
 864         }
 865
 866         /**
 867          * Getter for DatabaseFrontend instance
 868          *
 869          * @return DatabaseFrontend instance
 870          */
 871         protected final DatabaseFrontend getFrontend () {
 872                 return this.wrapper;
 873         }
 874
 875         /**
 876          * Setter for wrapper instance
 877          *
 878          * @param wrapper A DatabaseFrontend instance
 879          */
 880         protected final void setFrontend (final DatabaseFrontend wrapper) {
 881                 this.wrapper = wrapper;
 882         }
 883
 884         /**
 885          * Initializes i18n bundles
 886          */
 887         protected void initBundle () {
 888                 // Trace message
 889                 this.getLogger().trace("CALLED!");
 890
 891                 // Is the bundle set?
 892                 if (bundle instanceof ResourceBundle) {
 893                         // Is already set
 894                         throw new IllegalStateException("called twice"); //NOI18N
 895                 }
 896
 897                 // Set instance
 898                 bundle = ResourceBundle.getBundle(FrameworkInterface.I18N_BUNDLE_FILE); // NOI18N
 899
 900                 // Trace message
 901                 this.getLogger().trace("EXIT!");
 902         }
 903
 904         /**
 905          * Prepares all properties, the file is written if it is not found
 906          *
 907          * @throws java.io.IOException If any IO problem occurs
 908          */
 909         protected void initProperties () throws IOException {
 910                 // Trace message
 911                 this.getLogger().trace("CALLED!"); //NOI18N
 912
 913                 // Debug message
 914                 this.getLogger().debug(MessageFormat.format("{0} properties are loaded already.", BaseFrameworkSystem.properties.size())); //NOI18N
 915
 916                 // Are some properties loaded?
 917                 if (!BaseFrameworkSystem.properties.isEmpty()) {
 918                         // Some are already loaded, abort here
 919                         return;
 920                 }
 921
 922                 try {
 923                         // Try to read it
 924                         BaseFrameworkSystem.properties.load(new BufferedReader(new InputStreamReader(new FileInputStream(FrameworkInterface.PROPERTIES_CONFIG_FILE))));
 925
 926                         // Debug message
 927                         this.getLogger().debug(MessageFormat.format("{0} properties has been loaded.", BaseFrameworkSystem.properties.size())); //NOI18N
 928                 } catch (final FileNotFoundException ex) {
 929                         // Debug message
 930                         this.getLogger().debug(MessageFormat.format("Properties file {0} not found: {1}", FrameworkInterface.PROPERTIES_CONFIG_FILE, ex)); //NOI18N
 931
 932                         /*
 933                          * The file is not found which is normal for first run, so
 934                          * initialize default values.
 935                          */
 936                         this.initPropertiesWithDefault();
 937
 938                         // Write file
 939                         this.writePropertiesFile();
 940                 }
 941
 942                 // Trace message
 943                 this.getLogger().trace("EXIT!"); //NOI18N
 944         }
 945
 946         /**
 947          * Checks whether the given field is a boolean field by probing it.
 948          *
 949          * @param instance Instance to call
 950          * @param targetClass Target class
 951          * @param columnName Column name to check
 952          * @return Whether the given column name represents a boolean field
 953          */
 954         protected boolean isBooleanField (final FrameworkInterface instance, final String targetClass, final String columnName) {
 955                 // Trace message
 956                 this.getLogger().trace(MessageFormat.format("instance={0},targetCLass={1},columnName={2} - CALLED!", instance, targetClass, columnName)); //NOI18N
 957
 958                 // Convert column name to getter name (boolean)
 959                 String methodName = this.convertColumnNameToGetterMethod(columnName, true);
 960
 961                 // Get class instance
 962                 Class<? extends FrameworkInterface> c = this.getClassFromTarget(instance, targetClass);
 963
 964                 // Defauzlt is boolean
 965                 boolean isBool = true;
 966
 967                 try {
 968                         // Now try to instance the method
 969                         Method method = c.getDeclaredMethod(methodName, new Class<?>[0]);
 970                 } catch (final NoSuchMethodException ex) {
 971                         // Debug message
 972                         this.getLogger().debug(MessageFormat.format("Method {0} does not exist, field {1} cannot be boolean: {2}", methodName, columnName, ex)); //NOI18N
 973
 974                         // Not found
 975                         isBool = false;
 976                 }
 977
 978                 // Trace message
 979                 this.getLogger().trace(MessageFormat.format("isBool={0} - EXIT!", isBool)); //NOI18N
 980
 981                 // Return result
 982                 return isBool;
 983         }
 984
 985         /**
 986          * Sets value in properties instance.
 987          *
 988          * @param key Property key (part) to set
 989          * @param value Property value to set
 990          */
 991         protected void setProperty (final String key, final String value) {
 992                 // Trace message
 993                 this.getLogger().trace(MessageFormat.format("key={0},value={1} - CALLED!", key, value)); //NOI18N
 994
 995                 // Both should not be null
 996                 if (key == null) {
 997                         // key is null
 998                         throw new NullPointerException("key is null");
 999                 } else if (value == null) {
1000                         // value is null
1001                         throw new NullPointerException("value is null");
1002                 }
1003
1004                 // Set it
1005                 properties.setProperty(String.format("org.mxchange.%s", key), value); //NOI18N
1006
1007                 // Trace message
1008                 this.getLogger().trace("EXIT!"); //NOI18N
1009         }
1010
1011         /**
1012          * Some getter for properties names (without org.mxchange)
1013          *
1014          * @return An array with property names
1015          */
1016         protected String[] getPropertyNames () {
1017                 // Init array
1018                 String[] names = {
1019                         "database.backend.class", //NOI18N
1020                         "database.backend.storagepath", //NOI18N
1021                         "database.mysql.login", //NOI18N
1022                         "database.mysql.host", //NOI18N
1023                         "database.mysql.password", //NOI18N
1024                         "database.mysql.dbname", //NOI18N
1025                 };
1026
1027                 // Return it
1028                 return names;
1029         }
1030
1031         /**
1032          * Some "setter" for a value in given Storeable instance and target class
1033          *
1034          * @param instance An instance of a Storeable class
1035          * @param targetClass The target class (where the field resides)
1036          * @param columnName Column name (= field name)
1037          * @param value Value to set
1038          * @throws java.lang.NoSuchMethodException If the setter is not found
1039          * @throws java.lang.IllegalAccessException If the setter cannot be accessed
1040          * @throws java.lang.reflect.InvocationTargetException Any other problem?
1041          */
1042         protected void setValueInStoreableFromColumn (final Storeable instance, final String targetClass, final String columnName, final Object value) throws NoSuchMethodException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
1043                 // Trace message
1044                 this.getLogger().trace("instance=" + instance + ",targetClass=" + targetClass + ",columnName=" + columnName + ",value=" + value + " - CALLED!");
1045
1046                 // A '$' means not our field
1047                 if (columnName.startsWith("$")) {
1048                         // Don't handle these
1049                         throw new IllegalArgumentException("columnsName contains $");
1050                 }
1051
1052                 // Determine if the given column is boolean
1053                 if (this.isBooleanField(instance, targetClass, columnName)) {
1054                         // Debug message
1055                         this.getLogger().debug("Column " + columnName + " represents a boolean field.");
1056
1057                         // Yes, then call other method
1058                         this.setBooleanField(instance, targetClass, this.convertColumnNameToSetterMethod(columnName), columnName, (Boolean) value);
1059                 }
1060
1061                 // Convert column name to field name
1062                 String methodName = this.convertColumnNameToSetterMethod(columnName);
1063
1064                 // Debug message
1065                 this.getLogger().debug(MessageFormat.format("methodName={0}", methodName));
1066
1067                 // Get field
1068                 this.setField(instance, targetClass, methodName, columnName, value);
1069
1070                 // Trace message
1071                 this.getLogger().trace("EXIT!");
1072         }
1073
1074         /**
1075          * Some "getter" for a value from given Storeable instance and target class
1076          *
1077          * @param instance An instance of a Storeable class
1078          * @param targetClass The target class (where the field resides)
1079          * @param columnName Column name (= field name)
1080          * @return  value Value to get
1081          * @throws java.lang.NoSuchMethodException If the getter was not found
1082          * @throws java.lang.IllegalAccessException If the getter cannot be accessed
1083          * @throws java.lang.reflect.InvocationTargetException Some other problems?
1084          */
1085         protected Object getValueInStoreableFromColumn (final Storeable instance, final String targetClass, final String columnName) throws NoSuchMethodException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
1086                 // Trace message
1087                 this.getLogger().trace(MessageFormat.format("instance={0},targetClass={1},columnName={2} - CALLED!", instance, targetClass, columnName));
1088
1089                 // A '$' means not our field
1090                 if (columnName.startsWith("$")) {
1091                         // Don't handle these
1092                         throw new IllegalArgumentException("columnsName contains $");
1093                 }
1094
1095                 // Determine if the given column is boolean
1096                 if (this.isBooleanField(instance, targetClass, columnName)) {
1097                         // Debug message
1098                         this.getLogger().debug("Column " + columnName + " represents a boolean field.");
1099
1100                         // Yes, then call other method
1101                         return this.getBooleanField(instance, targetClass, this.convertColumnNameToGetterMethod(columnName, true));
1102                 }
1103
1104                 // Convert column name to field name
1105                 String methodName = this.convertColumnNameToGetterMethod(columnName, false);
1106
1107                 // Debug message
1108                 this.getLogger().debug(MessageFormat.format("methodName={0}", methodName));
1109
1110                 // Get field
1111                 Object value = this.getField(instance, targetClass, methodName);
1112
1113                 // Trace message
1114                 this.getLogger().trace("value=" + value + " - EXIT!");
1115
1116                 // Return value
1117                 return value;
1118         }
1119
1120         /**
1121          * Some getter for type reflection of given column name
1122          *
1123          * @param instance The instance to check
1124          * @param targetClass Target class to check
1125          * @param columnName Column name
1126          * @return Type reflection of value
1127          */
1128         private Class<?> getType (final FrameworkInterface instance, final String targetClass, final String columnName) {
1129                 // Trace message
1130                 this.getLogger().trace("instance=" + instance + ",targetClass=" + targetClass + ",columnName=" + columnName + " - CALLED!");
1131
1132                 // Init field tye
1133                 Class<?> type = null;
1134
1135                 // Get all attributes from given instance
1136                 Field[] fields = this.getClassFromTarget(instance, targetClass).getDeclaredFields();
1137
1138                 // Debug message
1139                 this.getLogger().debug("fields()=" + fields.length);
1140
1141                 // Search for proper field instance
1142                 for (final Field field : fields) {
1143                         // Debug message
1144                         this.getLogger().debug("field=" + field);
1145
1146                         // Does it match?
1147                         if (field.getName().equals(columnName)) {
1148                                 // Found it
1149                                 type = field.getType();
1150                                 break;
1151                         }
1152                 }
1153
1154                 // type should not be null
1155                 if (type == null) {
1156                         // No null allowed
1157                         throw new NullPointerException("type is null");
1158                 }
1159
1160                 // Trace message
1161                 this.getLogger().debug("type=" + type +  " - EXIT!");
1162
1163                 // Return it
1164                 return type;
1165         }
1166 }