jypkg/public/convert.go

package public

import (
	"encoding/gob"
	"os"
	"strconv"
	"strings"
	"sync"
)

type Convert struct {
	lock      *sync.RWMutex
	lockun    *sync.RWMutex
	mapping   map[rune]rune
	unmapping map[rune]rune
}

//
func NewConvert() *Convert {
	return &Convert{
		lock:      new(sync.RWMutex),
		lockun:    new(sync.RWMutex),
		mapping:   make(map[rune]rune),
		unmapping: make(map[rune]rune),
	}
}

//支持动态切换mapping文件
func (c *Convert) LoadMapping(mappingfilepath string) error {
	c.lock.Lock()
	defer c.lock.Unlock()
	c.lockun.Lock()
	defer c.lockun.Unlock()
	fi, err := os.Open(mappingfilepath)
	if err != nil {
		return err
	}
	mapping := make(map[string]string)
	err = gob.NewDecoder(fi).Decode(&mapping)
	if err != nil {
		return err
	}
	fi.Close()
	for k, v := range mapping {
		key_r, _ := strconv.ParseInt(k[3:], 16, 32)
		value_r, _ := strconv.ParseInt(v[3:], 16, 32)
		c.mapping[rune(value_r)] = rune(key_r)
		c.unmapping[rune(key_r)] = rune(value_r)
	}
	return nil
}

//转换
func (c *Convert) DoConvert(src string) string {
	c.lock.RLock()
	defer c.lock.RUnlock()
	return strings.Map(func(r rune) rune {
		if v, ok := c.mapping[r]; ok {
			return v
		} else {
			return r
		}
	}, src)
}

func (c *Convert) UnConvert(src string) string {
	c.lockun.RLock()
	defer c.lockun.RUnlock()
	return strings.Map(func(r rune) rune {
		if v, ok := c.unmapping[r]; ok {
			return v
		} else {
			return r
		}
	}, src)
}