Recursively collects all properties of the schema and its ancestors. They are added to the props object.
504797
function collectProperties (schemaObj, props) {
    if (schemaObj.properties) {
      for (var property in schemaObj.properties) {
        if (schemaObj.properties.hasOwnProperty(property)) {
          props[property] = schemaObj.properties[property];
        }
      }
    }
    if (schemaObj.allOf) {
      schemaObj.allOf.forEach(function (parent) {
        collectProperties(parent, props);
      });
    }
  }
195762
function (options) {
                var ret = {};
                for (var k in this.schema) {
                    if (this.schema.hasOwnProperty(k)) {
                        ret[k] = this.getTransformedValue(k);
                    }
                }

                this.set(ret, options);
            }
698150
protected R fetchProperties(TQProperty<?>... props) {
    ((TQRootBean) _root).query().fetch(_name, properties(props));
    return _root;
  }
697854
def property_schema(self, key):
        
        schema = self.__class__.SCHEMA

        # first try plain properties
        plain_schema = schema.get("properties", {}).get(key)
        if plain_schema is not None:
            return plain_schema
        # then try pattern properties
        pattern_properties = schema.get("patternProperties", {})
        for pattern, pattern_schema in pattern_properties.items():
            if match(pattern, key):
                return pattern_schema
        # finally try additional properties (defaults to true per JSON Schema)
        return schema.get("additionalProperties", True)
1262190
def schemas
      @content['components']['schemas'].each_with_object([]) do |(key, value), results|
        schema_content = { name: key, definition: value}
        schema = Openapi2ruby::Openapi::Schema.new(schema_content)
        results << schema unless schema.properties.empty?
      end
    end
498335
function extend(schema) {
	var schemas, extendedSchema;

	if (schema.extends) {
		schemas = [{}, schema].concat(schema.extends);
		extendedSchema = _.defaultsDeep.apply(null, schemas);
		extendedSchema = _.omit(extendedSchema, ['extends']);
		return extendedSchema;
	}
	return schema;
}
932712
public void addAll(Schema sch) {
		fields.putAll(sch.fields);
		if (myFieldSet != null)
			myFieldSet = new TreeSet<String>(fields.keySet());
	}
271588
public void addAllToProperties(Properties props) {
		synchronized (this.confData) {
			for (Map.Entry<String, Object> entry : this.confData.entrySet()) {
				props.put(entry.getKey(), entry.getValue());
			}
		}
	}
1036450
@SuppressWarnings("unchecked")
    public A set(Iterable<Property> props) {
        if (Iterables.isEmpty(props)) {
            return (A) this;
        }
        return copy(delegate.put("data", Property.toArrayNode(props)));
    }
1313822
def find_additional_properties(instance, schema):
    

    properties = schema.get("properties", {})
    patterns = "|".join(schema.get("patternProperties", {}))
    for property in instance:
        if property not in properties:
            if patterns and re.search(patterns, property):
                continue
            yield property
1268904
public Data set(Iterable<Property> props) {
        return !Iterables.isEmpty(props)
               ? new Data(props)
               : this;
    }
97951
private void collectPropertyNamesHelper(
      Set<String> props, Set<PropertyMap> cache) {
    if (!cache.add(this)) {
      return;
    }
    props.addAll(properties.keySet());
    PropertyMap primaryParent = getPrimaryParent();
    if (primaryParent != null) {
      primaryParent.collectPropertyNamesHelper(props, cache);
    }
    for (ObjectType o : getSecondaryParentObjects()) {
      PropertyMap p = o.getPropertyMap();
      if (p != null) {
        p.collectPropertyNamesHelper(props, cache);
      }
    }
  }
1311076
private static void copyProperties(Schema oldSchema, Schema newSchema) {
    Preconditions.checkNotNull(oldSchema);
    Preconditions.checkNotNull(newSchema);

    Map<String, JsonNode> props = oldSchema.getJsonProps();
    copyProperties(props, newSchema);
  }
392833
def _get_inherited_field_types(class_to_field_type_overrides, schema_graph):
    """"""
    inherited_field_type_overrides = dict()
    for superclass_name, field_type_overrides in class_to_field_type_overrides.items():
        for subclass_name in schema_graph.get_subclass_set(superclass_name):
            inherited_field_type_overrides.setdefault(subclass_name, dict())
            inherited_field_type_overrides[subclass_name].update(field_type_overrides)
    return inherited_field_type_overrides
1002629
def schema(self):
        
        schema = _helpers._get_sub_prop(self._properties, ["load", "schema", "fields"])
        if schema is None:
            return
        return [SchemaField.from_api_repr(field) for field in schema]
1239932
@SuppressWarnings("unchecked")
    protected StorableProperty<S>[] gatherAllDataProperties() {
        Map<String, ? extends StorableProperty<S>> map =
            StorableIntrospector.examine(mType).getDataProperties();

        List<StorableProperty<S>> list = new ArrayList<StorableProperty<S>>(map.size());

        for (StorableProperty<S> property : map.values()) {
            if (!property.isDerived()) {
                list.add(property);
            }
        }

        return list.toArray(new StorableProperty[list.size()]);
    }
311865
def schema(self):
        
        if not self.__schema:
            # Inherit context from parent.
            context = getattr(self.parent, 'context', {})
            if isinstance(self.nested, SchemaABC):
                self.__schema = self.nested
                self.__schema.context.update(context)
            else:
                if isinstance(self.nested, type) and issubclass(self.nested, SchemaABC):
                    schema_class = self.nested
                elif not isinstance(self.nested, basestring):
                    raise ValueError(
                        'Nested fields must be passed a '
                        'Schema, not {}.'.format(self.nested.__class__),
                    )
                elif self.nested == 'self':
                    schema_class = self.parent.__class__
                else:
                    schema_class = class_registry.get_class(self.nested)
                self.__schema = schema_class(
                    many=self.many,
                    only=self.only,
                    exclude=self.exclude,
                    context=context,
                    load_only=self._nested_normalized_option('load_only'),
                    dump_only=self._nested_normalized_option('dump_only'),
                )
        return self.__schema