public static object Box(SqlSingle a)
{
if (a.IsNull)
return null;
else
return a.Value;
}
static SqlSingle()
{
Null = new SqlSingle(true);
Zero = new SqlSingle(0f);
MinValue = new SqlSingle(float.MinValue);
MaxValue = new SqlSingle(float.MaxValue);
}
public void Properties()
{
SqlSingle Test = new SqlSingle (5443e12f);
SqlSingle Test1 = new SqlSingle (1);
Assert ("#C01", SqlSingle.Null.IsNull);
AssertEquals ("#C02", 5443e12f, Test.Value);
AssertEquals ("#C03", (float)1, Test1.Value);
}
public void Properties()
{
SqlSingle Test = new SqlSingle(5443e12f);
SqlSingle Test1 = new SqlSingle(1);
Assert.True(SqlSingle.Null.IsNull);
Assert.Equal(5443e12f, Test.Value);
Assert.Equal(1, Test1.Value);
}
public void Properties()
{
SqlSingle Test = new SqlSingle (5443e12f);
SqlSingle Test1 = new SqlSingle (1);
Assert.IsTrue (SqlSingle.Null.IsNull, "#C01");
Assert.AreEqual (5443e12f, Test.Value, "#C02");
Assert.AreEqual ((float)1, Test1.Value, "#C03");
}
// IComparable
// Compares this object to another object, returning an integer that
// indicates the relationship.
// Returns a value less than zero if this < object, zero if this = object,
// or a value greater than zero if this > object.
// null is considered to be less than any instance.
// If object is not of same type, this method throws an ArgumentException.
public int CompareTo(object value)
{
if (value is SqlSingle)
{
SqlSingle i = (SqlSingle)value;
return CompareTo(i);
}
throw ADP.WrongType(value.GetType(), typeof(SqlSingle));
}
public int CompareTo(object value)
{
if (!(value is SqlSingle))
{
throw ADP.WrongType(value.GetType(), typeof(SqlSingle));
}
SqlSingle num = (SqlSingle)value;
return(this.CompareTo(num));
}
// Builtin functions
internal static SqlSingle Abs(SqlSingle x)
{
if (x.IsNull || x.m_value >= 0)
{
return(x);
}
else
{
return(new SqlSingle(-x.m_value));
}
}
private int CompareSqlSingle(SqlSingle value)
{
if (value.IsNull)
{
return(1);
}
else
{
return(this.value.CompareTo(value.Value));
}
}
public void Create()
{
SqlSingle Test= new SqlSingle ((float)34.87);
SqlSingle Test2 = 45.2f;
AssertEquals ("#A01", 34.87f, Test.Value);
AssertEquals ("#A02", 45.2f, Test2.Value);
Test = new SqlSingle (-9000.6543);
AssertEquals ("#A03", -9000.6543f, Test.Value);
}
public void Create()
{
SqlSingle Test= new SqlSingle ((float)34.87);
SqlSingle Test2 = 45.2f;
Assert.AreEqual (34.87f, Test.Value, "#A01");
Assert.AreEqual (45.2f, Test2.Value, "#A02");
Test = new SqlSingle (-9000.6543);
Assert.AreEqual (-9000.6543f, Test.Value, "#A03");
}
public int CompareTo(SqlSingle value)
{
// If both Null, consider them equal.
// Otherwise, Null is less than anything.
if (IsNull)
return value.IsNull ? 0 : -1;
else if (value.IsNull)
return 1;
if (this < value) return -1;
if (this > value) return 1;
return 0;
}
/**
* Performs a logical comparison on two instances of SqlSingle to determine if they are equal.
* @param x A SqlSingle instance.
* @param y A SqlSingle instance.
* @return true if the two values are equal, otherwise false.
* If one of the parameters is null or null value return SqlBoolean.Null.
*/
public static SqlBoolean Equals(SqlSingle x, SqlSingle y)
{
if (x.IsNull || y.IsNull)
{
return(SqlBoolean.Null);
}
if (x.Equals(y))
{
return(SqlBoolean.True);
}
return(SqlBoolean.False);
}
/**
* Compares two instances of SqlSingle to determine if the first is less than or equal to the second.
* @param x A SqlSingle instance
* @param y A SqlSingle instance
* @return A SqlBoolean that is True if the first instance is less than or equal to the second instance, otherwise False.
* If either instance of SqlSingle is null, the Value of the SqlBoolean will be Null.
*/
public static SqlBoolean LessThanOrEqual(SqlSingle x, SqlSingle y)
{
if (x.IsNull || y.IsNull)
{
return(SqlBoolean.Null);
}
if (x._value <= y._value)
{
return(SqlBoolean.True);
}
return(SqlBoolean.False);
}
/**
* Compares two instances of SqlSingle to determine if the first is greater than the second.
* @param x A SqlSingle instance
* @param y A SqlSingle instance
* @return A SqlBoolean that is True if the first instance is greater than the second instance, otherwise False.
* If either instance of SqlSingle is null, the Value of the SqlBoolean will be Null.
*/
public static SqlBoolean GreaterThan(SqlSingle x, SqlSingle y)
{
if (x.IsNull || y.IsNull)
{
return(SqlBoolean.Null);
}
if (x._value > y._value)
{
return(SqlBoolean.True);
}
return(SqlBoolean.False);
}
// Compares this instance with a specified object
public override bool Equals(object value)
{
if (!(value is SqlSingle))
{
return false;
}
SqlSingle i = (SqlSingle)value;
if (i.IsNull || IsNull)
return (i.IsNull && IsNull);
else
return (this == i).Value;
}
/**
* Compares two instances of SqlSingle to determine if they are equal.
* @param x A SqlSingle instance
* @param y A SqlSingle instance
* @return A SqlBoolean that is True if the two instances are not equal or False if the two instances are equal.
* If either instance of SqlSingle is null, the Value of the SqlBoolean will be Null.
*/
public static SqlBoolean NotEquals(SqlSingle x, SqlSingle y)
{
SqlBoolean res = Equals(x, y);
if (res.IsNull)
{
return(res);
}
if (res.IsFalse)
{
return(SqlBoolean.True);
}
return(SqlBoolean.False);
}
public override bool Equals(object value)
{
if (!(value is SqlSingle))
{
return(false);
}
SqlSingle num = (SqlSingle)value;
if (num.IsNull || this.IsNull)
{
return(num.IsNull && this.IsNull);
}
SqlBoolean flag = this == num;
return(flag.Value);
}
public static SqlByte op_Explicit(SqlSingle x)
{
if (x.IsNull)
{
return(SqlByte.Null);
}
float val = x.Value;
if (val < 0 || val > 255)
{
throw new OverflowException("Arithmetic Overflow.");
}
return(new SqlByte((byte)val));
}
// Compares this instance with a specified object
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public override bool Equals(Object value)
{
if (!(value is SqlSingle))
{
return(false);
}
SqlSingle i = (SqlSingle)value;
if (i.IsNull || IsNull)
{
return(i.IsNull && IsNull);
}
else
{
return((this == i).Value);
}
}
/**
* The subtraction operator the second SqlSingle operand from the first.
* @param x A SqlSingle instance
* @param y A SqlSingle instance
* @return The results of the subtraction operation.
*/
public static SqlSingle Subtract(SqlSingle x, SqlSingle y)
{
if (x.IsNull || y.IsNull)
{
return(SqlSingle.Null);
}
float xVal = x._value;
float yVal = y._value;
if (xVal < 0 && yVal > 0 && (java.lang.Math.abs(_minVal - xVal) < yVal))
{
throw new System.OverflowException("Overflow - " + x + " - " + y + " < " + _minVal);
}
if (xVal > 0 && yVal < 0 && (_maxVal - xVal < java.lang.Math.abs(yVal)))
{
throw new System.OverflowException("Overflow - " + x + " - " + y + " > " + _maxVal);
}
return(new SqlSingle(x._value - y._value));
}
/**
* The addition operator computes the sum of the two SqlSingle operands.
* @param x A SqlSingle structure.
* @param y A SqlSingle structure.
* @return The sum of the two SqlSingle operands.
* If one of the parameters is null or null value - return SqlSingle.Null.
*/
public static SqlSingle Add(SqlSingle x, SqlSingle y)
{
if (x.IsNull || y.IsNull)
{
return(SqlSingle.Null);
}
float xVal = x._value;
float yVal = y._value;
if (xVal < 0 && yVal < 0 && (_minVal - xVal > yVal))
{
throw new System.OverflowException("Overflow - " + x + " + " + y + " < " + _minVal);
}
if (xVal > 0 && yVal > 0 && (_maxVal - xVal < yVal))
{
throw new System.OverflowException("Overflow - " + x + " + " + y + " > " + _maxVal);
}
return(new SqlSingle(xVal + yVal));
}
public int CompareTo(SqlSingle value)
{
// If both Null, consider them equal.
// Otherwise, Null is less than anything.
if (IsNull)
{
return(value.IsNull ? 0 : -1);
}
else if (value.IsNull)
{
return(1);
}
if (this < value)
{
return(-1);
}
if (this > value)
{
return(1);
}
return(0);
}
public int CompareTo(SqlSingle value)
{
if (this.IsNull)
{
if (!value.IsNull)
{
return(-1);
}
return(0);
}
if (value.IsNull)
{
return(1);
}
if (SqlBoolean.op_True(this < value))
{
return(-1);
}
if (SqlBoolean.op_True(this > value))
{
return(1);
}
return(0);
}
override public object ConvertXmlToObject(string s) {
SqlSingle newValue = new SqlSingle();
string tempStr =string.Concat("<col>", s, "</col>"); // this is done since you can give fragmet to reader, bug 98767
StringReader strReader = new StringReader(tempStr);
IXmlSerializable tmp = newValue;
using (XmlTextReader xmlTextReader = new XmlTextReader(strReader)) {
tmp.ReadXml(xmlTextReader);
}
return ((SqlSingle)tmp);
}
public static SqlBoolean Equals (SqlSingle x, SqlSingle y)
{
return (x == y);
}
public int CompareTo(SqlSingle value)
{
return(CompareSqlSingle(value));
}
public void SqlSingleToSqlByte()
{
SqlSingle TestSingle64 = new SqlSingle(64);
SqlSingle TestSingle900 = new SqlSingle(900);
Assert.AreEqual((byte)64, ((SqlByte)TestSingle64).Value, "SqlSingleToByte" + Error);
try {
SqlByte test = (SqlByte)TestSingle900;
Assert.Fail("SqlSingleToByte 2" + Error);
} catch (Exception e) {
Assert.AreEqual(typeof(OverflowException), e.GetType(), "OverflowException");
}
}
private int CompareSqlSingle (SqlSingle value)
{
if (value.IsNull)
return 1;
else
return this.value.CompareTo (value.Value);
}
private static void SetSqlSingle_Unchecked( SmiEventSink_Default sink, ITypedSettersV3 setters, int ordinal, SqlSingle value ) {
if ( value.IsNull ) {
setters.SetDBNull( sink, ordinal );
}
else {
setters.SetSingle( sink, ordinal, value.Value );
}
sink.ProcessMessagesAndThrow();
}
// implements SqlClient 1.1-compatible GetSqlValue() semantics for everything except output parameters
internal static object GetSqlValue(
SmiEventSink_Default sink,
ITypedGettersV3 getters,
int ordinal,
SmiMetaData metaData,
SmiContext context
) {
object result = null;
if ( IsDBNull_Unchecked( sink, getters, ordinal ) ) {
if (SqlDbType.Udt == metaData.SqlDbType) {
result = NullUdtInstance(metaData);
}
else {
result = __typeSpecificNullForSqlValue[(int)metaData.SqlDbType];
}
}
else {
switch( metaData.SqlDbType ) {
case SqlDbType.BigInt:
result = new SqlInt64( GetInt64_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.Binary:
result = GetSqlBinary_Unchecked( sink, getters, ordinal );
break;
case SqlDbType.Bit:
result = new SqlBoolean( GetBoolean_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.Char:
result = new SqlString( GetString_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.DateTime:
result = new SqlDateTime( GetDateTime_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.Decimal:
result = GetSqlDecimal_Unchecked( sink, getters, ordinal );
break;
case SqlDbType.Float:
result = new SqlDouble( GetDouble_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.Image:
result = GetSqlBinary_Unchecked( sink, getters, ordinal );
break;
case SqlDbType.Int:
result = new SqlInt32( GetInt32_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.Money:
result = GetSqlMoney_Unchecked( sink, getters, ordinal );
break;
case SqlDbType.NChar:
result = new SqlString( GetString_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.NText:
result = new SqlString( GetString_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.NVarChar:
result = new SqlString( GetString_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.Real:
result = new SqlSingle( GetSingle_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.UniqueIdentifier:
result = new SqlGuid( GetGuid_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.SmallDateTime:
result = new SqlDateTime( GetDateTime_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.SmallInt:
result = new SqlInt16( GetInt16_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.SmallMoney:
result = GetSqlMoney_Unchecked( sink, getters, ordinal );
break;
case SqlDbType.Text:
result = new SqlString( GetString_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.Timestamp:
result = GetSqlBinary_Unchecked( sink, getters, ordinal );
break;
case SqlDbType.TinyInt:
result = new SqlByte( GetByte_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.VarBinary:
result = GetSqlBinary_Unchecked( sink, getters, ordinal );
break;
case SqlDbType.VarChar:
result = new SqlString( GetString_Unchecked( sink, getters, ordinal ) );
break;
case SqlDbType.Variant:
metaData = getters.GetVariantType( sink, ordinal );
sink.ProcessMessagesAndThrow();
Debug.Assert( SqlDbType.Variant != metaData.SqlDbType, "Variant-within-variant causes endless recursion!" );
result = GetSqlValue( sink, getters, ordinal, metaData, context );
break;
case SqlDbType.Xml:
result = GetSqlXml_Unchecked( sink, getters, ordinal, context );
break;
case SqlDbType.Udt:
result = GetUdt_LengthChecked( sink, getters, ordinal, metaData );
break;
}
}
return result;
}
public static SqlBoolean LessThan(SqlSingle x, SqlSingle y)
{
return(x < y);
}
public static SqlBoolean LessThanOrEqual(SqlSingle x, SqlSingle y)
{
return(x <= y);
}
public static SqlSingle Add (SqlSingle x, SqlSingle y)
{
return (x + y);
}
//--------------------------------------------------
// Alternative methods for overloaded operators
//--------------------------------------------------
// Alternative method for operator +
public static SqlSingle Add(SqlSingle x, SqlSingle y)
{
return x + y;
}
public static SqlBoolean NotEquals (SqlSingle x, SqlSingle y)
{
return (x != y);
}
public static SqlBoolean LessThanOrEqual (SqlSingle x, SqlSingle y)
{
return (x <= y);
}
public static SqlBoolean GreaterThanOrEqual (SqlSingle x, SqlSingle y)
{
return (x >= y);
}
private Boolean ReadValues(System.IO.BinaryReader r)
{
Int32 count;
if(r.BaseStream.Length == 0) return false;
count = Sql.Read7BitEncodedInt(r);
if (count == 0) return true;
for (Int32 i = 0; i < count; i++)
{
String name = r.ReadString();
SqlDbType LType = (SqlDbType)r.ReadUInt16();
Object value = null;
Int32 len;
//Int32 lcid;
//SqlCompareOptions co;
switch (LType)
{
case SqlDbType.Bit : value = new SqlBoolean(r.ReadBoolean()); break;
case SqlDbType.TinyInt : value = new SqlByte(r.ReadByte()); break;
case SqlDbType.SmallInt : value = new SqlInt16((Int16)r.ReadInt16()); break;
case SqlDbType.Int : value = new SqlInt32((Int32)r.ReadInt32()); break;
case SqlDbType.BigInt : value = new SqlInt64(r.ReadInt64()); break;
case SqlDbType.Binary :
case SqlDbType.VarBinary: len = r.ReadUInt16(); value = new SqlBytes(r.ReadBytes(len)); break;
case SqlDbType.Char :
case SqlDbType.VarChar : //value = new Sql.SqlAnsiString(r); break;
case SqlDbType.NChar:
case SqlDbType.NVarChar:
//co = (SqlCompareOptions)r.ReadUInt16();
//lcid = r.ReadInt32();
//value = new SqlString(r.ReadString(), lcid, co);
value = new SqlString(r.ReadString());
break;
case SqlDbType.DateTime : value = new SqlDateTime(DateTime.FromBinary(r.ReadInt64())); break;
case SqlDbType.SmallDateTime:
case SqlDbType.Date :
case SqlDbType.DateTime2 : value = DateTime.FromBinary(r.ReadInt64()); break;
case SqlDbType.Time : value = TimeSpan.FromTicks(r.ReadInt64()); break;
case SqlDbType.DateTimeOffset:
DateTime LDateTime = DateTime.FromBinary(r.ReadInt64());
value = new DateTimeOffset(LDateTime, TimeSpan.FromTicks(r.ReadInt64()));
break;
case SqlDbType.Decimal: value = new SqlDecimal(r.ReadDecimal()); break;
case SqlDbType.Float : value = new SqlDouble(r.ReadDouble()); break;
// Not support SqlDbType.Image
case SqlDbType.Money : value = new SqlMoney(r.ReadDecimal()); break;
case SqlDbType.Real : value = new SqlSingle(r.ReadDouble()); break;
case SqlDbType.SmallMoney: value = new SqlMoney(r.ReadDecimal()); break;
// Not support SqlDbType.Structured
// Not support SqlDbType.Text
// Not support SqlDbType.Timestamp
case SqlDbType.UniqueIdentifier: value = new SqlGuid(r.ReadString()); break;
// Not support SqlDbType.Variant
case SqlDbType.Xml:
XmlReader rXml = XmlReader.Create(new System.IO.StringReader(r.ReadString()));
value = new SqlXml(rXml);
break;
case SqlDbType.Udt:
// TODO: Пока поддержа только TParams
//String LTypeName = r.ReadString();
//value = CreateUdtObject(LTypeName);
//if (value is IBinarySerialize)
// (value as IBinarySerialize).Read(r);
//else
// throw new Exception(String.Format("Невозможно прочитать данные типа UDT '{0}' - не поддерживается IBinarySerialize", LTypeName));
value = new SqlUdt(r);
break;
default:
throw new Exception(String.Format("Невозможно прочитать данные, тип '{0}' не поддерживается текущей версией {1}", LType.ToString(), this.GetType().Name));
// Not support SqlDbType.NText
}
if (value != null) FData.Add(name, value);
}
return true;
}
public static SqlSingle Multiply(SqlSingle x, SqlSingle y)
{
return(x * y);
}
internal static void SetSqlSingle( SmiEventSink_Default sink, ITypedSettersV3 setters, int ordinal, SmiMetaData metaData, SqlSingle value ) {
ThrowIfInvalidSetterAccess( metaData, ExtendedClrTypeCode.SqlSingle );
SetSqlSingle_Unchecked( sink, setters, ordinal, value );
}
public static SqlBoolean NotEquals(SqlSingle x, SqlSingle y)
{
return(x != y);
}
internal static SqlSingle GetSqlSingle( SmiEventSink_Default sink, ITypedGettersV3 getters, int ordinal, SmiMetaData metaData ) {
SqlSingle result;
if ( CanAccessGetterDirectly( metaData, ExtendedClrTypeCode.SqlSingle ) ) {
if ( IsDBNull_Unchecked( sink, getters, ordinal ) ) {
result = SqlSingle.Null;
}
else {
Single temp = GetSingle_Unchecked( sink, getters, ordinal );
result = new SqlSingle( temp );
}
}
else {
object obj = GetSqlValue( sink, getters, ordinal, metaData, null );
if (null == obj) {
throw ADP.InvalidCast();
}
result = (SqlSingle) obj;
}
return result;
}
public static SqlSingle Subtract(SqlSingle x, SqlSingle y)
{
return(x - y);
}
public void SqlSingleToSqlInt64 ()
{
SqlSingle TestSingle64 = new SqlSingle (64);
Assert.AreEqual ((long) 64, ((SqlInt64) TestSingle64).Value, "#AE01");
}
/**
* Compares two instances of SqlSingle to determine if they are equal.
* @param x A SqlSingle instance
* @param y A SqlSingle instance
* @return A SqlBoolean that is True if the two instances are not equal or False if the two instances are equal.
* If either instance of SqlSingle is null, the Value of the SqlBoolean will be Null.
*/
public static SqlBoolean NotEquals(SqlSingle x, SqlSingle y)
{
SqlBoolean res = Equals(x, y);
if (res.IsNull)
return res;
if (res.IsFalse)
return SqlBoolean.True;
return SqlBoolean.False;
}
public int CompareTo (SqlSingle value)
{
return CompareSqlSingle (value);
}
/**
* The subtraction operator the second SqlSingle operand from the first.
* @param x A SqlSingle instance
* @param y A SqlSingle instance
* @return The results of the subtraction operation.
*/
public static SqlSingle Subtract(SqlSingle x, SqlSingle y)
{
if (x.IsNull || y.IsNull)
return SqlSingle.Null;
float xVal = x._value;
float yVal = y._value;
if (xVal < 0 && yVal > 0 && (java.lang.Math.abs(_minVal - xVal) < yVal))
throw new System.OverflowException("Overflow - " + x + " - " + y + " < " + _minVal);
if (xVal > 0 && yVal < 0 && (_maxVal - xVal < java.lang.Math.abs(yVal)))
throw new System.OverflowException("Overflow - " + x + " - " + y + " > " + _maxVal);
return new SqlSingle(x._value - y._value);
}
public static SqlSingle Divide (SqlSingle x, SqlSingle y)
{
return (x / y);
}
override public void SetCapacity(int capacity) {
SqlSingle[] newValues = new SqlSingle[capacity];
if (null != values) {
Array.Copy(values, 0, newValues, 0, Math.Min(capacity, values.Length));
}
values = newValues;
}
public static SqlBoolean GreaterThan (SqlSingle x, SqlSingle y)
{
return (x > y);
}
public static SqlSingle Add(SqlSingle x, SqlSingle y)
{
return(x + y);
}
public static SqlBoolean LessThan (SqlSingle x, SqlSingle y)
{
return (x < y);
}
public static SqlSingle Divide(SqlSingle x, SqlSingle y)
{
return(x / y);
}
public static SqlSingle Multiply (SqlSingle x, SqlSingle y)
{
return (x * y);
}
public static SqlBoolean Equals(SqlSingle x, SqlSingle y)
{
return(x == y);
}
public static SqlSingle Subtract (SqlSingle x, SqlSingle y)
{
return (x - y);
}
public static SqlBoolean GreaterThan(SqlSingle x, SqlSingle y)
{
return(x > y);
}
public SqlSingle Adjust(SqlSingle value)
{
if (SqlDbType.Real != SqlDbType)
ThrowInvalidType();
return value;
}
public static SqlBoolean GreaterThanOrEqual(SqlSingle x, SqlSingle y)
{
return(x >= y);
}
