Skips over the next object and all its children.
518261
boolean skipObject()
    throws IOException
  {
    int ch = read();
    int len;
    
    switch (ch) {
     // inline string (1 byte)
    case 0x00: case 0x01: case 0x02: case 0x03:
    case 0x04: case 0x05: case 0x06: case 0x07:
    case 0x08: case 0x09: case 0x0a: case 0x0b:
    case 0x0c: case 0x0d: case 0x0e: case 0x0f:
      
    case 0x10: case 0x11: case 0x12: case 0x13:
    case 0x14: case 0x15: case 0x16: case 0x17:
    case 0x18: case 0x19: case 0x1a: case 0x1b:
    case 0x1c: case 0x1d: case 0x1e: case 0x1f:
      skip(ch - 0x00);
      return true;
      
      // inline binary (1 byte)
    case 0x20: case 0x21: case 0x22: case 0x23:
    case 0x24: case 0x25: case 0x26: case 0x27:
    case 0x28: case 0x29: case 0x2a: case 0x2b:
    case 0x2c: case 0x2d: case 0x2e: case 0x2f:
      skip(ch - 0x20);
      return true;
      
      // string (1 byte)
    case 0x30: case 0x31: case 0x32: case 0x33:
      len = 256 * (ch - 0x30) + read();
      skip(len);
      return true;
      
      // binary (1 byte)
    case 0x34: case 0x35: case 0x36: case 0x37:
      len = 256 * (ch - 0x34) + read();
      skip(len);
      return true;
      
      // 0x38-0x3b are reserved
      
      // long three-byte
    case 0x3c: case 0x3d: case 0x3e: case 0x3f:
      skip(2);
      return true;
      
      // 0x40 is reserved
      
      // binary non-tail chunk
    case 0x41:
      len = readShort();
      skip(len);
      return skipObject();
      
      // binary tail chunk
    case 0x42:
      len = readShort();
      skip(len);
      return true;
      
      // class def
    case 0x43:
      scanObjectDef();
      return skipObject();
      
      // 64-bit double
    case 0x44:
      skip(8);
      return true;
      
      // error marker
    case 0x45:
      throw new IllegalStateException("Invalid Hessian bytecode 'E'");
      
      // false
    case 0x46:
      return true;
      
      // ext type (fixed int)
    case 0x47:
      skipObject();
      skipObject();
      return true;
      
    case 0x48: { // untyped map 'H'
      skipMap();
      return true;
    }
      
      // 32-bit int
    case 0x49:
      skip(4);
      return true;
      
      // 64-bit date
    case 0x4a:
      skip(8);
      return true;
      
      // 32-bit date
    case 0x4b:
      skip(4);
      return true;
      
      // 64-bit long
    case 0x4c:
      skip(8);
      return true;
      
    case 0x4d: { // typed map 'M'
      skipObject();
      skipMap();
      return true;
    }
      
      // null
    case 0x4e:
      return true;
      
    case 0x4f: // object instance
      {
        int type = scanInt();
        String []def = _classDefs.get(type);
        len = def.length - 1;
        for (int i = 0; i < len; i++) {
          skipObject();
        }
        return true;
      }
      
      // ext type (named)
    case 0x50:
      skipObject();
      skipObject();
      return true;
      
      // backref
    case 0x51:
      skipObject();
      return true;
      
      // string non-tail chunk
    case 0x52:
      len = readShort();
      skip(len);
      return skipObject();
      
      // string tail chunk
    case 0x53:
      len = readShort();
      skip(len);
      return true;
      
      // true
    case 0x54:
      return true;
      
      // typed variable list
    case 0x55:
      readType();
      while (skipObject()) {
      }
      return true;
      
      // typed fixed list
    case 0x56:
      readType();
      len = scanInt();
      for (int i = 0; i < len; i++) {
        skipObject();
      }
      return true;
      
      // untyped variable list
    case 0x57:
      while (skipObject()) {
      }
      return true;
      
      // untyped fixed list
    case 0x58:
      len = scanInt();
      for (int i = 0; i < len; i++) {
        skipObject();
      }
      return true;
      
      // 32-bit long
    case 0x59:
      skip(4);
      return true;
      
    case 0x5a: // 'Z' end
      return false;
      
      // 0.0, 1.0
    case 0x5b: case 0x5c:
      return true;
      
      // (double) b0
    case 0x5d:
      skip(1);
      return true;
      
      // (double) b1 b0
    case 0x5e:
      skip(2);
      return true;
      
      // (double) int
    case 0x5f:
      return skipObject();
      
      // object instance
    case 0x60: case 0x61: case 0x62: case 0x63:
    case 0x64: case 0x65: case 0x66: case 0x67:
    case 0x68: case 0x69: case 0x6a: case 0x6b:
    case 0x6c: case 0x6d: case 0x6e: case 0x6f:
    {
      int type = ch - 0x60;
      String []def = _classDefs.get(type);
      len = def.length - 1;
      for (int i = 0; i < len; i++) {
        skipObject();
      }
      return true;
    }

      // direct fixed typed list
    case 0x70: case 0x71: case 0x72: case 0x73:
    case 0x74: case 0x75: case 0x76: case 0x77:
      skipObject();
      len = ch - 0x70;
      for (int i = 0; i < len; i++) {
        skipObject();
      }
      return true;
      
      // direct fixed untyped list
    case 0x78: case 0x79: case 0x7a: case 0x7b:
    case 0x7c: case 0x7d: case 0x7e: case 0x7f:
      len = ch - 0x78;
      for (int i = 0; i < len; i++) {
        skipObject();
      }
      return true;
      
      // int single-byte
    case 0x80: case 0x81: case 0x82: case 0x83:
    case 0x84: case 0x85: case 0x86: case 0x87:
    case 0x88: case 0x89: case 0x8a: case 0x8b:
    case 0x8c: case 0x8d: case 0x8e: case 0x8f:
      
    case 0x90: case 0x91: case 0x92: case 0x93:
    case 0x94: case 0x95: case 0x96: case 0x97:
    case 0x98: case 0x99: case 0x9a: case 0x9b:
    case 0x9c: case 0x9d: case 0x9e: case 0x9f:
      
    case 0xa0: case 0xa1: case 0xa2: case 0xa3:
    case 0xa4: case 0xa5: case 0xa6: case 0xa7:
    case 0xa8: case 0xa9: case 0xaa: case 0xab:
    case 0xac: case 0xad: case 0xae: case 0xaf:
      
    case 0xb0: case 0xb1: case 0xb2: case 0xb3:
    case 0xb4: case 0xb5: case 0xb6: case 0xb7:
    case 0xb8: case 0xb9: case 0xba: case 0xbb:
    case 0xbc: case 0xbd: case 0xbe: case 0xbf:
      return true;
      
      // int two-byte
    case 0xc0: case 0xc1: case 0xc2: case 0xc3:
    case 0xc4: case 0xc5: case 0xc6: case 0xc7:
    case 0xc8: case 0xc9: case 0xca: case 0xcb:
    case 0xcc: case 0xcd: case 0xce: case 0xcf:
      skip(1);
      return true;
      
      // int three-byte
    case 0xd0: case 0xd1: case 0xd2: case 0xd3:
    case 0xd4: case 0xd5: case 0xd6: case 0xd7:
      skip(2);
      return true;
      
      // long single-byte
    case 0xd8: case 0xd9: case 0xda: case 0xdb:
    case 0xdc: case 0xdd: case 0xde: case 0xdf:
      
    case 0xe0: case 0xe1: case 0xe2: case 0xe3:
    case 0xe4: case 0xe5: case 0xe6: case 0xe7:
    case 0xe8: case 0xe9: case 0xea: case 0xeb:
    case 0xec: case 0xed: case 0xee: case 0xef:
      return true;

      // long two-byte
    case 0xf0: case 0xf1: case 0xf2: case 0xf3:
    case 0xf4: case 0xf5: case 0xf6: case 0xf7:
    case 0xf8: case 0xf9: case 0xfa: case 0xfb:
    case 0xfc: case 0xfd: case 0xfe: case 0xff:
      skip(1);
      return true;
      
    
    default:
      throw new UnsupportedOperationException("0x" + Integer.toHexString(ch));
    }
  }
