Example usage for java.lang IllegalAccessError IllegalAccessError

List of usage examples for java.lang IllegalAccessError IllegalAccessError

Introduction

In this page you can find the example usage for java.lang IllegalAccessError IllegalAccessError.

Prototype

public IllegalAccessError(String s) 

Source Link

Document

Constructs an IllegalAccessError with the specified detail message.

Usage

From source file:Main.java

public static Object clone(final Object obj) throws CloneNotSupportedException {
    if (obj == null) {
        return null;
    }/*ww w  .ja  v a2s .  c  om*/
    if (obj instanceof Cloneable) {
        Class<?> clazz = obj.getClass();
        Method m;
        try {
            m = clazz.getMethod("clone", (Class[]) null);
        } catch (NoSuchMethodException ex) {
            throw new NoSuchMethodError(ex.getMessage());
        }
        try {
            return m.invoke(obj, (Object[]) null);
        } catch (InvocationTargetException ex) {
            Throwable cause = ex.getCause();
            if (cause instanceof CloneNotSupportedException) {
                throw ((CloneNotSupportedException) cause);
            } else {
                throw new Error("Unexpected exception", cause);
            }
        } catch (IllegalAccessException ex) {
            throw new IllegalAccessError(ex.getMessage());
        }
    } else {
        throw new CloneNotSupportedException();
    }
}

From source file:org.sonatype.nexus.logging.task.TaskLogHome.java

private TaskLogHome() {
    throw new IllegalAccessError("Utility class");
}

From source file:edu.cornell.mannlib.vitro.webapp.utils.dataGetter.DataGetterBase.java

/** 
 * Get the model to use based on a model URI.
 *//*from w w  w.j av  a  2s .  c om*/
protected Model getModel(ServletContext context, VitroRequest vreq, String modelName) {
    //if not set use jenaOntModel from the request
    if (StringUtils.isEmpty(modelName)) {
        return vreq.getJenaOntModel();
    } else if (REQUEST_DISPLAY_MODEL.equals(modelName)) {
        return vreq.getDisplayModel();
    } else if (REQUEST_JENA_ONT_MODEL.equals(modelName)) {
        return vreq.getJenaOntModel();
    } else if (CONTEXT_DISPLAY_MODEL.equals(modelName)) {
        return ModelAccess.on(context).getOntModel(DISPLAY);
    } else if (!StringUtils.isEmpty(modelName)) {
        Model model = JenaIngestController.getModel(modelName, vreq);
        if (model == null)
            throw new IllegalAccessError("Cannot get model <" + modelName + "> for DataGetter.");
        else
            return model;
    } else {
        //default is just the JeanOntModel from the vreq.
        return vreq.getJenaOntModel();
    }
}

From source file:Main.java

/**
 * @since 4.3/*  w  ww.j av a  2  s  .  co  m*/
 */
public static <T> T cloneObject(final T obj) throws CloneNotSupportedException {
    if (obj == null) {
        return null;
    }
    if (obj instanceof Cloneable) {
        final Class<?> clazz = obj.getClass();
        final Method m;
        try {
            m = clazz.getMethod("clone", (Class[]) null);
        } catch (final NoSuchMethodException ex) {
            throw new NoSuchMethodError(ex.getMessage());
        }
        try {
            @SuppressWarnings("unchecked")
            // OK because clone() preserves the class
            final T result = (T) m.invoke(obj, (Object[]) null);
            return result;
        } catch (final InvocationTargetException ex) {
            final Throwable cause = ex.getCause();
            if (cause instanceof CloneNotSupportedException) {
                throw ((CloneNotSupportedException) cause);
            } else {
                throw new Error("Unexpected exception", cause);
            }
        } catch (final IllegalAccessException ex) {
            throw new IllegalAccessError(ex.getMessage());
        }
    } else {
        throw new CloneNotSupportedException();
    }
}

From source file:Main.java

/**
 * @since 4.3/*from w w  w  .j av  a  2 s . c o m*/
 */
public static <T> T cloneObject(final T obj) throws CloneNotSupportedException {
    if (obj == null) {
        return null;
    }
    if (obj instanceof Cloneable) {
        final Class<?> clazz = obj.getClass();
        final Method m;
        try {
            m = clazz.getMethod("clone", (Class<?>[]) null);
        } catch (final NoSuchMethodException ex) {
            throw new NoSuchMethodError(ex.getMessage());
        }
        try {
            @SuppressWarnings("unchecked")
            // OK because clone() preserves the class
            final T result = (T) m.invoke(obj, (Object[]) null);
            return result;
        } catch (final InvocationTargetException ex) {
            final Throwable cause = ex.getCause();
            if (cause instanceof CloneNotSupportedException) {
                throw ((CloneNotSupportedException) cause);
            } else {
                throw new Error("Unexpected exception", cause);
            }
        } catch (final IllegalAccessException ex) {
            throw new IllegalAccessError(ex.getMessage());
        }
    } else {
        throw new CloneNotSupportedException();
    }
}

