Internal usage only
327448
def __EncodedAttribute_generic_encode_rgb24(self, rgb24, width=0, height=0, quality=0, format=_ImageFormat.RawImage):
    """"""
    if not is_seq(rgb24):
        raise TypeError("Expected sequence (str, numpy.ndarray, list, tuple "
                        "or bytearray) as first argument")

    is_str = is_pure_str(rgb24)
    if is_str:
        if not width or not height:
            raise ValueError("When giving a string as data, you must also "
                             "supply width and height")

    if np and isinstance(rgb24, np.ndarray):
        if rgb24.ndim != 3:
            if not width or not height:
                raise ValueError("When giving a non 2D numpy array, width and "
                                 "height must be supplied")
            if rgb24.nbytes / 3 != width * height:
                raise ValueError("numpy array size mismatch")
        else:
            if rgb24.itemsize != 1:
                raise TypeError("Expected numpy array with itemsize == 1")
        if not rgb24.flags.c_contiguous:
            raise TypeError("Currently, only contiguous, aligned numpy arrays "
                            "are supported")
        if not rgb24.flags.aligned:
            raise TypeError("Currently, only contiguous, aligned numpy arrays "
                            "are supported")

    if not is_str and (not width or not height):
        height = len(rgb24)
        if height < 1:
            raise IndexError("Expected sequence with at least one row")

        row0 = rgb24[0]
        if not is_seq(row0):
            raise IndexError("Expected sequence (str, numpy.ndarray, list, tuple or "
                             "bytearray) inside a sequence")
        width = len(row0)
        if is_pure_str(row0) or type(row0) == bytearray:
            width /= 3
    if format == _ImageFormat.RawImage:
        self._encode_rgb24(rgb24, width, height)
    elif format == _ImageFormat.JpegImage:
        self._encode_jpeg_rgb24(rgb24, width, height, quality)
190603
protected void usage() {
		String footnotes = null;
		if (!getOptions().getCommands().isEmpty()) {
			footnotes = "Use `" + CSLToolContext.current().getToolName() +
					" help <command>' to read about a specific command.";
		}
		
		String name = CSLToolContext.current().getToolName();
		String usageName = getUsageName();
		if (usageName != null && !usageName.isEmpty()) {
			name += " " + usageName;
		}
		
		String unknownArguments = OptionIntrospector.getUnknownArgumentName(
				getClassesToIntrospect());
		
		OptionParser.usage(name, getUsageDescription(), getOptions(),
				unknownArguments, footnotes, new PrintWriter(System.out, true));
	}
1323133
def appropriate_for(self, usage, alg='HS256'):
        
        try:
            _use = USE[usage]
        except:
            raise ValueError('Unknown key usage')
        else:
            if not self.use or self.use == _use:
                if _use == 'sig':
                    return self.get_key()
                else:
                    return self.encryption_key(alg)

            raise WrongUsage("This key can't be used for {}".format(usage))
284552
@Override
  public void writeExternal(ObjectOutput out) throws IOException {
    super.writeExternal(out);
    out.writeBoolean(isLeaf);
    out.writeInt(numEntries);
    // Entries will be written in subclasses
  }
666721
private final static void usage(final String msg) {
    System.err.println(msg);
    System.err.println("Usage: java Base64 -e|-d inputfile outputfile");
  }
404988
private void keypointInternal() throws InternalLogException
    {
        if (tc.isEntryEnabled())
            Tr.entry(tc, "keypointInternal");

        try
        {
            //  _activeFile is in KEYPOINTING state, other file is in ACTIVE state

            force();

            // _activeFile is in KEYPOINTING state, other file is in ACTIVE state

            _activeFile.keypointComplete();

            // _activeFile is in ACTIVE(time2) state, other file is in ACTIVE(time1) (time2 later than time1)

            if (_activeFile == _file1)
            {
                _file2.becomeInactive();
            }
            else
            {
                _file1.becomeInactive();
            }
        } catch (InternalLogException exc)
        {
            FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.LogHandle.keypointInternal", "952", this);
            if (tc.isEntryEnabled())
                Tr.exit(tc, "keypointInternal", exc);
            throw exc;
        } catch (Throwable exc)
        {
            FFDCFilter.processException(exc, "com.ibm.ws.recoverylog.spi.LogHandle.keypointInternal", "958", this);
            if (tc.isEntryEnabled())
                Tr.exit(tc, "keypointInternal", "InternalLogException");
            throw new InternalLogException(exc);
        }

        // _activeFile is in ACTIVE state, other file is in INACTIVE state

        if (tc.isEntryEnabled())
            Tr.exit(tc, "keypointInternal");
    }
1090870
public void freeUseCount()
  {
    if (_indirectSource != null) {
      _indirectSource.freeUseCount();
    }
    else if (_useCount != null) {
      if (_useCount.decrementAndGet() < 0) {
        closeSelf();
      }
    }
  }
646951
public synchronized void use() {
        assert(!inUse);
        inUse = true;
        compiler = com.sun.tools.javac.api.JavacTool.create();
        fileManager = compiler.getStandardFileManager(null, null, null);
        fileManagerBase = (BaseFileManager)fileManager;
        smartFileManager = new SmartFileManager(fileManager);
        context = new Context();
        context.put(JavaFileManager.class, smartFileManager);
        ResolveWithDeps.preRegister(context);
        JavaCompilerWithDeps.preRegister(context, this);
        subTasks = new ArrayList<Future<?>>();
    }
