Example #1
0
        /// <summary>
        /// construct as a copy of the list
        /// </summary>
        /// <param name="list"></param>
        public VectorOfFloat(List <float> list)
        {
            var arr = list.ToArray();

            _ptr = Invoke.std_vector_float_ctor_count(arr.Length);

            var dptr = (float *)Data;

            for (var i = 0; i < arr.Length; i++)
            {
                dptr[i] = arr[i];
            }
        }
Example #2
0
        public IEnumerable <KeyValuePair <uint, uint> > EqualRange(uint key)
        {
            using (var begin = new Iterator())
                using (var end = new Iterator())
                {
                    Invoke.std_multimap_uintanduint_equal_range(_ptr, key, begin, end);

                    for (; !begin.Equals(end); begin.Increment())
                    {
                        yield return(new KeyValuePair <uint, uint>(begin.Key, begin.Value));
                    }
                }
        }
Example #3
0
        /// <summary>
        /// construct as a copy of the list
        /// </summary>
        /// <param name="list"></param>
        public VectorOfXYZ(List <PointXYZ> list)
        {
            var arr = list.ToArray();

            _ptr = Invoke.std_vector_xyz_ctor_count(arr.Length);

            var dptr = (PointXYZ *)Data;

            for (var i = 0; i < arr.Length; i++)
            {
                dptr[i] = arr[i];
            }
        }
Example #4
0
        /// <summary>
        /// construct as a copy of the list
        /// </summary>
        /// <param name="list"></param>
        public VectorOfNormal(List <Normal> list)
        {
            var arr = list.ToArray();

            _ptr = Invoke.std_vector_normal_ctor_count(arr.Length);

            var dptr = (Normal *)Data;

            for (var i = 0; i < arr.Length; i++)
            {
                dptr[i] = arr[i];
            }
        }
Example #5
0
        /// <summary>
        /// construct as a copy of the list
        /// </summary>
        /// <param name="list"></param>
        public VectorOfByte(List <byte> list)
        {
            var arr = list.ToArray();

            _ptr = Invoke.std_vector_byte_ctor_count(arr.Length);

            var dptr = (byte *)Data;

            for (var i = 0; i < arr.Length; i++)
            {
                dptr[i] = arr[i];
            }
        }
Example #6
0
 public override void Insert(int index, PointXYZ item)
 => Invoke.std_vector_xyz_insert(_ptr, (IntPtr)index, item);
Example #7
0
 public override void Add(PointXYZ value)
 => Invoke.std_vector_xyz_add(_ptr, value);
Example #8
0
 public override void Add(uint value)
 => Invoke.std_vector_uint_add(_ptr, value);
Example #9
0
 public override void Clear() => Invoke.std_vector_normal_clear(_ptr);
Example #10
0
 public VectorOfByte()
 {
     _ptr = Invoke.std_vector_byte_ctor();
 }
Example #11
0
 public override void Clear() => Invoke.std_vector_byte_clear(_ptr);
Example #12
0
 public override void Insert(int index, float item)
 => Invoke.std_vector_float_insert(_ptr, (IntPtr)index, item);
Example #13
0
 public override void Clear() => Invoke.std_vector_float_clear(_ptr);
Example #14
0
 public override void At(int idx, ref Normal value)
 {
     Invoke.std_vector_normal_at(_ptr, (UIntPtr)idx, ref value);
 }
Example #15
0
 public VectorOfNormal(int count)
 {
     _ptr = Invoke.std_vector_normal_ctor_count(count);
 }
Example #16
0
 public VectorOfNormal()
 {
     _ptr = Invoke.std_vector_normal_ctor();
 }
Example #17
0
 public override void Insert(int index, Normal item)
 => Invoke.std_vector_normal_insert(_ptr, (IntPtr)index, item);
Example #18
0
 public VectorOfXYZ()
 {
     _ptr = Invoke.std_vector_xyz_ctor();
 }
Example #19
0
 public VectorOfXYZ(int count)
 {
     _ptr = Invoke.std_vector_xyz_ctor_count(count);
 }
Example #20
0
 public VectorOfFloat()
 {
     _ptr = Invoke.std_vector_float_ctor();
 }
Example #21
0
 public override void At(int idx, ref PointXYZ value)
 {
     Invoke.std_vector_xyz_at(_ptr, (UIntPtr)idx, ref value);
 }
Example #22
0
 public VectorOfFloat(int count)
 {
     _ptr = Invoke.std_vector_float_ctor_count(count);
 }
Example #23
0
 public override void Insert(int index, byte item)
 => Invoke.std_vector_byte_insert(_ptr, (IntPtr)index, item);
Example #24
0
 public override void Resize(int size)
 => Invoke.std_vector_byte_resize(_ptr, size);
Example #25
0
 public VectorOfByte(int count)
 {
     _ptr = Invoke.std_vector_byte_ctor_count(count);
 }
Example #26
0
 public override void Add(Normal value)
 => Invoke.std_vector_normal_add(_ptr, value);
Example #27
0
 public override void At(int idx, ref byte value)
 {
     Invoke.std_vector_byte_at(_ptr, (UIntPtr)idx, ref value);
 }
Example #28
0
 public override void At(int idx, ref float value)
 {
     Invoke.std_vector_float_at(_ptr, (UIntPtr)idx, ref value);
 }
Example #29
0
 public override void Add(byte value)
 => Invoke.std_vector_byte_add(_ptr, value);
Example #30
0
 public override void Add(float value)
 => Invoke.std_vector_float_add(_ptr, value);