Set/Get bindable data.
@memberof WTag
519756
function(name, value) {
            var data = this.findDataBinding(name);
            if (typeof value === 'undefined') {
                return data[0];
            }
            if (value !== data[0]) {
                data[0] = value;
                this.fireData(data);
            }
        }
707821
private static function Bind()
	{
		ValueProxy::$conv_t = array_fill( 0, ValueProxy::TYPES_MAX, 0 );
		for ( $k = 0; $k < ValueProxy::TYPES_MAX; $k++ )
		{
			ValueProxy::$conv_t[ $k ] = array_fill( 0, ValueProxy::TYPES_MAX, -2 );
		}

		$list = array_values( ValueProxy::$valueFactory );

		foreach ( $list as /** @var ValueProxyFactory $curr */ $curr )
		{
			foreach ( $list as /** @var ValueProxyFactory $curr2 */ $curr2 )
			{
				if ( $curr == $curr2 )
					ValueProxy::$conv_t[ $curr->GetValueCode() ][ $curr2->GetValueCode() ] = 0;
				else
					ValueProxy::$conv_t[ $curr->GetValueCode() ][ $curr2->GetValueCode() ] = $curr->Compare( $curr2 );
			}
		}
	}
467991
public function setData($data)
	{
		if( is_null($data) )
		{
			$data = [];
		}

		if( $data instanceof stdClass )
		{
			$data = [$data];
		}

		if( is_array($data) )
		{
			$data = $this->checkItems($data);
			$this->data = $data;
		}

		$this->data = (array) $data;

		if(empty($this->type) && ! empty($this->data[0]))
		{
			$this->type = $this->data[0]->getType();
		}
	}
1195018
function setData(el, attr, val, prefix) {
    if (prefix === undefined) {
      prefix = 'wookmark-';
    }
    el.setAttribute('data-' + prefix + attr, val);
  }
812526
protected function bind()
    {
        $variables = array();

        // Bind each field
        while ($field = $this->metadata->fetch_field()) {
            $this->columns[] = $field->name;
            $this->types[$field->name] = $field->type;
            // Note that while boundValues isn't initialised at this point,
            // later calls to $this->statement->fetch() Will populate
            // $this->boundValues later with the next result.
            $variables[] = &$this->boundValues[$field->name];
        }

        $this->bound = true;
        $this->metadata->free();

        // Buffer all results
        $this->statement->store_result();

        call_user_func_array(array($this->statement, 'bind_result'), $variables);
    }
550375
function set($data) {
		if ($data instanceof Row) {
			$this->row->__set($data->getTable()->getName() . "_id", $data->id);
			$this->row->__unset($this->name);
			return $this;
		}
		if ($data instanceof Cell) {
			$data = $data->get();
		}
		parent::set($data);
		$this->dirty = true;
		return $this;
	}
837941
function () {
            this.$BindableWidget.initWidget.call(this);

            var bindings = this._cfg.bind;
            var isBound = false;

            if (bindings.visible) {
                var visible = this._transform(bindings.visible.transform, bindings.visible.inside[bindings.visible.to], "toWidget");
                if (visible === true) {
                    this.show();
                }
                isBound = true;
            }
            if (!isBound) {
                this.$logWarn(this.BINDING_NEEDED, [this.$class, "visible"]);
            }
        }
1123917
protected function setData()
    {
        // If it's already an array of arrays, we're good to go
        if (is_array(reset($this->data))) {
            return $this->setArrayOfArraysData();
        }

        $column_width = $this->getColumnWidth($this->data);
        $row_count    = $this->getMaxRows($column_width);

        return array_chunk($this->data, $row_count);
    }
1207507
public function bind($data=null)
	{
		if (is_object($data))
		{
			$res = $this->_tbl->bind($data);

			if ($res)
			{
				$properties = $this->_tbl->getProperties();
				foreach (get_object_vars($data) as $key => $property)
				{
					if (!array_key_exists($key, $properties))
					{
						$this->_tbl->set('__' . $key, $property);
					}
				}
			}
		}
		else if (is_array($data))
		{
			$res = $this->_tbl->bind($data);

			if ($res)
			{
				$properties = $this->_tbl->getProperties();
				foreach (array_keys($data) as $key)
				{
					if (!array_key_exists($key, $properties))
					{
						$this->_tbl->set('__' . $key, $data[$key]);
					}
				}
			}
		}
		else
		{
			$this->_logError(
				__CLASS__ . '::' . __FUNCTION__ . '(); ' . \Lang::txt('Data must be of type object or array. Type given was %s', gettype($data))
			);
			throw new \InvalidArgumentException(\Lang::txt('Data must be of type object or array. Type given was %s', gettype($data)));
		}

		return $res;
	}