From source file:org.eclipse.smarthome.binding.astro.internal.util.DateTimeUtils.java

/** Constructor */
private DateTimeUtils() {
    throw new IllegalAccessError("Non-instantiable");
}

From source file:org.eclipse.smarthome.binding.astro.internal.util.PropertyUtils.java

/** Constructor */
private PropertyUtils() {
    throw new IllegalAccessError("Non-instantiable");
}

From source file:org.jboss.tools.openshift.reddeer.utils.v3.OpenShift3NativeProjectUtils.java

private OpenShift3NativeProjectUtils() {
    throw new IllegalAccessError("Utilities class");
}

From source file:hudson.lifecycle.Lifecycle.java

/**
 * Gets the singleton instance.//from w w w .j av a2 s  .com
 *
 * @return never null
 */
public synchronized static Lifecycle get() {
    if (INSTANCE == null) {
        String p = System.getProperty("hudson.lifecycle");
        if (p != null) {
            try {
                ClassLoader cl = Hudson.getInstance().getPluginManager().uberClassLoader;
                INSTANCE = (Lifecycle) cl.loadClass(p).newInstance();
            } catch (InstantiationException e) {
                InstantiationError x = new InstantiationError(e.getMessage());
                x.initCause(e);
                throw x;
            } catch (IllegalAccessException e) {
                IllegalAccessError x = new IllegalAccessError(e.getMessage());
                x.initCause(e);
                throw x;
            } catch (ClassNotFoundException e) {
                NoClassDefFoundError x = new NoClassDefFoundError(e.getMessage());
                x.initCause(e);
                throw x;
            }
        } else {
            // if run on Unix, we can do restart 
            if (!Hudson.isWindows()) {
                try {
                    INSTANCE = new UnixLifecycle();
                } catch (IOException e) {
                    LOGGER.log(Level.WARNING, "Failed to install embedded lifecycle implementation", e);
                }
            }

            // use the default one. final fallback.
            if (INSTANCE == null)
                INSTANCE = new Lifecycle() {
                };
        }
    }

    return INSTANCE;
}

From source file:org.rdswicthboard.utils.rdf.oai.App.java

