示例#1
0
        /// <summary>
        /// Updates any fields which have an ordinal index only to include a field name if one is available in the taxonomy. The
        /// same taxonomy is passed to any submessages.
        /// </summary>
        /// <param name="taxonomy">taxonomy to set field names from</param>
        public void SetNamesFromTaxonomy(IFudgeTaxonomy taxonomy)
        {
            if (taxonomy == null)
            {
                return;
            }
            for (int i = 0; i < fields.Count; i++)
            {
                FudgeMsgField field = fields[i];
                if ((field.Ordinal != null) && (field.Name == null))
                {
                    string nameFromTaxonomy = taxonomy.GetFieldName(field.Ordinal.Value);
                    if (nameFromTaxonomy == null)
                    {
                        continue;
                    }
                    FudgeMsgField replacementField = new FudgeMsgField(field.Type, field.Value, nameFromTaxonomy, field.Ordinal);
                    fields[i] = replacementField;
                }

                if (field.Value is FudgeMsg)
                {
                    FudgeMsg subMsg = (FudgeMsg)field.Value;
                    subMsg.SetNamesFromTaxonomy(taxonomy);
                }
            }
        }
示例#2
0
        /// <summary>
        /// Returns the Fudge encoded form of a <c>FudgeMsg</c> as a <c>byte</c> array without a taxonomy reference.
        /// </summary>
        /// <param name="msg">the <c>FudgeMsg</c> to encode</param>
        /// <returns>an array containing the encoded message</returns>
        public byte[] ToByteArray(FudgeMsg msg)
        {
            MemoryStream stream = new MemoryStream();

            Serialize(msg, stream);
            return(stream.ToArray());
        }
示例#3
0
 /// <summary>
 /// Creates a new <c>FudgeMsg</c> object as a copy of another.
 /// </summary>
 /// <param name="other">an existing <c>FudgeMsg</c> object to copy</param>
 public FudgeMsg(FudgeMsg other)
 {
     if (other == null)
     {
         throw new ArgumentNullException("Cannot initialize from a null other FudgeMsg");
     }
     this.context = other.context;
     InitializeFromByteArray(other.ToByteArray());
 }
 /// <summary>
 /// Creates a new <c>FudgeMsgEnvelope</c> around an existing <c>FudgeMsg</c> with a specific encoding schema version. The default
 /// schema version is 0.
 /// </summary>
 /// <param name="message">message contained within the envelope</param>
 /// <param name="version">schema version, 0 to 255</param>
 public FudgeMsgEnvelope(FudgeMsg message, int version)
 {
     if (message == null)
     {
         throw new ArgumentNullException("message", "Must specify a message to wrap.");
     }
     if ((version < 0) || (version > 255))
     {
         throw new ArgumentOutOfRangeException("version", "Provided version " + version + " which doesn't fit within one byte.");
     }
     this.message = message;
     this.version = version;
 }
