W6 Reflection

/**
     * Check the field definition of a class, including naming conventions.
     *
     * @param targetClass to check
     * @param modifiers visibility, static, final
     * @param type of the field
     * @param fieldName of the field
     * @throws SecurityException when field is not accessible.
     */
    public static void checkFieldAndNaming( Class<?> targetClass,
                                            int modifierMask,
                                            int modifiers,
                                            Class<?> type, String fieldName )
            throws SecurityException {
        if ( ( PUBLIC | STATIC | FINAL ) == modifiers ) {  (1)
            assertAllUpper( fieldName );
        } else {                                           (2)
            char firstChar = fieldName.charAt( 0 );
            assertEquals( "first char not lower case", "" + (char) Character.
                          toLowerCase(
                                  firstChar ), "" + (char) firstChar );
        }
        checkField( targetClass, modifierMask, modifiers, type, fieldName );
    }

/**
 * Check the field definition of a class.
 *
 * This method tests if the required modifiers are set. Example: to check
 * private, but not require final, specify both modifierMask and Modifier.PUBLIC |
 * Modifier.PRIVATE | Modifier.PROTECTED and as modsRequired, thereby accvepting any
 * value of the final modifier.
 *
 * @param targetClass to check
 * @param modifierMask visibility, static, final
 * @param modsRequired required modifiers
 * @param fieldType of the field
 * @param fieldName of the field
 * @throws SecurityException when field is not accessible
 */
public static void checkField( Class<?> targetClass,
                               int modifierMask,
                               int modsRequired,
                               Class<?> fieldType,
                               String fieldName )
        throws SecurityException {
    Field f = null;
    try {
        f = targetClass.getDeclaredField( fieldName );
        assertEquals( "field " + fieldName + " should be of type "
                + fieldType, fieldType, f.getType() );
        int fieldModifiers = f.getModifiers();
        if ( ( modifierMask & fieldModifiers ) != modsRequired ) {
            fail( "field '" + f.getName()
                    + "' should be declared '"
                    + Modifier.toString( modsRequired )
                    + "', you declared it '"
                    + Modifier.toString( fieldModifiers ) + '\'' );
        }
    } catch ( NoSuchFieldException ex ) {
        fail( "your class '" + targetClass
                + "' does not contain the required field '"
                + Modifier.toString( modifierMask )
                + " "
                + fieldType.getSimpleName()
                + " " + fieldName + "'" );
    }
}

  void useEntity( E e ) {

    for (Object f : Deconstructor.forType( e.getClass() ).deconstruct( e ) ) {
      // use fields.
    }
  }

public abstract class Deconstructor<E> {

    private static final ConcurrentMap<Class<?>, Deconstructor<?>> register
         = new ConcurrentHashMap<>();

    public static <E> Deconstructor<E> forType( Class<E> et ) {
        if ( !register.containsKey( et ) ) {
            loadDeconstructorClass( et );
        } // assume loading is successful
        return (Deconstructor<E>) register.get( et );
    }

    private static <E> void loadDeconstructorClass( Class<E> forEntity ) {
        String deconstructorName = forEntity.getName() + "Deconstructor";
        try {
            Class.forName( deconstructorName, true, forEntity.getClassLoader() );
        } catch ( ClassNotFoundException ex ) {
            Logger.getLogger( Deconstructor.class.getName() ).log( Level.SEVERE,
                    ex.getMessage() );
        }
    }

    protected static void register( Class<?> et, Deconstructor<?> dec ) {
        register.put( et, dec );
    }

    /**
     * Method to be implemented by (potentially generated) leaf deconstructors.
     *
     * @param entity to deconstruct
     * @return field values in array
     */
    public abstract Object[] deconstruct( E entity );
}

class StudentDeconstructor extends Deconstructor<Student> {

  private StudentDeconstructor(){
    // do what is needed to make this a valid object
    // or leave empty to suppress a default constructor.
  }

  /**
   * Static block to self register.
   */
  static {
    Registry.register( Student.class, new StudentDeconstructor() );
  }

