flutter::StandardCodecSerializer Class Reference

#include <standard_codec_serializer.h>

Public Member Functions
virtual	~StandardCodecSerializer ()
	StandardCodecSerializer (StandardCodecSerializer const &)=delete
StandardCodecSerializer &	operator= (StandardCodecSerializer const &)=delete
EncodableValue	ReadValue (ByteStreamReader *stream) const
virtual void	WriteValue (const EncodableValue &value, ByteStreamWriter *stream) const

Static Public Member Functions
static const StandardCodecSerializer &	GetInstance ()

Protected Member Functions
	StandardCodecSerializer ()
virtual EncodableValue	ReadValueOfType (uint8_t type, ByteStreamReader *stream) const
size_t	ReadSize (ByteStreamReader *stream) const
void	WriteSize (size_t size, ByteStreamWriter *stream) const

Detailed Description

Definition at line 18 of file standard_codec_serializer.h.

Constructor & Destructor Documentation

~StandardCodecSerializer()

flutter::StandardCodecSerializer::~StandardCodecSerializer ( )

virtualdefault

StandardCodecSerializer() [1/2]

flutter::StandardCodecSerializer::StandardCodecSerializer ( StandardCodecSerializer const &  )

delete

StandardCodecSerializer() [2/2]

flutter::StandardCodecSerializer::StandardCodecSerializer ( )

protecteddefault

Member Function Documentation

GetInstance()

const StandardCodecSerializer & flutter::StandardCodecSerializer::GetInstance ( )

static

Definition at line 87 of file standard_codec.cc.

                                                                    {
  static StandardCodecSerializer sInstance;
  return sInstance;
};

Referenced by flutter::StandardMessageCodec::GetInstance(), and flutter::StandardMethodCodec::GetInstance().

operator=()

StandardCodecSerializer& flutter::StandardCodecSerializer::operator= ( StandardCodecSerializer const &  )

delete

ReadSize()

size_t flutter::StandardCodecSerializer::ReadSize ( ByteStreamReader *  stream ) const

protected

Definition at line 229 of file standard_codec.cc.

                                                                       {
  uint8_t byte = stream->ReadByte();
  if (byte < 254) {
    return byte;
  } else if (byte == 254) {
    uint16_t value = 0;
    stream->ReadBytes(reinterpret_cast<uint8_t*>(&value), 2);
    return value;
  } else {
    uint32_t value = 0;
    stream->ReadBytes(reinterpret_cast<uint8_t*>(&value), 4);
    return value;
  }
}

References flutter::ByteStreamReader::ReadByte(), and flutter::ByteStreamReader::ReadBytes().

Referenced by ReadValueOfType().

ReadValue()

EncodableValue flutter::StandardCodecSerializer::ReadValue

(

ByteStreamReader *

stream

)

const

Definition at line 92 of file standard_codec.cc.

                                    {
  uint8_t type = stream->ReadByte();
  return ReadValueOfType(type, stream);
}

References flutter::ByteStreamReader::ReadByte(), ReadValueOfType(), and type.

Referenced by flutter::StandardMethodCodec::DecodeAndProcessResponseEnvelopeInternal(), flutter::StandardMessageCodec::DecodeMessageInternal(), flutter::StandardMethodCodec::DecodeMethodCallInternal(), and ReadValueOfType().

ReadValueOfType()

EncodableValue flutter::StandardCodecSerializer::ReadValueOfType ( uint8_t  type, ByteStreamReader *  stream  ) const

protectedvirtual

Definition at line 168 of file standard_codec.cc.

                                    {
  switch (static_cast<EncodedType>(type)) {
    case EncodedType::kNull:
      return EncodableValue();
    case EncodedType::kTrue:
      return EncodableValue(true);
    case EncodedType::kFalse:
      return EncodableValue(false);
    case EncodedType::kInt32:
      return EncodableValue(stream->ReadInt32());
    case EncodedType::kInt64:
      return EncodableValue(stream->ReadInt64());
    case EncodedType::kFloat64:
      stream->ReadAlignment(8);
      return EncodableValue(stream->ReadDouble());
    case EncodedType::kLargeInt:
    case EncodedType::kString: {
      size_t size = ReadSize(stream);
      std::string string_value;
      string_value.resize(size);
      stream->ReadBytes(reinterpret_cast<uint8_t*>(&string_value[0]), size);
      return EncodableValue(string_value);
    }
    case EncodedType::kUInt8List:
      return ReadVector<uint8_t>(stream);
    case EncodedType::kInt32List:
      return ReadVector<int32_t>(stream);
    case EncodedType::kInt64List:
      return ReadVector<int64_t>(stream);
    case EncodedType::kFloat64List:
      return ReadVector<double>(stream);
    case EncodedType::kList: {
      size_t length = ReadSize(stream);
      EncodableList list_value;
      list_value.reserve(length);
      for (size_t i = 0; i < length; ++i) {
        list_value.push_back(ReadValue(stream));
      }
      return EncodableValue(list_value);
    }
    case EncodedType::kMap: {
      size_t length = ReadSize(stream);
      EncodableMap map_value;
      for (size_t i = 0; i < length; ++i) {
        EncodableValue key = ReadValue(stream);
        EncodableValue value = ReadValue(stream);
        map_value.emplace(std::move(key), std::move(value));
      }
      return EncodableValue(map_value);
    }
    case EncodedType::kFloat32List: {
      return ReadVector<float>(stream);
    }
  }
  std::cerr << "Unknown type in StandardCodecSerializer::ReadValueOfType: "
            << static_cast<int>(type) << std::endl;
  return EncodableValue();
}

