Package it.uniroma2.art.semanticturkey.services.core.controllers

Class ManchesterHandlerController

java.lang.Object

it.uniroma2.art.semanticturkey.services.core.controllers.ManchesterHandlerController

All Implemented Interfaces:

IntrospectableController, org.springframework.beans.factory.Aware, org.springframework.context.ApplicationContextAware

@Controller
public class ManchesterHandlerController
extends Object
implements org.springframework.context.ApplicationContextAware, IntrospectableController

Constructor Summary

Constructors

Constructor	Description
ManchesterHandlerController()

Method Summary

Modifier and Type	Method	Description
org.springframework.http.HttpEntity<Response<com.fasterxml.jackson.databind.JsonNode>>	checkDatatypeExpressionPublished(String manchExpr)
org.springframework.http.HttpEntity<Response<com.fasterxml.jackson.databind.JsonNode>>	checkExpressionPublished(String manchExpr, boolean skipSemanticCheck)
org.springframework.http.HttpEntity<Response<com.fasterxml.jackson.databind.JsonNode>>	checkLiteralEnumerationExpressionPublished(String manchExpr)
org.springframework.http.HttpEntity<Response<com.fasterxml.jackson.databind.JsonNode>>	checkObjectPropertyExpressionPublished(String manchExpr)
org.springframework.http.HttpEntity<Response<AnnotatedValue<org.eclipse.rdf4j.model.BNode>>>	createRestrictionPublished(org.eclipse.rdf4j.model.IRI classIri, org.eclipse.rdf4j.model.IRI exprType, String manchExpr, boolean skipSemanticCheck)
org.springframework.http.HttpEntity<Response<Map<String,Map<String,String>>>>	getAllDLExpressionPublished(org.eclipse.rdf4j.model.IRI classIri, boolean usePrefixes, boolean useUppercaseSyntax)
org.springframework.http.HttpEntity<Response<String>>	getExpressionPublished(org.eclipse.rdf4j.model.BNode bnode, boolean usePrefixes, boolean useUppercaseSyntax)
ManchesterHandler	getService()
ServiceSpecies	getServiceSpecies()
org.springframework.http.HttpEntity<Response<Boolean>>	isClassAxiomPublished(org.eclipse.rdf4j.model.BNode bnode)
org.springframework.http.HttpEntity<String>	removeExpressionPublished(org.eclipse.rdf4j.model.IRI classIri, org.eclipse.rdf4j.model.IRI exprType, org.eclipse.rdf4j.model.BNode bnode)
void	setApplicationContext(org.springframework.context.ApplicationContext arg0)
org.springframework.http.HttpEntity<Response<AnnotatedValue<org.eclipse.rdf4j.model.BNode>>>	updateExpressionPublished(String newManchExpr, org.eclipse.rdf4j.model.BNode bnode, boolean skipSemanticCheck)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Details

ManchesterHandlerController

public ManchesterHandlerController()

Method Details

setApplicationContext

public void setApplicationContext(org.springframework.context.ApplicationContext arg0)
                           throws org.springframework.beans.BeansException

Specified by:

setApplicationContext in interface org.springframework.context.ApplicationContextAware

Throws:

org.springframework.beans.BeansException

getServiceSpecies

public ServiceSpecies getServiceSpecies()

Specified by:

getServiceSpecies in interface IntrospectableController

getService

public ManchesterHandler getService()

Specified by:

getService in interface IntrospectableController

checkLiteralEnumerationExpressionPublished

@RequestMapping(value="it.uniroma2.art.semanticturkey/st-core-services/ManchesterHandler/checkLiteralEnumerationExpression",
                method=GET,
                produces="application/json;charset=UTF-8")
public org.springframework.http.HttpEntity<Response<com.fasterxml.jackson.databind.JsonNode>> checkLiteralEnumerationExpressionPublished(@RequestParam("manchExpr")
 String manchExpr)

getExpressionPublished

@RequestMapping(value="it.uniroma2.art.semanticturkey/st-core-services/ManchesterHandler/getExpression",
                method=GET,
                produces="application/json;charset=UTF-8")
public org.springframework.http.HttpEntity<Response<String>> getExpressionPublished(@RequestParam("bnode")
 org.eclipse.rdf4j.model.BNode bnode,
 @RequestParam(value="usePrefixes",required=false,defaultValue="true")
 boolean usePrefixes,
 @RequestParam(value="useUppercaseSyntax",required=false,defaultValue="true")
 boolean useUppercaseSyntax)
                                                                             throws NotClassAxiomException

Throws:

NotClassAxiomException

createRestrictionPublished

@RequestMapping(value="it.uniroma2.art.semanticturkey/st-core-services/ManchesterHandler/createRestriction",
                method=POST,
                produces="application/json;charset=UTF-8")
