chore: Removes individual header setting in IEs

ie/apply_action.go

@@ -193,23 +193,18 @@ func (applyaction ApplyAction) IsZeroValue() bool {
 	return applyaction.Header.Length == 0
 }
 
-func DeserializeApplyAction(ieHeader Header, ieValue []byte) (ApplyAction, error) {
-	var applyaction ApplyAction
-
-	if ieHeader.Type != ApplyActionIEType {
-		return applyaction, fmt.Errorf("invalid IE type: expected %d, got %d", ApplyActionIEType, ieHeader.Type)
-	}
+func (applyaction ApplyAction) SetHeader(header Header) InformationElement {
+	applyaction.Header = header
+	return applyaction
+}
 
-	if ieHeader.Length != 2 {
-		return applyaction, fmt.Errorf("invalid length field for ApplyAction: expected 2, got %d", ieHeader.Length)
-	}
+func DeserializeApplyAction(ieValue []byte) (ApplyAction, error) {
+	var applyaction ApplyAction
 
 	if len(ieValue) != 2 {
-		return applyaction, fmt.Errorf("invalid length for ApplyAction: got %d bytes, want 2", len(ieValue))
+		return ApplyAction{}, fmt.Errorf("invalid length for ApplyAction: got %d bytes, want 2", len(ieValue))
 	}
 
-	applyaction.Header = ieHeader
-
 	// Deserialize the first byte (Octet 5)
 	byte5 := ieValue[0]
 	applyaction.DFRT = byte5&(1<<7) != 0

ie/apply_action_test.go

@@ -114,25 +114,12 @@ func TestGivenApplyActionSerializedWhenDeserializeThenFieldsSetCorrectly(t *test
 
 	serialized := applyAction.Serialize()
 
-	ieHeader := ie.Header{
-		Type:   44,
-		Length: 2,
-	}
-
-	deserialized, err := ie.DeserializeApplyAction(ieHeader, serialized[4:])
+	deserialized, err := ie.DeserializeApplyAction(serialized[4:])
 
 	if err != nil {
 		t.Fatalf("Error deserializing ApplyAction: %v", err)
 	}
 
-	if deserialized.Header.Type != 44 {
-		t.Errorf("Expected IEType 44, got %d", deserialized.Header.Type)
-	}
-
-	if deserialized.Header.Length != 2 {
-		t.Errorf("Expected Length 2, got %d", deserialized.Header.Length)
-	}
-
 	if deserialized.DFRT != false {
 		t.Errorf("Expected no DFRT, got %v", deserialized.DFRT)
 	}

ie/cause.go

@@ -65,15 +65,18 @@ func (cause Cause) IsZeroValue() bool {
 	return cause.Value == 0
 }
 
-func DeserializeCause(ieHeader Header, ieValue []byte) (Cause, error) {
-	var cause Cause
+func (cause Cause) SetHeader(ieHeader Header) InformationElement {
+	cause.Header = ieHeader
+	return cause
+}
+
+func DeserializeCause(ieValue []byte) (Cause, error) {
 
 	if len(ieValue) != 1 {
-		return cause, fmt.Errorf("invalid length for Cause: got %d bytes, want 1", len(ieValue))
+		return Cause{}, fmt.Errorf("invalid length for Cause: got %d bytes, want 1", len(ieValue))
 	}
 
 	return Cause{
-		Header: ieHeader,
-		Value:  CauseValue(ieValue[0]),
+		Value: CauseValue(ieValue[0]),
 	}, nil
 }

ie/create_far.go

@@ -47,25 +47,28 @@ func (createfar CreateFAR) IsZeroValue() bool {
 	return createfar.Header.Length == 0
 }
 
-func DeserializeCreateFAR(ieHeader Header, value []byte) (CreateFAR, error) {
+func (createfar CreateFAR) SetHeader(header Header) InformationElement {
+	createfar.Header = header
+	return createfar
+}
+
+func DeserializeCreateFAR(value []byte) (CreateFAR, error) {
 	var createfar CreateFAR
 
 	if len(value) < HeaderLength {
-		return createfar, fmt.Errorf("invalid length for CreateFAR: got %d bytes, want at least %d", len(value), HeaderLength)
+		return CreateFAR{}, fmt.Errorf("invalid length for CreateFAR: got %d bytes, want at least %d", len(value), HeaderLength)
 	}
 
-	createfar.Header = ieHeader
-
 	buffer := bytes.NewBuffer(value)
 
 	// Deserialize FARID
 	if buffer.Len() < 2 {
-		return createfar, fmt.Errorf("not enough data for FARID type")
+		return CreateFAR{}, fmt.Errorf("not enough data for FARID type")
 	}
 	faridIEType := binary.BigEndian.Uint16(buffer.Next(2))
 
 	if buffer.Len() < 2 {
-		return createfar, fmt.Errorf("not enough data for FARID length")
+		return CreateFAR{}, fmt.Errorf("not enough data for FARID length")
 	}
 
 	faridIELength := binary.BigEndian.Uint16(buffer.Next(2))
@@ -76,24 +79,29 @@ func DeserializeCreateFAR(ieHeader Header, value []byte) (CreateFAR, error) {
 		Length: faridIELength,
 	}
 
-	farid, err := DeserializeFARID(faridIEHEader, faridIEValue)
+	tempFarid, err := DeserializeFARID(faridIEValue)
 	if err != nil {
-		return createfar, fmt.Errorf("failed to deserialize FARID: %v", err)
+		return CreateFAR{}, fmt.Errorf("failed to deserialize FARID: %v", err)
+	}
+	farid, ok := tempFarid.SetHeader(faridIEHEader).(FARID)
+	if !ok {
+		return CreateFAR{}, fmt.Errorf("type assertion to FarID failed")
 	}
+
 	createfar.FARID = farid
 
 	if buffer.Len() < 2 {
-		return createfar, fmt.Errorf("not enough data for ApplyAction type")
+		return CreateFAR{}, fmt.Errorf("not enough data for ApplyAction type")
 	}
 	applyactionIEType := binary.BigEndian.Uint16(buffer.Next(2))
 
 	if buffer.Len() < 2 {
-		return createfar, fmt.Errorf("not enough data for ApplyAction length")
+		return CreateFAR{}, fmt.Errorf("not enough data for ApplyAction length")
 	}
 	applyactionIELength := binary.BigEndian.Uint16(buffer.Next(2))
 
 	if buffer.Len() < int(applyactionIELength) {
-		return createfar, fmt.Errorf("not enough data for ApplyAction value, expected %d, got %d", applyactionIELength, buffer.Len())
+		return CreateFAR{}, fmt.Errorf("not enough data for ApplyAction value, expected %d, got %d", applyactionIELength, buffer.Len())
 	}
 	applyactionIEValue := buffer.Next(int(applyactionIELength))
 
@@ -102,10 +110,16 @@ func DeserializeCreateFAR(ieHeader Header, value []byte) (CreateFAR, error) {
 		Length: applyactionIELength,
 	}
 
-	applyaction, err := DeserializeApplyAction(applyActionHeader, applyactionIEValue)
+	tempApplyaction, err := DeserializeApplyAction(applyactionIEValue)
 	if err != nil {
-		return createfar, fmt.Errorf("failed to deserialize ApplyAction: %v", err)
+		return CreateFAR{}, fmt.Errorf("failed to deserialize ApplyAction: %v", err)
+	}
+
+	applyaction, ok := tempApplyaction.SetHeader(applyActionHeader).(ApplyAction)
+	if !ok {
+		return CreateFAR{}, fmt.Errorf("type assertion to ApplyAction failed")
 	}
+
 	createfar.ApplyAction = applyaction
 	return createfar, nil
 }

ie/create_far_test.go

@@ -26,14 +26,6 @@ func TestGivenCorrectValuesWhenNewFarThenFieldsSetCorrectly(t *testing.T) {
 		t.Fatalf("Error creating CreateFAR: %v", err)
 	}
 
-	if createFar.Header.Type != 3 {
-		t.Errorf("Expected IEType 3, got %d", createFar.Header.Type)
-	}
-
-	if createFar.Header.Length != 14 {
-		t.Errorf("Expected Length 14, got %d", createFar.Header.Length)
-	}
-
 	if createFar.FARID.Value != 1 {
 		t.Errorf("Expected FARID 1, got %d", createFar.FARID.Value)
 	}
@@ -113,25 +105,12 @@ func TestGivenSerializedWhenDeserializeCreateFarThenFieldsSetCorrectly(t *testin
 
 	serialized := createFar.Serialize()
 
-	ieHeader := ie.Header{
-		Type:   3,
-		Length: 14,
-	}
-
-	deserialized, err := ie.DeserializeCreateFAR(ieHeader, serialized[4:])
+	deserialized, err := ie.DeserializeCreateFAR(serialized[4:])
 
 	if err != nil {
 		t.Fatalf("Error deserializing CreateFAR: %v", err)
 	}
 
-	if deserialized.Header.Type != 3 {
-		t.Errorf("Expected IEType 3, got %d", deserialized.Header.Type)
-	}
-
-	if deserialized.Header.Length != 14 {
-		t.Errorf("Expected Length 14, got %d", deserialized.Header.Length)
-	}
-
 	if deserialized.FARID != farId {
 		t.Errorf("Expected FARID %v, got %v", farId, deserialized.FARID)
 	}

ie/create_pdr.go

@@ -53,9 +53,13 @@ func (createPDR CreatePDR) Serialize() []byte {
 
 }
 
-func DeserializeCreatePDR(ieHeader Header, value []byte) (CreatePDR, error) {
+func (createPDR CreatePDR) SetHeader(header Header) InformationElement {
+	createPDR.Header = header
+	return createPDR
+}
+
+func DeserializeCreatePDR(value []byte) (CreatePDR, error) {
 	createPDR := CreatePDR{
-		Header:     ieHeader,
 		PDRID:      PDRID{},
 		Precedence: Precedence{},
 		PDI:        PDI{},
@@ -82,30 +86,43 @@ func DeserializeCreatePDR(ieHeader Header, value []byte) (CreatePDR, error) {
 				Type:   IEType(currentIEType),
 				Length: currentIELength,
 			}
-			pdrID, err := DeserializePDRID(pdrIDHeader, currentIEValue)
+
+			tempPdrID, err := DeserializePDRID(currentIEValue)
 			if err != nil {
 				return CreatePDR{}, fmt.Errorf("failed to deserialize PDR ID: %v", err)
 			}
+			pdrID, ok := tempPdrID.SetHeader(pdrIDHeader).(PDRID)
+			if !ok {
+				return CreatePDR{}, fmt.Errorf("type assertion to PDRID failed")
+			}
 			createPDR.PDRID = pdrID
 		case PrecedenceIEType:
 			precedenceHeader := Header{
 				Type:   IEType(currentIEType),
 				Length: currentIELength,
 			}
-			precedence, err := DeserializePrecedence(precedenceHeader, currentIEValue)
+			tempPrecedence, err := DeserializePrecedence(currentIEValue)
 			if err != nil {
 				return CreatePDR{}, fmt.Errorf("failed to deserialize Precedence: %v", err)
 			}
+			precedence, ok := tempPrecedence.SetHeader(precedenceHeader).(Precedence)
+			if !ok {
+				return CreatePDR{}, fmt.Errorf("type assertion to Precedence failed")
+			}
 			createPDR.Precedence = precedence
 		case PDIIEType:
-			pdiIEHEader := Header{
+			pdiIEHeader := Header{
 				Type:   IEType(currentIEType),
 				Length: currentIELength,
 			}
-			pdi, err := DeserializePDI(pdiIEHEader, currentIEValue)
+			tempPDI, err := DeserializePDI(currentIEValue)
 			if err != nil {
 				return CreatePDR{}, fmt.Errorf("failed to deserialize PDI: %v", err)
 			}
+			pdi, ok := tempPDI.SetHeader(pdiIEHeader).(PDI)
+			if !ok {
+				return CreatePDR{}, fmt.Errorf("type assertion to PDI failed")
+			}
 			createPDR.PDI = pdi
 		}
 

ie/create_pdr_test.go

@@ -41,14 +41,6 @@ func TestGivenCorrectParametersWhenNewCreatePDRThenFieldsSetCorrectly(t *testing
 		t.Fatalf("Error creating CreatePDR: %v", err)
 	}
 
-	if createPDR.Header.Type != 1 {
-		t.Errorf("Expected CreatePDR IEType 1, got %d", createPDR.Header.Type)
-	}
-
-	if createPDR.Header.Length != 29 {
-		t.Errorf("Expected CreatePDR length 29, got %d", createPDR.Header.Length)
-	}
-
 	if createPDR.PDRID != pdrID {
 		t.Errorf("Expected CreatePDR PDRID %v, got %v", pdrID, createPDR.PDRID)
 	}
@@ -145,25 +137,12 @@ func TestGivenSerializedWhenDeserializeCreatePDRThenFieldsSetCorrectly(t *testin
 
 	serialized := createPDR.Serialize()
 
-	ieHeader := ie.Header{
-		Type:   1,
-		Length: 17,
-	}
-
-	deserialized, err := ie.DeserializeCreatePDR(ieHeader, serialized[4:])
+	deserialized, err := ie.DeserializeCreatePDR(serialized[4:])
 
 	if err != nil {
 		t.Fatalf("Error deserializing CreatePDR: %v", err)
 	}
 
-	if deserialized.Header.Type != 1 {
-		t.Errorf("Expected CreatePDR IEType 1, got %d", deserialized.Header.Type)
-	}
-
-	if deserialized.Header.Length != 17 {
-		t.Errorf("Expected CreatePDR length 17, got %d", deserialized.Header.Length)
-	}
-
 	if deserialized.PDRID != pdrID {
 		t.Errorf("Expected CreatePDR PDRID %v, got %v", pdrID, deserialized.PDRID)
 	}

ie/farID.go

@@ -39,17 +39,17 @@ func (farID FARID) IsZeroValue() bool {
 	return farID.Header.Length == 0
 }
 
-func DeserializeFARID(ieHeader Header, ieValue []byte) (FARID, error) {
+func (farID FARID) SetHeader(header Header) InformationElement {
+	farID.Header = header
+	return farID
+}
+
+func DeserializeFARID(ieValue []byte) (FARID, error) {
 	if len(ieValue) != 4 {
 		return FARID{}, fmt.Errorf("invalid length for FARID: got %d bytes, want 4", len(ieValue))
 	}
 
-	if ieHeader.Type != FARIDIEType {
-		return FARID{}, fmt.Errorf("invalid IE type for FARID: got %d, want %d", ieHeader.Type, FARIDIEType)
-	}
-
 	return FARID{
-		Header: ieHeader,
-		Value:  binary.BigEndian.Uint32(ieValue),
+		Value: binary.BigEndian.Uint32(ieValue),
 	}, nil
 }

ie/farID_test.go

@@ -15,14 +15,6 @@ func TestGivenCorrectFarIDValueWhenNewFarIDThenFieldsSetCorrectly(t *testing.T)
 		t.Fatalf("Expected no error, got %v", err)
 	}
 
-	if farID.Header.Type != 108 {
-		t.Errorf("Expected IEType %d, got %d", 108, farID.Header.Type)
-	}
-
-	if farID.Header.Length != 4 {
-		t.Errorf("Expected Length %d, got %d", 4, farID.Header.Length)
-	}
-
 	if farID.Value != farIDValue {
 		t.Errorf("Expected FarIDValue %d, got %d", farIDValue, farID.Value)
 	}
@@ -38,24 +30,12 @@ func TestGivenFarIDSerializedWhenDeserializeThenFieldsSetCorrectly(t *testing.T)
 
 	farIDSerialized := farID.Serialize()
 
-	ieHeader := ie.Header{
-		Type:   108,
-		Length: 4,
-	}
-	deserializedFarID, err := ie.DeserializeFARID(ieHeader, farIDSerialized[4:])
+	deserializedFarID, err := ie.DeserializeFARID(farIDSerialized[4:])
 
 	if err != nil {
 		t.Fatalf("Expected no error, got %v", err)
 	}
 
-	if deserializedFarID.Header.Type != 108 {
-		t.Errorf("Expected IEType %d, got %d", 108, deserializedFarID.Header.Type)
-	}
-
-	if deserializedFarID.Header.Length != 4 {
-		t.Errorf("Expected Length %d, got %d", 4, deserializedFarID.Header.Length)
-	}
-
 	if deserializedFarID.Value != farIDValue {
 		t.Errorf("Expected FarIDValue %d, got %d", farIDValue, deserializedFarID.Value)
 	}