public override string ToString()
{
string val = string.Empty;
switch (Type)
{
case ValueType.Boolean:
val = BoolValue.ToString();
break;
case ValueType.Integer:
val = IntValue.ToString();
break;
case ValueType.Null:
break;
case ValueType.Process:
val = ProcessValue.ToString();
break;
case ValueType.String:
val = '"' + Regex.Escape(StringValue) + '"';
break;
case ValueType.SshConnection:
val = SshValue.Info.Host;
break;
}
return($"[{Type}] {val}");
}
private void TextBox_TextChanged(object sender, TextChangedEventArgs e)
{
if (!_handleTextChanged)
{
return;
}
_handleTextChanged = false;
TextBox origin = sender as TextBox;
e.Handled = true;
if (origin.Text.Length != 0)
{
if (origin.Text.Length == 1 && (origin.Text.StartsWith('-') || origin.Text.StartsWith('+')))
{
}
else if (Int32.TryParse(origin.Text, out int value))
{
IntValue = value;
}
else
{
SetTextBoxText(ref origin, IntValue.ToString(CultureInfo.CurrentCulture));
}
}
_handleTextChanged = true;
}
public override string ToString()
{
if (StrValue != null)
{
return(StrValue);
}
if (IntValue != null)
{
return(IntValue.ToString());
}
if (LongValue != null)
{
return(LongValue.ToString());
}
if (DoubleValue != null)
{
return(DoubleValue.ToString());
}
if (DateValue != null)
{
return(DateValue.Value.ToShortDateString());
}
if (DecimalValue != null)
{
return(DecimalValue.Value.ToString(CultureInfo.InvariantCulture));
}
if (ArrayValue != null)
{
return(string.Join(", ", ArrayValue));
}
return(string.Empty);
}
protected override string ConvertValue(string newValue)
{
decimal.TryParse(newValue, out decimal currentValue);
// Clamp to range
IntValue = Math.Min((int)currentValue, this.MaxValue);
IntValue = Math.Max(IntValue, this.MinValue);
return(IntValue.ToString());
}
private void UpdateText()
{
switch (InputType)
{
case NumberType.Float:
TextBox.Text = FloatValue.Format(decimalsToDisplay);
break;
case NumberType.Int:
TextBox.Text = IntValue.ToString();
break;
}
}
public override string ToString()
{
switch (NumberType)
{
case NumberType.Int:
return(IntValue.ToString());
case NumberType.Float:
return(FloatValue.ToString(CultureInfo.InvariantCulture));
default:
return("None");
}
}
public override String ToString()
{
switch (NumberType)
{
case NumberType.Int:
return(IntValue.ToString());
case NumberType.Float:
return(FloatValue.ToString());
default:
return("None");
}
}
public override string ToString()
{
if (IsSymbol)
{
return(Value.ToString());
}
if (IsString)
{
return(StringValue);
}
if (IsInt)
{
return(IntValue.ToString(CultureInfo.InvariantCulture));
}
if (IsDouble)
{
return(DoubleValue.ToString(CultureInfo.InvariantCulture));
}
if (IsBool)
{
return(BoolValue ? "#t" : "#f");
}
if (IsNil)
{
return(LispToken.Nil);
}
if (IsList)
{
return(ExpandContainerToString(ListValue));
}
if (IsFunction)
{
return("function " + (FunctionValue.Signature != null ? FunctionValue.Signature : "<unknown>"));
}
if (IsNativeObject)
{
return(NativeObjectStringRepresentation);
}
if (IsUndefined)
{
return("<undefined>");
}
if (IsError)
{
return("Error: " + Value);
}
return("?");
}
public String ToValueString()
{
switch (GetFormatByType(_type))
{
case OptionFormat.Integer:
return((_type == OptionType.Accept || _type == OptionType.ContentFormat) ?
("\"" + MediaType.ToString(IntValue) + "\"") :
IntValue.ToString());
case OptionFormat.String:
return("\"" + StringValue + "\"");
default:
return(ByteArrayUtils.ToHexString(RawValue));
}
}
public void OnEvent(EventData eventData) //响应服务器端发送过来的时间
{
switch (eventData.Code)
{
case 1:
Dictionary <byte, object> data = eventData.Parameters;
object IntValue, StringValue;;
data.TryGetValue(1, out IntValue);
data.TryGetValue(2, out StringValue);
Debug.Log("Event." + IntValue.ToString() + " , " + "Event." + StringValue.ToString());
break;
default:
break;
}
}
public override string ToString()
{
string weaponString = base.ToString() + ", ";
weaponString += NumberHands.ToString() + ", ";
weaponString += AttackValue.ToString() + ", ";
weaponString += AttackModifier.ToString() + ", ";
weaponString += DamageValue.ToString() + ", ";
weaponString += DamageModifier.ToString() + ",";
weaponString += StrValue.ToString() + ",";
weaponString += DexValue.ToString() + ",";
weaponString += IntValue.ToString() + ",";
weaponString += Stability.ToString();
foreach (Type t in allowableClasses)
{
weaponString += ", " + t.Name;
}
return(base.ToString());
}
public override string ToString()
{
switch(FieldType)
{
case FieldType.String:
case FieldType.Time:
if (!FieldLength.HasValue)
throw new Exception("必须指定字段长度");
return StringValue.PadRight(FieldLength.Value);
case FieldType.Int:
if (!FieldLength.HasValue)
throw new Exception("必须指定字段长度");
if (!IntValue.HasValue)
throw new Exception("必须指定字段值");
return IntValue.ToString().PadRight(FieldLength.Value , '0');
case FieldType.Decimal:
if (!FieldLength.HasValue || !DecimalLength.HasValue)
throw new Exception("必须指定字段长度");
if (!DecimalValue.HasValue)
throw new Exception("必须指定字段值");
string format = "{0:" + 0.ToString().PadLeft(FieldLength.Value - DecimalLength.Value, '0') + "." + 0.ToString().PadRight(DecimalLength.Value, '0') + "}";
string ret = string.Format(format, DecimalValue);
if (DecimalValue.Value < 0)
ret = "-" + ret;
else
ret = "+" + ret;
return ret ;
case FieldType.Date:
if (!DateValue.HasValue)
throw new Exception("必须指定字段值");
if (DateValue.Value == DateTime.Parse("1900-01-01"))
return "".PadLeft(FieldLength.Value);
return DateValue.Value.ToString("MM/dd/yyyy");
default:
throw new Exception("未知的字段类型");
}
}
private void IBIntBox_TextChanged(object sender, TextChangedEventArgs e)
{
int value;
if (int.TryParse(Text, out value))
{
if (value > Maximum)
{
value = Maximum;
}
else if (value < 0)
{
value = 0;
}
IntValue = value;
}
else
{
Text = IntValue.ToString();
Select(Text.Length, 0);
}
}
/// <summary>
/// Returns a human-readable string representation of the option's value.
/// </summary>
public override String ToString()
{
switch (this._type)
{
case OptionType.ContentType:
return(MediaType.ToString(IntValue));
case OptionType.MaxAge:
return(String.Format("{0} s", IntValue));
case OptionType.UriPort:
case OptionType.Observe:
case OptionType.Block2:
case OptionType.Block1:
case OptionType.Size:
return(IntValue.ToString());
case OptionType.ProxyUri:
case OptionType.UriHost:
case OptionType.LocationPath:
case OptionType.LocationQuery:
case OptionType.UriPath:
case OptionType.UriQuery:
return(StringValue);
case OptionType.IfNoneMatch:
return("set");
case OptionType.Accept:
return(MediaType.ToString(IntValue));
case OptionType.ETag:
case OptionType.Token:
case OptionType.IfMatch:
default:
return(ByteArrayUtils.ToHexString(RawValue));
}
}
public string GetFieldName()
{
string table = GetTableReferenceString();
switch (_type)
{
case HqlFieldType.STAR:
return(table + "*");
case HqlFieldType.FIELDNUM:
return(table + String.Format("field{0}", _start + 1));
case HqlFieldType.FIXEDWIDTH:
return(table + String.Format("{0}({1}, {2})", _name, _start + 1, _length));
case HqlFieldType.LITERAL_STRING:
return(String.Format("'{0}'", _name));
case HqlFieldType.FUNCTION:
return(Func.GetFieldName());
case HqlFieldType.SCALAR:
return(Scalar.GetFieldName());
case HqlFieldType.LITERAL_INT:
return(IntValue.ToString());
case HqlFieldType.LITERAL_FLOAT:
return(DecimalValue.ToString());
case HqlFieldType.ROWNUM:
return(table + "rownum");
case HqlFieldType.FILENAME:
return(table + "filename");
}
return("UNKNOWN_FIELD");
}
private string GetValue()
{
if (IntValue.HasValue)
{
return(IntValue.ToString());
}
if (DoubleValue.HasValue)
{
return(DoubleValue.ToString());
}
if (!string.IsNullOrEmpty(VariableName))
{
return(VariableName);
}
if (!string.IsNullOrEmpty(BoolValue))
{
return((BoolValue == Constants.TRUE_VALUE ? 1 : 0).ToString());
}
return("");
}
public string GetStringValue()
{
if (BoolValue != null)
{
return(BoolValue.ToString());
}
if (IntValue.HasValue)
{
return(IntValue.ToString());
}
if (DoubleValue.HasValue)
{
return(DoubleValue.ToString());
}
if (!string.IsNullOrEmpty(StringValue))
{
return(StringValue);
}
else
{
return("None");
}
}
public override string ToString()
{
if (IsNull)
{
return("");
}
switch (DataTypeName)
{
case "System.Int32":
return(IntValue.ToString());
case "System.String":
return(StringValue);
case "System.Double":
return(DoubleValue.ToString());
case "System.DateTime":
return(DateTimeValue.ToString());
default:
return(ObjectValue.ToString());
}
}
public override string ToString()
{
switch (_type)
{
case Type.Int:
return(IntValue.ToString());
case Type.Short:
return(ShortValue.ToString());
case Type.UInt:
return(UIntValue.ToString());
case Type.ULong:
return(ULongValue.ToString());
case Type.UShort:
return(UShortValue.ToString());
case Type.Long:
default:
return(LongValue.ToString());
}
}
protected virtual void setDeltaText(XElement xml)
{
xml.SetAttribute(Common.PublishFieldValue, IntValue.ToString());
}
public override string ToString()
{
return("PkiFailureInfo: 0x" + IntValue.ToString("X"));
}
public void LogIntValue() => _logger.Log(IntValue.ToString());
public string Clean()
{
return(IsNumeric ? IntValue.ToString() : Value);
}
public override string ToString()
{
return((InTestMode ? "TEST -- " : "") + IntValue.ToString());
}
public string GetPreviewString(RSTriggerInfo inTriggerContext, RSLibrary inLibrary)
{
switch (m_Type)
{
case InnerType.String:
return(string.Format("\"{0}\"", m_StringValue));
case InnerType.Color:
return(ColorValue.ToString());
case InnerType.Bool:
return(BoolValue ? "true" : "false");
case InnerType.Float:
return(FloatValue.ToString());
case InnerType.Int32:
return(IntValue.ToString());
case InnerType.Null:
return("null");
case InnerType.Vector2:
return(AsVector2.ToString());
case InnerType.Vector3:
return(AsVector3.ToString());
case InnerType.Vector4:
return(AsVector4.ToString());
case InnerType.EntityScope:
return(EntityValue.GetPreviewString(inTriggerContext, inLibrary));
case InnerType.GroupId:
return(GroupIdValue.ToString(inLibrary));
case InnerType.TriggerId:
return(TriggerIdValue.ToString(inLibrary));
case InnerType.Enum:
{
Type enumType = Type.GetType(m_StringValue);
if (enumType == null)
{
Debug.LogErrorFormat("Enum type {0} no longer exists", m_StringValue);
return(m_IntValue.ToString());
}
try
{
return(Enum.ToObject(enumType, m_IntValue).ToString());
}
catch (Exception e)
{
Debug.LogException(e);
Debug.LogErrorFormat("Enum {0} cannot be represented as type {1}", m_IntValue, enumType);
return(m_IntValue.ToString());
}
}
case InnerType.Invalid:
return("INVALID");
default:
ThrowInvalidCastException(m_Type, typeof(string));
return(null);
}
}
public override String ToString()
{
switch (type)
{
case ValType.Boolean:
return(BoolValue.ToString(CultureInfo.InvariantCulture));
case ValType.Break:
return("break");
case ValType.Double:
return(DoubleValue.ToString(CultureInfo.InvariantCulture));
case ValType.Integer:
return(IntValue.ToString(CultureInfo.InvariantCulture));
case ValType.Layer:
return(StringValue);
case ValType.List:
var builder = new StringBuilder();
builder.Append("{");
for (int i = 0; i < ListValue.Count; i++) // Loop through all strings
{
builder.Append(ListValue[i]); // Append string to StringBuilder
if (i < ListValue.Count - 1)
{
builder.Append(",");
}
}
builder.Append("}");
string result = builder.ToString(); // Get string from StringBuilder
return(ListValue.ToString());
case ValType.LoopType:
return(StringValue);
case ValType.Null:
return("null");
case ValType.Object:
return("class");
case ValType.Origin:
return(StringValue);
case ValType.LoopTrigger:
return(StringValue);
case ValType.Return:
return("return");
case ValType.String:
return(StringValue);
case ValType.Void:
return("void");
default:
return("unknown");
}
}
