467 lines
9.8 KiB
Twig
467 lines
9.8 KiB
Twig
{% macro decl_units(meta) %}
|
|
{%- for u in meta.getunits ~%}
|
|
{%- if u.object is instanceof('\\mtgMetaStruct') ~%}
|
|
{{ _self.decl_struct(u.object) }}
|
|
{%- elseif u.object is instanceof('\\mtgMetaEnum') ~%}
|
|
{{ _self.decl_enum(u.object) }}
|
|
{%- elseif u.object is instanceof('\\mtgMetaRPC') ~%}
|
|
{{ _self.decl_rpc(u.object) }}
|
|
{%- endif ~%}
|
|
{%- endfor ~%}
|
|
{% endmacro %}
|
|
|
|
{% macro decl_struct(o) %}
|
|
{%- if o.parent and has_token(o, 'POD') -%}
|
|
{{Error("@POD structs can't have a parent: " ~ o.name)}}
|
|
{%- endif -%}
|
|
{%- if o.parent and has_token(o, 'bitfields') -%}
|
|
{{Error("@bitfields structs can't have a parent: " ~ o.name)}}
|
|
{%- endif ~%}
|
|
|
|
//==============================
|
|
type {{o.name}} struct {
|
|
{% if o.parent %}
|
|
{{o.parent.name}}
|
|
{% endif %}
|
|
|
|
{{_self.decl_struct_fields(o)}}
|
|
}
|
|
|
|
var _{{o.name}}_class_props map[string]string = {{_self.props_map(o.tokens)}}
|
|
var _{{o.name}}_class_fields []string = {{_self.struct_fields_names(o)}}
|
|
var _{{o.name}}_fields_props meta.ClassFieldsProps = {{_self.struct_fields_props(o)}}
|
|
|
|
func {{o.name}}_CLASS_ID() uint32 {
|
|
return {{o.classid}}
|
|
}
|
|
|
|
type I{{o.name}} interface {
|
|
meta.IMetaStruct
|
|
Ptr{{o.name}}() *{{o.name}}
|
|
}
|
|
|
|
func (*{{o.name}}) CLASS_ID() uint32 {
|
|
return {{o.classid}}
|
|
}
|
|
|
|
func (*{{o.name}}) CLASS_NAME() string {
|
|
return "{{o.name}}"
|
|
}
|
|
|
|
func (*{{o.name}}) CLASS_PROPS() *map[string]string {
|
|
return &_{{o.name}}_class_props
|
|
}
|
|
|
|
func (*{{o.name}}) CLASS_FIELDS() []string {
|
|
return _{{o.name}}_class_fields
|
|
}
|
|
|
|
func (*{{o.name}}) CLASS_FIELDS_PROPS() *meta.ClassFieldsProps {
|
|
return &_{{o.name}}_fields_props
|
|
}
|
|
|
|
//convenience getter
|
|
func Ptr{{o.name}}(m meta.IMetaStruct) *{{o.name}} {
|
|
p, ok := m.(I{{o.name}})
|
|
if !ok {
|
|
return nil
|
|
}
|
|
return p.Ptr{{o.name}}()
|
|
}
|
|
|
|
func (self *{{o.name}}) Ptr{{o.name}}() *{{o.name}} {
|
|
return self
|
|
}
|
|
|
|
func New{{o.name}}() *{{o.name}} {
|
|
item := new ({{o.name}})
|
|
item.Reset()
|
|
return item
|
|
}
|
|
|
|
func (self *{{o.name}}) Reset() {
|
|
{{_self.struct_reset_fields(o)}}
|
|
}
|
|
|
|
func (self *{{o.name}}) Read(reader meta.Reader) error {
|
|
return meta.ReadStruct(reader, self, "")
|
|
}
|
|
|
|
func (self *{{o.name}}) ReadFields(reader meta.Reader) error {
|
|
self.Reset()
|
|
|
|
{{_self.struct_read_fields(o)}}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (self *{{o.name}}) Write(writer meta.Writer) error {
|
|
return meta.WriteStruct(writer, self, "")
|
|
}
|
|
|
|
func (self *{{o.name}}) WriteFields(writer meta.Writer) error {
|
|
|
|
{{_self.struct_write_fields(o)}}
|
|
|
|
return nil
|
|
}
|
|
|
|
{% if has_token(o, 'bitfields') %}
|
|
{{_self.bitfields_methods(o)}}
|
|
{% endif %}
|
|
|
|
{% if has_token(o, 'statist') %}
|
|
{{_self.stats_methods(o)}}
|
|
{% endif %}
|
|
|
|
{% if has_token(o, 'POD') and has_token(o, 'id') and has_token(o, 'table') and has_token(o, 'owner') %}
|
|
{{_self.db_item_methods(o)}}
|
|
{% endif %}
|
|
|
|
{% endmacro %}
|
|
|
|
{% macro props_map(tokens) %}
|
|
map[string]string{
|
|
{%- for k,v in tokens -%}
|
|
"{{k}}" : "{{v|replace({'"' : '\\"'})}}",
|
|
{%- endfor -%}
|
|
}
|
|
{% endmacro %}
|
|
|
|
{% macro struct_fields_names(o) %}
|
|
[]string{
|
|
{%- for f in get_all_fields(o) -%}
|
|
"{{f.name}}",
|
|
{%- endfor -%}
|
|
}
|
|
{% endmacro %}
|
|
|
|
{% macro struct_fields_props(o) %}
|
|
map[string]map[string]string{
|
|
{%- for f in get_all_fields(o) -%}
|
|
"{{f.name|ucfirst}}" : {{_self.props_map(f.tokens)}},
|
|
{%- endfor -%}
|
|
}
|
|
{% endmacro %}
|
|
|
|
{% macro decl_struct_fields(o) %}
|
|
{%- for f in o.fields ~%}
|
|
{{f.name|ucfirst}} {{f.type|go_type(f.tokens)}} {{_self.field_annotations(o, f)}}
|
|
{%- endfor ~%}
|
|
|
|
{%if has_token(o, 'bitfields') %}
|
|
fieldsMask meta.FieldsMask //@bitfields support
|
|
{%- endif ~%}
|
|
|
|
{% endmacro %}
|
|
|
|
{% macro field_annotations(o, f) %}
|
|
{%- if f.name|first != '_' -%}
|
|
`json:"{{f.name}}" {% if has_token(o, 'table') -%} db:"{{f.name}}"{%- endif -%}`
|
|
{%- endif -%}
|
|
{% endmacro %}
|
|
|
|
{% macro struct_reset_fields(o) %}
|
|
|
|
{%- if o.parent ~%}
|
|
self.{{o.parent.name}}.Reset()
|
|
{%- endif ~%}
|
|
|
|
{%- for f in o.fields ~%}
|
|
{{field_reset(f.name|ucfirst, f.type, f.tokens)}}
|
|
{%- endfor ~%}
|
|
|
|
{%if has_token(o, 'bitfields') %}
|
|
self.fieldsMask = meta.FieldsMask{}
|
|
{%- endif ~%}
|
|
|
|
{% endmacro %}
|
|
|
|
{% macro struct_read_fields(o) %}
|
|
|
|
{%if has_token(o, 'bitfields') %}
|
|
use_mask, mask, err := reader.TryReadMask()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
self.fieldsMask = mask
|
|
{%- endif ~%}
|
|
|
|
_cont_size, err := reader.GetContainerSize()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if _cont_size < {{(o.fields|length) - count_optional(o.fields)}} {
|
|
_cont_size = {{(o.fields|length) - count_optional(o.fields)}}
|
|
}
|
|
|
|
{%- if o.parent ~%}
|
|
if err := self.{{o.parent.name}}.ReadFields(reader); err != nil { return err }
|
|
{%- endif ~%}
|
|
|
|
{%- for f in o.fields ~%}
|
|
if _cont_size <= 0 {
|
|
return nil
|
|
}
|
|
|
|
{%if has_token(o, 'bitfields') ~%}
|
|
if !use_mask {
|
|
{%- endif ~%}
|
|
|
|
_cont_size--
|
|
|
|
{%if has_token(o, 'bitfields') ~%}
|
|
}
|
|
if !use_mask || (use_mask && self.HasValue({{loop.index0}})) {
|
|
{%- endif ~%}
|
|
|
|
{{buf2var(f.name, 'self.' ~ f.name|ucfirst, f.type, 'reader', f.tokens, false)}}
|
|
|
|
{%if has_token(o, 'bitfields') ~%}
|
|
}
|
|
{%- endif -%}
|
|
|
|
{%- endfor -%}
|
|
|
|
{% endmacro %}
|
|
|
|
{% macro struct_write_fields(o) %}
|
|
|
|
{%- if o.parent ~%}
|
|
if err := self.{{o.parent.name}}.WriteFields(writer); err != nil { return err }
|
|
{%- endif ~%}
|
|
|
|
{%- for f in o.fields ~%}
|
|
{{var2buf(f.name, 'self.' ~ f.name|ucfirst, f.type, "writer", f.tokens, has_token(f, 'virtual'))}}
|
|
{%- endfor -%}
|
|
|
|
{% endmacro %}
|
|
|
|
{% macro bitfields_methods(o) %}
|
|
func(self *{{o.name}}) HasValue(index uint64) bool {
|
|
return self.fieldsMask.FieldChanged(index)
|
|
}
|
|
|
|
func(self *{{o.name}}) SetFieldChanged(index uint64) {
|
|
self.fieldsMask.SetFieldChanged(index)
|
|
}
|
|
|
|
func(self *{{o.name}}) IsMaskFilled() bool {
|
|
return self.fieldsMask.IsFilled()
|
|
}
|
|
|
|
func(self *{{o.name}}) GetMask() meta.FieldsMask {
|
|
return self.fieldsMask
|
|
}
|
|
{% endmacro %}
|
|
|
|
{% macro stats_methods(o) %}
|
|
|
|
func (self *{{o.name}}) Table() string {
|
|
return "{{token(o, 'statist')}}"
|
|
}
|
|
|
|
func (self * {{o.name}}) Columns() []string {
|
|
return []string{
|
|
{%- for f in get_all_fields(o) ~%}
|
|
{%- if not has_token(f, 'statist_skip') ~%}
|
|
"{{token_or(f, 'statist_alias', f.name)}}",
|
|
{%- endif ~%}
|
|
{%- endfor ~%}
|
|
}
|
|
}
|
|
|
|
func (self *{{o.name}}) Values() []interface{} {
|
|
return []interface{}{
|
|
{%- for f in get_all_fields(o) ~%}
|
|
{%- if not has_token(f, 'statist_skip') ~%}
|
|
self.{{f.name|ucfirst}},
|
|
{%- endif ~%}
|
|
{%- endfor ~%}
|
|
}
|
|
}
|
|
|
|
{% endmacro %}
|
|
|
|
{% macro db_item_methods(o) %}
|
|
|
|
func (self *{{o.name}}) NewInstance() meta.IMetaDataItem {
|
|
return New{{o.name}}()
|
|
}
|
|
|
|
func (self *{{o.name}}) GetDbTableName() string {
|
|
return "{{token(o, 'table')}}"
|
|
}
|
|
|
|
func (self *{{o.name}}) GetDbFields() []string {
|
|
return self.CLASS_FIELDS()
|
|
}
|
|
|
|
func (self *{{o.name}}) GetOwnerFieldName() string {
|
|
return "{{token(o, 'owner')}}"
|
|
}
|
|
|
|
func (self *{{o.name}}) GetIdFieldName() string {
|
|
return "{{token(o, 'id')}}"
|
|
}
|
|
|
|
func (self *{{o.name}}) GetIdValue() uint64 {
|
|
return uint64(self.{{token(o, 'id')|ucfirst}})
|
|
}
|
|
|
|
func (self *{{o.name}}) Import(data interface{}) {
|
|
switch data.(type) {
|
|
case {{o.name}}:
|
|
{
|
|
row := data.({{o.name}})
|
|
{%- for f in get_all_fields(o) ~%}
|
|
self.{{f.name|ucfirst}} = row.{{f.name|ucfirst}}
|
|
{%- endfor ~%}
|
|
break
|
|
}
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
|
|
func (self *{{o.name}}) Export(data []interface{}) {
|
|
{%- for f in get_all_fields(o) ~%}
|
|
data[{{loop.index0}}] = self.{{f.name|ucfirst}}
|
|
{%- endfor ~%}
|
|
}
|
|
{% endmacro %}
|
|
|
|
{% macro decl_enum(o) %}
|
|
|
|
//==============================
|
|
const (
|
|
{{_self.enum_consts(o)}}
|
|
)
|
|
type {{o.name}} int32
|
|
var _{{o.name}}_values []int = []int{ {{_self.enum_values_list(o)}} }
|
|
var _{{o.name}}_map map[string]{{o.name}}
|
|
func init() {
|
|
_{{o.name}}_map = map[string]{{o.name}}{ {{_self.enum_values_map(o)}} }
|
|
}
|
|
func (*{{o.name}}) CLASS_ID() uint32 {
|
|
return {{o.classid}}
|
|
}
|
|
func (*{{o.name}}) CLASS_NAME() string {
|
|
return "{{o.name}}"
|
|
}
|
|
func (*{{o.name}}) DEFAULT_VALUE() int32 {
|
|
return {{o.values|first}}
|
|
}
|
|
func (self *{{o.name}}) IsValid() bool {
|
|
return sort.SearchInts(_{{o.name}}_values, int(*self)) != -1
|
|
}
|
|
func {{o.name}}_GetNameByValue(value int) string {
|
|
for name, num := range _{{o.name}}_map {
|
|
if value == int(num) {
|
|
return name
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
func New{{o.name}}ByName(name string) ({{o.name}}, error) {
|
|
if v, ok := _{{o.name}}_map[name]; ok == true {
|
|
return v, nil
|
|
}
|
|
return 0, errors.Errorf("Wrong name of {{o.name}}: '%s'", name)
|
|
}
|
|
{% endmacro %}
|
|
|
|
{% macro enum_values_list(o) %}
|
|
{%- for v in o.values|sort -%}
|
|
{{v}},
|
|
{%- endfor ~%}
|
|
{% endmacro %}
|
|
|
|
{% macro enum_values_map(o) %}
|
|
{%- for k,v in o.values -%}
|
|
"{{k}}" : {{v}},
|
|
{%- endfor ~%}
|
|
{% endmacro %}
|
|
|
|
{% macro enum_consts(o) %}
|
|
{%- for k,v in o.values ~%}
|
|
{{o.name}}_{{k}} {{o.name}} = {{v}}
|
|
{%- endfor ~%}
|
|
{% endmacro %}
|
|
|
|
{% macro decl_rpc(o) %}
|
|
|
|
{{_self._decl_rpc_part(o.req, o.code)}}
|
|
{{_self._decl_rpc_part(o.rsp, o.code)}}
|
|
|
|
func New{{o.name}}() *{{o.name}} {
|
|
rpc := {{o.name}}{}
|
|
rpc.Req = New{{o.req.name}}()
|
|
rpc.Rsp = New{{o.rsp.name}}()
|
|
return &rpc
|
|
}
|
|
|
|
type {{o.name}} struct {
|
|
ErrCode int32
|
|
ErrMsg string
|
|
Req *{{o.req.name}}
|
|
Rsp *{{o.rsp.name}}
|
|
}
|
|
|
|
func (rpc *{{o.name}}) SetError(code int32, msg string) {
|
|
rpc.ErrCode = code
|
|
rpc.ErrMsg = msg
|
|
}
|
|
|
|
func (rpc *{{o.name}}) GetError() (int32, string) {
|
|
return rpc.ErrCode, rpc.ErrMsg
|
|
}
|
|
|
|
func (rpc *{{o.name}}) GetRequest() meta.IMetaStruct {
|
|
return rpc.Req
|
|
}
|
|
|
|
func (rpc *{{o.name}}) GetResponse() meta.IMetaStruct {
|
|
return rpc.Rsp
|
|
}
|
|
|
|
func (rpc *{{o.name}}) GetName() string {
|
|
return "{{o.name}}"
|
|
}
|
|
|
|
func (rpc *{{o.name}}) GetCode() int32 {
|
|
return {{o.code}}
|
|
}
|
|
|
|
type IRPCHandler_{{o.name}} interface {
|
|
{{o.name}}(*{{o.name}}) error
|
|
}
|
|
|
|
func (rpc *{{o.name}}) Execute(h interface{}) error{
|
|
mh, ok := h.(IRPCHandler_{{o.name}})
|
|
if !ok {
|
|
return errors.New("RPC '{{o.name}}(*{{o.name}}) error' is not implemented")
|
|
}
|
|
return mh.{{o.name}}(rpc)
|
|
}
|
|
|
|
{% endmacro %}
|
|
|
|
{% macro _decl_rpc_part(o, code) %}
|
|
|
|
{{_self.decl_struct(o)}}
|
|
|
|
var {{o.name}}_ func(interface{}, *{{o.name}}, *{{o.name|rpc_invert}}) error
|
|
|
|
func (self *{{o.name}}) I{{o.name}}() *{{o.name}} {
|
|
return self
|
|
}
|
|
|
|
func (*{{o.name}}) GetCode() int32 {
|
|
return {{code}}
|
|
}
|
|
|
|
{% endmacro %}
|
|
|