1023876
def remove_children(self, reset_parent=True):
        
        if reset_parent:
            for child in self.children:
                child.parent = None
        self.__children = []
964361
def Skip(self: Iterable, n):
    
    con = iter(self)
    for i, _ in enumerate(con):
        if i == n:
            break
    return con
755435
def skip_redundant(iterable, skipset=None):
    
    if skipset is None:
        skipset = set()
    for item in iterable:
        if item not in skipset:
            skipset.add(item)
            yield item
245705
def remove_all(self):
        ''''''
        if self._children:
            for child in self._children:
                if isinstance(child, String):
                    child._parent = None
            self._children = []
643571
def scram(self):
        '''

        '''
        self.stop_all_children()
        signal.signal(signal.SIGTERM, signal.SIG_DFL)
        sys.exit(2)
556513
public void reset() {
		Enumeration<TreeNode> children = root.children();
		while (children.hasMoreElements()) {
			removeNodeFromParent((MutableTreeNode) children.nextElement());
			children = root.children();
		}
	}
1363322
@Restricted(NoExternalUse.class)
    public static void skip(@Nonnull Iterator<?> iterator, int count) {
        if (count < 0) {
            throw new IllegalArgumentException();
        }
        while (iterator.hasNext() && count-- > 0) {
            iterator.next();
        }
    }
