C# (CSharp) IronPython.Modules MemoryHolder.AddObject Examples

AddObject() private method

Used to track the lifetime of objects when one memory region depends upon another memory region. For example if you have an array of objects that each have an element which has it's own lifetime the array needs to keep the individual elements alive. The keys used here match CPython's keys as tested by CPython's test_ctypes. Typically they are a string which is the array index, "ffffffff" when from_buffer is used, or when it's a simple type there's just a string instead of the full dictionary - we store that under the key "str".

private AddObject ( object key, object value ) : void
key	object
value	object
return	void

Example #1

File: Pointer.cs Project: nieve/ironruby

 public Pointer(CData value) {
     _object = value; // Keep alive the object, more to do here.
     _memHolder = new MemoryHolder(IntPtr.Size);
     _memHolder.WriteIntPtr(0, value._memHolder);
     _memHolder.AddObject("1", value);
     if (value._objects != null) {
         _memHolder.AddObject("0", value._objects);
     }
 }

Example #2

 public Pointer(CData value)
 {
     _object    = value; // Keep alive the object, more to do here.
     _memHolder = new MemoryHolder(IntPtr.Size);
     _memHolder.WriteIntPtr(0, value._memHolder);
     _memHolder.AddObject("1", value);
     if (value._objects != null)
     {
         _memHolder.AddObject("0", value._objects);
     }
 }

Example #3

File: SimpleCData.cs Project: TerabyteX/ironpython3

 public void __init__(object value) {
     _memHolder = new MemoryHolder(Size);
     NativeType.SetValue(_memHolder, 0, value);
     if (IsString) {
         _memHolder.AddObject("str", value);
     }
 }

Example #4

 public void __init__(object value)
 {
     _memHolder = new MemoryHolder(Size);
     NativeType.SetValue(_memHolder, 0, value);
     if (IsString)
     {
         _memHolder.AddObject("str", value);
     }
 }

Example #5

            public void __init__(CodeContext /*!*/ context, object value)
            {
                if (IsChar && !(value is string t && t.Length == 1))
                {
                    throw PythonOps.TypeError("one character string expected");
                }

                if (IsIntegerType)
                {
                    object __int__ = null;
                    if (value is float || value is double)
                    {
                        throw PythonOps.TypeError("int expected instead of float");
                    }

                    if (!(value is int || value is BigInteger || PythonOps.TryGetBoundAttr(value, "__int__", out __int__)))
                    {
                        throw PythonOps.TypeError("an integer is required");
                    }

                    if (__int__ != null)
                    {
                        value = PythonOps.CallWithContext(context, __int__);
                    }
                }

                if (IsFloatType)
                {
                    object __float__ = null;

                    if (!(value is double || value is float || value is int || value is BigInteger || PythonOps.TryGetBoundAttr(value, "__float__", out __float__)))
                    {
                        throw PythonOps.TypeError("a float is required");
                    }

                    if (value is BigInteger x)
                    {
                        if (x > (BigInteger)double.MaxValue)
                        {
                            throw PythonOps.OverflowError("long int too large to convert to float");
                        }
                    }

                    if (__float__ != null)
                    {
                        value = PythonOps.CallWithContext(context, __float__);
                    }
                }

                _memHolder = new MemoryHolder(Size);
                NativeType.SetValue(_memHolder, 0, value);
                if (IsString)
                {
                    _memHolder.AddObject("str", value);
                }
            }

Example #6

 internal void SetValue(MemoryHolder address, int baseOffset, object value)
 {
     if (_bits == -1)
     {
         object keepAlive = _fieldType.SetValue(address, baseOffset + _offset, value);
         if (keepAlive != null)
         {
             address.AddObject(_index.ToString(), keepAlive);
         }
     }
     else
     {
         SetBitsValue(address, baseOffset, value);
     }
 }

Example #7

File: Field.cs Project: kevinkeeney/ironruby

 internal void SetValue(MemoryHolder address, int baseOffset, object value) {
     if (_bits == -1) {
         object keepAlive = _fieldType.SetValue(address, baseOffset + _offset, value);
         if (keepAlive != null) {
             address.AddObject(_index.ToString(), keepAlive);
         }
     } else {
         SetBitsValue(address, baseOffset, value);
     }
 }

Example #8

File: SimpleCData.cs Project: zuvys/ironpython3

            public void __init__(CodeContext /*!*/ context, object value)
            {
                switch (((SimpleType)NativeType)._type)
                {
                case SimpleTypeKind.Char:
                {
                    if (value is IList <byte> t && t.Count == 1)
                    {
                        value = Bytes.FromByte(t[0]);
                    }
                    else if (value is int i)
                    {
                        try {
                            value = Bytes.FromByte(checked ((byte)i));
                        } catch (OverflowException) {
                            throw PythonOps.TypeError("one character bytes, bytearray or integer expected");
                        }
                    }
                    else
                    {
                        throw PythonOps.TypeError("one character bytes, bytearray or integer expected");
                    }
                }
                break;

                case SimpleTypeKind.WChar: {
                    if (!(value is string t && t.Length == 1))
                    {
                        throw PythonOps.TypeError("one character unicode string expected");
                    }
                }
                break;

                case SimpleTypeKind.SignedInt:
                case SimpleTypeKind.SignedLong:
                case SimpleTypeKind.SignedLongLong:
                case SimpleTypeKind.SignedShort:
                case SimpleTypeKind.UnsignedInt:
                case SimpleTypeKind.UnsignedLong:
                case SimpleTypeKind.UnsignedLongLong:
                case SimpleTypeKind.UnsignedShort: {
                    object __int__ = null;
                    if (value is float || value is double)
                    {
                        throw PythonOps.TypeError("int expected instead of float");
                    }

                    if (!(value is int || value is BigInteger || PythonOps.TryGetBoundAttr(value, "__int__", out __int__)))
                    {
                        throw PythonOps.TypeError("an integer is required");
                    }

                    if (__int__ != null)
                    {
                        value = PythonOps.CallWithContext(context, __int__);
                    }
                }
                break;

                case SimpleTypeKind.Double:
                case SimpleTypeKind.Single: {
                    object __float__ = null;

                    if (!(value is double || value is float || value is int || value is BigInteger || PythonOps.TryGetBoundAttr(value, "__float__", out __float__)))
                    {
                        throw PythonOps.TypeError("a float is required");
                    }

                    if (value is BigInteger x)
                    {
                        if (x > (BigInteger)double.MaxValue)
                        {
                            throw PythonOps.OverflowError("long int too large to convert to float");
                        }
                    }

                    if (__float__ != null)
                    {
                        value = PythonOps.CallWithContext(context, __float__);
                    }
                }
                break;

                default:
                    break;
                }

                _memHolder = new MemoryHolder(Size);
                NativeType.SetValue(_memHolder, 0, value);
                if (IsString)
                {
                    _memHolder.AddObject("str", value);
                }
            }