lib

Documentation

Index

• Variables
• func ErrNow(message string)
• func Init()
• func Mechanism(c *cli.Context)
• type Body
• type Body1
• type Body2
• type Body3
• type Body4
• type Body5
• type Body6
• type Body7
• type Envelope
• type Envelope1
• type Envelope2
• type Envelope3
• type Envelope4
• type Envelope5
• type Envelope6
• type Envelope7
• type Text
• type Text1
• type Text2
• type Text3
• type Text4
• type Text5
• type Text6
• type Text7

Variables

var (
	//  title ==> url
	NlpMapUrls = map[string]string{
		"Base						":                              "http://nlptools.info.uaic.ro/",
		"Tools						":                             "http://nlptools.info.uaic.ro/tools",
		"PoS Tagger for Romanian				":             "http://nlptools.infoiasi.ro/WebPosRo/",
		"Graphical Grammar Studio			":             "http://sourceforge.net/projects/ggs/",
		"NP Chunker for Romanian				":             "http://nlptools.infoiasi.ro/WebNpChunkerRo/",
		"Dependency Parser for Romanian			":       "http://nlptools.infoiasi.ro/WebFdgRo/",
		"Discourse Analysis Tool				":             "http://datool.infoiasi.ro/",
		"Public Discourse Analyzer for Romanian ": "http://students.info.uaic.ro/~ana.timofciuc/PDA/index.php",
		"Quo Vadis Visualization Tool			":         "http://nlptools.infoiasi.ro/QuoVadisVisualization/",
		"Multilingual Named Entity Recognizer		":  "http://nlptools.infoiasi.ro/UAIC.NamedEntityRecognizer/",
		"Multilingual Named Entity Editor		":      "http://nlptools.infoiasi.ro/UAIC.NamedEntityEditor/",
		"Multilingual Anaphora Resolution		":      "http://nlptools.infoiasi.ro/UAIC.AnaphoraResolution/",
		"Multilingual Anaphora Editor			":         "http://nlptools.infoiasi.ro/UAIC.AnaphoraEditor/",
		"Multilingual Clause Splitter			":         "http://nlptools.infoiasi.ro/UAIC.ClauseSplitter/",
		"Multilingual Clause Editor			":           "http://nlptools.infoiasi.ro/UAIC.ClauseEditor/",
		"Multilingual Discourse Parser			":        "http://nlptools.infoiasi.ro/UAIC.DiscourseParser/",
		"XML Statistics					":                     "http://nlptools.infoiasi.ro/UAIC.XMLStatistics/",
		"Bermuda						":                           "http://dev.racai.ro:8080/BermudaTTS/nlp?WSDL",
	}

	// The tools that the app will support
	// and interact for this moment
	NlpPostUrls = [...]string{
		"http://nlptools.infoiasi.ro/WebPosRo/PosTaggerRoWS?wsdl",
		"http://nlptools.infoiasi.ro/WebNpChunkerRo/NpChunkerRoWS?wsdl",
		"http://nlptools.infoiasi.ro/WebFdgRo/FdgParserRoWS?wsdl",
		"http://nlptools.infoiasi.ro/UAIC.NamedEntityRecognizer/NamedEntityRecognizerWS?wsdl",
		"http://nlptools.infoiasi.ro/UAIC.AnaphoraResolution/AnaphoraResolutionWS?wsdl",
		"http://nlptools.infoiasi.ro/UAIC.ClauseSplitter/ClauseSplitterWS?wsdl",
		"http://nlptools.infoiasi.ro/UAIC.DiscourseParser/DiscourseParserWS?wsdl",
		"http://dev.racai.ro:8080/BermudaTTS/nlp?WSDL",
	}

	// Main application declare it globally
	App *cli.App
)

Functions

func ErrNow

func ErrNow(message string)

func Init

func Init()

init the app

func Mechanism

func Mechanism(c *cli.Context)

Types

type Body

type Body struct {
	CreateText Text `xml:"web:parseText_XML"`
}

type Body1

type Body1 struct {
	CreateText Text1 `xml:"web:chunkText"`
}

type Body2

