niche.newres.timedevents2owl.generator.introspector.GeneralBeanIntrospector.java Source code

Introduction

Here is the source code for niche.newres.timedevents2owl.generator.introspector.GeneralBeanIntrospector.java

Source

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

package niche.newres.timedevents2owl.generator.introspector;

import com.hp.hpl.jena.rdf.model.Model;
import com.hp.hpl.jena.rdf.model.ModelFactory;
import com.hp.hpl.jena.rdf.model.Statement;
import java.io.OutputStream;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.logging.Level;
import java.util.logging.Logger;
import niche.newres.timedevents2owl.examples.softwarelogs.types.DatedMethodEvent;
import niche.newres.timedevents2owl.generator.JenaOWLfiable;
import niche.newres.timedevents2owl.generator.StatementFactory;
import niche.newres.timedevents2owl.generator.util.ModelPrinter;
import niche.newres.timedevents2owl.types.builtins.DatedDoubleValue;
import org.apache.commons.beanutils.PropertyUtils;
import org.joda.time.DateTime;

/**
 * General class to translate a bean to statements, models, outputstreams, etc.
 * @author newres
 */
public class GeneralBeanIntrospector {

    /**
     * Translates a particular bean into a set of statements.
     * @param bean
     * @param id
     * @param name
     * @return 
     */
    public static List<Statement> fromBean2OWL(Object bean, String id, String name) {
        List<Statement> objectStatements = new LinkedList<Statement>();
        Statement classStatement = StatementFactory.createInstanceOfClassStatement(id, name);
        objectStatements.add(classStatement);
        if (bean instanceof JenaOWLfiable) {
            objectStatements.addAll(StatementFactory.createJenaOWLfiableContentStatements(objectStatements,
                    classStatement, id, name, (JenaOWLfiable) bean));
            return objectStatements;
        } else {
            Map<String, Object> propertiesMap = new HashMap<String, Object>();
            try {
                propertiesMap = PropertyUtils.describe(bean);
            } catch (IllegalAccessException ex) {
                Logger.getLogger(GeneralBeanIntrospector.class.getName()).log(Level.SEVERE, null, ex);
            } catch (InvocationTargetException ex) {
                Logger.getLogger(GeneralBeanIntrospector.class.getName()).log(Level.SEVERE, null, ex);
            } catch (NoSuchMethodException ex) {
                Logger.getLogger(GeneralBeanIntrospector.class.getName()).log(Level.SEVERE, null, ex);
            }
            if (propertiesMap != null) {
                for (Map.Entry<String, Object> entry : propertiesMap.entrySet()) {
                    StatementFactory.createObjectContentStatements(objectStatements, classStatement,
                            GeneralBeanIntrospector.capitalizeFirstLetter(entry.getKey()), -1, entry.getValue());
                    //StatementFactory.createPropertyContentStatements(classStatement, entry.getKey(), entry.getValue());
                }
            }
            //List<Statement> dateStatements = StatementFactory.createDatatypePropertyContentStatements(classStatement, "Date", this.getDate());
            objectStatements.add(classStatement);
            //objectStatements.addAll(typeStatements);
            //objectStatements.addAll(dateStatements);
            return objectStatements;
        }
    }

    /**
     * Adds translated statements from a bean into the given model.
     * @param model
     * @param bean
     * @param id
     * @param name
     * @return 
     */
    public static Model fromBean2Model(Model model, Object bean, String id, String name) {
        model.add(GeneralBeanIntrospector.fromBean2OWL(bean, id, name));
        return model;
    }

    /**
     * Adds the translated statements from a bean to the default model.
     * @param bean
     * @param id
     * @param name
     * @return 
     */
    public static Model fromBean2Model(Object bean, String id, String name) {
        Model model = ModelFactory.createDefaultModel();
        model.add(GeneralBeanIntrospector.fromBean2OWL(bean, id, name));
        return model;
    }

    /**
     * Adds statements from a bean to a given outputstream.
     * @param stream
     * @param bean
     * @param id
     * @param name
     * @return 
     */
    public static OutputStream fromBean2Stream(OutputStream stream, Object bean, String id, String name) {

        (GeneralBeanIntrospector.fromBean2Model(bean, id, name)).write(stream, "N3");

        return stream;
    }

    public static String capitalizeFirstLetter(String original) {
        if (original.length() == 0)
            return original;
        return original.substring(0, 1).toUpperCase() + original.substring(1);
    }

    public static List<Statement> fromOWLfiable2OWL(JenaOWLfiable o, Statement parentStatement, String id,
            String name) {
        List<Statement> objectStatements = new LinkedList<Statement>();
        return StatementFactory.createJenaOWLfiableContentStatements(objectStatements, parentStatement, id, name,
                o);
    }

    public static OutputStream fromOWLfiable2Stream(OutputStream stream, JenaOWLfiable o, Statement parentStatement,
            String id, String name) {
        Model model = ModelFactory.createDefaultModel();

        model.add(GeneralBeanIntrospector.fromOWLfiable2OWL(o, parentStatement, id, name));
        //         if(id.startsWith("Patient"))
        //         {
        //             System.out.println("Okay");
        //             //System.out.println(GeneralBeanIntrospector.fromOWLfiable2OWL(o, parentStatement, id, name));
        //             model.write(System.out, "TTL");
        //             
        //         }
        model.write(stream, "TTL");
        return stream;
    }

    public static void main(String[] args) {
        DatedMethodEvent methodEvent = new DatedMethodEvent();
        methodEvent.setDate(new DateTime());
        methodEvent.setPackageName("IO");
        methodEvent.setClassName("Switcher");
        methodEvent.setMethodName("Lock");
        List<Statement> statements = GeneralBeanIntrospector.fromBean2OWL(methodEvent, "methodEvent", "m1");

        ModelPrinter.print(statements);
    }

}