func (i *Instances) ExportDel(sess, inst, method string, retval int) error {
	i.lck.Lock()
	defer i.lck.Unlock()
	s, found := i.Insts[sess]
	if !found {
		return e.New(ErrSessionNotFound)
	}
	in, found := s.Insts[inst]
	if !found {
		return e.New(ErrInstanceNotFound)
	}
	retvals, found := in.Export()[method]
	if !found {
		return e.New(ErrMethodNotFound)
	}
	_, found = retvals[retval]
	if !found {
		return e.New(ErrReturnValueNotFound)
	}
	delete(retvals, retval)
	if len(retvals) == 0 {
		delete(in.Export(), method)
	}
	return nil
}

func NewMongoDb(rawurl, collection string, safe *mgo.Safe, entry Entry, timeout time.Duration) (Storer, error) {
	var err error
	m := &MongoDb{}
	err = chkData(entry)
	if err != nil {
		return nil, e.Forward(err)
	}
	m.tentry = reflect.TypeOf(entry)
	if m.tentry.Kind() != reflect.Ptr {
		m.tentry = reflect.PtrTo(m.tentry)
	}
	m.session, err = mgo.DialWithTimeout(rawurl, timeout)
	if err != nil {
		return nil, e.New(err)
	}
	parsed, err := url.Parse(rawurl)
	if err != nil {
		return nil, e.New(err)
	}
	if safe == nil {
		safe = &mgo.Safe{}
	}
	m.session.SetSafe(safe)
	m.dbname = strings.Trim(parsed.Path, "/")
	m.db = m.session.DB(m.dbname)
	m.collection = collection
	m.c = m.db.C(collection)
	return m, nil
}

func (c *clone) Init(inst string) error {
	if c.Num <= 0 {
		return e.New("number of clones invalid")
	}
	if c.Session == nil {
		return e.New("nil Session")
	}
	if c.Num > c.MaxNum {
		return e.New("number of initial streams is greater than the maximun")
	}
	c.inst = inst
	c.once.Do(func() {
		c.conns = make([]connInst, 0, c.Num)
		log.ProtoLevel().Tag("gormethods", "client", "clone").Println("Init clones.")
		for i := 0; i < c.Num; i++ {
			conn, err := c.Session.NamedInstance(c.inst)
			if err != nil {
				log.ProtoLevel().Tag("gormethods", "client", "clone").Printf("New instance failed: %v.", err)
				continue
			}
			c.conns = append(c.conns, conn)
		}
	})
	return nil
}

func (i *Instances) Export(sess, inst string, exp *ToExport) error {
	i.lck.Lock()
	defer i.lck.Unlock()
	s, found := i.Insts[sess]
	if !found {
		return e.New(ErrSessionNotFound)
	}
	in, found := s.Insts[inst]
	if !found {
		return e.New(ErrInstanceNotFound)
	}
	m, ok := in.Instance().Type().MethodByName(exp.Method)
	if !ok {
		return e.New(ErrMethodNotFound)
	}
	if exp.RetvalPos >= m.Type.NumOut() {
		return e.New(ErrInvRetval)
	}
	retvals, found := in.Export()[exp.Method]
	if !found {
		retvals = make(map[int]*Export)
		in.Export()[exp.Method] = retvals
	}
	if exp.Export.Client == nil {
		return e.New(ErrInvClient)
	}
	retvals[exp.RetvalPos] = exp.Export
	return nil
}

//NewMulti creates a MultiLog
func NewMulti(vals ...interface{}) LogBackend {
	if len(vals)%2 != 0 {
		Fail(e.New("parameters must be in pair of LogBackend and Formatter"))
		return nil
	}
	l := len(vals) / 2
	mp := make([]LogBackend, 0, l)
	for i := 0; i < len(vals); i += 2 {
		bak, ok := vals[i].(LogBackend)
		if !ok {
			Fail(e.New("not a LogBackend"))
			return nil
		}
		f, ok := vals[i+1].(Formatter)
		if !ok {
			Fail(e.New("not a Formatter"))
			return nil
		}
		bak.F(f)
		mp = append(mp, bak)
	}
	return &MultiLog{
		mp: mp,
	}
}

