674 lines
17 KiB
C#
674 lines
17 KiB
C#
//
|
|
// OciDefineHandle.cs
|
|
//
|
|
// Part of managed C#/.NET library System.Data.OracleClient.dll
|
|
//
|
|
// Part of the Mono class libraries at
|
|
// mcs/class/System.Data.OracleClient/System.Data.OracleClient.Oci
|
|
//
|
|
// Assembly: System.Data.OracleClient.dll
|
|
// Namespace: System.Data.OracleClient.Oci
|
|
//
|
|
// Authors:
|
|
// Tim Coleman <tim@timcoleman.com>
|
|
// Daniel Morgan <monodanmorg@yahoo.com>
|
|
//
|
|
// Copyright (C) Tim Coleman, 2003
|
|
// Copyright (C) Daniel Morgan, 2004, 2009
|
|
//
|
|
|
|
using System;
|
|
using System.Data.OracleClient;
|
|
using System.Runtime.InteropServices;
|
|
using System.Text;
|
|
|
|
namespace System.Data.OracleClient.Oci
|
|
{
|
|
internal sealed class OciDefineHandle : OciHandle, IDisposable
|
|
{
|
|
#region Fields
|
|
|
|
bool disposed = false;
|
|
|
|
//IntPtr handle;
|
|
IntPtr value;
|
|
IntPtr indicator;
|
|
//OracleType type;
|
|
OciDataType ociType;
|
|
OciDataType definedType;
|
|
int definedSize;
|
|
IntPtr rlenp;
|
|
//short precision;
|
|
short scale;
|
|
Type fieldType;
|
|
string name;
|
|
|
|
// Oracle defines the LONG VARCHAR and LONG VARRAW to have a size of 2 to the 31 power - 5
|
|
// see DefineLongVarChar and DefineLongVarRaw
|
|
// TODO: see OCI Programmers Guide on how to do a piece-wise operations
|
|
// instead of using the below. Or better yet, convert
|
|
// your LONG/LONG VARCHAR to CLOB and LONG RAW/LONG VARRAW to BLOB.
|
|
internal static int LongVarCharMaxValue = (int) Int16.MaxValue - 5;
|
|
internal static int LongVarRawMaxValue = (int) Int16.MaxValue - 5;
|
|
|
|
OciErrorHandle errorHandle;
|
|
|
|
OciLobLocator lobLocator;
|
|
OciDateTimeDescriptor dateTimeDesc;
|
|
OciIntervalDescriptor intervalDesc;
|
|
|
|
#endregion // Fields
|
|
|
|
#region Constructors
|
|
|
|
internal OciDefineHandle (OciHandle parent, IntPtr newHandle)
|
|
: base (OciHandleType.Define, parent, newHandle)
|
|
{
|
|
}
|
|
|
|
internal void DefineByPosition (int position, OracleConnection connection)
|
|
{
|
|
OciParameterDescriptor parameter = ((OciStatementHandle) Parent).GetParameter (position);
|
|
|
|
name = parameter.GetName ();
|
|
definedType = parameter.GetDataType ();
|
|
definedSize = parameter.GetDataSize ();
|
|
//precision = parameter.GetPrecision ();
|
|
scale = parameter.GetScale ();
|
|
rlenp = OciCalls.AllocateClear (sizeof(short));
|
|
indicator = OciCalls.AllocateClear (sizeof(short));
|
|
|
|
Define (position, connection);
|
|
|
|
parameter.Dispose ();
|
|
}
|
|
|
|
#endregion // Constructors
|
|
|
|
#region Properties
|
|
|
|
internal OciDataType DataType {
|
|
get { return definedType; }
|
|
}
|
|
|
|
internal Type FieldType {
|
|
get { return fieldType; }
|
|
}
|
|
|
|
internal int DefinedSize {
|
|
get { return definedSize; }
|
|
}
|
|
|
|
internal OciErrorHandle ErrorHandle {
|
|
get { return errorHandle; }
|
|
set { errorHandle = value; }
|
|
}
|
|
|
|
internal bool IsNull {
|
|
get { return (Indicator == -1); }
|
|
}
|
|
|
|
internal short Scale {
|
|
get { return scale; }
|
|
}
|
|
|
|
internal short Size {
|
|
get { return(Marshal.ReadInt16(rlenp)); }
|
|
set { Marshal.WriteInt16(rlenp, value); }
|
|
}
|
|
|
|
internal short Indicator {
|
|
get { return(Marshal.ReadInt16(indicator)); }
|
|
set { Marshal.WriteInt16(indicator, value); }
|
|
}
|
|
|
|
internal IntPtr Value {
|
|
get { return value; }
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Methods
|
|
|
|
void Define (int position, OracleConnection connection)
|
|
{
|
|
switch (definedType) {
|
|
case OciDataType.Date:
|
|
DefineDate (position, connection);
|
|
return;
|
|
case OciDataType.TimeStamp:
|
|
DefineTimeStamp (position, connection);
|
|
return;
|
|
case OciDataType.Clob:
|
|
case OciDataType.Blob:
|
|
DefineLob (position, definedType, connection);
|
|
return;
|
|
case OciDataType.Raw:
|
|
case OciDataType.VarRaw:
|
|
DefineRaw( position, connection);
|
|
return;
|
|
case OciDataType.LongRaw:
|
|
case OciDataType.LongVarRaw:
|
|
DefineLongVarRaw (position, connection);
|
|
return;
|
|
case OciDataType.RowIdDescriptor:
|
|
definedSize = 10;
|
|
DefineChar (position, connection);
|
|
return;
|
|
case OciDataType.Integer:
|
|
case OciDataType.Number:
|
|
case OciDataType.Float:
|
|
case OciDataType.VarNum:
|
|
case OciDataType.UnsignedInt:
|
|
DefineNumber (position, connection);
|
|
return;
|
|
case OciDataType.Long:
|
|
case OciDataType.LongVarChar:
|
|
DefineLongVarChar (position, connection);
|
|
return;
|
|
case OciDataType.IntervalDayToSecond:
|
|
case OciDataType.IntervalYearToMonth:
|
|
DefineInterval (position, definedType, connection);
|
|
return;
|
|
default:
|
|
DefineChar (position, connection); // HANDLE ALL OTHERS AS CHAR FOR NOW
|
|
return;
|
|
}
|
|
}
|
|
|
|
void DefineTimeStamp (int position, OracleConnection connection)
|
|
{
|
|
definedSize = -1;
|
|
ociType = OciDataType.TimeStamp;
|
|
fieldType = typeof(System.DateTime);
|
|
|
|
dateTimeDesc = (OciDateTimeDescriptor) connection.Environment.Allocate (OciHandleType.TimeStamp);
|
|
if (dateTimeDesc == null) {
|
|
OciErrorInfo info = connection.ErrorHandle.HandleError ();
|
|
throw new OracleException (info.ErrorCode, info.ErrorMessage);
|
|
}
|
|
|
|
value = dateTimeDesc.Handle;
|
|
dateTimeDesc.ErrorHandle = ErrorHandle;
|
|
|
|
int status = 0;
|
|
|
|
status = OciCalls.OCIDefineByPosPtr (Parent,
|
|
out handle,
|
|
ErrorHandle,
|
|
position + 1,
|
|
ref value,
|
|
definedSize,
|
|
ociType,
|
|
indicator,
|
|
rlenp,
|
|
IntPtr.Zero,
|
|
0);
|
|
|
|
definedSize = 11;
|
|
|
|
if (status != 0) {
|
|
OciErrorInfo info = connection.ErrorHandle.HandleError ();
|
|
throw new OracleException (info.ErrorCode, info.ErrorMessage);
|
|
}
|
|
}
|
|
|
|
void DefineDate (int position, OracleConnection connection)
|
|
{
|
|
definedSize = 7;
|
|
ociType = OciDataType.Date;
|
|
fieldType = typeof(System.DateTime);
|
|
|
|
value = OciCalls.AllocateClear (definedSize);
|
|
|
|
int status = 0;
|
|
|
|
status = OciCalls.OCIDefineByPos (Parent,
|
|
out handle,
|
|
ErrorHandle,
|
|
position + 1,
|
|
value,
|
|
definedSize,
|
|
ociType,
|
|
indicator,
|
|
rlenp,
|
|
IntPtr.Zero,
|
|
0);
|
|
|
|
if (status != 0) {
|
|
OciErrorInfo info = ErrorHandle.HandleError ();
|
|
throw new OracleException (info.ErrorCode, info.ErrorMessage);
|
|
}
|
|
}
|
|
|
|
void DefineLongVarChar (int position, OracleConnection connection)
|
|
{
|
|
fieldType = typeof (System.String);
|
|
|
|
// LONG VARCHAR max length is 2 to the 31 power - 5
|
|
// the first 4 bytes of a LONG VARCHAR value contains the length
|
|
// Int32.MaxValue - 5 causes out of memory in mono on win32
|
|
// because I do not have 2GB of memory available
|
|
// so Int16.MaxValue - 5 is used instead.
|
|
// LAMESPEC for Oracle OCI - you can not get the length of the LONG VARCHAR value
|
|
// until after you get the value. This could be why Oracle deprecated LONG VARCHAR.
|
|
// If you specify a definedSize less then the length of the column value,
|
|
// then you will get an OCI_ERROR ORA-01406: fetched column value was truncated
|
|
|
|
// TODO: get via piece-wise - a chunk at a time
|
|
definedSize = LongVarCharMaxValue;
|
|
|
|
value = OciCalls.AllocateClear (definedSize);
|
|
ociType = OciDataType.LongVarChar;
|
|
|
|
int status = 0;
|
|
status = OciCalls.OCIDefineByPos (Parent,
|
|
out handle,
|
|
ErrorHandle,
|
|
position + 1,
|
|
value,
|
|
definedSize,
|
|
ociType,
|
|
indicator,
|
|
rlenp,
|
|
IntPtr.Zero, 0);
|
|
|
|
Size = (short) definedSize;
|
|
|
|
if (status != 0) {
|
|
OciErrorInfo info = ErrorHandle.HandleError ();
|
|
throw new OracleException (info.ErrorCode, info.ErrorMessage);
|
|
}
|
|
}
|
|
|
|
void DefineChar (int position, OracleConnection connection)
|
|
{
|
|
fieldType = typeof (System.String);
|
|
|
|
int maxByteCount = Encoding.UTF8.GetMaxByteCount (definedSize);
|
|
value = OciCalls.AllocateClear (maxByteCount);
|
|
|
|
ociType = OciDataType.Char;
|
|
|
|
int status = 0;
|
|
|
|
status = OciCalls.OCIDefineByPos (Parent,
|
|
out handle,
|
|
ErrorHandle,
|
|
position + 1,
|
|
value,
|
|
maxByteCount,
|
|
ociType,
|
|
indicator,
|
|
rlenp,
|
|
IntPtr.Zero,
|
|
0);
|
|
OciErrorHandle.ThrowExceptionIfError (ErrorHandle, status);
|
|
}
|
|
|
|
void DefineNumber (int position, OracleConnection connection)
|
|
{
|
|
fieldType = typeof (System.Decimal);
|
|
value = OciCalls.AllocateClear (definedSize);
|
|
|
|
ociType = OciDataType.Char;
|
|
|
|
int status = 0;
|
|
|
|
status = OciCalls.OCIDefineByPos (Parent,
|
|
out handle,
|
|
ErrorHandle,
|
|
position + 1,
|
|
value,
|
|
definedSize,
|
|
ociType,
|
|
indicator,
|
|
rlenp,
|
|
IntPtr.Zero,
|
|
0);
|
|
|
|
if (status != 0) {
|
|
OciErrorInfo info = ErrorHandle.HandleError ();
|
|
throw new OracleException (info.ErrorCode, info.ErrorMessage);
|
|
}
|
|
}
|
|
|
|
void DefineLob (int position, OciDataType type, OracleConnection connection)
|
|
{
|
|
ociType = type;
|
|
|
|
if (ociType == OciDataType.Clob)
|
|
fieldType = typeof(System.String);
|
|
else if (ociType == OciDataType.Blob)
|
|
fieldType = typeof(byte[]);
|
|
|
|
int status = 0;
|
|
|
|
definedSize = -1;
|
|
|
|
lobLocator = (OciLobLocator) connection.Environment.Allocate (OciHandleType.LobLocator);
|
|
|
|
if (lobLocator == null) {
|
|
OciErrorInfo info = connection.ErrorHandle.HandleError ();
|
|
throw new OracleException (info.ErrorCode, info.ErrorMessage);
|
|
}
|
|
|
|
value = lobLocator.Handle;
|
|
lobLocator.ErrorHandle = connection.ErrorHandle;
|
|
lobLocator.Service = connection.ServiceContext;
|
|
lobLocator.Environment = connection.Environment;
|
|
|
|
status = OciCalls.OCIDefineByPosPtr (Parent,
|
|
out handle,
|
|
ErrorHandle,
|
|
position + 1,
|
|
ref value,
|
|
definedSize,
|
|
ociType,
|
|
indicator,
|
|
rlenp,
|
|
IntPtr.Zero,
|
|
0);
|
|
|
|
definedSize = Int32.MaxValue;
|
|
|
|
if (status != 0) {
|
|
OciErrorInfo info = connection.ErrorHandle.HandleError ();
|
|
throw new OracleException (info.ErrorCode, info.ErrorMessage);
|
|
}
|
|
}
|
|
|
|
void DefineRaw (int position, OracleConnection connection)
|
|
{
|
|
ociType = OciDataType.Raw;
|
|
fieldType = typeof (byte[]);
|
|
|
|
value = OciCalls.AllocateClear (definedSize);
|
|
|
|
int status = 0;
|
|
|
|
status = OciCalls.OCIDefineByPos (Parent,
|
|
out handle,
|
|
ErrorHandle,
|
|
position + 1,
|
|
value,
|
|
definedSize,
|
|
ociType,
|
|
indicator,
|
|
rlenp,
|
|
IntPtr.Zero, 0);
|
|
|
|
if (status != 0) {
|
|
OciErrorInfo info = ErrorHandle.HandleError ();
|
|
throw new OracleException (info.ErrorCode, info.ErrorMessage);
|
|
}
|
|
}
|
|
|
|
void DefineLongVarRaw (int position, OracleConnection connection)
|
|
{
|
|
ociType = OciDataType.LongVarRaw;
|
|
fieldType = typeof (byte[]);
|
|
|
|
// TODO: get via piece-wise - a chunk at a time
|
|
definedSize = LongVarRawMaxValue;
|
|
|
|
value = OciCalls.AllocateClear (definedSize);
|
|
|
|
int status = 0;
|
|
|
|
status = OciCalls.OCIDefineByPos (Parent,
|
|
out handle,
|
|
ErrorHandle,
|
|
position + 1,
|
|
value,
|
|
definedSize,
|
|
ociType,
|
|
indicator,
|
|
rlenp,
|
|
IntPtr.Zero, 0);
|
|
|
|
if (status != 0) {
|
|
OciErrorInfo info = ErrorHandle.HandleError ();
|
|
throw new OracleException (info.ErrorCode, info.ErrorMessage);
|
|
}
|
|
}
|
|
|
|
void DefineInterval (int position, OciDataType type, OracleConnection connection)
|
|
{
|
|
ociType = type;
|
|
fieldType = typeof(string);
|
|
definedSize = -1;
|
|
|
|
switch (type) {
|
|
case OciDataType.IntervalDayToSecond:
|
|
definedSize = 11;
|
|
intervalDesc = (OciIntervalDescriptor) connection.Environment.Allocate (OciHandleType.IntervalDayToSecond);
|
|
break;
|
|
case OciDataType.IntervalYearToMonth:
|
|
intervalDesc = (OciIntervalDescriptor) connection.Environment.Allocate (OciHandleType.IntervalYearToMonth);
|
|
definedSize = 5;
|
|
break;
|
|
}
|
|
|
|
if (intervalDesc == null) {
|
|
OciErrorInfo info = connection.ErrorHandle.HandleError ();
|
|
throw new OracleException (info.ErrorCode, info.ErrorMessage);
|
|
}
|
|
|
|
value = intervalDesc.Handle;
|
|
intervalDesc.ErrorHandle = ErrorHandle;
|
|
|
|
int status = 0;
|
|
|
|
status = OciCalls.OCIDefineByPosPtr (Parent,
|
|
out handle,
|
|
ErrorHandle,
|
|
position + 1,
|
|
ref value,
|
|
definedSize,
|
|
ociType,
|
|
indicator,
|
|
rlenp,
|
|
IntPtr.Zero,
|
|
0);
|
|
|
|
if (status != 0) {
|
|
OciErrorInfo info = connection.ErrorHandle.HandleError ();
|
|
throw new OracleException (info.ErrorCode, info.ErrorMessage);
|
|
}
|
|
}
|
|
|
|
protected override void Dispose (bool disposing)
|
|
{
|
|
if (!disposed) {
|
|
try {
|
|
switch (definedType) {
|
|
case OciDataType.Clob:
|
|
case OciDataType.Blob:
|
|
case OciDataType.TimeStamp:
|
|
case OciDataType.IntervalDayToSecond:
|
|
case OciDataType.IntervalYearToMonth:
|
|
break;
|
|
default:
|
|
Marshal.FreeHGlobal (value);
|
|
break;
|
|
}
|
|
disposed = true;
|
|
} finally {
|
|
Marshal.FreeHGlobal (indicator);
|
|
Marshal.FreeHGlobal (rlenp);
|
|
base.Dispose (disposing);
|
|
value = IntPtr.Zero;
|
|
}
|
|
}
|
|
}
|
|
|
|
internal OracleLob GetOracleLob ()
|
|
{
|
|
return new OracleLob (lobLocator, ociType);
|
|
}
|
|
|
|
internal object GetValue (IFormatProvider formatProvider, OracleConnection conn)
|
|
{
|
|
object tmp;
|
|
|
|
byte [] buffer = null;
|
|
|
|
switch (DataType) {
|
|
case OciDataType.VarChar2:
|
|
case OciDataType.String:
|
|
case OciDataType.VarChar:
|
|
case OciDataType.Char:
|
|
case OciDataType.CharZ:
|
|
case OciDataType.OciString:
|
|
case OciDataType.RowIdDescriptor:
|
|
buffer = new byte [Size];
|
|
Marshal.Copy (Value, buffer, 0, Size);
|
|
|
|
// Get length of returned string
|
|
int rsize = 0;
|
|
//IntPtr env = Parent.Parent; // Parent is statement, grandparent is environment
|
|
IntPtr env = conn.Environment;
|
|
int status = OciCalls.OCICharSetToUnicode (env, null, buffer, out rsize);
|
|
OciErrorHandle.ThrowExceptionIfError (ErrorHandle, status);
|
|
|
|
// Get string
|
|
StringBuilder ret = new StringBuilder(rsize);
|
|
status = OciCalls.OCICharSetToUnicode (env, ret, buffer, out rsize);
|
|
OciErrorHandle.ThrowExceptionIfError (ErrorHandle, status);
|
|
|
|
return ret.ToString ();
|
|
case OciDataType.LongVarChar:
|
|
case OciDataType.Long:
|
|
buffer = new byte [LongVarCharMaxValue];
|
|
Marshal.Copy (Value, buffer, 0, buffer.Length);
|
|
|
|
int longSize = 0;
|
|
if (BitConverter.IsLittleEndian)
|
|
longSize = BitConverter.ToInt32 (new byte[]{buffer[0], buffer[1], buffer[2], buffer[3]}, 0);
|
|
else
|
|
longSize = BitConverter.ToInt32 (new byte[]{buffer[3], buffer[2], buffer[1], buffer[0]}, 0);
|
|
|
|
ASCIIEncoding encoding = new ASCIIEncoding ();
|
|
string e = encoding.GetString (buffer, 4, longSize);
|
|
return e;
|
|
case OciDataType.Integer:
|
|
case OciDataType.Number:
|
|
case OciDataType.Float:
|
|
case OciDataType.VarNum:
|
|
case OciDataType.UnsignedInt:
|
|
tmp = Marshal.PtrToStringAnsi (Value, Size);
|
|
if (tmp != null)
|
|
return Decimal.Parse (String.Copy ((string) tmp), formatProvider);
|
|
break;
|
|
case OciDataType.TimeStamp:
|
|
return dateTimeDesc.GetDateTime (conn.Environment, dateTimeDesc.ErrorHandle);
|
|
case OciDataType.Date:
|
|
return UnpackDate ();
|
|
case OciDataType.Raw:
|
|
case OciDataType.VarRaw:
|
|
byte [] raw_buffer = new byte [Size];
|
|
Marshal.Copy (Value, raw_buffer, 0, Size);
|
|
return raw_buffer;
|
|
case OciDataType.LongRaw:
|
|
case OciDataType.LongVarRaw:
|
|
buffer = new byte [LongVarRawMaxValue];
|
|
Marshal.Copy (Value, buffer, 0, buffer.Length);
|
|
|
|
int longrawSize = 0;
|
|
if (BitConverter.IsLittleEndian)
|
|
longrawSize = BitConverter.ToInt32 (new byte[]{buffer[0], buffer[1], buffer[2], buffer[3]}, 0);
|
|
else
|
|
longrawSize = BitConverter.ToInt32 (new byte[]{buffer[3], buffer[2], buffer[1], buffer[0]}, 0);
|
|
|
|
byte[] longraw_buffer = new byte [longrawSize];
|
|
Array.ConstrainedCopy (buffer, 4, longraw_buffer, 0, longrawSize);
|
|
return longraw_buffer;
|
|
case OciDataType.Blob:
|
|
case OciDataType.Clob:
|
|
return GetOracleLob ();
|
|
case OciDataType.IntervalDayToSecond:
|
|
return new OracleTimeSpan (intervalDesc.GetDayToSecond (conn.Environment, intervalDesc.ErrorHandle));
|
|
case OciDataType.IntervalYearToMonth:
|
|
return new OracleMonthSpan (intervalDesc.GetYearToMonth (conn.Environment, intervalDesc.ErrorHandle));
|
|
default:
|
|
throw new Exception("OciDataType not implemented: " + DataType.ToString ());
|
|
}
|
|
|
|
return DBNull.Value;
|
|
}
|
|
|
|
internal object GetOracleValue (IFormatProvider formatProvider, OracleConnection conn)
|
|
{
|
|
object ovalue = GetValue (formatProvider, conn);
|
|
|
|
switch (DataType) {
|
|
case OciDataType.Raw:
|
|
case OciDataType.VarRaw:
|
|
case OciDataType.LongRaw:
|
|
case OciDataType.LongVarRaw:
|
|
return new OracleBinary ((byte[]) ovalue);
|
|
case OciDataType.Date:
|
|
case OciDataType.TimeStamp:
|
|
return new OracleDateTime ((DateTime) ovalue);
|
|
case OciDataType.Blob:
|
|
case OciDataType.Clob:
|
|
OracleLob lob = (OracleLob) ovalue;
|
|
return lob;
|
|
case OciDataType.Integer:
|
|
case OciDataType.Number:
|
|
case OciDataType.Float:
|
|
case OciDataType.VarNum:
|
|
case OciDataType.UnsignedInt:
|
|
return new OracleNumber ((decimal) ovalue);
|
|
case OciDataType.VarChar2:
|
|
case OciDataType.String:
|
|
case OciDataType.VarChar:
|
|
case OciDataType.Char:
|
|
case OciDataType.CharZ:
|
|
case OciDataType.OciString:
|
|
case OciDataType.LongVarChar:
|
|
case OciDataType.Long:
|
|
case OciDataType.RowIdDescriptor:
|
|
return new OracleString ((string) ovalue);
|
|
case OciDataType.IntervalDayToSecond:
|
|
return new OracleTimeSpan ((OracleTimeSpan) ovalue);
|
|
case OciDataType.IntervalYearToMonth:
|
|
return new OracleMonthSpan ((OracleMonthSpan) ovalue);
|
|
default:
|
|
// TODO: do other types
|
|
throw new NotImplementedException ();
|
|
}
|
|
}
|
|
|
|
[MonoTODO ("Be able to handle negative dates... i.e. BCE.")]
|
|
internal DateTime UnpackDate ()
|
|
{
|
|
byte century = Marshal.ReadByte (value, 0);
|
|
byte year = Marshal.ReadByte (value, 1);
|
|
byte month = Marshal.ReadByte (value, 2);
|
|
byte day = Marshal.ReadByte (value, 3);
|
|
byte hour = Marshal.ReadByte (value, 4);
|
|
byte minute = Marshal.ReadByte (value, 5);
|
|
byte second = Marshal.ReadByte (value, 6);
|
|
|
|
if (hour == 0)
|
|
hour ++;
|
|
if (minute == 0)
|
|
minute ++;
|
|
if (second == 0)
|
|
second ++;
|
|
|
|
return new DateTime ((century - 100) * 100 + (year - 100),
|
|
month,
|
|
day,
|
|
hour - 1,
|
|
minute - 1,
|
|
second - 1);
|
|
|
|
}
|
|
|
|
#endregion // Methods
|
|
}
|
|
}
|