FlutterStandardWriter Class Reference

#include <FlutterCodecs.h>

Inheritance diagram for FlutterStandardWriter:

Instance Methods
(instancetype)	- initWithData:
(void)	- writeByte:
(void)	- writeBytes:length:
(void)	- writeData:
(void)	- writeSize:
(void)	- writeAlignment:
(void)	- writeUTF8:
(void)	- writeValue:

Class Methods
(static FlutterStandardCodecObjcType)	+ GetWriteType [implementation]
(static void)	+ WriteKeyValues [implementation]
(static void)	+ FastWriteValueOfType [implementation]
(static void)	+ WriteValueOfType [implementation]

Detailed Description

A writer of the Flutter standard binary encoding.

See FlutterStandardMessageCodec for details on the encoding.

The encoding is extensible via subclasses overriding writeValue.

Definition at line 92 of file FlutterCodecs.h.

Method Documentation

FastWriteValueOfType

+ (static void) FastWriteValueOfType (CFTypeRef)  writer (CFMutableDataRef)  data (CFTypeRef)  value

implementation

Definition at line 271 of file FlutterStandardCodec.mm.

                                                                                           {
  FlutterStandardCodecObjcType type = GetWriteType((__bridge id)value);
  if (type != FlutterStandardCodecObjcTypeUnknown) {
    WriteValueOfType(writer, data, type, value);
  } else {
    [(__bridge FlutterStandardWriter*)writer writeValue:(__bridge id)value];
  }
}

GetWriteType

+ (static FlutterStandardCodecObjcType) GetWriteType (id)  value

implementation

Definition at line 238 of file FlutterStandardCodec.mm.

                                                           {
  if (value == nil || (__bridge CFNullRef)value == kCFNull) {
    return FlutterStandardCodecObjcTypeNil;
  } else if ([value isKindOfClass:[NSNumber class]]) {
    return FlutterStandardCodecObjcTypeNSNumber;
  } else if ([value isKindOfClass:[NSString class]]) {
    return FlutterStandardCodecObjcTypeNSString;
  } else if ([value isKindOfClass:[FlutterStandardTypedData class]]) {
    return FlutterStandardCodecObjcTypeFlutterStandardTypedData;
  } else if ([value isKindOfClass:[NSData class]]) {
    return FlutterStandardCodecObjcTypeNSData;
  } else if ([value isKindOfClass:[NSArray class]]) {
    return FlutterStandardCodecObjcTypeNSArray;
  } else if ([value isKindOfClass:[NSDictionary class]]) {
    return FlutterStandardCodecObjcTypeNSDictionary;
  } else {
    return FlutterStandardCodecObjcTypeUnknown;
  }
}

initWithData:

- (instancetype) initWithData:

(NSMutableData*)

data

Initial value:

