961 lines
36 KiB
Lua
961 lines
36 KiB
Lua
--
|
|
--------------------------------------------------------------------------------
|
|
-- FILE: protobuf.lua
|
|
-- DESCRIPTION: protoc-gen-lua
|
|
-- Google's Protocol Buffers project, ported to lua.
|
|
-- https://code.google.com/p/protoc-gen-lua/
|
|
--
|
|
-- Copyright (c) 2010 , 林卓毅 (Zhuoyi Lin) netsnail@gmail.com
|
|
-- All rights reserved.
|
|
--
|
|
-- Use, modification and distribution are subject to the "New BSD License"
|
|
-- as listed at <url: http://www.opensource.org/licenses/bsd-license.php >.
|
|
--
|
|
-- COMPANY: NetEase
|
|
-- CREATED: 2010年07月29日 14时30分02秒 CST
|
|
--------------------------------------------------------------------------------
|
|
--
|
|
|
|
local setmetatable = setmetatable
|
|
local rawset = rawset
|
|
local rawget = rawget
|
|
local error = error
|
|
local ipairs = ipairs
|
|
local pairs = pairs
|
|
local print = print
|
|
local table = table
|
|
local string = string
|
|
local tostring = tostring
|
|
local type = type
|
|
|
|
local pb = require "pb"
|
|
local wire_format = require "protobuf.wire_format"
|
|
local type_checkers = require "protobuf.type_checkers"
|
|
local encoder = require "protobuf.encoder"
|
|
local decoder = require "protobuf.decoder"
|
|
local listener_mod = require "protobuf.listener"
|
|
local containers = require "protobuf.containers"
|
|
local descriptor = require "protobuf.descriptor"
|
|
local FieldDescriptor = descriptor.FieldDescriptor
|
|
local text_format = require "protobuf.text_format"
|
|
|
|
module("protobuf.protobuf")
|
|
|
|
local function make_descriptor(name, descriptor, usable_key)
|
|
local meta = {
|
|
__newindex = function(self, key, value)
|
|
if usable_key[key] then
|
|
rawset(self, key, value)
|
|
else
|
|
error("error key: "..key)
|
|
end
|
|
end
|
|
};
|
|
meta.__index = meta
|
|
meta.__call = function()
|
|
return setmetatable({}, meta)
|
|
end
|
|
|
|
_M[name] = setmetatable(descriptor, meta);
|
|
end
|
|
|
|
|
|
make_descriptor("Descriptor", {}, {
|
|
name = true,
|
|
full_name = true,
|
|
filename = true,
|
|
containing_type = true,
|
|
fields = true,
|
|
nested_types = true,
|
|
enum_types = true,
|
|
extensions = true,
|
|
options = true,
|
|
is_extendable = true,
|
|
extension_ranges = true,
|
|
})
|
|
|
|
make_descriptor("FieldDescriptor", FieldDescriptor, {
|
|
name = true,
|
|
full_name = true,
|
|
index = true,
|
|
number = true,
|
|
type = true,
|
|
cpp_type = true,
|
|
label = true,
|
|
has_default_value = true,
|
|
default_value = true,
|
|
containing_type = true,
|
|
message_type = true,
|
|
enum_type = true,
|
|
is_extension = true,
|
|
extension_scope = true,
|
|
})
|
|
|
|
make_descriptor("EnumDescriptor", {}, {
|
|
name = true,
|
|
full_name = true,
|
|
values = true,
|
|
containing_type = true,
|
|
options = true
|
|
})
|
|
|
|
make_descriptor("EnumValueDescriptor", {}, {
|
|
name = true,
|
|
index = true,
|
|
number = true,
|
|
type = true,
|
|
options = true
|
|
})
|
|
|
|
-- Maps from field type to expected wiretype.
|
|
local FIELD_TYPE_TO_WIRE_TYPE = {
|
|
[FieldDescriptor.TYPE_DOUBLE] = wire_format.WIRETYPE_FIXED64,
|
|
[FieldDescriptor.TYPE_FLOAT] = wire_format.WIRETYPE_FIXED32,
|
|
[FieldDescriptor.TYPE_INT64] = wire_format.WIRETYPE_VARINT,
|
|
[FieldDescriptor.TYPE_UINT64] = wire_format.WIRETYPE_VARINT,
|
|
[FieldDescriptor.TYPE_INT32] = wire_format.WIRETYPE_VARINT,
|
|
[FieldDescriptor.TYPE_FIXED64] = wire_format.WIRETYPE_FIXED64,
|
|
[FieldDescriptor.TYPE_FIXED32] = wire_format.WIRETYPE_FIXED32,
|
|
[FieldDescriptor.TYPE_BOOL] = wire_format.WIRETYPE_VARINT,
|
|
[FieldDescriptor.TYPE_STRING] = wire_format.WIRETYPE_LENGTH_DELIMITED,
|
|
[FieldDescriptor.TYPE_GROUP] = wire_format.WIRETYPE_START_GROUP,
|
|
[FieldDescriptor.TYPE_MESSAGE] = wire_format.WIRETYPE_LENGTH_DELIMITED,
|
|
[FieldDescriptor.TYPE_BYTES] = wire_format.WIRETYPE_LENGTH_DELIMITED,
|
|
[FieldDescriptor.TYPE_UINT32] = wire_format.WIRETYPE_VARINT,
|
|
[FieldDescriptor.TYPE_ENUM] = wire_format.WIRETYPE_VARINT,
|
|
[FieldDescriptor.TYPE_SFIXED32] = wire_format.WIRETYPE_FIXED32,
|
|
[FieldDescriptor.TYPE_SFIXED64] = wire_format.WIRETYPE_FIXED64,
|
|
[FieldDescriptor.TYPE_SINT32] = wire_format.WIRETYPE_VARINT,
|
|
[FieldDescriptor.TYPE_SINT64] = wire_format.WIRETYPE_VARINT
|
|
}
|
|
|
|
local NON_PACKABLE_TYPES = {
|
|
[FieldDescriptor.TYPE_STRING] = true,
|
|
[FieldDescriptor.TYPE_GROUP] = true,
|
|
[FieldDescriptor.TYPE_MESSAGE] = true,
|
|
[FieldDescriptor.TYPE_BYTES] = true
|
|
}
|
|
|
|
local _VALUE_CHECKERS = {
|
|
[FieldDescriptor.CPPTYPE_INT32] = type_checkers.Int32ValueChecker(),
|
|
[FieldDescriptor.CPPTYPE_INT64] = type_checkers.TypeChecker({string = true, number = true}),
|
|
[FieldDescriptor.CPPTYPE_UINT32] = type_checkers.Uint32ValueChecker(),
|
|
[FieldDescriptor.CPPTYPE_UINT64] = type_checkers.TypeChecker({string = true, number = true}),
|
|
[FieldDescriptor.CPPTYPE_DOUBLE] = type_checkers.TypeChecker({number = true}),
|
|
[FieldDescriptor.CPPTYPE_FLOAT] = type_checkers.TypeChecker({number = true}),
|
|
[FieldDescriptor.CPPTYPE_BOOL] = type_checkers.TypeChecker({boolean = true, bool = true, int=true}),
|
|
[FieldDescriptor.CPPTYPE_ENUM] = type_checkers.Int32ValueChecker(),
|
|
[FieldDescriptor.CPPTYPE_STRING] = type_checkers.TypeChecker({string = true})
|
|
}
|
|
|
|
|
|
local TYPE_TO_BYTE_SIZE_FN = {
|
|
[FieldDescriptor.TYPE_DOUBLE] = wire_format.DoubleByteSize,
|
|
[FieldDescriptor.TYPE_FLOAT] = wire_format.FloatByteSize,
|
|
[FieldDescriptor.TYPE_INT64] = wire_format.Int64ByteSize,
|
|
[FieldDescriptor.TYPE_UINT64] = wire_format.UInt64ByteSize,
|
|
[FieldDescriptor.TYPE_INT32] = wire_format.Int32ByteSize,
|
|
[FieldDescriptor.TYPE_FIXED64] = wire_format.Fixed64ByteSize,
|
|
[FieldDescriptor.TYPE_FIXED32] = wire_format.Fixed32ByteSize,
|
|
[FieldDescriptor.TYPE_BOOL] = wire_format.BoolByteSize,
|
|
[FieldDescriptor.TYPE_STRING] = wire_format.StringByteSize,
|
|
[FieldDescriptor.TYPE_GROUP] = wire_format.GroupByteSize,
|
|
[FieldDescriptor.TYPE_MESSAGE] = wire_format.MessageByteSize,
|
|
[FieldDescriptor.TYPE_BYTES] = wire_format.BytesByteSize,
|
|
[FieldDescriptor.TYPE_UINT32] = wire_format.UInt32ByteSize,
|
|
[FieldDescriptor.TYPE_ENUM] = wire_format.EnumByteSize,
|
|
[FieldDescriptor.TYPE_SFIXED32] = wire_format.SFixed32ByteSize,
|
|
[FieldDescriptor.TYPE_SFIXED64] = wire_format.SFixed64ByteSize,
|
|
[FieldDescriptor.TYPE_SINT32] = wire_format.SInt32ByteSize,
|
|
[FieldDescriptor.TYPE_SINT64] = wire_format.SInt64ByteSize
|
|
}
|
|
|
|
local TYPE_TO_ENCODER = {
|
|
[FieldDescriptor.TYPE_DOUBLE] = encoder.DoubleEncoder,
|
|
[FieldDescriptor.TYPE_FLOAT] = encoder.FloatEncoder,
|
|
[FieldDescriptor.TYPE_INT64] = encoder.Int64Encoder,
|
|
[FieldDescriptor.TYPE_UINT64] = encoder.UInt64Encoder,
|
|
[FieldDescriptor.TYPE_INT32] = encoder.Int32Encoder,
|
|
[FieldDescriptor.TYPE_FIXED64] = encoder.Fixed64Encoder,
|
|
[FieldDescriptor.TYPE_FIXED32] = encoder.Fixed32Encoder,
|
|
[FieldDescriptor.TYPE_BOOL] = encoder.BoolEncoder,
|
|
[FieldDescriptor.TYPE_STRING] = encoder.StringEncoder,
|
|
[FieldDescriptor.TYPE_GROUP] = encoder.GroupEncoder,
|
|
[FieldDescriptor.TYPE_MESSAGE] = encoder.MessageEncoder,
|
|
[FieldDescriptor.TYPE_BYTES] = encoder.BytesEncoder,
|
|
[FieldDescriptor.TYPE_UINT32] = encoder.UInt32Encoder,
|
|
[FieldDescriptor.TYPE_ENUM] = encoder.EnumEncoder,
|
|
[FieldDescriptor.TYPE_SFIXED32] = encoder.SFixed32Encoder,
|
|
[FieldDescriptor.TYPE_SFIXED64] = encoder.SFixed64Encoder,
|
|
[FieldDescriptor.TYPE_SINT32] = encoder.SInt32Encoder,
|
|
[FieldDescriptor.TYPE_SINT64] = encoder.SInt64Encoder
|
|
}
|
|
|
|
local TYPE_TO_SIZER = {
|
|
[FieldDescriptor.TYPE_DOUBLE] = encoder.DoubleSizer,
|
|
[FieldDescriptor.TYPE_FLOAT] = encoder.FloatSizer,
|
|
[FieldDescriptor.TYPE_INT64] = encoder.Int64Sizer,
|
|
[FieldDescriptor.TYPE_UINT64] = encoder.UInt64Sizer,
|
|
[FieldDescriptor.TYPE_INT32] = encoder.Int32Sizer,
|
|
[FieldDescriptor.TYPE_FIXED64] = encoder.Fixed64Sizer,
|
|
[FieldDescriptor.TYPE_FIXED32] = encoder.Fixed32Sizer,
|
|
[FieldDescriptor.TYPE_BOOL] = encoder.BoolSizer,
|
|
[FieldDescriptor.TYPE_STRING] = encoder.StringSizer,
|
|
[FieldDescriptor.TYPE_GROUP] = encoder.GroupSizer,
|
|
[FieldDescriptor.TYPE_MESSAGE] = encoder.MessageSizer,
|
|
[FieldDescriptor.TYPE_BYTES] = encoder.BytesSizer,
|
|
[FieldDescriptor.TYPE_UINT32] = encoder.UInt32Sizer,
|
|
[FieldDescriptor.TYPE_ENUM] = encoder.EnumSizer,
|
|
[FieldDescriptor.TYPE_SFIXED32] = encoder.SFixed32Sizer,
|
|
[FieldDescriptor.TYPE_SFIXED64] = encoder.SFixed64Sizer,
|
|
[FieldDescriptor.TYPE_SINT32] = encoder.SInt32Sizer,
|
|
[FieldDescriptor.TYPE_SINT64] = encoder.SInt64Sizer
|
|
}
|
|
|
|
local TYPE_TO_DECODER = {
|
|
[FieldDescriptor.TYPE_DOUBLE] = decoder.DoubleDecoder,
|
|
[FieldDescriptor.TYPE_FLOAT] = decoder.FloatDecoder,
|
|
[FieldDescriptor.TYPE_INT64] = decoder.Int64Decoder,
|
|
[FieldDescriptor.TYPE_UINT64] = decoder.UInt64Decoder,
|
|
[FieldDescriptor.TYPE_INT32] = decoder.Int32Decoder,
|
|
[FieldDescriptor.TYPE_FIXED64] = decoder.Fixed64Decoder,
|
|
[FieldDescriptor.TYPE_FIXED32] = decoder.Fixed32Decoder,
|
|
[FieldDescriptor.TYPE_BOOL] = decoder.BoolDecoder,
|
|
[FieldDescriptor.TYPE_STRING] = decoder.StringDecoder,
|
|
[FieldDescriptor.TYPE_GROUP] = decoder.GroupDecoder,
|
|
[FieldDescriptor.TYPE_MESSAGE] = decoder.MessageDecoder,
|
|
[FieldDescriptor.TYPE_BYTES] = decoder.BytesDecoder,
|
|
[FieldDescriptor.TYPE_UINT32] = decoder.UInt32Decoder,
|
|
[FieldDescriptor.TYPE_ENUM] = decoder.EnumDecoder,
|
|
[FieldDescriptor.TYPE_SFIXED32] = decoder.SFixed32Decoder,
|
|
[FieldDescriptor.TYPE_SFIXED64] = decoder.SFixed64Decoder,
|
|
[FieldDescriptor.TYPE_SINT32] = decoder.SInt32Decoder,
|
|
[FieldDescriptor.TYPE_SINT64] = decoder.SInt64Decoder
|
|
}
|
|
|
|
local FIELD_TYPE_TO_WIRE_TYPE = {
|
|
[FieldDescriptor.TYPE_DOUBLE] = wire_format.WIRETYPE_FIXED64,
|
|
[FieldDescriptor.TYPE_FLOAT] = wire_format.WIRETYPE_FIXED32,
|
|
[FieldDescriptor.TYPE_INT64] = wire_format.WIRETYPE_VARINT,
|
|
[FieldDescriptor.TYPE_UINT64] = wire_format.WIRETYPE_VARINT,
|
|
[FieldDescriptor.TYPE_INT32] = wire_format.WIRETYPE_VARINT,
|
|
[FieldDescriptor.TYPE_FIXED64] = wire_format.WIRETYPE_FIXED64,
|
|
[FieldDescriptor.TYPE_FIXED32] = wire_format.WIRETYPE_FIXED32,
|
|
[FieldDescriptor.TYPE_BOOL] = wire_format.WIRETYPE_VARINT,
|
|
[FieldDescriptor.TYPE_STRING] = wire_format.WIRETYPE_LENGTH_DELIMITED,
|
|
[FieldDescriptor.TYPE_GROUP] = wire_format.WIRETYPE_START_GROUP,
|
|
[FieldDescriptor.TYPE_MESSAGE] = wire_format.WIRETYPE_LENGTH_DELIMITED,
|
|
[FieldDescriptor.TYPE_BYTES] = wire_format.WIRETYPE_LENGTH_DELIMITED,
|
|
[FieldDescriptor.TYPE_UINT32] = wire_format.WIRETYPE_VARINT,
|
|
[FieldDescriptor.TYPE_ENUM] = wire_format.WIRETYPE_VARINT,
|
|
[FieldDescriptor.TYPE_SFIXED32] = wire_format.WIRETYPE_FIXED32,
|
|
[FieldDescriptor.TYPE_SFIXED64] = wire_format.WIRETYPE_FIXED64,
|
|
[FieldDescriptor.TYPE_SINT32] = wire_format.WIRETYPE_VARINT,
|
|
[FieldDescriptor.TYPE_SINT64] = wire_format.WIRETYPE_VARINT
|
|
}
|
|
|
|
local function IsTypePackable(field_type)
|
|
return NON_PACKABLE_TYPES[field_type] == nil
|
|
end
|
|
|
|
local function GetTypeChecker(cpp_type, field_type)
|
|
if (cpp_type == FieldDescriptor.CPPTYPE_STRING and field_type == FieldDescriptor.TYPE_STRING) then
|
|
return type_checkers.UnicodeValueChecker()
|
|
end
|
|
return _VALUE_CHECKERS[cpp_type]
|
|
end
|
|
|
|
local function _DefaultValueConstructorForField(field)
|
|
if field.label == FieldDescriptor.LABEL_REPEATED then
|
|
if type(field.default_value) ~= "table" or #(field.default_value) ~= 0 then
|
|
error('Repeated field default value not empty list:' .. tostring(field.default_value))
|
|
end
|
|
if field.cpp_type == FieldDescriptor.CPPTYPE_MESSAGE then
|
|
local message_type = field.message_type
|
|
return function (message)
|
|
return containers.RepeatedCompositeFieldContainer(message._listener_for_children, message_type)
|
|
end
|
|
else
|
|
local type_checker = GetTypeChecker(field.cpp_type, field.type)
|
|
return function (message)
|
|
return containers.RepeatedScalarFieldContainer(message._listener_for_children, type_checker)
|
|
end
|
|
end
|
|
end
|
|
if field.cpp_type == FieldDescriptor.CPPTYPE_MESSAGE then
|
|
local message_type = field.message_type
|
|
return function (message)
|
|
result = message_type._concrete_class()
|
|
result._SetListener(message._listener_for_children)
|
|
return result
|
|
end
|
|
end
|
|
return function (message)
|
|
return field.default_value
|
|
end
|
|
end
|
|
|
|
local function _AttachFieldHelpers(message_meta, field_descriptor)
|
|
local is_repeated = (field_descriptor.label == FieldDescriptor.LABEL_REPEATED)
|
|
local is_packed = (field_descriptor.has_options and field_descriptor.GetOptions().packed)
|
|
|
|
rawset(field_descriptor, "_encoder", TYPE_TO_ENCODER[field_descriptor.type](field_descriptor.number, is_repeated, is_packed))
|
|
rawset(field_descriptor, "_sizer", TYPE_TO_SIZER[field_descriptor.type](field_descriptor.number, is_repeated, is_packed))
|
|
rawset(field_descriptor, "_default_constructor", _DefaultValueConstructorForField(field_descriptor))
|
|
|
|
local AddDecoder = function(wiretype, is_packed)
|
|
local tag_bytes = encoder.TagBytes(field_descriptor.number, wiretype)
|
|
message_meta._decoders_by_tag[tag_bytes] = TYPE_TO_DECODER[field_descriptor.type](field_descriptor.number, is_repeated, is_packed, field_descriptor, field_descriptor._default_constructor)
|
|
end
|
|
|
|
AddDecoder(FIELD_TYPE_TO_WIRE_TYPE[field_descriptor.type], False)
|
|
if is_repeated and IsTypePackable(field_descriptor.type) then
|
|
AddDecoder(wire_format.WIRETYPE_LENGTH_DELIMITED, True)
|
|
end
|
|
end
|
|
|
|
local function _AddEnumValues(descriptor, message_meta)
|
|
for _, enum_type in ipairs(descriptor.enum_types) do
|
|
for _, enum_value in ipairs(enum_type.values) do
|
|
message_meta._member[enum_value.name] = enum_value.number
|
|
end
|
|
end
|
|
end
|
|
|
|
local function _InitMethod(message_meta)
|
|
return function()
|
|
local self = {}
|
|
self._cached_byte_size = 0
|
|
self._cached_byte_size_dirty = false
|
|
self._fields = {}
|
|
self._is_present_in_parent = false
|
|
self._listener = listener_mod.NullMessageListener()
|
|
self._listener_for_children = listener_mod.Listener(self)
|
|
return setmetatable(self, message_meta)
|
|
end
|
|
end
|
|
|
|
local function _AddPropertiesForRepeatedField(field, message_meta)
|
|
local property_name = field.name
|
|
|
|
message_meta._getter[property_name] = function(self)
|
|
local field_value = self._fields[field]
|
|
if field_value == nil then
|
|
field_value = field._default_constructor(self)
|
|
self._fields[field] = field_value
|
|
|
|
if not self._cached_byte_size_dirty then
|
|
message_meta._member._Modified(self)
|
|
end
|
|
end
|
|
return field_value
|
|
end
|
|
|
|
message_meta._setter[property_name] = function(self)
|
|
error('Assignment not allowed to repeated field "' .. property_name .. '" in protocol message object.')
|
|
end
|
|
end
|
|
|
|
local function _AddPropertiesForNonRepeatedCompositeField(field, message_meta)
|
|
local property_name = field.name
|
|
local message_type = field.message_type
|
|
|
|
message_meta._getter[property_name] = function(self)
|
|
local field_value = self._fields[field]
|
|
if field_value == nil then
|
|
field_value = message_type._concrete_class()
|
|
field_value:_SetListener(self._listener_for_children)
|
|
self._fields[field] = field_value
|
|
|
|
if not self._cached_byte_size_dirty then
|
|
message_meta._member._Modified(self)
|
|
end
|
|
end
|
|
return field_value
|
|
end
|
|
message_meta._setter[property_name] = function(self, new_value)
|
|
error('Assignment not allowed to composite field' .. property_name .. 'in protocol message object.' )
|
|
end
|
|
end
|
|
|
|
local function _AddPropertiesForNonRepeatedScalarField(field, message)
|
|
local property_name = field.name
|
|
local type_checker = GetTypeChecker(field.cpp_type, field.type)
|
|
local default_value = field.default_value
|
|
|
|
message._getter[property_name] = function(self)
|
|
local value = self._fields[field]
|
|
if value ~= nil then
|
|
return self._fields[field]
|
|
else
|
|
return default_value
|
|
end
|
|
end
|
|
|
|
message._setter[property_name] = function(self, new_value)
|
|
type_checker(new_value)
|
|
self._fields[field] = new_value
|
|
if not self._cached_byte_size_dirty then
|
|
message._member._Modified(self)
|
|
end
|
|
end
|
|
end
|
|
|
|
local function _AddPropertiesForField(field, message_meta)
|
|
constant_name = field.name:upper() .. "_FIELD_NUMBER"
|
|
message_meta._member[constant_name] = field.number
|
|
|
|
if field.label == FieldDescriptor.LABEL_REPEATED then
|
|
_AddPropertiesForRepeatedField(field, message_meta)
|
|
elseif field.cpp_type == FieldDescriptor.CPPTYPE_MESSAGE then
|
|
_AddPropertiesForNonRepeatedCompositeField(field, message_meta)
|
|
else
|
|
_AddPropertiesForNonRepeatedScalarField(field, message_meta)
|
|
end
|
|
end
|
|
|
|
local _ED_meta = {
|
|
__index = function(self, extension_handle)
|
|
local _extended_message = rawget(self, "_extended_message")
|
|
local value = _extended_message._fields[extension_handle]
|
|
if value ~= nil then
|
|
return value
|
|
end
|
|
if extension_handle.label == FieldDescriptor.LABEL_REPEATED then
|
|
value = extension_handle._default_constructor(self._extended_message)
|
|
elseif extension_handle.cpp_type == FieldDescriptor.CPPTYPE_MESSAGE then
|
|
value = extension_handle.message_type._concrete_class()
|
|
value:_SetListener(_extended_message._listener_for_children)
|
|
else
|
|
return extension_handle.default_value
|
|
end
|
|
_extended_message._fields[extension_handle] = value
|
|
return value
|
|
end,
|
|
__newindex = function(self, extension_handle, value)
|
|
local _extended_message = rawget(self, "_extended_message")
|
|
if (extension_handle.label == FieldDescriptor.LABEL_REPEATED or
|
|
extension_handle.cpp_type == FieldDescriptor.CPPTYPE_MESSAGE) then
|
|
error('Cannot assign to extension "'.. extension_handle.full_name .. '" because it is a repeated or composite type.')
|
|
end
|
|
|
|
local type_checker = GetTypeChecker(extension_handle.cpp_type, extension_handle.type)
|
|
type_checker.CheckValue(value)
|
|
_extended_message._fields[extension_handle] = value
|
|
_extended_message._Modified()
|
|
end
|
|
}
|
|
|
|
local function _ExtensionDict(message)
|
|
local o = {}
|
|
o._extended_message = message
|
|
return setmetatable(o, _ED_meta)
|
|
end
|
|
|
|
local function _AddPropertiesForFields(descriptor, message_meta)
|
|
for _, field in ipairs(descriptor.fields) do
|
|
_AddPropertiesForField(field, message_meta)
|
|
end
|
|
if descriptor.is_extendable then
|
|
message_meta._getter.Extensions = function(self) return _ExtensionDict(self) end
|
|
end
|
|
end
|
|
|
|
local function _AddPropertiesForExtensions(descriptor, message_meta)
|
|
local extension_dict = descriptor._extensions_by_name
|
|
for extension_name, extension_field in pairs(extension_dict) do
|
|
local constant_name = string.upper(extension_name) .. "_FIELD_NUMBER"
|
|
message_meta._member[constant_name] = extension_field.number
|
|
end
|
|
end
|
|
|
|
local function _AddStaticMethods(message_meta)
|
|
message_meta._member.RegisterExtension = function(extension_handle)
|
|
extension_handle.containing_type = message_meta._descriptor
|
|
_AttachFieldHelpers(message_meta, extension_handle)
|
|
|
|
if message_meta._extensions_by_number[extension_handle.number] == nil then
|
|
message_meta._extensions_by_number[extension_handle.number] = extension_handle
|
|
else
|
|
error(
|
|
string.format('Extensions "%s" and "%s" both try to extend message type "%s" with field number %d.',
|
|
extension_handle.full_name, actual_handle.full_name,
|
|
message_meta._descriptor.full_name, extension_handle.number))
|
|
end
|
|
message_meta._extensions_by_name[extension_handle.full_name] = extension_handle
|
|
end
|
|
|
|
message_meta._member.FromString = function(s)
|
|
local message = message_meta._member.__call()
|
|
message.MergeFromString(s)
|
|
return message
|
|
end
|
|
end
|
|
|
|
local function _IsPresent(descriptor, value)
|
|
if descriptor.label == FieldDescriptor.LABEL_REPEATED then
|
|
return value
|
|
elseif descriptor.cpp_type == FieldDescriptor.CPPTYPE_MESSAGE then
|
|
return value._is_present_in_parent
|
|
else
|
|
return true
|
|
end
|
|
end
|
|
|
|
function sortFunc(a, b)
|
|
return a.index < b.index
|
|
end
|
|
function pairsByKeys (t, f)
|
|
local a = {}
|
|
for n in pairs(t) do table.insert(a, n) end
|
|
table.sort(a, f)
|
|
local i = 0 -- iterator variable
|
|
local iter = function () -- iterator function
|
|
i = i + 1
|
|
if a[i] == nil then return nil
|
|
else return a[i], t[a[i]]
|
|
end
|
|
end
|
|
return iter
|
|
end
|
|
|
|
local function _AddListFieldsMethod(message_descriptor, message_meta)
|
|
message_meta._member.ListFields = function (self)
|
|
local list_field = function(fields)
|
|
--local f, s, v = pairs(self._fields)
|
|
local f,s,v = pairsByKeys(self._fields, sortFunc)
|
|
local iter = function(a, i)
|
|
while true do
|
|
local descriptor, value = f(a, i)
|
|
if descriptor == nil then
|
|
return
|
|
elseif _IsPresent(descriptor, value) then
|
|
return descriptor, value
|
|
end
|
|
end
|
|
end
|
|
return iter, s, v
|
|
end
|
|
return list_field(self._fields)
|
|
end
|
|
end
|
|
|
|
local function _AddHasFieldMethod(message_descriptor, message_meta)
|
|
local singular_fields = {}
|
|
for _, field in ipairs(message_descriptor.fields) do
|
|
if field.label ~= FieldDescriptor.LABEL_REPEATED then
|
|
singular_fields[field.name] = field
|
|
end
|
|
end
|
|
message_meta._member.HasField = function (self, field_name)
|
|
field = singular_fields[field_name]
|
|
if field == nil then
|
|
error('Protocol message has no singular "'.. field_name.. '" field.')
|
|
end
|
|
if field.cpp_type == FieldDescriptor.CPPTYPE_MESSAGE then
|
|
value = self._fields[field]
|
|
return value ~= nil and value._is_present_in_parent
|
|
else
|
|
local valueTmp = self._fields[field]
|
|
return valueTmp ~= nil
|
|
end
|
|
end
|
|
end
|
|
|
|
local function _AddClearFieldMethod(message_descriptor, message_meta)
|
|
local singular_fields = {}
|
|
for _, field in ipairs(message_descriptor.fields) do
|
|
if field.label ~= FieldDescriptor.LABEL_REPEATED then
|
|
singular_fields[field.name] = field
|
|
end
|
|
end
|
|
|
|
message_meta._member.ClearField = function(self, field_name)
|
|
field = singular_fields[field_name]
|
|
if field == nil then
|
|
error('Protocol message has no singular "'.. field_name.. '" field.')
|
|
end
|
|
|
|
if self._fields[field] then
|
|
self._fields[field] = nil
|
|
end
|
|
message_meta._member._Modified(self)
|
|
end
|
|
end
|
|
|
|
local function _AddClearExtensionMethod(message_meta)
|
|
message_meta._member.ClearExtension = function(self, extension_handle)
|
|
if self._fields[extension_handle] == nil then
|
|
self._fields[extension_handle] = nil
|
|
end
|
|
message_meta._member._Modified(self)
|
|
end
|
|
end
|
|
|
|
local function _AddClearMethod(message_descriptor, message_meta)
|
|
message_meta._member.Clear = function(self)
|
|
self._fields = {}
|
|
message_meta._member._Modified(self)
|
|
end
|
|
end
|
|
|
|
local function _AddStrMethod(message_meta)
|
|
local format = text_format.msg_format
|
|
message_meta.__tostring = function(self)
|
|
return format(self)
|
|
end
|
|
end
|
|
|
|
local function _AddHasExtensionMethod(message_meta)
|
|
message_meta._member.HasExtension = function(self, extension_handle)
|
|
if extension_handle.label == FieldDescriptor.LABEL_REPEATED then
|
|
error(extension_handle.full_name .. ' is repeated.')
|
|
end
|
|
if extension_handle.cpp_type == FieldDescriptor.CPPTYPE_MESSAGE then
|
|
value = self._fields[extension_handle]
|
|
return value ~= nil and value._is_present_in_parent
|
|
else
|
|
return self._fields[extension_handle]
|
|
end
|
|
end
|
|
end
|
|
|
|
local function _AddSetListenerMethod(message_meta)
|
|
message_meta._member._SetListener = function(self, listener)
|
|
if listener ~= nil then
|
|
self._listener = listener_mod.NullMessageListener()
|
|
else
|
|
self._listener = listener
|
|
end
|
|
end
|
|
end
|
|
|
|
local function _AddByteSizeMethod(message_descriptor, message_meta)
|
|
message_meta._member.ByteSize = function(self)
|
|
--kaiser
|
|
--bug:这里在Repeat字段的结构体如果第一个字段不是int变量会产生_cached_byte_size_dirty为false而导致byte size为0
|
|
--如果bytesize为0让它强制计算byte size
|
|
if not self._cached_byte_size_dirty and self._cached_byte_size > 0 then
|
|
return self._cached_byte_size
|
|
end
|
|
local size = 0
|
|
for field_descriptor, field_value in message_meta._member.ListFields(self) do
|
|
size = field_descriptor._sizer(field_value) + size
|
|
end
|
|
self._cached_byte_size = size
|
|
self._cached_byte_size_dirty = false
|
|
self._listener_for_children.dirty = false
|
|
return size
|
|
end
|
|
end
|
|
|
|
local function _AddSerializeToStringMethod(message_descriptor, message_meta)
|
|
message_meta._member.SerializeToString = function(self)
|
|
if not message_meta._member.IsInitialized(self) then
|
|
error('Message is missing required fields: ' ..
|
|
table.concat(message_meta._member.FindInitializationErrors(self), ','))
|
|
end
|
|
return message_meta._member.SerializePartialToString(self)
|
|
end
|
|
message_meta._member.SerializeToIOString = function(self, iostring)
|
|
if not message_meta._member.IsInitialized(self) then
|
|
error('Message is missing required fields: ' ..
|
|
table.concat(message_meta._member.FindInitializationErrors(self), ','))
|
|
end
|
|
return message_meta._member.SerializePartialToIOString(self, iostring)
|
|
end
|
|
end
|
|
|
|
local function _AddSerializePartialToStringMethod(message_descriptor, message_meta)
|
|
local concat = table.concat
|
|
local _internal_serialize = function(self, write_bytes)
|
|
for field_descriptor, field_value in message_meta._member.ListFields(self) do
|
|
field_descriptor._encoder(write_bytes, field_value)
|
|
end
|
|
end
|
|
|
|
local _serialize_partial_to_iostring = function(self, iostring)
|
|
local w = iostring.write
|
|
local write = function(value)
|
|
w(iostring, value)
|
|
end
|
|
_internal_serialize(self, write)
|
|
return
|
|
end
|
|
|
|
local _serialize_partial_to_string = function(self)
|
|
local out = {}
|
|
local write = function(value)
|
|
out[#out + 1] = value
|
|
end
|
|
_internal_serialize(self, write)
|
|
return concat(out)
|
|
end
|
|
|
|
message_meta._member._InternalSerialize = _internal_serialize
|
|
message_meta._member.SerializePartialToIOString = _serialize_partial_to_iostring
|
|
message_meta._member.SerializePartialToString = _serialize_partial_to_string
|
|
end
|
|
|
|
|
|
|
|
local function _AddMergeFromStringMethod(message_descriptor, message_meta)
|
|
local ReadTag = decoder.ReadTag
|
|
local SkipField = decoder.SkipField
|
|
local decoders_by_tag = message_meta._decoders_by_tag
|
|
|
|
local _internal_parse = function(self, buffer, pos, pend)
|
|
message_meta._member._Modified(self)
|
|
local field_dict = self._fields
|
|
local tag_bytes, new_pos
|
|
local field_decoder
|
|
while pos ~= pend do
|
|
tag_bytes, new_pos = ReadTag(buffer, pos)
|
|
field_decoder = decoders_by_tag[tag_bytes]
|
|
if field_decoder == nil then
|
|
new_pos = SkipField(buffer, new_pos, pend, tag_bytes)
|
|
if new_pos == -1 then
|
|
return pos
|
|
end
|
|
pos = new_pos
|
|
else
|
|
pos = field_decoder(buffer, new_pos, pend, self, field_dict)
|
|
end
|
|
end
|
|
return pos
|
|
end
|
|
message_meta._member._InternalParse = _internal_parse
|
|
|
|
local merge_from_string = function(self, serialized)
|
|
local length = #serialized
|
|
if _internal_parse(self, serialized, 0, length) ~= length then
|
|
error('Unexpected end-group tag.')
|
|
end
|
|
return length
|
|
end
|
|
message_meta._member.MergeFromString = merge_from_string
|
|
|
|
message_meta._member.ParseFromString = function(self, serialized)
|
|
message_meta._member.Clear(self)
|
|
merge_from_string(self, serialized)
|
|
end
|
|
end
|
|
|
|
local function _AddIsInitializedMethod(message_descriptor, message_meta)
|
|
local required_fields = {}
|
|
for _, field in ipairs(message_descriptor.fields) do
|
|
if field.label == FieldDescriptor.LABEL_REQUIRED then
|
|
required_fields[#required_fields + 1] = field
|
|
end
|
|
end
|
|
|
|
message_meta._member.IsInitialized = function(self, errors)
|
|
for _, field in ipairs(required_fields) do
|
|
if self._fields[field] == nil or
|
|
(field.cpp_type == FieldDescriptor.CPPTYPE_MESSAGE and not self._fields[field]._is_present_in_parent) then
|
|
if errors ~= nil then
|
|
errors[#errors + 1] = message_meta._member.FindInitializationErrors(self)
|
|
end
|
|
return false
|
|
end
|
|
end
|
|
|
|
for field, value in pairs(self._fields) do
|
|
if field.cpp_type == FieldDescriptor.CPPTYPE_MESSAGE then
|
|
if field.label == FieldDescriptor.LABEL_REPEATED then
|
|
for _, element in ipairs(value) do
|
|
if not element:IsInitialized() then
|
|
if errors ~= nil then
|
|
errors[#errors + 1] = message_meta._member.FindInitializationErrors(self)
|
|
end
|
|
return false
|
|
end
|
|
end
|
|
elseif value._is_present_in_parent and not value:IsInitialized() then
|
|
if errors ~= nil then
|
|
errors[#errors + 1] = message_meta._member.FindInitializationErrors(self)
|
|
end
|
|
return false
|
|
end
|
|
end
|
|
end
|
|
return true
|
|
end
|
|
|
|
message_meta._member.FindInitializationErrors = function(self)
|
|
local errors = {}
|
|
|
|
for _,field in ipairs(required_fields) do
|
|
if not message_meta._member.HasField(self, field.name) then
|
|
errors[#errors + 1] = field.name
|
|
end
|
|
end
|
|
|
|
for field, value in message_meta._member.ListFields(self) do
|
|
if field.cpp_type == FieldDescriptor.CPPTYPE_MESSAGE then
|
|
if field.is_extension then
|
|
name = string.format("(%s)", field.full_name)
|
|
else
|
|
name = field.name
|
|
end
|
|
if field.label == FieldDescriptor.LABEL_REPEATED then
|
|
for i, element in ipairs(value) do
|
|
prefix = string.format("%s[%d].", name, i)
|
|
sub_errors = element:FindInitializationErrors()
|
|
for _, e in ipairs(sub_errors) do
|
|
errors[#errors + 1] = prefix .. e
|
|
end
|
|
end
|
|
else
|
|
prefix = name .. "."
|
|
sub_errors = value:FindInitializationErrors()
|
|
for _, e in ipairs(sub_errors) do
|
|
errors[#errors + 1] = prefix .. e
|
|
end
|
|
end
|
|
end
|
|
end
|
|
return errors
|
|
end
|
|
end
|
|
|
|
local function _AddMergeFromMethod(message_meta)
|
|
local LABEL_REPEATED = FieldDescriptor.LABEL_REPEATED
|
|
local CPPTYPE_MESSAGE = FieldDescriptor.CPPTYPE_MESSAGE
|
|
|
|
message_meta._member.MergeFrom = function (self, msg)
|
|
assert(msg ~= self)
|
|
message_meta._member._Modified(self)
|
|
|
|
local fields = self._fields
|
|
|
|
for field, value in pairs(msg._fields) do
|
|
if field.label == LABEL_REPEATED or field.cpp_type == CPPTYPE_MESSAGE then
|
|
field_value = fields[field]
|
|
if field_value == nil then
|
|
field_value = field._default_constructor(self)
|
|
fields[field] = field_value
|
|
end
|
|
field_value:MergeFrom(value)
|
|
else
|
|
self._fields[field] = value
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function _AddMessageMethods(message_descriptor, message_meta)
|
|
_AddListFieldsMethod(message_descriptor, message_meta)
|
|
_AddHasFieldMethod(message_descriptor, message_meta)
|
|
_AddClearFieldMethod(message_descriptor, message_meta)
|
|
if message_descriptor.is_extendable then
|
|
_AddClearExtensionMethod(message_meta)
|
|
_AddHasExtensionMethod(message_meta)
|
|
end
|
|
_AddClearMethod(message_descriptor, message_meta)
|
|
-- _AddEqualsMethod(message_descriptor, message_meta)
|
|
_AddStrMethod(message_meta)
|
|
_AddSetListenerMethod(message_meta)
|
|
_AddByteSizeMethod(message_descriptor, message_meta)
|
|
_AddSerializeToStringMethod(message_descriptor, message_meta)
|
|
_AddSerializePartialToStringMethod(message_descriptor, message_meta)
|
|
_AddMergeFromStringMethod(message_descriptor, message_meta)
|
|
_AddIsInitializedMethod(message_descriptor, message_meta)
|
|
_AddMergeFromMethod(message_meta)
|
|
end
|
|
|
|
local function _AddPrivateHelperMethods(message_meta)
|
|
local Modified = function (self)
|
|
if not self._cached_byte_size_dirty then
|
|
self._cached_byte_size_dirty = true
|
|
self._listener_for_children.dirty = true
|
|
self._is_present_in_parent = true
|
|
self._listener:Modified()
|
|
end
|
|
end
|
|
message_meta._member._Modified = Modified
|
|
message_meta._member.SetInParent = Modified
|
|
end
|
|
|
|
local function property_getter(message_meta)
|
|
local getter = message_meta._getter
|
|
local member = message_meta._member
|
|
|
|
return function (self, property)
|
|
local g = getter[property]
|
|
if g then
|
|
return g(self)
|
|
else
|
|
return member[property]
|
|
end
|
|
end
|
|
end
|
|
|
|
local function property_setter(message_meta)
|
|
local setter = message_meta._setter
|
|
|
|
return function (self, property, value)
|
|
local s = setter[property]
|
|
if s then
|
|
s(self, value)
|
|
else
|
|
error(property .. " not found")
|
|
end
|
|
end
|
|
end
|
|
|
|
function _AddClassAttributesForNestedExtensions(descriptor, message_meta)
|
|
local extension_dict = descriptor._extensions_by_name
|
|
for extension_name, extension_field in pairs(extension_dict) do
|
|
message_meta._member[extension_name] = extension_field
|
|
end
|
|
end
|
|
|
|
local function Message(descriptor)
|
|
local message_meta = {}
|
|
message_meta._decoders_by_tag = {}
|
|
rawset(descriptor, "_extensions_by_name", {})
|
|
for _, k in ipairs(descriptor.extensions) do
|
|
descriptor._extensions_by_name[k.name] = k
|
|
end
|
|
rawset(descriptor, "_extensions_by_number", {})
|
|
for _, k in ipairs(descriptor.extensions) do
|
|
descriptor._extensions_by_number[k.number] = k
|
|
end
|
|
message_meta._descriptor = descriptor
|
|
message_meta._extensions_by_name = {}
|
|
message_meta._extensions_by_number = {}
|
|
|
|
message_meta._getter = {}
|
|
message_meta._setter = {}
|
|
message_meta._member = {}
|
|
-- message_meta._name = descriptor.full_name
|
|
|
|
local ns = setmetatable({}, message_meta._member)
|
|
message_meta._member.__call = _InitMethod(message_meta)
|
|
message_meta._member.__index = message_meta._member
|
|
message_meta._member.type = ns
|
|
|
|
if rawget(descriptor, "_concrete_class") == nil then
|
|
rawset(descriptor, "_concrete_class", ns)
|
|
for k, field in ipairs(descriptor.fields) do
|
|
_AttachFieldHelpers(message_meta, field)
|
|
end
|
|
end
|
|
_AddEnumValues(descriptor, message_meta)
|
|
_AddClassAttributesForNestedExtensions(descriptor, message_meta)
|
|
_AddPropertiesForFields(descriptor, message_meta)
|
|
_AddPropertiesForExtensions(descriptor, message_meta)
|
|
_AddStaticMethods(message_meta)
|
|
_AddMessageMethods(descriptor, message_meta)
|
|
_AddPrivateHelperMethods(message_meta)
|
|
|
|
message_meta.__index = property_getter(message_meta)
|
|
message_meta.__newindex = property_setter(message_meta)
|
|
|
|
return ns
|
|
end
|
|
|
|
_M.Message = Message
|
|
|