Exemple #1
0
        public void RemoveItem(IStyleGalleryItem istyleGalleryItem_0)
        {
            Guid   guid;
            object obj;

            if (this.string_0 != "")
            {
                string str = this.method_2(istyleGalleryItem_0);
                if (str.Length != 0 && istyleGalleryItem_0.ID != -1)
                {
                    IPersistStream    item = (IPersistStream)istyleGalleryItem_0.Item;
                    IMemoryBlobStream memoryBlobStreamClass = new MemoryBlobStream();
                    (new ObjectStream()).Stream = memoryBlobStreamClass;
                    item.GetClassID(out guid);
                    item.Save(memoryBlobStreamClass, 1);
                    ((IMemoryBlobStreamVariant)memoryBlobStreamClass).ExportToVariant(out obj);
                    Array  arrays   = (Array)obj;
                    byte[] numArray = new byte[arrays.Length + 16];
                    guid.ToByteArray().CopyTo(numArray, 0);
                    arrays.CopyTo(numArray, 16);
                    obj = numArray;
                    OleDbConnection oleDbConnection =
                        new OleDbConnection(string.Concat("Provider=Microsoft.Jet.OLEDB.4.0;Data source= ",
                                                          this.string_0));
                    oleDbConnection.Open();
                    OleDbCommand d = this.method_7(str, oleDbConnection);
                    d.Parameters["ID"].Value = istyleGalleryItem_0.ID;
                    d.ExecuteNonQuery();
                    oleDbConnection.Close();
                }
            }
        }
 private void FillComboWithEnumValues(ComboBox combo, Type enumType)
 {
     System.Array values = Enum.GetValues(enumType);
     object[]     styles = new object[values.Length];
     values.CopyTo(styles, 0);
     combo.Items.AddRange(styles);
 }
Exemple #3
0
        public static void AddItemToArray(object item, System.Array array)
        {
            int   arraySize = array.GetLength(0);
            Array tempArray = Array.CreateInstance(item.GetType(), arraySize + 1);

            array.CopyTo(tempArray, 0);
            array = tempArray;
            array.SetValue(item, arraySize);
        }
Exemple #4
0
        /// <summary>
        /// Append item to the end of given array.
        /// Not effective - reallocation happends.
        /// </summary>
        /// <param name="arrExtended">Appended array</param>
        /// <param name="objAppended">Appended object</param>
        /// <param name="objTypeOf">Type of appended item</param>
        /// <returns>Newly allocated array with appended item</returns>
        private System.Array AppendItem(System.Array arrExtended, Object objAppended, System.Type objTypeOf)
        {
            int intNewLength = arrExtended.Length + 1;

            System.Array arrReturned = Array.CreateInstance(objTypeOf, intNewLength);
            arrExtended.CopyTo(arrReturned, 0);
            arrReturned.SetValue(objAppended, arrExtended.Length);
            return(arrReturned);
        }
Exemple #5
0
        private Guid ParseDeviceId()
        {
            Byte[] deviceGuid       = new Byte[16];
            String macWithoutColons = this.BluetoothDevice.Address.Replace(":", "");

            Byte[] macBytes = Enumerable.Range(0, macWithoutColons.Length)
                              .Where(x => x % 2 == 0)
                              .Select(x => Convert.ToByte(macWithoutColons.Substring(x, 2), 16))
                              .ToArray();
            macBytes.CopyTo(deviceGuid, 10);
            return(new Guid(deviceGuid));
        }
        private static Array CombineArrays(Array arr1, Array arr2)
        {
            if (arr1 == null)
                return arr2;
            if (arr2 == null)
                return arr1;

            Array newArr = Array.CreateInstance(arr1.GetType().GetElementType(), arr1.Length + arr2.Length);
            arr1.CopyTo(newArr, 0);
            arr2.CopyTo(newArr, arr1.Length);
            return newArr;
        }