func (a *Server) bind() (conn *net.UDPConn, err error) {
	if !a.NotMulticast && a.iface.Flags&net.FlagMulticast == net.FlagMulticast {
		gaddr, err := a.groupAddr()
		if err != nil {
			return nil, e.Forward(err)
		}
		conn, err = net.ListenMulticastUDP(a.Proto(), a.iface, gaddr)
		if err != nil {
			return nil, e.New(err)
		}
	} else {
		server, err := net.ResolveUDPAddr(a.Proto(), ":"+a.Port)
		if err != nil {
			return nil, e.New(err)
		}
		conn, err = net.ListenUDP(a.Proto(), server)
		if err != nil {
			return nil, e.New(err)
		}
	}
	a.ipver(conn.LocalAddr())
	_, a.Port, err = utilNet.SplitHostPort(conn.LocalAddr().String())
	if err != nil {
		return nil, e.Forward(err)
	}
	return
}

// Put inserts in the database the struct in v, v must have the fild _id and
// the field _rev both strings. Like the TestStruct struct.
func (c *Couch) Put(v interface{}) (id, rev string, err error) {
	data, err := json.Marshal(v)
	if err != nil {
		return "", "", e.Push(err, "can't serialize the data")
	}
	id = grepId(data)
	if id == "" {
		return "", "", e.New("document have no id")
	}
	code, resp, err := c.put(id, "", data)
	if err != nil && code == 409 {
		return "", "", e.Push(err, ErrDocConflict)
	} else if err != nil {
		return "", "", e.Push(err, "can't put the document")
	}
	if code == http.StatusCreated {
		ir := new(response)
		err := json.Unmarshal(resp, ir)
		if err != nil {
			return "", "", e.Push(e.Push(err, "can't desserialize returned data"), "can't put the document")
		}
		if !ir.Ok {
			return "", "", e.New("put failed")
		}
		return ir.Id, ir.Rev, nil
	}
	return "", "", e.Push(e.Push(err, e.New("received wrong response code, %v", code)), "can't put the document")
}

// PingHttp connect a http or https server and try to
// receive something. If the server return a code different
// of 2xx, it will fail. Ignores insecure certificates.
func PingHttp(url *url.URL) error {
	resp, err := httpClient.Get(url.String())
	if e.Contains(err, "connection refused") {
		return e.Push(e.New(err), "get failed: connection refused")
	} else if err != nil {
		return e.Push(e.New(err), "get failed")
	}
	defer resp.Body.Close()
	buf := make([]byte, 4096)
	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
		n, err := resp.Body.Read(buf)
		if err != nil && err != io.EOF {
			return e.Forward(err)
		}
		buf = buf[:n]
		//status.Log(status.Protocol, "PingHttp status code is %v and received it from server: %v", resp.StatusCode, string(buf))
		log.ProtoLevel().Printf("PingHttp status code is %v and received it from server: %v", resp.StatusCode, string(buf))
		return e.New("returned status code %v, expected 2xx", resp.StatusCode)
	}
	_, err = resp.Body.Read(buf)
	if err != nil && err != io.EOF {
		return e.Forward(err)
	}
	return nil
}

// TypeOf returns the type of val. If samething wrong occur return a error.
// This functoin don't panic.
func TypeOf(val reflect.Value) (t reflect.Type, err error) {
	defer func() {
		r := recover()
		if r != nil {
			switch v := r.(type) {
			case error:
				err = e.Forward(v)
			case string:
				if strings.Contains(v, "runtime error") {
					panic(r)
				}
				err = e.New(v)
			default:
				err = e.New("unable to type switch the recover data")
			}
		}
	}()
	t = val.Type()
	if t.Kind() == reflect.Interface {
		if val.Elem().IsValid() {
			t = val.Elem().Type()
		} else {
			err = e.New("invalid interface")
		}
	}
	return
}

func (t *transaction) Put(key string, data interface{}) error {
	if !t.write {
		return e.New(ErrReadOnly)
	}
	if key == "" {
		return e.New(ErrInvKey)
	}
	t.m[key] = data
	idx := *t.idx
	defer func() {
		*t.idx = idx
	}()
	if len(idx) == 0 {
		idx = append(idx, key)
		return nil
	}
	i := searchString(idx, key)
	if i >= len(idx) || idx[i] != key {
		if i+1 > len(idx) {
			idx = append(idx, key)
			return nil
		}
		idx = append(idx[:i], append([]string{key}, idx[i:]...)...)
	}
	return nil
}

