♻️ refact(state): Use GetState to reduce duplicate code (#3542)

♻️ refact: use GetState to reduce duplicate code

Author: ksw2000

state.go

@@ -135,205 +135,103 @@ func GetStateWithDefault[T any](s *State, key string, defaultVal T) T {
 // GetString retrieves a string value from the State.
 // It returns the string and a boolean indicating successful type assertion.
 func (s *State) GetString(key string) (string, bool) {
-	dep, ok := s.Get(key)
-	if ok {
-		depString, okCast := dep.(string)
-		return depString, okCast
-	}
-
-	return "", false
+	return GetState[string](s, key)
 }
 
 // GetInt retrieves an integer value from the State.
 // It returns the int and a boolean indicating successful type assertion.
 func (s *State) GetInt(key string) (int, bool) {
-	dep, ok := s.Get(key)
-	if ok {
-		depInt, okCast := dep.(int)
-		return depInt, okCast
-	}
-
-	return 0, false
+	return GetState[int](s, key)
 }
 
 // GetBool retrieves a boolean value from the State.
 // It returns the bool and a boolean indicating successful type assertion.
 func (s *State) GetBool(key string) (value, ok bool) { //nolint:nonamedreturns // Better idea to use named returns here
-	dep, ok := s.Get(key)
-	if ok {
-		depBool, okCast := dep.(bool)
-		return depBool, okCast
-	}
-
-	return false, false
+	return GetState[bool](s, key)
 }
 
 // GetFloat64 retrieves a float64 value from the State.
 // It returns the float64 and a boolean indicating successful type assertion.
 func (s *State) GetFloat64(key string) (float64, bool) {
-	dep, ok := s.Get(key)
-	if ok {
-		depFloat64, okCast := dep.(float64)
-		return depFloat64, okCast
-	}
-
-	return 0, false
+	return GetState[float64](s, key)
 }
 
 // GetUint retrieves a uint value from the State.
-// It returns the float64 and a boolean indicating successful type assertion.
+// It returns the uint and a boolean indicating successful type assertion.
 func (s *State) GetUint(key string) (uint, bool) {
-	dep, ok := s.Get(key)
-	if ok {
-		if depUint, okCast := dep.(uint); okCast {
-			return depUint, true
-		}
-	}
-	return 0, false
+	return GetState[uint](s, key)
 }
 
 // GetInt8 retrieves an int8 value from the State.
-// It returns the float64 and a boolean indicating successful type assertion.
+// It returns the int8 and a boolean indicating successful type assertion.
 func (s *State) GetInt8(key string) (int8, bool) {
-	dep, ok := s.Get(key)
-	if ok {
-		if depInt8, okCast := dep.(int8); okCast {
-			return depInt8, true
-		}
-	}
-	return 0, false
+	return GetState[int8](s, key)
 }
 
 // GetInt16 retrieves an int16 value from the State.
-// It returns the float64 and a boolean indicating successful type assertion.
+// It returns the int16 and a boolean indicating successful type assertion.
 func (s *State) GetInt16(key string) (int16, bool) {
-	dep, ok := s.Get(key)
-	if ok {
-		if depInt16, okCast := dep.(int16); okCast {
-			return depInt16, true
-		}
-	}
-	return 0, false
+	return GetState[int16](s, key)
 }
 
 // GetInt32 retrieves an int32 value from the State.
-// It returns the float64 and a boolean indicating successful type assertion.
+// It returns the int32 and a boolean indicating successful type assertion.
 func (s *State) GetInt32(key string) (int32, bool) {
-	dep, ok := s.Get(key)
-	if ok {
-		if depInt32, okCast := dep.(int32); okCast {
-			return depInt32, true
-		}
-	}
-	return 0, false
+	return GetState[int32](s, key)
 }
 
 // GetInt64 retrieves an int64 value from the State.
-// It returns the float64 and a boolean indicating successful type assertion.
+// It returns the int64 and a boolean indicating successful type assertion.
 func (s *State) GetInt64(key string) (int64, bool) {
-	dep, ok := s.Get(key)
-	if ok {
-		if depInt64, okCast := dep.(int64); okCast {
-			return depInt64, true
-		}
-	}
-	return 0, false
+	return GetState[int64](s, key)
 }
 
 // GetUint8 retrieves a uint8 value from the State.
-// It returns the float64 and a boolean indicating successful type assertion.
+// It returns the uint8 and a boolean indicating successful type assertion.
 func (s *State) GetUint8(key string) (uint8, bool) {
-	dep, ok := s.Get(key)
-	if ok {
-		if depUint8, okCast := dep.(uint8); okCast {
-			return depUint8, true
-		}
-	}
-	return 0, false
+	return GetState[uint8](s, key)
 }
 
 // GetUint16 retrieves a uint16 value from the State.
-// It returns the float64 and a boolean indicating successful type assertion.
+// It returns the uint16 and a boolean indicating successful type assertion.
 func (s *State) GetUint16(key string) (uint16, bool) {
-	dep, ok := s.Get(key)
-	if ok {
-		if depUint16, okCast := dep.(uint16); okCast {
-			return depUint16, true
-		}
-	}
-	return 0, false
+	return GetState[uint16](s, key)
 }
 
 // GetUint32 retrieves a uint32 value from the State.
-// It returns the float64 and a boolean indicating successful type assertion.
+// It returns the uint32 and a boolean indicating successful type assertion.
 func (s *State) GetUint32(key string) (uint32, bool) {
-	dep, ok := s.Get(key)
-	if ok {
-		if depUint32, okCast := dep.(uint32); okCast {
-			return depUint32, true
-		}
-	}
-	return 0, false
+	return GetState[uint32](s, key)
 }
 
 // GetUint64 retrieves a uint64 value from the State.
-// It returns the float64 and a boolean indicating successful type assertion.
+// It returns the uint64 and a boolean indicating successful type assertion.
 func (s *State) GetUint64(key string) (uint64, bool) {
-	dep, ok := s.Get(key)
-	if ok {
-		if depUint64, okCast := dep.(uint64); okCast {
-			return depUint64, true
-		}
-	}
-	return 0, false
+	return GetState[uint64](s, key)
 }
 
 // GetUintptr retrieves a uintptr value from the State.
-// It returns the float64 and a boolean indicating successful type assertion.
+// It returns the uintptr and a boolean indicating successful type assertion.
 func (s *State) GetUintptr(key string) (uintptr, bool) {
-	dep, ok := s.Get(key)
-	if ok {
-		if depUintptr, okCast := dep.(uintptr); okCast {
-			return depUintptr, true
-		}
-	}
-	return 0, false
+	return GetState[uintptr](s, key)
 }
 
 // GetFloat32 retrieves a float32 value from the State.
-// It returns the float64 and a boolean indicating successful type assertion.
+// It returns the float32 and a boolean indicating successful type assertion.
 func (s *State) GetFloat32(key string) (float32, bool) {
-	dep, ok := s.Get(key)
-	if ok {
-		if depFloat32, okCast := dep.(float32); okCast {
-			return depFloat32, true
-		}
-	}
-	return 0, false
+	return GetState[float32](s, key)
 }
 
 // GetComplex64 retrieves a complex64 value from the State.
-// It returns the float64 and a boolean indicating successful type assertion.
+// It returns the complex64 and a boolean indicating successful type assertion.
 func (s *State) GetComplex64(key string) (complex64, bool) {
-	dep, ok := s.Get(key)
-	if ok {
-		if depComplex64, okCast := dep.(complex64); okCast {
-			return depComplex64, true
-		}
-	}
-	return 0, false
+	return GetState[complex64](s, key)
 }
 
 // GetComplex128 retrieves a complex128 value from the State.
-// It returns the float64 and a boolean indicating successful type assertion.
+// It returns the complex128 and a boolean indicating successful type assertion.
 func (s *State) GetComplex128(key string) (complex128, bool) {
-	dep, ok := s.Get(key)
-	if ok {
-		if depComplex128, okCast := dep.(complex128); okCast {
-			return depComplex128, true
-		}
-	}
-	return 0, false
+	return GetState[complex128](s, key)
 }
 
 // serviceKey returns a key for a service in the State.