예제 #1
0
        public int TightMarshalNestedObject1(DataStructure o, BooleanStream bs)
        {
            bs.WriteBoolean(o != null);
            if (o == null)
            {
                return(0);
            }

            if (o.IsMarshallAware())
            {
                MarshallAware ma       = (MarshallAware)o;
                byte[]        sequence = ma.GetMarshalledForm(this);
                bs.WriteBoolean(sequence != null);
                if (sequence != null)
                {
                    return(1 + sequence.Length);
                }
            }

            byte type = o.GetDataStructureType();

            if (type == 0)
            {
                throw new IOException("No valid data structure type for: " + o + " of type: " + o.GetType());
            }
            BaseDataStreamMarshaller dsm = (BaseDataStreamMarshaller)dataMarshallers[type & 0xFF];

            if (dsm == null)
            {
                throw new IOException("Unknown data type: " + type);
            }
            //Console.WriteLine("Marshalling type: " + type + " with structure: " + o);
            return(1 + dsm.TightMarshal1(this, o, bs));
        }
예제 #2
0
        public void Marshal(Object o, BinaryWriter ds)
        {
            int size = 1;

            if (o != null)
            {
                DataStructure            c    = (DataStructure)o;
                byte                     type = c.GetDataStructureType();
                BaseDataStreamMarshaller dsm  = dataMarshallers[type & 0xFF];
                if (dsm == null)
                {
                    throw new IOException("Unknown data type: " + type);
                }

                if (tightEncodingEnabled)
                {
                    BooleanStream bs = new BooleanStream();
                    size += dsm.TightMarshal1(this, c, bs);
                    size += bs.MarshalledSize();

                    if (!sizePrefixDisabled)
                    {
                        ds.Write(size);
                    }

                    ds.Write(type);
                    bs.Marshal(ds);
                    dsm.TightMarshal2(this, c, ds, bs);
                }
                else
                {
                    BinaryWriter looseOut = ds;
                    MemoryStream ms       = null;
                    // If we are prefixing then we need to first write it to memory,
                    // otherwise we can write direct to the stream.
                    if (!sizePrefixDisabled)
                    {
                        ms       = new MemoryStream();
                        looseOut = new OpenWireBinaryWriter(ms);
                        looseOut.Write(size);
                    }

                    looseOut.Write(type);
                    dsm.LooseMarshal(this, c, looseOut);

                    if (!sizePrefixDisabled)
                    {
                        ms.Position = 0;
                        looseOut.Write((int)ms.Length - 4);
                        ds.Write(ms.GetBuffer(), 0, (int)ms.Length);
                    }
                }
            }
            else
            {
                ds.Write(size);
                ds.Write(NULL_TYPE);
            }
        }