// Delete deletes from database the id id with rev revision.
// If rev is empty Delete deletes the last revision.
func (c *Couch) Delete(id, rev string) (string, error) {
	if rev == "" {
		revision := new(idRev)
		err := c.Get(id, "", revision)
		if e.Equal(err, ErrCantGetDoc) {
			return "", e.Push(err, ErrDocDontExist)
		} else if err != nil {
			return "", e.Push(err, "not deleted")
		}
		rev = revision.Rev
	}
	rev = "rev=" + rev
	code, resp, err := c.delete(id, rev, nil)
	if err != nil && code == 404 {
		return "", e.Push(err, ErrDocDontExist)
	} else if err != nil {
		return "", e.Push(err, "not deleted")
	}
	if code != http.StatusOK && code != http.StatusAccepted {
		return "", e.New("can't delete the document, wrong code: %v", code)
	}
	dr := new(response)
	err = json.Unmarshal(resp, dr)
	if err != nil {
		return "", e.Push(e.Push(err, "can't desserialize returned data"), "can't put the document")
	}
	if !dr.Ok {
		return "", e.New("delete failed")
	}
	if dr.Id != id {
		return "", e.New("response with the wrong id")
	}
	return dr.Rev, nil
}

func (c *client) do(method, path, params string, body []byte) (int, []byte, error) {
	url := utilUrl.Copy(c.url)
	url.Path += path
	url.RawQuery = params

	var buf io.Reader
	if len(body) > 0 {
		buf = bytes.NewBuffer(body)
	}

	req, err := http.NewRequest(method, url.String(), buf)
	if err != nil {
		return 0, nil, e.New("can't create request")
	}

	if c.url.User != nil {
		req.Header.Set("Authorization", authorizationHeader(url.User.String()))
	}
	req.Header.Set("Content-Type", "application/json")

	resp, err := HttpClient.Do(req)
	if err != nil {
		return 0, nil, e.Push(err, "can't put")
	}
	defer resp.Body.Close()

	if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
		return resp.StatusCode, nil, e.New("wrong status code - %v: %v", resp.StatusCode, resp.Status)
	}

	var data []byte
	data, _ = ioutil.ReadAll(resp.Body)

	return resp.StatusCode, data, nil
}

func (c *Constructors) Construct(name string, args ...interface{}) (reflect.Value, error) {
	c.lck.Lock()
	defer c.lck.Unlock()
	con, found := c.constructors[name]
	if !found {
		t, err := types.GetType(name)
		if err != nil {
			return reflect.Value{}, e.New(ErrTypeNotFound)
		}
		return types.Make(t), nil
	}
	vals := make([]reflect.Value, 0, len(args))
	for _, arg := range args {
		vals = append(vals, reflect.ValueOf(arg))
	}
	retvals := con.Call(vals)
	if len(retvals) != 2 {
		return reflect.Value{}, e.New(ErrInvReturn)
	}
	if retvals[1].Interface() != nil {
		err, ok := retvals[1].Interface().(error)
		if !ok {
			return reflect.Value{}, e.New(ErrInvReturn)
		}
		if err != nil {
			return reflect.Value{}, e.Forward(err)
		}
	}
	return retvals[0], nil
}

func (i *Intface) getInt() error {
	if i.Interface != "" && i.iface == nil {
		ints, err := net.Interfaces()
		if err != nil {
			return e.New(err)
		}
		for _, in := range ints {
			if in.Name == i.Interface {
				i.iface = &in
				return nil
			}
		}
		return e.New("none interface with this name")
	} else if i.Interface == "" && i.iface == nil {
		ints, err := net.Interfaces()
		if err != nil {
			return e.New(err)
		}
		var intName string
		for _, in := range ints {
			if in.Flags&net.FlagMulticast == net.FlagMulticast || in.Flags&net.FlagBroadcast == net.FlagBroadcast || in.Flags&net.FlagBroadcast == net.FlagBroadcast {
				_, intName = getInterface(in)
				if intName == "" {
					continue
				}
				i.Interface = intName
				i.iface = &in
				break
			}
		}
	}
	return nil
}

