private void ReceiveNodeInitialState(PyDataType ar) { if (ar is PyObjectData == false) { throw new Exception($"Expected PyObjectData for machoNet.nodeInfo but got {ar.GetType()}"); } PyObjectData info = ar as PyObjectData; if (info.Name != "machoNet.nodeInfo") { throw new Exception($"Expected PyObjectData of type machoNet.nodeInfo but got {info.Name}"); } // Update our local info NodeInfo nodeinfo = info; this.Container.NodeID = nodeinfo.nodeID; Log.Debug("Found machoNet.nodeInfo, our new node id is " + nodeinfo.nodeID.ToString("X4")); // load the specified solar systems this.SystemManager.LoadSolarSystems(nodeinfo.solarSystems); // finally set the new packet handler this.Socket.SetReceiveCallback(ReceiveNormalPacketCallback); }
/// <summary> /// Processes the given <paramref name="data" /> python type and writes it's byte stream equivalent into. /// Every Python object converted must write the opcode in front as this is how it's identified on unmarshal /// <paramref name="writer" /> /// </summary> /// <param name="writer">The writer were to write the data to</param> /// <param name="data">The python object to convert</param> /// <exception cref="InvalidDataException">If an unknow python data type is detected</exception> private static void Process(BinaryWriter writer, PyDataType data) { if (data == null || data is PyNone) { ProcessNone(writer); } else if (data is PyInteger pyInteger) { ProcessInteger(writer, pyInteger); } else if (data is PyDecimal pyDecimal) { ProcessDecimal(writer, pyDecimal); } else if (data is PyToken pyToken) { ProcessToken(writer, pyToken); } else if (data is PyBool pyBool) { ProcessBool(writer, pyBool); } else if (data is PyBuffer pyBuffer) { ProcessBuffer(writer, pyBuffer); } else if (data is PyDictionary pyDictionary) { ProcessDictionary(writer, pyDictionary); } else if (data is PyList pyList) { ProcessList(writer, pyList); } else if (data is PyObjectData pyObjectData) { ProcessObjectData(writer, pyObjectData); } else if (data is PyObject pyObject) { ProcessObject(writer, pyObject); } else if (data is PyString pyString) { ProcessString(writer, pyString); } else if (data is PySubStream pySubStream) { ProcessSubStream(writer, pySubStream); } else if (data is PyChecksumedStream pyChecksumedStream) { ProcessChecksumedStream(writer, pyChecksumedStream); } else if (data is PySubStruct pySubStruct) { ProcessSubStruct(writer, pySubStruct); } else if (data is PyTuple pyTuple) { ProcessTuple(writer, pyTuple); } else if (data is PyPackedRow pyPackedRow) { ProcessPackedRow(writer, pyPackedRow); } else { throw new InvalidDataException($"Unexpected type {data.GetType()}"); } }
/// <summary> /// Processes the given <paramref name="data" /> python type and writes it's byte stream equivalent into. /// Every Python object converted must write the opcode in front as this is how it's identified on unmarshal /// <paramref name="writer" /> /// </summary> /// <param name="writer">The writer were to write the data to</param> /// <param name="data">The python object to convert</param> /// <exception cref="InvalidDataException">If an unknow python data type is detected</exception> private static void Process(BinaryWriter writer, PyDataType data) { switch (data) { case null: case PyNone _: ProcessNone(writer); break; case PyInteger pyInteger: ProcessInteger(writer, pyInteger); break; case PyDecimal pyDecimal: ProcessDecimal(writer, pyDecimal); break; case PyToken pyToken: ProcessToken(writer, pyToken); break; case PyBool pyBool: ProcessBool(writer, pyBool); break; case PyBuffer pyBuffer: ProcessBuffer(writer, pyBuffer); break; case PyDictionary pyDictionary: ProcessDictionary(writer, pyDictionary); break; case PyList pyList: ProcessList(writer, pyList); break; case PyObjectData pyObjectData: ProcessObjectData(writer, pyObjectData); break; case PyObject pyObject: ProcessObject(writer, pyObject); break; case PyString pyString: ProcessString(writer, pyString); break; case PySubStream pySubStream: ProcessSubStream(writer, pySubStream); break; case PyChecksumedStream pyChecksumedStream: ProcessChecksumedStream(writer, pyChecksumedStream); break; case PySubStruct pySubStruct: ProcessSubStruct(writer, pySubStruct); break; case PyTuple pyTuple: ProcessTuple(writer, pyTuple); break; case PyPackedRow pyPackedRow: ProcessPackedRow(writer, pyPackedRow); break; default: throw new InvalidDataException($"Unexpected type {data.GetType()}"); } }
/// <summary> /// <seealso cref="Marshal.ProcessDictionary"/> /// /// Opcodes supported: /// <seealso cref="Opcode.Dictionary"/> /// </summary> /// <param name="opcode">Type of object to parse</param> /// <returns>The decoded python type</returns> /// <exception cref="InvalidDataException">If any error was found in the data</exception> private PyDataType ProcessDictionary(Opcode opcode) { if (opcode != Opcode.Dictionary) { throw new InvalidDataException($"Trying to parse a {opcode} as Dictionary"); } PyDictionary dictionary = new PyDictionary(); uint size = this.mReader.ReadSizeEx(); while (size-- > 0) { PyDataType value = this.Process(false); PyDataType key = this.Process(false); if (key is PyString == false) { throw new InvalidDataException($"Expected String as Dictionary key, but gor {key.GetType()}"); } dictionary[key as PyString] = value; } return(dictionary); }