inherit 'data' from parent and override by own values (if any)
434702
function(state) {
      if (state.parent && state.parent.data) {
        state.data = state.self.data = extend({}, state.parent.data, state.data);
      }
      return state.data;
    }
273393
def parent(self, value):
        

        if value is not None:
            assert issubclass(value.__class__, AbstractNode), "'{0}' attribute: '{1}' is not a '{2}' subclass!".format(
                "parent", value, AbstractNode.__class__.__name__)
        self.__parent = value
944142
def data(self, data):
        
        # Descendants should convert the data to the desired type here
        self._data = self._enforceDataType(data)

        #logger.debug("BoolCti.setData: {} for {}".format(data, self))
        enabled = self.enabled
        self.enableBranch(enabled and self.data != self.childrenDisabledValue)
        self.enabled = enabled
77642
function inherits(ctor, superCtor) {
  ctor.super_ = superCtor;
  Object.setPrototypeOf(ctor.prototype, superCtor.prototype);
}
970657
function(data, options) {
            for (var property in data) {
                if (!this.__hasProperty(property.split('.')[0])) {
                    continue;
                }

                var value = data[property];

                if (_.isUndefined(value) || _.isNull(value)) {
                    this.__removePropertyValue(property, options);
                }
                else if (_.isObject(value) && _.isEmpty(value)) {
                    this.__clearPropertyValue(property, options)
                }
                else {
                    this.__setPropertyValue(property, value, options);
                }
            }
            return this;
        }
1100291
function inherits(child, parent) {
  if (!child || !parent) return child;

  var _arr4 = t.INHERIT_KEYS.optional;
  for (var _i4 = 0; _i4 < _arr4.length; _i4++) {
    var key = _arr4[_i4];
    if (child[key] == null) {
      child[key] = parent[key];
    }
  }

  var _arr5 = t.INHERIT_KEYS.force;
  for (var _i5 = 0; _i5 < _arr5.length; _i5++) {
    var key = _arr5[_i5];
    child[key] = parent[key];
  }

  t.inheritsComments(child, parent);

  return child;
}
814704
function (data, defaults, callback) {
  // Flatten everything for ease of use.
  var options = _.defaults({}, data, data.options, defaults)

  callback(null, options)
}
139698
function inheritsFrom(validatedClass, expectedParentClass, errorText) {
  if (
    //fail-fast if it is nil
    !validatedClass ||
    //lenient check whether class directly or indirectly inherits from expected class
    (!(validatedClass.prototype instanceof expectedParentClass) &&
      validatedClass !== expectedParentClass)
  ) {
    throw new ValidationError(
      errorText || `Validated class does not inherit from ${expectedParentClass.name}`
    );
  }
  return validatedClass;
}
1323969
protected function _inherit() {

		$inherited = array_fill_keys($this->_inherited(), []);

		foreach (static::_parents() as $parent) {
			$parentConfig = get_class_vars($parent);

			foreach ($inherited as $key => $value) {
				if (isset($parentConfig["{$key}"])) {
					$val = $parentConfig["{$key}"];
					if (is_array($val)) {
						$inherited[$key] += $val;
					}
				}
			}

			if ($parent === __CLASS__) {
				break;
			}
		}

		foreach ($inherited as $key => $value) {
			if (is_array($this->{$key})) {
				$this->{$key} += $value;
			}
		}
	}
849392
function init() {
      var _this = this;

      /** Store the keys originally belonging to the tag */
      this.one('update', function () {
        _this._ownPropKeys = getAllPropertyNames(_this);
        _this._ownOptsKeys = getAllPropertyNames(_this.opts);
      });
      /** Inherit the properties from parents on each update */
      this.on('update', function () {
        var ignoreProps = ['root', 'triggerDomEvent'];
        getAllPropertyNames(_this.parent)
        // TODO:
        //   Skipping 'triggerDomEvent' is a temporal workaround.
        //   In some cases function on the child would be overriden.
        //   This issue needs more study...
        .filter(function (key) {
          return ! ~_this._ownPropKeys.concat(ignoreProps).indexOf(key);
        }).forEach(function (key) {
          _this[key] = typeof _this.parent[key] != 'function' || _this.parent[key]._inherited ? _this.parent[key] : hook(_this.parent, key);
        });
        getAllPropertyNames(_this.parent.opts).filter(function (key) {
          return ! ~_this._ownOptsKeys.indexOf(key) && key != 'riotTag';
        }).forEach(function (key) {
          _this.opts[key] = typeof _this.parent.opts[key] != 'function' || _this.parent.opts[key]._inherited ? _this.parent.opts[key] : hook(_this.parent, key);
        });
      });
    }
428233
function(source, obj, override) {
      var out;

      // Create extensible object.
      if(override) {
        out = source;
      } else {
        // Create shallow copy of source.
        out = {};
        for(var i in source){
          if(source.hasOwnProperty(i)) {
            out[i] = source[i];
          }
        }
      }

      // Copy properties.
      for(var j in obj) {
        if(obj.hasOwnProperty(j)) {
          out[j] = obj[j];
        }
      }

      return out;
    }
875303
def handle_data(self, data):
        
        if self.current_parent_element['tag'] == '':
            self.cleaned_html += '<p>'
            self.current_parent_element['tag'] = 'p'

        self.cleaned_html += data
383632
function inherits(ctor, sctor) {
		ctor.prototype = Object.create(sctor.prototype);
		ctor._super = sctor;
	}
437735
function inherit(child, parent, options) {
  
  if (options && options.deepExtend) {
    
    //copy all members of parents to this (the child)
    deepExtend(child, parent);
  
  } else {
  
    extend(child, parent);
  
  }
  
  //constructor helper
  function ctor() { this.constructor = child; }
  
  //set ctor prototype to the parent's
  ctor.prototype = parent.prototype;
  
  // Put the parent's prototype in the child's prototype hierarchy
  //
  // i.e. set the child's prototype to new object such that
  //
  // (1) child.prototype.constructor = parent.contructor = child
  // (2) child.prototype.__proto__   = parent.__proto__ 
  //                                 = ctor.prototype 
  //                                 = parent.prototype
  //
  child.prototype = extend(new ctor, child.prototype, {overwrite: true});
  
  //save the parent's prototype for future reference
  child.__super__ = parent;
}
4244
def override(self, value):
        """"""
        if self._value is not value:
            return _ScopedValueOverrideContext(self, value)
        else:
            return empty_context
151126
function (data) {
            this.data = data;
            this.isFulfilled = true;

            if (this.parent === null) {
                return;
            }

            this.parent.dispatch(this.name);
        }
343132
function inherit(child, base, properties) {
    var baseP = base.prototype,
        childP;

    childP = child.prototype = Object.create(baseP);
    childP.constructor = child;
    childP._super = baseP;

    if (properties) {
        assign(childP, properties);
    }
}