// create product or sum depending on enum provided
// modulo the input until all digits retrieved and used as a sum or product onto the resultant itself (don't need linked list if just going to use resultant itself)
// return the sum or product
public int CreateSumOrProduct(int n, TypeOfNumber m)
{
int result;
switch (m)
{
case TypeOfNumber.Sum:
result = 0; // for some reason, variable can be initialized here and still in scope for the next case; but would be best practice to declare outside switch
while (n != 0)
{
result += n % 10;
n /= 10;
}
return(result);
case TypeOfNumber.Product:
result = 1;
while (n != 0)
{
result *= n % 10;
n /= 10;
}
return(result);
default:
return(0);
}
}
public static List <Result> GetResults(int[] arr)
{
int count = 1, sum = 0;
TypeOfNumber typeOfNumber = GetTypeOfNumber(arr[0]);
sum = sum + arr[0];
List <Result> result = new List <Result>();
int i = 1;
while (i < arr.Length)
{
if (typeOfNumber == GetTypeOfNumber(arr[i]))
{
count++;
sum = sum + arr[i];
typeOfNumber = GetTypeOfNumber(arr[i]);
}
else
{
result.Add(new Result(count, sum, typeOfNumber));
count = 1;
sum = 0;
sum = sum + arr[i];
typeOfNumber = GetTypeOfNumber(arr[i]);
}
i++;
}
result.Add(new Result(count, sum, typeOfNumber));
return(result);
}
/// <summary>
/// Address constructor
/// </summary>
/// <param name="ton">Type Of Number</param>
/// <param name="npi">Numeric plan</param>
/// <param name="addr">Address</param>
public address_range(TypeOfNumber ton, NumericPlanIndicator npi, string addr)
{
ton_.Value = ton;
npi_.Value = npi;
addr_.Value = addr;
ValidateData();
}
protected override void Parse(ByteBuffer buffer)
{
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
const int minBytes = 7;
if (buffer.Length < minBytes)
{
throw new NotEnoughBytesException("BindRequest requires at least 7 bytes for body parameters");
}
try
{
vSystemID = DecodeCString(buffer);
vPassword = DecodeCString(buffer);
vSystemType = DecodeCString(buffer);
vInterfaceVersion = GetByte(buffer);
vAddressTon = (TypeOfNumber)GetByte(buffer);
vAddressNpi = (NumberingPlanIndicator)GetByte(buffer);
vAddressRange = DecodeCString(buffer);
}
catch (InvalidOperationException ex)
{
//ByteBuffer.Remove() throws InvalidOperationException exception if called on a empty ByteBuffer instance
//Wrap this exception as a NotEnoughBytesException exception
throw new NotEnoughBytesException(ex.Message, ex);
}
if (buffer.Length > 0) //If there are some bytes left
{
throw new TooManyBytesException();
}
}
public Submit(
uint sequenceNumber,
string serviceType,
TypeOfNumber sourceTon,
NumericPlanIndicator sourceNpi,
string sourceAddress,
TypeOfNumber destTon,
NumericPlanIndicator destNpi,
string destAddress,
int esmClass,
int protocolId,
int priorityFlag,
string shortMessage)
: base(sequenceNumber)
{
ServiceType = serviceType;
SourceTon = sourceTon;
SourceNpi = sourceNpi;
SourceAddress = sourceAddress;
DestTon = destTon;
DestNpi = destNpi;
DestAddress = destAddress;
EsmClass = esmClass;
ProtocolId = protocolId;
PriorityFlag = priorityFlag;
ShortMessage = shortMessage;
}
public Address(
TypeOfNumber ton,
NumericPlanIndicator npi,
string value)
{
Ton = ton;
Npi = npi;
Value = value;
}
/// <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);
}
internal BindRequest(PduHeader header)
: base(header)
{
_vSystemId = "";
_vPassword = "";
_vSystemType = "";
_vAddressTon = TypeOfNumber.International; //International
_vAddressNpi = NumberingPlanIndicator.Isdn; //ISDN
_vInterfaceVersion = 34; //SMPP 3.4 version
_vAddressRange = "";
}
internal BindRequest(PDUHeader header)
: base(header)
{
vSystemID = "";
vPassword = "";
vSystemType = "";
vAddressTon = TypeOfNumber.International; //International
vAddressNpi = NumberingPlanIndicator.ISDN; //ISDN
vInterfaceVersion = 34; //SMPP 3.4 version
vAddressRange = "";
}
internal BindRequest(PDUHeader header)
: base(header)
{
vSystemID = "";
vPassword = "";
vSystemType = "";
vAddressTon = TypeOfNumber.International; //International
vAddressNpi = NumberingPlanIndicator.ISDN; //ISDN
vInterfaceVersion = 34; //SMPP 3.4 version
vAddressRange = "";
}
public SessionBindInfo()
{
_vHost = "";
_vSystemId = "";
_vPassword = "";
_vSystemType = "";
_vInterfaceVersion = InterfaceVersion.V34;
_vAllowReceive = true;
_vAllowTransmit = true;
_vAddressTon = TypeOfNumber.International;
_vAddressNpi = NumberingPlanIndicator.Isdn;
}
/// <summary>
/// International phone number
/// </summary>
/// <param name="number"></param>
public Address(long number)
{
string stringNumber = number.ToString();
//this.m_AddressLength = stringNumber.Length;
this.m_TypeOfNumber = TypeOfNumber.InternationalNumber;
this.m_NumberingPlanIdentification = NumberingPlanIdentification.ISDN_telephoneNumberingPlan;
this.m_AddressValue = stringNumber;
}
public SessionBindInfo()
{
vHost = "";
vSystemID = "";
vPassword = "";
vSystemType = "";
vInterfaceVersion = InterfaceVersion.v34;
vAllowReceive = true;
vAllowTransmit = true;
vAddressTon = TypeOfNumber.International;
vAddressNpi = NumberingPlanIndicator.ISDN;
}
public SessionBindInfo()
{
vHost = "";
vSystemID = "";
vPassword = "";
vSystemType = "";
vInterfaceVersion = InterfaceVersion.v34;
vAllowReceive = true;
vAllowTransmit = true;
vAddressTon = TypeOfNumber.International;
vAddressNpi = NumberingPlanIndicator.ISDN;
}
/// <summary>
/// Initializes a new instance of <see cref="SmppConnectionProperties"/>
/// </summary>
public SmppConnectionProperties()
{
vSystemID = "";
vPassword = "";
vHost = "";
vAddressTon = TypeOfNumber.International;
vAddressNpi = NumberingPlanIndicator.ISDN;
vInterfaceVersion = InterfaceVersion.v34;
vSystemType = "";
vDefaultServiceType = "";
SmscID = "";
vSyncRoot = new object();
}
internal static SmppAddress Parse(ByteBuffer buffer)
{
//We require at least 3 bytes for SMPPAddress instance to be craeted
if (buffer.Length < 3)
{
throw new NotEnoughBytesException("SMPPAddress requires at least 3 bytes");
}
TypeOfNumber ton = (TypeOfNumber)PDU.GetByte(buffer);
NumberingPlanIndicator npi = (NumberingPlanIndicator)PDU.GetByte(buffer);
string address = PDU.DecodeCString(buffer);
return(new SmppAddress(ton, npi, address));
}
/// <summary>
/// Initializes a new instance of <see cref="SmppConnectionProperties"/>
/// </summary>
public SmppConnectionProperties()
{
_vSystemId = "";
_vPassword = "";
_vHost = "";
_vAddressTon = TypeOfNumber.International;
_vAddressNpi = NumberingPlanIndicator.Isdn;
_vInterfaceVersion = InterfaceVersion.V34;
_vSystemType = "";
_vDefaultServiceType = "";
SmscId = "";
_vSyncRoot = new object();
}
/// <summary>
/// Initializes a new instance of <see cref="SmppConnectionProperties"/>
/// </summary>
public SmppConnectionProperties()
{
vSystemID = "";
vPassword = "";
vHost = "";
vAddressTon = TypeOfNumber.International;
vAddressNpi = NumberingPlanIndicator.ISDN;
vInterfaceVersion = InterfaceVersion.v34;
vSystemType = "";
vDefaultServiceType = "";
SmscID = "";
vSyncRoot = new object();
}
public static IEnumerable<int> FindNumberType(IEnumerable<int> numbers, TypeOfNumber TypeofNumber)
{
switch (TypeofNumber)
{
case TypeOfNumber.odd:
return numbers.Find(IsOdd);
case TypeOfNumber.even:
return numbers.Find(IsEven);
case TypeOfNumber.prime:
return numbers.Find(IsPrime);
case TypeOfNumber.perfect:
return numbers.Find(IsPerfect);
default:
throw new ArgumentOutOfRangeException("TypeofNumber");
}
}
public Address(string codedAddressField)
{
int length = int.Parse(codedAddressField.Substring(0, 2), System.Globalization.NumberStyles.HexNumber);
this.m_AddressValue = BaseConversionHelper.DecimalSemiOctetToDecimal(codedAddressField.Substring(4, codedAddressField.Length - 4)).ToString();
if (this.m_AddressValue.Length != length)
{
throw new NotImplementedException();
}
int[] typeOfAddress = BaseConversionHelper.HexToBinary(codedAddressField.Substring(2, 2));
this.m_TypeOfNumber = (TypeOfNumber)BaseConversionHelper.BinaryToDecimal(new int[] { typeOfAddress[4], typeOfAddress[5], typeOfAddress[6] });
this.m_NumberingPlanIdentification = (NumberingPlanIdentification)BaseConversionHelper.BinaryToDecimal(new int[] { typeOfAddress[0], typeOfAddress[1], typeOfAddress[2], typeOfAddress[3] });
}
public BindTransceiver(
uint sequenceNumber,
string systemId,
string password,
string systemType,
byte interfaceVersion,
TypeOfNumber addressTon,
NumericPlanIndicator addressNpi,
string addressRange)
: base(sequenceNumber)
{
SystemId = systemId;
Password = password;
SystemType = systemType;
InterfaceVersion = interfaceVersion;
AddressTon = addressTon;
AddressNpi = addressNpi;
AddressRange = AddressRange;
}
public static IEnumerable <int> FindNumberType(IEnumerable <int> numbers, TypeOfNumber TypeofNumber)
{
switch (TypeofNumber)
{
case TypeOfNumber.odd:
return(numbers.Find(IsOdd));
case TypeOfNumber.even:
return(numbers.Find(IsEven));
case TypeOfNumber.prime:
return(numbers.Find(IsPrime));
case TypeOfNumber.perfect:
return(numbers.Find(IsPerfect));
default:
throw new ArgumentOutOfRangeException("TypeofNumber");
}
}
private void BindSession(SessionBindInfo bindInfo, int timeOut)
{
_vTcpIpSession.SessionClosed += TcpIpSessionClosedEventHandler;
BindRequest bindReq = bindInfo.CreatePdu();
_vTrans.Send(bindReq);
BindResponse bindResp = null;
try { bindResp = (BindResponse)_vRespHandler.WaitResponse(bindReq, timeOut); }
catch (SmppResponseTimedOutException ex)
{ throw new SmppBindException(ex); }
if (bindResp.Header.ErrorCode != 0)
{
throw new SmppBindException(bindResp.Header.ErrorCode);
}
//Copy settings
_vSmscId = bindResp.SystemId;
_vSystemId = bindInfo.SystemId;
_vPassword = bindInfo.Password;
_vAddressTon = bindInfo.AddressTon;
_vAddressNpi = bindInfo.AddressNpi;
//Start timer
_vTimer.Start();
_vIsAlive = true;
switch (bindReq.Header.CommandType)
{
case CommandType.BindTransceiver:
ChangeState(SmppSessionState.Transceiver);
break;
case CommandType.BindReceiver:
ChangeState(SmppSessionState.Receiver);
break;
case CommandType.BindTransmitter:
ChangeState(SmppSessionState.Transmitter);
break;
}
}
/// <summary>
/// Address constructor
/// </summary>
/// <param name="ton">Type Of Number</param>
/// <param name="npi">Numeric plan</param>
/// <param name="addr">Address</param>
public multi_address(TypeOfNumber ton, NumericPlanIndicator npi, string addr)
{
flag_.Value = DestinationType.SME_ADDRESS;
elem_ = new address(ton, npi, addr);
}
protected override void Parse(ByteBuffer buffer)
{
if (buffer == null) { throw new ArgumentNullException("buffer"); }
const int minBytes = 7;
if (buffer.Length < minBytes) { throw new NotEnoughBytesException("BindRequest requires at least 7 bytes for body parameters"); }
try
{
vSystemID = DecodeCString(buffer);
vPassword = DecodeCString(buffer);
vSystemType = DecodeCString(buffer);
vInterfaceVersion = GetByte(buffer);
vAddressTon = (TypeOfNumber)GetByte(buffer);
vAddressNpi = (NumberingPlanIndicator)GetByte(buffer);
vAddressRange = DecodeCString(buffer);
}
catch (InvalidOperationException ex)
{
//ByteBuffer.Remove() throws InvalidOperationException exception if called on a empty ByteBuffer instance
//Wrap this exception as a NotEnoughBytesException exception
throw new NotEnoughBytesException(ex.Message,ex);
}
if (buffer.Length > 0) //If there are some bytes left
{ throw new TooManyBytesException(); }
}
public SmppAddress()
{
_vTon = TypeOfNumber.International;
_vNpi = NumberingPlanIndicator.Isdn;
_vAddress = "";
}
public SmppAddress()
{
vTon = TypeOfNumber.International;
vNpi = NumberingPlanIndicator.ISDN;
vAddress = "";
}
public Result(int count, int sum, TypeOfNumber type)
{
_count = count;
_sum = sum;
_typeOfNumber = type;
}
public SmppAddress()
{
vTon = TypeOfNumber.International;
vNpi = NumberingPlanIndicator.ISDN;
vAddress = "";
}
public SmppAddress(TypeOfNumber ton, NumberingPlanIndicator npi, string address)
{
vTon = ton;
vNpi = npi;
vAddress = address;
}
/// <summary>
/// Компиляця строки к отправке SMS
/// </summary>
/// <param name="smsc_num"></param>
/// <param name="tsmsc_num"></param>
/// <param name="da_num"></param>
/// <param name="tda_num"></param>
/// <param name="ep"></param>
/// <param name="TimeLife"></param>
/// <param name="text"></param>
/// <param name="pdu_len">Длина PDU, исключая блок SCA</param>
/// <returns></returns>
string GetPDUSendStr(string smsc_num, TypeOfNumber tsmsc_num, string da_num, TypeOfNumber tda_num, DEncProtocol ep, string text, out int pdu_len)
{
int len_sca = 1;
SPDUSMS spdusms = new SPDUSMS();
string res = string.Empty;
if (smsc_num.Length == 0)
{
spdusms.SMSC_num_len = 0x00;
spdusms.SMSC_type_of_num = 0x00;
spdusms.SMSC_num = string.Empty;
res += "00";
}
else
{
spdusms.SMSC_type_of_num = (byte)tsmsc_num;
spdusms.SMSC_num = BCDFixNum(smsc_num);
len_sca += 1 + (spdusms.SMSC_num.Length / 2);
spdusms.SMSC_num_len = (byte)(len_sca - 1);
res += string.Format("{0:X2}", spdusms.SMSC_num_len) + string.Format("{0:X2}", spdusms.SMSC_type_of_num) + spdusms.SMSC_num;
}
spdusms.TPDU = 0x31;//Отчет о доставке, вр.жизни далее 1 байт
res += string.Format("{0:X2}", spdusms.TPDU);
spdusms.MR = 0x00;
res += string.Format("{0:X2}", spdusms.MR);
spdusms.DA_ref_len = (byte)da_num.Length;
res += string.Format("{0:X2}", spdusms.DA_ref_len);
spdusms.DA_type_of_num = (byte)tda_num;
res += string.Format("{0:X2}", spdusms.DA_type_of_num);
spdusms.DA_num = BCDFixNum(da_num);
res += spdusms.DA_num;
spdusms.PID = 0x00;
res += string.Format("{0:X2}", spdusms.PID);
spdusms.DCS = (byte)ep;
res += string.Format("{0:X2}", spdusms.DCS);
spdusms.VP = 0xAA;
res += string.Format("{0:X2}", spdusms.VP);
string[] rt = new string[2];
switch (ep)
{
case DEncProtocol.SbitDefault:
{
rt = StringToPDU7b(text);
spdusms.UDL = Convert.ToByte(rt[0], 16);
spdusms.UD = rt[1];
}
break;
case DEncProtocol.UTF7:
{
rt = StringToUCS2(text);
spdusms.UDL = Convert.ToByte(rt[0], 16);
spdusms.UD = rt[1];
}
break;
default:
break;
}
res += rt[0] + rt[1];
pdu_len = (res.Length / 2) - len_sca;
return(res);
}
/// <summary>
/// Address constructor
/// </summary>
/// <param name="status">Status code</param>
/// <param name="ton">Type Of Number</param>
/// <param name="npi">Numeric plan</param>
/// <param name="addr">Address</param>
public unsuccess_sme(int status, TypeOfNumber ton, NumericPlanIndicator npi, string addr) :
this(status, new address(ton, npi, addr))
{
}
public SmppAddress(TypeOfNumber ton, NumberingPlanIndicator npi, string address)
{
vTon = ton;
vNpi = npi;
vAddress = address;
}
/// <summary>
/// Address constructor
/// </summary>
/// <param name="ton">Type Of Number</param>
/// <param name="npi">Numeric plan</param>
/// <param name="addr">Address</param>
public address(TypeOfNumber ton, NumericPlanIndicator npi, string addr)
{
ton_.Value = ton;
npi_.Value = npi;
addr_.Value = addr;
}
/// <summary>
/// Specific constructor
/// </summary>
/// <param name="ton">Type</param>
public ton(TypeOfNumber ton) : base((byte)ton)
{
}
