Adds an object properties/methods to the current instance

@public
@param {Object} obj An object whose properties/methods will be copied to the current instance
@returns {Object} this
190767
function (obj) {
                if (obj) {
                    var k;
                    for (k in obj) {
                        if (obj.hasOwnProperty(k)) {
                            this[k] = obj[k];
                        }
                    }
                }
                return this;
            }
589391
function () {
			var newObj = {};
			for (var i = 0; i < arguments.length; i++) {
				var obj = arguments[i];
				for (var key in obj) {
					if (obj.hasOwnProperty(key)) {
						newObj[key] = obj[key];
					}
				}
			}
			return newObj;
		}
1111678
function addSetter(obj, prop, def){
  obj[prop] = function(value){
    if (!arguments.length) return this[prop]
    this[prop] = value
    return this
  }
  prop = '_' + prop // make prop private
  if (def !== undefined) obj[prop] = def
}
1260353
function (obj) {
        
        if (obj == null) {
            obj = new OpenLayers.Layer.Vector(this.name, this.getOptions());
        }

        //get all additions from superclasses
        obj = OpenLayers.Layer.prototype.clone.apply(this, [obj]);

        // copy/set any non-init, non-simple values here
        var features = this.features;
        var len = features.length;
        var clonedFeatures = new Array(len);
        for(var i=0; i<len; ++i) {
            clonedFeatures[i] = features[i].clone();
        }
        obj.features = clonedFeatures;

        return obj;
    }
888609
function clone(object) {
  if (object === null || typeof object != "object") {
    return object;
  }
  const copy = object.constructor();
  for (const attr in object) {
    if (Object.prototype.hasOwnProperty.call(object, attr)) {
      copy[attr] = object[attr];
    }
  }

  return copy;
}
405638
function(obj) {
        if (obj == null) {
            obj = new OpenLayers.Layer.Bing(this.options);
        }
        //get all additions from superclasses
        obj = OpenLayers.Layer.XYZ.prototype.clone.apply(this, [obj]);
        // copy/set any non-init, non-simple values here
        return obj;
    }
375873
def set_object(self, obj, properties):
        """"""
        self._objects.add(obj)
        properties = set(properties)
        self._properties |= properties
        pairs = self._pairs
        for p in self._properties:
            if p in properties:
                pairs.add((obj, p))
            else:
                pairs.discard((obj, p))
1250019
function extend( obj, var_args ) {
        for ( var i = 1; i < arguments.length ; i += 1 ) {
            var other = arguments[ i ];
            for ( var p in other ) {
                var v = Object.getOwnPropertyDescriptor( other, p );
                if ( typeof v == "undefined" || typeof v.value == "undefined" ) {
                    delete obj[ p ];
                } else {
                    Object.defineProperty( obj, p, v );
                }
            }
        }
        return obj;
    }
192534
function clone (obj){
	if(obj == null || typeof(obj) != 'object')
		return obj;

	var temp = obj.constructor();

	for(var key in obj)
		temp[key] = clone(obj[key]);
	return temp;
}
959620
function(obj) {
        if (obj == null) {
            obj = new OpenLayers.Layer.WMTS(this.options);
        }
        //get all additions from superclasses
        obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]);
        // copy/set any non-init, non-simple values here
        return obj;
    }
1131010
function decorate(obj) {
    utils.define(obj, 'merge', function() {
      var args = [].concat.apply([], [].slice.call(arguments));
      var len = args.length;
      var idx = -1;

      while (++idx < len) {
        var val = args[idx];
        if (!utils.isObject(val)) continue;
        if (val.hasOwnProperty('hash')) {
          // shallow clone and delete the `data` object
          val = utils.merge({}, val, val.hash);
          delete val.data;
        }
        utils.merge(obj, val);
      }
      // ensure methods aren't overwritten
      decorate(obj);
      if (obj.hasOwnProperty('app') && obj.hasOwnProperty('options')) {
        decorate(obj.options);
      }
      return obj;
    });

    utils.define(obj, 'get', function(prop) {
      return utils.get(obj, prop);
    });

    utils.define(obj, 'set', function(key, val) {
      return utils.set(obj, key, val);
    });
  }
157859
function ( obj ) {
		var result = [];

		array.each( obj, function ( i ) {
			array.add( result, i );
		});

		return result;
	}
1252183
function (obj, prop, add) {
            return prop in obj ? obj[prop] : (add && (obj[prop] = {}));
        }
1225005
function extend(obj) {
  for(var i=1,len=arguments.length;i<len;i++) {
    var props = arguments[i];
   
    for(var p in props) {
      if(props.hasOwnProperty(p)) {
        obj[p] = props[p];
      }
    }
  }
  return obj;
}
1108659
function(obj) {
       var args = Array.prototype.slice.call(arguments, 1);
       for (var i = 0; i < args.length; i++) {
         var source = args[i];
         if (source) {
           for (var prop in source) {
             obj[prop] = source[prop];
           }
         }
       }
       return obj;
    }
1254043
function (obj) {
        if (obj == null) {
            obj = new OpenLayers.Layer.UTFGrid(this.getOptions());
        }

        // get all additions from superclasses
        obj = OpenLayers.Layer.Grid.prototype.clone.apply(this, [obj]);

        return obj;
    }
87281
function(obj, extObj) {
        this.each(extObj, function(value, key) {
            if (extObj.hasOwnProperty(key)) obj[key] = value
        })
        return obj
    }