Constructs a Reflect base class.
@exports ProtoBuf.Reflect.T
@constructor
@abstract
@param {!ProtoBuf.Builder} builder Builder reference
@param {?ProtoBuf.Reflect.T} parent Parent object
@param {string} name Object name
492766
function(builder, parent, name) {

            /**
             * Builder reference.
             * @type {!ProtoBuf.Builder}
             * @expose
             */
            this.builder = builder;

            /**
             * Parent object.
             * @type {?ProtoBuf.Reflect.T}
             * @expose
             */
            this.parent = parent;

            /**
             * Object name in namespace.
             * @type {string}
             * @expose
             */
            this.name = name;

            /**
             * Fully qualified class name
             * @type {string}
             * @expose
             */
            this.className;
        }
385252
function Builder (config) {
  if (!(config instanceof Config)) {
    config = new Config(config)
  }
  this.config = config
  // TODO: check for root.val
  if (!this.config.native.root) {
    // TODO: simplify this set
    this.config.native.set({
      root: {
        val: process.cwd()
      }
    })
  }
}
729840
public function of(string $name, callable $callback = null): BuilderContract
    {
        if (! isset($this->names[$name])) {
            $this->names[$name] = $this->make($callback);
            $this->names[$name]->name = $name;
        }

        return $this->names[$name];
    }
72683
function base(name, predicate) {
  if (typeof name === 'function') {
    predicate = name;
    ({ name } = predicate);
  }

  /* istanbul ignore else */
  if (__DEV__) {
    assert(typeof name === 'string', `base()'s name must be string`);
    assert(
      typeof predicate === 'function',
      `base()'s predicate must be a function`
    );
  }

  const api = this;

  function Base(value, context) {
    if (Context.isRequired(context)) {
      return Context.with(value, Base, context, api);
    }

    return predicate(value)
      ? context.toValue(value, Base)
      : context.valueIsNotOfType(value, Base);
  }

  return decorate(Base, name, base, predicate);
}
591393
function(reflector, property_name) {
        this.reflector = reflector;
        this.name = property_name;
        this.meta = reflector.getMeta().metadata[property_name];

        // If we, for some strange reason don't have metadata, fill it in
        // with some default values.
        if (typeof (this.meta) === 'undefined') {
            this.meta = {
                name        : this.name,
                type        : null,
                visibility  : 'public',
                is_nullable : false,
                is_abstract : false,
                is_read_only: false,
                is_final    : false
            };
        }

        // Attempt to fetch the type by fetching the predefined value.
        // However, only do this for non-nullable types to avoid type
        // mismatching exceptions in setters.
        if (this.meta.type === null && this.meta.is_nullable === false) {
            this.meta.type = typeof (this.reflector.getProto()[this.meta.name]);
        }
    }
1159799
@Nonnull
	public static LLongToSrtFunction longToSrtFunctionFrom(Consumer<LLongToSrtFunctionBuilder> buildingFunction) {
		LLongToSrtFunctionBuilder builder = new LLongToSrtFunctionBuilder();
		buildingFunction.accept(builder);
		return builder.build();
	}
183449
public org.inferred.freebuilder.processor.property.Property.Builder setName(String name) {
    this.name = Objects.requireNonNull(name);
    _unsetProperties.remove(Property.NAME);
    return (org.inferred.freebuilder.processor.property.Property.Builder) this;
  }
345144
function inherit(name, defmessage, abstract, construct) {
        if (typeof name === "object") {
            name.parent = this;
            return create(name);
        }
        return create(name, this, defmessage, abstract, construct);
    }
802022
function ArrayField (array, name, parent) {
  if (!(this instanceof ArrayField)) return new ArrayField(array, name, parent);
  debug('array <%s> being built', name);
  Entry.call(this, array, name, parent);
  this._context = parent._context;
  this._this = parent._this;
  this._currVal = {};

  var data = this._content;
  this._config = {
    size: function () { return 1; }
  };
  if (this._content.length > 0 &&
      this._content[0] === '{{_$config}}') {
    data = this._content.slice(2);
    debug('array <%s> is configured with options <%s>', name, this._content[1]);
    var opts = _.defaults(this._content[1], DEFAULTS);
    if (Array.isArray(opts.size)) {
      this._config.size = function () {
        return _.random(opts.size[0], opts.size[1]);
      };
    } else {
      this._config.size = function () {
        return Number(opts.size);
      };
    }
  }
  this._children = [];
  data.forEach(function (child, index) {
    this._children.push(helpers.build(child, index, this));
    (function (method) {
      var child = this._children[method];
      Object.defineProperty(this._currVal, method, {
        enumerable: true,
        get: function () {
          if (child._currVal === undefined)
            return child.next();
          return child._currVal; // doc and array's currval never empty
        }
      });
    }).call(this, index);
  }, this);

  debug('array <%s> build complete', name);
}
353293
function(parent, protoProps, staticProps) {
  var child;

  // The constructor function for the new subclass is either defined by you
  // (the "constructor" property in your extend definition), or defaulted
  // by us to simply call the parent's constructor.
  if (protoProps && protoProps.hasOwnProperty('constructor')) {
    child = protoProps.constructor;
  } else {
    child = function(){ parent.apply(this, arguments); };
  }

  // Inherit class (static) properties from parent.
  copyProps(child, parent);

  // Set the prototype chain to inherit from parent, without calling
  // parent's constructor function.
  ctor.prototype = parent.prototype;
  child.prototype = new ctor();

  // Add prototype properties (instance properties) to the subclass,
  // if supplied.
  if (protoProps) copyProps(child.prototype, protoProps);

  // Add static properties to the constructor function, if supplied.
  if (staticProps) copyProps(child, staticProps);

  // Correctly set child's 'prototype.constructor'.
  child.prototype.constructor = child;

  // Set a convenience property in case the parent's prototype is needed later.
  child.__super__ = parent.prototype;

  return child;
}
797470
public static Builder name(String name) {
    if (name == null || name.trim().isEmpty()) {
      throw new IllegalArgumentException("Name should be defined.");
    }
    return new Builder(name);
  }
