function adaptLiteralValue()

in packages/autorest.go/src/m4togocodemodel/types.ts [498:586]
89 lines of code
23 McCabe index (conditional complexity)

function adaptLiteralValue(constSchema: m4.ConstantSchema): go.LiteralValue {
  switch (constSchema.valueType.type) {
    case m4.SchemaType.Boolean: {
      const keyName = `literal-${m4.SchemaType.Boolean}-${constSchema.value.value}`;
      let literalBool = types.get(keyName);
      if (literalBool) {
        return <go.LiteralValue>literalBool;
      }
      literalBool = new go.LiteralValue(new go.PrimitiveType('bool'), constSchema.value.value);
      types.set(keyName, literalBool);
      return literalBool;
    }
    case m4.SchemaType.ByteArray: {
      const keyName = `literal-${m4.SchemaType.ByteArray}-${constSchema.value.value}`;
      let literalByteArray = types.get(keyName);
      if (literalByteArray) {
        return <go.LiteralValue>literalByteArray;
      }
      literalByteArray = new go.LiteralValue(adaptBytesType(<m4.ByteArraySchema>constSchema.valueType), constSchema.value.value);
      types.set(keyName, literalByteArray);
      return literalByteArray;
    }
    case m4.SchemaType.Choice:
    case m4.SchemaType.SealedChoice: {
      const keyName = `literal-${constSchema.language.go!.name}-${constSchema.value.value}`;
      let literalConst = types.get(keyName);
      if (literalConst) {
        return <go.LiteralValue>literalConst;
      }
      literalConst = new go.LiteralValue(adaptConstantType(<m4.ChoiceSchema>constSchema.valueType), constSchema.value.value);
      types.set(keyName, literalConst);
      return literalConst;
    }
    case m4.SchemaType.Date:
    case m4.SchemaType.DateTime:
    case m4.SchemaType.UnixTime: {
      const keyName = `literal-${constSchema.valueType.language.go!.internalTimeType}-${constSchema.value.value}`;
      let literalTime = types.get(keyName);
      if (literalTime) {
        return <go.LiteralValue>literalTime;
      }
      literalTime = new go.LiteralValue(new go.TimeType(constSchema.valueType.language.go!.internalTimeType, false), constSchema.value.value);
      types.set(keyName, literalTime);
      return literalTime;
    }
    case m4.SchemaType.Integer: {
      const keyName = `literal-int${(<m4.NumberSchema>constSchema.valueType).precision}-${constSchema.value.value}`;
      let literalInt = types.get(keyName);
      if (literalInt) {
        return <go.LiteralValue>literalInt;
      }
      if ((<m4.NumberSchema>constSchema.valueType).precision === 32) {
        literalInt = new go.LiteralValue(new go.PrimitiveType('int32'), constSchema.value.value);
      } else {
        literalInt = new go.LiteralValue(new go.PrimitiveType('int64'), constSchema.value.value);
      }
      types.set(keyName, literalInt);
      return literalInt;
    }
    case m4.SchemaType.Number: {
      const keyName = `literal-float${(<m4.NumberSchema>constSchema.valueType).precision}-${constSchema.value.value}`;
      let literalFloat = types.get(keyName);
      if (literalFloat) {
        return <go.LiteralValue>literalFloat;
      }
      if ((<m4.NumberSchema>constSchema.valueType).precision === 32) {
        literalFloat = new go.LiteralValue(new go.PrimitiveType('float32'), constSchema.value.value);
      } else {
        literalFloat = new go.LiteralValue(new go.PrimitiveType('float64'), constSchema.value.value);
      }
      types.set(keyName, literalFloat);
      return literalFloat;
    }
    case m4.SchemaType.String:
    case m4.SchemaType.Duration:
    case m4.SchemaType.Uuid: {
      const keyName = `literal-string-${constSchema.value.value}`;
      let literalString = types.get(keyName);
      if (literalString) {
        return <go.LiteralValue>literalString;
      }
      literalString = new go.LiteralValue(new go.PrimitiveType('string'), constSchema.value.value);
      types.set(keyName, literalString);
      return literalString;
    }
    default:
      throw new Error(`unsupported scheam type ${constSchema.valueType.type} for LiteralValue`);
  }
}