public ReferenceType(BaseType value)
     : base(false)
 {
     referencedValue = value;
     value.Changed += new EventHandler<ValueChangedEventArgs>(value_Changed);
     DoAllocation();
 }

 /// <summary>
 /// Returns true if the value is numerical.
 /// </summary>
 /// <param name="value"></param>
 /// <returns></returns>
 public static bool IsNumeric(BaseType value)
 {
     TypeEnum type = value.Type;
     return type == TypeEnum.Decimal ||
            type == TypeEnum.Float ||
            type == TypeEnum.Integer;
 }

 public override void Insert(BaseType value)
 {
     if (!Contains(value))
     {
         base.Insert(value);
     }
 }

 protected BaseType Promote(BaseType a, BaseType b)
 {
     if (a == BaseType.Double || b == BaseType.Double)
         return BaseType.Double;
     if (a == BaseType.Float || b == BaseType.Float)
         return BaseType.Float;
     if (a == BaseType.ULong || b == BaseType.ULong)
         return BaseType.ULong;
     int aSize = Types.GetBaseTypeSize(a);
     int bSize = Types.GetBaseTypeSize(b);
     if (Types.IsUnsigned(a) && Types.IsSigned(b))
     {
         if (aSize < bSize)
             return b;
         else
             Types.GetIntegralTypeBySize(Math.Max(aSize, bSize), false);
     }
     if (Types.IsSigned(a) && Types.IsUnsigned(b))
     {
         if (bSize < aSize)
             return a;
         else
             return Types.GetIntegralTypeBySize(Math.Max(aSize, bSize), false);
     }
     else
     {
         bool isSigned = Types.IsSigned(a);
         return Types.GetIntegralTypeBySize(Math.Max(aSize, bSize), isSigned);
     }
 } 

        protected override void Because_of()
        {
            var baseType = new BaseType();
            var baseTypeDto = new BaseTypeDto();

            Mapper.Map(baseType, baseTypeDto);
        }

    public static void Main()
    {
        test_is();

        DerivedType derivedObj = new DerivedType();
        BaseType baseObj1 = new BaseType();
        BaseType baseObj2 = derivedObj;

        DerivedType derivedObj2 = baseObj2 as DerivedType;
        if( derivedObj2 != null ) {
            Console.WriteLine( "Conversion Succeeded" );
        } else {
            Console.WriteLine( "Conversion Failed" );
        }

        derivedObj2 = baseObj1 as DerivedType;
        if( derivedObj2 != null ) {
            Console.WriteLine( "Conversion Succeeded" );
        } else {
            Console.WriteLine( "Conversion Failed" );
        }

        BaseType baseObj3 = derivedObj as BaseType;
        if( baseObj3 != null ) {
            Console.WriteLine( "Conversion Succeeded" );
        } else {
            Console.WriteLine( "Conversion Failed" );
        }

        System.Console.WriteLine("Press any key to continue...");
        System.Console.ReadKey();
    }

        public static MvcHtmlString GetAuthorizerScripts(this HtmlHelper helper, BaseType libraryBase, CommonResources includedResources)
        {
            UrlHelper Urls = new UrlHelper(helper.ViewContext.RequestContext);
            List<TagBuilder> LibrarySupportingElements = new List<TagBuilder>();

            TagBuilder OpenIdLibrary = new TagBuilder("script");
            OpenIdLibrary.Attributes.Add(new KeyValuePair<string,string>( "type", "text/javascript"));

            switch(libraryBase)
            {
                case BaseType.Jquery:
                    OpenIdLibrary.Attributes.Add(new KeyValuePair<string, string>("src", Urls.RouteUrl("AuthorizationResources", new {resourceType = "Scripts", resourceName = "openid-jquery.js"})));
                    TagBuilder LanguageFile = new TagBuilder("script");
                    LanguageFile.Attributes.Add(new KeyValuePair<string, string>("type", "text/javascript"));
                    LanguageFile.Attributes.Add(new KeyValuePair<string, string>("src", Urls.RouteUrl("AuthorizationResources", new { resourceType = "Scripts", resourceName = "openid-en.js" })));

                    LibrarySupportingElements.Add(LanguageFile);
                    break;
                default:
                    throw new InvalidOperationException();
            }

            string RawResult = OpenIdLibrary.ToString(TagRenderMode.Normal);
            LibrarySupportingElements.ForEach(Lib => RawResult += Lib.ToString(TagRenderMode.Normal));
            return MvcHtmlString.Create(RawResult);
        }

 public void Can_create_with_complex_type()
 {
     var Complex = new BaseType();
     var a = Immutable.Build<HazAComplexType>(new {Complex});
     Assert.IsNotNull(a.Complex);
     Assert.AreSame(Complex,a.Complex);
 }

 public NetObject(string ip, string dns, string name, BaseType type, int position)
 {
     _ip = ip;
     _dns = dns;
     _name = name;
     _type = type;
     _position = position;
 }

 public NetObject(string ip, string dns, string name, BaseType type, int position, ConditionType state, int threadId)
 {
     _ip = ip;
         _dns = dns;
         _name = name;
         _type = type;
         _position = position;
         _state = state;
         _threadId = threadId;
 }

 /// <summary>
 /// Converts a basetype value to the given type.
 /// </summary>
 /// <param name="value"></param>
 /// <param name="targetType"></param>
 /// <returns></returns>
 public static BaseType Convert(BaseType value, TypeIdentifier targetType)
 {
     if (targetType.TypeEnum == TypeEnum.Undefined || targetType == value.Type)
     {
         return value;
     }
     var target = CreateValue(targetType);
     target.Assign(value);
     return target;
 }

 /// <summary>
 /// Returns true if the value is a type of scalar.
 /// </summary>
 /// <param name="value"></param>
 /// <returns></returns>
 public static bool IsScalar(BaseType value)
 {
     TypeEnum type = value.Type;
     return type == TypeEnum.Boolean ||
         type == TypeEnum.Character ||
         type == TypeEnum.Decimal ||
         type == TypeEnum.Float ||
         type == TypeEnum.Integer ||
         type == TypeEnum.String;
 }

 public static QueryExec Create(BaseType baseType)
 {
     switch (baseType)
     {
         case BaseType.PDA:
             return new QueryExecPDA();
         case BaseType.Oracle:
             return new QueryExecOracle();
     }
     throw new ArgumentException("Base not implemented");
 }

 /// <summary>
 /// Returns true if the value is a type of scalar.
 /// </summary>
 /// <param name="value"></param>
 /// <returns></returns>
 public static bool IsContainer(BaseType value)
 {
     TypeEnum type = value.Type;
     return type == TypeEnum.Array ||
            type == TypeEnum.LinkedList ||
            type == TypeEnum.List ||
            type == TypeEnum.Matrix ||
            type == TypeEnum.PriorityQueue ||
            type == TypeEnum.Queue ||
            type == TypeEnum.Set ||
            type == TypeEnum.Stack;
 }

        public Base(int playerNum, int teamNum, BaseType baseType, Tile tile)
        {
            PlayerNum = playerNum;
            TeamNum = teamNum;
            this.Scale = 2.75f;
            this.Tile = tile;
            this.Position = tile.Position;

            this.model = ScreenManager.Game.Content.Load<Model>("Objects\\Base\\oilRig");
            SetupModel(Position);
            SetupCamera();
        }

 public GunEmplacement(VL.TrackType trackType, VL.GunType gunType, Vector2 positionOffset, float radius, float depthOffset, BaseType baseType, Monster srcMonster)
 {
     this.gunType = gunType;
     this.trackType = trackType;
     this.positionOffset = positionOffset;
     this.radius = radius;
     this.baseRadius = .75f * radius;
     this.depthOffset = depthOffset;
     this.baseType = baseType;
     this.gunLine = srcMonster.position.direction;
     this.gunNormal = Vector3.Cross(gunLine, srcMonster.position.normal);
     this.position = srcMonster.position;
 }

 /// <summary>
 /// Pushes the value converted to the given type.
 /// </summary>
 /// <param name="value"></param>
 /// <param name="type"></param>
 public Push(object value, TypeEnum type)
 {
     AccessMode = ValueAccessModes.Constant;
     this.type = type;
     if (type == TypeEnum.Undefined)
     {
         this.value = ValueFactory.Create(value);
     }
     else
     {
         this.value = ValueFactory.CreateValue(type);
         BaseType param = ValueFactory.Create(value);
         this.value.Assign(param);
     }
 }

        public ScalarGraphics(BaseType value)
            : base()
        {
            this.value = value;
            label = new Label();
            label.VerticalContentAlignment = VerticalAlignment.Center;
            label.HorizontalContentAlignment = HorizontalAlignment.Center;
            label.IsHitTestVisible = true;
            Content = label;
            value.Changed += value_Changed;

            this.MouseUp += new MouseButtonEventHandler(ScalarGraphics_MouseUp);

            currentMode = Mode.Display;

            Update();
        }

        public static GraphicsElement Produce(BaseType value)
        {
            if (value == null)
                return new ScalarGraphics(new VapeTeam.Psimulex.Core.Types.String("NULL"));
            switch (value.Type.TypeEnum)
            {
                case TypeEnum.Integer:
             					return new ScalarGraphics(value);
                case TypeEnum.Array:
                    return new ArrayGraphics(value.ToArray());
                case TypeEnum.Tree:
                    return new TreeGraphics(value.ToTree());
                case TypeEnum.BinaryTree:
                    return new TreeGraphics(value.ToBinaryTree());

                default:
                    if (TypeHierarchy.IsContainer(value))
                    {
                        return new ArrayGraphics(value as AbstractCollection);
                    }
                    return new ScalarGraphics(value);
            }
        }

 //for item db purposes
 public ItemType(BaseType baseItemType, int subItemType, EquipSlot equipSlot)
 {
     this.itemBaseType = baseItemType;
     this.subItemType = subItemType;
     this.itemSlot = equipSlot;
 }