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);
}
