X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=e2ap%2Fpkg%2Fe2ap%2Fe2ap_packerif.go;h=6a9c80dbdc2e9a4287bade152afd41188e74808d;hb=01a4c49324392003717106267c56126275b9058b;hp=23e5b0a7461ad299096170052053d9f9b1889db9;hpb=83ada00338d2c9fa47d48c406b4a46b9d7888aff;p=ric-plt%2Fsubmgr.git

diff --git a/e2ap/pkg/e2ap/e2ap_packerif.go b/e2ap/pkg/e2ap/e2ap_packerif.go
index 23e5b0a..6a9c80d 100644
--- a/e2ap/pkg/e2ap/e2ap_packerif.go
+++ b/e2ap/pkg/e2ap/e2ap_packerif.go
@@ -20,71 +20,63 @@
 package e2ap
 
 import (
-	"fmt"
 	"gerrit.o-ran-sc.org/r/ric-plt/e2ap/pkg/packer"
 )
 
-//-----------------------------------------------------------------------------
-//
-//-----------------------------------------------------------------------------
-type E2APMsgPackerIf interface {
-	Pack(*packer.PackedData) (error, *packer.PackedData)
-	UnPack(msg *packer.PackedData) error
-	String() string
-}
-
 //-----------------------------------------------------------------------------
 //
 //-----------------------------------------------------------------------------
 type E2APMsgPackerSubscriptionRequestIf interface {
-	E2APMsgPackerIf
-	Set(*E2APSubscriptionRequest) error
-	Get() (error, *E2APSubscriptionRequest)
+	Pack(*E2APSubscriptionRequest) (error, *packer.PackedData)
+	UnPack(msg *packer.PackedData) (error, *E2APSubscriptionRequest)
+	String() string
 }
 
 //-----------------------------------------------------------------------------
 //
 //-----------------------------------------------------------------------------
 type E2APMsgPackerSubscriptionResponseIf interface {
-	E2APMsgPackerIf
-	Set(*E2APSubscriptionResponse) error
-	Get() (error, *E2APSubscriptionResponse)
+	Pack(*E2APSubscriptionResponse) (error, *packer.PackedData)
+	UnPack(msg *packer.PackedData) (error, *E2APSubscriptionResponse)
+	String() string
 }
 
 //-----------------------------------------------------------------------------
 //
 //-----------------------------------------------------------------------------
 type E2APMsgPackerSubscriptionFailureIf interface {
-	E2APMsgPackerIf
-	Set(*E2APSubscriptionFailure) error
-	Get() (error, *E2APSubscriptionFailure)
+	Pack(*E2APSubscriptionFailure) (error, *packer.PackedData)
+	UnPack(msg *packer.PackedData) (error, *E2APSubscriptionFailure)
+	String() string
 }
 
 //-----------------------------------------------------------------------------
 //
 //-----------------------------------------------------------------------------
 type E2APMsgPackerSubscriptionDeleteRequestIf interface {
-	E2APMsgPackerIf
-	Set(*E2APSubscriptionDeleteRequest) error
-	Get() (error, *E2APSubscriptionDeleteRequest)
+	Pack(*E2APSubscriptionDeleteRequest) (error, *packer.PackedData)
+	Pack21(*E2APSubscriptionDeleteRequest) (error, *packer.PackedData)
+	Pack22(*E2APSubscriptionDeleteRequest) (error, *packer.PackedData)
+	UnPack(msg *packer.PackedData) (error, *E2APSubscriptionDeleteRequest)
+	String() string
 }
 
 //-----------------------------------------------------------------------------
 //
 //-----------------------------------------------------------------------------
 type E2APMsgPackerSubscriptionDeleteResponseIf interface {
-	E2APMsgPackerIf
-	Set(*E2APSubscriptionDeleteResponse) error
-	Get() (error, *E2APSubscriptionDeleteResponse)
+	Pack(*E2APSubscriptionDeleteResponse) (error, *packer.PackedData)
+	UnPack(msg *packer.PackedData) (error, *E2APSubscriptionDeleteResponse)
+	String() string
 }
 
 //-----------------------------------------------------------------------------
 //
 //-----------------------------------------------------------------------------
 type E2APMsgPackerSubscriptionDeleteFailureIf interface {
-	E2APMsgPackerIf
-	Set(*E2APSubscriptionDeleteFailure) error
-	Get() (error, *E2APSubscriptionDeleteFailure)
+	Pack(*E2APSubscriptionDeleteFailure) (error, *packer.PackedData)
+	UnPack(msg *packer.PackedData) (error, *E2APSubscriptionDeleteFailure)
+	String() string
 }
 
 //-----------------------------------------------------------------------------