// NewStdFormatter crete a new formatter.
func NewStdFormatter(delim, tmpl string, entry Entry, values map[string]interface{}, timeformat string) (Formatter, error) {
	if delim == "" {
		return nil, e.New("invalid delimitator")
	}
	if tmpl == "" {
		return nil, e.New("invalid template")
	}
	if entry == nil {
		return nil, e.New("invalid entry")
	}
	if values == nil {
		return nil, e.New("invalid values")
	}
	if timeformat == "" {
		timeformat = TimeDateFormat
	}
	return &StdFormatter{
		Delim:      []byte(delim),
		Tmpl:       []byte(tmpl),
		E:          entry,
		Map:        values,
		Idx:        mkindex(entry),
		TimeFormat: timeformat,
	}, nil
}

func makeFunction(f *Func) (*Function, error) {
	var args []*Argument
	if len(f.Params.Arguments) >= 1 {
		args = f.Params.Arguments[0]
	}
	var results []*Argument
	if len(f.Params.Arguments) >= 2 {
		results = f.Params.Arguments[1]
	}
	found := -1
	for i, r := range results {
		if r.Type == "error" {
			found = i
		}
	}
	if found >= 0 && found != len(results)-1 {
		return nil, e.New("one error must be the last result")
	}
	named := false
	for i, r := range results {
		if len(r.Names) > 0 && i == 0 {
			named = true
		}
		if len(r.Names) == 0 && named {
			return nil, e.New("all results must be named")
		} else if len(r.Names) > 0 && !named {
			return nil, e.New("all results must be unnamed")
		}
		if r.Type == "error" && len(r.Names) > 0 && r.Names[len(r.Names)-1] != "err" {
			return nil, e.New("last error must be named err")
		}
	}
	if !named {
		for i, r := range results {
			if r.Type == "error" {
				r.Names = []string{"err"}
				continue
			}
			r.Names = []string{fmt.Sprintf("arg%v", i)}
		}
	}
	for i, arg := range args {
		for j, name := range arg.Names {
			if name == "_" {
				arg.Names[j] = "param" + strconv.Itoa(i) + strconv.Itoa(j)
			}
		}
	}
	function := &Function{
		Name:      f.Name,
		RecvVar:   f.Recv,
		RecvType:  f.RecvType,
		Arguments: args,
		Results:   results,
		ReturnErr: found >= 0,
		Comments:  f.Comments,
	}
	return function, nil
}

// Check if a tag is formed with the corrects characters
func CheckTag(tag string) error {
	for _, v := range tag {
		if !u.IsLetter(v) && !unicode.IsDigit(v) && v != ' ' && v != '-' && v != '_' && v != '.' && v != '/' && v != ':' {
			return e.Push(e.New(ErrInvalidTagChar), e.New("the character '%v' is invalid", string([]byte{byte(v)})))
		}
	}
	return nil
}

func CheckDomain(domain string) error {
	for _, v := range domain {
		if !uni.IsLetter(v) && !unicode.IsDigit(v) && v != '.' {
			return e.Push(e.New("invalid domain name"), e.New("the character '%v' in redirect is invalid", string([]byte{byte(v)})))
		}
	}
	return nil
}

func CheckObjectName(name string) error {
	for _, v := range name {
		if !uni.IsLetter(v) && !unicode.IsDigit(v) && v != '-' && v != '_' && v != '*' && v != '{' && v != '}' && v != '/' && v != '.' && v != '[' && v != ']' {
			return e.Push(e.New(text.ErrInvCharacter), e.New("the character '%v' in object name is invalid", string([]byte{byte(v)})))
		}
	}
	return nil
}

// CheckHash the hash of a password.
func CheckHash(name string) error {
	for _, v := range name {
		if !uni.IsLetter(v) && !unicode.IsDigit(v) && v != '-' && v != '_' && v != '.' && v != '=' {
			return e.Push(e.New(text.ErrInvCharacter), e.New("the character '%v' in instance name is invalid", string([]byte{byte(v)})))
		}
	}
	return nil
}