Add the behaviors to sync this property to this virtual field.
969677
public void addPropertiesFieldBehavior(BaseField fldDisplay, String strProperty)
    {
        FieldListener listener = new CopyConvertersHandler(new PropertiesConverter(this, strProperty));
        listener.setRespondsToMode(DBConstants.INIT_MOVE, false);
        listener.setRespondsToMode(DBConstants.READ_MOVE, false);
        fldDisplay.addListener(listener);
        listener = new CopyConvertersHandler(fldDisplay, new PropertiesConverter(this, strProperty));
        this.addListener(listener);
    }
1045806
def _init_and_add_behavior(behavior_hash)
      obj = _load_asset(ASSET_TYPE_BEHAVIOR, behavior_hash[:name])
      unless obj.nil?
        obj.parameters = behavior_hash[:parameters]
        @behavior_objects << obj
      end
    end
1003689
def add_traits(self, **traits):
        """"""
        super(Widget, self).add_traits(**traits)
        for name, trait in traits.items():
            if trait.get_metadata('sync'):
                self.keys.append(name)
                self.send_state(name)
654393
function( behavior ){

            var notify;

            // don't allow duplicates
            if ( this.has( behavior ) ){
                return this;
            }

            behavior.setWorld( this );
            this._behaviors.push( behavior );

            this.emit( 'add:behavior', {
                behavior: behavior
            });

            return this;
        }
1051689
public function syncToMember()
    {
        $member = $this->Member();
        $sync = $this->config()->sync_fields;
        $write = false;

        if (!$member->exists()) {
            return;
        }

        foreach ($this->getChangedFields() as $field => $change) {
            // If this field is a field to sync, and it is different
            // then update member
            if (in_array($field, $sync) && $member->$field != $this->$field) {
                $member->$field = $this->$field;
                $write = true;
            }
        }

        if ($write) {
            $member->write();
        }
    }
84118
public void addProperty(ReadableProperty<R> property) {
        property.addValueChangeListener(changeAdapter);
        properties.add(property);
        updateFromProperties();
    }
572513
public void updateProperties(Map<Object, Object> properties) {
        this.commonProperties = properties;
        try {
            new TCPFactoryConfiguration(properties);
        } catch (ChannelFactoryException e) {
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                Tr.debug(tc, "Unable to consume property updates");
            }
        }
    }
743537
@Override
    public void addProperty(Property property) {
        properties.add(property);
        property.addPropertyChangeListener(this);
        buildModel();
    }
1368200
public void add(Featurable featurable)
    {
        featurables.put(featurable.getFeature(Identifiable.class).getId(), featurable);

        for (final Class<?> type : featurable.getClass().getInterfaces())
        {
            addType(type, featurable);
        }

        for (final Class<? extends Feature> feature : featurable.getFeaturesType())
        {
            final Feature object = featurable.getFeature(feature);
            addType(feature, object);
            for (final Class<?> other : UtilReflection.getInterfaces(feature, Feature.class))
            {
                addType(other, object);
            }
        }
        addType(featurable.getClass(), featurable);
        addSuperClass(featurable, featurable.getClass());
    }
1059734
public void addMetaBeanProperty(MetaBeanProperty mp) {

        MetaProperty staticProperty = establishStaticMetaProperty(mp);
        if (staticProperty != null) {
            staticPropertyIndex.put(mp.getName(), mp);
        } else {

            SingleKeyHashMap propertyMap = classPropertyIndex.getNotNull(theCachedClass);
            //keep field
            CachedField field;
            MetaProperty old = (MetaProperty) propertyMap.get(mp.getName());
            if (old != null) {
                if (old instanceof MetaBeanProperty) {
                    field = ((MetaBeanProperty) old).getField();
                } else if (old instanceof MultipleSetterProperty) {
                    field = ((MultipleSetterProperty)old).getField();
                } else {
                    field = (CachedField) old;
                }
                mp.setField(field);
            }

            // put it in the list
            // this will overwrite a possible field property
            propertyMap.put(mp.getName(), mp);
        }

    }
402331
def attach(self, gui):
        """"""
        super(FeatureView, self).attach(gui)
        self.actions.add(self.increase)
        self.actions.add(self.decrease)
        self.actions.separator()
        self.actions.add(self.clear_channels)
        self.actions.add(self.toggle_automatic_channel_selection)

        gui.connect_(self.on_channel_click)
        gui.connect_(self.on_request_split)
163750
private void addVirtualAccessor(AbstractPojoPropertyDescriptor propertyDescriptor, PojoPropertyAccessor accessor) {

    LOG.trace("adding virtual accessor: {}", accessor);
    propertyDescriptor.putAccessor(accessor);
  }
274265
public void addNewConnective() {

        String fieldName = this.fieldName;
        String fieldType = this.fieldType;
        String factType = this.factType;

        if ( this.connectives == null ) {
            this.connectives = new ConnectiveConstraint[]{ new ConnectiveConstraint( factType,
                                                                                     fieldName,
                                                                                     fieldType ) };
        } else {
            final ConnectiveConstraint[] newList = new ConnectiveConstraint[ this.connectives.length + 1 ];
            for ( int i = 0; i < this.connectives.length; i++ ) {
                newList[ i ] = this.connectives[ i ];
            }
            newList[ this.connectives.length ] = new ConnectiveConstraint( factType,
                                                                           fieldName,
                                                                           fieldType );
            this.connectives = newList;
        }
    }
1362595
function (obj, prop, value) {
                shared.utils.dassert(getTracker(obj) === this);
                this._lastTx = this.tc().addNew(obj, prop, value, this._lastTx);
            }
1345474
def add_props(self,**kwargs):
        
        for kw,val in kwargs.iteritems():
            self.properties[kw] = val
362286
public boolean commit() {
        try {
            setWrongValueMessage(null);
            propInfo.setPropertyValue(target, getValue());
            updateValue();
            return true;
        } catch (Exception e) {
            setWrongValueException(e);
            return false;
        }
    }
525616
protected  <P> void addMapping(K columnKey, ColumnDefinition<K, ?> columnDefinition,  PropertyMeta<T, P> prop) {
		propertyMappingsBuilder.addProperty(columnKey, columnDefinition, prop);
	}