/// <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_); }