  // other details left out
}

  SomeType result;
  var a = m1();
  var b=null;
  var c=null;
  if ( null != a ) {
    b = m2( a );
  }
  if ( null != b ) {
    c = m3( b );
  }

  if ( null != c ) {
    result = m4( c );
  }
  return result;
  // do something with result

  Optional<SomeType> result
     = m1ReturningOptional() (1)
      .map( a-> m2( a ) )
      .map( b-> m3( b ) )
      .map( c-> m4( c ) );
  return result;
  // do something with Optional result

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <repositories>
        <repository>
            <id>fontysvenlo.org</id>
            <url>https://www.fontysvenlo.org/repository</url>
        </repository>
    </repositories>
    <pluginRepositories>  (1)
        <pluginRepository>
            <id>sebiplugins</id>
            <url>https://www.fontysvenlo.org/repository/</url>
        </pluginRepository>
    </pluginRepositories>
    <parent>
        <groupId>fontys</groupId>
        <artifactId>AirlineInformationSystem</artifactId>
        <version>1.1-SNAPSHOT</version>
        <relativePath>..</relativePath>
    </parent>
    <artifactId>BusinessEntities</artifactId>
    <packaging>jar</packaging>
    <version>1.1-SNAPSHOT</version>
    <dependencies>
        <dependency>
            <groupId>io.github.sebivenlo</groupId>
            <artifactId>sebiannotations</artifactId>
            <version>1.0-SNAPSHOT</version>
            <type>jar</type>
        </dependency>
        <dependency>
            <groupId>io.github.sebivenlo</groupId>
            <artifactId>genericmapper</artifactId>
            <version>[2.2.0,)</version>  (2)
            <type>jar</type>
            <scope>provided</scope>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>io.github.sebivenlo</groupId>
                <artifactId>mapperplugin</artifactId> (3)
                <version>1.0</version>
                <executions>
                    <execution>
                        <id>gen-src</id>
                        <phase>generate-sources</phase>
                        <goals>
                            <goal>sebimappergenerator</goal>
                        </goals>
                        <configuration>
                            <entityPackages>
                                <entityPackage>businessentities</entityPackage> (4)
                            </entityPackages>
                            <classesDir>${basedir}/target/classes</classesDir> (5)
                            <outDir>${basedir}/src/main/java</outDir>(6)
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

  static {
        System.out.println( "loading  StringMapper" );
        try {
            Class.forName( "genericmapper.Mapper$StringMapper" );
        } catch ( ClassNotFoundException neverhappens ) {
        }
  }

    /**
     * Better info when a constructor with a specific signature can't be
     * found.
     *
     * The method attempts to produce the missing constructor signature.
     *
     * @param ex     exception that triggered this method
     * @param fields to compute the detail info.
     */
    void logCannotFind( Throwable ex, final Field[] fields ) {
        ex.setStackTrace( Stream.of( ex.getStackTrace() )
                .filter( steFilter ).toArray( StackTraceElement[]::new ) );
        Supplier<String> msg = () -> String.format(
                "failed to find constructor for class '%s'\n\twith exception type '%s' \n\tand signature\n %3s\n",
                entityType.getName(), ex.getClass().getName(),
                "\tpublic " + entityType.getSimpleName() + "( " + Stream
                .of( fields )
                .map( f -> f.getType().getSimpleName() + " " + f.getName() )
                .collect( joining( ",\n\t\t\t" ) ) + "\n\t);" );
        logger.log( Level.SEVERE, ex, msg );
    }

    catch ( IllegalAccessException | NoSuchMethodException ex ) {
            Supplier<String> puk = () -> String.format(
                    "failed to find constructor for class %s with exception type %s and message %3s",
                    entityType.getClass().getName(), ex.getClass().getName(),
                    ex.getMessage() );
            Logger.getLogger( Mapper.class.getName() )
                    .log( Level.SEVERE, puk );
    }

     catch ( IllegalAccessException | NoSuchMethodException ex ) {
            logCannotFind( ex, fields );
     }

@echo off
rem @author David Greven - https://github.com/grevend
set jar=target/sqltablegenerator-1.0-SNAPSHOT.jar
if not exist %jar% cls & echo Maven... & call mvn package
echo.
java -jar %jar% %*

#!/bin/bash
jar=target/sqltablegenerator-1.0-SNAPSHOT.jar
if [ ! -e ${jar} ]; then mvn package; fi
java -jar ${jar} "$@"