Exemple #7
0
        private static TResult[] get_results_array <TResult>(System.Array results_sa, int numitems)
        {
            if (results_sa.Length != numitems)
            {
                string msg = String.Format("Expected {0} items from GetResults but only received {1}", numitems,
                                           results_sa.Length);
                throw new AutomationException(msg);
            }

            TResult[] results = new TResult[results_sa.Length];
            results_sa.CopyTo(results, 0);
            return(results);
        }
Exemple #8
0
 //�ΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡΡ��������Ӻ���
 public static Array Join(Array list1, Array list2, Type arrayType)
 {
     Array list = null;
     if (list1 != null && list2 != null)
     {
         list = Activator.CreateInstance(arrayType, list1.Length + list2.Length) as Array;
         if (list != null)
         {
             list1.CopyTo(list, 0);
             list2.CopyTo(list, list1.Length);
         }
     }
     return list;
 }
 static int CopyTo(IntPtr L)
 {
     try
     {
         ToLua.CheckArgsCount(L, 3);
         System.Array obj  = (System.Array)ToLua.CheckObject(L, 1, typeof(System.Array));
         System.Array arg0 = (System.Array)ToLua.CheckObject(L, 2, typeof(System.Array));
         long         arg1 = (long)LuaDLL.luaL_checknumber(L, 3);
         obj.CopyTo(arg0, arg1);
         return(0);
     }
     catch (Exception e)
     {
         return(LuaDLL.toluaL_exception(L, e));
     }
 }
Exemple #10
0
 static public int CopyTo__Array__Int32(IntPtr l)
 {
     try {
         System.Array self = (System.Array)checkSelf(l);
         System.Array a1;
         checkType(l, 2, out a1);
         System.Int32 a2;
         checkType(l, 3, out a2);
         self.CopyTo(a1, a2);
         pushValue(l, true);
         return(1);
     }
     catch (Exception e) {
         return(error(l, e));
     }
 }