975292
@Override
	public void internalWrite(Server server, Query query, ImmutableList<Result> results) throws Exception {
		String gatewayMessage = getGatewayMessage(results);

		// message won't be returned if there are no numeric values in the query results
		if (gatewayMessage != null) {
			logger.info(gatewayMessage);
			doSend(gatewayMessage);
		}
	}
843530
@Override
    public void encodeTo(FLEncoder enc) {
        final Encoder encoder = new Encoder(enc);
        internalDict.encodeTo(encoder);
        encoder.release();
    }
763509
private void internalBatchExecution(int size) throws SQLException {

    executeQueryPrologue(true);
    results = new Results(this,
        0,
        true,
        size,
        false,
        resultSetScrollType,
        resultSetConcurrency,
        Statement.RETURN_GENERATED_KEYS,
        protocol.getAutoIncrementIncrement());
    protocol.executeBatchStmt(protocol.isMasterConnection(), results, batchQueries);
    results.commandEnd();
  }
180591
def unused(self):
    """"""
    unused = self.definitions - self.used
    # Filter (variable_name,node) pairs that should be removed, because
    # node is used elsewhere
    used_nodes = set([u[1] for u in self.used])
    unused = set([u for u in unused if u[1] not in used_nodes])
    return unused
1364955
public void writeExternal(ObjectOutput out) throws IOException {
		if(logger.isDebugEnabled()) {
        	logger.debug("writeExternal - sessionKey=" + sessionKey);
        }

		out.writeObject(sipFactoryImpl);
		if(sessionKey != null) {
			out.writeUTF(sessionKey.toString());
		} else {
			if (null == sipSession) {
				out.writeUTF("");
			} else {
				out.writeUTF(sipSession.getId());
			}
		}
		if(attributes != null && attributes.size() > 0) {
			out.writeInt(attributes.size());
			Object[][] attributesArray = new Object[2][attributes.size()];
			int i = 0;
			for (Entry<String, Object> entry : attributes.entrySet()) {
				attributesArray [0][i] = entry.getKey();
				attributesArray [1][i] = entry.getValue();
				i++;
			}
			out.writeObject(attributesArray);
		} else {
			out.writeInt(0);
		}
		if(transactionApplicationData != null) {
			out.writeBoolean(true);
			out.writeObject(transactionApplicationData);
		} else {
			out.writeBoolean(false);
		}
		out.writeUTF(headerForm.toString());
		if(currentApplicationName != null) {
			out.writeUTF(currentApplicationName);
		} else {
			out.writeUTF("");
		}
		out.writeBoolean(isMessageSent);
		if(ReplicationStrategy.EarlyDialog == StaticServiceHolder.sipStandardService.getReplicationStrategy()) {
			if (logger.isDebugEnabled()) {
				logger.debug("writeExternal transaction = " + transaction);
			}
			if(transaction == null) {
				out.writeUTF("");
			} else {
				if (logger.isDebugEnabled()) {
					logger.debug("writeExternal transactionId = " + transaction.getBranchId() + " transactionType " + (transaction instanceof ServerTransaction));
				}
				out.writeUTF(transaction.getBranchId());
				out.writeBoolean(transaction instanceof ServerTransaction);
			}
		}
		out.writeUTF(message.toString());
	}
1208779
public void writeExternal(ObjectOutput out) throws IOException
   {
      byte[] buf = id.getBytes(Constants.DEFAULT_ENCODING);
      out.writeInt(buf.length);
      out.write(buf);
      
      if (parentId == null)
      {
         out.writeInt(-1);
      }
      else
      {
         buf = parentId.getBytes(Constants.DEFAULT_ENCODING);
         out.writeInt(buf.length);
         out.write(buf);
      }
      if (name == null)
      {
         out.writeInt(-1);
      }
      else
      {
         buf = name.getAsString(true).getBytes(Constants.DEFAULT_ENCODING);
         out.writeInt(buf.length);
         out.write(buf);
      }
      if (path == null)
      {
         out.writeInt(-1);
      }
      else
      {
         buf = path.getAsString().getBytes(Constants.DEFAULT_ENCODING);
         out.writeInt(buf.length);
         out.write(buf);
      }
   }
1186052
void transform_internal (double data[], int i0, int stride, int direction) {
    if (decimate==DECINFREQ) {
      transform_DIF(data,i0,stride,direction); }
    else {
      transform_DIT(data,i0,stride,direction); }}
54342
void internalDeactivate ()
    {
      final String methodName = "internalDeactivate";
      if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
          SibTr.entry(this, TRACE, methodName);
      }

      synchronized (_sessionsByMeUuid) {
        _sessionsByMeUuid.clear();
      }

      super.deactivate();

      if (TraceComponent.isAnyTracingEnabled() && TRACE.isEntryEnabled()) {
        SibTr.exit(this, TRACE, methodName);
      }

    }
54791
private static void usage() {
    new HelpFormatter().printHelp(String.format(
        "java -cp %s %s -type <[READ, WRITE]> -fileSize <fileSize> -iterations <iterations> "
            + "-concurrency <concurrency>",
        RuntimeConstants.ALLUXIO_JAR, MiniBenchmark.class.getCanonicalName()),
        "run a mini benchmark to write or read a file",
        OPTIONS, "", true);
  }