Bind the field descriptor to the owner once the target is defined.
353331
def LateBind(self, target=None):
    """"""
    self.type = target
    self._GetPrimitiveEncoder()

    # Now re-add the descriptor to the owner protobuf.
    self.late_bound = False
    self.owner.AddDescriptor(self)
400847
public void setOwner(ListenerOwner owner)
    {
        super.setOwner(owner);
        if (owner == null)
            return;
        if (m_recordMain != null)
        {   // If they are using the main record, then make sure the key area is correct.
            ReferenceField fieldThisRecord = this.getOwner().getReferenceField(m_recordMain);
            if (fieldThisRecord != null)
                if (fieldThisRecord.getReferenceRecord(null, false) == null)
                    fieldThisRecord.setReferenceRecord(m_recordMain);   // Make sure these are linked
            this.getOwner().setKeyArea(fieldThisRecord);
            // Listen carefully:
            // If the main record belongs to another screen and the screen is closed,
            // do not change the sub-field.
            if (fieldThisRecord != null)
                if (this.getOwner().getRecordOwner() != null)
                    if (m_recordMain.getRecordOwner() != null)
                        if (this.getOwner().getRecordOwner() != m_recordMain.getRecordOwner())
                            fieldThisRecord.addListener(new InitIfSubFieldHandler(null));
        }
        else if (m_fldThisFile == null)
        {
            if (m_strKeyName == null)
                m_strKeyName = this.getOwner().getKeyArea().getKeyName();
            if (m_strKeyName != null)
            {
            	this.getOwner().setKeyArea(m_strKeyName);
            	if (m_fldMainFile != null)
            		m_fldThisFile = this.getOwner().getKeyArea().getField(0);
            	if (m_fldMainFile2 != null)
            		m_fldThisFile2 = this.getOwner().getKeyArea().getField(1);
            	if (m_fldMainFile3 != null)
            		m_fldThisFile3 = this.getOwner().getKeyArea().getField(2);
            }
        }
    }
821732
public void init(BaseField field, String targetFieldName, BaseField fldTarget)
    {
        super.init(field);

        m_bDisableTarget = false;
        this.targetFieldName = targetFieldName;
        m_fldTarget = fldTarget;
    }
330802
public void setOwner(ListenerOwner owner)
    {
        super.setOwner(owner);
        if (this.getOwner() == null)
            return;
        if (m_fldDest.getRecord() != this.getOwner())  // If field is not in this file, remember to remove it
            m_fldDest.addListener(new FieldRemoveBOnCloseHandler(this));
        if (m_fldSource != null) if (m_fldSource.getRecord() != this.getOwner()) if (m_fldSource.getRecord() != m_fldDest.getRecord())
            m_fldSource.addListener(new FieldRemoveBOnCloseHandler(this));
        if ((this.getOwner().getEditMode() == DBConstants.EDIT_CURRENT) || (this.getOwner().getEditMode() == DBConstants.EDIT_IN_PROGRESS))
            if (m_bMoveOnValid)
                this.moveTheData(DBConstants.DISPLAY, DBConstants.INIT_MOVE);  // Do trigger a record change.
        if (this.getOwner().getEditMode() == DBConstants.EDIT_ADD)
            if (m_bMoveOnNew)
                this.moveTheData(DBConstants.DISPLAY, DBConstants.INIT_MOVE);  // Do trigger a record change.
    }
932658
public <D, V> void iget(FieldId<D, ? extends V> fieldId, Local<V> target, Local<D> instance) {
        addInstruction(new ThrowingCstInsn(Rops.opGetField(target.type.ropType), sourcePosition,
                RegisterSpecList.make(instance.spec()), catches, fieldId.constant));
        moveResult(target, true);
    }
1229166
public static void set(Object target, Field field, String fieldVal)
    {
        PropertyAccessor<?> accessor = PropertyAccessorFactory.getPropertyAccessor(field);
        Object value = accessor.fromString(target.getClass(), fieldVal);
        set(target, field, value);
    }
62047
public void bind(Object newValue)
    {
    	if (getValue() == null)
    	{
    		setValue(newValue);
    	}	
    	else
    	{
    		setValue2(newValue);
    		setBound(true); 		
    	}
    }
907048
def _bind_field(self, field_name, field_obj):
        
        try:
            if field_name in self.load_only:
                field_obj.load_only = True
            if field_name in self.dump_only:
                field_obj.dump_only = True
            field_obj._bind_to_schema(field_name, self)
            self.on_bind_field(field_name, field_obj)
        except TypeError:
            # field declared as a class, not an instance
            if (isinstance(field_obj, type) and
                    issubclass(field_obj, base.FieldABC)):
                msg = ('Field for "{}" must be declared as a '
                       'Field instance, not a class. '
                       'Did you mean "fields.{}()"?'
                       .format(field_name, field_obj.__name__))
                raise TypeError(msg)
