generator

var MetaTmpl string

var OctopusFixtureRepositoryTmpl string

var OctopusFormatMapper = map[octopus.Format]OctopusFormatParam{
	octopus.Bool:    {Name: "Uint8", UnpackConvFunc: "octopus.UintToBool", /* contains filtered or unexported fields */},
	octopus.Uint8:   {Name: "Uint8", /* contains filtered or unexported fields */},
	octopus.Uint16:  {Name: "Uint16", /* contains filtered or unexported fields */},
	octopus.Uint32:  {Name: "Uint32", /* contains filtered or unexported fields */},
	octopus.Uint64:  {Name: "Uint64", /* contains filtered or unexported fields */},
	octopus.Uint:    {Name: "Uint32", UnpackConvFunc: "uint", /* contains filtered or unexported fields */},
	octopus.Int8:    {Name: "Uint8", UnpackConvFunc: "int8", /* contains filtered or unexported fields */},
	octopus.Int16:   {Name: "Uint16", UnpackConvFunc: "int16", /* contains filtered or unexported fields */},
	octopus.Int32:   {Name: "Uint32", UnpackConvFunc: "int32", /* contains filtered or unexported fields */},
	octopus.Int64:   {Name: "Uint64", UnpackConvFunc: "int64", /* contains filtered or unexported fields */},
	octopus.Int:     {Name: "Uint32", UnpackConvFunc: "int", /* contains filtered or unexported fields */},
	octopus.Float32: {Name: "Uint32", UnpackConvFunc: "math.Float32frombits", /* contains filtered or unexported fields */},
	octopus.Float64: {Name: "Uint64", UnpackConvFunc: "math.Float64frombits", /* contains filtered or unexported fields */},
	octopus.String:  {Name: "String", /* contains filtered or unexported fields */}}

var OctopusMockRepositoryTmpl string

var OctopusMutatorMapper = map[string]OctopusMutatorParam{
	ds.IncMutator:      {Name: "Inc", AvailableType: octopus.NumericFormat},
	ds.DecMutator:      {Name: "Dec", AvailableType: octopus.NumericFormat},
	ds.AndMutator:      {Name: "And", AvailableType: octopus.UnsignedFormat},
	ds.OrMutator:       {Name: "Or", AvailableType: octopus.UnsignedFormat},
	ds.XorMutator:      {Name: "Xor", AvailableType: octopus.UnsignedFormat},
	ds.ClearBitMutator: {Name: "ClearBit", AvailableType: octopus.UnsignedFormat},
	ds.SetBitMutator:   {Name: "SetBit", AvailableType: octopus.UnsignedFormat},
}

var OctopusRootRepositoryTmpl string

var OctopusTemplateFuncs = template.FuncMap{
	"packerParam": func(format octopus.Format) OctopusFormatParam {
		ret, ex := OctopusFormatMapper[format]
		if !ex {
			log.Fatalf("packer for type `%s` not found", format)
		}

		return ret
	},
	"mutatorParam": func(mut string, format octopus.Format) OctopusMutatorParam {
		ret, ex := OctopusMutatorMapper[mut]
		if !ex {
			log.Fatalf("mutator packer for type `%s` not found", format)
		}

		for _, availFormat := range ret.AvailableType {
			if availFormat == format {
				return ret
			}
		}

		log.Fatalf("Mutator `%s` not available for type `%s`", mut, format)

		return OctopusMutatorParam{}
	},
	"addImport": func(flds []ds.FieldDeclaration) (imports []string) {
		var needMath, needStrconv bool

		for _, fld := range flds {
			if fld.Format == octopus.Float32 || fld.Format == octopus.Float64 {
				needMath = true
			}

			if len(fld.Mutators) > 0 && fld.Format != "uint32" && fld.Format != "uint64" && fld.Format != "uint" {
				needMath = true
			}

			if fld.PrimaryKey && fld.Format != "string" {
				needStrconv = true
			}
		}

		if needMath {
			imports = append(imports, "math")
		}

		if needStrconv {
			imports = append(imports, "strconv")
		}

		return
	},
	"trimPrefix": strings.TrimPrefix,
	"hasPrefix":  strings.HasPrefix,
}

var PrimitiveTypeFormatConverter = map[octopus.Format]TarantoolFormatParam{
	octopus.Bool:    "strconv.FormatBool(%%)",
	octopus.Uint8:   "strconv.FormatUint(uint64(%%), 10)",
	octopus.Uint16:  "strconv.FormatUint(uint64(%%), 10)",
	octopus.Uint32:  "strconv.FormatUint(uint64(%%), 10)",
	octopus.Uint64:  "strconv.FormatUint(%%, 10)",
	octopus.Uint:    "strconv.FormatUint(uint64(%%), 10)",
	octopus.Int8:    "strconv.FormatInt(int64(%%), 10)",
	octopus.Int16:   "strconv.FormatInt(int64(%%), 10)",
	octopus.Int32:   "strconv.FormatInt(int64(%%), 10)",
	octopus.Int64:   "strconv.FormatInt(%%, 10)",
	octopus.Int:     "strconv.FormatInt(int64(%%), 10)",
	octopus.Float32: "strconv.FormatFloat(%%, 32)",
	octopus.Float64: "strconv.FormatFloat(%%, 64)",
	octopus.String:  "%%",
}

var Tarantool2TmplFunc = template.FuncMap{
	"packerParam": func(format octopus.Format) TarantoolFormatParam {
		ret, ex := PrimitiveTypeFormatConverter[format]
		if !ex {
			log.Fatalf("packer for type `%s` not found", format)
		}

		return ret
	},
	"addImport": func(flds []ds.FieldDeclaration) (imports []string) {
		var needStrconv bool

		for _, fld := range flds {
			if fld.PrimaryKey && fld.Format != "string" {
				needStrconv = true
			}
		}

		if needStrconv {
			imports = append(imports, "strconv")
		}

		return
	},
	"trimPrefix":       strings.TrimPrefix,
	"hasPrefix":        strings.HasPrefix,
	"lowerCase":        strings.ToLower,
	"snakeToCamelCase": text.SnakeToCamelCase,
}

var ToLower = cases.Title(language.English)