type Body2 struct {
	CreateText Text2 `xml:"web:parseText"`
}

type Body3

type Body3 struct {
	CreateText Text3 `xml:"rec:recognizeEntities"`
}

type Body4

type Body4 struct {
	CreateText Text4 `xml:"res:solveLinks"`
}

type Body5

type Body5 struct {
	CreateText Text5 `xml:"spl:split"`
}

type Body6

type Body6 struct {
	CreateText Text6 `xml:"par:parse"`
}

type Body7

type Body7 struct {
	CreateText Text7 `xml:"ws:ProcessText"`
}

type Envelope

type Envelope struct {
	XMLName    xml.Name `xml:"Envelope"`
	Val1       string   `xml:"xmlns:soapenv,attr"`
	Val2       string   `xml:"xmlns:web,attr"`
	CreateBody Body     `xml:"soapenv:Body"`
}

type Envelope1

type Envelope1 struct {
	XMLName    xml.Name `xml:"Envelope"`
	Val1       string   `xml:"xmlns:soapenv,attr"`
	Val2       string   `xml:"xmlns:web,attr"`
	CreateBody Body1    `xml:"soapenv:Body"`
}

CHUNK TAGGER ENVELOPE SERVICE

type Envelope2

type Envelope2 struct {
	XMLName    xml.Name `xml:"Envelope"`
	Val1       string   `xml:"xmlns:soapenv,attr"`
	Val2       string   `xml:"xmlns:web,attr"`
	CreateBody Body2    `xml:"soapenv:Body"`
}

FDG PARSER ENVELOPE SERVICE

type Envelope3

type Envelope3 struct {
	XMLName    xml.Name `xml:"Envelope"`
	Val1       string   `xml:"xmlns:soapenv,attr"`
	Val2       string   `xml:"xmlns:rec,attr"`
	CreateBody Body3    `xml:"soapenv:Body"`
}

NAME ENTITY RECOGNIZER SERVICE

type Envelope4

type Envelope4 struct {
	XMLName    xml.Name `xml:"Envelope"`
	Val1       string   `xml:"xmlns:soapenv,attr"`
	Val2       string   `xml:"xmlns:res,attr"`
	CreateBody Body4    `xml:"soapenv:Body"`
}

type Envelope5

type Envelope5 struct {
	XMLName    xml.Name `xml:"Envelope"`
	Val1       string   `xml:"xmlns:soapenv,attr"`
	Val2       string   `xml:"xmlns:spl,attr"`
	CreateBody Body5    `xml:"soapenv:Body"`
}

CLAUSE SPLITTER SERVICE

type Envelope6

type Envelope6 struct {
	XMLName    xml.Name `xml:"Envelope"`
	Val1       string   `xml:"xmlns:soapenv,attr"`
	Val2       string   `xml:"xmlns:par,attr"`
	CreateBody Body6    `xml:"soapenv:Body"`
}

DISCOURSE PARSE SERVICE

type Envelope7

type Envelope7 struct {
	XMLName    xml.Name `xml:"Envelope"`
	Val1       string   `xml:"xmlns:soapenv,attr"`
	Val2       string   `xml:"xmlns:ws,attr"`
	CreateBody Body7    `xml:"soapenv:Body"`
}

BERMUDA

type Text

type Text struct {
	TextRow []byte `xml:"rawTextInput"`
}

type Text1

type Text1 struct {
	TypeRow []byte `xml:"inputText"`
}

type Text2

type Text2 struct {
	TypeRow []byte `xml:"txt"`
}

type Text3

type Text3 struct {
	TypeRow []byte `xml:"text"`
	Lang    []byte `xml:"language"`
}

type Text4

type Text4 struct {
	TypeRow []byte `xml:"text"`
	Lang    []byte `xml:"language"`
}

type Text5

type Text5 struct {
	TypeRow []byte `xml:"text"`
	Lang    []byte `xml:"language"`
}

type Text6

type Text6 struct {
	TypeRow []byte `xml:"text"`
	Lang    []byte `xml:"language"`
}

type Text7

type Text7 struct {
	Model []byte `xml:"model"`
	Test  []byte `xml:"text"`
}