public org.springframework.http.HttpEntity<Response<AnnotatedValue<org.eclipse.rdf4j.model.BNode>>> createRestrictionPublished(@RequestParam("classIri")
 org.eclipse.rdf4j.model.IRI classIri,
 @RequestParam("exprType")
 org.eclipse.rdf4j.model.IRI exprType,
 @RequestParam("manchExpr")
 String manchExpr,
 @RequestParam(value="skipSemanticCheck",required=false,defaultValue="false")
 boolean skipSemanticCheck)
                                                                                                                        throws ManchesterParserException,
ManchesterSyntacticException,
ManchesterPrefixNotDefinedException,
ManchesterSemanticException

Throws:

ManchesterParserException

ManchesterSyntacticException

ManchesterPrefixNotDefinedException

ManchesterSemanticException

removeExpressionPublished

@RequestMapping(value="it.uniroma2.art.semanticturkey/st-core-services/ManchesterHandler/removeExpression",
                method=POST,
                produces="application/json;charset=UTF-8")
public org.springframework.http.HttpEntity<String> removeExpressionPublished(@RequestParam(value="classIri",required=false)
 org.eclipse.rdf4j.model.IRI classIri,
 @RequestParam(value="exprType",required=false)
 org.eclipse.rdf4j.model.IRI exprType,
 @RequestParam("bnode")
 org.eclipse.rdf4j.model.BNode bnode)
                                                                      throws NotClassAxiomException

Throws:

NotClassAxiomException

getAllDLExpressionPublished

@RequestMapping(value="it.uniroma2.art.semanticturkey/st-core-services/ManchesterHandler/getAllDLExpression",
                method=GET,
                produces="application/json;charset=UTF-8")
public org.springframework.http.HttpEntity<Response<Map<String,Map<String,String>>>> getAllDLExpressionPublished(@RequestParam("classIri")
 org.eclipse.rdf4j.model.IRI classIri,
 @RequestParam(value="usePrefixes",required=false,defaultValue="true")
 boolean usePrefixes,
 @RequestParam(value="useUppercaseSyntax",required=false,defaultValue="true")
 boolean useUppercaseSyntax)

updateExpressionPublished

@RequestMapping(value="it.uniroma2.art.semanticturkey/st-core-services/ManchesterHandler/updateExpression",
                method=POST,
                produces="application/json;charset=UTF-8")
public org.springframework.http.HttpEntity<Response<AnnotatedValue<org.eclipse.rdf4j.model.BNode>>> updateExpressionPublished(@RequestParam("newManchExpr")
 String newManchExpr,
 @RequestParam("bnode")
 org.eclipse.rdf4j.model.BNode bnode,
 @RequestParam(value="skipSemanticCheck",required=false,defaultValue="false")
 boolean skipSemanticCheck)
                                                                                                                       throws ManchesterParserException,
NotClassAxiomException,
ManchesterSyntacticException,
ManchesterPrefixNotDefinedException,
ManchesterSemanticException

Throws:

ManchesterParserException

NotClassAxiomException

ManchesterSyntacticException

ManchesterPrefixNotDefinedException

ManchesterSemanticException

isClassAxiomPublished

@RequestMapping(value="it.uniroma2.art.semanticturkey/st-core-services/ManchesterHandler/isClassAxiom",
                method=GET,
                produces="application/json;charset=UTF-8")
public org.springframework.http.HttpEntity<Response<Boolean>> isClassAxiomPublished(@RequestParam("bnode")
 org.eclipse.rdf4j.model.BNode bnode)

checkDatatypeExpressionPublished

@RequestMapping(value="it.uniroma2.art.semanticturkey/st-core-services/ManchesterHandler/checkDatatypeExpression",
                method=GET,
                produces="application/json;charset=UTF-8")
public org.springframework.http.HttpEntity<Response<com.fasterxml.jackson.databind.JsonNode>> checkDatatypeExpressionPublished(@RequestParam("manchExpr")
 String manchExpr)

checkExpressionPublished

@RequestMapping(value="it.uniroma2.art.semanticturkey/st-core-services/ManchesterHandler/checkExpression",
                method=GET,
                produces="application/json;charset=UTF-8")
public org.springframework.http.HttpEntity<Response<com.fasterxml.jackson.databind.JsonNode>> checkExpressionPublished(@RequestParam("manchExpr")
 String manchExpr,
 @RequestParam(value="skipSemanticCheck",required=false,defaultValue="false")
 boolean skipSemanticCheck)

checkObjectPropertyExpressionPublished

@RequestMapping(value="it.uniroma2.art.semanticturkey/st-core-services/ManchesterHandler/checkObjectPropertyExpression",
                method=GET,
                produces="application/json;charset=UTF-8")
public org.springframework.http.HttpEntity<Response<com.fasterxml.jackson.databind.JsonNode>> checkObjectPropertyExpressionPublished(@RequestParam("manchExpr")
 String manchExpr)