483003
function( skipParents ){
    skipParents = !!skipParents;


    this.updateMatrix();
    var invalidWorldMatrix = this._hasInvalidWorldMatrix( skipParents );
    if( invalidWorldMatrix ) {
      this._computeWorldMatrix( skipParents );
    }

    for (var i = 0; i < this._children.length; i++) {
      var c = this._children[i];
      c._invalidW = c._invalidW || invalidWorldMatrix;
      c.updateWorldMatrix( true );
    }

  }
246149
function skipIndex() {
		if( childType && childType.indexOf('[]') === childType.length-2 ) {
			childType = childType.substring(0, childType.length-2);
		}
	}
1069990
def get_next(self):
        

        while self.stack:
            if self.stack[-1].wkids:
                node = self.stack[-1].wkids.pop(0)
                if not self.stack[-1].wkids:
                    self.stack[-1].wkids = None
                if node in self.history:
                    self.cycle_func(node, self.stack)
                else:
                    node.wkids = copy.copy(self.kids_func(node, self.stack[-1]))
                    self.stack.append(node)
                    self.history[node] = None
            else:
                node = self.stack.pop()
                del self.history[node]
                if node:
                    if self.stack:
                        parent = self.stack[-1]
                    else:
                        parent = None
                    self.eval_func(node, parent)
                return node
        return None
13029
private void skipClasslessStackFrames() {
        // skip over any stack trace elements that are unmatched in the classes array
        if (classes.isEmpty()) return;
        while (elements.size() > 0 && !!!elements.peek().getClassName().equals(classes.peek().getName())) {
            elements.pop();
        }
    }
329714
public void removeAllChildren() {
        for (final GVRSceneObject so : headTransformObject.getChildren()) {
            final boolean notCamera = (so != leftCameraObject && so != rightCameraObject && so != centerCameraObject);
            if (notCamera) {
                headTransformObject.removeChildObject(so);
            }
        }
    }
553143
private String skipCRS(JsonParser jp) throws IOException {
        jp.nextToken(); //START_OBJECT {
        jp.skipChildren();
        jp.nextToken(); //Go to features
        return jp.getText();
    }
533796
def skip_first(pipe, items=1):
    ''' 
    '''
    pipe = iter(pipe)
    for i in skip(pipe, items):
        yield i
234407
static private long skipForward(InputStream is, long toSkip)
                throws IOException {

        long eachSkip = 0;
        long skipped = 0;

        while (skipped != toSkip) {
            eachSkip = is.skip(toSkip - skipped);

            // check if EOF is reached
            if (eachSkip <= 0) {
                if (is.read() == -1) {
                    return skipped ;
                } else {
                    skipped++;
                }
            }
            skipped += eachSkip;
        }
        return skipped;
    }
1366850
def _skip_frame(self):
        """"""
        size = self.read_size()
        for i in range(size+1):
            line = self._f.readline()
            if len(line) == 0:
                raise StopIteration