func (this *Scheduler) Loop() {
collection, session := connectMongo()
defer func() {
session.Close()
if err := recover(); err != nil {
spew.Println(err)
}
}()
for {
select {
case item := <-this.Queue:
switch v := item.(type) {
case Joke:
spew.Println("[+] insert : ", v)
v.Date = time.Now().Unix()
v.Id = time.Now().UnixNano()
spew.Println(v.Date, v.Id)
collection.Insert(v)
default:
spew.Println("sth wrong?")
}
spew.Println("----------------------------------------------------------------------------")
//case for other chan receive
//...
}
}
}
// Less(CmpI) を実装した型であれば、CmpI 型として、このスーパーな関数が使えるようになるんだぜ。
func quickSortCmpI(buff []CmpI, low, high int) {
p := buff[low+(high-low)/2] // 枢軸の値を決める。
i, j := low, high
spew.Println(" start:", "i:", i, "j:", j, "pvalue:", p, buff)
for {
for buff[i].Less(p) { // 左から（小さいグループ）要素 < 枢軸 が崩れるところまでインデックスを進める。
i++
}
for p.Less(buff[j]) { // 右から（大きいグループ）枢軸 < 要素 が崩れるところまでインデックスを進める。
j--
}
if i >= j { // 左右のインデックスが交わったらループ終了。
break
}
// で、大小グループ関係が崩れているところをスワップ。
buff[i], buff[j] = buff[j], buff[i]
// インデックスを進めてループの先頭へ。
i++
j--
}
spew.Println("result:", "i:", i, "j:", j, "pvalue:", p, buff)
fmt.Println()
// 枢軸を基準に大小グループに分けられた。
// こんどはそれらの大小グループに対して上の処理を繰り返す。
// 以下で
// x x x x P y y y y
// i j
// って分割されるっぽい。
if low < i-1 {
quickSortCmpI(buff, low, i-1)
}
if high > j+1 {
quickSortCmpI(buff, high, j+1)
}
}
func main() {
//* Go のシグナル通知はチャネル上の '''os.Signal''' 値を送信することで動作します。私達はこれらの通知を受け取るチャネルを一つ作成します（また、プログラムが exit 可能時に、そのチャネルが私達に通知するようにします）。
// これなんでバッファ（非同期チャネルに）してんだ？バッファなし（同期チャネル）でも動くじゃん。
sigs := make(chan os.Signal, 1)
done := make(chan bool, 1)
//* '''signal.Notify''' は特定のシグナル通知を受け取るチャネルを登録します。
signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
//* この goroutine はシグナル受信のブロッキングを実行します。シグナルを受信すると、プログラムが終了可能であることを通知します。
// ブロッ......キング......レシーバー？
// main が実行されると、ここの goroutine も並行して実行される。
go func() {
sig := <-sigs //signal 受信専用チャネル。
spew.Println()
spew.Println(sig) // signal キター。
done <- true
}()
//* プログラムは期待された（上の groutine の '''done''' の値の送信で示された）シグナルを取得するまでここで待ちます。その後、exit します。
// で、上の groutine と合わせて main() の処理も進む。
spew.Println("awaiting signal")
// 上の groutine の、done チャネルにデータが入ってくるまで待ち合わせ。
<-done
spew.Println("exiting")
}
func main() {
// int
var i int = 1
var pi *int = &i
// string
var str string = "hello, world."
var pstr *string = &str
// array
var ary [2]int = [2]int{1, 2}
var pary *[2]int = &ary
// slice
var slc []int = []int{10, 20}
var pslc *[]int = &slc
// これは分かる。
spew.Println("int")
spew.Printf("i = %#+v, &i = %#+v, pi = %#+v, *pi = %#+v\n\n", i, &i, pi, *pi)
spew.Println("string")
spew.Printf("str = %#+v, &str = %#+v, pstr = %#+v, *pstr = %#+v\n\n", str, &str, pstr, *pstr)
spew.Println("array")
spew.Printf("ary = %#+v, &ary = %#+v, pary = %#+v, *pary = %#+v\n\n", ary, &ary, pary, *pary)
spew.Println("slice")
spew.Printf("slc = %#+v, &slc = %#+v, pslc = %#+v, *pslc = %#+v\n\n", slc, &slc, pslc, *pslc)
// 解せぬ。
spew.Println("string[n]")
// &str[0]: cannot take the address of str[0] // 文字列の要素をアドレス番地 + 添字で求められないのは仕様である、といった感じであろうか？
// pstr[0]: invalid operation: pstr[0] (type *string does not support indexing) // 上と同様。
// *pstr[0]: invalid operation: pstr[0] (type *string does not support indexing) // なぜだ。
spew.Printf("str[0] = %#+v\n\n", str[0])
spew.Println("array[n]")
// *pary[0]: invalid indirect of pary[0] (type int) // なぜだ。
spew.Printf("ary[0] = %#+v, &ary[0] = %#+v, pary[0] = %#+v\n\n", ary[0], &ary[0], pary[0])
spew.Println("slice[n]")
// pslc[0]: invalid operation: pslc[0] (type *[]int does not support indexing) // スライスはそれ自体がすでにどこかのアドレス番地の参照先のはず。スライスのポインタはダブルポインタ的な感じなので、アドレス番地 + 添字で求められないのは仕様である、といった感じだろうか？
// *pslc[0]: invalid operation: pslc[0] (type *[]int does not support indexing) // なぜだ。
spew.Printf("slc[0] = %#+v, &slc[0] = %#+v\n\n", slc[0], &slc[0])
// できるじゃん。
spew.Println("(*string)[n]")
spew.Printf("(*pstr)[0] = %#+v\n\n", (*pstr)[0])
spew.Println("(*array)[n]")
spew.Printf("(*pary)[0] = %#+v\n\n", (*pary)[0])
spew.Println("(*pscl)[n]")
spew.Printf("(*pslc)[0] = %#+v\n\n", (*pslc)[0])
}
func (p *Parser) PrintDistinctCombatLogTypes() {
for k, v := range p.combatLogParser.distinct {
spew.Println(k)
for kk, vv := range v {
if len(vv) > 1 {
spew.Println(kk)
pp(vv)
}
}
}
}
func main() {
var p Point
var q Point = Point{10, 10}
r := Point{x: 100, y: 100}
spew.Dump(p, q, r)
spew.Dump(p.x, p.y, q.x, q.y, r.x, r.y)
spew.Println(distance(p, q))
spew.Println(distance(p, r))
spew.Println(distance(q, r))
}
func main() {
a := []int{5, 8, 4, 6, 3, 7, 2, 9, 1, 0}
b := []int{9, 8, 7, 6, 5, 4, 3, 2, 1, 0}
c := []int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
insertSort(a)
insertSort(b)
insertSort(c)
spew.Println(a)
spew.Println(b)
spew.Println(c)
}
func main() {
//* key / varlue ペアを設定するために、'''os.Setenv''' を使います。key から value を取得するために '''os.Getenv''' を使います。環境に key が存在しない場合は空文字が返ります。
os.Setenv("FOO", "1")
spew.Printf("FOO: %#+v\n", os.Getenv("FOO"))
spew.Printf("BAR: %#+v\n", os.Getenv("BAR"))
spew.Printf("$PGUSER: %#+v\n", os.Getenv("PGUSER"))
//* '''os.Environ''' を使うと、環境内の全ての key / value ペアがリストされます。これは '''key=value''' という形式の文字列スライスです。ここで私達は全ての key を出力しています。
spew.Println()
for _, e := range os.Environ() {
pair := strings.Split(e, "=") // e: "key=value" --- strings.Split() ---> pair:["key", "value"]
spew.Println(pair[0])
}
}
func main() {
for i := 1; i <= 100; i++ {
switch i % 15 {
case 0:
spew.Println("FizzBuzz")
case 3, 6, 9:
spew.Println("Fizz")
case 5, 10:
spew.Println("Buzz")
default:
spew.Println(i)
}
}
}
func main() {
for i := 1; i <= 100; i++ {
switch {
case i%15 == 0:
spew.Println("FizzBuzz")
case i%3 == 0:
spew.Println("Fizz")
case i%5 == 0:
spew.Println("Buzz")
default:
spew.Println(i)
}
}
}
func main() {
// 構造体のポインタを定義する。
var p *Point = &Point{} // var p *Point だけでは当然 nil である。
var q *Point = &Point{10, 10} // これで初期化した構造体のアドレス番地が返るようだ。
r := new(Point) // でも普通は new 使ってゼロ値で初期化済みの構造体のアドレス番地返しますよね。
r.x, r.y = 100, 100 // new したら値は明示的に代入する。
spew.Dump(p, q, r)
spew.Dump(p.x, p.y, q.x, q.y, r.x, r.y)
spew.Println(distance(p, q))
spew.Println(distance(p, r))
spew.Println(distance(q, r))
}
func pppc(pc uintptr, ok bool, args ...interface{}) {
if ok {
f := runtime.FuncForPC(pc)
fParts := strings.Split(f.Name(), ".")
fun := fParts[len(fParts)-1]
s := spew.Sprintf("vvvvvvvvvvvvvvv %s vvvvvvvvvvvvvvv\n", fun)
spew.Print(s)
spew.Dump(args...)
spew.Println(strings.Repeat("^", len(s)-1))
} else {
spew.Println("vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv")
spew.Dump(args...)
spew.Println("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^")
}
}
func (this *qiubaiCrawler) Visit(Q chan interface{}, L *sync.Mutex) {
//spew.Dump(this)
this.CrawlerBase.Visit(Q, L)
//spew.Dump(CACHEMAP)
this.doc.Find(".content").Each(func(i int, s *Selection) {
src, ok := s.Parent().Attr("id")
if !ok {
src = this.doc.Url.String()
} else {
src = this.Cfg.Host + strings.Replace(src, "qiushi_tag_", "article/", -1)
}
cont := strings.TrimSpace(s.Text())
_, ok = CACHEMAP[src]
if ok {
spew.Println("[!] Skip!")
return
} else {
L.Lock()
CACHEMAP[src] = true
L.Unlock()
}
imgsrc := ""
if thumb := s.Next(); thumb != nil {
imgsrc, _ = thumb.Find("img").Eq(0).Attr("src")
}
joke := Joke{
Content: cont,
Src: src,
ImgSrc: imgsrc,
}
Q <- joke
})
//spew.Dump(joke)
}
func main() {
//* '''defer''' は '''os.Exit''' を使うと '''実行されません'''。したがって、この '''fmt.Println''' は決して call されません。
defer spew.Println("!")
os.Exit(3)
//* 例えば C などとは違って、Go は exit ステータスを示すために '''main''' からの整数の戻り値を使いません。非ゼロステータスで exit したい場合は、'''os.Exit''' を使う必要があります。
}
func (p *OuterParser) AnalyzePacket(callback func(*OuterParserBaseItem), fromEvent dota.EDemoCommands, tick int, data []byte) {
reader := NewBytesReader(data)
for reader.CanRead() {
iType := int(reader.ReadVarInt32())
length := int(reader.ReadVarInt32())
obj, err := p.AsBaseEventNETSVC(iType)
if err != nil {
spew.Println(err)
reader.Skip(length)
} else {
item := &OuterParserItem{
Sequence: p.Sequence,
From: fromEvent,
Object: obj,
Tick: tick,
Data: reader.Read(length),
}
p.Sequence++
switch obj.(type) {
case *dota.CSVCMsg_UserMessage:
message := &dota.CSVCMsg_UserMessage{}
ProtoUnmarshal(item.Data, message)
um, err := p.AsBaseEventBUMDUM(int(message.GetMsgType()))
if err == nil {
item.Object = um
item.Data = message.GetMsgData()
callback(parseOne(item))
}
default:
callback(parseOne(item))
}
}
}
}
func main() {
a := []int{1, 2, 3}
b := []int{4, 5, 6}
foo(0, b...) // foo(0, b[0], b[1], b[2]) といっしょ。
spew.Println(append(a, b...)) // append() だって当然できる。
}
func (this *neihanduanziCrawler) Visit(Q chan interface{}, L *sync.Mutex) {
//spew.Dump(this)
this.CrawlerBase.Visit(Q, L)
this.doc.Find(".share_url").Each(func(i int, s *Selection) {
src, _ := s.Attr("href")
src = this.Cfg.Host + src[1:]
imgsrc := ""
if img := s.Find("img"); img != nil {
imgsrc, _ = img.Attr("data-original")
}
cont := strings.TrimSpace(s.Text())
_, ok := CACHEMAP[src]
if ok {
spew.Println("[!] Skip!")
return
} else {
L.Lock()
CACHEMAP[src] = true
L.Unlock()
}
joke := Joke{
Content: cont,
Src: src,
ImgSrc: imgsrc,
}
Q <- joke
//spew.Printf("%d: %s\n", i, band)
})
}
func (this *budejieCrawler) Visit(Q chan interface{}, L *sync.Mutex) {
//spew.Dump(this)
this.CrawlerBase.Visit(Q, L)
//spew.Dump(CACHEMAP)
this.doc.Find(".web_size").Each(func(i int, s *Selection) {
//title-5595718, detail-5595718.html
src, ok := s.Attr("id")
if !ok {
src = this.doc.Url.String()
} else {
src = this.Cfg.Host + strings.Replace(src, "title", "detail", -1) + ".html"
}
//spew.Println("!!!!!!!!!!!!!!!!!!!!!!!!", src)
cont := strings.TrimSpace(s.Text())
_, ok = CACHEMAP[src]
//spew.Println(ok)
if ok {
spew.Println("[!] Skip!")
return
} else {
L.Lock()
CACHEMAP[src] = true
L.Unlock()
}
joke := Joke{
Content: cont,
Src: src,
}
Q <- joke
})
//spew.Dump(joke)
}
func main() {
if len(os.Args) < 2 {
spew.Println("Expected a .dem file as argument")
}
for _, path := range os.Args[1:] {
parser := yasha.ParserFromFile(path)
parser.OnFileInfo = func(fileinfo *dota.CDemoFileInfo) {
data, err := json.MarshalIndent(fileinfo, "", " ")
if err != nil {
panic(err)
}
spew.Println(string(data))
}
parser.Parse()
}
}
func main() {
for i := 0; i < 10; i++ {
s := "foo"
spew.Println(s, i)
}
// ブロック外。
// spew.Println(s, i)
}
func main() {
lex := newLex()
lex.Init(os.Stdin)
for {
spew.Printf("> ")
lex.getToken()
spew.Println(lex.token, lex.TokenText())
}
}
func main() {
s := new(scanner.Scanner)
s.Init(os.Stdin)
for {
spew.Printf("> ")
x := s.Scan()
spew.Println(x, s.TokenText())
}
}
func (p *Parser) onGameEvent(tick int, obj *dota.CSVCMsg_GameEvent) {
desc := p.GameEventMap[obj.GetEventid()]
dName := desc.GetName()
switch dName {
case "hltv_versioninfo":
// version : <*>type:5 val_byte:1
case "hltv_message":
// text : <*>type:1 val_string:"Please wait for broadcast to start ..."
case "hltv_status":
// clients : <*>type:3 val_long:523
// slots : <*>type:3 val_long:3840
// proxies : <*>type:4 val_short:59
// master : <*>type:1 val_string:"146.66.152.49:28027"
case "dota_combatlog":
if p.OnCombatLog != nil {
if log := p.combatLogParser.parse(obj); log != nil {
p.OnCombatLog(log)
}
}
case "dota_chase_hero":
// target1 : <*>type:4 val_short:1418
// target2 : <*>type:4 val_short:0
// type : <*>type:5 val_byte:0
// priority : <*>type:4 val_short:15
// gametime : <*>type:2 val_float:2710.3667
// highlight : <*>type:6 val_bool:false
// target1playerid : <*>type:5 val_byte:1
// target2playerid : <*>type:5 val_byte:32
// eventtype : <*>type:4 val_short:1
case "dota_tournament_item_event":
// event_type : <*>type:4 val_short:0 => witness first blood
// event_type : <*>type:4 val_short:1 => witness killing spree
// event_type : <*>type:4 val_short:3 => witness hero deny
default:
dKeys := desc.GetKeys()
spew.Println(dName)
for n, key := range obj.GetKeys() {
spew.Println(dKeys[n].GetName(), ":", key)
}
}
}
func main() {
a := newTree()
for _, v := range []int{5, 5, 6, 4, 7, 3, 8, 2, 9, 1, 0} {
a.insertTree(Int(v))
}
a.printTree()
spew.Println("generator start")
resume := a.makeGen()
for i := 0; i < 11; i++ {
fmt.Println(resume())
}
spew.Println("generator end")
for i := 0; i < 10; i++ {
fmt.Println(a.searchTree(Int(i)))
}
for i := 0; i < 10; i++ {
a.deleteTree(Int(i))
a.printTree()
}
}
func main() {
//* '''os.Args''' は非加工のコマンドライン引数へのアクセスを提供します。このスライスの最初の値はプログラムへのパスであり、'''os.Args[1:]''' がプログラムに対する引数を保持している点に注意してください。
argsWithProg := os.Args
argsWithoutProg := os.Args[1:]
//* あなたは通常のインデックスと同様に個々の引数を取得できます。
arg := os.Args[3] // これ引数が 2 個以下なら panic じゃん。
spew.Println(arg)
spew.Dump(argsWithProg)
spew.Dump(argsWithoutProg)
}
func quickSortSub(data SortI, low, high int) {
p := low + (high-low)/2 // !!! これは枢軸となるインデックスだ !!!
i, j := low, high
spew.Println(" start:", "i:", i, "j:", j, "p:", p, "pvalue =", data.(IntArray)[p], data) // あー、インターフェースはデータ型が不定だから型アサーションしないと要素取れないのか。
for {
for data.Less(i, p) {
i++
}
for data.Less(p, j) {
j--
}
if i >= j {
break
}
data.Swap(i, j)
/*
* たしかにこれがないと正しくソートされなかったけど、なんでこれが必要なの？ => p は枢軸の添字でした。
* 関連があるか不明だが、data (SortI を実装した IntArray) は添字のアクセスができなかった。
* スライスな IntArray を SortI に代入すると添字アクセスできなくなるようだ。 => インターフェースなので、型アサーションすれば取れる。
*/
// スワップした時に、枢軸が移動したら枢軸の添字も移動しなければいけない。
switch {
case p == i:
p = j
case p == j:
p = i
}
i++
j--
}
spew.Println("result:", "i:", i, "j:", j, "p:", p, "pvalue =", data.(IntArray)[p], data)
spew.Println()
if low < i-1 {
quickSortSub(data, low, i-1)
}
if high > j+1 {
quickSortSub(data, j+1, high)
}
}
func main() {
a := []int{8, 4, 3, 7, 6, 5, 2, 1}
b := IntArray{8, 4, 3, 7, 6, 5, 2, 1}
c := []CmpI{Cint(8), Cint(4), Cint(3), Cint(7), Cint(6), Cint(5), Cint(2), Cint(1)}
fmt.Println("int")
spew.Println(a)
fmt.Println()
quickSortInt(a, 0, len(a)-1)
fmt.Println()
spew.Println(a)
fmt.Println()
fmt.Println("IntArray")
spew.Println(b)
fmt.Println()
quickSort(b)
fmt.Println()
spew.Println(b)
fmt.Println()
fmt.Println("CmpI")
spew.Println(c)
fmt.Println()
quickSortCmpI(c, 0, len(c)-1)
fmt.Println()
spew.Println(c)
}
func main() {
//* 基本的なフラグ宣言は文字、整数、真偽値のそれぞれをオプションとして使えます。ここでは、私達は文字フラグの '''word''' をデフォルト値 '''foo''' と簡単な説明を持った状態で宣言します。この '''flag.String''' 関数は文字のポインタ（文字の値ではありません）を返します; 私達は以下でこのポインタの使い方を確認します。
wordPtr := flag.String("word", "foo", "a string")
//* これは'''wor''' フラグと'''num''' と '''fork''' フラグを宣言しています。
numbPtr := flag.Int("numb", 42, "an int")
boolPtr := flag.Bool("fork", false, "a bool")
//* プログラムのいかなる場所でも、var で宣言した変数をオプションとして使うことは可能です。
var svar string
flag.StringVar(&svar, "svar", "bar", "a string var") // とは言え、flag.Parse() より前なんだろうけど。
//* 全てのフラグが宣言されたら、コマンドラインをパースするために '''flag.Parse()''' を呼び出します。
flag.Parse()
//* パースされたオプションと末尾の位置パラメータを出力します。例えば、'''*wordPtr''' と実際のオプション値を取得するためにポインタを逆参照する必要があることに注意してください。
spew.Println("word:", *wordPtr) // -word=xxx
spew.Println("numb:", *numbPtr) // -numb=xxx
spew.Println("fork", *boolPtr) // -fork=xxx
spew.Println("svar", svar) // -svar=xxx
spew.Println("tail:", flag.Args()) // 位置パラメータのスライスが返る。
}
func main() {
a := []int{1, 2, 3, 1, 2, 3, 4, 5}
spew.Println(find(4, a))
spew.Println(find(6, a))
spew.Println(position(5, a))
spew.Println(position(6, a))
spew.Println(count(3, a))
spew.Println(count(8, a))
}
func parseOne(item *OuterParserItem) *OuterParserBaseItem {
err := ProtoUnmarshal(item.Data, item.Object)
if err != nil {
spew.Println("parseOne()")
spew.Dump(item)
panic(err)
return &OuterParserBaseItem{}
}
item.Data = nil
return &OuterParserBaseItem{
Sequence: item.Sequence,
Tick: item.Tick,
From: item.From,
Object: item.Object,
}
}