public static void main(String[] args) {
    // create the command line parser
    CommandLineParser parser = new DefaultParser();

    // create the Options
    Options options = new Options();
    options.addOption("i", PROPERTY_INPUT_FILE, true, "input RDF file");
    options.addOption("o", PROPERTY_OUTPUT_FILE, true,
            "output OAI-PMH XML file (default is " + DEFAULT_OUTPUT_FILE + ")");
    options.addOption("c", PROPERTY_CONFIG_FILE, true, "configuration file (" + PROPERTIES_FILE + ")");
    options.addOption("s", PROPERTY_SET_SPEC, true, "set spec value (default is " + DEFAULT_SET_SPEC + ")");
    options.addOption("I", PROPERTY_INPUT_ENCODING, true,
            "input file encoding (default is " + DEFAULT_ENCODING + ")");
    options.addOption("O", PROPERTY_OUTPUT_ENCODING, true,
            "output file encoding (default is " + DEFAULT_ENCODING + ")");
    options.addOption("f", PROPERTY_FORMAT_OUTPUT, false, "format output encoding");
    options.addOption("h", PROPERTY_HELP, false, "print this message");

    try {/*from   w  w  w  . j  av  a2s .com*/
        // parse the command line arguments
        CommandLine line = parser.parse(options, args);

        if (line.hasOption(PROPERTY_HELP)) {
            HelpFormatter formatter = new HelpFormatter();
            formatter.printHelp("java -jar rdf2oai-[verion].jar [PARAMETERS] [INPUT FILE] [OUTPUT FILE]",
                    options);

            System.exit(0);
        }

        // variables to store program properties
        CompositeConfiguration config = new CompositeConfiguration();
        config.setProperty(PROPERTY_OUTPUT_FILE, DEFAULT_OUTPUT_FILE);
        config.setProperty(PROPERTY_INPUT_ENCODING, DEFAULT_ENCODING);
        config.setProperty(PROPERTY_OUTPUT_ENCODING, DEFAULT_ENCODING);
        config.setProperty(PROPERTY_SET_SPEC, DEFAULT_SET_SPEC);
        config.setProperty(PROPERTY_FORMAT_OUTPUT, DEFAULT_FORMAT_OUTPUT);

        // check if arguments has input file properties 
        if (line.hasOption(PROPERTY_CONFIG_FILE)) {
            // if it does, load the specified configuration file
            Path defaultConfig = Paths.get(line.getOptionValue(PROPERTY_CONFIG_FILE));
            if (Files.isRegularFile(defaultConfig) && Files.isReadable(defaultConfig)) {
                config.addConfiguration(new PropertiesConfiguration(defaultConfig.toFile()));
            } else
                throw new Exception("Invalid configuration file: " + defaultConfig.toString());
        } else {
            // if it not, try to load default configurationfile
            Path defaultConfig = Paths.get(PROPERTIES_FILE);
            if (Files.isRegularFile(defaultConfig) && Files.isReadable(defaultConfig)) {
                config.addConfiguration(new PropertiesConfiguration(defaultConfig.toFile()));
            }
        }

        // check if arguments has input file 
        if (line.hasOption(PROPERTY_INPUT_FILE))
            config.setProperty(PROPERTY_INPUT_FILE, line.getOptionValue(PROPERTY_INPUT_FILE));

        // check if arguments has output file
        if (line.hasOption(PROPERTY_OUTPUT_FILE))
            config.setProperty(PROPERTY_OUTPUT_FILE, line.getOptionValue(PROPERTY_OUTPUT_FILE));

        // check if arguments has set spec name
        if (line.hasOption(PROPERTY_SET_SPEC))
            config.setProperty(PROPERTY_SET_SPEC, line.getOptionValue(PROPERTY_SET_SPEC));

        // check if arguments has input encoding
        if (line.hasOption(PROPERTY_INPUT_ENCODING))
            config.setProperty(PROPERTY_INPUT_ENCODING, line.getOptionValue(PROPERTY_INPUT_ENCODING));

        // check if arguments has output encoding
        if (line.hasOption(PROPERTY_OUTPUT_ENCODING))
            config.setProperty(PROPERTY_OUTPUT_ENCODING, line.getOptionValue(PROPERTY_OUTPUT_ENCODING));

        // check if arguments has output encoding
        if (line.hasOption(PROPERTY_FORMAT_OUTPUT))
            config.setProperty(PROPERTY_FORMAT_OUTPUT, "yes");

        // check if arguments has input file without a key
        if (line.getArgs().length > 0) {
            config.setProperty(PROPERTY_INPUT_FILE, line.getArgs()[0]);

            // check if arguments has output file without a key
            if (line.getArgs().length > 1) {
                config.setProperty(PROPERTY_OUTPUT_FILE, line.getArgs()[1]);

                // check if there is too many arguments
                if (line.getArgs().length > 2)
                    throw new Exception("Too many arguments");
            }
        }

        // The program has default output file, but input file must be presented
        if (!config.containsKey(PROPERTY_INPUT_FILE))
            throw new Exception("Please specify input file");

        // extract input file
        String inputFile = config.getString(PROPERTY_INPUT_FILE);

        // extract output file
        String outputFile = config.getString(PROPERTY_OUTPUT_FILE);

        // extract set spec
        String setSpecName = config.getString(PROPERTY_SET_SPEC);

        // extract encoding
        String inputEncoding = config.getString(PROPERTY_INPUT_ENCODING);
        String outputEncoding = config.getString(PROPERTY_OUTPUT_ENCODING);

        boolean formatOutput = config.getBoolean(PROPERTY_FORMAT_OUTPUT);

        // test if source is an regular file and it is readable
        Path source = Paths.get(inputFile);
        if (!Files.isRegularFile(source))
            throw new Exception("The input file: " + source.toString() + " is not an regular file");
        if (!Files.isReadable(source))
            throw new Exception("The input file: " + source.toString() + " is not readable");

        Path target = Paths.get(outputFile);
        if (Files.exists(target)) {
            if (!Files.isRegularFile(target))
                throw new Exception("The output file: " + target.toString() + " is not an regular file");
            if (!Files.isWritable(target))
                throw new Exception("The output file: " + target.toString() + " is not writable");
        }

        // create and setup document builder factory
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        factory.setNamespaceAware(true);

        // create new document builder
        DocumentBuilder builder = factory.newDocumentBuilder();

        // create oai document
        Document oai = builder.newDocument();

        // set document version
        oai.setXmlVersion("1.0");
        oai.setXmlStandalone(true);

        // create root OAI-PMH element
        Element oaiPmh = oai.createElement("OAI-PMH");

        // set document namespaces
        oaiPmh.setAttribute("xmlns", "http://www.openarchives.org/OAI/2.0/");
        oaiPmh.setAttributeNS("http://www.w3.org/2000/xmlns/", "xmlns:xsi",
                "http://www.w3.org/2001/XMLSchema-instance");
        oaiPmh.setAttribute("xsi:schemaLocation",
                "http://www.openarchives.org/OAI/2.0/ http://www.openarchives.org/OAI/2.0/OAI-PMH.xsd");

        // append root node
        oai.appendChild(oaiPmh);

        // create responseDate element
        Element responseDate = oai.createElement("responseDate");

        // create simple date format
        DateFormat dateFormat = new SimpleDateFormat(TIME_FORMAT);

        // generate date
        String date = dateFormat.format(new Date());

        // set current date and time
        responseDate.setTextContent(date);

        oaiPmh.appendChild(responseDate);

        Element listRecords = oai.createElement("ListRecords");
        oaiPmh.appendChild(listRecords);

        // create xpath factory
        XPathFactory xPathfactory = XPathFactory.newInstance();

        // create namespace context
        NamespaceContext namespaceContext = new NamespaceContext() {
            public String getNamespaceURI(String prefix) {
                if (prefix.equals("rdf"))
                    return RDF_NAMESPACE;
                else if (prefix.equals("rns"))
                    return RNF_NAMESPACE;
                else
                    return null;
            }

            @Override
            public Iterator<?> getPrefixes(String val) {
                throw new IllegalAccessError("Not implemented!");
            }

            @Override
            public String getPrefix(String uri) {
                throw new IllegalAccessError("Not implemented!");
            }
        };

        // create xpath object
        XPath xpath = xPathfactory.newXPath();
        // set namespace contex
        xpath.setNamespaceContext(namespaceContext);

        // create XPath expressions
        XPathExpression idExpr = xpath.compile("/rdf:RDF/rns:Researcher/@rdf:about");
        XPathExpression emptyExpr = xpath.compile("//text()[normalize-space(.) = '']");

        // create RegEx patterns  
        Pattern pattern = Pattern.compile(
                "<\\?xml\\s+version=\"[\\d\\.]+\"\\s*\\?>\\s*<\\s*rdf:RDF[^>]*>[\\s\\S]*?<\\s*\\/\\s*rdf:RDF\\s*>");

        // read file into a string
        String content = new String(Files.readAllBytes(source), inputEncoding);

        Matcher matcher = pattern.matcher(content);
        // process all records
        while (matcher.find()) {
            // convert string to input stream
            ByteArrayInputStream input = new ByteArrayInputStream(
                    matcher.group().getBytes(StandardCharsets.UTF_8.toString()));

            // parse the xml document
            Document doc = builder.parse(input);

            // remove all spaces
            NodeList emptyNodes = (NodeList) emptyExpr.evaluate(doc, XPathConstants.NODESET);
            // Remove each empty text node from document.
            for (int i = 0; i < emptyNodes.getLength(); i++) {
                Node emptyTextNode = emptyNodes.item(i);
                emptyTextNode.getParentNode().removeChild(emptyTextNode);
            }

            // obtain researcher id
            String id = (String) idExpr.evaluate(doc, XPathConstants.STRING);
            if (StringUtils.isEmpty(id))
                throw new Exception("The record identifier can not be empty");

            // create record element
            Element record = oai.createElement("record");
            listRecords.appendChild(record);

            // create header element
            Element header = oai.createElement("header");
            record.appendChild(header);

            // create identifier element
            Element identifier = oai.createElement("identifier");
            identifier.setTextContent(id);
            header.appendChild(identifier);

            // create datestamp element
            Element datestamp = oai.createElement("datestamp");
            datestamp.setTextContent(date);
            header.appendChild(datestamp);

            // create set spec element if it exists
            if (!StringUtils.isEmpty(setSpecName)) {
                Element setSpec = oai.createElement("setSpec");
                setSpec.setTextContent(setSpecName);
                header.appendChild(setSpec);
            }

            // create metadata element
            Element metadata = oai.createElement("metadata");
            record.appendChild(metadata);

            // import the record
            metadata.appendChild(oai.importNode(doc.getDocumentElement(), true));
        }

        // create transformer factory
        TransformerFactory transformerFactory = TransformerFactory.newInstance();

        // create transformer
        Transformer transformer = transformerFactory.newTransformer();
        transformer.setOutputProperty(OutputKeys.ENCODING, outputEncoding);

        if (formatOutput) {
            transformer.setOutputProperty(OutputKeys.INDENT, "yes");
            transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
        } else
            transformer.setOutputProperty(OutputKeys.INDENT, "no");

        // create dom source
        DOMSource oaiSource = new DOMSource(oai);

        // create stream result
        StreamResult result = new StreamResult(target.toFile());

        // stream xml to file
        transformer.transform(oaiSource, result);

        // optional stream xml to console for testing
        //StreamResult consoleResult = new StreamResult(System.out);
        //transformer.transform(oaiSource, consoleResult);

    } catch (Exception e) {
        System.err.println("Error: " + e.getMessage());

        //e.printStackTrace();

        System.exit(1);
    }
}