static void ChangeProperties(ValueType instance)
        {
            instance.Number = 29;
            instance.String = "twentynine";

            Console.WriteLine("value in method: {0} {1}", instance.Number, instance.String);
        }

 /// <summary>
 /// 
 /// </summary>
 /// <remarks></remarks>
 /// <seealso cref=""/>
 /// <param name="name"></param>
 /// <param name="dataType"></param>
 /// <param name="pattern"></param>
 public PatternValidation(string name, string dataType, string pattern)
 {
     this.appliedTo = ValueType.All;
     this.name = name;
     this.dataType = dataType;
     this.pattern = pattern;
 }

 /// <summary>
 /// 移除flag中指定的vt特性
 /// </summary>
 public static void RemoveFlag(ref int flag, ValueType vt)
 {
     if (CheckFlag(flag, vt))
     {
         flag &= ~(1 << (int)vt);
     }
 }

 public Option(string name, ValueType valueType, string description, string example) : this(name, valueType)
 {
     Name = name;
     ValueType = valueType;
     Description = description;
     Example = example;
 }

 /// <summary>
 /// 
 /// </summary>
 /// <remarks></remarks>
 /// <seealso cref=""/>
 /// <param name="name"></param>
 /// <param name="dataType"></param>
 /// <param name="checkList"></param>
 public DomainValidation(string name, string dataType, List<string> checkList)
 {
     this.appliedTo = ValueType.All;
     this.name = name;
     this.dataType = dataType;
     this.checkList = checkList;
 }

 internal static void AddIndexRuleConstraints(ConstraintBuilder constraintBuilder, ValueType stringType)
 {
     constraintBuilder
         .AssertAll<ValueField>(vf => (!vf.HasIndexAttribute && !vf.HasMaxLengthAttribute)
                                      ^ (vf.HasIndexAttribute && vf.Type != stringType)
                                      ^ (vf.HasIndexAttribute && vf.HasMaxLengthAttribute))
         .AssertAll<ValueField>(vf => !(vf.HasKeyAttribute && vf.HasIndexAttribute));
 }

        public static int Test2()
        {
            ValueType vt = new ValueType(2);

            int i = vt.GetValue();

            return i;
        }

 private CssMediaFeature(string aName, RangeType aRangeType, ValueType aValueType, int[] aKeywordTable, string aMetric)
 {
     mName = aName;
     mRangeType = aRangeType;
     mValueType = aValueType;
     mKeywordTable = aKeywordTable;
     mMetric = aMetric;
 }

 public CastFunction(ValueType type)
     : base(Fixity.Prefix, 1)
 {
     CastType = type;
     Signature.InputSignature.Clear();
     Signature.InputSignature.Add(ValueType.BlankIdentifier);
     Signature.OutputSignature = ValueType.BlankIdentifier;
 }

		public ValueCorrectionViewModel(ValueType type)
		{
			if (type == ValueType.Integer)
				_format = "0";
			else if (type == ValueType.Percent)
				_format = "P2";
			else
				_format = "0.00";
		}

        public FunctionType(Fixity fixity, int numArguments = 2)
            : base("FunctionType")
        {
            Fixity = fixity;
            InputSignature = new List<ValueType>();

            if (fixity != Hype.Fixity.Prefix && numArguments != 2) throw new Exception("Infix functions can only take 2 arguments.");

            for (int i = 0; i < numArguments; ++i)
            {
                InputSignature.Add(ValueType.Uncertain);
            }
            OutputSignature = ValueType.Uncertain;
        }

		private static string GetName(ValueType type)
		{
			var index = (int)type;
			var names = new string[] {
				"Null",
				"Boolean",
				"Integer",
				"UInteger",
				"Number",
				"String",
				"Array",
				"Object",
			};
			return (index >= 0 && index < names.Length) ? names[index] : "Unknown";
		}

        /// <summary>Assigns all needed attributes to the tag</summary>
        /// <returns>This instance downcasted to base class</returns>
        public virtual IndexedTag attr(
            string id = null,
            string name = null,
            string value = null,
            ValueType? valuetype = null,
            MimeType type = null
        )
        {
            Id = id;
            Name = name;
            Value = value;
            ValueType = valuetype;
            Type = type;

            return this;
        }

        static void Main(string[] args)
        {
            var referenceInstance = new ReferenceType();
            referenceInstance.Number = 1;
            referenceInstance.String = "one";

            ChangeProperties(referenceInstance);
            Console.WriteLine("reference: {0} {1}", referenceInstance.Number, referenceInstance.String);

            var valueInstance = new ValueType();
            valueInstance.Number = 1;
            valueInstance.String = "one";

            ChangeProperties(valueInstance);
            Console.WriteLine("value: {0} {1}", valueInstance.Number, valueInstance.String);
        }

        internal ConstNode(DataTable table, ValueType type, object constant, bool fParseQuotes) : base(table)
        {
            switch (type)
            {
                case ValueType.Null:
                    _val = DBNull.Value;
                    break;

                case ValueType.Numeric:
                    _val = SmallestNumeric(constant);
                    break;
                case ValueType.Decimal:
                    _val = SmallestDecimal(constant);
                    break;
                case ValueType.Float:
                    _val = Convert.ToDouble(constant, NumberFormatInfo.InvariantInfo);
                    break;

                case ValueType.Bool:
                    _val = Convert.ToBoolean(constant, CultureInfo.InvariantCulture);
                    break;

                case ValueType.Str:
                    if (fParseQuotes)
                    {
                        // replace '' with one '
                        _val = ((string)constant).Replace("''", "'");
                    }
                    else
                    {
                        _val = (string)constant;
                    }
                    break;

                case ValueType.Date:
                    _val = DateTime.Parse((string)constant, CultureInfo.InvariantCulture);
                    break;

                case ValueType.Object:
                    _val = constant;
                    break;

                default:
                    Debug.Assert(false, "NYI");
                    goto case ValueType.Object;
            }
        }

 internal static void AddDatabaseGeneratedRuleConstraints(
     ConstraintBuilder constraintBuilder, ValueType stringType, ValueType numberType, ValueType guidType)
 {
     constraintBuilder
         .AssertAll<ValueField>(f => (!f.IsPrimaryKey && f.DatabaseGeneratedAttribute == DatabaseGeneratedAttribute.None)
                                     ^
                                     (
                                         f.IsPrimaryKey
                                         &&
                                         (
                                             (f.Type == stringType && f.DatabaseGeneratedAttribute == DatabaseGeneratedAttribute.Computed)
                                             ^ (f.Type == numberType && f.DatabaseGeneratedAttribute != DatabaseGeneratedAttribute.Computed)
                                             ^ (f.Type == guidType && f.DatabaseGeneratedAttribute != DatabaseGeneratedAttribute.Identity)
                                         )
                                     )
                               );
 }

		public Value(Value value)
		{
			Type = value.Type;
			switch (Type) {
				case ValueType.String:
					Str = value.Str;
					break;
				case ValueType.Number:
					Number = value.Number;
					break;
				case ValueType.Object:
					if (value.Obj != null)
						Obj = new Object(value.Obj);
					break;
				case ValueType.Array:
					Array = new Array(value.Array);
					break;
				case ValueType.Boolean:
					Boolean = value.Boolean;
					break;
			}
		}

            public void VisitConditionalExpr(bool condition, object thenValue, object elseValue, ValueType expected)
            {
                var target = new TypeCheckingVisitor();

                var conditionExpression = new ConstantExpr(condition);
                var thenExpression = new ConstantExpr(thenValue);
                var elseExpression = new ConstantExpr(elseValue);

                var expr = new ConditionalExpr(conditionExpression, thenExpression, elseExpression);

                var actual = target.Visit(expr, scope);

                Assert.AreEqual(expected, actual);
            }

            public void VisitBooleanNotExpr(bool a, ValueType expected)
            {
                var target = new TypeCheckingVisitor();

                var aExpression = new ConstantExpr(a);
                var expr = new NotExpr(aExpression);

                var actual = target.Visit(expr, scope);

                Assert.AreEqual(expected, actual);
            }

        public void RetrieveValue()
        {
            Key = oldKey;

            if (PlayerPrefs.GetString(Key, UNIQUE_STRING) != UNIQUE_STRING)
            {
                Type = ValueType.String;
                value = PlayerPrefs.GetString(Key);
            }
            else if (PlayerPrefs.GetInt(Key, UNIQUE_INT) != UNIQUE_INT)
            {
                Type = ValueType.Integer;
                value = PlayerPrefs.GetInt(Key);
            }
            else if (PlayerPrefs.GetFloat(Key, UNIQUE_FLOAT) != UNIQUE_FLOAT)
            {
                Type = ValueType.Float;
                value = PlayerPrefs.GetFloat(Key);
            }

            oldKey = Key;

            //Don't mark the first set Value as changed
            HasChanged = false;
        }