Returns a StorableIndex instance with all the properties reversed.
332130
public StorableIndex<S> reverse() {
        Direction[] directions = mDirections;

        specified: {
            for (int i=directions.length; --i>=0; ) {
                if (directions[i] != Direction.UNSPECIFIED) {
                    break specified;
                }
            }
            // Completely unspecified direction, so nothing to reverse.
            return this;
        }

        directions = directions.clone();
        for (int i=directions.length; --i>=0; ) {
            directions[i] = directions[i].reverse();
        }

        return new StorableIndex<S>(mProperties, directions, mUnique, mClustered, false);
    }
533380
function reverse (arr) {
  const reversedArray = [];
  for (let i = arr.length - 1; i >= 0; i--) {
    reversedArray.push(arr[i]);
  }
  return reversedArray;
}
290242
def _reverse(self):
        
        o = self.copy()
        # Clear ok reversed flag
        o._reversed = not o._reversed

        if o.bits == 8:
            # No need for reversing
            return o.copy()

        if o.is_top:
            # A TOP is still a TOP after reversing
            si = o.copy()
            return si

        else:
            if not o.is_integer:
                # We really don't want to do that... but well, sometimes it just happens...
                logger.warning('Reversing a real strided-interval %s is bad', self)

            # Reversing an integer is easy
            rounded_bits = ((o.bits + 7) // 8) * 8
            list_bytes = [ ]
            si = None

            for i in xrange(0, rounded_bits, 8):
                b = o._unrev_extract(min(i + 7, o.bits - 1), i)
                list_bytes.append(b)

            for b in list_bytes:
                si = b if si is None else si.concat(b)
            si.uninitialized = self.uninitialized
            si._reversed = o._reversed
            return si
569450
def reverse(self):
        
        return Geometry(shapely.ops.transform(lambda x, y: (y, x), self.geometry), crs=self.crs)
1362283
public IntStreamEx reverseSorted() {
        IntUnaryOperator inv = x -> ~x;
        return new IntStreamEx(stream().map(inv).sorted().map(inv), context);
    }
1328827
public OrderAwarePluginRegistry<T, S> reverse() {

		List<T> copy = new ArrayList<>(getPlugins());
		return of(copy, comparator.reversed());
	}
561604
def reverse_dict(self):
        """"""
        self.reserve_paint = dict(zip(self.paint.values(), self.paint.keys()))
890395
def reverse(self):
        
        return BBox((self.min_y, self.min_x, self.max_y, self.max_x), crs=self.crs)
877554
def reversed(self):
        """"""
        new_quad = QuadraticBezier(self.end, self.control, self.start)
        if self._length_info['length']:
            new_quad._length_info = self._length_info
            new_quad._length_info['bpoints'] = (
                self.end, self.control, self.start)
        return new_quad
385971
public WordBuilder<I> reverse() {
        ensureUnlocked();
        int lowIdx = 0, highIdx = length - 1;

        while (lowIdx < highIdx) {
            Object tmp = array[lowIdx];
            array[lowIdx++] = array[highIdx];
            array[highIdx--] = tmp;
        }

        return this;
    }
908518
public function getReverseDiff()
    {
        $diff = new self();

        // columns
        $diff->setFromColumn($this->getToColumn());
        $diff->setToColumn($this->getFromColumn());

        // properties
        $changedProperties = array();
        foreach ($this->getChangedProperties() as $name => $propertyChange) {
            $changedProperties[$name] = array_reverse($propertyChange);
        }
        $diff->setChangedProperties($changedProperties);

        return $diff;
    }
1221483
def _reversedict(d):
    
    return dict(list(zip(list(d.values()), list(d.keys()))))
1139450
public static <C extends Comparable> Ordering<Range<C>> reverseOrderingByLowerEndpoint() {
        Ordering<Range<C>> orderingByLowerEndpoint = orderingByLowerEndpoint();
        return orderingByLowerEndpoint.reverse();
    }
286677
def inverted(self):
        
        out = self.copy()
        out.setInverted(not self.isInverted())
        return out
1605
public static <C extends Comparable> Ordering<Range<C>> reverseOrderingByUpperEndpoint() {
        Ordering<Range<C>> orderingByUpperEndpoint = orderingByUpperEndpoint();
        return orderingByUpperEndpoint.reverse();
    }
649578
def inverted(self):
        '''
        
        '''
        return Instance(input=self.output, output=self.input,
                        annotated_input=self.annotated_output,
                        annotated_output=self.annotated_input,
                        alt_inputs=self.alt_outputs,
                        alt_outputs=self.alt_inputs,
                        source=self.source)
137425
public StrBuilder reverse() {
        if (size == 0) {
            return this;
        }

        final int half = size / 2;
        final char[] buf = buffer;
        for (int leftIdx = 0, rightIdx = size - 1; leftIdx < half; leftIdx++,rightIdx--) {
            final char swap = buf[leftIdx];
            buf[leftIdx] = buf[rightIdx];
            buf[rightIdx] = swap;
        }
        return this;
    }