示例#5
0
 /// <summary>
 /// Encodes a <c>FudgeMsg</c> object to a <c>Stream</c> with an optional taxonomy reference.
 /// If a taxonomy is supplied it may be used to optimize the output by writing ordinals instead
 /// of field names.
 /// </summary>
 /// <param name="msg">the <c>FudgeMessage</c> to write</param>
 /// <param name="taxonomyId">the identifier of the taxonomy to use. Specify <c>null</c> for no taxonomy</param>
 /// <param name="bw">The <see cref="BinaryWriter"/> to serialise to</param>
 public void Serialize(FudgeMsg msg, short?taxonomyId, BinaryWriter bw)
 {
     try
     {
         var writer = new FudgeEncodedStreamWriter(this);
         writer.TaxonomyId = taxonomyId;
         writer.Reset(bw);
         writer.StartMessage();
         writer.WriteFields(msg.GetAllFields());
         writer.EndMessage();
     }
     catch (IOException e)
     {
         throw new FudgeRuntimeException("Unable to write Fudge message to OutputStream", e);
     }
 }
        /// <summary>
        /// Parses data from a given <see cref="BinaryReader"/>.
        /// </summary>
        /// <param name="binaryReader"></param>
        /// <returns></returns>
        public FudgeMsgEnvelope Parse(BinaryReader binaryReader)
        {
            FudgeEncodedStreamReader reader = new FudgeEncodedStreamReader(FudgeContext);

            reader.Reset(binaryReader);
            FudgeStreamElement element = reader.MoveNext();

            if (element == FudgeStreamElement.NoElement)
            {
                return(null);
            }
            if (element != FudgeStreamElement.MessageStart)
            {
                throw new ArgumentException("First element in encoding stream wasn't a message element.");
            }
            int              version  = reader.SchemaVersion;
            FudgeMsg         msg      = FudgeContext.NewMessage();
            FudgeMsgEnvelope envelope = new FudgeMsgEnvelope(msg, version);

            ProcessFields(reader, msg);
            return(envelope);
        }
        /// <summary>
        /// Writes a line describing a field and its value. If the field is a submessage, that message is output at a deeper indentation level.
        /// </summary>
        /// <param name="field">field to output</param>
        /// <param name="index">physical index within containing message</param>
        /// <param name="depth">indentation level</param>
        /// <param name="fieldSpec">field description text (includes indent)</param>
        /// <param name="maxFieldSpecWidth">length of longest field description text (for layout)</param>
        /// <param name="maxTypeNameWidth">length of longest type name (for layout)</param>
        protected void Format(IFudgeField field, int index, int depth, string fieldSpec, int maxFieldSpecWidth, int maxTypeNameWidth)
        {
            if (field == null)
            {
                throw new ArgumentNullException("Cannot format a null field");
            }
            Writer.Write(fieldSpec);
            int nWritten     = fieldSpec.Length;
            int requiredSize = maxFieldSpecWidth + 1;

            for (int i = nWritten; i <= requiredSize; i++)
            {
                Writer.Write(' ');
                nWritten++;
            }
            string typeName = GetTypeName(field.Type);

            Writer.Write(typeName);
            nWritten    += typeName.Length;
            requiredSize = requiredSize + maxTypeNameWidth + 1;
            for (int i = nWritten; i <= requiredSize; i++)
            {
                Writer.Write(' ');
                nWritten++;
            }
            if (field.Value is FudgeMsg)
            {
                Writer.WriteLine();
                FudgeMsg msgValue = (FudgeMsg)field.Value;
                Format(msgValue, depth + 1);
            }
            else
            {
                Writer.Write(field.Value);
                Writer.WriteLine();
            }
            Writer.Flush();
        }
        /**
         * @param reader
         * @param msg
         */
        protected void ProcessFields(IFudgeStreamReader reader, FudgeMsg msg)
        {
            while (reader.HasNext)
            {
                FudgeStreamElement element = reader.MoveNext();
                switch (element)
                {
                case FudgeStreamElement.SimpleField:
                    msg.Add(reader.FieldName, reader.FieldOrdinal, reader.FieldType, reader.FieldValue);
                    break;

                case FudgeStreamElement.SubmessageFieldStart:
                    FudgeMsg subMsg = FudgeContext.NewMessage();
                    msg.Add(reader.FieldName, reader.FieldOrdinal, subMsg);
                    ProcessFields(reader, subMsg);
                    break;

                case FudgeStreamElement.SubmessageFieldEnd:
                case FudgeStreamElement.MessageEnd:
                    return;
                }
            }
        }
        // TODO 2009-12-14 Andrew -- lose the constructor above; we should at least pass the context and use that to construct the inner message

        /// <summary>
        /// Creates a new <c>FudgeMsgEnvelope</c> around an existing <c>FudgeMsg</c>.
        /// </summary>
        /// <param name="msg">message contained within the envelope</param>
        public FudgeMsgEnvelope(FudgeMsg msg)
            : this(msg, 0)
        {
        }
示例#10
0
 /// <summary>
 /// Encodes a <c>FudgeMsg</c> object to a <c>Stream</c> with an optional taxonomy reference.
 /// If a taxonomy is supplied it may be used to optimize the output by writing ordinals instead
 /// of field names.
 /// </summary>
 /// <param name="msg">the <c>FudgeMessage</c> to write</param>
 /// <param name="taxonomyId">the identifier of the taxonomy to use. Specify <c>null</c> for no taxonomy</param>
 /// <param name="s">the <c>Stream</c> to write to</param>
 public void Serialize(FudgeMsg msg, short?taxonomyId, Stream s)
 {
     Serialize(msg, taxonomyId, new FudgeBinaryWriter(s));
 }
示例#11
0
 /// <summary>
 /// Encodes a <c>FudgeMsg</c> object to a <see cref="BinaryWriter"/> without any taxonomy reference.
 /// </summary>
 /// <param name="msg">The message to serialise</param>
 /// <param name="bw">The <see cref="BinaryWriter"/> to serialise to</param>
 public void Serialize(FudgeMsg msg, BinaryWriter bw)
 {
     Serialize(msg, null, bw);
 }
示例#12
0
 /// <summary>
 /// Encodes a <c>FudgeMsg</c> object to a <c>Stream</c> without any taxonomy reference.
 /// </summary>
 /// <param name="msg">The message to serialise</param>
 /// <param name="s">The stream to serialise to</param>
 public void Serialize(FudgeMsg msg, Stream s)
 {
     Serialize(msg, null, s);
 }