@@ -97,128 +89,6 @@ type E2APPackerIf interface {
 	NewPackerSubscriptionDeleteRequest() E2APMsgPackerSubscriptionDeleteRequestIf
 	NewPackerSubscriptionDeleteResponse() E2APMsgPackerSubscriptionDeleteResponseIf
 	NewPackerSubscriptionDeleteFailure() E2APMsgPackerSubscriptionDeleteFailureIf
-	MessageInfo(msg *packer.PackedData) *packer.MessageInfo
-}
-
-//-----------------------------------------------------------------------------
-//
-//-----------------------------------------------------------------------------
-type E2APAutoPacker struct {
-	packer E2APPackerIf
-}
-
-func NewE2APAutoPacker(packer E2APPackerIf) *E2APAutoPacker {
-	return &E2APAutoPacker{packer: packer}
-}
-
-// TODO improve openasn handling to reuse PDU etc...
-// Now practically decodes two times each E2/X2 message, as first round solves message type
-func (autopacker *E2APAutoPacker) UnPack(msg *packer.PackedData) (error, interface{}) {
-	var err error = nil
-	msgInfo := autopacker.packer.MessageInfo(msg)
-	if msgInfo != nil {
-		switch msgInfo.MsgType {
-		case E2AP_InitiatingMessage:
-			switch msgInfo.MsgId {
-			case E2AP_RICSubscriptionRequest:
-				unpa := autopacker.packer.NewPackerSubscriptionRequest()
-				err = unpa.UnPack(msg)
-				if err == nil {
-					return unpa.Get()
-				}
-			case E2AP_RICSubscriptionDeleteRequest:
-				unpa := autopacker.packer.NewPackerSubscriptionDeleteRequest()
-				err = unpa.UnPack(msg)
-				if err == nil {
-					return unpa.Get()
-				}
-			default:
-				err = fmt.Errorf("MsgType: E2AP_InitiatingMessage => MsgId:%d unknown", msgInfo.MsgId)
-			}
-		case E2AP_SuccessfulOutcome:
-			switch msgInfo.MsgId {
-			case E2AP_RICSubscriptionResponse:
-				unpa := autopacker.packer.NewPackerSubscriptionResponse()
-				err = unpa.UnPack(msg)
-				if err == nil {
-					return unpa.Get()
-				}
-			case E2AP_RICSubscriptionDeleteResponse:
-				unpa := autopacker.packer.NewPackerSubscriptionDeleteResponse()
-				err = unpa.UnPack(msg)
-				if err == nil {
-					return unpa.Get()
-				}
-			default:
-				err = fmt.Errorf("MsgType: E2AP_SuccessfulOutcome => MsgId:%d unknown", msgInfo.MsgId)
-			}
-		case E2AP_UnsuccessfulOutcome:
-			switch msgInfo.MsgId {
-			case E2AP_RICSubscriptionFailure:
-				unpa := autopacker.packer.NewPackerSubscriptionFailure()
-				err = unpa.UnPack(msg)
-				if err == nil {
-					return unpa.Get()
-				}
-			case E2AP_RICSubscriptionDeleteFailure:
-				unpa := autopacker.packer.NewPackerSubscriptionDeleteFailure()
-				err = unpa.UnPack(msg)
-				if err == nil {
-					return unpa.Get()
-				}
-			default:
-				err = fmt.Errorf("MsgType: E2AP_UnsuccessfulOutcome => MsgId:%d unknown", msgInfo.MsgId)
-			}
-		default:
-			err = fmt.Errorf("MsgType: %d and MsgId:%d unknown", msgInfo.MsgType, msgInfo.MsgId)
-		}
-	} else {
-		err = fmt.Errorf("MsgInfo not received")
-	}
-	return err, nil
-}
-
-func (autopacker *E2APAutoPacker) Pack(data interface{}, trg *packer.PackedData) (error, *packer.PackedData) {
-	var err error = nil
-	switch themsg := data.(type) {
-	case *E2APSubscriptionRequest:
-		pa := autopacker.packer.NewPackerSubscriptionRequest()
-		err = pa.Set(themsg)
-		if err == nil {
-			return pa.Pack(trg)
-		}
-	case *E2APSubscriptionResponse:
-		pa := autopacker.packer.NewPackerSubscriptionResponse()
-		err = pa.Set(themsg)
-		if err == nil {
-			return pa.Pack(trg)
-		}
-	case *E2APSubscriptionFailure:
-		pa := autopacker.packer.NewPackerSubscriptionFailure()
-		err = pa.Set(themsg)
-		if err == nil {
-			return pa.Pack(trg)
-		}
-	case *E2APSubscriptionDeleteRequest:
-		pa := autopacker.packer.NewPackerSubscriptionDeleteRequest()
-		err = pa.Set(themsg)
-		if err == nil {
-			return pa.Pack(trg)
-		}
-	case *E2APSubscriptionDeleteResponse:
-		pa := autopacker.packer.NewPackerSubscriptionDeleteResponse()
-		err = pa.Set(themsg)
-		if err == nil {
-			return pa.Pack(trg)
-		}
-	case *E2APSubscriptionDeleteFailure:
-		pa := autopacker.packer.NewPackerSubscriptionDeleteFailure()
-		err = pa.Set(themsg)
-		if err == nil {
-			return pa.Pack(trg)
-		}
-	default:
-		err = fmt.Errorf("unknown message")
-	}
-	return err, nil
+	//UnPack(*packer.PackedData) (error, interface{})
+	//Pack(interface{}, *packer.PackedData) (error, *packer.PackedData)
 }