func (this *TAppDecTop) xFlushOutput(pcListPic *list.List) {
if pcListPic == nil {
return
}
//fmt.Printf("list len=%d\n", pcListPic.Len());
for e := pcListPic.Front(); e != nil; e = e.Next() {
pcPic := e.Value.(*TLibCommon.TComPic)
if pcPic.GetOutputMark() {
// write to file
if this.m_pchReconFile != "" {
conf := pcPic.GetConformanceWindow()
var defDisp *TLibCommon.Window
if this.m_respectDefDispWindow != 0 {
defDisp = pcPic.GetDefDisplayWindow()
} else {
defDisp = TLibCommon.NewWindow()
}
this.m_cTVideoIOYuvReconFile.Write(pcPic.GetPicYuvRec(),
conf.GetWindowLeftOffset()+defDisp.GetWindowLeftOffset(),
conf.GetWindowRightOffset()+defDisp.GetWindowRightOffset(),
conf.GetWindowTopOffset()+defDisp.GetWindowTopOffset(),
conf.GetWindowBottomOffset()+defDisp.GetWindowBottomOffset())
}
// update POC of display order
this.m_iPOCLastDisplay = int(pcPic.GetPOC())
//fmt.Printf("m_iPOCLastDisplay=%d\n",this.m_iPOCLastDisplay);
// erase non-referenced picture in the reference picture list after display
if !pcPic.GetSlice(0).IsReferenced() && pcPic.GetReconMark() == true {
//#if !DYN_REF_FREE
pcPic.SetReconMark(false)
// mark it should be extended later
pcPic.GetPicYuvRec().SetBorderExtension(false)
//#else
// pcPic->destroy();
// pcListPic->erase( iterPic );
// iterPic = pcListPic->begin(); // to the beginning, non-efficient way, have to be revised!
// continue;
//#endif
}
pcPic.SetOutputMark(false)
}
//#if !DYN_REF_FREE
if pcPic != nil {
pcPic.Destroy()
//delete pcPic;
pcPic = nil
}
//#endif
}
pcListPic.Init()
this.m_iPOCLastDisplay = -TLibCommon.MAX_INT
}
func LoadTemplates(name string, loader TemplateLoader) (*template.Template, error) {
load_tracker := map[string]bool{name: true}
var load_queue list.List
load_queue.Init()
load_queue.PushBack(name)
t := template.New(name).Funcs(builtins)
for e := load_queue.Front(); e != nil; e = e.Next() {
template_name := e.Value.(string)
new_template, err := loader.LoadTemplate(template_name)
if err != nil {
return nil, err
}
if _, err := t.Parse(new_template.Data); err != nil {
return nil, err
}
if t.Lookup(template_name) == nil {
return nil, fmt.Errorf(`template "%s"load failed.`, template_name)
}
for _, new_name := range new_template.Dependencies {
if !load_tracker[new_name] {
load_tracker[new_name] = true
load_queue.PushBack(new_name)
}
}
}
return t, nil
}
func outOfOrder(l *list.List) {
iTotal := 25
if iTotal > l.Len() {
iTotal = l.Len()
}
ll := make([]*list.List, iTotal)
for i := 0; i < iTotal; i++ {
ll[i] = list.New()
}
r := rand.New(rand.NewSource(time.Now().UnixNano()))
for e := l.Front(); e != nil; e = e.Next() {
fpath, ok := e.Value.(string)
if !ok {
panic("The path is invalid string")
}
if rand.Int()%2 == 0 {
ll[r.Intn(iTotal)].PushFront(fpath)
} else {
ll[r.Intn(iTotal)].PushBack(fpath)
}
}
r0 := rand.New(rand.NewSource(time.Now().UnixNano()))
l.Init()
for i := 0; i < iTotal; i++ {
if r0.Intn(2) == 0 {
l.PushBackList(ll[i])
} else {
l.PushFrontList(ll[i])
}
ll[i].Init()
}
}
func (this *InputNALUnit) convertPayloadToRBSP(nalUnitBuf *list.List, pcBitstream *TLibCommon.TComInputBitstream, isVclNalUnit bool) *list.List {
zeroCount := 0
it_write := list.New()
oldBuf := list.New()
for e := nalUnitBuf.Front(); e != nil; e = e.Next() {
//assert(zeroCount < 2 || *it_read >= 0x03);
it_read := e.Value.(byte)
oldBuf.PushBack(it_read)
if zeroCount == 2 && it_read == 0x03 {
zeroCount = 0
e = e.Next()
if e == nil {
break
} else {
it_read = e.Value.(byte)
oldBuf.PushBack(it_read)
}
}
if it_read == 0x00 {
zeroCount++
} else {
zeroCount = 0
}
it_write.PushBack(it_read)
}
//assert(zeroCount == 0);
if isVclNalUnit {
// Remove cabac_zero_word from payload if present
n := 0
e := it_write.Back()
it_read := e.Value.(byte)
for it_read == 0x00 {
it_write.Remove(e)
e = e.Prev()
it_read = e.Value.(byte)
n++
}
if n > 0 {
fmt.Printf("\nDetected %d instances of cabac_zero_word", n/2)
}
}
nalUnitBuf.Init() // = .resize(it_write - nalUnitBuf.begin());
for e := it_write.Front(); e != nil; e = e.Next() {
it_read := e.Value.(byte)
nalUnitBuf.PushBack(it_read)
}
return oldBuf
}
func empty(l *list.List, args []string) {
// print out all elements before droping
itemNumber := 1
for e := l.Front(); e != nil; e = e.Next() {
fmt.Printf("Removing item[%d]:", itemNumber)
printJSON(e.Value)
itemNumber++
}
// empty list
l.Init()
}
// Serve the clients their events and destroy them when its time
// This also triggers the done chan, when c is closed
func serveChannels(c <-chan interface{}, clients *list.List, done chan<- struct{}) {
for {
var (
event interface{}
channelOpen bool
)
event = nil
channelOpen = true
select {
case event, channelOpen = <-c:
case <-time.After(120 * time.Second):
}
if !channelOpen {
close(done)
// wait so no new clients come any longer
<-time.After(1 * time.Second)
for client := range clientsIter(clients) {
close(client.value.channel)
}
// empty all references
clients.Init()
return
}
// channel is still open
var wg sync.WaitGroup
for client := range clientsIter(clients) {
select {
case <-client.value.quit:
// client has quit
client.removeFrom(clients)
continue
default:
}
// client has too many strikes
if client.value.strikes >= 5 {
client.removeFrom(clients)
continue
}
// client has not quit
wg.Add(1)
go sendEvent(event, client.value, &wg)
}
// wait for the events to be sent
wg.Wait()
}
}
func TestList(t *testing.T) {
var myInstance *MyType
myInstance = new(MyType)
myInstance.name = "hello"
var myList list.List
myList.Init()
myList.PushFront(myInstance)
x := myList.Front().Value.(*MyType)
fmt.Println((*x).name)
}
func ListSwap(ls1 *list.List, ls2 *list.List) {
tmpLs := list.New()
for l1 := ls1.Front(); l1 != nil; l1 = l1.Next() {
tmpLs.PushBack(l1)
}
ls1 = ls1.Init()
for l2 := ls2.Front(); l2 != nil; l2 = l2.Next() {
ls1.PushBack(l2)
}
ls2 = ls2.Init()
for tl := tmpLs.Front(); tl != nil; tl = tl.Next() {
ls2.PushBack(tl)
}
}
func (st *offlineSubTask) flush(id uint64, l *list.List) {
path := filepath.Join(st.baseDir, fmt.Sprintf("%d", st.id), fmt.Sprintf("%d", id))
var file *os.File
var err error
if file, err = open(path, os.O_WRONLY|os.O_APPEND|os.O_CREATE); err != nil {
panic(err)
}
writer := bufio.NewWriter(file)
defer file.Close()
for e := l.Front(); e != nil; e = e.Next() {
msg := e.Value.(RouteMsg)
_writeMsg(writer, msg)
st.cacheBytes -= uint64(len(msg.Body()))
}
writer.Flush()
l.Init()
}
// Parse splits code into `Section`s
func parse(source string, code []byte) *list.List {
lines := bytes.Split(code, []byte("\n"))
sections := new(list.List)
sections.Init()
language := getLanguage(source)
var hasCode bool
var codeText = new(bytes.Buffer)
var docsText = new(bytes.Buffer)
// save a new section
save := func(docs, code []byte) {
// deep copy the slices since slices always refer to the same storage
// by default
docsCopy, codeCopy := make([]byte, len(docs)), make([]byte, len(code))
copy(docsCopy, docs)
copy(codeCopy, code)
sections.PushBack(&Section{docsCopy, codeCopy, nil, nil})
}
for _, line := range lines {
// if the line is a comment
if language.commentMatcher.Match(line) {
// but there was previous code
if hasCode {
// we need to save the existing documentation and text
// as a section and start a new section since code blocks
// have to be delimited before being sent to Pygments
save(docsText.Bytes(), codeText.Bytes())
hasCode = false
codeText.Reset()
docsText.Reset()
}
docsText.Write(language.commentMatcher.ReplaceAll(line, nil))
docsText.WriteString("\n")
} else {
hasCode = true
codeText.Write(line)
codeText.WriteString("\n")
}
}
// save any remaining parts of the source file
save(docsText.Bytes(), codeText.Bytes())
return sections
}
func (bb *ReportQueue) PE_ParetoTestError() {
bb.less = lessSizeTestError
sort.Sort(bb)
var pareto list.List
pareto.Init()
for i, _ := range bb.queue {
if bb.queue[i] == nil {
continue
}
pareto.PushBack(bb.queue[i])
}
over := len(bb.queue) - 1
for pareto.Len() > 0 && over >= 0 {
pe := pareto.Front()
eLast := pe
pb := pe.Value.(*ExprReport)
cSize := pb.Size()
cScore := pb.testError
pe = pe.Next()
for pe != nil && over >= 0 {
pb := pe.Value.(*ExprReport)
if pb.testError < cScore {
cScore = pb.testError
if pb.Size() > cSize {
bb.queue[over] = eLast.Value.(*ExprReport)
over--
pareto.Remove(eLast)
cSize = pb.Size()
eLast = pe
}
}
pe = pe.Next()
}
if over < 0 {
break
}
bb.queue[over] = eLast.Value.(*ExprReport)
over--
pareto.Remove(eLast)
}
}
/* delete all the elements with time <= t */
func DeleteBefore(t Time, L *list.List) {
if L.Len() == 0 {
return
}
back := L.Back()
if back.Value.(Elem).GetTime() <= t {
L = L.Init()
return
}
Loop:
for {
el := L.Front()
if el.Value.(Elem).GetTime() <= t {
L.Remove(el)
} else {
break Loop
}
}
}
/* delete all the elements with time >= t */
func DeleteAfter(t Time, L *list.List) {
if L.Len() == 0 {
return
}
front := L.Front()
if front.Value.(Elem).GetTime() >= t {
L = L.Init()
return
}
Loop:
for {
el := L.Back()
if el.Value.(Elem).GetTime() >= t {
L.Remove(el)
} else {
break Loop
}
}
}
func tileWorker(T *quadratic.Map, alternativeStack chan *list.List, sink chan<- *quadratic.Map, workerCount chan int, halt chan int, tileMaps []*quadratic.Map, chooseNextEdge func(*quadratic.Map) *quadratic.Edge, maxtiles int, tileSymmetry string, showIntermediate bool) {
localAlternatives := new(list.List)
Work:
for {
select {
case <-halt:
halt <- 1
fmt.Fprintf(os.Stderr, "premature halt\n")
return
case L := <-alternativeStack:
L.PushFrontList(localAlternatives)
localAlternatives.Init()
alternativeStack <- L
default:
if T.Faces.Len() > maxtiles && maxtiles > 0 {
sink <- T
break Work
} else if noActiveFaces(T) {
finishTime, _, _ := os.Time()
fmt.Fprintf(os.Stderr, "new tiling complete, took %v seconds\n", finishTime-initializationTime)
sink <- T
break Work
} else if showIntermediate {
sink <- T
}
alternatives := addTilesByEdge(T, tileMaps, chooseNextEdge, tileSymmetry)
if alternatives.Len() == 0 {
break Work
}
T = alternatives.Remove(alternatives.Front()).(*quadratic.Map)
localAlternatives.PushFrontList(alternatives)
//fmt.Fprintf(os.Stderr,"currently have %v faces\n",T.Faces.Len())
}
}
L := <-alternativeStack
L.PushFrontList(localAlternatives)
localAlternatives.Init()
alternativeStack <- L
workers := <-workerCount
workerCount <- workers - 1
}
// our simplified version of MapReduce does not supply a
// key to the Map function, as in the paper; only a value,
// which is a part of the input file contents
func Map(value string) *list.List {
m := make(map[string]int)
words := strings.FieldsFunc(value, func(r rune) bool { return !unicode.IsLetter(r) })
for i := 0; i < len(words); i++ {
word := words[i]
v, ok := m[word]
if ok {
m[word] = v + 1
} else {
m[word] = 1
}
}
l := new(list.List)
l.Init()
for k, val := range m {
kv := mapreduce.KeyValue{Key: k, Value: strconv.Itoa(val)}
l.PushBack(kv)
}
// fmt.Println("DONE WITH MAPPING PHASE\n\n")
return l
}
// Dump the DHT
// First line of response is number of items
// It is important that the DHT is delivered in one go as
// otherwise there will be sync issues. Imagine you dump a bit now, then delete
// a message what was part of that dump and then dump some more, the delete would
// be lost.
// Will this work for 1,000,000 messages in the DHT?
func (myDHTServer *DHTServerStruct) dumpDHT(con *net.TCPConn) {
// Query DHT
sql := fmt.Sprintf("SELECT id,sha1,mailbox,size,orignodeid FROM DHT order by id")
G_dhtDBLock.Lock()
stmt, serr := myDHTServer.dht.Prepare(sql)
defer stmt.Finalize()
defer G_dhtDBLock.Unlock()
if serr == nil {
var id int
var sha1 string
var mailbox string
var size int
var orignodeid int
var r list.List
r.Init()
stmt.Exec()
rowcount := 0
for stmt.Next() {
err := stmt.Scan(&id, &sha1, &mailbox, &size, &orignodeid)
if err != nil {
myDHTServer.logger.Logf(LMIN, "Unexpected error using DB: %s", err)
break
}
reply := fmt.Sprintf("%d,%s,%s,%d,%d\r\n", id, sha1, mailbox, size, orignodeid)
r.PushBack(reply)
rowcount++
}
con.Write([]byte(fmt.Sprintf("%d\r\n", rowcount)))
for c := range r.Iter() {
con.Write([]byte(c.(string)))
}
} else {
myDHTServer.logger.Logf(LMIN, "Unexpected error using DB (%s): %s", sql, serr)
}
}
// Send the New Message Log to a remote node
// First line of response is number of items
func (myDHTServer *DHTServerStruct) sendNewMessageLog(con *net.TCPConn, hid string) {
// Query newMessageLog
sql := fmt.Sprintf("SELECT id, sha1, mailbox, size FROM newMessageLog where id > %s order by id", hid)
G_nmlDBLock.Lock()
stmt, serr := myDHTServer.nml.Prepare(sql)
defer stmt.Finalize()
defer G_nmlDBLock.Unlock()
if serr == nil {
var id int
var sha1 string
var mailbox string
var size int
var r list.List
r.Init()
stmt.Exec()
rowcount := 0
for stmt.Next() {
err := stmt.Scan(&id, &sha1, &mailbox, &size)
if err != nil {
myDHTServer.logger.Logf(LMIN, "Unexpected error using DB: %s", err)
break
}
reply := fmt.Sprintf("%d,%s,%s,%d,%s\r\n", id, sha1, mailbox, size, G_nodeID)
r.PushBack(reply)
rowcount++
}
con.Write([]byte(fmt.Sprintf("%d\r\n", rowcount)))
for c := range r.Iter() {
con.Write([]byte(c.(string)))
}
} else {
myDHTServer.logger.Logf(LMIN, "Unexpected error using DB (%s): %s", sql, serr)
}
}
func (this *Dictionary) SortList(ls *list.List, pref map[string]string) {
tmpLs := make([]string, ls.Len())
count := 0
for i := ls.Front(); i != nil; i = i.Next() {
tmpLs[count] = i.Value.(string)
count++
}
for i := 0; i < len(tmpLs); i++ {
for j := i + 1; j < len(tmpLs); j++ {
if this.less(tmpLs[j], tmpLs[i], pref) {
tmp := tmpLs[j]
tmpLs[j] = tmpLs[i]
tmpLs[i] = tmp
}
}
}
ls = ls.Init()
for i := 0; i < len(tmpLs); i++ {
ls.PushBack(tmpLs[i])
}
}
func (this *SemanticDB) getWNKeys(form string, lemma string, tag string, searchList *list.List) {
searchList = searchList.Init()
for p := this.posMap.Front(); p != nil; p = p.Next() {
LOG.Trace("Check tag " + tag + " with posmap " + p.Value.(PosMapRule).pos + " " + p.Value.(PosMapRule).wnpos + " " + p.Value.(PosMapRule).lemma)
if strings.Index(tag, p.Value.(PosMapRule).pos) == 0 {
LOG.Trace(" matched")
var lm string
if p.Value.(PosMapRule).lemma == "L" {
lm = lemma
} else if p.Value.(PosMapRule).lemma == "F" {
lm = form
} else {
LOG.Trace("FOund word matching special map: " + lemma + " " + p.Value.(PosMapRule).lemma)
lm = this.formDict.accessDatabase(lemma + " " + p.Value.(PosMapRule).lemma)
}
fms := StrArray2StrList(Split(lm, " "))
for ifm := fms.Front(); ifm != nil; ifm = ifm.Next() {
LOG.Trace("Adding word '" + form + "' to be searched with pos=" + p.Value.(PosMapRule).pos + " and lemma=" + ifm.Value.(string))
searchList.PushBack(Pair{ifm.Value.(string), p.Value.(PosMapRule).wnpos})
}
}
}
}
func (this *Tokenizer) Tokenize(p string, offset int, v *list.List) {
var t [10]string
var i *list.Element
var match bool
substr := 0
ln := 0
v = v.Init()
cont := 0
for cont < len(p) {
for WhiteSpace(p[cont]) {
cont++
offset++
}
LOG.Trace("Tokenizing [" + p[cont:] + "]")
match = false
for i = this.rules.Front(); i != nil && !match; i = i.Next() {
LOG.Trace("Checking rule " + i.Value.(Pair).first.(string))
ps := strings.Index(p[cont:], " ")
delta := cont + ps
if ps == -1 {
delta = cont + len(p) - cont
}
results := RegExHasSuffix(i.Value.(Pair).second.(*regexp.Regexp), p[cont:delta])
if len(results) > 0 {
match = true
ln = 0
substr = this.matches[i.Value.(Pair).first.(string)]
for j := If(substr == 0, 0, 1).(int); j <= substr && match; j++ {
t[j] = results[j]
ln += len(t[j])
LOG.Trace("Found match " + strconv.Itoa(j) + " [" + t[j] + "] for rule " + i.Value.(Pair).first.(string))
if string(i.Value.(Pair).first.(string)[0]) == "*" {
lower := strings.ToLower(t[j])
if !this.abrevs.Has(lower) {
match = false
LOG.Trace("Special rule and found match not in abbrev list. Rule not satisfied")
}
}
}
}
}
if match {
if i == nil {
i = this.rules.Back()
} else {
i = i.Prev()
}
substr = this.matches[i.Value.(Pair).first.(string)]
for j := If(substr == 0, 0, 1).(int); j <= substr && match; j++ {
if len(t[j]) > 0 {
LOG.Trace("Accepting matched substring [" + t[j] + "]")
w := NewWordFromLemma(t[j])
w.setSpan(offset, offset+len(t[j]))
offset += len(t[j])
v.PushBack(w)
} else {
LOG.Trace("Skipping matched null substring [" + t[j] + "]")
}
}
cont += ln
} else if cont < len(p) {
LOG.Warn("No rule matched input substring" + p[cont:] + " . Character " + string(p[cont:][0]) + " skipped . Check your tokenization rules")
cont++
}
}
offset++
}
func main() {
var sigchan = make(chan os.Signal, 1)
signal.Notify(sigchan, os.Interrupt)
go func() {
<-sigchan
fmt.Fprintf(os.Stdout, "\n")
os.Exit(0)
}()
pacemakerPresentPattern, _ := regexp.Compile("PACEMAKER_PRESENT")
pacemakerIterationPattern, _ := regexp.Compile("PACEMAKER_ITERATION")
numberPattern, _ := regexp.Compile("[0-9.]+$")
scanner := bufio.NewScanner(os.Stdin)
var buffer list.List
var legend string
var scaleHasChanged = false
w, _, _ := terminal.GetSize(1)
terminalWidth := uint(w - 10)
lastSampleTaken := time.Now()
pacemakerPresent := false
for scanner.Scan() {
lineOfText := scanner.Text()
if pacemakerPresentPattern.MatchString(lineOfText) {
pacemakerPresent = true
if msBetweenSamples != defaultMsBetweenSamples {
log.Fatal("You specified a value for sample-period-ms but a pacemaker signal was found. If you are processing logs retrospectively stick with the pacemaker. If you are sampling in real time ditch the pacemaker.")
}
}
pacemakerIterationSignal := pacemakerIterationPattern.MatchString(lineOfText)
if !pacemakerIterationSignal && numberPattern.MatchString(lineOfText) {
var dataPoint float64
numberText := numberPattern.FindString(lineOfText)
dataPoint, _ = strconv.ParseFloat(numberText, 64)
if dataPoint > maximumValue {
maximumValue = 1.2 * dataPoint
scaleHasChanged = true
}
buffer.PushBack(dataPoint)
}
if pacemakerIterationSignal || (!pacemakerPresent && time.Since(lastSampleTaken) >= time.Millisecond*time.Duration(msBetweenSamples)) {
timeText := time.Time.Format(time.Now(), "15:04:05")
if pacemakerIterationSignal {
timeText = strings.Split(lineOfText, " ")[1]
}
histogram, newMaximumMagnitude, maximumMagnitudeHasChanged := sample(buffer, maximumValue, terminalWidth, maximumMagnitude)
if maximumMagnitudeHasChanged {
maximumMagnitude = newMaximumMagnitude
} // otherwise scope means it is forgotten each time
legend = updateLegendAndNotifyIfScaleHasChanged(legend, maximumValue, scaleHasChanged, terminalWidth)
printSample(histogram, timeText, maximumValue, terminalWidth, maximumMagnitude, maximumMagnitudeHasChanged)
printScale(histogram, int(len(timeText)), legend)
// reset for next sample
scaleHasChanged = false
buffer.Init()
lastSampleTaken = time.Now()
}
}
if err := scanner.Err(); err != nil {
fmt.Fprintln(os.Stderr, "reading standard input:", err)
}
fmt.Fprint(os.Stdout, "\n")
}
func (this *Splitter) Split(st *SplitterStatus, v *list.List, flush bool, ls *list.List) {
ls = ls.Init()
LOG.Trace("Looking for a sentence marker. Max no split is " + strconv.Itoa(int(this.SPLIT_MaxWords)))
for w := v.Front(); w != nil; w = w.Next() {
m := this.markers[w.Value.(*Word).getForm()]
checkSplit := true
if st.BetweenMark && !this.SPLIT_AllowBetweenMarkers && m != 0 && m == If(m > SAME, 1, -1).(int)*st.MarkType.Front().Value.(int) {
LOG.Trace("End no split period. marker " + w.Value.(*Word).getForm() + " code: " + strconv.Itoa(m))
st.MarkType.Remove(st.MarkType.Front())
st.MarkForm.Remove(st.MarkForm.Front())
if st.MarkForm.Len() == 0 {
st.BetweenMark = false
st.NoSplitCount = 0
} else {
st.NoSplitCount++
}
st.buffer.PushBack(w.Value.(*Word))
checkSplit = false
} else if m > 0 && !this.SPLIT_AllowBetweenMarkers {
st.MarkForm.PushFront(w.Value.(*Word).getForm())
st.MarkType.PushFront(m)
LOG.Trace("Start no split periood, marker " + w.Value.(*Word).getForm() + " code:" + strconv.Itoa(m))
st.BetweenMark = true
st.NoSplitCount++
st.buffer.PushBack(w.Value.(*Word))
checkSplit = false
} else if st.BetweenMark {
LOG.Trace("no-split flag continues set. word " + w.Value.(*Word).getForm() + " expecting code " + strconv.Itoa(st.MarkType.Front().Value.(int)) + " (closing " + st.MarkForm.Front().Value.(string))
st.NoSplitCount++
if this.SPLIT_MaxWords == 0 || st.NoSplitCount <= int(this.SPLIT_MaxWords) {
checkSplit = false
st.buffer.PushBack(w.Value.(*Word))
}
if st.NoSplitCount == VERY_LONG {
LOG.Warn("Sentence is very long")
}
}
if checkSplit {
e := this.enders[w.Value.(*Word).getForm()]
if e {
if e || this.endOfSentence(w, v) {
LOG.Trace("Sentence marker [" + w.Value.(*Word).getForm() + "] found")
st.buffer.PushBack(w.Value.(*Word))
st.nsentence++
st.buffer.sentID = strconv.Itoa(st.nsentence)
ls.PushBack(st.buffer)
LOG.Trace("Sentence lenght " + strconv.Itoa(st.buffer.Len()))
nsentence := st.nsentence
this.CloseSession(st)
st = this.OpenSession()
st.nsentence = nsentence
} else {
LOG.Trace(w.Value.(*Word).getForm() + " is not a sentence marker here")
st.buffer.PushBack(w.Value.(*Word))
}
} else {
LOG.Trace(w.Value.(*Word).getForm() + " is not a sentence marker here")
st.buffer.PushBack(w.Value.(*Word))
}
}
}
if flush && st.buffer.Len() > 0 {
LOG.Trace("Flushing the remaining words into a sentence")
st.nsentence++
st.buffer.sentID = strconv.Itoa(st.nsentence)
ls.PushBack(st.buffer)
nsentence := st.nsentence
this.CloseSession(st)
st = this.OpenSession()
st.nsentence = nsentence
}
}
func (this *Dictionary) AnnotateWord(w *Word, lw *list.List, override bool) bool {
LOG.Trace("Searching in dictionary for word " + w.getForm())
la := list.New()
this.SearchForm(w.getForm(), la)
w.setFoundInDict(la.Len() > 0)
LOG.Trace(" Found " + strconv.Itoa(la.Len()) + " analysis.")
for a := la.Front(); a != nil; a = a.Next() {
w.addAnalysis(a.Value.(*Analysis))
LOG.Trace(" added analysis " + a.Value.(*Analysis).getLemma())
}
if this.CompoundAnalysis {
//TODO
}
contr := false
if !this.RetokenizeContractions || override {
newLa := list.New()
na := &Analysis{}
for a := w.Front(); a != nil; a = a.Next() {
tgs := list.New()
tmpItems := Split(a.Value.(*Analysis).getTag(), "+")
for _, tmpItem := range tmpItems {
tgs.PushBack(tmpItem)
}
tc := this.tagCombination(tgs.Front(), tgs.Back().Prev())
if tc.Len() > 1 {
newLa = newLa.Init()
for tag := tc.Front(); tag != nil; tag = tag.Next() {
na.init(a.Value.(*Analysis).getLemma(), tag.Value.(string))
newLa.PushBack(na)
}
ta := a
for t := newLa.Front(); t != nil; t = t.Next() {
ta = w.InsertAfter(ta, t)
}
w.Remove(a)
a = ta
}
}
for a := w.Front(); a != nil; a = a.Next() {
lw = lw.Init()
if this.CheckContracted(w.getForm(), a.Value.(*Analysis).getLemma(), a.Value.(*Analysis).getTag(), lw) {
a.Value.(*Analysis).setRetokenizable(lw)
}
}
} else {
ca := w.Front()
for ca != nil && (strings.Index(ca.Value.(*Analysis).getLemma(), "+") == -1 || strings.Index(ca.Value.(*Analysis).getTag(), "+") == -1) {
ca = ca.Next()
}
if ca != nil && w.getNAnalysis() > 1 {
LOG.Warn("Contraction " + w.getForm() + " has several analysis in dictionary. All ignored except (" + ca.Value.(*Analysis).getLemma() + "," + ca.Value.(*Analysis).getTag() + "). Set RetokenizeContraction=false to keep all analysis.")
} else {
ca = w.Front()
}
if ca != nil && this.CheckContracted(w.getForm(), ca.Value.(*Analysis).getLemma(), ca.Value.(*Analysis).getTag(), lw) {
contr = true
}
}
return contr
}
