// part 1: read from the chunk stream, returning true if enough data is here. you must take the value
// returned at `chunkStreamId`, find the chunk stream snapshot associated with that chunk stream and
// pass it to the second stage (part2) along with the opaque value.
public static bool ReadFrom1(AmfReader reader, out int chunkStreamId, out MessageHeader.Type opaque)
{
if (BasicHeader.ReadFrom(reader, out var format, out var streamId))
{
opaque = (MessageHeader.Type)format;
chunkStreamId = streamId;
return(true);
}
public ReceiveMessageQueueItem(Action <BasicHeader, object, Type> payloadReceived, BasicHeader header,
object payload, Type type)
{
PayloadReceived = payloadReceived;
Header = header;
Payload = payload;
Type = type;
}
public static void WriteTo(AmfWriter writer, Snapshot previous, Snapshot next, int chunkLength, Space <byte> message)
{
Kon.Assert(
!previous.Ready || previous.ChunkStreamId == next.ChunkStreamId,
"previous and next describe two different chunk streams");
Kon.Assert(
next.MessageLength == message.Length,
"mismatch between reported message length and actual message length");
// we don't write zero-length packets, and as state for `next` and `previous` won't match what our peer
// sees if we pass a zero-length message here. zero-length sends should be filtered out at a higher level.
Kon.Assert(
next.MessageLength != 0,
"message length cannot be zero");
var header = GetInitialHeaderType();
for (var i = 0; i < next.MessageLength; i += chunkLength)
{
if (i == 0)
{
BasicHeader.WriteTo(writer, (byte)header, next.ChunkStreamId);
MessageHeader.WriteTo(writer, header, next);
}
else
{
BasicHeader.WriteTo(writer, (byte)MessageHeader.Type.Type3, next.ChunkStreamId);
}
var count = Math.Min(chunkLength, next.MessageLength - i);
var slice = message.Slice(i, count);
writer.WriteBytes(slice);
}
MessageHeader.Type GetInitialHeaderType()
{
if (!previous.Ready || next.MessageStreamId != previous.MessageStreamId)
{
return(MessageHeader.Type.Type0);
}
if (next.MessageLength != previous.MessageLength || next.ContentType != previous.ContentType)
{
return(MessageHeader.Type.Type1);
}
if (next.Timestamp != previous.Timestamp)
{
return(MessageHeader.Type.Type2);
}
return(MessageHeader.Type.Type3);
}
}
/// <summary>Specifies the Content-Encoding header, as a string.</summary>
/// <remarks>
/// Specifies the Content-Encoding header, as a string.
/// The default implementation calls
/// <see cref="SetContentEncoding(Org.Apache.Http.Header)">setContentEncoding(Header)
/// </see>
/// .
/// </remarks>
/// <param name="ceString">
/// the new Content-Encoding header, or
/// <code>null</code> to unset
/// </param>
public virtual void SetContentEncoding(string ceString)
{
Header h = null;
if (ceString != null)
{
h = new BasicHeader(HTTP.ContentEncoding, ceString);
}
SetContentEncoding(h);
}
/// <summary>Specifies the Content-Type header, as a string.</summary>
/// <remarks>
/// Specifies the Content-Type header, as a string.
/// The default implementation calls
/// <see cref="SetContentType(Org.Apache.Http.Header)">setContentType(Header)</see>
/// .
/// </remarks>
/// <param name="ctString">
/// the new Content-Type header, or
/// <code>null</code> to unset
/// </param>
public virtual void SetContentType(string ctString)
{
Header h = null;
if (ctString != null)
{
h = new BasicHeader(HTTP.ContentType, ctString);
}
SetContentType(h);
}
public void PrepareRaw(RawDataPacket rawDataContainer)
{
if (rawDataContainer == null)
{
throw new ArgumentNullException(nameof(rawDataContainer));
}
_headerIsSent = false;
_header = rawDataContainer.Header;
_message = rawDataContainer.Payload ??
throw new InvalidDataException("Invalid raw data (needs to be a Stream)");
}
public void FindBranchCode()
{
string str;
using (StreamReader sr = File.OpenText(samplemessagelocation))
{
str = sr.ReadToEnd();
}
MTParser message = new MTParser();
Dictionary <string, string> swiftBlocks = message.SeperateSWIFTFile(str.Trim());
BasicHeader Sender = new BasicHeader(swiftBlocks);
Assert.AreEqual("JPX", Sender.BranchCode);
}
internal Message(
BasicHeader basicHeader,
ApplicationHeader applicationHeader,
UserHeader userHeader,
TextBlock text,
Trailer trailer)
{
if (basicHeader == null)
{
throw new ParserException("The Basic Header Block is mandatory.");
}
this.BasicHeader = basicHeader;
this.ApplicationHeader = applicationHeader;
this.UserHeader = userHeader;
this.Text = text;
this.Trailer = trailer;
}
internal Message(
BasicHeader basicHeader,
ApplicationHeader applicationHeader,
UserHeader userHeader,
TextBlock text,
Trailer trailer)
{
if (basicHeader == null)
{
throw new ParserException("The Basic Header Block is mandatory.");
}
this.BasicHeader = basicHeader;
this.ApplicationHeader = applicationHeader;
this.UserHeader = userHeader;
this.Text = text;
this.Trailer = trailer;
}
public void Prepare(BasicHeader header, object payload)
{
_header = header;
_message = payload;
_headerIsSent = _headerCreated = false;
}