906592
def bind_target(self, target, ctx=None):
        

        # process self _bind_target
        result = self._bind_target(target=target, ctx=ctx)

        # fire on bind target event
        self.on_bind_target(target=target, ctx=ctx)

        return result
1153802
def bind(self, form):
        """"""
        field = self.field(default=self.default, **self.field_kwargs)
        form._fields[self.name] = field.bind(form, self.name, prefix=form._prefix)
244781
function bindClass(target: DecoratorTarget): DecoratorTarget {
  const proto = target.prototype;

  Object.getOwnPropertyNames(proto).forEach((name) => {
    if (name.match(/^(on|handle)[A-Z]/)) {
      Object.defineProperty(
        proto,
        name,
        bindMethod(proto, name, Object.getOwnPropertyDescriptor(proto, name)),
      );
    }
  });

  return target;
}
1023454
def owners(self, value):
        """"""
        warnings.warn(
            _ASSIGNMENT_DEPRECATED_MSG.format("owners", OWNER_ROLE), DeprecationWarning
        )
        self[OWNER_ROLE] = value
117094
protected void onVisitFieldInsn(int opcode, String owner, String name, String descriptor) {
        super.visitFieldInsn(opcode, owner, name, descriptor);
    }
258683
def bind(self, field_name, parent):
        
        super(TranslatedFieldsField, self).bind(field_name, parent)

        # Expect 1-on-1 for now. Allow using source as alias,
        # but it should not be a dotted path for now
        related_name = self.source or field_name

        # This could all be done in __init__(), but by moving the code here,
        # it's possible to auto-detect the parent model.
        if self.shared_model is not None and self.serializer_class is not None:
            return

        # Fill in the blanks
        if self.serializer_class is None:
            if self.shared_model is None:
                # Auto detect parent model
                from .serializers import TranslatableModelSerializer
                if not isinstance(parent, TranslatableModelSerializer):
                    raise TypeError("Expected 'TranslatableModelSerializer' as serializer base class")
                if not issubclass(parent.Meta.model, TranslatableModel):
                    raise TypeError("Expected 'TranslatableModel' for the parent model")

                self.shared_model = parent.Meta.model

            # Create serializer based on shared model.
            translated_model = self.shared_model._parler_meta[related_name]
            self.serializer_class = create_translated_fields_serializer(
                self.shared_model, related_name=related_name,
                meta={'fields': translated_model.get_translated_fields()}
            )
        else:
            if not issubclass(self.serializer_class.Meta.model, TranslatedFieldsModel):
                raise TypeError("Expected 'TranslatedFieldsModel' for the serializer model")
958153
def _assign_to_field(obj, name, val):
    ''
    target = getattr(obj, name)

    if isinstance(target, containers.RepeatedScalarFieldContainer):
        target.append(val)
    elif isinstance(target, containers.RepeatedCompositeFieldContainer):
        target = target.add()
        target.CopyFrom(val)
    elif isinstance(target, (int, float, bool, str, bytes)):
        setattr(obj, name, val)
    elif isinstance(target, message.Message):
        target.CopyFrom(val)
    else:
        raise RuntimeError("Unsupported type: {}".format(type(target)))
912509
public void bind() throws Throwable
   {
      if (name == null)
         throw new IllegalArgumentException("Name is null");

      if (obj == null)
         throw new IllegalArgumentException("Obj is null");

      if (trace)
         log.trace("Binding " + obj.getClass().getName() + " under " + name);

      Properties properties = new Properties();
      properties.setProperty(Context.PROVIDER_URL, jndiProtocol + "://" + jndiHost + ":" + jndiPort);
      Context context = new InitialContext(properties);

      try
      {
         String className = obj.getClass().getName();
         Reference ref = new Reference(className,
                                       new StringRefAddr("class", className),
                                       JndiBinder.class.getName(),
                                       null);
         ref.add(new StringRefAddr("name", name));

         objs.put(name, obj);

         Util.bind(context, name, ref);

         if (log.isDebugEnabled())
            log.debug("Bound " + obj.getClass().getName() + " under " + name);
      }
      finally
      {
         if (context != null)
         {
            try
            {
               context.close();
            }
            catch (NamingException ne)
            {
               // Ignore
            }
         }
      }
   }
369610
def bind(self, name):
        
        return _BoundColumnDescr(
            dtype=self.dtype,
            missing_value=self.missing_value,
            name=name,
            doc=self.doc,
            metadata=self.metadata,
        )