service.tmpl

// Code generated by go generate via cmd/definitions; DO NOT EDIT.
package {{ .Name }}

import (
    "context"
    "io"
    "time"

    "github.com/beyondstorage/go-storage/v4/pkg/httpclient"
    "github.com/beyondstorage/go-storage/v4/services"
    . "github.com/beyondstorage/go-storage/v4/types"
)

var _ Storager
var _ services.ServiceError
var _ httpclient.Options
var _ time.Duration

// Type is the type for {{ .Name }}
const Type = "{{ .Name }}"

// ObjectSystemMetadata stores system metadata for object.
type ObjectSystemMetadata struct {
{{- range $_, $v := .Infos }}
    {{- if eq $v.Scope "object" }}
    {{- if not $v.Global }}
    {{- $pname := $v.Name | toPascal }}
    {{- if $v.DisplayName }}
        {{- $pname = $v.DisplayName }}
    {{- end }}
    {{ $v.Description }}
    {{ $pname }} {{ $v.Type }}
    {{- end }}
    {{- end }}
{{- end }}
}

// GetObjectSystemMetadata will get ObjectSystemMetadata from Object.
//
// - This function should not be called by service implementer.
// - The returning ObjectServiceMetadata is read only and should not be modified.
func GetObjectSystemMetadata(o *Object) ObjectSystemMetadata {
    sm, ok := o.GetSystemMetadata()
    if ok {
        return sm.(ObjectSystemMetadata)
    }
    return ObjectSystemMetadata{}
}

// setObjectSystemMetadata will set ObjectSystemMetadata into Object.
//
// - This function should only be called once, please make sure all data has been written before set.
func setObjectSystemMetadata(o *Object, sm ObjectSystemMetadata) {
    o.SetSystemMetadata(sm)
}

// StorageSystemMetadata stores system metadata for storage meta.
type StorageSystemMetadata struct {
{{- range $_, $v := .Infos }}
    {{- if eq $v.Scope "storage" }}
        {{- if not $v.Global }}
            {{- $pname := $v.Name | toPascal }}
            {{- if $v.DisplayName }}
                {{- $pname = $v.DisplayName }}
            {{- end }}
            {{ $v.Description }}
            {{ $pname }} {{ $v.Type }}
        {{- end }}
    {{- end }}
{{- end }}
}

// GetStorageSystemMetadata will get SystemMetadata from StorageMeta.
//
// - The returning StorageSystemMetadata is read only and should not be modified.
func GetStorageSystemMetadata(s *StorageMeta) StorageSystemMetadata {
    sm, ok := s.GetSystemMetadata()
    if ok {
        return sm.(StorageSystemMetadata)
    }
    return StorageSystemMetadata{}
}

// setStorageSystemMetadata will set SystemMetadata into StorageMeta.
//
// - This function should only be called once, please make sure all data has been written before set.
func setStorageSystemMetadata(s *StorageMeta, sm StorageSystemMetadata) {
    s.SetSystemMetadata(sm)
}

{{- range $_, $v := .Pairs }}
{{- if not $v.Global }}
{{- $pname := $v.Name | toPascal }}
{{- if $v.Conflict }}
// Deprecated: Use pairs.With{{ $pname }} instead.
//
{{- end }}
// With{{ $pname }} will apply {{ $v.Name }} value to Options.
//
{{ $v.Description }}
func With{{ $pname }}(v {{ $v.Type }}) Pair {
        return Pair{
        Key: "{{ $v.Name }}",
        Value: v,
    }
}
{{- end }}
{{- end }}

var pairMap = map[string]string {
    {{- range $_, $v := .Pairs }}
    {{- $pname := $v.Name | toPascal }}
    "{{ $v.Name }}": "{{ $v.Type }}",
    {{- end }}
}

{{- range $_, $v := .Namespaces }}
    {{- template "interfaces" makeSlice $v.Name $v.Interfaces }}
    {{- template "features" makeSlice $v.Name $v.Funcs $v.Features }}
    {{- template "pair_new" makeSlice ( $v.Name | toPascal ) $v.New }}
    {{- template "pairs" makeSlice $v $v.Funcs }}
    {{- template "functions" makeSlice $v.Name $v.Funcs }}
{{- end }}

{{- define "interfaces" }}
{{- $pn := index . 0 }}
{{- $inters := index . 1 }}
var (
    {{- range $_, $v := $inters }}
    _ {{ $v.Name | toPascal }} = &{{ $pn | toPascal }}{}
    {{- end }}
)
{{- end }}

