Utilization of PIDL

namespace Proud
{
    enum UnitType
    {
        Zergling,     // StarCraft's juggling (ground type normal attack unit)
        Queen,        // Queen of Starcraft (Flying Special Technology Use Unit)
        Broodling    // A short-lived attack unit created by Queen using her brudling skills
    };
 
    struct Unit
    {
        UnitType m_type;          // Unit's type
        Vector2D m_position;    // Unit;s location
        int m_energy;            // Unit's energy (or mana) reserves -> Queen only
        float m_lifeTime;        // Unit's survival time limit -> Bridling only
        int m_attackPower;        // Unit's attack power->Juggling only
    };
 
    CMessage& operator<<(CMessage& msg,const Unit& unit)
    {
        msg<<unit.m_type<<unit.m_position;
        switch(unit.m_type)
        {
        case Zergling:
            msg<<unit.m_attackPower;
            break;
        case Queen:
            msg<<unit.m_energy;
            break;
        case Broodling:
            msg<<unit.m_lifeTime;
            break;
        }
        return msg;
    }
 
    CMessage& operator>>(CMessage& msg,Unit& unit)
    {
        msg>>unit.m_type>>unit.m_position;
        switch(unit.m_type)
        {
        case Zergling:
            msg>>unit.m_attackPower;
            break;
        case Queen:
            msg>>unit.m_energy;
            break;
        case Broodling:
            msg>>unit.m_lifeTime;
            break;
        }
        return msg;
    }
}

namespace Proud
{
    struct MyType
    {
        int x,y,z;
    };
    CMessage& operator>>(CMessage &a, MyType &b)
    {
        // Use 6 bits to read the x value
        a.ReadBits(b.x,6);
        // Use 3 bits to read the y value
        a.ReadBits(b.y,3);
        // Use 15 bits to read the z value, i.e. sum 6+3+15=24 bits (3 bytes)
        a.ReadBits(b.z,15);
        return a;
    }
    CMessage& operator<<(CMessage &a, const MyType &b)
    {
        a.WriteBits(b.x,6); // Store x,y,z values in bits.
        a.WriteBits(b.y,3);
        a.WriteBits(b.z,15);
        return a;
    }
}

namespace Proud
{
    // Serialisation functions available in vector
    // for output to stream
    template<typename elem>
    inline CMessage& operator>>(CMessage &a, std::vector<elem> &b)
    {
        // Get the size.
        int size;
        a >> size;
 
        // Raise an exception if the size is unacceptable.
        // You may suspect that it has been hacked.
        if (size<0 ||size >= CNetConfig::MessageMaxLength)
            ThrowExceptionOnReadArray(size);
 
        // To reduce memory fragments
        b.reserve(size);
        b.resize(0);
 
        // Reads the array items one by one.
        elem e;
        for (int i = 0;i < size;i++)
        {
            a >> e;
            b.push_back(e);
        }
        return a;
    }
 
    // Serialisation functions available 
    // for unary item elem such as vector, list, etc.
    // for input from stream
    template<typename elem>
    inline CMessage& operator<<(CMessage &a, const std::vector<elem> &b)
    {
        // Record the size of the array.
        int size = (int)b.size();
        a << size;
        
        // Record each array argument.
        for (std::vector<elem>::const_iterator i = b.begin();i != b.end();i++)
        {
            a << (*i);
        }
        return a;
    }
 
    template<typename elem>
    inline void AppendTextOut(String &a, std::vector<elem> &b)
    {
        a += L"<vector>";
    }
}