Exemple #11
0
    public UnitComponent PflongeOnUnit(System.Array newextensions)
    {
        if (ComponentExtendsTheOptionalstateOrder)
        {
            UNIT            = this.gameObject.GetComponent <UnitScript>();
            StateExtensions = new System.Enum[newextensions.Length];
            newextensions.CopyTo(StateExtensions, 0);
            this.ID = UNIT.Options.RegisterUnitComponent(this, StateExtensions);

            SignIn();

            return(this);
        }
        else
        {
            return(PflongeOnUnit());
        }
    }
        /// <summary>
        /// Adds new points to the SnapClass' point index.
        /// </summary>
        /// <param name="newShape">The shape containing data to add to the points index.</param>
        public void AddShapeData(int shpIndex, int snaplayeridx)
        {
            int numPoints = 0;

            double []    pts;
            System.Array arr = ((MapWinGIS.Shapefile)m_sfs[snaplayeridx]).QuickPoints(shpIndex, ref numPoints);
            pts = new double[arr.Length];
            arr.CopyTo(pts, 0);
            arr = null;

            for (int j = 0; j < pts.Length; j += 2)
            {
                if (((System.Collections.SortedList)m_lists[snaplayeridx]).ContainsKey(pts[j]))
                {                       // the x value is already in the list.  Add the y value to the "values" list.
                    System.Collections.SortedList yLst;
                    yLst = (System.Collections.SortedList)((System.Collections.SortedList)m_lists[snaplayeridx]).GetByIndex(((System.Collections.SortedList)m_lists[snaplayeridx]).IndexOfKey(pts[j]));
                    if (yLst.ContainsKey(pts[j + 1]) == false)
                    {                           // does not contain the y point yet
                        SnapData data = new SnapData(shpIndex, (int)j / 2, new PointD(pts[j], pts[j + 1]));
                        System.Collections.ArrayList l = new System.Collections.ArrayList();
                        l.Add(data);
                        yLst.Add(pts[j + 1], l);
                    }
                    else
                    {                           // already containt the y point (duplicate point)
                        SnapData data = new SnapData(shpIndex, (int)j / 2, new PointD(pts[j], pts[j + 1]));
                        ((System.Collections.ArrayList)yLst.GetByIndex(yLst.IndexOfKey(pts[j + 1]))).Add(data);
                    }
                }
                else
                {
                    System.Collections.SortedList y_list = new System.Collections.SortedList();
                    SnapData data = new SnapData(shpIndex, (int)j / 2, new PointD(pts[j], pts[j + 1]));
                    System.Collections.ArrayList l = new System.Collections.ArrayList();
                    l.Add(data);
                    y_list.Add(pts[j + 1], l);
                    ((System.Collections.SortedList)m_lists[snaplayeridx]).Add(pts[j], y_list);
                }
            }

            pts = null;
        }
        static StackObject *CopyTo_0(ILIntepreter __intp, StackObject *__esp, IList <object> __mStack, CLRMethod __method, bool isNewObj)
        {
            ILRuntime.Runtime.Enviorment.AppDomain __domain = __intp.AppDomain;
            StackObject *ptr_of_this_method;
            StackObject *__ret = ILIntepreter.Minus(__esp, 3);

            ptr_of_this_method = ILIntepreter.Minus(__esp, 1);
            System.Int32 @index = ptr_of_this_method->Value;

            ptr_of_this_method = ILIntepreter.Minus(__esp, 2);
            System.Array @array = (System.Array) typeof(System.Array).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
            __intp.Free(ptr_of_this_method);

            ptr_of_this_method = ILIntepreter.Minus(__esp, 3);
            System.Array instance_of_this_method = (System.Array) typeof(System.Array).CheckCLRTypes(StackObject.ToObject(ptr_of_this_method, __domain, __mStack));
            __intp.Free(ptr_of_this_method);

            instance_of_this_method.CopyTo(@array, @index);

            return(__ret);
        }
Exemple #14
0
        public static Array Add(Array aFirst, Array aSecond)
        {
            if (aFirst ==  null)
            {
                return aSecond.Clone() as Array;
            }

            if (aSecond == null)
            {
                return aFirst.Clone() as Array;
            }

            Type typeFirst = aFirst.GetType().GetElementType();
            Type typeSecond = aSecond.GetType().GetElementType();

            System.Diagnostics.Debug.Assert(typeFirst == typeSecond);

            Array aNewArray = Array.CreateInstance(typeFirst, aFirst.Length + aSecond.Length);
            aFirst.CopyTo(aNewArray, 0);
            aSecond.CopyTo(aNewArray, aFirst.Length);

            return aNewArray;
        }
	private void PrintRequestCompleted(int result, int responseCode, Array<string> headers, Array<byte> body)
	{
		GD.Print("result: ", result);
		GD.Print("response_code: ", responseCode);

        GD.Print("Headers count " + headers.Count);
        for (int j = 0; j < headers.Count; ++j)
        {
            GD.Print("header " + j + " " + headers[j]);
        }

        byte[] bytes = new byte[body.Count];
        body.CopyTo(bytes, 0);
        string str = System.Text.Encoding.Default.GetString(bytes);
        GD.Print("str ", str);
        if (str.Empty())
        {
            return;
        }
		JSONParseResult jsonParseResult = JSON.Parse(str);
        GD.Print("jsonParseResult is ", jsonParseResult);
        GD.Print("jsonParseResult.Result is ", jsonParseResult.Result);
        GD.Print("jsonParseResult.Result.GetType() " + jsonParseResult.Result.GetType());
        Godot.Collections.Array arrResults = jsonParseResult.Result as Godot.Collections.Array;
        if (null == arrResults)
        {
            return;
        }
        GD.Print("arrResults count " + arrResults.Count);
//        for (int i = 0; i < arrResults.Count; ++i)
//        {
//            Godot.Collections.Dictionary dict = arrResults[i] as Godot.Collections.Dictionary;
//            GD.Print(dict["id"]);
//            GD.Print(dict["name"]);
//            GD.Print(dict["score"]);
//        }
    }
