Esempio n. 1
0
/*
1 Converts single-byte characters in cExpression to double-byte characters.

  Supported for Locale ID only (specified with the nRegionalIdentifier or nRegionalIDType parameters).

2 Converts double-byte characters in cExpression to single-byte characters.

  Supported for Locale ID only (specified with the nRegionalIdentifier or nRegionalIDType parameters).

3 Converts double-byte Katakana characters in cExpression to double-byte Hiragana characters.

 Supported for Locale ID only (specified with the nRegionalIdentifier or nRegionalIDType parameters).

4 Converts double-byte Hiragana characters in cExpression to double-byte Katakana characters.

  Supported for Locale ID only (specified with the nRegionalIdentifier or nRegionalIDType parameters).

5 Converts double-byte characters to UNICODE (wide characters).

6 Converts UNICODE (wide characters) to double-byte characters.

7 Converts cExpression to locale-specific lowercase.

  Supported for Locale ID only (specified with the nRegionalIdentifier or nRegionalIDType parameters).

8 Converts cExpression to locale-specific uppercase.

  Supported for Locale ID only (specified with the nRegionalIdentifier or nRegionalIDType parameters).





13 Converts single-byte characters in cExpression to encoded base64 binary.

14 Converts base64 encoded data in cExpression to original unencoded data.

15 Converts single-byte characters in cExpression to encoded hexBinary.

16 Converts single-byte characters in cExpression to decoded hexBinary

*/
func Strconv(zstr string, zconvertType int) string {

	zcharset := ""

	switch zconvertType {
	case 9: //9 Converts double-byte characters in cExpression to UTF-8
		zcharset = getCurrentCP()
		dec := mahonia.NewDecoder(zcharset)
		return dec.ConvertString(zstr)
	case 10: //10 Converts Unicode characters in cExpression to UTF-8
		zcharset = "utf16"
		dec := mahonia.NewDecoder(zcharset)
		return dec.ConvertString(zstr)

	case 11: //11 Converts UTF-8 characters in cExpression to double-byte characters.
		zcharset = getCurrentCP()
		enc := mahonia.NewEncoder(zcharset)
		return enc.ConvertString(zstr)
	case 12: //12 Converts UTF-8 characters in cExpression to UNICODE characters.
		zcharset = "utf16"
		enc := mahonia.NewEncoder(zcharset)
		return enc.ConvertString(zstr)

	}
	return zstr
}
Esempio n. 2
0
func packEC(paramMap map[string]string) *Request {
	sid := make([]uint32, 1)
	sid[0] = 2014
	urlPack := UrlPack{} //UrlPack{voice_search: 2}
	urlPack.Voice_search = 2
	byteUrlPack, _ := mcpack.Marshal(urlPack)
	normalreq := Normalreq{} //{sid: sid, rsse_num: 10, rsse_type: 139}
	normalreq.Sid = sid
	normalreq.Rsse_num = 10
	normalreq.Rsse_type = 139
	normalreq.UrlPack = byteUrlPack
	if paramMap["character"] == "utf-8" || paramMap["character"] == "utf8" {
		enc := mahonia.NewEncoder("gbk")
		gbk := enc.ConvertString(paramMap["query"])
		normalreq.Word = gbk
	} else {
		normalreq.Word = paramMap["query"]
	}

	req := Req{}
	req.Cmd = 0
	req.Cmd64 = 0
	cmdreq := make([]uint64, 2)
	cmdreq[0] = 0
	cmdreq[1] = 2097152
	req.Cmdreq = cmdreq
	req.Normalreq = normalreq
	request := Request{}
	reqList := make([]Req, 1)
	reqList[0] = req
	request.Req = reqList
	request.Req_module = "imms"
	request.Server = "mmsda"
	return &request
}
Esempio n. 3
0
func packCQ(paramMap map[string]string) *Request {
	sid := make([]uint32, 1)
	sid[0] = 2014
	urlPack := UrlPackCQ{} //UrlPack{voice_search: 2}
	urlPack.Voice_search = 2
	if _, ok := paramMap["speachid"]; ok {
		speachid, err := strconv.Atoi(paramMap["speachid"])
		if err == nil {
			urlPack.Speachid = int32(speachid)
		}

	}
	enc := mahonia.NewEncoder("gbk")
	if _, ok := paramMap["lq"]; ok {
		if paramMap["character"] == "utf-8" || paramMap["character"] == "utf8" {
			mmsuse := enc.ConvertString(paramMap["lq"])
			urlPack.Mmsuse = "lq@" + mmsuse
		} else {
			urlPack.Mmsuse = "lq@" + paramMap["lq"]
		}
	} else {
		if _, okbaidu := paramMap["baiduid"]; okbaidu {
			urlPack.Baiduid = paramMap["baiduid"]
		}
	}

	byteUrlPack, _ := mcpack.Marshal(urlPack)
	normalreq := Normalreq{} //{sid: sid, rsse_num: 10, rsse_type: 139}
	normalreq.Sid = sid
	normalreq.Rsse_num = 10
	normalreq.Rsse_type = 139
	normalreq.UrlPack = byteUrlPack
	if paramMap["character"] == "utf-8" || paramMap["character"] == "utf8" {
		//enc := mahonia.NewEncoder("gbk")
		gbk := enc.ConvertString(paramMap["query"])
		normalreq.Word = gbk
	} else {
		normalreq.Word = paramMap["query"]
	}

	req := Req{}
	req.Cmd = 0
	req.Cmd64 = 0
	cmdreq := make([]uint64, 2)
	cmdreq[0] = 0
	cmdreq[1] = 2097152
	req.Cmdreq = cmdreq
	req.Normalreq = normalreq
	request := Request{}
	reqList := make([]Req, 1)
	reqList[0] = req
	request.Req = reqList
	request.Req_module = "imms"
	request.Server = "mmsda"
	return &request
}
Esempio n. 4
0
func main() {
	enc := mahonia.NewEncoder("gbk")
	gbk := enc.ConvertString("失落伐克欧洲杯")
	fmt.Println(gbk)

	//enc = mahonia.NewEncoder("utf8")
	dec := mahonia.NewDecoder("gbk")
	utf8 := dec.ConvertString(gbk)
	fmt.Println(utf8)
}
Esempio n. 5
0
func ExportCsv(columnNames []string, sql string, params []interface{}, db *sql.DB) ([]byte, error) {

	type TmpString struct {
		Value string
	}

	enc := mahonia.NewEncoder("gbk")

	rows, err := db.Query(sql, params...)

	if err != nil {
		return []byte{}, err
	}

	var buf = []byte{}

	for index, name := range columnNames {
		buf = append(buf, []byte(enc.ConvertString(name))...)
		if index != len(columnNames)-1 {
			buf = append(buf, []byte(";")...)
		}
	}

	buf = append(buf, []byte("\n")...)

	columns, err := rows.Columns()

	for rows.Next() {
		objects := []*TmpString{}
		tmpString := []interface{}{}

		for i := 0; i < len(columns); i++ {
			var tmp = new(TmpString)
			objects = append(objects, tmp)
			tmpString = append(tmpString, &tmp.Value)
		}

		err = PutRecord(rows, tmpString...)

		if err != nil {
			return nil, err
		}

		for index, object := range objects {
			buf = append(buf, []byte(enc.ConvertString(object.Value))...)
			if index != len(objects)-1 {
				buf = append(buf, []byte(";")...)
			}
		}

		buf = append(buf, []byte("\n")...)
	}

	return buf, nil
}
Esempio n. 6
0
/*
  getByteSlice converts value to byte slice according to given encoding and return
  a slice that is length equals to numberOfBytes or less if the string is shorter than
  numberOfBytes
*/
func (dt *DbfTable) convertToByteSlice(value string, numberOfBytes int) (s []byte) {
	e := mahonia.NewEncoder(dt.fileEncoding)
	b := []byte(e.ConvertString(value))

	if len(b) <= numberOfBytes {
		s = b
	} else {
		s = b[0:numberOfBytes]
	}
	return
}
Esempio n. 7
0
func (dt *DbfTable) getNormalizedFieldName(name string) (s string) {
	e := mahonia.NewEncoder(dt.fileEncoding)
	b := []byte(e.ConvertString(name))

	if len(b) > 10 {
		b = b[0:10]
	}

	d := mahonia.NewDecoder(dt.fileEncoding)
	s = d.ConvertString(string(b))

	return
}
Esempio n. 8
0
// @Title Get Error Time Percent
// @Description get rangetime to caculate errtime percent
// @Param       starttime    query   string    "service starttime"
// @Param       endtime      query   string    "service endtime"
// @Param       ns           query   string    "ns name"
// @Success 200 {object} models.FaultData
// @Failure 403 body  is empty
// @router /
func (c *DownController) GetErrPercent() {
	var starttime int64
	var endtime int64
	var ns string
	var err error
	var result models.Result

	ns = c.GetString("ns")
	nslist := strings.Split(ns, ".")
	if nslist[len(nslist)-1] != "com" {
		result.Success = false
		result.Data = "ns is not correct"
		c.Data["json"] = result
		c.Abort("400")
	}

	now := time.Now()
	days := time.Date(now.Year(), now.Month()+1, 0, 0, 0, 0, 0, time.UTC).Day()
	next_time := now.AddDate(0, 0, days)

	start_month := time.Date(now.Year(), now.Month(), 1, 0, 0, 0, 0, time.Local)
	end_month := time.Date(next_time.Year(), next_time.Month(), 1, 0, 0, 0, 0, time.Local)

	starttime, err = c.GetInt64("starttime")
	if err != nil {
		starttime = start_month.Unix()
	}

	endtime, err = c.GetInt64("endtime")
	if err != nil {
		endtime = end_month.Unix()
	}

	detail, err := models.GetErrTimeDetail(starttime, endtime, ns)
	c.Ctx.Output.Header("Content-Disposition", "attachment;filename=myfilename.csv")
	c.Ctx.Output.Header("Content-Type", "application/CSV")
	result2 := bytes.NewBufferString("")
	csvResult := csv.NewWriter(result2)

	csvResult.Write([]string{"影响业务", "发生时间", "事故内容", "影响面", "影响时长(min)", "事故原因", "对应方案", "未来对策", "定级"})
	for _, oneDetail := range detail {
		csvResult.Write(oneDetail.GenCsv())
	}
	csvResult.Flush()

	enc := mahonia.NewEncoder("gbk")
	output := enc.ConvertString(result2.String())

	c.Ctx.Output.Body([]byte(output))
	c.ServeJson()
}
Esempio n. 9
0
// 修改DNS
func changeDNS(nic, dns string) error {
	var cmd = fmt.Sprintf(`netsh interface ipv4 set dnsservers name="%s" static %s primary`, nic, dns)
	enc := mahonia.NewEncoder("gbk")
	cmd = enc.ConvertString(cmd)
	utils.Logger.Debug(cmd)
	if output, err := utils.ExecCmd(scriptFile, cmd); err != nil {
		utils.Logger.Error(err.Error())
		return nil
	} else {
		utils.Logger.Debug(string(output))
	}

	return nil
}
Esempio n. 10
0
// 修改 IP
func changeIP(nic, ip, netmask, gateway string) error {
	var cmd = fmt.Sprintf(`netsh interface ipv4 set address name="%s" source=static addr=%s mask=%s gateway=%s`, nic, ip, netmask, gateway)
	enc := mahonia.NewEncoder("gbk")
	cmd = enc.ConvertString(cmd)
	utils.Logger.Debug(cmd)
	if output, err := utils.ExecCmd(scriptFile, cmd); err != nil {
		utils.Logger.Error(err.Error())
		return nil
	} else {
		utils.Logger.Debug(string(output))
	}

	return nil
}
Esempio n. 11
0
func main() {
	sid := make([]uint32, 1)
	sid[0] = 2014
	urlPack := UrlPack{} //UrlPack{voice_search: 2}
	urlPack.Voice_search = 2
	byteUrlPack, _ := mcpack.Marshal(urlPack)
	normalreq := Normalreq{} //{sid: sid, rsse_num: 10, rsse_type: 139}
	normalreq.Sid = sid
	normalreq.Rsse_num = 10
	normalreq.Rsse_type = 139
	normalreq.UrlPack = byteUrlPack
	enc := mahonia.NewEncoder("gbk")
	gbk := enc.ConvertString("你好")
	normalreq.Word = gbk

	req := Req{}
	req.Cmd = 0
	req.Cmd64 = 0
	cmdreq := make([]uint64, 2)
	cmdreq[0] = 0
	cmdreq[1] = 2097152
	req.Cmdreq = cmdreq
	req.Normalreq = normalreq
	request := Request{}
	reqList := make([]Req, 1)
	reqList[0] = req
	request.Req = reqList
	request.Req_module = "imms"
	request.Server = "mmsda"
	mcRequet, _ := mcpack.Marshal(request)
	fmt.Println(len(mcRequet))
	conn, err := mcpackrpc.Dial("tcp", "10.144.21.41:2987")
	if err != nil {
		fmt.Println(err)
	}
	fmt.Println("conn:", conn)
	connn, _ := conn.(io.ReadWriteCloser)
	clien := mcpackrpc.NewClientCodec(connn)
	fmt.Println("clien:", clien)
}
Esempio n. 12
0
func writeOutput(file *FilePath, pairTerms []*term.PairTerm, outputFreq int) {
	ext := filepath.Ext(file.filename)
	pos := strings.Index(file.filename, ext)
	base := string(file.filename[:pos])
	outfile := base + ".csv"
	//fmt.Println("Outfile name:", outfile)
	outfile = filepath.Join(file.folder, outfile)

	//fmt.Println("Total words: ", len(pairTerms))
	format := "%s,%d,%f\n"
	str := "短语,频率,分数\n"
	for _, pt := range pairTerms {
		if pt.GetFrequency() > outputFreq {
			str += fmt.Sprintf(format, pt.GetKey(), pt.GetFrequency(), pt.GetScore())
		}
	}

	//fmt.Println(str)
	encoder := mahonia.NewEncoder(Encoding)
	str = encoder.ConvertString(str)
	util.WriteFile(outfile, str)
	log.Printf("短语存储到文件: %s", outfile)
}
Esempio n. 13
0
func main() {
	flag.Parse()

	var r io.Reader = os.Stdin
	var w io.Writer = os.Stdout

	if *from != "utf-8" {
		decode := mahonia.NewDecoder(*from)
		if decode == nil {
			log.Fatalf("Could not create decoder for %s", *from)
		}
		r = decode.NewReader(r)
	}

	if *to != "utf-8" {
		encode := mahonia.NewEncoder(*to)
		if encode == nil {
			log.Fatalf("Could not create decoder for %s", *to)
		}
		w = encode.NewWriter(w)
	}

	io.Copy(w, r)
}
Esempio n. 14
0
func main() {
	enc := mahonia.NewEncoder("gbk")
	fmt.Println(enc.ConvertString("hello,世界"))
}
Esempio n. 15
0
func NewFromFile(fileName string, fileEncoding string) (table *DbfTable, err error) {
	s, err := readFile(fileName)

	if err != nil {
		return nil, err
	}

	// Create and pupulate DbaseTable struct
	dt := new(DbfTable)

	dt.fileEncoding = fileEncoding
	dt.encoder = mahonia.NewEncoder(fileEncoding)
	dt.decoder = mahonia.NewDecoder(fileEncoding)

	// read dbase table header information
	dt.fileSignature = s[0]
	dt.updateYear = s[1]
	dt.updateMonth = s[2]
	dt.updateDay = s[3]
	dt.numberOfRecords = uint32(s[4]) | (uint32(s[5]) << 8) | (uint32(s[6]) << 16) | (uint32(s[7]) << 24)
	dt.numberOfBytesInHeader = uint16(s[8]) | (uint16(s[9]) << 8)
	dt.lengthOfEachRecord = uint16(s[10]) | (uint16(s[11]) << 8)

	// create fieldMap to taranslate field name to index
	dt.fieldMap = make(map[string]int)

	// Number of fields in dbase table
	dt.numberOfFields = int((dt.numberOfBytesInHeader - 1 - 32) / 32)

	// populate dbf fields
	for i := 0; i < int(dt.numberOfFields); i++ {
		offset := (i * 32) + 32

		fieldName := strings.Trim(dt.encoder.ConvertString(string(s[offset:offset+10])), string([]byte{0}))
		dt.fieldMap[fieldName] = i

		var err error

		switch s[offset+11] {
		case 'C':
			err = dt.AddTextField(fieldName, s[offset+16])
		case 'N':
			err = dt.AddNumberField(fieldName, s[offset+16], s[offset+17])
		case 'F':
			err = dt.AddFloatField(fieldName, s[offset+16], s[offset+17])
		case 'L':
			err = dt.AddBooleanField(fieldName)
		case 'D':
			err = dt.AddDateField(fieldName)
		}

		// Check return value for errors
		if err != nil {
			return nil, err
		}

		//fmt.Printf("Field name:%v\n", fieldName)
		//fmt.Printf("Field data type:%v\n", string(s[offset+11]))
		//fmt.Printf("Field length:%v\n", s[offset+16])
		//fmt.Println("-----------------------------------------------")
	}

	//fmt.Printf("DbfReader:\n%#v\n", dt)
	//fmt.Printf("DbfReader:\n%#v\n", int(dt.Fields[2].fieldLength))

	//fmt.Printf("num records in table:%v\n", (dt.numberOfRecords))
	//fmt.Printf("lenght of each record:%v\n", (dt.lengthOfEachRecord))

	// Since we are reading dbase file from the disk at least at this
	// phase changing schema of dbase file is not allowed.
	dt.dataEntryStarted = true

	// set DbfTable dataStore slice that will store the complete file in memory
	dt.dataStore = s

	return dt, nil
}
Esempio n. 16
0
畅酎抹亟赤装宁。

