Cleaning and bug fixes

[ric-plt/submgr.git] / e2ap / pkg / e2ap / e2ap_packerif.go

diff --git a/e2ap/pkg/e2ap/e2ap_packerif.go b/e2ap/pkg/e2ap/e2ap_packerif.go
index 23e5b0a..6a9c80d 100644 (file)
--- 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)
 }