Exemple #16
0
 /// <summary>
 /// Fills dest with a rotated version of source.
 /// </summary>
 /// <param name="source">The source array.</param>
 /// <param name="dest">The dest array, which must have the same length and underlying type
 /// as source.</param>
 /// <param name="rotation">The number of elements to rotate to the left by.</param>
 private static void RotateArrayLeft(Array source, Array dest, int rotation)
 {
     if (source.Length != dest.Length)
     {
         throw new ArgumentException("source and dest lengths differ.");
     }
     if (rotation == 0)
     {
         source.CopyTo(dest, 0);
     }
     else
     {
         for (int i = 0; i < source.Length; ++i)
         {
             dest.SetValue(source.GetValue((rotation + i) % source.Length), i);
         }
     }
 }
 public void CopyTo(Array array, int index)
 {
     array.CopyTo(array, index);
 }
Exemple #18
0
        public void AcquireWriteLock_ReadWrite_LocksCorrectly()
        {
            var name = Guid.NewGuid().ToString();
            Random r = new Random();
            int bufSize = 1024;
            byte[] data = new byte[bufSize];
            byte[] readBuf = new byte[bufSize];

            bool readIsFirst = false;
            bool readBlocked = false;
            int syncValue = 0;

            // Fill with random data
            r.NextBytes(data);

            using (var sma = new Array<byte>(name, bufSize))
            {
                // Acquire write lock early
                sma.AcquireWriteLock();
                using (var smr = new Array<byte>(name))
                {
                    var t1 = Task.Factory.StartNew(() =>
                        {
                            if (System.Threading.Interlocked.Exchange(ref syncValue, 1) == 0)
                                readIsFirst = true;
                            // Should block until write lock is released
                            smr.AcquireReadLock();
                            if (System.Threading.Interlocked.Exchange(ref syncValue, 3) == 4)
                                readBlocked = true;
                            smr.CopyTo(readBuf);
                            smr.ReleaseReadLock();
                        });

                    System.Threading.Thread.Sleep(10);

                    var t2 = Task.Factory.StartNew(() =>
                        {
                            var val = System.Threading.Interlocked.Exchange(ref syncValue, 2);
                            if (val == 0)
                                readIsFirst = false;
                            else if (val == 3)
                                readBlocked = false;
                            System.Threading.Thread.Sleep(10);
                            sma.Write(data);
                            System.Threading.Interlocked.Exchange(ref syncValue, 4);
                            sma.ReleaseWriteLock();
                        });

                    Task.WaitAll(t1, t2);

                    Assert.IsTrue(readIsFirst, "The read thread did not enter first.");
                    Assert.IsTrue(readBlocked, "The read thread did not block.");

                    // Check data was written before read
                    for (var i = 0; i < readBuf.Length; i++)
                    {
                        Assert.AreEqual(data[i], readBuf[i]);
                    }
                }
            }
        }
Exemple #19
0
 public static object[] AppendToArray(Array currentListeners, object listener) {
     var elemType = currentListeners.GetType().GetElementType();
     var newListeners = Array.CreateInstance(elemType, currentListeners.Length + 1);
     currentListeners.CopyTo(newListeners, 0);
     newListeners.SetValue(listener, currentListeners.Length);
     return (object[]) newListeners;
 }
Exemple #20
0
 public void setRow(int row, Array vals)
 {
     vals.CopyTo (boxes, row * 4);
 }
