Get a scope, which is bound to property of the value of this container
@param {string} property_name
@returns {Lava.scope.DataBinding}
169172
function(property_name) {

		if (!(property_name in this._data_bindings_by_property)) {

			this._data_bindings_by_property[property_name] = new Lava.scope.DataBinding(this, property_name);

		}

		return this._data_bindings_by_property[property_name];

	}
578481
public V getVar(String name) {
    ImplicitVar implicit = name != null ? ImplicitVar.of(name) : null;
    if (implicit != null) {
      return getImplicitVar(implicit, true);
    }
    S scope = thisScope();
    while (scope != null) {
      V var = scope.getOwnSlot(name);
      if (var != null) {
        return var;
      }
      // Recurse up the parent Scope
      scope = scope.getParent();
    }
    return null;
  }
460433
public static Object name(Context cx, Scriptable scope, String name)
    {
        Scriptable parent = scope.getParentScope();
        if (parent == null) {
            Object result = topScopeName(cx, scope, name);
            if (result == Scriptable.NOT_FOUND) {
                throw notFoundError(scope, name);
            }
            return result;
        }

        return nameOrFunction(cx, scope, parent, name, false);
    }
846971
function(target, propertyName, eventName) {
		var self = this,
			handler;


		// This is objects that can be bound to with can.bind.
		handler = function () {
			self.updater(self._get(), self.value);
		};
		this._get = function() {
			return getObject(target, propertyName);
		};
		this._set = function(value) {
			// allow setting properties n levels deep, if separated with dot syntax
			var properties = propertyName.split("."),
				leafPropertyName = properties.pop();

			if(properties.length) {
				var targetProperty = getObject(target, properties.join('.'));
				targetProperty[leafPropertyName] = value;
			} else {
				target[propertyName] = value;
			}
		};

		this._on = function(update) {
			eventQueue.on.call(target, eventName || propertyName, handler);
			// Set the cached value
			this.value = this._get();
		};
		this._off = function() {
			return eventQueue.off.call( target, eventName || propertyName, handler);
		};
	}
1180636
public String resolvePropertyValue(final String name, final PropertyScope scope) {
        if (null == scope || scope == PropertyScope.Unspecified) {
            throw new IllegalArgumentException("scope must be specified");
        }
        String value = null;
        if (scope.isInstanceLevel()) {
            if (null != instanceScopeResolver) {
                value = instanceScopeResolver.getProperty(name);
                log.trace("resolvePropertyValue(" + scope + ")(I) " + name + " = " + value);
            }
        }
        if (null != value || scope == PropertyScope.InstanceOnly) {
            log.debug("resolvePropertyValue(" + scope + ") " + name + " = " + value);
            return value;
        }

        if (scope.isProjectLevel()) {
            if (null != projectScopeResolver) {
                value = projectScopeResolver.getProperty(name);
                log.trace("resolvePropertyValue(" + scope + ")(P) " + name + " = " + value);
            }
        }
        if (null != value || scope == PropertyScope.ProjectOnly) {
            log.debug("resolvePropertyValue(" + scope + ") " + name + " = " + value);
            return value;
        }
        if (null != frameworkScopeResolver) {
            if (scope.isFrameworkLevel()) {
                value = frameworkScopeResolver.getProperty(name);
                log.trace("resolvePropertyValue(" + scope + ")(F) " + name + " = " + value);
            }
        }
        log.debug("resolvePropertyValue(" + scope + ") " + name + " = " + value);
        return value;
    }
559490
def get_scope(self, scope_name):
        """"""
        request_url = self._build_url(['Scope', scope_name])
        return self._do_request('GET', request_url)
317788
function(ev, newVal) {
                            scopePropertyUpdating = name;
                            componentScope.attr(name, newVal);
                            scopePropertyUpdating = null;
                        }
1003192
public PropertyData getProperty(String name)
   {
      return properties == null ? null : properties.get(name);
   }
288256
function getScope(identifier) {
            for (let currentNode = identifier; currentNode; currentNode = currentNode.parent) {
                const scope = sourceCode.scopeManager.acquire(currentNode, true);

                if (scope) {
                    return scope;
                }
            }
            return null;
        }
564120
public function get($property_name) {
    if ($property_name === 'entity' && !isset($this->values[$property_name])) {
      $value = $this->values[$property_name] = SKU::loadFromSku($this->values['value'], $this->getLangcode());
      $this->properties[$property_name] = $this->getTypedDataManager()->getPropertyInstance($this, $property_name, $value);
    }
    return parent::get($property_name);
  }
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);
            }
        }
109221
public IScope getScope(String name) {
        IBasicScope child = children.getBasicScope(ScopeType.UNDEFINED, name);
        log.debug("Child of {}: {}", this.name, child);
        if (child != null) {
            if (child instanceof IScope) {
                return (IScope) child;
            }
            log.warn("Requested scope: {} is not of IScope type: {}", name, child.getClass().getName());
        }
        return null;
    }
1257673
public GrProperty getProperty(String propertyName) {
		for (GrProperty prop : getProperties()) {
			if (prop.getName().equals(propertyName))
				return prop;
		}
		return null;
	}
1107384
function get(notation, defaultValue) {
			var value = read(this.scope, notation);
			return undef(value) ? defaultValue : value;
		}
289961
def get_object(self, binding_name, cls):
        
        return self._state.get_object(self, binding_name, cls)
1213579
private void visitBlockScopedName(NodeTraversal t, Node decl, Node nameNode) {
    Scope scope = t.getScope();
    Node parent = decl.getParent();
    // Normalize "let x;" to "let x = undefined;" if in a loop, since we later convert x
    // to be $jscomp$loop$0.x and want to reset the property to undefined every loop iteration.
    if ((decl.isLet() || decl.isConst())
        && !nameNode.hasChildren()
        && (parent == null || !parent.isForIn())
        && inLoop(decl)) {
      Node undefined = createUndefinedNode().srcref(nameNode);
      nameNode.addChildToFront(undefined);
      compiler.reportChangeToEnclosingScope(undefined);
    }

    String oldName = nameNode.getString();
    Scope hoistScope = scope.getClosestHoistScope();
    if (scope != hoistScope) {
      String newName = oldName;
      if (hoistScope.hasSlot(oldName) || undeclaredNames.contains(oldName)) {
        do {
          newName = oldName + "$" + compiler.getUniqueNameIdSupplier().get();
        } while (hoistScope.hasSlot(newName));
        nameNode.setString(newName);
        compiler.reportChangeToEnclosingScope(nameNode);
        Node scopeRoot = scope.getRootNode();
        renameTable.put(scopeRoot, oldName, newName);
      }
      Var oldVar = scope.getVar(oldName);
      scope.undeclare(oldVar);
      hoistScope.declare(newName, nameNode, oldVar.input);
    }
  }
1146782
def generate_binding(a_binding=binding)
      a_binding.local_variables do |local_var|
        a_binding.local_variable_set local_var, nil
      end
      @bound_procs.each_with_index do |bound_proc, index|
        a_binding.local_variable_set "proc_#{index}",  bound_proc
      end
      @bound_constants.each_with_index do |bound_const, index|
        a_binding.local_variable_set "const_#{index}", bound_const
      end
      a_binding
    end