Replaces the contents of self with the contents of other_array, truncating or expanding if necessary. The contents of other_array
 is converted standardized URL Hashes.
556007
def replace( other_array )
      if !other_array.nil?
        converted = other_array.map { |url| convert_remote_url( url ) }
        super( converted )
      else
        super( nil )  
      end
    end
199982
def extend(self, other):
        
        def extend_trans(pipe):
            values = list(other.__iter__(pipe)) if use_redis else other
            len_self = pipe.rpush(self.key, *(self._pickle(v) for v in values))
            if self.writeback:
                for i, v in enumerate(values, len_self - len(values)):
                    self.cache[i] = v

        if self._same_redis(other, RedisCollection):
            use_redis = True
            self._transaction(extend_trans, other.key)
        else:
            use_redis = False
            self._transaction(extend_trans)
1101671
def update(self, other):
        
        if isinstance(other, Properties):
            other = other.defined
        for n, v in other.items():
            self.set(n, v)
        return self
554058
def append(self, other):
        
        self.data.extend(other.data)
        self.height = self.height + other.height
        return self
1303045
def fill(*args, &block)
      ary = self.to_a
      ary.fill *args, &block
      self.replace ary
    end
743283
function (options) {
      options = options || {};
      lazy.extend(options, this.options.excerpt || {});

      var re = /<!--+\s*more\s*--+>/;
      var str = this.content;
      var view = this;

      var link = options.link || '<a id="more"></a>';

      this.content = str.replace(re, function (match, i) {
        view.data.excerpt = str.slice(0, i).trim();
        view.data.more = str.slice(i + match.length).trim() + link;
        return '';
      });
      return this;
    }
528388
def update(self, other, inplace=True):
        
        return self.append(other, inplace=inplace, resize=False)
153401
def extend(self, other):
        
        def extend_trans(pipe):
            values = list(other.__iter__(pipe)) if use_redis else other
            for v in values:
                self._append_helper(v, pipe)

        if self._same_redis(other, RedisCollection):
            use_redis = True
            self._transaction(extend_trans, other.key)
        else:
            use_redis = False
            self._transaction(extend_trans)
513547
def p_ArrayLiteralContent(p):
    '''
    
    '''
    if len(p) < 3:
        p[0] = ArrayLiteralContent(None, p[1])
    else:
        p[0] = ArrayLiteralContent(p[1], p[3])
837229
def extend(self, *args, **kwargs):
        
        if len(args) > 1:
            raise TypeError("extend() takes at most 1 positional "
                            "arguments ({0} given)".format(len(args)))
        other = args[0] if len(args) >= 1 else ()

        if isinstance(other, HTTPHeaderDict):
            for key, val in other.iteritems():
                self.add(key, val)
        elif isinstance(other, Mapping):
            for key in other:
                self.add(key, other[key])
        elif hasattr(other, "keys"):
            for key in other.keys():
                self.add(key, other[key])
        else:
            for key, value in other:
                self.add(key, value)

        for key, value in kwargs.items():
            self.add(key, value)
298010
def merge(self, other, replacements=None):
        

        # TODO: is the current solution not optimal enough?
        for _, item in other._storage.items():  # type: RegionObject
            for so in item.stored_objects:  # type: StoredObject
                if replacements and so.obj in replacements:
                    so = StoredObject(so.start, replacements[so.obj], so.size)
                self._object_mapping[so.obj_id] = so
                self.__store(so, overwrite=False)

        return self
116465
def merge!(other)
      self.class.coerce(other).to_h.each { |name, values| set name, values }
    end
909237
private function parseOriginalContent()
    {
        $content = $this->exists() ? file_get_contents($this->getPath()) : '';
        $this->arrayKeys = JsonFormatter::getArrayKeys($content);
        $this->indent = JsonFormatter::getIndent($content);
    }
1098459
def extend(self, attributes, prefix):
        

        self._contents += [Attribute(attr, prefix) for attr in attributes]
1116054
def update(self, other):
        

        acceptable_models = [ m for m in other._models if set(m.model.keys()) == self.variables ]
        self._models.update(acceptable_models)
        self._eval_exhausted.update(other._eval_exhausted)
        self._max_exhausted.update(other._max_exhausted)
        self._min_exhausted.update(other._min_exhausted)
1244966
def p_ArrayLiteralContentList(p):
    '''
    
    '''
    if len(p) < 3:
        p[0] = ArrayLiteralContentList(None, p[1])
    else:
        p[0] = ArrayLiteralContentList(p[1], p[3])
1061903
private void rehash() {
        int oldCapacity = mTable.length;
        Entry oldSet[] = mTable;

        int newCapacity = oldCapacity * 2 + 1;
        Entry newSet[] = new Entry[newCapacity];

        mModCount++;
        mThreshold = (int)(newCapacity * mLoadFactor);
        mTable = newSet;

        for (int i = oldCapacity ; i-- > 0 ;) {
            for (Entry old = oldSet[i] ; old != null ; ) {
                Entry e = old;
                old = old.mNext;

                // Only copy entry if its value hasn't been cleared.
                if (e.get() == null) {
                    mCount--;
                }
                else {
                    int index = (e.mHash & 0x7FFFFFFF) % newCapacity;
                    e.mNext = newSet[index];
                    newSet[index] = e;
                }
            }
        }
    }