Initial commit.

detect.go

@@ -0,0 +1,100 @@
+package icu
+
+// #cgo pkg-config: icu-i18n
+// #include "c_bridge.h"
+// #include "stdlib.h"
+import "C"
+import (
+    "fmt"
+    "sync"
+    "unsafe"
+)
+
+const (
+    U_ZERO_ERROR        = 0     // ICU common constant error code which means that no error occured
+    MatchDataBufferSize = 25    // Size of the buffer for detection results (Max count of returned guesses per detect call)
+) 
+
+// CharsetDetector provides ICU charset detection functionality.
+type CharsetDetector struct {
+    ptr         *C.UCharsetDetector // ICU struct needed for detection
+    resBuffer   [MatchDataBufferSize]C.MatchData
+    gMutex      sync.Mutex // Mutex used to guarantee thread safety for ICU calls
+}
+
+// An equivalent of MatchData C structure (see c_bridge.h)
+type Match struct {
+    Charset string
+    Language string
+    Confidence int
+}
+
+// Creates new charset detector. If it is successfully created, it
+// must be closed as it needs to free native ICU resources.
+func NewCharsetDetector() (*CharsetDetector, error) {
+    det := new(CharsetDetector)
+
+    var status int
+    statusPtr := unsafe.Pointer(&status)
+
+    det.ptr = C.ucsdet_open((*C.UErrorCode)(statusPtr))
+
+    if status != U_ZERO_ERROR {
+        return nil, fmt.Errorf("ICU Error code returned: %d", status)
+    }
+
+    return det, nil
+}
+
+func (det *CharsetDetector) GuessCharset(input []byte) (matches []Match, err error) {
+
+    // As described in c_bridge.h, detection operations are not thread safe and
+    // should be called consequently. So a mutex is used here.
+    det.gMutex.Lock()
+    defer det.gMutex.Unlock()
+
+    inputLen := len(input)
+    if inputLen == 0 {
+        return nil, fmt.Errorf("Input data len is 0")
+    }
+
+    var status int
+
+    // Perform detection. Guess count is the number of matches returned.
+    // The matches themself are put in the result buffer
+    guessCount := C.detectCharset(
+        unsafe.Pointer(det.ptr), 
+        unsafe.Pointer(&input[0]), 
+        C.int(inputLen), 
+        (*C.int)(unsafe.Pointer(&status)), 
+        (*C.MatchData)(unsafe.Pointer(&det.resBuffer[0])),
+        C.int(MatchDataBufferSize))
+
+    if status == U_ZERO_ERROR {
+        // Convert the returned number of entries from result buffer to a slice
+        // that will be returned
+        count := int(guessCount)
+        mt := make([]Match, count, count)
+
+        for i := 0; i < count; i++ {
+            mData := det.resBuffer[i]
+            charset := C.GoString(mData.charset)
+            language := C.GoString(mData.language)
+            mt[i] = Match{charset, language, int(mData.confidence)}
+        }
+
+        return mt, nil
+    }
+
+    return nil, fmt.Errorf("ICU Error code returned: %d", status)
+}
+
+// Close frees native C resources
+func (det *CharsetDetector) Close() {
+    det.gMutex.Lock()
+    defer det.gMutex.Unlock()
+
+    if det.ptr != nil {
+        C.ucsdet_close(det.ptr)
+    }
+}