{{- define "features" }}
{{- $pn := index . 0 | toPascal }}
{{- $fns := index . 1 }}
{{- $fs := index . 2 }}

type {{ $pn }}Features struct {
    {{- range $_, $v := $fs }}
    {{ $v.Description }}
    {{ $v.Name | toPascal }} bool
    {{- end }}
}
{{- end }}

{{- define "pair_new" }}
{{- $pn := index . 0 }}
{{- $fn := index . 1 }}

{{- $fnk := $fn.Name | toPascal }}

// pair{{ $pn }}{{ $fnk }} is the parsed struct
type pair{{ $pn }}{{$fnk}} struct {
    pairs []Pair

    // Required pairs
    {{- range $_, $pair := $fn.Required }}
    Has{{ $pair.Name | toPascal }}   bool
    {{ $pair.Name | toPascal }}    {{ $pair.Type }}
    {{- end }}
    // Optional pairs
    {{- range $_, $pair := $fn.Optional }}
    Has{{ $pair.Name | toPascal }}   bool
    {{ $pair.Name | toPascal }}      {{ $pair.Type }}
    {{- end }}
}

// parsePair{{ $pn }}{{ $fnk }} will parse Pair slice into *pair{{ $pn }}{{ $fnk }}
func parsePair{{ $pn }}{{ $fnk }}(opts []Pair) (pair{{ $pn }}{{ $fnk }}, error) {
    result := pair{{ $pn }}{{ $fnk }}{
        pairs: opts,
    }

    for _, v := range opts {
        switch v.Key {
        // Required pairs
        {{- range $_, $pair := $fn.Required }}
        case "{{ $pair.Name }}":
            if result.Has{{ $pair.Name | toPascal }} {
                continue
            }
            result.Has{{ $pair.Name | toPascal }} = true
            result.{{ $pair.Name | toPascal }} = v.Value.({{ $pair.Type }})
        {{- end }}
        // Optional pairs
        {{- range $_, $pair := $fn.Optional }}
        case "{{ $pair.Name }}":
            if result.Has{{ $pair.Name | toPascal }} {
                continue
            }
            result.Has{{ $pair.Name | toPascal }} = true
            result.{{ $pair.Name | toPascal }} = v.Value.({{ $pair.Type }})
        {{- end }}
        }
    }

    {{- range $_, $pair := $fn.Required }}
    if !result.Has{{ $pair.Name | toPascal }} {
        return pair{{ $pn }}{{ $fnk }}{}, services.PairRequiredError{ Keys:[]string{ "{{ $pair.Name }}" } }
    }
    {{- end }}

    return result, nil
}
{{- end }}

{{- define "pairs" }}
{{- $pn := index . 0 }}
{{- $data := index . 1 }}

{{- $pnk := $pn.Name | toPascal }}

// Default{{ $pnk }}Pairs is default pairs for specific action
type Default{{ $pnk }}Pairs struct {
{{- range $_, $v := $data }}
    {{ $v.Name | toPascal }} []Pair
{{- end }}
}

    {{- range $_, $v := $data }}
        {{- template "pair" makeSlice $pn $v}}
    {{- end }}
{{- end }}

{{- define "pair" }}
{{- $pn := index . 0 }}
{{- $fn := index . 1 }}

{{- $pnk := $pn.Name | toPascal }}
{{- $fnk := $fn.Name | toPascal }}

// pair{{ $pnk }}{{ $fnk }} is the parsed struct
type pair{{ $pnk }}{{ $fnk }} struct {
    pairs []Pair

    {{- range $_, $pair := $fn.Required }}
    Has{{ $pair.Name | toPascal }}   bool
    {{ $pair.Name | toPascal }}      {{ $pair.Type }}
    {{- end }}
    {{- range $_, $pair := $fn.Optional }}
    Has{{ $pair.Name | toPascal }}   bool
    {{ $pair.Name | toPascal }}      {{ $pair.Type }}
    {{- end }}
}