{
  NSMutableData* _data

Create a FlutterStandardWriter who will write to data.

Definition at line 8 of file FlutterStandardCodec.mm.

                            :(NSMutableData*)data {
  self = [super init];
  NSAssert(self, @"Super init cannot be nil");
  _data = data;
  return self;
}

writeAlignment:

- (void) writeAlignment:

(UInt8)

alignment

Write zero padding until data is aligned with alignment.

Definition at line 8 of file FlutterStandardCodec.mm.

                      :(UInt8)alignment {
  FlutterStandardCodecHelperWriteAlignment((__bridge CFMutableDataRef)_data, alignment);
}

writeByte:

- (void) writeByte:

(UInt8)

value

Write a 8-bit byte.

Definition at line 8 of file FlutterStandardCodec.mm.

                 :(UInt8)value {
  FlutterStandardCodecHelperWriteByte((__bridge CFMutableDataRef)_data, value);
}

writeBytes:length:

- (void) writeBytes:		(const void*)	bytes
length:		(NSUInteger)	length

Write an array of bytes of size length.

Definition at line 8 of file FlutterStandardCodec.mm.

                  :(const void*)bytes length:(NSUInteger)length {
  FlutterStandardCodecHelperWriteBytes((__bridge CFMutableDataRef)_data, bytes, length);
}

writeData:

- (void) writeData:

(NSData*)

data

Write an array of bytes contained in data.

Definition at line 8 of file FlutterStandardCodec.mm.

                 :(NSData*)data {
  FlutterStandardCodecHelperWriteData((__bridge CFMutableDataRef)_data, (__bridge CFDataRef)data);
}

WriteKeyValues

+ (static void) WriteKeyValues (CFTypeRef)  key (CFTypeRef)  value (void *)  context

implementation

Definition at line 263 of file FlutterStandardCodec.mm.

                                                                          {
  WriteKeyValuesInfo* info = (WriteKeyValuesInfo*)context;
  FastWriteValueOfType(info->writer, info->data, key);
  FastWriteValueOfType(info->writer, info->data, value);
}

writeSize:

- (void) writeSize:

(UInt32)

size

Write 32-bit unsigned integer that represents a size of a collection.

Definition at line 8 of file FlutterStandardCodec.mm.

                 :(UInt32)size {
  FlutterStandardCodecHelperWriteSize((__bridge CFMutableDataRef)_data, size);
}

writeUTF8:

- (void) writeUTF8:

(NSString*)

value

Write a string with UTF-8 encoding.

Definition at line 8 of file FlutterStandardCodec.mm.

                 :(NSString*)value {
  FlutterStandardCodecHelperWriteUTF8((__bridge CFMutableDataRef)_data,
                                      (__bridge CFStringRef)value);
}

writeValue:

- (void) writeValue:

(id)

value

Introspects into an object and writes its representation.

Supported Data Types:

• NSNull
• NSNumber
• NSString (as UTF-8)
• FlutterStandardTypedData
• NSArray of supported types
• NSDictionary of supporte types

NSAsserts on failure.

Reimplemented in ExtendedWriter.

Definition at line 280 of file FlutterStandardCodec.mm.

                  :(id)value {
  FlutterStandardCodecObjcType type = GetWriteType(value);
  WriteValueOfType((__bridge CFTypeRef)self, (__bridge CFMutableDataRef)self->_data, type,
                   (__bridge CFTypeRef)value);
}

WriteValueOfType

+ (static void) WriteValueOfType (CFTypeRef)  writer (CFMutableDataRef)  data (FlutterStandardCodecObjcType)  type (CFTypeRef)  value

implementation

Definition at line 280 of file FlutterStandardCodec.mm.

                                              {
  switch (type) {
    case FlutterStandardCodecObjcTypeNil:
      FlutterStandardCodecHelperWriteByte(data, FlutterStandardFieldNil);
      break;
    case FlutterStandardCodecObjcTypeNSNumber: {
      CFNumberRef number = (CFNumberRef)value;
      BOOL success = FlutterStandardCodecHelperWriteNumber(data, number);
      if (!success) {
        NSLog(@"Unsupported value: %@ of number type %ld", value, CFNumberGetType(number));
        NSCAssert(NO, @"Unsupported value for standard codec");
      }
      break;
    }
    case FlutterStandardCodecObjcTypeNSString: {
      CFStringRef string = (CFStringRef)value;
      FlutterStandardCodecHelperWriteByte(data, FlutterStandardFieldString);
      FlutterStandardCodecHelperWriteUTF8(data, string);
      break;
    }
    case FlutterStandardCodecObjcTypeFlutterStandardTypedData: {
      FlutterStandardTypedData* typedData = (__bridge FlutterStandardTypedData*)value;
      FlutterStandardCodecHelperWriteByte(data, FlutterStandardFieldForDataType(typedData.type));
      FlutterStandardCodecHelperWriteSize(data, typedData.elementCount);
      FlutterStandardCodecHelperWriteAlignment(data, typedData.elementSize);
      FlutterStandardCodecHelperWriteData(data, (__bridge CFDataRef)typedData.data);
      break;
    }
    case FlutterStandardCodecObjcTypeNSData:
      WriteValueOfType(writer, data, FlutterStandardCodecObjcTypeFlutterStandardTypedData,
                       (__bridge CFTypeRef)
                           [FlutterStandardTypedData typedDataWithBytes:(__bridge NSData*)value]);
      break;
    case FlutterStandardCodecObjcTypeNSArray: {
      CFArrayRef array = (CFArrayRef)value;
      FlutterStandardCodecHelperWriteByte(data, FlutterStandardFieldList);
      CFIndex count = CFArrayGetCount(array);
      FlutterStandardCodecHelperWriteSize(data, count);
      for (CFIndex i = 0; i < count; ++i) {
        FastWriteValueOfType(writer, data, CFArrayGetValueAtIndex(array, i));
      }
      break;
    }
    case FlutterStandardCodecObjcTypeNSDictionary: {
      CFDictionaryRef dict = (CFDictionaryRef)value;
      FlutterStandardCodecHelperWriteByte(data, FlutterStandardFieldMap);
      CFIndex count = CFDictionaryGetCount(dict);
      FlutterStandardCodecHelperWriteSize(data, count);
      WriteKeyValuesInfo info = {
          .writer = writer,
          .data = data,
      };
      CFDictionaryApplyFunction(dict, WriteKeyValues, (void*)&info);
      break;
    }
    case FlutterStandardCodecObjcTypeUnknown: {
      id objc_value = (__bridge id)value;
      NSLog(@"Unsupported value: %@ of type %@", objc_value, [objc_value class]);
      NSCAssert(NO, @"Unsupported value for standard codec");
      break;
    }
  }
}

---

The documentation for this class was generated from the following files:

• shell/platform/darwin/common/framework/Headers/FlutterCodecs.h
• shell/platform/darwin/common/framework/Source/FlutterStandardCodec.mm