Update for renamed public functions (#37)

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 <pex/sdk/version.h>
 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")
 	}

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,42 +20,42 @@ 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),
 			Message: C.GoString(&cStatusMessage[0]),
 		}
 	}
 
-	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
 }

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

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),

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)
 }

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,52 +191,52 @@ 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
 }
 
 // StartSearch starts a Pex search. This operation does not block until
 // 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))
 	}