526 lines
18 KiB
Objective-C
526 lines
18 KiB
Objective-C
// Protocol Buffers - Google's data interchange format
|
|
// Copyright 2008 Google Inc. All rights reserved.
|
|
// https://developers.google.com/protocol-buffers/
|
|
//
|
|
// Redistribution and use in source and binary forms, with or without
|
|
// modification, are permitted provided that the following conditions are
|
|
// met:
|
|
//
|
|
// * Redistributions of source code must retain the above copyright
|
|
// notice, this list of conditions and the following disclaimer.
|
|
// * Redistributions in binary form must reproduce the above
|
|
// copyright notice, this list of conditions and the following disclaimer
|
|
// in the documentation and/or other materials provided with the
|
|
// distribution.
|
|
// * Neither the name of Google Inc. nor the names of its
|
|
// contributors may be used to endorse or promote products derived from
|
|
// this software without specific prior written permission.
|
|
//
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
#import "GPBExtensionField_PackagePrivate.h"
|
|
|
|
#import <objc/runtime.h>
|
|
|
|
#import "GPBCodedInputStream_PackagePrivate.h"
|
|
#import "GPBCodedOutputStream.h"
|
|
#import "GPBDescriptor_PackagePrivate.h"
|
|
#import "GPBMessage_PackagePrivate.h"
|
|
#import "GPBUtilities_PackagePrivate.h"
|
|
|
|
GPB_INLINE size_t TypeSize(GPBType type) {
|
|
switch (type) {
|
|
case GPBTypeBool:
|
|
return 1;
|
|
case GPBTypeFixed32:
|
|
case GPBTypeSFixed32:
|
|
case GPBTypeFloat:
|
|
return 4;
|
|
case GPBTypeFixed64:
|
|
case GPBTypeSFixed64:
|
|
case GPBTypeDouble:
|
|
return 8;
|
|
default:
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
GPB_INLINE BOOL ExtensionIsRepeated(GPBExtensionDescription *description) {
|
|
return (description->options & GPBExtensionRepeated) != 0;
|
|
}
|
|
|
|
GPB_INLINE BOOL ExtensionIsPacked(GPBExtensionDescription *description) {
|
|
return (description->options & GPBExtensionPacked) != 0;
|
|
}
|
|
|
|
GPB_INLINE BOOL ExtensionIsWireFormat(GPBExtensionDescription *description) {
|
|
return (description->options & GPBExtensionSetWireFormat) != 0;
|
|
}
|
|
|
|
static size_t ComputePBSerializedSizeNoTagOfObject(GPBType type, id object) {
|
|
#define FIELD_CASE(TYPE, ACCESSOR) \
|
|
case GPBType##TYPE: \
|
|
return GPBCompute##TYPE##SizeNoTag([(NSNumber *)object ACCESSOR]);
|
|
#define FIELD_CASE2(TYPE) \
|
|
case GPBType##TYPE: \
|
|
return GPBCompute##TYPE##SizeNoTag(object);
|
|
switch (type) {
|
|
FIELD_CASE(Bool, boolValue)
|
|
FIELD_CASE(Float, floatValue)
|
|
FIELD_CASE(Double, doubleValue)
|
|
FIELD_CASE(Int32, intValue)
|
|
FIELD_CASE(SFixed32, intValue)
|
|
FIELD_CASE(SInt32, intValue)
|
|
FIELD_CASE(Enum, intValue)
|
|
FIELD_CASE(Int64, longLongValue)
|
|
FIELD_CASE(SInt64, longLongValue)
|
|
FIELD_CASE(SFixed64, longLongValue)
|
|
FIELD_CASE(UInt32, unsignedIntValue)
|
|
FIELD_CASE(Fixed32, unsignedIntValue)
|
|
FIELD_CASE(UInt64, unsignedLongLongValue)
|
|
FIELD_CASE(Fixed64, unsignedLongLongValue)
|
|
FIELD_CASE2(Data)
|
|
FIELD_CASE2(String)
|
|
FIELD_CASE2(Message)
|
|
FIELD_CASE2(Group)
|
|
}
|
|
#undef FIELD_CASE
|
|
#undef FIELD_CASE2
|
|
}
|
|
|
|
static size_t ComputeSerializedSizeIncludingTagOfObject(
|
|
GPBExtensionDescription *description, id object) {
|
|
#define FIELD_CASE(TYPE, ACCESSOR) \
|
|
case GPBType##TYPE: \
|
|
return GPBCompute##TYPE##Size(description->fieldNumber, \
|
|
[(NSNumber *)object ACCESSOR]);
|
|
#define FIELD_CASE2(TYPE) \
|
|
case GPBType##TYPE: \
|
|
return GPBCompute##TYPE##Size(description->fieldNumber, object);
|
|
switch (description->type) {
|
|
FIELD_CASE(Bool, boolValue)
|
|
FIELD_CASE(Float, floatValue)
|
|
FIELD_CASE(Double, doubleValue)
|
|
FIELD_CASE(Int32, intValue)
|
|
FIELD_CASE(SFixed32, intValue)
|
|
FIELD_CASE(SInt32, intValue)
|
|
FIELD_CASE(Enum, intValue)
|
|
FIELD_CASE(Int64, longLongValue)
|
|
FIELD_CASE(SInt64, longLongValue)
|
|
FIELD_CASE(SFixed64, longLongValue)
|
|
FIELD_CASE(UInt32, unsignedIntValue)
|
|
FIELD_CASE(Fixed32, unsignedIntValue)
|
|
FIELD_CASE(UInt64, unsignedLongLongValue)
|
|
FIELD_CASE(Fixed64, unsignedLongLongValue)
|
|
FIELD_CASE2(Data)
|
|
FIELD_CASE2(String)
|
|
FIELD_CASE2(Group)
|
|
case GPBTypeMessage:
|
|
if (ExtensionIsWireFormat(description)) {
|
|
return GPBComputeMessageSetExtensionSize(description->fieldNumber,
|
|
object);
|
|
} else {
|
|
return GPBComputeMessageSize(description->fieldNumber, object);
|
|
}
|
|
}
|
|
#undef FIELD_CASE
|
|
#undef FIELD_CASE2
|
|
}
|
|
|
|
static size_t ComputeSerializedSizeIncludingTagOfArray(
|
|
GPBExtensionDescription *description, NSArray *values) {
|
|
if (ExtensionIsPacked(description)) {
|
|
size_t size = 0;
|
|
size_t typeSize = TypeSize(description->type);
|
|
if (typeSize != 0) {
|
|
size = values.count * typeSize;
|
|
} else {
|
|
for (id value in values) {
|
|
size += ComputePBSerializedSizeNoTagOfObject(description->type, value);
|
|
}
|
|
}
|
|
return size + GPBComputeTagSize(description->fieldNumber) +
|
|
GPBComputeRawVarint32SizeForInteger(size);
|
|
} else {
|
|
size_t size = 0;
|
|
for (id value in values) {
|
|
size += ComputeSerializedSizeIncludingTagOfObject(description, value);
|
|
}
|
|
return size;
|
|
}
|
|
}
|
|
|
|
static void WriteObjectIncludingTagToCodedOutputStream(
|
|
id object, GPBExtensionDescription *description,
|
|
GPBCodedOutputStream *output) {
|
|
#define FIELD_CASE(TYPE, ACCESSOR) \
|
|
case GPBType##TYPE: \
|
|
[output write##TYPE:description->fieldNumber \
|
|
value:[(NSNumber *)object ACCESSOR]]; \
|
|
return;
|
|
#define FIELD_CASE2(TYPE) \
|
|
case GPBType##TYPE: \
|
|
[output write##TYPE:description->fieldNumber value:object]; \
|
|
return;
|
|
switch (description->type) {
|
|
FIELD_CASE(Bool, boolValue)
|
|
FIELD_CASE(Float, floatValue)
|
|
FIELD_CASE(Double, doubleValue)
|
|
FIELD_CASE(Int32, intValue)
|
|
FIELD_CASE(SFixed32, intValue)
|
|
FIELD_CASE(SInt32, intValue)
|
|
FIELD_CASE(Enum, intValue)
|
|
FIELD_CASE(Int64, longLongValue)
|
|
FIELD_CASE(SInt64, longLongValue)
|
|
FIELD_CASE(SFixed64, longLongValue)
|
|
FIELD_CASE(UInt32, unsignedIntValue)
|
|
FIELD_CASE(Fixed32, unsignedIntValue)
|
|
FIELD_CASE(UInt64, unsignedLongLongValue)
|
|
FIELD_CASE(Fixed64, unsignedLongLongValue)
|
|
FIELD_CASE2(Data)
|
|
FIELD_CASE2(String)
|
|
FIELD_CASE2(Group)
|
|
case GPBTypeMessage:
|
|
if (ExtensionIsWireFormat(description)) {
|
|
[output writeMessageSetExtension:description->fieldNumber value:object];
|
|
} else {
|
|
[output writeMessage:description->fieldNumber value:object];
|
|
}
|
|
return;
|
|
}
|
|
#undef FIELD_CASE
|
|
#undef FIELD_CASE2
|
|
}
|
|
|
|
static void WriteObjectNoTagToCodedOutputStream(
|
|
id object, GPBExtensionDescription *description,
|
|
GPBCodedOutputStream *output) {
|
|
#define FIELD_CASE(TYPE, ACCESSOR) \
|
|
case GPBType##TYPE: \
|
|
[output write##TYPE##NoTag:[(NSNumber *)object ACCESSOR]]; \
|
|
return;
|
|
#define FIELD_CASE2(TYPE) \
|
|
case GPBType##TYPE: \
|
|
[output write##TYPE##NoTag:object]; \
|
|
return;
|
|
switch (description->type) {
|
|
FIELD_CASE(Bool, boolValue)
|
|
FIELD_CASE(Float, floatValue)
|
|
FIELD_CASE(Double, doubleValue)
|
|
FIELD_CASE(Int32, intValue)
|
|
FIELD_CASE(SFixed32, intValue)
|
|
FIELD_CASE(SInt32, intValue)
|
|
FIELD_CASE(Enum, intValue)
|
|
FIELD_CASE(Int64, longLongValue)
|
|
FIELD_CASE(SInt64, longLongValue)
|
|
FIELD_CASE(SFixed64, longLongValue)
|
|
FIELD_CASE(UInt32, unsignedIntValue)
|
|
FIELD_CASE(Fixed32, unsignedIntValue)
|
|
FIELD_CASE(UInt64, unsignedLongLongValue)
|
|
FIELD_CASE(Fixed64, unsignedLongLongValue)
|
|
FIELD_CASE2(Data)
|
|
FIELD_CASE2(String)
|
|
FIELD_CASE2(Message)
|
|
case GPBTypeGroup:
|
|
[output writeGroupNoTag:description->fieldNumber value:object];
|
|
return;
|
|
}
|
|
#undef FIELD_CASE
|
|
#undef FIELD_CASE2
|
|
}
|
|
|
|
static void WriteArrayIncludingTagsToCodedOutputStream(
|
|
NSArray *values, GPBExtensionDescription *description,
|
|
GPBCodedOutputStream *output) {
|
|
if (ExtensionIsPacked(description)) {
|
|
[output writeTag:description->fieldNumber
|
|
format:GPBWireFormatLengthDelimited];
|
|
size_t dataSize = 0;
|
|
size_t typeSize = TypeSize(description->type);
|
|
if (typeSize != 0) {
|
|
dataSize = values.count * typeSize;
|
|
} else {
|
|
for (id value in values) {
|
|
dataSize +=
|
|
ComputePBSerializedSizeNoTagOfObject(description->type, value);
|
|
}
|
|
}
|
|
[output writeRawVarintSizeTAs32:dataSize];
|
|
for (id value in values) {
|
|
WriteObjectNoTagToCodedOutputStream(value, description, output);
|
|
}
|
|
} else {
|
|
for (id value in values) {
|
|
WriteObjectIncludingTagToCodedOutputStream(value, description, output);
|
|
}
|
|
}
|
|
}
|
|
|
|
@implementation GPBExtensionField {
|
|
GPBExtensionDescription *description_;
|
|
GPBExtensionDescriptor *descriptor_;
|
|
GPBValue defaultValue_;
|
|
}
|
|
|
|
@synthesize containingType = containingType_;
|
|
@synthesize descriptor = descriptor_;
|
|
|
|
- (instancetype)init {
|
|
// Throw an exception if people attempt to not use the designated initializer.
|
|
self = [super init];
|
|
if (self != nil) {
|
|
[self doesNotRecognizeSelector:_cmd];
|
|
self = nil;
|
|
}
|
|
return self;
|
|
}
|
|
|
|
- (instancetype)initWithDescription:(GPBExtensionDescription *)description {
|
|
if ((self = [super init])) {
|
|
description_ = description;
|
|
if (description->extendedClass) {
|
|
Class containingClass = objc_lookUpClass(description->extendedClass);
|
|
NSAssert1(containingClass, @"Class %s not defined",
|
|
description->extendedClass);
|
|
containingType_ = [containingClass descriptor];
|
|
}
|
|
#if DEBUG
|
|
const char *className = description->messageOrGroupClassName;
|
|
if (className) {
|
|
NSAssert1(objc_lookUpClass(className) != Nil, @"Class %s not defined",
|
|
className);
|
|
}
|
|
#endif
|
|
descriptor_ = [[GPBExtensionDescriptor alloc]
|
|
initWithExtensionDescription:description];
|
|
GPBType type = description_->type;
|
|
if (type == GPBTypeData) {
|
|
// Data stored as a length prefixed c-string in descriptor records.
|
|
const uint8_t *bytes =
|
|
(const uint8_t *)description->defaultValue.valueData;
|
|
if (bytes) {
|
|
uint32_t length = *((uint32_t *)bytes);
|
|
// The length is stored in network byte order.
|
|
length = ntohl(length);
|
|
bytes += sizeof(length);
|
|
defaultValue_.valueData =
|
|
[[NSData alloc] initWithBytes:bytes length:length];
|
|
}
|
|
} else if (type == GPBTypeMessage || type == GPBTypeGroup) {
|
|
// The default is looked up in -defaultValue instead since extensions
|
|
// aren't
|
|
// common, we avoid the hit startup hit and it avoid initialization order
|
|
// issues.
|
|
} else {
|
|
defaultValue_ = description->defaultValue;
|
|
}
|
|
}
|
|
return self;
|
|
}
|
|
|
|
- (void)dealloc {
|
|
if ((description_->type == GPBTypeData) &&
|
|
!ExtensionIsRepeated(description_)) {
|
|
[defaultValue_.valueData release];
|
|
}
|
|
[descriptor_ release];
|
|
[super dealloc];
|
|
}
|
|
|
|
- (NSString *)description {
|
|
return [NSString stringWithFormat:@"<%@ %p> FieldNumber:%d ContainingType:%@",
|
|
[self class], self, self.fieldNumber,
|
|
self.containingType];
|
|
}
|
|
|
|
- (id)copyWithZone:(NSZone *)__unused zone {
|
|
return [self retain];
|
|
}
|
|
|
|
#pragma mark Properties
|
|
|
|
- (int32_t)fieldNumber {
|
|
return description_->fieldNumber;
|
|
}
|
|
|
|
- (GPBWireFormat)wireType {
|
|
return GPBWireFormatForType(description_->type,
|
|
ExtensionIsPacked(description_));
|
|
}
|
|
|
|
- (BOOL)isRepeated {
|
|
return ExtensionIsRepeated(description_);
|
|
}
|
|
|
|
- (id)defaultValue {
|
|
if (ExtensionIsRepeated(description_)) {
|
|
return nil;
|
|
}
|
|
|
|
switch (description_->type) {
|
|
case GPBTypeBool:
|
|
return @(defaultValue_.valueBool);
|
|
case GPBTypeFloat:
|
|
return @(defaultValue_.valueFloat);
|
|
case GPBTypeDouble:
|
|
return @(defaultValue_.valueDouble);
|
|
case GPBTypeInt32:
|
|
case GPBTypeSInt32:
|
|
case GPBTypeEnum:
|
|
case GPBTypeSFixed32:
|
|
return @(defaultValue_.valueInt32);
|
|
case GPBTypeInt64:
|
|
case GPBTypeSInt64:
|
|
case GPBTypeSFixed64:
|
|
return @(defaultValue_.valueInt64);
|
|
case GPBTypeUInt32:
|
|
case GPBTypeFixed32:
|
|
return @(defaultValue_.valueUInt32);
|
|
case GPBTypeUInt64:
|
|
case GPBTypeFixed64:
|
|
return @(defaultValue_.valueUInt64);
|
|
case GPBTypeData:
|
|
// Like message fields, the default is zero length data.
|
|
return (defaultValue_.valueData ? defaultValue_.valueData
|
|
: GPBEmptyNSData());
|
|
case GPBTypeString:
|
|
// Like message fields, the default is zero length string.
|
|
return (defaultValue_.valueString ? defaultValue_.valueString : @"");
|
|
case GPBTypeGroup:
|
|
case GPBTypeMessage:
|
|
NSAssert(0, @"Shouldn't get here");
|
|
return nil;
|
|
}
|
|
}
|
|
|
|
#pragma mark Internals
|
|
|
|
- (void)mergeFromCodedInputStream:(GPBCodedInputStream *)input
|
|
extensionRegistry:(GPBExtensionRegistry *)extensionRegistry
|
|
message:(GPBMessage *)message {
|
|
GPBCodedInputStreamState *state = &input->state_;
|
|
if (ExtensionIsPacked(description_)) {
|
|
int32_t length = GPBCodedInputStreamReadInt32(state);
|
|
size_t limit = GPBCodedInputStreamPushLimit(state, length);
|
|
while (GPBCodedInputStreamBytesUntilLimit(state) > 0) {
|
|
id value = [self newSingleValueFromCodedInputStream:input
|
|
extensionRegistry:extensionRegistry
|
|
existingValue:nil];
|
|
[message addExtension:self value:value];
|
|
[value release];
|
|
}
|
|
GPBCodedInputStreamPopLimit(state, limit);
|
|
} else {
|
|
id existingValue = nil;
|
|
BOOL isRepeated = ExtensionIsRepeated(description_);
|
|
if (!isRepeated && GPBTypeIsMessage(description_->type)) {
|
|
existingValue = [message getExistingExtension:self];
|
|
}
|
|
id value = [self newSingleValueFromCodedInputStream:input
|
|
extensionRegistry:extensionRegistry
|
|
existingValue:existingValue];
|
|
if (isRepeated) {
|
|
[message addExtension:self value:value];
|
|
} else {
|
|
[message setExtension:self value:value];
|
|
}
|
|
[value release];
|
|
}
|
|
}
|
|
|
|
- (void)writeValue:(id)value
|
|
includingTagToCodedOutputStream:(GPBCodedOutputStream *)output {
|
|
if (ExtensionIsRepeated(description_)) {
|
|
WriteArrayIncludingTagsToCodedOutputStream(value, description_, output);
|
|
} else {
|
|
WriteObjectIncludingTagToCodedOutputStream(value, description_, output);
|
|
}
|
|
}
|
|
|
|
- (size_t)computeSerializedSizeIncludingTag:(id)value {
|
|
if (ExtensionIsRepeated(description_)) {
|
|
return ComputeSerializedSizeIncludingTagOfArray(description_, value);
|
|
} else {
|
|
return ComputeSerializedSizeIncludingTagOfObject(description_, value);
|
|
}
|
|
}
|
|
|
|
// Note that this returns a retained value intentionally.
|
|
- (id)newSingleValueFromCodedInputStream:(GPBCodedInputStream *)input
|
|
extensionRegistry:(GPBExtensionRegistry *)extensionRegistry
|
|
existingValue:(GPBMessage *)existingValue {
|
|
GPBCodedInputStreamState *state = &input->state_;
|
|
switch (description_->type) {
|
|
case GPBTypeBool: return [[NSNumber alloc] initWithBool:GPBCodedInputStreamReadBool(state)];
|
|
case GPBTypeFixed32: return [[NSNumber alloc] initWithUnsignedInt:GPBCodedInputStreamReadFixed32(state)];
|
|
case GPBTypeSFixed32: return [[NSNumber alloc] initWithInt:GPBCodedInputStreamReadSFixed32(state)];
|
|
case GPBTypeFloat: return [[NSNumber alloc] initWithFloat:GPBCodedInputStreamReadFloat(state)];
|
|
case GPBTypeFixed64: return [[NSNumber alloc] initWithUnsignedLongLong:GPBCodedInputStreamReadFixed64(state)];
|
|
case GPBTypeSFixed64: return [[NSNumber alloc] initWithLongLong:GPBCodedInputStreamReadSFixed64(state)];
|
|
case GPBTypeDouble: return [[NSNumber alloc] initWithDouble:GPBCodedInputStreamReadDouble(state)];
|
|
case GPBTypeInt32: return [[NSNumber alloc] initWithInt:GPBCodedInputStreamReadInt32(state)];
|
|
case GPBTypeInt64: return [[NSNumber alloc] initWithLongLong:GPBCodedInputStreamReadInt64(state)];
|
|
case GPBTypeSInt32: return [[NSNumber alloc] initWithInt:GPBCodedInputStreamReadSInt32(state)];
|
|
case GPBTypeSInt64: return [[NSNumber alloc] initWithLongLong:GPBCodedInputStreamReadSInt64(state)];
|
|
case GPBTypeUInt32: return [[NSNumber alloc] initWithUnsignedInt:GPBCodedInputStreamReadUInt32(state)];
|
|
case GPBTypeUInt64: return [[NSNumber alloc] initWithUnsignedLongLong:GPBCodedInputStreamReadUInt64(state)];
|
|
case GPBTypeData: return GPBCodedInputStreamReadRetainedData(state);
|
|
case GPBTypeString: return GPBCodedInputStreamReadRetainedString(state);
|
|
case GPBTypeEnum: return [[NSNumber alloc] initWithInt:GPBCodedInputStreamReadEnum(state)];
|
|
case GPBTypeGroup:
|
|
case GPBTypeMessage: {
|
|
GPBMessage *message;
|
|
if (existingValue) {
|
|
message = [existingValue retain];
|
|
} else {
|
|
GPBDescriptor *decriptor = [descriptor_.msgClass descriptor];
|
|
message = [[decriptor.messageClass alloc] init];
|
|
}
|
|
|
|
if (description_->type == GPBTypeGroup) {
|
|
[input readGroup:description_->fieldNumber
|
|
message:message
|
|
extensionRegistry:extensionRegistry];
|
|
} else {
|
|
// description_->type == GPBTypeMessage
|
|
if (ExtensionIsWireFormat(description_)) {
|
|
// For MessageSet fields the message length will have already been
|
|
// read.
|
|
[message mergeFromCodedInputStream:input
|
|
extensionRegistry:extensionRegistry];
|
|
} else {
|
|
[input readMessage:message extensionRegistry:extensionRegistry];
|
|
}
|
|
}
|
|
|
|
return message;
|
|
}
|
|
}
|
|
|
|
return nil;
|
|
}
|
|
|
|
- (NSComparisonResult)compareByFieldNumber:(GPBExtensionField *)other {
|
|
int32_t selfNumber = description_->fieldNumber;
|
|
int32_t otherNumber = other->description_->fieldNumber;
|
|
if (selfNumber < otherNumber) {
|
|
return NSOrderedAscending;
|
|
} else if (selfNumber == otherNumber) {
|
|
return NSOrderedSame;
|
|
} else {
|
|
return NSOrderedDescending;
|
|
}
|
|
}
|
|
|
|
@end
|