1058415
function bind(property, options, preserveContext, shouldDisplay, valueNormalizer, childProperties) {
      var data = options.data;
      var fn = options.fn;
      var inverse = options.inverse;
      var view = data.view;
      var normalized, observer, i;

      // we relied on the behavior of calling without
      // context to mean this === window, but when running
      // "use strict", it's possible for this to === undefined;
      var currentContext = this || window;

      normalized = normalizePath(currentContext, property, data);

      if (data.insideGroup) {
        observer = function() {
          while (view._contextView) {
            view = view._contextView;
          }
          run.once(view, 'rerender');
        };

        var template, context;
        var result = handlebarsGet(currentContext, property, options);

        result = valueNormalizer ? valueNormalizer(result) : result;

        context = preserveContext ? currentContext : result;
        if (shouldDisplay(result)) {
          template = fn;
        } else if (inverse) {
          template = inverse;
        }

        template(context, { data: options.data });
      } else {
        var viewClass = _HandlebarsBoundView;
        var viewOptions = {
          preserveContext: preserveContext,
          shouldDisplayFunc: shouldDisplay,
          valueNormalizerFunc: valueNormalizer,
          displayTemplate: fn,
          inverseTemplate: inverse,
          path: property,
          pathRoot: currentContext,
          previousContext: currentContext,
          isEscaped: !options.hash.unescaped,
          templateData: options.data,
          templateHash: options.hash,
          helperName: options.helperName
        };

        if (options.isWithHelper) {
          viewClass = WithView;
        }

        // Create the view that will wrap the output of this template/property
        // and add it to the nearest view's childViews array.
        // See the documentation of Ember._HandlebarsBoundView for more.
        var bindView = view.createChildView(viewClass, viewOptions);

        view.appendChild(bindView);

        observer = function() {
          run.scheduleOnce('render', bindView, 'rerenderIfNeeded');
        };
      }

      // Observes the given property on the context and
      // tells the Ember._HandlebarsBoundView to re-render. If property
      // is an empty string, we are printing the current context
      // object ({{this}}) so updating it is not our responsibility.
      if (typeof this === 'object' && normalized.path !== '') {
        view.registerObserver(normalized.root, normalized.path, observer);
        if (childProperties) {
          for (i=0; i<childProperties.length; i++) {
            view.registerObserver(normalized.root, normalized.path+'.'+childProperties[i], observer);
          }
        }
      }
    }
1253090
function BindableCollection (source) {
  BindableObject.call(this, this);
  this.source = source || [];
  this._updateInfo();
  this.bind("source", _.bind(this._onSourceChange, this));
}
1221174
function () {
            this.$Element.initWidget.call(this);
            this.setOptions();

            var newIndex = this.getSelectedIndexFromBindings();
            if (newIndex != null) {
                this._domElt.selectedIndex = newIndex;
            }
            this.initDisabledWidgetAttribute();

            this.__updateDataModel();
        }
784629
function () {
            var bindings = this._cfg.bind;
            var binding = bindings.disabled;
            if (binding) {
                var newValue = this._transform(binding.transform, binding.inside[binding.to], "toWidget");
                if (ariaUtilsType.isBoolean(newValue)) {
                    this._domElt.disabled = newValue;
                } else {
                    ariaUtilsJson.setValue(binding.inside, binding.to, this._domElt.disabled);
                }
            }
        }
1212719
protected function bindData(&$parent, $data)
  {
    if ( is_object($data) ){
      $data = get_object_vars($data);
    }
    else {
      $data = (array) $data;
    }
    
    foreach($data as $k => $v){
      if ( (is_array($v) && ArrayHelper::isAssociative($v)) || is_object($v) ){
        $parent->$k = new \stdClass;
        $this->bindData($parent->$k, $v);
      }
      else {
        $parent->$k = $v;
      }
    }
  }
665402
def data
      templates = @templates.deep_clone

      templates.each_pair do |name, value|
        if value['bindings']
          value['bindings'].each_pair do |number, binding|
            value['bindings'][number] = binding.map { |code| eval(code) }
          end
        end
      end

      templates
    end
477685
private void serializeBinds(Map<String, ParameterBindingDTO> bindValues) throws BindException
  {
    List<ColumnTypeDataPair> columns = getColumnValues(bindValues);
    List<String[]> rows = buildRows(columns);
    writeRowsToCSV(rows);
  }
821254
private function bind()
    {
        $this->app->bind(
            'League\Fractal\Manager',
            function () {
                $manager = new Manager();
                $manager->setSerializer(new ArraySerializer());
                return $manager;
            }
        );
    }