// parsePair{{ $pnk }}{{ $fnk }} will parse Pair slice into *pair{{ $pnk }}{{ $fnk }}
func (s *{{ $pnk }})parsePair{{ $pnk }}{{ $fnk }}(opts []Pair) (pair{{ $pnk }}{{ $fnk }}, error) {
    result := pair{{ $pnk }}{{ $fnk }}{
        pairs: opts,
    }

    for _, v := range opts {
        switch v.Key {
        {{- range $_, $pair := $fn.Required }}
        case "{{ $pair.Name }}":
            if result.Has{{ $pair.Name | toPascal }} {
                continue
            }
            result.Has{{ $pair.Name | toPascal }} = true
            result.{{ $pair.Name | toPascal }} = v.Value.({{ $pair.Type }})
            continue
        {{- end }}
        {{- range $_, $pair := $fn.Optional }}
        case "{{ $pair.Name }}":
            if result.Has{{ $pair.Name | toPascal }} {
                continue
            }
            result.Has{{ $pair.Name | toPascal }} = true
            result.{{ $pair.Name | toPascal }} = v.Value.({{ $pair.Type }})
            continue
        {{- end }}
        default:
            {{- if $pn.HasFeatureLoosePair }}
            // loose_pair feature introduced in GSP-109.
            // If user enable this feature, service should ignore not support pair error.
            if s.features.LoosePair {
                continue
            }
            {{- end }}
            return pair{{ $pnk }}{{ $fnk }}{}, services.PairUnsupportedError{Pair:v}
        }
    }

    // Check required pairs.
    {{- range $_, $pair := $fn.Required }}
    if !result.Has{{ $pair.Name | toPascal }} {
        return pair{{ $pnk }}{{ $fnk }}{}, services.PairRequiredError{ Keys:[]string{ "{{ $pair.Name }}" } }
    }
    {{- end }}

    return result, nil
}
{{- end }}

{{- define "functions" }}
    {{- $pn := index . 0 | toPascal }}
    {{- $data := index . 1 }}

    {{- range $_, $v := $data }}
        {{- if $v.Local }}
        {{- template "local_function" makeSlice $pn $v}}
        {{- else }}
        {{- template "function" makeSlice $pn $v}}
        {{- end }}
    {{- end }}
{{- end }}

{{- define "function" }}
{{- $pn := index . 0 }}
{{- $fn := index . 1 }}

{{ $fnk := $fn.Name | toPascal }}

// {{ $fnk }} {{ $fn.Description }}
//
// This function will create a context by default.
func (s *{{$pn}}) {{ $fnk }}({{$fn.Params.String}}) ({{$fn.Results.String}}) {
    ctx := context.Background()
    return s.{{ $fnk }}WithContext(ctx, {{$fn.Params.Caller}})
}

// {{ $fnk }}WithContext {{ $fn.Description }}
func (s *{{$pn}}) {{ $fnk }}WithContext(ctx context.Context, {{$fn.Params.String}}) ({{$fn.Results.String}}) {
    defer func(){
        {{- $path := $fn.Params.PathCaller }}
        {{- if and (eq $path "") (eq $pn "Service") }}
            {{ $path = ",\"\"" }}
        {{- end }}
        err = s.formatError("{{$fn.Name}}", err {{ $path }} )
    }()

    {{- if ne $fn.ObjectMode "" }}
    {{- $mode := $fn.ObjectMode | toPascal }}
    if !o.Mode.Is{{ $mode }}() {
        err = services.ObjectModeInvalidError{Expected: Mode{{ $mode }}, Actual: o.Mode}
        return
    }
    {{- end }}

    pairs = append(pairs, s.defaultPairs.{{ $fnk }}...)
    var opt pair{{ $pn }}{{ $fnk }}

    opt, err = s.parsePair{{ $pn }}{{ $fnk }}(pairs)
    if err != nil {
        return
    }

    return s.{{ $fn.Name | toCamel }}(ctx, {{$fn.Params.TrimLast.CallerEndswithComma}} opt)
}
{{- end }}

{{- define "local_function" }}
    {{- $pn := index . 0 }}
    {{- $fn := index . 1 }}

    {{ $fnk := $fn.Name | toPascal }}

    // {{ $fnk }} {{ $fn.Description }}
    //
    // This function will create a context by default.
    func (s *{{$pn}}) {{ $fnk }}({{$fn.Params.String}}) ({{$fn.Results.String}}) {
        pairs = append(pairs, s.defaultPairs.{{ $fnk }}...)
        var opt pair{{ $pn }}{{ $fnk }}

        // Ignore error while handling local funtions.
        opt, _ = s.parsePair{{ $pn }}{{ $fnk }}(pairs)

        return s.{{  $fn.Name | toCamel }}({{$fn.Params.TrimLast.CallerEndswithComma}} opt)
    }
{{- end }}

func init() {
    {{- range $_, $v := .Namespaces }}
        services.Register{{ $v.Name | toPascal }}r(Type, New{{ $v.Name | toPascal }}r)
    {{- end }}
    services.RegisterSchema(Type, pairMap)
}