hunk.code_window:   {
       "id": "store.sql_channel.get_channels_by_ids.not_found.app_error",
       "translation": "No channel found."
     },
     {
       "id": "store.sql_channel.get_deleted_by_name.existing.app_error",
       "translation": "Unable to find the existing deleted channel."
     },
     {
       "id": "store.sql_channel.get_deleted_by_name.missing.app_error",
       "translation": "No deleted channel exists with that name."
     },
     {
       "id": "store.sql_channel.get_for_post.app_error",
       "translation": "Unable to get the channel for the given post."
  
hunk.labels: keep keep keep keep replace replace replace replace replace replace replace replace keep keep keep
hunk.file_path: i18n/en.json
hunk.type: replace
file: package msgp
  
  import (
  	"bufio"
  	"encoding/base64"
  	"encoding/json"
  	"io"
  	"strconv"
  	"time"
  )
  
  var unfuns [_maxtype]func(jsWriter, []byte, []byte) ([]byte, []byte, error)
  
  func init() {
  
  	// NOTE(pmh): this is best expressed as a jump table,
  	// but gc doesn't do that yet. revisit post-go1.5.
  	unfuns = [_maxtype]func(jsWriter, []byte, []byte) ([]byte, []byte, error){
  		StrType:        rwStringBytes,
  		BinType:        rwBytesBytes,
  		MapType:        rwMapBytes,
  		ArrayType:      rwArrayBytes,
  		Float64Type:    rwFloat64Bytes,
  		Float32Type:    rwFloat32Bytes,
  		BoolType:       rwBoolBytes,
  		IntType:        rwIntBytes,
  		UintType:       rwUintBytes,
  		NilType:        rwNullBytes,
  		ExtensionType:  rwExtensionBytes,
  		Complex64Type:  rwExtensionBytes,
  		Complex128Type: rwExtensionBytes,
  		TimeType:       rwTimeBytes,
  	}
  }
  
  // UnmarshalAsJSON takes raw messagepack and writes
  // it as JSON to 'w'. If an error is returned, the
  // bytes not translated will also be returned. If
  // no errors are encountered, the length of the returned
  // slice will be zero.
  func UnmarshalAsJSON(w io.Writer, msg []byte) ([]byte, error) {
  	var (
  		scratch []byte
  		cast    bool
  		dst     jsWriter
  		err     error
  	)
  	if jsw, ok := w.(jsWriter); ok {
  		dst = jsw
  		cast = true
  	} else {
  		dst = bufio.NewWriterSize(w, 512)
  	}
  	for len(msg) > 0 && err == nil {
  		msg, scratch, err = writeNext(dst, msg, scratch)
  	}
  	if !cast && err == nil {
  		err = dst.(*bufio.Writer).Flush()
  	}
  	return msg, err
  }
  
  func writeNext(w jsWriter, msg []byte, scratch []byte) ([]byte, []byte, error) {
  	if len(msg) < 1 {
  		return msg, scratch, ErrShortBytes
  	}
  	t := getType(msg[0])
  	if t == InvalidType {
  		return msg, scratch, InvalidPrefixError(msg[0])
  	}
  	if t == ExtensionType {
  		et, err := peekExtension(msg)
  		if err != nil {
  			return nil, scratch, err
  		}
  		if et == TimeExtension {
  			t = TimeType
  		}
  	}
  	return unfuns[t](w, msg, scratch)
  }
  
  func rwArrayBytes(w jsWriter, msg []byte, scratch []byte) ([]byte, []byte, error) {
  	sz, msg, err := ReadArrayHeaderBytes(msg)
  	if err != nil {
  		return msg, scratch, err
  	}
  	err = w.WriteByte('[')
  	if err != nil {
  		return msg, scratch, err
  	}
  	for i := uint32(0); i < sz; i++ {
  		if i != 0 {
  			err = w.WriteByte(',')
  			if err != nil {
  				return msg, scratch, err
  			}
  		}
  		msg, scratch, err = writeNext(w, msg, scratch)
  		if err != nil {
  			return msg, scratch, err
  		}
  	}
  	err = w.WriteByte(']')
  	return msg, scratch, err
  }
  
  func rwMapBytes(w jsWriter, msg []byte, scratch []byte) ([]byte, []byte, error) {
  	sz, msg, err := ReadMapHeaderBytes(msg)
  	if err != nil {
  		return msg, scratch, err
  	}
  	err = w.WriteByte('{')
  	if err != nil {
  		return msg, scratch, err
  	}
  	for i := uint32(0); i < sz; i++ {
  		if i != 0 {
  			err = w.WriteByte(',')
  			if err != nil {
  				return msg, scratch, err
  			}
  		}
  		msg, scratch, err = rwMapKeyBytes(w, msg, scratch)
  		if err != nil {
  			return msg, scratch, err
  		}
  		err = w.WriteByte(':')
  		if err != nil {
  			return msg, scratch, err
  		}
  		msg, scratch, err = writeNext(w, msg, scratch)
  		if err != nil {
  			return msg, scratch, err
  		}
  	}
  	err = w.WriteByte('}')
  	return msg, scratch, err
  }
  
  func rwMapKeyBytes(w jsWriter, msg []byte, scratch []byte) ([]byte, []byte, error) {
  	msg, scratch, err := rwStringBytes(w, msg, scratch)
  	if err != nil {
  		if tperr, ok := err.(TypeError); ok && tperr.Encoded == BinType {
  			return rwBytesBytes(w, msg, scratch)
  		}
  	}
  	return msg, scratch, err
  }
  
  func rwStringBytes(w jsWriter, msg []byte, scratch []byte) ([]byte, []byte, error) {
  	str, msg, err := ReadStringZC(msg)
  	if err != nil {
  		return msg, scratch, err
  	}
  	_, err = rwquoted(w, str)
  	return msg, scratch, err
  }
  
  func rwBytesBytes(w jsWriter, msg []byte, scratch []byte) ([]byte, []byte, error) {
  	bts, msg, err := ReadBytesZC(msg)
  	if err != nil {
  		return msg, scratch, err
  	}
  	l := base64.StdEncoding.EncodedLen(len(bts))
  	if cap(scratch) >= l {
  		scratch = scratch[0:l]
  	} else {
  		scratch = make([]byte, l)
  	}
  	base64.StdEncoding.Encode(scratch, bts)
  	err = w.WriteByte('"')
  	if err != nil {
  		return msg, scratch, err
  	}
  	_, err = w.Write(scratch)
  	if err != nil {
  		return msg, scratch, err
  	}
  	err = w.WriteByte('"')
  	return msg, scratch, err
  }
  
  func rwNullBytes(w jsWriter, msg []byte, scratch []byte) ([]byte, []byte, error) {
  	msg, err := ReadNilBytes(msg)
  	if err != nil {
  		return msg, scratch, err
  	}
  	_, err = w.Write(null)
  	return msg, scratch, err
  }
  
  func rwBoolBytes(w jsWriter, msg []byte, scratch []byte) ([]byte, []byte, error) {
  	b, msg, err := ReadBoolBytes(msg)
  	if err != nil {
  		return msg, scratch, err
  	}
  	if b {
  		_, err = w.WriteString("true")
  		return msg, scratch, err
  	}
  	_, err = w.WriteString("false")
  	return msg, scratch, err
  }
  
  func rwIntBytes(w jsWriter, msg []byte, scratch []byte) ([]byte, []byte, error) {
  	i, msg, err := ReadInt64Bytes(msg)
  	if err != nil {
  		return msg, scratch, err
  	}
  	scratch = strconv.AppendInt(scratch[0:0], i, 10)
  	_, err = w.Write(scratch)
  	return msg, scratch, err
  }
  
  func rwUintBytes(w jsWriter, msg []byte, scratch []byte) ([]byte, []byte, error) {
  	u, msg, err := ReadUint64Bytes(msg)
  	if err != nil {
  		return msg, scratch, err
  	}
  	scratch = strconv.AppendUint(scratch[0:0], u, 10)
  	_, err = w.Write(scratch)
  	return msg, scratch, err
  }
  
  func rwFloatBytes(w jsWriter, msg []byte, f64 bool, scratch []byte) ([]byte, []byte, error) {
  	var f float64
  	var err error
  	var sz int
  	if f64 {
  		sz = 64
  		f, msg, err = ReadFloat64Bytes(msg)
  	} else {
  		sz = 32
  		var v float32
  		v, msg, err = ReadFloat32Bytes(msg)
  		f = float64(v)
  	}
  	if err != nil {
  		return msg, scratch, err
  	}
  	scratch = strconv.AppendFloat(scratch, f, 'f', -1, sz)
  	_, err = w.Write(scratch)
  	return msg, scratch, err
  }
  
  func rwFloat32Bytes(w jsWriter, msg []byte, scratch []byte) ([]byte, []byte, error) {
  	var f float32
  	var err error
  	f, msg, err = ReadFloat32Bytes(msg)
  	if err != nil {
  		return msg, scratch, err
  	}
  	scratch = strconv.AppendFloat(scratch[:0], float64(f), 'f', -1, 32)
  	_, err = w.Write(scratch)
  	return msg, scratch, err
  }
  
  func rwFloat64Bytes(w jsWriter, msg []byte, scratch []byte) ([]byte, []byte, error) {
  	var f float64
  	var err error
  	f, msg, err = ReadFloat64Bytes(msg)
  	if err != nil {
  		return msg, scratch, err
  	}
  	scratch = strconv.AppendFloat(scratch[:0], f, 'f', -1, 64)
  	_, err = w.Write(scratch)
  	return msg, scratch, err
  }
  
  func rwTimeBytes(w jsWriter, msg []byte, scratch []byte) ([]byte, []byte, error) {
  	var t time.Time
  	var err error
  	t, msg, err = ReadTimeBytes(msg)
  	if err != nil {
  		return msg, scratch, err
  	}
  	bts, err := t.MarshalJSON()
  	if err != nil {
  		return msg, scratch, err
  	}
  	_, err = w.Write(bts)
  	return msg, scratch, err
  }
  
  func rwExtensionBytes(w jsWriter, msg []byte, scratch []byte) ([]byte, []byte, error) {
  	var err error
  	var et int8
  	et, err = peekExtension(msg)
  	if err != nil {
  		return msg, scratch, err
  	}
  
  	// if it's time.Time
  	if et == TimeExtension {
  		var tm time.Time
  		tm, msg, err = ReadTimeBytes(msg)
  		if err != nil {
  			return msg, scratch, err
  		}
  		bts, err := tm.MarshalJSON()
  		if err != nil {
  			return msg, scratch, err
  		}
  		_, err = w.Write(bts)
  		return msg, scratch, err
  	}
  
  	// if the extension is registered,
  	// use its canonical JSON form
  	if f, ok := extensionReg[et]; ok {
  		e := f()
  		msg, err = ReadExtensionBytes(msg, e)
  		if err != nil {
  			return msg, scratch, err
  		}
  		bts, err := json.Marshal(e)
  		if err != nil {
  			return msg, scratch, err
  		}
  		_, err = w.Write(bts)
  		return msg, scratch, err
  	}
  
  	// otherwise, write `{"type": <num>, "data": "<base64data>"}`
  	r := RawExtension{}
  	r.Type = et
  	msg, err = ReadExtensionBytes(msg, &r)
  	if err != nil {
  		return msg, scratch, err
  	}
  	scratch, err = writeExt(w, r, scratch)
  	return msg, scratch, err
  }
  
  func writeExt(w jsWriter, r RawExtension, scratch []byte) ([]byte, error) {
  	_, err := w.WriteString(`{"type":`)
  	if err != nil {
  		return scratch, err
  	}
  	scratch = strconv.AppendInt(scratch[0:0], int64(r.Type), 10)
  	_, err = w.Write(scratch)
  	if err != nil {
  		return scratch, err
  	}
  	_, err = w.WriteString(`,"data":"`)
  	if err != nil {
  		return scratch, err
  	}
  	l := base64.StdEncoding.EncodedLen(len(r.Data))
  	if cap(scratch) >= l {
  		scratch = scratch[0:l]
  	} else {
  		scratch = make([]byte, l)
  	}
  	base64.StdEncoding.Encode(scratch, r.Data)
  	_, err = w.Write(scratch)
  	if err != nil {
  		return scratch, err
  	}
  	_, err = w.WriteString(`"}`)
  	return scratch, err
  }
  