in packages/autorest.go/src/m4togocodemodel/types.ts [273:496]
export function adaptPossibleType(schema: m4.Schema, elementTypeByValue?: boolean): go.PossibleType {
const rawJSONAsBytes = <boolean>schema.language.go!.rawJSONAsBytes;
switch (schema.type) {
case m4.SchemaType.Any: {
if (rawJSONAsBytes) {
const anyRawJSONKey = `${m4.SchemaType.Any}-raw-json`;
let anyRawJSON = types.get(anyRawJSONKey);
if (anyRawJSON) {
return anyRawJSON;
}
anyRawJSON = new go.SliceType(new go.PrimitiveType('byte'), true);
anyRawJSON.rawJSONAsBytes = true;
types.set(anyRawJSONKey, anyRawJSON);
return anyRawJSON;
}
let anyType = types.get(m4.SchemaType.Any);
if (anyType) {
return anyType;
}
anyType = new go.PrimitiveType('any');
types.set(m4.SchemaType.Any, anyType);
return anyType;
}
case m4.SchemaType.AnyObject: {
if (rawJSONAsBytes) {
const anyObjectRawJSONKey = `${m4.SchemaType.Any}-raw-json`;
let anyObjectRawJSON = types.get(anyObjectRawJSONKey);
if (anyObjectRawJSON) {
return anyObjectRawJSON;
}
anyObjectRawJSON = new go.SliceType(new go.PrimitiveType('byte'), true);
anyObjectRawJSON.rawJSONAsBytes = true;
types.set(anyObjectRawJSONKey, anyObjectRawJSON);
return anyObjectRawJSON;
}
let anyObject = types.get(m4.SchemaType.AnyObject);
if (anyObject) {
return anyObject;
}
anyObject = new go.MapType(new go.PrimitiveType('any'), true);
types.set(m4.SchemaType.AnyObject, anyObject);
return anyObject;
}
case m4.SchemaType.ArmId: {
let stringType = types.get(m4.SchemaType.String);
if (stringType) {
return stringType;
}
stringType = new go.PrimitiveType('string');
types.set(m4.SchemaType.ArmId, stringType);
return stringType;
}
case m4.SchemaType.Array: {
let myElementTypeByValue = !schema.language.go!.elementIsPtr;
if (elementTypeByValue) {
myElementTypeByValue = elementTypeByValue;
}
const keyName = recursiveKeyName(`${m4.SchemaType.Array}-${myElementTypeByValue}`, (<m4.ArraySchema>schema).elementType);
let arrayType = types.get(keyName);
if (arrayType) {
return arrayType;
}
arrayType = new go.SliceType(adaptPossibleType((<m4.ArraySchema>schema).elementType, elementTypeByValue), myElementTypeByValue);
types.set(keyName, arrayType);
return arrayType;
}
case m4.SchemaType.Binary: {
let binaryType = types.get(m4.SchemaType.Binary);
if (binaryType) {
return binaryType;
}
binaryType = new go.QualifiedType('ReadSeekCloser', 'io');
types.set(m4.SchemaType.Binary, binaryType);
return binaryType;
}
case m4.SchemaType.Boolean: {
let primitiveBool = types.get(m4.SchemaType.Boolean);
if (primitiveBool) {
return primitiveBool;
}
primitiveBool = new go.PrimitiveType('bool');
types.set(m4.SchemaType.Boolean, primitiveBool);
return primitiveBool;
}
case m4.SchemaType.ByteArray:
return adaptBytesType(<m4.ByteArraySchema>schema);
case m4.SchemaType.Char: {
let rune = types.get(m4.SchemaType.Char);
if (rune) {
return rune;
}
rune = new go.PrimitiveType('rune');
types.set(m4.SchemaType.Char, rune);
return rune;
}
case m4.SchemaType.Choice:
return adaptConstantType(<m4.ChoiceSchema>schema);
case m4.SchemaType.Constant:
return adaptLiteralValue(<m4.ConstantSchema>schema);
case m4.SchemaType.Credential: {
let credType = types.get(m4.SchemaType.Credential);
if (credType) {
return credType;
}
credType = new go.PrimitiveType('string');
types.set(m4.SchemaType.Credential, credType);
return credType;
}
case m4.SchemaType.Date:
case m4.SchemaType.DateTime:
case m4.SchemaType.Time:
case m4.SchemaType.UnixTime: {
let time = types.get(schema.language.go!.internalTimeType);
if (time) {
return time;
}
time = new go.TimeType(schema.language.go!.internalTimeType, false);
types.set(schema.language.go!.internalTimeType, time);
return time;
}
case m4.SchemaType.Dictionary: {
const valueTypeByValue = !schema.language.go!.elementIsPtr;
const keyName = recursiveKeyName(`${m4.SchemaType.Dictionary}-${valueTypeByValue}`, (<m4.DictionarySchema>schema).elementType);
let mapType = types.get(keyName);
if (mapType) {
return mapType;
}
mapType = new go.MapType(adaptPossibleType((<m4.DictionarySchema>schema).elementType, elementTypeByValue), valueTypeByValue);
types.set(keyName, mapType);
return mapType;
}
case m4.SchemaType.Duration: {
let duration = types.get(m4.SchemaType.Duration);
if (duration) {
return duration;
}
duration = new go.PrimitiveType('string');
types.set(m4.SchemaType.Duration, duration);
return duration;
}
case m4.SchemaType.Integer: {
if ((<m4.NumberSchema>schema).precision === 32) {
const int32Key = 'int32';
let int32 = types.get(int32Key);
if (int32) {
return int32;
}
int32 = new go.PrimitiveType(int32Key);
types.set(int32Key, int32);
return int32;
}
const int64Key = 'int64';
let int64 = types.get(int64Key);
if (int64) {
return int64;
}
int64 = new go.PrimitiveType(int64Key);
types.set(int64Key, int64);
return int64;
}
case m4.SchemaType.Number: {
if ((<m4.NumberSchema>schema).precision === 32) {
const float32Key = 'float32';
let float32 = types.get(float32Key);
if (float32) {
return float32;
}
float32 = new go.PrimitiveType(float32Key);
types.set(float32Key, float32);
return float32;
}
const float64Key = 'float64';
let float64 = types.get(float64Key);
if (float64) {
return float64;
}
float64 = new go.PrimitiveType(float64Key);
types.set(float64Key, float64);
return float64;
}
case m4.SchemaType.Object:
return adaptModel(<m4.ObjectSchema>schema);
case m4.SchemaType.ODataQuery: {
let odataType = types.get(m4.SchemaType.ODataQuery);
if (odataType) {
return odataType;
}
odataType = new go.PrimitiveType('string');
types.set(m4.SchemaType.ODataQuery, odataType);
return odataType;
}
case m4.SchemaType.SealedChoice:
return adaptConstantType(<m4.SealedChoiceSchema>schema);
case m4.SchemaType.String: {
let stringType = types.get(m4.SchemaType.String);
if (stringType) {
return stringType;
}
stringType = new go.PrimitiveType('string');
types.set(m4.SchemaType.String, stringType);
return stringType;
}
case m4.SchemaType.Uri: {
let uriType = types.get(m4.SchemaType.Uri);
if (uriType) {
return uriType;
}
uriType = new go.PrimitiveType('string');
types.set(m4.SchemaType.Uri, uriType);
return uriType;
}
case m4.SchemaType.Uuid: {
let uuid = types.get(m4.SchemaType.Uuid);
if (uuid) {
return uuid;
}
uuid = new go.PrimitiveType('string');
types.set(m4.SchemaType.Uuid, uuid);
return uuid;
}
default:
throw new Error(`unhandled property schema type ${schema.type}`);
}
}