Exemple #21
0
 public void CopyTo_NullArray_ThrowsException()
 {
     var name = Guid.NewGuid().ToString();
     using (var sma = new Array<int>(name, 10))
     {
         bool exceptionThrown = false;
         try
         {
             sma.CopyTo(null);
         }
         catch (ArgumentNullException)
         {
             exceptionThrown = true;
         }
         Assert.IsTrue(exceptionThrown, "null buffer should result in ArgumentNullException");
     }
 }
 /// <summary>
 /// Creates an <see cref="InPredicate"/>.
 /// </summary>
 /// <param name="field">Database field.</param>
 /// <param name="values">List of values.</param>
 /// <param name="negate">Specifies whether the predicate is negated (NOT IN).</param>
 /// <returns>InPredicate.</returns>
 /// <remarks>Creates an IN predicate that determines if a field matches any value in a list.</remarks>
 public static InPredicate In(IDbColumn field, Array values, bool negate)
 {
     object[] objValues = new object[values.Length];
     values.CopyTo(objValues, 0);
     return In(field, objValues, negate);
 }
Exemple #23
0
    void DrawControlSchemeGUI()
    {
        ControlScheme scheme = m_ActionMapEditCopy.controlSchemes[selectedScheme];

        EditorGUI.BeginChangeCheck();
        string schemeName = EditorGUILayout.TextField("Control Scheme Name", scheme.name);

        if (EditorGUI.EndChangeCheck())
        {
            scheme.name = schemeName;
        }

        for (int i = 0; i < scheme.deviceSlots.Count; i++)
        {
            var deviceSlot = scheme.deviceSlots[i];

            Rect rect = EditorGUILayout.GetControlRect();
            if (Event.current.type == EventType.MouseDown && rect.Contains(Event.current.mousePosition))
            {
                m_SelectedDeviceIndex = i;
                Repaint();
            }
            if (m_SelectedDeviceIndex == i)
            {
                GUI.DrawTexture(rect, EditorGUIUtility.whiteTexture);
            }

            string[] tagNames   = null;
            Vector2  tagMaxSize = Vector2.zero;
            if (deviceSlot.type != null && deviceSlot.type.value != null)
            {
                tagNames = InputDeviceUtility.GetDeviceTags(deviceSlot.type.value);
                if (tagNames != null)
                {
                    GUIContent content = new GUIContent();
                    for (var j = 0; j < tagNames.Length; j++)
                    {
                        content.text = tagNames[j];
                        Vector2 size = EditorStyles.popup.CalcSize(content);
                        tagMaxSize = Vector2.Max(size, tagMaxSize);
                    }
                }
            }

            rect.width -= tagMaxSize.x; // Adjust width to leave room for tag
            EditorGUI.BeginChangeCheck();
            Type t = TypeGUI.TypeField(rect, new GUIContent("Device Type"), typeof(InputDevice), deviceSlot.type);
            if (EditorGUI.EndChangeCheck())
            {
                deviceSlot.type = t;
            }
            if (tagNames != null)
            {
                EditorGUI.BeginChangeCheck();
                // We want to have the ability to unset a tag after specifying one, so add an "Any" option
                var popupTags = new string[tagNames.Length + 1];
                popupTags[0] = "Any";
                tagNames.CopyTo(popupTags, 1);
                int tagIndex = deviceSlot.tagIndex + 1;
                rect.x    += rect.width;
                rect.width = tagMaxSize.x;
                tagIndex   = EditorGUI.Popup(
                    rect,
                    tagIndex,
                    popupTags);
                if (EditorGUI.EndChangeCheck())
                {
                    deviceSlot.tagIndex = tagIndex - 1;
                }
            }
        }

        // Device remove and add buttons
        EditorGUILayout.BeginHorizontal();
        {
            GUILayout.Space(15 * EditorGUI.indentLevel);

            if (GUILayout.Button(Styles.iconToolbarMinus, GUIStyle.none))
            {
                RemoveDevice();
            }

            if (GUILayout.Button(Styles.iconToolbarPlus, GUIStyle.none))
            {
                AddDevice();
            }

            GUILayout.FlexibleSpace();
        }
        EditorGUILayout.EndHorizontal();

        // Pad this area with spacing so all control schemes use same heights,
        // and the actions table below doesn't move when switching control scheme.
        int maxDevices = 0;

        for (int i = 0; i < m_ActionMapEditCopy.controlSchemes.Count; i++)
        {
            maxDevices = Mathf.Max(maxDevices, m_ActionMapEditCopy.controlSchemes[i].deviceSlots.Count);
        }
        int extraLines = maxDevices - scheme.deviceSlots.Count;

        EditorGUILayout.GetControlRect(true, extraLines * (EditorGUIUtility.singleLineHeight + EditorGUIUtility.standardVerticalSpacing));
    }