*/

package elang

import (
	"bytes"
	"io"

	"github.com/axgle/mahonia"
)

var (
	// 正转 u | u2j | g2u = u | u2e
	u2g = mahonia.NewEncoder("gbk")
	j2u = mahonia.NewDecoder("euc-jp")

	// 逆转 u | u2g | j2u = u | e2u
	u2j = mahonia.NewEncoder("euc-jp")
	g2u = mahonia.NewDecoder("gbk")
)

type Decoder struct {
	r    io.Reader
	u2jw io.Writer
	g2ur io.Reader
}

func (this *Decoder) Read(p []byte) (n int, err error) {
	io.Copy(this.u2jw, this.r)
Esempio n. 17
0
func main() {
	sid := make([]uint32, 1)
	sid[0] = 2014
	urlPack := UrlPack{} //UrlPack{voice_search: 2}
	urlPack.Voice_search = 2
	byteUrlPack, _ := mcpack.Marshal(urlPack)
	normalreq := Normalreq{} //{sid: sid, rsse_num: 10, rsse_type: 139}
	normalreq.Sid = sid
	normalreq.Rsse_num = 10
	normalreq.Rsse_type = 139
	normalreq.UrlPack = byteUrlPack
	//	cd, err := iconv.Open("gbk", "utf-8")
	//	if err != nil {
	//		fmt.Println(err)
	//	}
	//	gbk := cd.ConvString("失落伐克欧洲杯")
	enc := mahonia.NewEncoder("gbk")
	gbk := enc.ConvertString("失落伐克欧洲杯")
	normalreq.Word = gbk
	//jsonnormalreq, _ := json.Marshal(normalreq)
	//fmt.Println(string(jsonnormalreq))

	req := Req{}
	req.Cmd = 0
	req.Cmd64 = 0
	cmdreq := make([]uint64, 2)
	cmdreq[0] = 0
	cmdreq[1] = 2097152
	req.Cmdreq = cmdreq
	//req.Sub_cmdreq = cmdreq
	req.Normalreq = normalreq
	request := Request{}
	reqList := make([]Req, 1)
	reqList[0] = req
	request.Req = reqList
	request.Req_module = "imms"
	request.Server = "mmsda"
	///////////////////////
	//	jsonrequest, _ := json.Marshal(request)
	//	fmt.Println(string(jsonrequest))
	//	content, _ := mcpack.Marshal(request)
	//	fmt.Println(hex.Dump(content))
	//	msg := Request{}
	//	mcpack.Unmarshal(content, &msg)
	//	jsonMsg, _ := json.Marshal(msg)
	//	fmt.Println(string(jsonMsg))
	//return
	/////////////////////
	server := []string{HostAdd}
	client := mcpacknpc.NewClient(server)
	reply := new(Reply)
	now := time.Now()
	nanos := now.UnixNano()
	num := make(chan int, 64)
	for i := 0; i < 300000; i++ {
		num <- i
		go mmsda(client, &request, reply, num)
	}
	end := now.UnixNano()
	fmt.Println("time", (end - nanos))
	//	client.Call(request, reply)
	//	fmt.Println(reply)
	//	jsonother, _ := json.Marshal(reply)
	//	fmt.Println(string(jsonother))
	//	dec := mahonia.NewDecoder("gbk")
	//	fmt.Println(dec.ConvertString(reply.Result[0].Normal.Danormalanalysis.Voiceguidesidentify.Fullreplace_query))
	//fmt.Println(reply.Result[0].Normal.Danormalanalysis.Voiceguidesidentify.Fullreplace_query)

}
Esempio n. 18
0
//utf-8转gbk
func Utf8ToGBK(str string) string {
	//字符集转换
	enc := mahonia.NewEncoder("gbk")
	return enc.ConvertString(str)
}
Esempio n. 19
0
// Create a new dbase table from scratch
func New(encoding string) (table *DbfTable) {

	// Create and populate DbaseTable struct
	dt := new(DbfTable)

	dt.fileEncoding = encoding
	dt.encoder = mahonia.NewEncoder(encoding)
	dt.decoder = mahonia.NewDecoder(encoding)

	// set whether or not this table has been created from scratch
	dt.createdFromScratch = true

	// read dbase table header information
	dt.fileSignature = 0x03
	dt.updateYear = byte(time.Now().Year() % 100)
	dt.updateMonth = byte(time.Now().Month())
	dt.updateDay = byte(time.Now().YearDay())
	dt.numberOfRecords = 0
	dt.numberOfBytesInHeader = 32
	dt.lengthOfEachRecord = 0

	// create fieldMap to taranslate field name to index
	dt.fieldMap = make(map[string]int)

	// Number of fields in dbase table
	dt.numberOfFields = int((dt.numberOfBytesInHeader - 1 - 32) / 32)

	s := make([]byte, dt.numberOfBytesInHeader)

	//fmt.Printf("number of fields:\n%#v\n", numberOfFields)
	//fmt.Printf("DbfReader:\n%#v\n", int(dt.Fields[2].fieldLength))

	//fmt.Printf("num records in table:%v\n", (dt.numberOfRecords))
	//fmt.Printf("lenght of each record:%v\n", (dt.lengthOfEachRecord))

	// Since we are reading dbase file from the disk at least at this
	// phase changing schema of dbase file is not allowed.
	dt.dataEntryStarted = false

	// set DbfTable dataStore slice that will store the complete file in memory
	dt.dataStore = s

	dt.dataStore[0] = dt.fileSignature
	dt.dataStore[1] = dt.updateYear
	dt.dataStore[2] = dt.updateMonth
	dt.dataStore[3] = dt.updateDay

	// no MDX file (index upon demand)
	dt.dataStore[28] = 0x00

	// set dbase language driver
	// Huston we have problem!
	// There is no easy way to deal with encoding issues. At least at the moment
	// I will try to find archaic encoding code defined by dbase standard (if there is any)
	// for given encoding. If none match I will go with default ANSI.
	//
	// Despite this flag in set in dbase file, I will continue to use provide encoding for
	// the everything except this file encoding flag.
	//
	// Why? To make sure at least if you know the real encoding you can process text accordingly.

	if code, ok := encodingTable[lookup[encoding]]; ok {
		dt.dataStore[28] = code
	} else {
		dt.dataStore[28] = 0x57 // ANSI
	}

	return dt
}
Esempio n. 20
0
func main() {
	sid := make([]uint32, 1)
	sid[0] = 2014
	urlPack := UrlPack{} //UrlPack{voice_search: 2}
	urlPack.Voice_search = 2
	byteUrlPack, err := mcpack.Marshal(urlPack)
	normalreq := Normalreq{} //{sid: sid, rsse_num: 10, rsse_type: 139}
	normalreq.Sid = sid
	normalreq.Rsse_num = 10
	normalreq.Rsse_type = 139
	normalreq.UrlPack = byteUrlPack
	//	cd, err := iconv.Open("gbk", "utf-8")
	//	if err != nil {
	//		fmt.Println(err)
	//	}
	//	gbk := cd.ConvString("失落伐克欧洲杯")
	enc := mahonia.NewEncoder("gbk")
	gbk := enc.ConvertString("失落伐克欧洲杯")
	fmt.Println(gbk)
	normalreq.Word = "失落伐克欧洲杯" //gbk
	//jsonnormalreq, _ := json.Marshal(normalreq)
	//fmt.Println(string(jsonnormalreq))

	req := Req{}
	req.Cmd = 0
	req.Cmd64 = 0
	cmdreq := make([]uint64, 2)
	cmdreq[0] = 0
	cmdreq[1] = 2097152
	req.Cmdreq = cmdreq
	//req.Sub_cmdreq = cmdreq
	req.Normalreq = normalreq
	request := Request{}
	reqList := make([]Req, 1)
	reqList[0] = req
	request.Req = reqList
	request.Req_module = "imms"
	request.Server = "mmsda"

	//====================

	//jsonrequest, _ := json.Marshal(request)
	//fmt.Println(string(jsonrequest))
	cont, err := mcpack.Marshal(request)
	if err != nil {
		fmt.Println("mcpack.Marshal====", err)
	}

	nh, err := nshead.Dial(HostAdd)
	if err != nil {
		fmt.Println("lianjie", err)
	}
	defer nh.Close()
	//nh.Provider = "noahdt"
	nh.MagicNum = nshead.DefaultMagicNum

	_, err = nh.Write(cont)

	if err != nil {
		fmt.Println("Write", err)
		return
	}

	fmt.Println(hex.Dump(cont))

	msg := Request{}
	err = mcpack.Unmarshal(cont, &msg)
	if err != nil {
		fmt.Println("==============")
	}
	strMag, _ := json.Marshal(msg)
	fmt.Println("Unmarshal", string(strMag))
	//return
	data, err := nh.ReadBody()
	if err != nil {
		fmt.Println("ReadBody", err)
	}

	reply := new(interface{})
	err = mcpack.Unmarshal(data, reply)
	fmt.Printf("%p%v\n", reply, reply)
}
Esempio n. 21
0
package pinyin

import (
	"github.com/axgle/mahonia"
)

//define func UTF8ToGBK by using mahonia package
var enc = mahonia.NewEncoder("gbk")

func UTF8ToGBK(s string) string {
	return enc.ConvertString(s)
}