References key, flutter::ByteStreamReader::ReadAlignment(), flutter::ByteStreamReader::ReadBytes(), flutter::ByteStreamReader::ReadDouble(), flutter::ByteStreamReader::ReadInt32(), flutter::ByteStreamReader::ReadInt64(), ReadSize(), ReadValue(), and type.

Referenced by ReadValue().

WriteSize()

void flutter::StandardCodecSerializer::WriteSize ( size_t  size, ByteStreamWriter *  stream  ) const

protected

Definition at line 244 of file standard_codec.cc.

                                                                        {
  if (size < 254) {
    stream->WriteByte(static_cast<uint8_t>(size));
  } else if (size <= 0xffff) {
    stream->WriteByte(254);
    uint16_t value = static_cast<uint16_t>(size);
    stream->WriteBytes(reinterpret_cast<uint8_t*>(&value), 2);
  } else {
    stream->WriteByte(255);
    uint32_t value = static_cast<uint32_t>(size);
    stream->WriteBytes(reinterpret_cast<uint8_t*>(&value), 4);
  }
}

References flutter::ByteStreamWriter::WriteByte(), and flutter::ByteStreamWriter::WriteBytes().

Referenced by WriteValue().

WriteValue()

void flutter::StandardCodecSerializer::WriteValue ( const EncodableValue &  value, ByteStreamWriter *  stream  ) const

virtual

Definition at line 98 of file standard_codec.cc.

                                                                         {
  stream->WriteByte(static_cast<uint8_t>(EncodedTypeForValue(value)));
  // TODO(cbracken): Consider replacing this with std::visit.
  switch (value.index()) {
    case 0:
    case 1:
      // Null and bool are encoded directly in the type.
      break;
    case 2:
      stream->WriteInt32(std::get<int32_t>(value));
      break;
    case 3:
      stream->WriteInt64(std::get<int64_t>(value));
      break;
    case 4:
      stream->WriteAlignment(8);
      stream->WriteDouble(std::get<double>(value));
      break;
    case 5: {
      const auto& string_value = std::get<std::string>(value);
      size_t size = string_value.size();
      WriteSize(size, stream);
      if (size > 0) {
        stream->WriteBytes(
            reinterpret_cast<const uint8_t*>(string_value.data()), size);
      }
      break;
    }
    case 6:
      WriteVector(std::get<std::vector<uint8_t>>(value), stream);
      break;
    case 7:
      WriteVector(std::get<std::vector<int32_t>>(value), stream);
      break;
    case 8:
      WriteVector(std::get<std::vector<int64_t>>(value), stream);
      break;
    case 9:
      WriteVector(std::get<std::vector<double>>(value), stream);
      break;
    case 10: {
      const auto& list = std::get<EncodableList>(value);
      WriteSize(list.size(), stream);
      for (const auto& item : list) {
        WriteValue(item, stream);
      }
      break;
    }
    case 11: {
      const auto& map = std::get<EncodableMap>(value);
      WriteSize(map.size(), stream);
      for (const auto& pair : map) {
        WriteValue(pair.first, stream);
        WriteValue(pair.second, stream);
      }
      break;
    }
    case 12:
      std::cerr
          << "Unhandled custom type in StandardCodecSerializer::WriteValue. "
          << "Custom types require codec extensions." << std::endl;
      break;
    case 13: {
      WriteVector(std::get<std::vector<float>>(value), stream);
      break;
    }
  }
}

References flutter::ByteStreamWriter::WriteAlignment(), flutter::ByteStreamWriter::WriteByte(), flutter::ByteStreamWriter::WriteBytes(), flutter::ByteStreamWriter::WriteDouble(), flutter::ByteStreamWriter::WriteInt32(), flutter::ByteStreamWriter::WriteInt64(), and WriteSize().

Referenced by flutter::StandardMethodCodec::EncodeErrorEnvelopeInternal(), flutter::StandardMessageCodec::EncodeMessageInternal(), flutter::StandardMethodCodec::EncodeMethodCallInternal(), and flutter::StandardMethodCodec::EncodeSuccessEnvelopeInternal().

---

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

• shell/platform/common/client_wrapper/include/flutter/standard_codec_serializer.h
• shell/platform/common/client_wrapper/standard_codec.cc