Exemple #24
0
        public void TestWriteToAndReadFrom()
        {
            using (var map = new MemoryMapStream())
            {
                using (var memoryStream = new MemoryStream())
                {
                    using (var array = new Array<int>(map, 10))
                    {
                        for (var i = 0; i < array.Length; i++)
                        {
                            array[i] = i + 100;
                        }

                        array.CopyTo(memoryStream);
                        memoryStream.Seek(0, SeekOrigin.Begin);

                        using (var array1 = new Array<int>(map, array.Length))
                        {
                            array1.CopyFrom(memoryStream);
                            for (var i = 0; i < array.Length; i++)
                            {
                                Assert.AreEqual(array[i], array1[i]);
                            }
                        }
                    }
                }
            }

            using (var map = new MemoryMapStream())
            {
                using (var memoryStream = new MemoryStream())
                {
                    using (var array = new Array<int>(map, 10000, 32, 32, 2))
                    {
                        for (var i = 0; i < array.Length; i++)
                        {
                            array[i] = i + 100;
                        }

                        array.CopyFrom(memoryStream);
                        memoryStream.Seek(0, SeekOrigin.Begin);

                        using (var array1 = new Array<int>(map, array.Length))
                        {
                            array.CopyFrom(memoryStream);
                            for (var i = 0; i < array.Length; i++)
                            {
                                Assert.AreEqual(array[i], array1[i]);
                            }
                        }
                    }
                }
            }
        }
