Some more fields.

Author: nicolasnoble

src/core/gadp-server.cc

@@ -124,6 +124,54 @@ enum class TargetEventType {
     TET_SIGNAL = 11,
 };
 
+namespace PCSX {
+
+namespace {
+
+typedef Protobuf::Message<TYPESTRING("ErrorRequest")> ErrorRequest;
+
+typedef Protobuf::Field<Protobuf::Int32, TYPESTRING("code"), 1> ErrorReplyCode;
+typedef Protobuf::Field<Protobuf::String, TYPESTRING("message"), 2> ErrorReplyMessage;
+typedef Protobuf::Message<TYPESTRING("ErrorReply"), ErrorReplyCode, ErrorReplyMessage> ErrorReply;
+
+typedef Protobuf::RepeatedFieldVariable<Protobuf::String, TYPESTRING("version"), 1> ConnectRequestVersion;
+typedef Protobuf::Message<TYPESTRING("ConnectRequest"), ConnectRequestVersion> ConnectRequest;
+
+typedef Protobuf::Field<Protobuf::String, TYPESTRING("version"), 1> ConnectReplyVersion;
+typedef Protobuf::Field<Protobuf::String, TYPESTRING("schema_context"), 2> ConnectReplySchemaContext;
+typedef Protobuf::Field<Protobuf::String, TYPESTRING("root_schema"), 3> ConnectReplyRootSchema;
+typedef Protobuf::Message<TYPESTRING("ConnectReply"), ConnectReplyVersion, ConnectReplySchemaContext,
+                          ConnectReplyRootSchema>
+    ConnectReply;
+
+typedef Protobuf::Field<Protobuf::String, TYPESTRING("content"), 1> PingContent;
+typedef Protobuf::Message<TYPESTRING("PingRequest"), PingContent> PingRequest;
+typedef Protobuf::Message<TYPESTRING("PingReply"), PingContent> PingReply;
+
+typedef Protobuf::Field<Protobuf::String, TYPESTRING("space"), 1> AddressSpace;
+typedef Protobuf::Field<Protobuf::UInt64, TYPESTRING("offset"), 2> AddressOffset;
+typedef Protobuf::Field<Protobuf::UInt32, TYPESTRING("extend"), 3> AddressExtend;
+typedef Protobuf::Message<TYPESTRING("Address"), AddressSpace, AddressOffset> Address;
+typedef Protobuf::Message<TYPESTRING("AddressRange"), AddressSpace, AddressOffset, AddressExtend> AddressRange;
+
+typedef Protobuf::RepeatedFieldVariable<Protobuf::String, TYPESTRING("e"), 1> PathElement;
+typedef Protobuf::Message<TYPESTRING("Path"), PathElement> Path;
+typedef Protobuf::RepeatedFieldVariable<Path, TYPESTRING("path"), 1> PathListPath;
+typedef Protobuf::Message<TYPESTRING("path"), PathListPath> PathList;
+
+typedef Protobuf::RepeatedFieldVariable<Protobuf::Int32, TYPESTRING("k"), 1> KindSet;
+typedef Protobuf::Message<TYPESTRING("BreakKindSet"), KindSet> BreakKindSet;
+typedef Protobuf::Message<TYPESTRING("StepKindsSet"), KindSet> StepKindsSet;
+
+typedef Protobuf::RepeatedFieldVariable<Protobuf::String, TYPESTRING("s"), 1> StringListField;
+typedef Protobuf::Message<TYPESTRING("StringList"), StringListField> StringList;
+
+typedef Protobuf::Message<TYPESTRING("AttachKindSet"), KindSet> AttachKindSet;
+
+}  // namespace
+
+}  // namespace PCSX
+
 PCSX::GadpServer::GadpServer() : m_listener(g_system->m_eventBus) {
     m_listener.listen<Events::SettingsLoaded>([this](const auto& event) {
         if (g_emulator->settings.get<Emulator::SettingGadpServer>()) {

src/support/protobuf.h

@@ -549,6 +549,71 @@ struct RepeatedField<FieldType, amount, irqus::typestring<C...>, fieldNumberValu
     }
 };
 
+template <typename FieldType, typename name, uint64_t fieldNumberValue>
+struct RepeatedFieldVariable;
+template <typename FieldType, char... C, uint64_t fieldNumberValue>
+struct RepeatedFieldVariable<FieldType, irqus::typestring<C...>, fieldNumberValue> {
+    RepeatedFieldVariable() { reset(); }
+    static constexpr uint64_t fieldNumber = fieldNumberValue;
+    static constexpr unsigned wireType = 2;
+    typedef irqus::typestring<C...> fieldName;
+    static constexpr void dumpSchema(std::ostream &stream) {
+        stream << "    repeated " << FieldType::typeName << " " << fieldName::data() << " = " << fieldNumberValue << ";"
+               << std::endl;
+    }
+    std::vector<FieldType> value;
+    size_t count = 0;
+    constexpr void reset() {
+        value.clear();
+        count = 0;
+    }
+    static constexpr bool matches(unsigned wireType) { return wireType == 2 || FieldType::matches(wireType); }
+    static constexpr bool needsToSerializeHeader() { return FieldType::wireType == 2; }
+    void serialize(OutSlice *slice) const {
+        if (FieldType::wireType == 2) {
+            for (const auto &v : value) {
+                OutSlice subSlice;
+                v.serialize(&subSlice);
+                std::string subSliceData = subSlice.finalize();
+                slice->putVarInt((fieldNumber << 3) | FieldType::wireType);
+                slice->putVarInt(subSliceData.size());
+                slice->putBytes(subSliceData);
+            }
+        } else {
+            OutSlice subSlice;
+            for (const auto &v : value) {
+                v.serialize(&subSlice);
+            }
+            std::string subSliceData = subSlice.finalize();
+            slice->putVarInt(subSliceData.size());
+            slice->putBytes(subSliceData);
+        }
+    }
+    void deserialize(InSlice *slice, unsigned wireType) {
+        if (FieldType::wireType != wireType) {
+            InSlice subSlice = slice->getSubSlice(slice->getVarInt());
+            while (subSlice.bytesLeft()) {
+                deserializeOne(&subSlice, wireType);
+            }
+        } else {
+            deserializeOne(slice, wireType);
+        }
+    }
+    constexpr bool hasData() const { return !value.empty(); }
+    constexpr void commit() {}
+
+  private:
+    void deserializeOne(InSlice *slice, unsigned wireType) {
+        value.resize(count + 1);
+        if (FieldType::wireType == 2) {
+            InSlice subSlice = slice->getSubSlice(slice->getVarInt());
+            value[count++].deserialize(&subSlice, FieldType::wireType);
+        } else {
+            value[count++].deserialize(slice, wireType);
+        }
+    }
+};
+
 template <typename FieldType, size_t amount, typename name, uint64_t fieldNumberValue>
 struct RepeatedFieldRef;
 template <typename FieldType, size_t amount, char... C, uint64_t fieldNumberValue>