public PythonArray(string type, [Optional]object initializer) { if (type == null || type.Length != 1) throw PythonOps.TypeError("expected character, got {0}", DynamicHelpers.GetPythonType(type)); _typeCode = type[0]; _data = CreateData(_typeCode); if (initializer != Type.Missing) extend(initializer); }
public array([NotNull]string type) { if (type == null || type.Length != 1) { throw PythonOps.TypeError("expected character, got {0}", PythonTypeOps.GetName(type)); } _typeCode = type[0]; _data = CreateData(_typeCode); }
public void Test() { IAbstract i1 = new ArrayData(); Assert.AreEqual(2.2, i1.Average, MaxMistake); IAbstract i2 = new GridData(); Assert.AreEqual(2.2 / 3, i2.Average, MaxMistake); }
public static string GetCompanyName() { string surname = NameData.GetSurname(); string[] strArrays = new string[] { "Inc", "Incorporated", "LLC", "Ltd", "Group", "and Sons", "and Partners", "CIC", "CIO", "Co-Operative", "Society", "LP", "LLP", "General Partnership", "PLC", "Cyf", "Ccc", "Corp.", "Corporation" }; string str = string.Concat(surname, " ", ArrayData.GetElement <string>(strArrays)); return(str); }
public static IPickDataSource ConfigurUnityContainer() { IUnityContainer container = new UnityContainer(); container.RegisterType <IPickDataSource, ListData>(); ArrayData DList = container.Resolve <ArrayData>(); return(DList); }
// HW buffer FIXME miiight want to use offset? public RenderInfo(int cnt, ArrayData format, PrimitiveType renderas, int vboID, int tex = 0) { offset = 0; count = cnt; renderAs = renderas; dataFormat = format; vbo = vboID; texture = tex; }
// TODO use glinterleavedarrays possibly void PointazDiffa(ArrayData last, ArrayData now) { var sf = sizeof(float); // Last pointaz int lver, lcol, ltex, lstride; CSTrix(last, out lstride, out lver, out lcol, out ltex); // Want dese pointaz bozz int ver, col, tex, stride; CSTrix(now, out stride, out ver, out col, out tex); // Enabel dem if day waznt ooon befar if (ver > -1 && lver == -1) { buffer.ArrayEnabled(ArrayCap.VertexArray, true); } if (col > -1 && lcol == -1) { buffer.ArrayEnabled(ArrayCap.ColorArray, true); } if (tex > -1 && ltex == -1) { buffer.ArrayEnabled(ArrayCap.TextureCoordArray, true); } // Configah sum pointerz if dey on (caz strdez couldah changes) if (ver > -1) { buffer.SetPointer(ArrayCap.VertexArray, 2, stride * sf, ver * sf); } if (col > -1) { buffer.SetPointer(ArrayCap.ColorArray, 4, stride * sf, col * sf); } if (tex > -1) { buffer.SetPointer(ArrayCap.TextureCoordArray, 2, stride * sf, tex * sf); } // Turn em off if dey aint on no moar if (ver == -1 && lver > -1) { buffer.ArrayEnabled(ArrayCap.VertexArray, false); } if (col == -1 && lcol > -1) { buffer.ArrayEnabled(ArrayCap.ColorArray, false); } if (tex == -1 && ltex > -1) { buffer.ArrayEnabled(ArrayCap.TextureCoordArray, false); } }
public static T[] GetElement <T>(int count, params T[] array) { T[] returnArray = new T[count]; while (count > 0) { returnArray[count - 1] = ArrayData.GetElement <T>(array); count--; } return(returnArray); }
public PythonArray([BytesConversion]string type, [Optional]object initializer) { if (type == null || type.Length != 1) { throw PythonOps.TypeError("expected character, got {0}", PythonTypeOps.GetName(type)); } _typeCode = type[0]; _data = CreateData(_typeCode); if (initializer != Type.Missing) extend(initializer); }
public void Write_ABB_DataRecord(string Data_Record_Name, string Module_Name, string Task_Name, Controller aController, List <string> Variables, int ArrayIndex) { string L_Module_Name = Module_Name; string L_Task_Name = Task_Name; string L_Data_Record_Name = Data_Record_Name; List <string> _Variables = Variables; Controller L_aController = aController; int _ArrayIndex = ArrayIndex; string _info; try { //Get the array with the records rd_array = aController.Rapid.GetRapidData(Task_Name, Module_Name, "RawIndividuals"); ad = (ArrayData)rd_array.Value; int aRank = ad.Rank; //Read the record rd = L_aController.Rapid.GetRapidData(Task_Name, Module_Name, L_Data_Record_Name); rdt = L_aController.Rapid.GetRapidDataType(L_Task_Name, L_Module_Name, L_Data_Record_Name); UserDefined processdata = new UserDefined(rdt); //Prepare the parameters for (int i = 0; i < 5; i++) { processdata.Components[i].FillFromString(_Variables[i]); } //Add the parameters to the array rd_array.Value = ad; ad[ArrayIndex] = processdata; } catch (ABB.Robotics.Controllers.RapidDomain.RapidModuleNotFoundException ee) { _info = "Error: " + ee.Message; } catch (ABB.Robotics.Controllers.RapidDomain.RapidSymbolNotFoundException ee) { _info = "Error: " + ee.Message; } catch (ABB.Robotics.GenericControllerException ee) { _info = "Error: " + ee.Message; } catch (System.Exception ee) { _info = "Error: " + ee.Message; } finally { // Release resources } }
private static IArrowArray CreateArray(Field field, int length) { var creator = new ArrayBufferCreator(length); field.DataType.Accept(creator); ArrayData data = new ArrayData(field.DataType, length, 0, 0, new[] { ArrowBuffer.Empty, creator.Buffer }); return(ArrowArrayFactory.BuildArray(data)); }
public static Array MakeIntArray(int length) { // The following should be improved once the ArrayBuilder PR goes in var intBuilder = new ArrowBuffer.Builder <int>(); intBuilder.AppendRange(Enumerable.Range(0, length).Select(x => x)); ArrowBuffer buffer = intBuilder.Build(); ArrayData intData = new ArrayData(Int32Type.Default, length, 0, 0, new[] { ArrowBuffer.Empty, buffer }); Array intArray = ArrowArrayFactory.BuildArray(intData) as Array; return(intArray); }
private void CreateSelfAndChildrenFieldNodes(ArrayData data) { if (data.DataType is NestedType) { // flatbuffer struct vectors have to be created in reverse order for (int i = data.Children.Length - 1; i >= 0; i--) { CreateSelfAndChildrenFieldNodes(data.Children[i]); } } Flatbuf.FieldNode.CreateFieldNode(Builder, data.Length, data.NullCount); }
static byte[] getBytes(ArrayData str) { int size = Marshal.SizeOf(str); byte[] arr = new byte[size]; IntPtr ptr = Marshal.AllocHGlobal(size); Marshal.StructureToPtr(str, ptr, true); Marshal.Copy(ptr, arr, 0, size); Marshal.FreeHGlobal(ptr); return(arr); }
void IncrementalIndexTest(PrimitiveType pt, bool ver, bool col) { // test one, just put vertex data in only, same stride, same lenghts. Check the correct data ends up back in. int nd = 5 * buf.primsizes[pt] * (2 + 4); // 5 quads for (int i = 0; i < 3; i++) // 3 times { int st = i * nd; ArrayData ad = 0 | (ver ? ArrayData.Vertex : 0) | (col ? ArrayData.Color : 0); var r = new RenderInfo(st, nd, ad, pt); for (int j = st; j < st + nd; j++) { rd.sofwareBuffer.Add(j); } rd.bufferInfo.Add(r); } rp.ProcessRenderBuffer(rd); // check we haaave got ...erm...vertexes int chk = 0; foreach (var p in buf.renderlist) { Assert.AreEqual(p.pt, pt); foreach (var d in p.data) { Assert.IsNull(d.t); if (ver) { Assert.AreEqual(d.v.x, chk++); Assert.AreEqual(d.v.y, chk++); } else { Assert.IsNull(d.v); } if (col) { Assert.AreEqual(d.c.a, chk++); Assert.AreEqual(d.c.r, chk++); Assert.AreEqual(d.c.g, chk++); Assert.AreEqual(d.c.b, chk++); } else { Assert.IsNull(d.c); } } } buf.ResetBuffer(); }
/// <summary> /// Sets the ICC data (can be null if not used) /// </summary> /// <param name="inProfileData">Input profile data</param> /// <param name="outProfileData">Output profile data</param> public void SetICCData(double[][] inProfileData, double[][] outProfileData) { if (inProfileData != null) { _InICCData = new ArrayData(inProfileData); InICCData = _InICCData.Pointer; } if (outProfileData != null) { _OutICCData = new ArrayData(outProfileData); OutICCData = _OutICCData.Pointer; } }
static ArrayData fromBytes(byte[] arr) { ArrayData str = new ArrayData(); int size = Marshal.SizeOf(str); IntPtr ptr = Marshal.AllocHGlobal(size); Marshal.Copy(arr, 0, ptr, size); str = (ArrayData)Marshal.PtrToStructure(ptr, str.GetType()); Marshal.FreeHGlobal(ptr); return(str); }
public DotNetEmbeddedResourceImpl(DotNetResourceProvider resourceProvider, HexBufferSpan span, uint token) : base(resourceProvider, span, token) { if (span.Length < 4) { throw new ArgumentOutOfRangeException(nameof(span)); } Size = new StructField <UInt32Data>("Size", new UInt32Data(span.Buffer, span.Start.Position)); Content = new StructField <VirtualArrayData <ByteData> >("Content", ArrayData.CreateVirtualByteArray(HexBufferSpan.FromBounds(span.Start + 4, span.End))); Fields = new BufferField[] { Size, Content, }; }
//Functions public string Read_ABB_DataRecord(string Data_Record_Name, string Module_Name, string Task_Name, Controller aController, int ArrayIndex) { string Data_Records_Time = " "; string L_Module_Name = Module_Name; string L_Task_Name = Task_Name; string L_Data_Record_Name = Data_Record_Name; Controller L_aController = aController; string _info; try { //Get the array with the records rd_array = aController.Rapid.GetRapidData(Task_Name, Module_Name, "RawIndividuals"); ad = (ArrayData)rd_array.Value; int aRank = ad.Rank; //Read the record rd = L_aController.Rapid.GetRapidData(Task_Name, Module_Name, L_Data_Record_Name); rdt = L_aController.Rapid.GetRapidDataType(L_Task_Name, L_Module_Name, L_Data_Record_Name); UserDefined processdata = new UserDefined(rdt); processdata = (UserDefined)ad[ArrayIndex]; //Get the time elapsed using the individual's parameters Data_Records_Time = processdata.Components[5].ToString(); return(Data_Records_Time); } catch (ABB.Robotics.Controllers.RapidDomain.RapidModuleNotFoundException ee) { return(_info = "Error: " + ee.Message); } catch (ABB.Robotics.Controllers.RapidDomain.RapidSymbolNotFoundException ee) { return(_info = "Error: " + ee.Message); } catch (ABB.Robotics.GenericControllerException ee) { return(_info = "Error: " + ee.Message); } catch (System.Exception ee) { return(_info = "Error: " + ee.Message); } finally { // } }
public void InitDataStream() { Task tRob1 = controller.Rapid.GetTask("T_ROB1"); if (tRob1 != null) { rd_repeat = tRob1.GetRapidData("Module1", "repeat"); if (rd_repeat.Value is Bool) { repeatBool = (Bool)rd_repeat.Value; } rd_start = tRob1.GetRapidData("Module1", "flag"); if (rd_start.Value is Num) { processFlag = (Num)rd_start.Value; } rd_targetsNum = tRob1.GetRapidData("Module1", "targetsNum"); if (rd_targetsNum.Value is Num) { processFlag = (Num)rd_start.Value; } rd_speedLevel = tRob1.GetRapidData("Module1", "speedLevel"); if (rd_speedLevel.Value is Num) { speedLevel = (Num)rd_speedLevel.Value; } rd_targets = tRob1.GetRapidData("Module1", "tgPos"); if (rd_targets.IsArray) { targets = (ArrayData)rd_targets.Value; int aRank = targets.Rank; maxLength = targets.GetLength(aRank - 1); ArrayModes am = targets.Mode; Debug.WriteLine("ARRAY MODE! ::: " + am.ToString()); targets.Mode = ArrayModes.Dynamic; } else { MessageBox.Show("'targets' data is not array!"); } if (rd_targets == null) { MessageBox.Show("'targets' data does not exist!"); } } }
private void GenerateInvertedIndices() { indexHash = new Hashtable(); inverted = new ArrayData[vertices.Length]; for (int i = 0; i < vertices.Length; ++i) { if (!indexHash.ContainsKey(vertices[i])) { indexHash.Add(vertices[i], i); } inverted[i] = new ArrayData(); if (inverted[i].tmpConnections == null) { inverted[i].tmpConnections = new List <int>(); } if (inverted[i].tmpAdjacentIndices == null) { inverted[i].tmpAdjacentIndices = new List <int>(); } } //could probably do this on the fly in the previous loop for (int i = 0; i < vertices.Length; ++i) { if (indexHash.ContainsKey(vertices[i])) { int index = (int)indexHash[vertices[i]]; inverted[index].tmpConnections.Add(i); } } for (int i = 0; i < indices.Length; i += 3) { //for each index add to the adj inverted[indices[i]].tmpAdjacentIndices.Add(indices[i + 1]); inverted[indices[i]].tmpAdjacentIndices.Add(indices[i + 2]); inverted[indices[i + 1]].tmpAdjacentIndices.Add(indices[i + 0]); inverted[indices[i + 1]].tmpAdjacentIndices.Add(indices[i + 2]); inverted[indices[i + 2]].tmpAdjacentIndices.Add(indices[i + 1]); inverted[indices[i + 2]].tmpAdjacentIndices.Add(indices[i + 0]); } for (int i = 0; i < vertices.Length; ++i) { inverted[i].UpdateArray(); inverted[i].UpdateAdjacents(); } GenerateConnections(); }
private void PopulateMaterials(List <int> materials) { materials.Clear(); for (int i = 0; i < this.target.components.Count; i++) { if (this.target.components[i].type != null && (typeof(Renderer).IsAssignableFrom(this.target.components[i].type) == true || // Handle all renderers. (typeof(Behaviour).IsAssignableFrom(this.target.components[i].type) == true && // And those bastards like Projector. typeof(MonoBehaviour).IsAssignableFrom(this.target.components[i].type) == false) || typeof(MaskableGraphic).IsAssignableFrom(this.target.components[i].type) == true)) { for (int j = 0; j < this.target.components[i].fields.Length; j++) { if (this.target.components[i].fields[j].name.Equals("sharedMaterials") == true) { ArrayData array = this.target.components[i].fields[j].value as ArrayData; UnityObject[] sharedMaterials = array.array as UnityObject[]; for (int k = 0; k < sharedMaterials.Length; k++) { // Happens when resizing array. if (sharedMaterials[k] == null) { continue; } if (sharedMaterials[k].instanceID != 0 && materials.Contains(sharedMaterials[k].instanceID) == false) { materials.Add(sharedMaterials[k].instanceID); } } } else if (this.target.components[i].fields[j].name.Equals("material") == true) { UnityObject material = this.target.components[i].fields[j].value as UnityObject; if (material.instanceID != 0 && materials.Contains(material.instanceID) == false) { materials.Add(material.instanceID); } } } } } }
public void JudgeColor() { crd_SelectAction = RobotClass.con.Rapid.GetRapidData("T_ROB1", "RobotData", "SelectAction"); ArrayData pp = (ArrayData)crd_SelectAction.Value; switch (((Bool)pp[cPint - 1, 0]).ToString()) { case "False": btn_cy1.BackColor = Color.Gainsboro; break; case "True": btn_cy1.BackColor = Color.Red; break; default: btn_cy1.BackColor = Color.Gainsboro; break; } switch (((Bool)pp[cPint - 1, 1]).ToString()) { case "False": btn_cy2.BackColor = Color.Gainsboro; break; case "True": btn_cy2.BackColor = Color.Red; break; default: btn_cy2.BackColor = Color.Gainsboro; break; } switch (((Bool)pp[cPint - 1, 2]).ToString()) { case "False": btn_cy3.BackColor = Color.Gainsboro; break; case "True": btn_cy3.BackColor = Color.Red; break; default: btn_cy3.BackColor = Color.Gainsboro; break; } }
private static void AddArrayMetadata(Type type) { if (ArrayData.ContainsKey(type)) { return; } ArrayMetadata data = new ArrayMetadata(); data.IsArray = type.IsArray; if (type.GetInterface("System.Collections.IList") != null) { data.IsList = true; } foreach (PropertyInfo p_info in type.GetProperties()) { if (p_info.Name != "Item") { continue; } ParameterInfo[] parameters = p_info.GetIndexParameters(); if (parameters.Length != 1) { continue; } if (parameters[0].ParameterType == typeof(int)) { data.ElementType = p_info.PropertyType; } } lock (arrayMetadataLock) { try { ArrayData.Add(type, data); } catch (ArgumentException) { return; } } }
ComplexData?GetStructure(BlobDataInfo info, HexPosition position) { var pos = info.Span.Start; var lengthStart = pos; var len = ReadCompressedUInt32(ref pos) ?? -1; if (len < 0) { return(null); } if (pos + len > Span.Span.End) { return(null); } var lengthSpan = HexSpan.FromBounds(lengthStart, pos); var dataSpan = new HexSpan(lengthSpan.End, (ulong)len); var fullSpan = HexSpan.FromBounds(lengthSpan.Start, dataSpan.End); if (!fullSpan.Contains(position)) { return(null); } switch (info.Kind) { case BlobDataKind.None: case BlobDataKind.TypeSignature: case BlobDataKind.Signature: case BlobDataKind.Constant: case BlobDataKind.CustomAttribute: case BlobDataKind.NativeType: case BlobDataKind.PermissionSet: case BlobDataKind.PublicKey: case BlobDataKind.PublicKeyOrToken: case BlobDataKind.HashValue: case BlobDataKind.Utf8Name: case BlobDataKind.Name: case BlobDataKind.SequencePoints: case BlobDataKind.LocalConstantSig: case BlobDataKind.Imports: case BlobDataKind.CustomDebugInformationValue: var varray = ArrayData.CreateVirtualByteArray(new HexBufferSpan(Span.Buffer, dataSpan)); return(new BlobHeapRecordData(Span.Buffer, fullSpan, lengthSpan, varray, info.Tokens, this)); default: throw new InvalidOperationException(); } }
public TArray Build(MemoryAllocator allocator = default) { var bufs = new[] { NullCount > 0 ? ValidityBuffer.Build(allocator) : ArrowBuffer.Empty, ValueBuffer.Build(ByteWidth, allocator), }; var data = new ArrayData( DataType, Length, NullCount, 0, bufs); return(Build(data)); }
/// <summary> /// Constructor /// </summary> /// <param name="resourceProvider">Owner</param> /// <param name="resourceInfo">Resource info</param> /// <param name="span">Span</param> /// <param name="lengthPosition">Position of 32-bit content length which immediately follows the 7-bit encoded type code</param> public MultiResourceArrayDataHeaderData(DotNetMultiFileResources resourceProvider, MultiResourceInfo resourceInfo, HexBufferSpan span, HexPosition lengthPosition) : base(resourceProvider, resourceInfo, span) { var typeCodeSpan = new HexBufferSpan(span.Buffer, HexSpan.FromBounds(span.Start, lengthPosition)); TypeCode = new StructField <ResourceTypeCodeData>("TypeCode", ResourceTypeCodeData.Create(typeCodeSpan)); ContentLength = new StructField <UInt32Data>("ContentLength", new UInt32Data(span.Buffer, lengthPosition)); var arraySpan = new HexBufferSpan(span.Buffer, HexSpan.FromBounds(lengthPosition + 4, span.End)); Content = new StructField <VirtualArrayData <ByteData> >("Content", ArrayData.CreateVirtualByteArray(arraySpan)); Fields = new BufferField[] { TypeCode, ContentLength, Content, }; }
PeDosHeaderDataImpl(HexBufferSpan span) : base(span) { var buffer = span.Buffer; var pos = span.Start.Position; Magic = new StructField <UInt16Data>("e_magic", new UInt16Data(buffer, pos + 0)); Cblp = new StructField <UInt16Data>("e_cblp", new UInt16Data(buffer, pos + 2)); Cp = new StructField <UInt16Data>("e_cp", new UInt16Data(buffer, pos + 4)); Crlc = new StructField <UInt16Data>("e_crlc", new UInt16Data(buffer, pos + 6)); Cparhdr = new StructField <UInt16Data>("e_cparhdr", new UInt16Data(buffer, pos + 8)); Minalloc = new StructField <UInt16Data>("e_minalloc", new UInt16Data(buffer, pos + 0x0A)); Maxalloc = new StructField <UInt16Data>("e_maxalloc", new UInt16Data(buffer, pos + 0x0C)); Ss = new StructField <UInt16Data>("e_ss", new UInt16Data(buffer, pos + 0x0E)); Sp = new StructField <UInt16Data>("e_sp", new UInt16Data(buffer, pos + 0x10)); Csum = new StructField <UInt16Data>("e_csum", new UInt16Data(buffer, pos + 0x12)); Ip = new StructField <UInt16Data>("e_ip", new UInt16Data(buffer, pos + 0x14)); Cs = new StructField <UInt16Data>("e_cs", new UInt16Data(buffer, pos + 0x16)); Lfarlc = new StructField <UInt16Data>("e_lfarlc", new UInt16Data(buffer, pos + 0x18)); Ovno = new StructField <UInt16Data>("e_ovno", new UInt16Data(buffer, pos + 0x1A)); Res = new StructField <ArrayData <UInt16Data> >("e_res", ArrayData.CreateUInt16Array(buffer, pos + 0x1C, 4)); Oemid = new StructField <UInt16Data>("e_oemid", new UInt16Data(buffer, pos + 0x24)); Oeminfo = new StructField <UInt16Data>("e_oeminfo", new UInt16Data(buffer, pos + 0x26)); Res2 = new StructField <ArrayData <UInt16Data> >("e_res2", ArrayData.CreateUInt16Array(buffer, pos + 0x28, 10)); Lfanew = new StructField <FileOffsetData>("e_lfanew", new FileOffsetData(buffer, pos + 0x3C)); Fields = new StructField[] { Magic, Cblp, Cp, Crlc, Cparhdr, Minalloc, Maxalloc, Ss, Sp, Csum, Ip, Cs, Lfarlc, Ovno, Res, Oemid, Oeminfo, Res2, Lfanew, }; }
public void CannotTamperWithData() { var originalData = Encoding.UTF8.GetBytes("Hallo!"); var encryptedData = new List <byte>(); var decryptedData = new List <byte>(); IDataSource myDataSource = new ArrayData(originalData); IDataDestination myDataDestination = new ListData(encryptedData); _cryptor.Encrypt(myDataSource, myDataDestination); encryptedData[10] = 0x55; myDataSource = new ArrayData(encryptedData.ToArray()); myDataDestination = new ListData(decryptedData); _cryptor.Decrypt(myDataSource, myDataDestination); }
public FatMethodBodyImpl(DotNetMethodProvider methodProvider, HexBufferSpan span, ReadOnlyCollection <uint> tokens, HexSpan instructionsSpan, HexSpan ehSpan, bool fatEH) : base(methodProvider, span, tokens) { var buffer = span.Buffer; var pos = span.Start.Position; Flags_Size = new StructField <UInt16FlagsData>("Flags", new UInt16FlagsData(buffer, pos, fatHeaderFlagsFlagInfos)); MaxStack = new StructField <UInt16Data>("MaxStack", new UInt16Data(buffer, pos + 2)); CodeSize = new StructField <UInt32Data>("CodeSize", new UInt32Data(buffer, pos + 4)); LocalVarSigTok = new StructField <TokenData>("LocalVarSigTok", new TokenData(buffer, pos + 8)); Instructions = new StructField <VirtualArrayData <ByteData> >(TinyMethodBodyImpl.InstructionsFieldName, ArrayData.CreateVirtualByteArray(new HexBufferSpan(span.Buffer, instructionsSpan), TinyMethodBodyImpl.InstructionsFieldName)); if (!ehSpan.IsEmpty) { ExceptionHandlerTable ehTable; if (fatEH) { ehTable = new FatExceptionHandlerTableImpl(new HexBufferSpan(buffer, ehSpan)); } else { ehTable = new SmallExceptionHandlerTableImpl(new HexBufferSpan(buffer, ehSpan)); } EHTable = new StructField <ExceptionHandlerTable>("EHTable", ehTable); var paddingSpan = HexBufferSpan.FromBounds(Instructions.Data.Span.End, EHTable.Data.Span.Start); Padding = new StructField <VirtualArrayData <ByteData> >("Padding", ArrayData.CreateVirtualByteArray(paddingSpan)); } var fields = new List <BufferField>(7) { Flags_Size, MaxStack, CodeSize, LocalVarSigTok, Instructions, }; if (Padding is not null) { fields.Add(Padding); } if (EHTable is not null) { fields.Add(EHTable); } Fields = fields.ToArray(); }
// TODO use glinterleavedarrays possibly void CSTrix(ArrayData flags, out int stride, out int ver, out int col, out int tex) { stride = 0; ver = col = tex = -1; if ((flags & ArrayData.Vertex) != 0) { ver = stride; stride += 2; } if ((flags & ArrayData.Color) != 0) { col = stride; stride += 4; } if ((flags & ArrayData.Texture) != 0) { tex = stride; stride += 2; } }
public void SimpleArrayTest() { var cut = new XmlFormatter <ArrayData>(); var data = new ArrayData { Names = new[] { "Alice", "Bob", "Charles" } }; cut.Serialize(data, Filename); var read = cut.Deserialize(Filename); Assert.AreEqual(data.Names.Length, read.Names.Length); for (int i = 0; i < data.Names.Length; i++) { Assert.AreEqual(data.Names[i], read.Names[i], $"Names[{i}]"); } }
private static ArrayData CreateData(char typecode) { ArrayData data; switch (typecode) { case 'c': data = new ArrayData<char>(); break; case 'b': data = new ArrayData<sbyte>(); break; case 'B': data = new ArrayData<byte>(); break; case 'u': data = new ArrayData<char>(); break; case 'h': data = new ArrayData<short>(); break; case 'H': data = new ArrayData<ushort>(); break; case 'l': case 'i': data = new ArrayData<int>(); break; case 'L': case 'I': data = new ArrayData<uint>(); break; case 'f': data = new ArrayData<float>(); break; case 'd': data = new ArrayData<double>(); break; default: throw PythonOps.ValueError("Bad type code (expected one of 'c', 'b', 'B', 'u', 'H', 'h', 'i', 'I', 'l', 'L', 'f', 'd')"); } return data; }
private void SliceNoStep(object value, int start, int stop) { // replace between start & stop w/ values IEnumerator ie = PythonOps.GetEnumerator(value); int length = _data.Length; ArrayData newData = CreateData(_typeCode); for (int i = 0; i < start; i++) { newData.Append(_data.GetData(i)); } while (ie.MoveNext()) { newData.Append(ie.Current); } for (int i = Math.Max(stop, start); i < _data.Length; i++) { newData.Append(_data.GetData(i)); } _data = newData; }
internal void Clear() { _data = CreateData(_typeCode); }
public object this[Slice index] { get { if (index == null) throw PythonOps.TypeError("expected Slice, got None"); int start, stop, step; index.indices(_data.Length, out start, out stop, out step); PythonArray pa = new PythonArray(new string(_typeCode, 1), Type.Missing); if (step < 0) { for (int i = start; i > stop; i += step) { pa._data.Append(_data.GetData(i)); } } else { for (int i = start; i < stop; i += step) { pa._data.Append(_data.GetData(i)); } } return pa; } set { if (index == null) throw PythonOps.TypeError("expected Slice, got None"); PythonArray pa = value as PythonArray; if (pa != null && pa._typeCode != _typeCode) { throw PythonOps.TypeError("bad array type"); } if (index.step != null) { if (Object.ReferenceEquals(value, this)) value = this.tolist(); index.DoSliceAssign(SliceAssign, _data.Length, value); } else { int start, stop, step; index.indices(_data.Length, out start, out stop, out step); if (stop < start) { stop = start; } // replace between start & stop w/ values IEnumerator ie = PythonOps.GetEnumerator(value); ArrayData newData = CreateData(_typeCode); for (int i = 0; i < start; i++) { newData.Append(_data.GetData(i)); } while (ie.MoveNext()) { newData.Append(ie.Current); } for (int i = stop; i < _data.Length; i++) { newData.Append(_data.GetData(i)); } _data = newData; } } }