Exemple #25
0
    void FixedUpdate()
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            userPaused = !userPaused;
        }

        if (userPaused)
        {
            return;
        }

        //CalcBorderStuff();


        civilizaitons.CopyTo(civsCopy, 0);
        foreach (Civilization civ in civsCopy)
        {
            if (civ == null)
            {
                continue;                          // skip empty civs;
            }
            Profiler.BeginSample("City Expansion");
            foreach (City city in civ.Cities)
            {
                if (Random.value > 0.2f)
                {
                    continue;
                }

                HexRef xref;
                int    maxDistance = Mathf.CeilToInt(Mathf.Pow(Random.value, 3) * 2.99f);
                maxDistance = Mathf.Max(maxDistance, 1);
                bool foundTile = TryGetNewCityTileLocation(city, out xref, maxDistance);
                if (foundTile)
                {
                    float tileValue = CalcCityTileValue(xref, city);
                    if (tileValue > tileValueTreshold)
                    {
                        SetOwnership(xref.Index, civ.civID);
                    }
                }
            }            // end for each city
            Profiler.EndSample();
            //Conquest
            if (Random.value < 0.005f)
            {
                Profiler.BeginSample("Conquest");
                int roffset = Random.Range(0, civ.Cities.Count);
                for (int i = 0; i < civ.Cities.Count; i++)
                {
                    City sourceCity = civ.Cities[(i + roffset) % civ.Cities.Count];
                    int  dist;
                    City targetCity = GetNearestCityWithCondition(sourceCity.Hex, out dist, o => o.ownerID != civ.civID);
                    if (dist <= 6)
                    {
                        Civilization targetCiv = GetCiv(targetCity.ownerID);
                        Debug.LogFormat(" {0} captured {1} from {2}", civ.name, targetCity.name, GetCiv(targetCity.ownerID));

                        if (targetCiv == null)
                        {
                            Debug.Log("OwnerID: " + targetCity.ownerID);
                            Debug.LogFormat(" {0} captured {1} from {2}", civ.civIndex, targetCity.name, GetCiv(targetCity.ownerID).civIndex);

                            Debug.LogError("Target City's Civ is Null");
                            break;
                        }

                        CaptureCity(targetCity, civ);
                        break;
                    }
                }
                Profiler.EndSample();
            }

            // ChanceForRebellion
            else if (CanSpawnNewCivs() && civ.Cities.Count >= 6 && Random.value < 0.004f)
            {
                Profiler.BeginSample("Rebellion");
                City rebelCity = civ.Cities[Random.Range(1, civ.Cities.Count - 1)];
                Debug.LogFormat("Rebellion at {0}!", rebelCity.name);
                Civilization newCiv = StartNewCiv(rebelCity);
                TransferCityTerritory(rebelCity, newCiv, civ);
                Profiler.EndSample();
            }

            else if (civ.Cities.Count < maxCitiesPerCiv && Random.value < 0.005f)            // spawn new city
            {
                Profiler.BeginSample("Spawning Civs");
                HexRef xref;
                bool   foundCityLocation = TryGetNewCityLocation(civ, out xref);
                if (foundCityLocation)                // if true cell is valid
                {
                    float cityValue = CalcCityValue(xref);
                    if (cityValue > cityValueTreshold)
                    {
                        City newCity = spawnCity(xref);
                        civ.AddCity(newCity);
                    }
                }
                Profiler.EndSample();
            }
        }

        // Spawn New Civ

        if (CanSpawnNewCivs() && Random.value < 0.0003f)
        {
            SpawnCivs(1, 20);
        }

        // remove dead civilizations
        RemoveDeadCivs();

//		if(Input.GetMouseButtonUp(0))
//		{
//			Hex mouseHex = gameGrid.MouseHex();
//			Hex[] circle = Hex.HexCircle(mouseHex,3);
//			circle = gameGrid.ValidHexes(circle);
//			foreach(Hex h in circle)
//			{
//				int index = gameGrid.HexToIndex(h);
//				SetOwnership(index, 5);
//			}
//		}
    }     // end fixed Update
