/// <summary>
/// This method implements the ISupportSmppByteStream.AddToStream
/// method so that the PDU can serialize itself to the data stream.
/// </summary>
/// <param name="writer">StreamWriter</param>
public override void AddToStream(SmppWriter writer)
{
writer.Add(mid_);
writer.Add(msgState_);
writer.Add(areaId_);
writer.Add(successRate_);
}
/// <summary>
/// This method implements the ISupportSmppByteStream.AddToStream
/// method so that the PDU can serialize itself to the data stream.
/// </summary>
/// <param name="writer">StreamWriter</param>
public override void AddToStream(SmppWriter writer)
{
writer.Add(stype_);
writer.Add(msgid_);
writer.Add(saddr_);
writer.Add(daddr_);
}
/// <summary>
/// Parameterized constructor
/// </summary>
/// <param name="units">The units of frequency</param>
/// <param name="value">The frequency</param>
public broadcast_frequency_interval(BroadcastFrequencyUnits units, short value) : base(TlvTag)
{
SmppWriter writer = new SmppWriter(Data, true);
writer.Add((byte)units);
writer.Add(value);
}
/// <summary>
/// Parameterized constructor
/// </summary>
public callback_num_atag(DataEncoding dcod, string display) : base(TlvTag)
{
SmppWriter writer = new SmppWriter(Data, true);
writer.Add((byte)dcod);
writer.Add(display, false);
}
/// <summary>
/// This method implements the ISupportSmppByteStream.AddToStream
/// method so that the PDU can serialize itself to the data stream.
/// </summary>
/// <param name="writer">StreamWriter</param>
public override void AddToStream(SmppWriter writer)
{
writer.Add(mid_);
writer.Add(finalDate_);
writer.Add(msgState_);
writer.Add(errCode_);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="snum">Session number</param>
/// <param name="eos">End of session indicator</param>
public its_session_info(byte snum, bool eos) : base(TlvTag)
{
SmppWriter writer = new SmppWriter(Data, true);
writer.Add(snum);
writer.Add((eos == true) ? (byte)1 : (byte)0);
}
/// <summary>
/// This method implements the ISupportSmppByteStream.AddToStream
/// method so that the PDU can serialize itself to the data stream.
/// </summary>
/// <param name="writer">StreamWriter</param>
public override void AddToStream(SmppWriter writer)
{
writer.Add((byte)distList_.Count);
foreach (string str in distList_)
{
writer.Add(new SmppCOctetString(str));
}
}
/// <summary>
/// This method implements the ISupportSmppByteStream.AddToStream
/// method so that the PDU can serialize itself to the data stream.
/// </summary>
/// <param name="writer">StreamWriter</param>
public override void AddToStream(SmppWriter writer)
{
writer.Add((byte)distList_.Count);
foreach (dl_member_details dtls in distList_)
{
writer.Add(dtls);
}
}
/// <summary>
/// This method inserts the Tlv into a byte stream object.
/// </summary>
/// <param name="stm">Byte stream</param>
public override void AddToStream(SmppWriter stm)
{
if (HasValue)
{
stm.Add(Tag);
stm.Add((short)0);
}
}
/// <summary>
/// Parameterized constructor
/// </summary>
/// <param name="netType">Type of network</param>
/// <param name="content">Content type</param>
public broadcast_content_type(TypeOfNetwork netType, ContentType content)
: base(TlvTag)
{
SmppWriter writer = new SmppWriter(Data, true);
writer.Add((byte)netType);
writer.Add((short)content);
}
/// <summary>
/// This method implements the ISupportSmppByteStream.AddToStream
/// method so that the PDU can serialize itself to the data stream.
/// </summary>
/// <param name="writer">StreamWriter</param>
public override void AddToStream(SmppWriter writer)
{
writer.Add(sid_);
writer.Add(pwd_);
writer.Add(stype_);
writer.Add(ifver_);
writer.Add(addr_range_);
}
/// <summary>
/// This method adds our information to the byte stream.
/// </summary>
/// <param name="writer"></param>
public void AddToStream(SmppWriter writer)
{
if (elem_ != null)
{
flag_.AddToStream(writer);
ISupportSmppByteStream isb = (ISupportSmppByteStream)elem_;
isb.AddToStream(writer);
}
}
/// <summary>
/// Parameterized constructor
/// </summary>
public callback_num(DigitMode digitMode, TypeOfNumber typeOfNumber, NumericPlanIndicator numberPlan, string digits) : base(TlvTag)
{
SmppWriter writer = new SmppWriter(Data, true);
writer.Add((byte)digitMode);
writer.Add((byte)typeOfNumber);
writer.Add((byte)numberPlan);
writer.Add(digits, false);
}
/// <summary>
/// This method implements the ISupportSmppByteStream.AddToStream
/// method so that the PDU can serialize itself to the data stream.
/// </summary>
/// <param name="writer">StreamWriter</param>
public override void AddToStream(SmppWriter writer)
{
writer.Add(stype_);
writer.Add(saddr_);
writer.Add(daddr_);
writer.Add(esmclass_);
writer.Add(regDelivery_);
writer.Add(dataCoding_);
}
/// <summary>
/// This method adds our information to the byte stream.
/// </summary>
/// <param name="writer"></param>
public void AddToStream(SmppWriter writer)
{
writer.Add((byte)this.Count);
for (int i = 0; i < this.Count; ++i)
{
multi_address addr = this[i];
addr.AddToStream(writer);
}
}
/// <summary>
/// This method adds our information to the byte stream.
/// </summary>
/// <param name="writer"></param>
public void AddToStream(SmppWriter writer)
{
writer.Add((byte)this.Count);
for (int i = 0; i < this.Count; ++i)
{
unsuccess_sme addr = this[i];
addr.AddToStream(writer);
}
}
public Task SerializeAsync(object obj, SmppWriter writer, SmppSerializationSettings serializationSettings, CancellationToken cancellationToken)
{
if (obj == null)
{
throw new ArgumentNullException(nameof(obj), "Cannot determine the type from a null object");
}
return(SerializeAsync(obj.GetType(), obj, writer, serializationSettings, cancellationToken));
}
/// <summary>
/// This method adds the PDU to the given byte stream.
/// </summary>
/// <param name="stm"></param>
public void Serialize(SmppWriter stm)
{
bool includeBody = (this.Status == StatusCodes.ESME_ROK);
int length = REQUIRED_SIZE;
byte version = stm.Version;
SmppByteStream body = null, optBody = null;
// Get the optional (Tlv) parameters
if (includeBody == true)
{
// Serialize the body into a stream.
body = new SmppByteStream();
new SmppWriter(body, version).Add(this);
length += (int)body.Length;
// If we are using at least V3.4 of the SMPP spec
// then include Tlvs, otherwise we do not.
if (version >= SmppVersion.SMPP_V34)
{
int size = optionalParameters_.Count;
if (size > 0)
{
optBody = new SmppByteStream();
SmppWriter writer = new SmppWriter(optBody, version);
for (int i = 0; i < size; i++)
{
TlvParameter tlv = (TlvParameter)optionalParameters_[i];
if (tlv != null && tlv.HasValue)
{
writer.Add(tlv);
}
}
// Add the length of all optional parameters
length += (int)optBody.Length;
}
}
}
// Now serialize the whole thing together.
stm.Add(length);
stm.Add(CommandId);
stm.Add(status_);
stm.Add(sequenceNumber_);
if (includeBody == true)
{
if (body != null && body.Length > 0)
{
stm.Add(body);
}
if (optBody != null && optBody.Length > 0)
{
stm.Add(optBody);
}
}
}
/// <inheritdoc />
Task ISmppSerializer.SerializeAsync(object obj, SmppWriter writer, SmppSerializationSettings serializationSettings, CancellationToken cancellationToken)
{
if (obj is T)
{
return(SerializeAsync((T)obj, writer, serializationSettings, cancellationToken));
}
throw new ArgumentException($"The value of the object is not of type {typeof(T)}");
}
/// <summary>
/// This method implements the ISupportSmppByteStream.AddToStream
/// method so that the PDU can serialize itself to the data stream.
/// </summary>
/// <param name="writer">StreamWriter</param>
public override void AddToStream(SmppWriter writer)
{
writer.Add(msgid_);
writer.Add(stype_);
writer.Add(saddr_);
writer.Add(deliveryTime_);
writer.Add(validPeriod_);
writer.Add(regDelivery_);
writer.Add(defMsgId_);
writer.Add(msg_);
}
/// <summary>
/// Parameterized constructor
/// </summary>
/// <param name="formatType">The broadcast format type</param>
/// <param name="text">The specific area details based on the type</param>
public broadcast_area_identifier(BroadcastArea formatType, string text)
: base(TlvTag)
{
SmppWriter writer = new SmppWriter(Data, true);
writer.Add((byte)formatType);
if (text.Length > (MAX_LENGTH - 1))
{
text = text.Substring(0, MAX_LENGTH - 1);
}
writer.Add(text, false);
}
/// <summary> Serialize SubmitSm object to the byte array. </summary>
///
/// <param name="client"> The client. </param>
/// <param name="pdu"> The SubmitSm object. </param>
///
/// <returns> A byte array. </returns>
public byte[] Serialize(SmppClient client, SubmitSm pdu)
{
using (MemoryStream stream = new MemoryStream())
{
using (SmppWriter writer = new SmppWriter(stream, client.EncodingMapper))
{
writer.WritePDU(pdu);
return(stream.ToArray());
}
}
}
/// <summary>
/// This method adds our information to the byte stream.
/// </summary>
/// <param name="writer"></param>
public void AddToStream(SmppWriter writer)
{
writer.Add(customerId_);
writer.Add(name_);
writer.Add(address_);
writer.Add(sourceAddress_);
writer.Add(svcLevel_);
writer.Add(barStatus_);
writer.Add(ocos_);
writer.Add(tcos_);
writer.Add(password_);
}
public static TPdu Clone <TPdu>(this TPdu pdu) where TPdu : SmppPDU
{
using (MemoryStream stream = new MemoryStream())
{
SmppWriter writer = new SmppWriter(stream);
writer.WritePDU(pdu);
stream.Position = 0;
SmppStreamReader reader = new SmppStreamReader(stream);
return((TPdu)reader.ReadPDU());
}
}
/// <summary>
/// This is used for diagnostics - it places the PDU into binary
/// byte array form.
/// </summary>
/// <returns>Byte array</returns>
public string ToString(string fmt)
{
if (fmt.ToLower() == "b")
{
SmppByteStream stm = new SmppByteStream();
SmppWriter writer = new SmppWriter(stm);
this.Serialize(writer);
return(stm.ToString());
}
else
{
return(this.ToString());
}
}
/// <summary>
/// This method implements the ISupportSmppByteStream.AddToStream
/// method so that the PDU can serialize itself to the data stream.
/// </summary>
/// <param name="writer">StreamWriter</param>
public override void AddToStream(SmppWriter writer)
{
writer.Add(sourceAddr_);
writer.Add(dlname_);
writer.Add(new SmppByte((byte)type_));
if (type_ == DistributionListModifyType.AddMember)
{
writer.Add(memberDetails_);
}
else
{
writer.Add(memberDetails_.Description);
}
}
/// <summary>
/// This method implements the ISupportSmppByteStream.AddToStream
/// method so that the PDU can serialize itself to the data stream.
/// </summary>
/// <param name="writer">StreamWriter</param>
public override void AddToStream(SmppWriter writer)
{
writer.Add(stype_);
writer.Add(saddr_);
writer.Add(mid_);
writer.Add(pflag_);
writer.Add(deliveryTime_);
writer.Add(validPeriod_);
writer.Add(repPresent_);
writer.Add(dataCoding_);
writer.Add(defMsgId_);
writer.Add(areaId_);
writer.Add(contentType_);
writer.Add(repNum_);
writer.Add(freqInt_);
}
/// <summary>
/// This method implements the ISupportSmppByteStream.AddToStream
/// method so that the PDU can serialize itself to the data stream.
/// </summary>
/// <param name="writer">StreamWriter</param>
public override void AddToStream(SmppWriter writer)
{
writer.Add(stype_);
writer.Add(saddr_);
writer.Add(daddr_);
writer.Add(esmclass_);
writer.Add(protid_);
writer.Add(pflag_);
writer.Add(deliveryTime_);
writer.Add(validPeriod_);
writer.Add(regDelivery_);
writer.Add(repPresent_);
writer.Add(dataCoding_);
writer.Add(defMsgId_);
writer.Add(msg_);
}
public Task SerializeAsync(Type type, object obj, SmppWriter writer, SmppSerializationSettings serializationSettings,
CancellationToken cancellationToken)
{
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
if (serializationSettings == null)
{
throw new ArgumentNullException(nameof(serializationSettings));
}
if (!type.IsInstanceOfType(obj))
{
throw new ArgumentException($"The provided object is not of type {type} and cannot be serialized");
}
if (serializationSettings.SerializerResolver == null)
{
throw new InvalidOperationException($"Cannot resolve the serializer for type {type}: the resolver is not set");
}
var serializer = serializationSettings.SerializerResolver.ResolveForType(type);
// TODO: if serializer not found, try to construct it from the type ...
if (serializer == null)
{
throw new InvalidOperationException($"No serializer was resolved for the type {type} from the available ones");
}
if (!serializer.CanSerialize(obj))
{
throw new InvalidOperationException($"The serializer for the type {type} cannot serialize the value provided");
}
return(serializer.SerializeAsync(obj, writer, serializationSettings, cancellationToken));
}
/// <summary>
/// This method adds our information to the byte stream.
/// </summary>
/// <param name="writer"></param>
public void AddToStream(SmppWriter writer)
{
addr_.AddToStream(writer);
writer.Add(status_);
}
