From d607585531b692e9f14d7a6ec5a5a6ff6ad0a926 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Martin=20Ho=C5=99e=C5=88ovsk=C3=BD?= Date: Wed, 13 Sep 2023 10:44:59 +0200 Subject: [PATCH] Update for renamed public functions (#37) --- 000init.go | 6 ++-- client.go | 28 ++++++++-------- error.go | 8 ++--- fingerprint.go | 26 +++++++-------- mockserver.go | 12 +++---- pex_search.go | 82 +++++++++++++++++++++++------------------------ private_search.go | 82 +++++++++++++++++++++++------------------------ 7 files changed, 122 insertions(+), 122 deletions(-) diff --git a/000init.go b/000init.go index a8a6a95..62d340d 100644 --- a/000init.go +++ b/000init.go @@ -6,14 +6,14 @@ package pex // #cgo pkg-config: pexae // -// #define AE_SDK_MAJOR_VERSION 4 -// #define AE_SDK_MINOR_VERSION 0 +// #define PEX_SDK_MAJOR_VERSION 4 +// #define PEX_SDK_MINOR_VERSION 0 // // #include import "C" func init() { - compatible := C.AE_Version_IsCompatible(C.AE_SDK_MAJOR_VERSION, C.AE_SDK_MINOR_VERSION) + compatible := C.Pex_Version_IsCompatible(C.PEX_SDK_MAJOR_VERSION, C.PEX_SDK_MINOR_VERSION) if !compatible { panic("bindings are not compatible with the native library") } diff --git a/client.go b/client.go index 95127a6..ba954d6 100644 --- a/client.go +++ b/client.go @@ -9,7 +9,7 @@ package pex import "C" import "unsafe" -func newClient(typ C.AE_ClientType, clientID, clientSecret string) (*C.AE_Client, error) { +func newClient(typ C.Pex_ClientType, clientID, clientSecret string) (*C.Pex_Client, error) { cClientID := C.CString(clientID) defer C.free(unsafe.Pointer(cClientID)) @@ -20,7 +20,7 @@ func newClient(typ C.AE_ClientType, clientID, clientSecret string) (*C.AE_Client cStatusMessage := make([]C.char, 100) cStatusMessageSize := C.size_t(len(cStatusMessage)) - C.AE_Init(cClientID, cClientSecret, &cStatusCode, &cStatusMessage[0], cStatusMessageSize) + C.Pex_Init(cClientID, cClientSecret, &cStatusCode, &cStatusMessage[0], cStatusMessageSize) if StatusCode(cStatusCode) != StatusOK { return nil, &Error{ Code: StatusCode(cStatusCode), @@ -28,34 +28,34 @@ func newClient(typ C.AE_ClientType, clientID, clientSecret string) (*C.AE_Client } } - C.AE_Lock() - defer C.AE_Unlock() + C.Pex_Lock() + defer C.Pex_Unlock() - cStatus := C.AE_Status_New() + cStatus := C.Pex_Status_New() if cStatus == nil { panic("out of memory") } - defer C.AE_Status_Delete(&cStatus) + defer C.Pex_Status_Delete(&cStatus) - cClient := C.AE_Client_New() + cClient := C.Pex_Client_New() if cClient == nil { panic("out of memory") } - C.AE_Client_Init(cClient, typ, cClientID, cClientSecret, cStatus) + C.Pex_Client_Init(cClient, typ, cClientID, cClientSecret, cStatus) if err := statusToError(cStatus); err != nil { - // TODO: if this fails, run AE_Cleanup + // TODO: if this fails, run Pex_Cleanup C.free(unsafe.Pointer(cClient)) return nil, err } return cClient, nil } -func closeClient(c **C.AE_Client) error { - C.AE_Lock() - C.AE_Client_Delete(c) - C.AE_Unlock() +func closeClient(c **C.Pex_Client) error { + C.Pex_Lock() + C.Pex_Client_Delete(c) + C.Pex_Unlock() - C.AE_Cleanup() + C.Pex_Cleanup() return nil } diff --git a/error.go b/error.go index 6f87a43..9b42a32 100644 --- a/error.go +++ b/error.go @@ -38,11 +38,11 @@ func (e *Error) Error() string { return fmt.Sprintf("%d: %s", e.Code, e.Message) } -func statusToError(status *C.AE_Status) error { - if !C.AE_Status_OK(status) { +func statusToError(status *C.Pex_Status) error { + if !C.Pex_Status_OK(status) { return &Error{ - Code: StatusCode(C.AE_Status_GetCode(status)), - Message: C.GoString(C.AE_Status_GetMessage(status)), + Code: StatusCode(C.Pex_Status_GetCode(status)), + Message: C.GoString(C.Pex_Status_GetMessage(status)), } } return nil diff --git a/fingerprint.go b/fingerprint.go index 27a01ce..c0c943a 100644 --- a/fingerprint.go +++ b/fingerprint.go @@ -67,16 +67,16 @@ func reduceTypes(in []FingerprintType) (out FingerprintType) { } func newFingerprint(input []byte, isFile bool, typ FingerprintType) (*Fingerprint, error) { - C.AE_Lock() - defer C.AE_Unlock() + C.Pex_Lock() + defer C.Pex_Unlock() - status := C.AE_Status_New() + status := C.Pex_Status_New() if status == nil { panic("out of memory") } - defer C.AE_Status_Delete(&status) + defer C.Pex_Status_Delete(&status) - ft := C.AE_Buffer_New() + ft := C.Pex_Buffer_New() if ft == nil { panic("out of memory") } @@ -85,28 +85,28 @@ func newFingerprint(input []byte, isFile bool, typ FingerprintType) (*Fingerprin cFile := C.CString(string(input)) defer C.free(unsafe.Pointer(cFile)) - C.AE_Fingerprint_File_For_Types(cFile, ft, status, C.int(typ)) + C.Pex_Fingerprint_File_For_Types(cFile, ft, status, C.int(typ)) } else { - buf := C.AE_Buffer_New() + buf := C.Pex_Buffer_New() if buf == nil { panic("out of memory") } - defer C.AE_Buffer_Delete(&buf) + defer C.Pex_Buffer_Delete(&buf) data := unsafe.Pointer(&input[0]) size := C.size_t(len(input)) - C.AE_Buffer_Set(buf, data, size) - C.AE_Fingerprint_Buffer_For_Types(buf, ft, status, C.int(typ)) + C.Pex_Buffer_Set(buf, data, size) + C.Pex_Fingerprint_Buffer_For_Types(buf, ft, status, C.int(typ)) } if err := statusToError(status); err != nil { - C.AE_Buffer_Delete(&ft) + C.Pex_Buffer_Delete(&ft) return nil, err } - data := C.AE_Buffer_GetData(ft) - size := C.int(C.AE_Buffer_GetSize(ft)) + data := C.Pex_Buffer_GetData(ft) + size := C.int(C.Pex_Buffer_GetSize(ft)) return &Fingerprint{ b: C.GoBytes(data, size), diff --git a/mockserver.go b/mockserver.go index dc8f195..93ceb27 100644 --- a/mockserver.go +++ b/mockserver.go @@ -7,20 +7,20 @@ package pex import "C" type client interface { - getCClient() *C.AE_Client + getCClient() *C.Pex_Client } // MockClient initializes the provided client to communicate with the mockserver. func MockClient(c client) error { - C.AE_Lock() - defer C.AE_Unlock() + C.Pex_Lock() + defer C.Pex_Unlock() - cStatus := C.AE_Status_New() + cStatus := C.Pex_Status_New() if cStatus == nil { panic("out of memory") } - defer C.AE_Status_Delete(&cStatus) + defer C.Pex_Status_Delete(&cStatus) - C.AE_Mockserver_InitClient(c.getCClient(), nil, cStatus) + C.Pex_Mockserver_InitClient(c.getCClient(), nil, cStatus) return statusToError(cStatus) } diff --git a/pex_search.go b/pex_search.go index 1d2d50c..a319775 100644 --- a/pex_search.go +++ b/pex_search.go @@ -46,13 +46,13 @@ type PexSearchAsset struct { Duration float32 } -func newPexSearchAssetFromC(cAsset *C.AE_Asset) *PexSearchAsset { +func newPexSearchAssetFromC(cAsset *C.Pex_Asset) *PexSearchAsset { return &PexSearchAsset{ - Title: C.GoString(C.AE_Asset_GetTitle(cAsset)), - Artist: C.GoString(C.AE_Asset_GetArtist(cAsset)), - ISRC: C.GoString(C.AE_Asset_GetISRC(cAsset)), - Label: C.GoString(C.AE_Asset_GetLabel(cAsset)), - Duration: float32(C.AE_Asset_GetDuration(cAsset)), + Title: C.GoString(C.Pex_Asset_GetTitle(cAsset)), + Artist: C.GoString(C.Pex_Asset_GetArtist(cAsset)), + ISRC: C.GoString(C.Pex_Asset_GetISRC(cAsset)), + Label: C.GoString(C.Pex_Asset_GetLabel(cAsset)), + Duration: float32(C.Pex_Asset_GetDuration(cAsset)), } } @@ -79,57 +79,57 @@ type PexSearchFuture struct { // also releases all the allocated resources, so it will return an // error when called multiple times. func (x *PexSearchFuture) Get() (*PexSearchResult, error) { - C.AE_Lock() - defer C.AE_Unlock() + C.Pex_Lock() + defer C.Pex_Unlock() - cStatus := C.AE_Status_New() + cStatus := C.Pex_Status_New() if cStatus == nil { panic("out of memory") } - defer C.AE_Status_Delete(&cStatus) + defer C.Pex_Status_Delete(&cStatus) - cRequest := C.AE_CheckSearchRequest_New() + cRequest := C.Pex_CheckSearchRequest_New() if cRequest == nil { panic("out of memory") } - defer C.AE_CheckSearchRequest_Delete(&cRequest) + defer C.Pex_CheckSearchRequest_Delete(&cRequest) - cResult := C.AE_CheckSearchResult_New() + cResult := C.Pex_CheckSearchResult_New() if cResult == nil { panic("out of memory") } - defer C.AE_CheckSearchResult_Delete(&cResult) + defer C.Pex_CheckSearchResult_Delete(&cResult) for _, lookupID := range x.LookupIDs { cLookupID := C.CString(lookupID) defer C.free(unsafe.Pointer(cLookupID)) - C.AE_CheckSearchRequest_AddLookupID(cRequest, cLookupID) + C.Pex_CheckSearchRequest_AddLookupID(cRequest, cLookupID) } - C.AE_CheckSearch(x.client.c, cRequest, cResult, cStatus) + C.Pex_CheckSearch(x.client.c, cRequest, cResult, cStatus) if err := statusToError(cStatus); err != nil { return nil, err } return x.processResult(cResult, cStatus) } -func (x *PexSearchFuture) processResult(cResult *C.AE_CheckSearchResult, cStatus *C.AE_Status) (*PexSearchResult, error) { - cMatch := C.AE_SearchMatch_New() +func (x *PexSearchFuture) processResult(cResult *C.Pex_CheckSearchResult, cStatus *C.Pex_Status) (*PexSearchResult, error) { + cMatch := C.Pex_SearchMatch_New() if cMatch == nil { panic("out of memory") } - defer C.AE_SearchMatch_Delete(&cMatch) + defer C.Pex_SearchMatch_Delete(&cMatch) - cAsset := C.AE_Asset_New() + cAsset := C.Pex_Asset_New() if cAsset == nil { panic("out of memory") } - defer C.AE_Asset_Delete(&cAsset) + defer C.Pex_Asset_Delete(&cAsset) var cMatchesPos C.int = 0 var matches []*PexSearchMatch - for C.AE_CheckSearchResult_NextMatch(cResult, cMatch, &cMatchesPos) { + for C.Pex_CheckSearchResult_NextMatch(cResult, cMatch, &cMatchesPos) { var cQueryStart C.int64_t var cQueryEnd C.int64_t var cAssetStart C.int64_t @@ -138,7 +138,7 @@ func (x *PexSearchFuture) processResult(cResult *C.AE_CheckSearchResult, cStatus var cSegmentsPos C.int = 0 var segments []*Segment - for C.AE_SearchMatch_NextSegment(cMatch, &cQueryStart, &cQueryEnd, &cAssetStart, &cAssetEnd, &cType, &cSegmentsPos) { + for C.Pex_SearchMatch_NextSegment(cMatch, &cQueryStart, &cQueryEnd, &cAssetStart, &cAssetEnd, &cType, &cSegmentsPos) { segments = append(segments, &Segment{ Type: SegmentType(cType), QueryStart: int64(cQueryStart), @@ -148,7 +148,7 @@ func (x *PexSearchFuture) processResult(cResult *C.AE_CheckSearchResult, cStatus }) } - C.AE_SearchMatch_GetAsset(cMatch, cAsset, cStatus) + C.Pex_SearchMatch_GetAsset(cMatch, cAsset, cStatus) if err := statusToError(cStatus); err != nil { return nil, err } @@ -172,11 +172,11 @@ func (x *PexSearchFuture) processResult(cResult *C.AE_CheckSearchResult, cStatus type PexSearchClient struct { fingerprinter - c *C.AE_Client + c *C.Pex_Client } func NewPexSearchClient(clientID, clientSecret string) (*PexSearchClient, error) { - cClient, err := newClient(C.AE_PEX_SEARCH, clientID, clientSecret) + cClient, err := newClient(C.Pex_PEX_SEARCH, clientID, clientSecret) if err != nil { return nil, err } @@ -191,7 +191,7 @@ func (x *PexSearchClient) Close() error { return closeClient(&x.c) } -func (x *PexSearchClient) getCClient() *C.AE_Client { +func (x *PexSearchClient) getCClient() *C.Pex_Client { return x.c } @@ -199,44 +199,44 @@ func (x *PexSearchClient) getCClient() *C.AE_Client { // the search is finished, it does however perform a network operation // to initiate the search on the backend service. func (x *PexSearchClient) StartSearch(req *PexSearchRequest) (*PexSearchFuture, error) { - C.AE_Lock() - defer C.AE_Unlock() + C.Pex_Lock() + defer C.Pex_Unlock() - cStatus := C.AE_Status_New() + cStatus := C.Pex_Status_New() if cStatus == nil { panic("out of memory") } - defer C.AE_Status_Delete(&cStatus) + defer C.Pex_Status_Delete(&cStatus) - cRequest := C.AE_StartSearchRequest_New() + cRequest := C.Pex_StartSearchRequest_New() if cRequest == nil { panic("out of memory") } - defer C.AE_StartSearchRequest_Delete(&cRequest) + defer C.Pex_StartSearchRequest_Delete(&cRequest) - cResult := C.AE_StartSearchResult_New() + cResult := C.Pex_StartSearchResult_New() if cResult == nil { panic("out of memory") } - defer C.AE_StartSearchResult_Delete(&cResult) + defer C.Pex_StartSearchResult_Delete(&cResult) - cBuffer := C.AE_Buffer_New() + cBuffer := C.Pex_Buffer_New() if cBuffer == nil { panic("out of memory") } - defer C.AE_Buffer_Delete(&cBuffer) + defer C.Pex_Buffer_Delete(&cBuffer) ftData := unsafe.Pointer(&req.Fingerprint.b[0]) ftSize := C.size_t(len(req.Fingerprint.b)) - C.AE_Buffer_Set(cBuffer, ftData, ftSize) + C.Pex_Buffer_Set(cBuffer, ftData, ftSize) - C.AE_StartSearchRequest_SetFingerprint(cRequest, cBuffer, cStatus) + C.Pex_StartSearchRequest_SetFingerprint(cRequest, cBuffer, cStatus) if err := statusToError(cStatus); err != nil { return nil, err } - C.AE_StartSearch(x.c, cRequest, cResult, cStatus) + C.Pex_StartSearch(x.c, cRequest, cResult, cStatus) if err := statusToError(cStatus); err != nil { return nil, err } @@ -245,7 +245,7 @@ func (x *PexSearchClient) StartSearch(req *PexSearchRequest) (*PexSearchFuture, var lookupIDs []string var cLookupID *C.char - for C.AE_StartSearchResult_NextLookupID(cResult, &cLookupIDPos, &cLookupID) { + for C.Pex_StartSearchResult_NextLookupID(cResult, &cLookupIDPos, &cLookupID) { lookupIDs = append(lookupIDs, C.GoString(cLookupID)) } diff --git a/private_search.go b/private_search.go index f724b52..487481a 100644 --- a/private_search.go +++ b/private_search.go @@ -54,51 +54,51 @@ type PrivateSearchFuture struct { // also releases all the allocated resources, so it will return an // error when called multiple times. func (x *PrivateSearchFuture) Get() (*PrivateSearchResult, error) { - C.AE_Lock() - defer C.AE_Unlock() + C.Pex_Lock() + defer C.Pex_Unlock() - cStatus := C.AE_Status_New() + cStatus := C.Pex_Status_New() if cStatus == nil { panic("out of memory") } - defer C.AE_Status_Delete(&cStatus) + defer C.Pex_Status_Delete(&cStatus) - cRequest := C.AE_CheckSearchRequest_New() + cRequest := C.Pex_CheckSearchRequest_New() if cRequest == nil { panic("out of memory") } - defer C.AE_CheckSearchRequest_Delete(&cRequest) + defer C.Pex_CheckSearchRequest_Delete(&cRequest) - cResult := C.AE_CheckSearchResult_New() + cResult := C.Pex_CheckSearchResult_New() if cResult == nil { panic("out of memory") } - defer C.AE_CheckSearchResult_Delete(&cResult) + defer C.Pex_CheckSearchResult_Delete(&cResult) for _, lookupID := range x.LookupIDs { cLookupID := C.CString(lookupID) defer C.free(unsafe.Pointer(cLookupID)) - C.AE_CheckSearchRequest_AddLookupID(cRequest, cLookupID) + C.Pex_CheckSearchRequest_AddLookupID(cRequest, cLookupID) } - C.AE_CheckSearch(x.client.c, cRequest, cResult, cStatus) + C.Pex_CheckSearch(x.client.c, cRequest, cResult, cStatus) if err := statusToError(cStatus); err != nil { return nil, err } return x.processResult(cResult, cStatus) } -func (x *PrivateSearchFuture) processResult(cResult *C.AE_CheckSearchResult, cStatus *C.AE_Status) (*PrivateSearchResult, error) { - cMatch := C.AE_SearchMatch_New() +func (x *PrivateSearchFuture) processResult(cResult *C.Pex_CheckSearchResult, cStatus *C.Pex_Status) (*PrivateSearchResult, error) { + cMatch := C.Pex_SearchMatch_New() if cMatch == nil { panic("out of memory") } - defer C.AE_SearchMatch_Delete(&cMatch) + defer C.Pex_SearchMatch_Delete(&cMatch) var cMatchesPos C.int = 0 var matches []*PrivateSearchMatch - for C.AE_CheckSearchResult_NextMatch(cResult, cMatch, &cMatchesPos) { + for C.Pex_CheckSearchResult_NextMatch(cResult, cMatch, &cMatchesPos) { var cQueryStart C.int64_t var cQueryEnd C.int64_t var cAssetStart C.int64_t @@ -107,7 +107,7 @@ func (x *PrivateSearchFuture) processResult(cResult *C.AE_CheckSearchResult, cSt var cSegmentsPos C.int = 0 var segments []*Segment - for C.AE_SearchMatch_NextSegment(cMatch, &cQueryStart, &cQueryEnd, &cAssetStart, &cAssetEnd, &cType, &cSegmentsPos) { + for C.Pex_SearchMatch_NextSegment(cMatch, &cQueryStart, &cQueryEnd, &cAssetStart, &cAssetEnd, &cType, &cSegmentsPos) { segments = append(segments, &Segment{ Type: SegmentType(cType), QueryStart: int64(cQueryStart), @@ -117,7 +117,7 @@ func (x *PrivateSearchFuture) processResult(cResult *C.AE_CheckSearchResult, cSt }) } - cProvidedID := C.AE_SearchMatch_GetProvidedID(cMatch, cStatus) + cProvidedID := C.Pex_SearchMatch_GetProvidedID(cMatch, cStatus) if err := statusToError(cStatus); err != nil { return nil, err } @@ -141,11 +141,11 @@ func (x *PrivateSearchFuture) processResult(cResult *C.AE_CheckSearchResult, cSt type PrivateSearchClient struct { fingerprinter - c *C.AE_Client + c *C.Pex_Client } func NewPrivateSearchClient(clientID, clientSecret string) (*PrivateSearchClient, error) { - cClient, err := newClient(C.AE_PRIVATE_SEARCH, clientID, clientSecret) + cClient, err := newClient(C.Pex_PRIVATE_SEARCH, clientID, clientSecret) if err != nil { return nil, err } @@ -160,7 +160,7 @@ func (x *PrivateSearchClient) Close() error { return closeClient(&x.c) } -func (x *PrivateSearchClient) getCClient() *C.AE_Client { +func (x *PrivateSearchClient) getCClient() *C.Pex_Client { return x.c } @@ -168,44 +168,44 @@ func (x *PrivateSearchClient) getCClient() *C.AE_Client { // the search is finished, it does however perform a network operation // to initiate the search on the backend service. func (x *PrivateSearchClient) StartSearch(req *PrivateSearchRequest) (*PrivateSearchFuture, error) { - C.AE_Lock() - defer C.AE_Unlock() + C.Pex_Lock() + defer C.Pex_Unlock() - cStatus := C.AE_Status_New() + cStatus := C.Pex_Status_New() if cStatus == nil { panic("out of memory") } - defer C.AE_Status_Delete(&cStatus) + defer C.Pex_Status_Delete(&cStatus) - cRequest := C.AE_StartSearchRequest_New() + cRequest := C.Pex_StartSearchRequest_New() if cRequest == nil { panic("out of memory") } - defer C.AE_StartSearchRequest_Delete(&cRequest) + defer C.Pex_StartSearchRequest_Delete(&cRequest) - cResult := C.AE_StartSearchResult_New() + cResult := C.Pex_StartSearchResult_New() if cResult == nil { panic("out of memory") } - defer C.AE_StartSearchResult_Delete(&cResult) + defer C.Pex_StartSearchResult_Delete(&cResult) - cBuffer := C.AE_Buffer_New() + cBuffer := C.Pex_Buffer_New() if cBuffer == nil { panic("out of memory") } - defer C.AE_Buffer_Delete(&cBuffer) + defer C.Pex_Buffer_Delete(&cBuffer) ftData := unsafe.Pointer(&req.Fingerprint.b[0]) ftSize := C.size_t(len(req.Fingerprint.b)) - C.AE_Buffer_Set(cBuffer, ftData, ftSize) + C.Pex_Buffer_Set(cBuffer, ftData, ftSize) - C.AE_StartSearchRequest_SetFingerprint(cRequest, cBuffer, cStatus) + C.Pex_StartSearchRequest_SetFingerprint(cRequest, cBuffer, cStatus) if err := statusToError(cStatus); err != nil { return nil, err } - C.AE_StartSearch(x.c, cRequest, cResult, cStatus) + C.Pex_StartSearch(x.c, cRequest, cResult, cStatus) if err := statusToError(cStatus); err != nil { return nil, err } @@ -214,7 +214,7 @@ func (x *PrivateSearchClient) StartSearch(req *PrivateSearchRequest) (*PrivateSe var lookupIDs []string var cLookupID *C.char - for C.AE_StartSearchResult_NextLookupID(cResult, &cLookupIDPos, &cLookupID) { + for C.Pex_StartSearchResult_NextLookupID(cResult, &cLookupIDPos, &cLookupID) { lookupIDs = append(lookupIDs, C.GoString(cLookupID)) } @@ -231,29 +231,29 @@ func (x *PrivateSearchClient) StartSearch(req *PrivateSearchRequest) (*PrivateSe // identifies the fingerprint and will be returned during search to identify // the matched asset. func (x *PrivateSearchClient) Ingest(id string, ft *Fingerprint) error { - C.AE_Lock() - defer C.AE_Unlock() + C.Pex_Lock() + defer C.Pex_Unlock() - cStatus := C.AE_Status_New() + cStatus := C.Pex_Status_New() if cStatus == nil { panic("out of memory") } - defer C.AE_Status_Delete(&cStatus) + defer C.Pex_Status_Delete(&cStatus) cID := C.CString(id) defer C.free(unsafe.Pointer(cID)) - cBuffer := C.AE_Buffer_New() + cBuffer := C.Pex_Buffer_New() if cBuffer == nil { panic("out of memory") } - defer C.AE_Buffer_Delete(&cBuffer) + defer C.Pex_Buffer_Delete(&cBuffer) ftData := unsafe.Pointer(&ft.b[0]) ftSize := C.size_t(len(ft.b)) - C.AE_Buffer_Set(cBuffer, ftData, ftSize) + C.Pex_Buffer_Set(cBuffer, ftData, ftSize) - C.AE_Ingest(x.c, cID, cBuffer, cStatus) + C.Pex_Ingest(x.c, cID, cBuffer, cStatus) return statusToError(cStatus) }