Exemple #26
0
        internal static object[] GetCustomAttributes(ICustomAttributeProvider obj, Type attributeType, bool inherit)
        {
            if (obj == null)
            {
                throw new ArgumentNullException("obj");
            }
            if (attributeType == null)
            {
                throw new ArgumentNullException("attributeType");
            }

            if (attributeType == typeof(MonoCustomAttrs))
            {
                attributeType = null;
            }

            object[] r;
            object[] res = GetCustomAttributesBase(obj, attributeType, false);
            // shortcut
            if (!inherit && res.Length == 1)
            {
                if (res [0] == null)
                {
                    throw new CustomAttributeFormatException("Invalid custom attribute format");
                }

                if (attributeType != null)
                {
                    if (attributeType.IsAssignableFrom(res[0].GetType()))
                    {
                        r    = (object[])Array.CreateInstance(attributeType, 1);
                        r[0] = res[0];
                    }
                    else
                    {
                        r = (object[])Array.CreateInstance(attributeType, 0);
                    }
                }
                else
                {
                    r    = (object[])Array.CreateInstance(res[0].GetType(), 1);
                    r[0] = res[0];
                }
                return(r);
            }

            if (inherit && GetBase(obj) == null)
            {
                inherit = false;
            }

            // if AttributeType is sealed, and Inherited is set to false, then
            // there's no use in scanning base types
            if ((attributeType != null && attributeType.IsSealed) && inherit)
            {
                AttributeUsageAttribute usageAttribute = RetrieveAttributeUsage(
                    attributeType);
                if (!usageAttribute.Inherited)
                {
                    inherit = false;
                }
            }

            var                      initialSize = Math.Max(res.Length, 16);
            List <Object>            a           = null;
            ICustomAttributeProvider btype       = obj;

            object[] array;

            /* Non-inherit case */
            if (!inherit)
            {
                if (attributeType == null)
                {
                    foreach (object attr in res)
                    {
                        if (attr == null)
                        {
                            throw new CustomAttributeFormatException("Invalid custom attribute format");
                        }
                    }
                    var result = new Attribute [res.Length];
                    res.CopyTo(result, 0);
                    return(result);
                }

                a = new List <object> (initialSize);
                foreach (object attr in res)
                {
                    if (attr == null)
                    {
                        throw new CustomAttributeFormatException("Invalid custom attribute format");
                    }

                    Type attrType = attr.GetType();
                    if (attributeType != null && !attributeType.IsAssignableFrom(attrType))
                    {
                        continue;
                    }
                    a.Add(attr);
                }

                if (attributeType == null || attributeType.IsValueType)
                {
                    array = new Attribute [a.Count];
                }
                else
                {
                    array = Array.CreateInstance(attributeType, a.Count) as object[];
                }
                a.CopyTo(array, 0);
                return(array);
            }

            /* Inherit case */
            var attributeInfos   = new Dictionary <Type, AttributeInfo> (initialSize);
            int inheritanceLevel = 0;

            a = new List <object> (initialSize);

            do
            {
                foreach (object attr in res)
                {
                    AttributeUsageAttribute usage;
                    if (attr == null)
                    {
                        throw new CustomAttributeFormatException("Invalid custom attribute format");
                    }

                    Type attrType = attr.GetType();
                    if (attributeType != null)
                    {
                        if (!attributeType.IsAssignableFrom(attrType))
                        {
                            continue;
                        }
                    }

                    AttributeInfo firstAttribute;
                    if (attributeInfos.TryGetValue(attrType, out firstAttribute))
                    {
                        usage = firstAttribute.Usage;
                    }
                    else
                    {
                        usage = RetrieveAttributeUsage(attrType);
                    }

                    // only add attribute to the list of attributes if
                    // - we are on the first inheritance level, or the attribute can be inherited anyway
                    // and (
                    // - multiple attributes of the type are allowed
                    // or (
                    // - this is the first attribute we've discovered
                    // or
                    // - the attribute is on same inheritance level than the first
                    //   attribute that was discovered for this attribute type ))
                    if ((inheritanceLevel == 0 || usage.Inherited) && (usage.AllowMultiple ||
                                                                       (firstAttribute == null || (firstAttribute != null &&
                                                                                                   firstAttribute.InheritanceLevel == inheritanceLevel))))
                    {
                        a.Add(attr);
                    }

                    if (firstAttribute == null)
                    {
                        attributeInfos.Add(attrType, new AttributeInfo(usage, inheritanceLevel));
                    }
                }

                if ((btype = GetBase(btype)) != null)
                {
                    inheritanceLevel++;
                    res = GetCustomAttributesBase(btype, attributeType, true);
                }
            } while (inherit && btype != null);

            if (attributeType == null || attributeType.IsValueType)
            {
                array = new Attribute [a.Count];
            }
            else
            {
                array = Array.CreateInstance(attributeType, a.Count) as object[];
            }

            // copy attributes to array
            a.CopyTo(array, 0);

            return(array);
        }
Exemple #27
0
		void ICollection.CopyTo (Array array, int index)
		{
			// assuming that Nodes is a correct collection.
			array.CopyTo (Nodes.ToArray (typeof(XmlAttribute)), index);
		}
Exemple #28
0
 public static void CopyTo <T>(this T[] array, Memory <T> destination)
 {
     array.CopyTo(destination.Span);
 }