1055387
function Builder (data) {

  if (!(this instanceof Builder)) return new Builder(data);

  debug('new builder', data);

  events.EventEmitter.call(this);

  this.message = Message(data);

}
713402
function(name, observable, oneTime) {
      var property = this.propertyForAttribute(name);
      if (!property) {
        // TODO(sjmiles): this mixin method must use the special form
        // of `super` installed by `mixinMethod` in declaration/prototype.js
        return this.mixinSuper(arguments);
      } else {
        // use n-way Polymer binding
        var observer = this.bindProperty(property, observable, oneTime);
        // NOTE: reflecting binding information is typically required only for
        // tooling. It has a performance cost so it's opt-in in Node.bind.
        if (Platform.enableBindingsReflection && observer) {
          observer.path = observable.path_;
          this._recordBinding(property, observer);
        }
        if (this.reflect[property]) {
          this.reflectPropertyToAttribute(property);
        }
        return observer;
      }
    }
592238
def const_missing(name)
      Attribute::Builder.determine_type(name) or
        Axiom::Types.const_defined?(name) && Axiom::Types.const_get(name) or
        super
    end
1365442
function Builder(baseURL, cfg) {
  if (typeof baseURL == 'object') {
    cfg = baseURL;
    baseURL = null;
  }

  this.loader = null;
  this.resetConfig = function() {};

  this.reset();

  if (baseURL)
    this.config({ baseURL: baseURL });

  // config passed to constructor will
  // be saved for future .reset() calls
  if (typeof cfg == 'object')
    this.config(cfg, true, !!baseURL);
  else if (typeof cfg == 'string')
    this.loadConfigSync(cfg, true, !!baseURL);
}
850315
public Reflector create(Object... args) throws ReflectException {
        Class<?>[] types = getTypes(args);

        try {
            Constructor<?> constructor = type().getDeclaredConstructor(types);
            return with(constructor, args);
        } catch (NoSuchMethodException e) {
            for (Constructor<?> constructor : type().getDeclaredConstructors()) {
                if (match(constructor.getParameterTypes(), types)) {
                    return with(constructor, args);
                }
            }

            throw new ReflectException(e);
        }
    }
1254465
function (parentBuilder, field) {
    if (!dataUtils.isValidStr(field)) throw "Invalid field, should be a string: " + dataUtils.JSONstringify(field);

    /**
     * Ensures a comparison of the field with the value.
     * @param {string} comparator e.g. "$gt", "$gte", etc.
     * @param {*} value
     * @returns {QueryBuilder} the parent Builder. Use .andField()
     * to chain further with this builder.
     */
    this.is = function (comparator, value) {
        return parentBuilder._compare(field, comparator, value);
    };

    /**
     * Ensures that the field matches the given value. This is same
     * as calling matchAll([value]).
     * @param {*} value
     * @returns {QueryBuilder} the parent Builder. Use .andField()
     * to chain further with this builder.
     */
    this.matches = function (value) {
        return parentBuilder._matchesAll(field, [value]);
    };

    /**
     * Ensures that the field matches all the values.
     * @param {Array.<*>} values
     * @returns {QueryBuilder} the parent Builder. Use .andField()
     * to chain further with this builder.
     */
    this.matchesAll = function (values) {
        return parentBuilder._matchesAll(field, values);
    };

    /**
     * Ensures that the field matches at least one of the values.
     * @param {Array.<*>} values
     * @param {boolean} [addToExistingOr=false] If true, this will
     * be added to the existing OR list ($in), if any.
     * @returns {QueryBuilder} the parent Builder. Use .andField()
     * to chain further with this builder.
     */
    this.matchesAny = function (values, addToExistingOr) {
        return parentBuilder._matchesAny(field, values, addToExistingOr);
    };
}