/
decode.go
147 lines (129 loc) · 4.01 KB
/
decode.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
package charconv
import (
"bytes"
"golang.org/x/text/encoding"
"golang.org/x/text/transform"
"io"
"os"
)
func Decode(src io.Reader, dest io.Writer, decoder *encoding.Decoder) error {
srcReader := transform.NewReader(src, decoder)
_, err := io.Copy(dest, srcReader)
if err != nil {
return err
}
return nil
}
func DecodeWithCharset(src io.Reader, dest io.Writer, srcCharset string) error {
decoder := DecoderOf(srcCharset)
if decoder == nil {
return unsupported(srcCharset)
}
return Decode(src, dest, decoder)
}
func DecodeBytes(src []byte, dest io.Writer, decoder *encoding.Decoder) error {
return Decode(bytes.NewReader(src), dest, decoder)
}
func DecodeBytesWithCharset(src []byte, dest io.Writer, srcCharset string) error {
decoder := DecoderOf(srcCharset)
if decoder == nil {
return unsupported(srcCharset)
}
return DecodeWithCharset(bytes.NewReader(src), dest, srcCharset)
}
func DecodeToBytes(src io.Reader, initBuffSize int, decoder *encoding.Decoder) ([]byte, error) {
buffer := MakeByteBuffer(initBuffSize)
err := Decode(src, buffer, decoder)
if err != nil {
return nil, err
}
return buffer.Bytes(), nil
}
func DecodeToBytesWithCharset(src io.Reader, initBuffSize int, srcCharset string) ([]byte, error) {
decoder := DecoderOf(srcCharset)
if decoder == nil {
return nil, unsupported(srcCharset)
}
return DecodeToBytes(src, initBuffSize, decoder)
}
func DecodeBytesToBytes(src []byte, initBuffSize int, decoder *encoding.Decoder) ([]byte, error) {
return DecodeToBytes(bytes.NewReader(src), initBuffSize, decoder)
}
func DecodeBytesToBytesWithCharset(src []byte, initBuffSize int, srcCharset string) ([]byte, error) {
decoder := DecoderOf(srcCharset)
if decoder == nil {
return nil, unsupported(srcCharset)
}
return DecodeBytesToBytes(src, initBuffSize, decoder)
}
func DecodeFile(srcFilePath string, dest io.Writer, decoder *encoding.Decoder) error {
srcFile, err := os.Open(srcFilePath)
if err != nil {
return err
}
defer CloseQuietly(srcFile)
return Decode(srcFile, dest, decoder)
}
func DecodeFileWithCharset(srcFilePath string, dest io.Writer, srcCharset string) error {
decoder := DecoderOf(srcCharset)
if decoder == nil {
return unsupported(srcCharset)
}
return DecodeFile(srcFilePath, dest, decoder)
}
func DecodeFileToFile(srcFilePath string, destFilePath string, destFileFlag int, decoder *encoding.Decoder) error {
tmpFile, err := MakeTempFile()
if err != nil {
return err
}
defer RemoveQuietly(tmpFile)
err = DecodeFile(srcFilePath, tmpFile, decoder)
if err != nil {
return err
}
err = tmpFile.Sync()
if err != nil {
return err
}
return CopyTmpFileTo(tmpFile, destFilePath, destFileFlag)
}
func DecodeFileToFileWithCharset(srcFilePath string, destFilePath string, destFileFlag int, srcCharset string) error {
decoder := DecoderOf(srcCharset)
if decoder == nil {
return unsupported(srcCharset)
}
return DecodeFileToFile(srcFilePath, destFilePath, destFileFlag, decoder)
}
func DecodeToFile(src io.Reader, destFilePath string, destFileFlag int, decoder *encoding.Decoder) error {
tmpFile, err := MakeTempFile()
if err != nil {
return err
}
defer RemoveQuietly(tmpFile)
err = Decode(src, tmpFile, decoder)
if err != nil {
return err
}
err = tmpFile.Sync()
if err != nil {
return err
}
return CopyTmpFileTo(tmpFile, destFilePath, destFileFlag)
}
func DecodeToFileWithCharset(src io.Reader, destFilePath string, destFileFlag int, srcCharset string) error {
decoder := DecoderOf(srcCharset)
if decoder == nil {
return unsupported(srcCharset)
}
return DecodeToFile(src, destFilePath, destFileFlag, decoder)
}
func DecodeBytesToFile(src []byte, destFilePath string, destFileFlag int, decoder *encoding.Decoder) error {
return DecodeToFile(bytes.NewReader(src), destFilePath, destFileFlag, decoder)
}
func DecodeBytesToFileWithCharset(src []byte, destFilePath string, destFileFlag int, srcCharset string) error {
decoder := DecoderOf(srcCharset)
if decoder == nil {
return unsupported(srcCharset)
}
return DecodeBytesToFile(src, destFilePath, destFileFlag, decoder)
}