Java Code Examples for java.util.Hashtable

private static void extractLocales(Hashtable languages, Vector q,Vector l)
{
    // XXX We will need to order by q value Vector in the Future ?
    Enumeration e = q.elements();
    while (e.hasMoreElements()) {
        Vector v =
            (Vector)languages.get(((Double)e.nextElement()).toString());
        Enumeration le = v.elements();
        while (le.hasMoreElements()) {
	        String language = (String)le.nextElement();
     	String country = "";
    		int countryIndex = language.indexOf("-");
            if (countryIndex > -1) {
                country = language.substring(countryIndex + 1).trim();
                language = language.substring(0, countryIndex).trim();
            }
            l.addElement(new Locale(language, country));
        }
    }
}
 

/**
 * @serialData Default fields.
 */
/*
 * Writes the contents of the permsMap field out as a Hashtable for
 * serialization compatibility with earlier releases. allPermission
 * unchanged.
 */
private void writeObject(ObjectOutputStream out) throws IOException {
    // Don't call out.defaultWriteObject()

    // Copy perms into a Hashtable
    Hashtable<Class<?>, PermissionCollection> perms =
        new Hashtable<>(permsMap.size()*2); // no sync; estimate
    synchronized (this) {
        perms.putAll(permsMap);
    }

    // Write out serializable fields
    ObjectOutputStream.PutField pfields = out.putFields();

    pfields.put("allPermission", allPermission); // no sync; staleness OK
    pfields.put("perms", perms);
    out.writeFields();
}
 

/**
 * This method is separated from the rest of the example since you normally
 * would NOT register a JDBC driver in your code. It would likely be
 * configered into your naming and directory service using some GUI.
 * 
 * @throws Exception
 *             if an error occurs
 */
private void registerDataSource() throws Exception {
    this.tempDir = File.createTempFile("jnditest", null);
    this.tempDir.delete();
    this.tempDir.mkdir();
    this.tempDir.deleteOnExit();

    com.mysql.jdbc.jdbc2.optional.MysqlDataSource ds;
    Hashtable<String, String> env = new Hashtable<String, String>();
    env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.fscontext.RefFSContextFactory");
    env.put(Context.PROVIDER_URL, this.tempDir.toURI().toString());
    this.ctx = new InitialContext(env);
    assertTrue("Naming Context not created", this.ctx != null);
    ds = new com.mysql.jdbc.jdbc2.optional.MysqlDataSource();
    ds.setUrl(dbUrl); // from BaseTestCase
    this.ctx.bind("_test", ds);
}
 

@Override
protected ThingHandler createHandler(Thing thing) {
    ThingTypeUID thingTypeUID = thing.getThingTypeUID();

    if (thingTypeUID.equals(THING_TYPE_HOME)) {
        TadoHomeHandler tadoHomeHandler = new TadoHomeHandler((Bridge) thing);

        TadoDiscoveryService discoveryService = new TadoDiscoveryService(tadoHomeHandler);
        bundleContext.registerService(DiscoveryService.class.getName(), discoveryService,
                new Hashtable<String, Object>());

        return tadoHomeHandler;
    } else if (thingTypeUID.equals(THING_TYPE_ZONE)) {
        return new TadoZoneHandler(thing);
    } else if (thingTypeUID.equals(THING_TYPE_MOBILE_DEVICE)) {
        return new TadoMobileDeviceHandler(thing);
    }

    return null;
}
 

public static Bitmap createQRCode(String str,int widthAndHeight) throws WriterException {
	Hashtable<EncodeHintType, String> hints = new Hashtable<EncodeHintType, String>();  
       hints.put(EncodeHintType.CHARACTER_SET, "utf-8"); 
	BitMatrix matrix = new MultiFormatWriter().encode(str,
			BarcodeFormat.QR_CODE, widthAndHeight, widthAndHeight);
	int width = matrix.getWidth();
	int height = matrix.getHeight();
	int[] pixels = new int[width * height];
	
	for (int y = 0; y < height; y++) {
		for (int x = 0; x < width; x++) {
			if (matrix.get(x, y)) {
				pixels[y * width + x] = BLACK;
			}
		}
	}
	Bitmap bitmap = Bitmap.createBitmap(width, height,
			Bitmap.Config.ARGB_8888);
	bitmap.setPixels(pixels, 0, width, 0, 0, width, height);
	return bitmap;
}
 

/**
 *
 **/
public void generate (Hashtable symbolTable, ForwardValueEntry v, PrintWriter str)
{
  this.symbolTable = symbolTable;
  this.v = v;

  openStream ();
  if (stream == null)
    return;
  generateHelper ();
  generateHolder ();
  generateStub ();
  writeHeading ();
  writeBody ();
  writeClosing ();
  closeStream ();
}
 

/**
 * Creates a jdbcDatasource object using the location or reference
 * information specified.<p>
 *
 * The Reference object should support the properties, database, user,
 * password.
 *
 * @param obj The reference information used in creating a
 *      jdbcDatasource object.
 * @param name ignored
 * @param nameCtx ignored
 * @param environment ignored
 * @return A newly created jdbcDataSource object; null if an object
 *      cannot be created.
 * @exception Exception never
 */
public Object getObjectInstance(Object obj, Name name, Context nameCtx,
                                Hashtable environment) throws Exception {

    String    dsClass = "org.hsqldb.jdbc.jdbcDataSource";
    Reference ref     = (Reference) obj;

    if (ref.getClassName().equals(dsClass)) {
        jdbcDataSource ds = new jdbcDataSource();

        ds.setDatabase((String) ref.get("database").getContent());
        ds.setUser((String) ref.get("user").getContent());
        ds.setPassword((String) ref.get("password").getContent());

        return ds;
    } else {
        return null;
    }
}
 

/**
 * Creates a ProcessEnvironment and derives the necessary environment,
 * working directory, command, etc.
 * @param req             HttpServletRequest for information provided by
 *                        the Servlet API
 * @param context         ServletContext for information provided by
 *                        the Servlet API
 * @param cgiPathPrefix   subdirectory of webAppRootDir below which the
 *                        web app's CGIs may be stored; can be null or "".
 * @param  debug          int debug level (0 == none, 6 == lots)
 */
public CGIProcessEnvironment(HttpServletRequest req,
    ServletContext context, String cgiPathPrefix, int debug) {
        super(req, context, debug);
        this.cgiPathPrefix = cgiPathPrefix;
        queryParameters = new Hashtable();
        Enumeration paramNames = req.getParameterNames();
        while (paramNames != null && paramNames.hasMoreElements()) {
            String param = paramNames.nextElement().toString();
            if (param != null) {
                queryParameters.put(param,
                    URLEncoder.encode(req.getParameter(param)));
            }
        }
        this.valid = deriveProcessEnvironment(req);
}
 

public Object lookup(Name name) throws NamingException {
    PartialCompositeContext ctx = this;
    Hashtable<?,?> env = p_getEnvironment();
    Continuation cont = new Continuation(name, env);
    Object answer;
    Name nm = name;

    try {
        answer = ctx.p_lookup(nm, cont);
        while (cont.isContinue()) {
            nm = cont.getRemainingName();
            ctx = getPCContext(cont);
            answer = ctx.p_lookup(nm, cont);
        }
    } catch (CannotProceedException e) {
        Context cctx = NamingManager.getContinuationContext(e);
        answer = cctx.lookup(e.getRemainingName());
    }
    return answer;
}
 

/**
 * method merging env into nenv
 * 
 * @throws UnifyException
 */
public static void addBindings(Environment env, Environment nenv)
        throws UnifyException {
    Hashtable<String, Value> eTable = env.getTable();
    Set<String> keys = eTable.keySet();
    Iterator<String> it = keys.iterator();
    while (it.hasNext()) {
        // we look if the variable is bound
        String eVar = it.next();
        Value val = new Value(Value.VAR, eVar);
        Value eVal = env.deref(val);
        if (!(eVal.equals(val))) {
            // if it is, we unify the bound values in the new environment
            Value.unify(val, eVal, nenv);
        }
    }
}
 

/**
 *  Gets all possible metadata formats that may be disiminated by this RepositoryManager. This includes
 *  formats that are available by conversion from the native format via the XMLConversionService.
 *
 * @return    The metadataFormats available.
 * @see       #getConfiguredFormats
 */
public final Hashtable getAvailableFormats() {
	if (index.getLastModifiedCount() > formatsLastUpdatedTime) {
		formatsLastUpdatedTime = index.getLastModifiedCount();

		formats.clear();
		List indexedFormats = index.getTerms("metadatapfx");
		if (indexedFormats == null)
			return formats;
		String format = null;
		for (int i = 0; i < indexedFormats.size(); i++) {
			format = (String) indexedFormats.get(i);
			// remove the '0' in the doctype
			format = format.substring(1, format.length());
			formats.putAll(getMetadataFormatsConversions(format));
		}
	}
	return formats;
}
 

public void select(Hashtable<String,Field> params){
	ArrayList<String> param_list = new ArrayList<String>(); 
	Enumeration<String> llaves = params.keys();
	while(llaves.hasMoreElements()){
		String llave = llaves.nextElement();
		if(GEOM.class.isAssignableFrom(params.get(llave).getType())){
			param_list.add(GEOM.GetSQL(llave));
		}
		else if(CENTROID.class.isAssignableFrom(params.get(llave).getType())){
			param_list.add(CENTROID.GetSQL(llave));
		}
		else
		{
			param_list.add(llave);
		}
	}
	String parametros = String.join(",", param_list);
	this.query = "SELECT "+parametros+" FROM "+this.table;
}
 

/**
 * This method is separated from the rest of the example since you normally
 * would NOT register a JDBC driver in your code. It would likely be
 * configered into your naming and directory service using some GUI.
 * 
 * @throws Exception
 *             if an error occurs
 */
private void registerDataSource() throws Exception {
    this.tempDir = File.createTempFile("jnditest", null);
    this.tempDir.delete();
    this.tempDir.mkdir();
    this.tempDir.deleteOnExit();

    com.mysql.jdbc.jdbc2.optional.MysqlDataSource ds;
    Hashtable<String, String> env = new Hashtable<String, String>();
    env.put(Context.INITIAL_CONTEXT_FACTORY, "com.sun.jndi.fscontext.RefFSContextFactory");
    env.put(Context.PROVIDER_URL, this.tempDir.toURI().toString());
    this.ctx = new InitialContext(env);
    assertTrue("Naming Context not created", this.ctx != null);
    ds = new com.mysql.jdbc.jdbc2.optional.MysqlDataSource();
    ds.setUrl(dbUrl); // from BaseTestCase
    this.ctx.bind("_test", ds);
}
 

/**
  * Creates a context in which to continue a <tt>DirContext</tt> operation.
  * Operates just like <tt>NamingManager.getContinuationContext()</tt>,
  * only the continuation context returned is a <tt>DirContext</tt>.
  *
  * @param cpe
  *         The non-null exception that triggered this continuation.
  * @return A non-null <tt>DirContext</tt> object for continuing the operation.
  * @exception NamingException If a naming exception occurred.
  *
  * @see NamingManager#getContinuationContext(CannotProceedException)
  */
@SuppressWarnings("unchecked")
public static DirContext getContinuationDirContext(
        CannotProceedException cpe) throws NamingException {

    Hashtable<Object,Object> env = (Hashtable<Object,Object>)cpe.getEnvironment();
    if (env == null) {
        env = new Hashtable<>(7);
    } else {
        // Make a (shallow) copy of the environment.
        env = (Hashtable<Object,Object>) env.clone();
    }
    env.put(CPE, cpe);

    return (new ContinuationDirContext(cpe, env));
}
 

public void testStickinessWhenABetterServiceIsAvailable() throws Exception {
	interceptor.setSticky(true);
	interceptor.afterPropertiesSet();

	ServiceListener sl = (ServiceListener) bundleContext.getServiceListeners().iterator().next();

	Dictionary props = new Hashtable();
	// increase service ranking
	props.put(Constants.SERVICE_RANKING, 10);

	ServiceReference ref = new MockServiceReference(null, props, null);
	ServiceEvent event = new ServiceEvent(ServiceEvent.REGISTERED, ref);

	assertEquals(1, SimpleTargetSourceLifecycleListener.BIND);
	assertEquals(0, SimpleTargetSourceLifecycleListener.UNBIND);

	sl.serviceChanged(event);

	assertEquals("the proxy is not sticky", 1, SimpleTargetSourceLifecycleListener.BIND);
	assertEquals(0, SimpleTargetSourceLifecycleListener.UNBIND);
}
 

private void registerServices(BundleContext context) {
    // store services with low ranking such that they can be overridden
    // during testing or the like
    Dictionary<String, Object> preferences = new Hashtable<String, Object>();
    preferences.put(Constants.SERVICE_RANKING, 1);

    Dictionary<String, Object> priorityPreferences = new Hashtable<String, Object>();
    priorityPreferences.put(Constants.SERVICE_RANKING, 2);

    // register all services (override the ProcessStreamsProvider registered in the core plugin)
    this.loggerService = registerService(context, Logger.class, createLogger(), preferences);
}
 

/**
 * @serialData Serialized fields. Convert Maps to Hashtables for backward
 * compatibility.
 */
private void writeObject(ObjectOutputStream out) throws IOException {
    // Convert Maps to Hashtables
    Hashtable<Node, Hashtable<String, UserDataRecord>> nud = null;
    if (nodeUserData != null) {
        nud = new Hashtable<>();
        for (Map.Entry<Node, Map<String, UserDataRecord>> e : nodeUserData.entrySet()) {
            //e.getValue() will not be null since an entry is always put with a non-null value
            nud.put(e.getKey(), new Hashtable<>(e.getValue()));
        }
    }

    Hashtable<String, Node> ids = (identifiers == null)? null : new Hashtable<>(identifiers);
    Hashtable<Node, Integer> nt = (nodeTable == null)? null : new Hashtable<>(nodeTable);

    // Write serialized fields
    ObjectOutputStream.PutField pf = out.putFields();
    pf.put("docType", docType);
    pf.put("docElement", docElement);
    pf.put("fFreeNLCache", fFreeNLCache);
    pf.put("encoding", encoding);
    pf.put("actualEncoding", actualEncoding);
    pf.put("version", version);
    pf.put("standalone", standalone);
    pf.put("fDocumentURI", fDocumentURI);

    //userData is the original name. It has been changed to nodeUserData, refer to the corrsponding @serialField
    pf.put("userData", nud);
    pf.put("identifiers", ids);
    pf.put("changes", changes);
    pf.put("allowGrammarAccess", allowGrammarAccess);
    pf.put("errorChecking", errorChecking);
    pf.put("ancestorChecking", ancestorChecking);
    pf.put("xmlVersionChanged", xmlVersionChanged);
    pf.put("documentNumber", documentNumber);
    pf.put("nodeCounter", nodeCounter);
    pf.put("nodeTable", nt);
    pf.put("xml11Version", xml11Version);
    out.writeFields();
}
 

public static Hashtable<Long,Set<Long>> findConflictingStudents(Long classId, int startSlot, int length, List<Date> dates) {
	Hashtable<Long,Set<Long>> table = new Hashtable();
	if (dates.isEmpty()) return table;
	String datesStr = "";
	for (int i=0; i<dates.size(); i++) {
		if (i>0) datesStr += ", ";
		datesStr += ":date"+i;
	}
	Query q = LocationDAO.getInstance().getSession()
	    .createQuery("select distinct e.clazz.uniqueId, e.student.uniqueId "+
	        	"from StudentClassEnrollment e, ClassEvent c inner join c.meetings m, StudentClassEnrollment x "+
	        	"where x.clazz.uniqueId=:classId and x.student=e.student and " + // only look among students of the given class 
	        	"e.clazz=c.clazz and " + // link ClassEvent c with StudentClassEnrollment e
        		"m.stopPeriod>:startSlot and :endSlot>m.startPeriod and " + // meeting time within given time period
        		"m.meetingDate in ("+datesStr+") and m.approvalStatus = 1")
        .setLong("classId",classId)
        .setInteger("startSlot", startSlot)
        .setInteger("endSlot", startSlot + length);
	for (int i=0; i<dates.size(); i++) {
		q.setDate("date"+i, dates.get(i));
	}
    for (Iterator i = q.setCacheable(true).list().iterator();i.hasNext();) {
        Object[] o = (Object[])i.next();
        Set<Long> set = table.get((Long)o[0]);
        if (set==null) {
        	set = new HashSet<Long>();
        	table.put((Long)o[0], set);
        }
        set.add((Long)o[1]);
    }
    return table;
}
 

/**
 * Returns the initialized attribute table.
 *
 * @return the initialized attribute table
 */
private Hashtable<String, Object> getTable() {
    if (this.table == null) {
        this.table = new Hashtable<>();
    }
    return this.table;
}
 

public Hashtable<String, Object> handleFunction(String sessionId, String function, Hashtable<String, Object> input) throws JLIException {
	if (function==null)
		return null;
	
	if (function.equals(FUNC_BOUND_BOX)) return actionBoundingBox(sessionId, input);
	else if (function.equals(FUNC_GET_SURFACES)) return actionGetSurfaces(sessionId, input);
	else if (function.equals(FUNC_GET_EDGES)) return actionGetEdges(sessionId, input);
	else {
		throw new JLIException("Unknown function name: " + function);
	}
}
 

public static Hashtable loadReasonsByTag(JSONObject json) throws JSONException {
  Hashtable reasonsByTagHt = new Hashtable();
  // Enumeration en = json.keys();
  Iterator en = json.keys();
  //  while ( en.hasMoreElements() ) {
  while (en.hasNext()) {
    //  String transType = (String) en.nextElement();
    String transType = (String) en.next();
    JSONObject tagsByTransJson = json.getJSONObject(transType);
    if (tagsByTransJson == null) {
      continue;
    }
    Iterator enTags = tagsByTransJson.keys();
    // Enumeration enTags = tagsByTransJson.keys();
    Hashtable tagsHt = new Hashtable();
    // while ( enTags.hasMoreElements() ) {
    //   String tag = (String) enTags.nextElement();
    while (enTags.hasNext()) {
      String tag = (String) enTags.next();
      String value = null;
      if ((value = (String) tagsByTransJson.get(tag)) != null && !value.equals("")) {
        tagsHt.put(tag, value);
      }
    }
    reasonsByTagHt.put(transType, tagsHt);
  }
  return reasonsByTagHt;
}
 

public void setProperties(Hashtable<?,?> props) {
    if (src != null) {
        src.checkSecurity(null, false);
    }
    image.setProperties(props);
    newInfo(image, ImageObserver.PROPERTIES, 0, 0, 0, 0);
}
 

public Hashtable<String, Object> handleFunction(String sessionId, String function, Hashtable<String, Object> input) throws JLIException {
	if (function==null)
		return null;
	
	if (function.equals(FUNC_EXISTS))
		return actionExists(sessionId, input);
	else if (function.equals(FUNC_DELETE))
		return actionDelete(sessionId, input);
	else if (function.equals(FUNC_DELETE_INST))
		return actionDeleteInst(sessionId, input);
	else if (function.equals(FUNC_GET_HEADER))
		return actionGetHeader(sessionId, input);
	else if (function.equals(FUNC_GET_ROW))
		return actionGetRow(sessionId, input);
	else if (function.equals(FUNC_GET_CELL))
		return actionGetCell(sessionId, input);
	else if (function.equals(FUNC_SET_CELL))
		return actionSetCell(sessionId, input);
	else if (function.equals(FUNC_ADD_INST))
		return actionAddInst(sessionId, input);
	else if (function.equals(FUNC_REPLACE))
		return actionReplace(sessionId, input);
	else if (function.equals(FUNC_LIST))
		return actionList(sessionId, input);
	else if (function.equals(FUNC_LIST_TREE))
		return actionListTree(sessionId, input);
	else if (function.equals(FUNC_CREATE_INST))
		return actionCreateInst(sessionId, input);
	else if (function.equals(FUNC_GET_PARENTS))
		return actionGetParents(sessionId, input);
	else {
		throw new JLIException("Unknown function name: " + function);
	}
}
 

private Hashtable<String, Object> actionExportProgram(String sessionId, Hashtable<String, Object> input) throws JLIException {
       String model = checkStringParameter(input, PARAM_MODEL, false);

       ExportResults results = intfHandler.exportProgram(model, sessionId);
       
       if (results!=null) {
		Hashtable<String, Object> out = new Hashtable<String, Object>();
		out.put(OUTPUT_DIRNAME, results.getDirname());
		out.put(OUTPUT_FILENAME, results.getFilename());
       	return out;
       }
       return null;
}
 

private String initUsingUrl(ORB orb, String url, Hashtable<?,?> env)
    throws NamingException {
    if (url.startsWith("iiop://") || url.startsWith("iiopname://")) {
        return initUsingIiopUrl(orb, url, env);
    } else {
        return initUsingCorbanameUrl(orb, url, env);
    }
}
 

/**
 * Removes all the components from this container.
 *
 * @since 1.5
 */
public void removeAll() {
    Component[] children = getComponents();
    Hashtable<Component, Integer> cToL = getComponentToLayer();
    for (int counter = children.length - 1; counter >= 0; counter--) {
        Component c = children[counter];
        if (c != null && !(c instanceof JComponent)) {
            cToL.remove(c);
        }
    }
    super.removeAll();
}
 

private Hashtable<Row, Boolean> getStreamsBuff(Row function) {
    Hashtable<Row, Boolean> stream = functionStreamsBuff.get(function);
    if (stream == null) {
        stream = new Hashtable<Row, Boolean>();
        functionStreamsBuff.put(function, stream);
    }
    return stream;
}
 

private Hashtable<String, Object> actionBackup(String sessionId, Hashtable<String, Object> input) throws JLIException {
       String filename = checkStringParameter(input, PARAM_MODEL, true);
       String targetdir = checkStringParameter(input, PARAM_TARGETDIR, true);
       
       fileHandler.backup(filename, targetdir, sessionId);
	
       return null;
}
 

@SuppressWarnings("unchecked")
public Map<Long, String> getValues(UserContext user) {
	Map<Long, String> ret = new Hashtable<Long, String>();
	for (RefTableEntry ref: (List<RefTableEntry>)SessionDAO.getInstance().getSession().createCriteria(iReference).list())
		ret.put(ref.getUniqueId(), ref.getLabel());
	return ret;
}
 

@Override
public void start ( final BundleContext context ) throws Exception
{
    Activator.context = context;

    this.executor = ScheduledExportedExecutorService.newSingleThreadExportedScheduledExecutor ( context.getBundle ().getSymbolicName () );
    this.factory = new BufferedDatasourceFactory ( context, this.executor );

    final Dictionary<String, String> properties = new Hashtable<String, String> ();
    properties.put ( Constants.SERVICE_DESCRIPTION, "A counter of changes on an item over a defined timeframe" );
    properties.put ( Constants.SERVICE_VENDOR, "Eclipse SCADA Project" );
    properties.put ( ConfigurationAdministrator.FACTORY_ID, context.getBundle ().getSymbolicName () );

    context.registerService ( ConfigurationFactory.class.getName (), this.factory, properties );
}
 

/**
 * 
 */
public void removeAllOverlays(Hashtable<Object, mxICellOverlay[]> map) {
  Iterator<Map.Entry<Object, mxICellOverlay[]>> it = map.entrySet().iterator();

  while (it.hasNext()) {
    Map.Entry<Object, mxICellOverlay[]> entry = it.next();
    mxICellOverlay[] c = entry.getValue();

    for (int i = 0; i < c.length; i++) {
      removeCellOverlayComponent(c[i], entry.getKey());
    }
  }
}
 

/**
 * Check the expression if it appears as an lvalue.
 * We just pass it on to our unparenthesized subexpression.
 * (Part of fix for 4090372)
 */
public Vset checkAssignOp(Environment env, Context ctx,
                          Vset vset, Hashtable exp, Expression outside) {
    vset = right.checkAssignOp(env, ctx, vset, exp, outside);
    type = right.type;
    return vset;
}
 

private String createProfile(String userId) throws SignatureException, IOException
{
    Hashtable<String, String> params = new Hashtable<String, String>();
    params.put("method", "profile.create");
    params.put("user_id", userId);

    return callRest(params);
}
 

@Override
protected Entry<ProxyMonitorQuery> createService ( final UserInformation userInformation, final String configurationId, final BundleContext context, final Map<String, String> parameters ) throws Exception
{
    logger.info ( "Creating new proxy query: {}", configurationId );

    final ProxyMonitorQuery service = new ProxyMonitorQuery ( context, this.executor );

    final Hashtable<String, Object> properties = new Hashtable<String, Object> ();
    properties.put ( Constants.SERVICE_PID, configurationId );
    final ServiceRegistration<MonitorQuery> handle = context.registerService ( MonitorQuery.class, service, properties );

    service.update ( userInformation, parameters );

    return new Entry<ProxyMonitorQuery> ( configurationId, service, handle );
}
 

/**
   * Convert a 3D coordinate into a generic JSON structure
   * @param x
   * @param y
   * @param z
   * @return The JSON data as a Hashtable
   */
  protected Hashtable<String, Object> writePoint(double x, double y, double z) {
Hashtable<String, Object> out = new Hashtable<String, Object>();
out.put(JLFileResponseParams.OUTPUT_X, x);
out.put(JLFileResponseParams.OUTPUT_Y, y);
out.put(JLFileResponseParams.OUTPUT_Z, z);
return out;
  }
 

public VariableHeightLayoutCache() {
    super();
    tempStacks = new Stack<Stack<TreePath>>();
    visibleNodes = new Vector<Object>();
    boundsBuffer = new Rectangle();
    treePathMapping = new Hashtable<TreePath, TreeStateNode>();
}
 

/**
 * Converts a Hashtable to a String array by converting each
 * key/value pair in the Hashtable to two consecutive Strings
 *
 * @param  h   Hashtable to convert
 * @return     converted string array
 * @exception  NullPointerException   if a hash key has a null value
 */
public static String[] hashToStringArray(Hashtable h)
    throws NullPointerException
{
    Vector v = new Vector();
    Enumeration e = h.keys();
    while (e.hasMoreElements()) {
        String k = e.nextElement().toString();
        v.add(k);
        v.add(h.get(k));
    }
    String[] strArr = new String[v.size()];
    v.copyInto(strArr);
    return strArr;
}
 

private Hashtable<String, Object> actionSet(String sessionId, Hashtable<String, Object> input) throws JLIException {
       String modelname = checkStringParameter(input, PARAM_MODEL, false);
       String dimname = checkStringParameter(input, PARAM_NAME, true);
       Object value = checkParameter(input, PARAM_VALUE, false);
       boolean encoded = checkFlagParameter(input, PARAM_ENCODED, false, false);
       
       dimHandler.set(modelname, dimname, value, encoded, sessionId);
       
	return null;
}
 

/**
 * Initialize the lookup table.
 */
private void initialize() {
	fgKeys = new Hashtable<String, Integer>();
	Integer k = new Integer(JavaLineStyler.KEY);
	for (int i = 0; i < fgKeywords.length; i++)
		fgKeys.put(fgKeywords[i], k);

	loadClassColor();
}
 

@DataProvider(name = "Maps", parallel = true)
private static Iterator<Object[]> makeMaps() {
    return Arrays.asList(
            // Test maps that CME
            new Object[]{new HashMap<>(), true},
            new Object[]{new Hashtable<>(), true},
            new Object[]{new LinkedHashMap<>(), true},
            // Test default Map methods - no CME
            new Object[]{new Defaults.ExtendsAbstractMap<>(), false}
    ).iterator();
}
 

/**
 * Write #includes
 * @param incHash Hashtable loaded with Types to include
 * @param p The output stream.
 */
protected void writeInheritedIncludes(
                                      Hashtable inhHash,
                             IndentingWriter p )
    throws IOException {
    Enumeration inhEnum = inhHash.elements();
    while ( inhEnum.hasMoreElements() ) {
        CompoundType t = (CompoundType)inhEnum.nextElement();
        writeInclude( t,0,!isThrown,p );
    }
}
 

DecodeHandler(ScannerActivity activity) {
    this.mActivity = activity;
    mMultiFormatReader = new MultiFormatReader();
    mHints = new Hashtable<>();
    mHints.put(DecodeHintType.CHARACTER_SET, "utf-8");
    mHints.put(DecodeHintType.TRY_HARDER, Boolean.TRUE);
    Collection<BarcodeFormat> barcodeFormats = new ArrayList<>();
    barcodeFormats.add(BarcodeFormat.CODE_39);
    barcodeFormats.add(BarcodeFormat.CODE_128); // 快递单常用格式39,128
    barcodeFormats.add(BarcodeFormat.QR_CODE); //扫描格式自行添加
    mHints.put(DecodeHintType.POSSIBLE_FORMATS, barcodeFormats);
}
 

Object lookupHashFieldInContext(String field, String key) {
    for (int i=0; i<context.length; i++) {
        Hashtable ht = (Hashtable)getField(context[i], field);
        if (ht != null) {
            Object rv = ht.get(key);
            if (rv != null) {
                return rv;
            }
        }
    }
    return null;
}
 

@Override
public void start ( final BundleContext context ) throws Exception
{
    this.executor = new ExportedExecutorService ( "org.eclipse.scada.da.server.component", 1, 1, 1, TimeUnit.MINUTES ); //$NON-NLS-1$

    this.hive = new Hive ( context, this.executor );

    this.hive.start ();
    final Dictionary<String, Object> properties = new Hashtable<> ();
    properties.put ( Constants.SERVICE_VENDOR, "Eclipse SCADA Project" );
    properties.put ( "hive.id", this.hive.getHiveId () ); //$NON-NLS-1$
    this.handle = context.registerService ( org.eclipse.scada.da.core.server.Hive.class, this.hive, properties );
}
 

@Override
protected Entry<DataStoreDataSource> createService ( final UserInformation userInformation, final String configurationId, final BundleContext context, final Map<String, String> parameters ) throws Exception
{
    logger.debug ( "Creating new memory source: {}", configurationId );

    final DataStoreDataSource source = new DataStoreDataSource ( context, configurationId, this.executor, this.dataNodeTracker );
    source.update ( parameters );

    final Dictionary<String, String> properties = new Hashtable<String, String> ();
    properties.put ( DataSource.DATA_SOURCE_ID, configurationId );

    this.objectPool.addService ( configurationId, source, properties );

    return new Entry<DataStoreDataSource> ( configurationId, source );
}
 

/**
 * Select the type of the expression
 */
public Vset checkValue(Environment env, Context ctx, Vset vset, Hashtable exp) {
    vset = right.checkValue(env, ctx, vset, exp);
    if (!right.type.isType(TC_ARRAY)) {
        env.error(where, "invalid.length", right.type);
    }
    return vset;
}
 

protected void registerItem ( final DataItem newItem, final String localId, final Map<String, Variant> properties )
{
    final Dictionary<String, String> props = new Hashtable<String, String> ();

    fillProperties ( properties, props );

    final ServiceRegistration<DataItem> handle = this.context.registerService ( DataItem.class, newItem, props );
    this.items.put ( localId, newItem );
    this.itemRegs.put ( localId, handle );
}
 

/**
 * Constructs a new instance of LdapReferralException.
 * @param   resolvedName    The part of the name that has been successfully
 *                          resolved.
 * @param   resolvedObj     The object to which resolution was successful.
 * @param   remainingName   The remaining unresolved portion of the name.
 * @param   explanation     Additional detail about this exception.
 */
LdapReferralException(Name resolvedName,
    Object resolvedObj,
    Name remainingName,
    String explanation,
    Hashtable<?,?> envprops,
    String nextName,
    int handleReferrals,
    Control[] reqCtls) {

    super(explanation);

    if (debug)
        System.out.println("LdapReferralException constructor");

    setResolvedName(resolvedName);
    setResolvedObj(resolvedObj);
    setRemainingName(remainingName);
    this.envprops = envprops;
    this.nextName = nextName;
    this.handleReferrals = handleReferrals;

    // If following referral, request controls are passed to referral ctx
    this.reqCtls =
        (handleReferrals == LdapClient.LDAP_REF_FOLLOW ||
                handleReferrals == LdapClient.LDAP_REF_FOLLOW_SCHEME ? reqCtls : null);
}
 

public static void main(String[] args) {

    //create Hashtable object
    Hashtable ht = new Hashtable();

    //add key value pairs to Hashtable
    ht.put("1", "One");
    ht.put("2", "Two");
    ht.put("3", "Three");

    /*
      get Set of keys contained in Hashtable using
      Set keySet() method of Hashtable class
    */

    Set st = ht.keySet();

    System.out.println("Set created from Hashtable Keys contains :");
    //iterate through the Set of keys
    Iterator itr = st.iterator();
    while (itr.hasNext()) System.out.println(itr.next());

    /*
       Please note that resultant Set object is backed by the Hashtable.
       Any key that is removed from Set will also be removed from
       original Hashtable object. The same is not the case with the element
       addition.
    */

    //remove 2 from Set
    st.remove("2");

    //print keys of original Hashtable
    System.out.println("Hashtable keys after removal from Set are :");
    Enumeration e = ht.keys();
    while (e.hasMoreElements()) System.out.println(e.nextElement());
  }
 

private Hashtable<String, Object> actionSetLengthUnits(String sessionId, Hashtable<String, Object> input) throws JLIException {
       String filename = checkStringParameter(input, PARAM_MODEL, false);
       String units = checkStringParameter(input, PARAM_UNITS, true);
       boolean convert = checkFlagParameter(input, PARAM_CONVERT, false, true);
       
       fileHandler.setLengthUnits(filename, units, convert, sessionId);

	return null;
}
 

public void collect_corefs(Hashtable<Value, Fs> corefs,
        Situation situation) {
    Value coref = this.coref;
    Fs New = this;
    if (corefs.keySet().contains(coref)) {
        // in this case we have to unify the feature structures, but we need
        // an environment
        try {
            // System.out.println("Start unify with
            // "+this+corefs.get(coref));
            New = unify(this, corefs.get(coref), new Environment(0),
                    situation.getTypeHierarchy());
            corefs.remove(coref);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    corefs.put(coref, New);
    Iterator<String> i = New.AVlist.keySet().iterator();
    while (i.hasNext()) {
        String f = i.next();
        Value v = New.AVlist.get(f);
        if (v.is(Value.AVM)) {
            v.getAvmVal().collect_corefs(corefs, situation);
        }
    }
}
 

public static void main(String[] args) {
	ServiceBuilder builder = new ServiceBuilder();
	UUID state = UUID.randomUUID();
	OAuth20Service service = builder.state(state.toString()).scope("https://www.googleapis.com/auth/gmail.send").apiKey("654832567742-6udg14sfuif69g84c78ss3s3msdlf33l.apps.googleusercontent.com").apiSecret("SDFwrgfsdSeQnFtSDFSDFzHd").callback("https://tburne.net/oauth/index.html").build(GoogleApi20.instance());
	Hashtable<String, String> params = new Hashtable<String, String>();
	params.put("access_type", "offline");
	params.put("approval_prompt", "force");
	System.out.println("Redirect Resource Owner to " + service.getAuthorizationUrl(params) + " with state " + state.toString());	
}
 

@Override
public void start ( final BundleContext context ) throws Exception
{
    this.service = new ConfigurationAdministratorService ( context );

    final Dictionary<String, Object> properties = new Hashtable<String, Object> ();
    properties.put ( JaxWsExporter.EXPORT_ENABLED, Boolean.TRUE );
    properties.put ( Constants.SERVICE_PID, context.getBundle ().getSymbolicName () );

    this.handle = context.registerService ( RemoteConfigurationAdministrator.class, this.service, properties );
}
 

private void shrink() {
    Hashtable<?,?> tmp = (Hashtable)table;
    Object[] array = new Object[tmp.size()*2];
    Enumeration<?> keys = tmp.keys();
    int j = 0;

    while (keys.hasMoreElements()) {
        Object o = keys.nextElement();
        array[j] = o;
        array[j+1] = tmp.get(o);
        j+=2;
    }
    table = array;
}
 

public synchronized void enableDummyAuthentication ()
{
    if ( this.authnHandle != null )
    {
        return;
    }

    final Dictionary<String, Object> properties = new Hashtable<String, Object> ();
    properties.put ( Constants.SERVICE_DESCRIPTION, "A dummy authentication service" );
    properties.put ( Constants.SERVICE_VENDOR, "Eclipse SCADA Project" );
    properties.put ( Constants.SERVICE_RANKING, this.authenticationPriority );

    System.out.println ( String.format ( "Injecting dummy authentication service with priority: %s", this.authenticationPriority ) );
    this.authnHandle = this.context.registerService ( AuthenticationService.class, this.authenticationService, properties );
}
 

private Hashtable<String, Object> actionCd(String sessionId, Hashtable<String, Object> input) throws JLIException {
       String dirname = checkStringParameter(input, PARAM_DIRNAME, true);
       
	String outdir = proeHandler.cd(dirname, sessionId);
	
	if (outdir!=null) {
		Hashtable<String, Object> out = new Hashtable<String, Object>();
		out.put(OUTPUT_DIRNAME, outdir);
		return out;
	}
	return null;
}
 

@Override
public void getReward(MissionInit missionInit, MultidimensionalReward reward) {
    super.getReward(missionInit, reward);
    try {
        Hashtable<String, Object> properties = MalmoMod.getPropertiesForCurrentThread();
        if (properties.containsKey("QuitCode")) {
            float reward_value = parseQuitCode((String) properties.get("QuitCode"));
            reward.add( this.params.getDimension(), reward_value);
        }
    } catch (Exception e) {
    }
}
 

@Override
public void start ( final BundleContext context ) throws Exception
{
    this.executor = Executors.newSingleThreadExecutor ( new NamedThreadFactory ( context.getBundle ().getSymbolicName () ) );

    this.factory = new ProxyMonitorQueryFactory ( context, this.executor );

    final Hashtable<String, Object> properties = new Hashtable<String, Object> ();
    properties.put ( Constants.SERVICE_DESCRIPTION, "Eclipse SCADA Proxy Monitor Query" );
    properties.put ( Constants.SERVICE_VENDOR, "Eclipse SCADA Project" );
    properties.put ( ConfigurationAdministrator.FACTORY_ID, ProxyMonitorQueryFactory.FACTORY_ID );
    this.handle = context.registerService ( ConfigurationFactory.class, this.factory, properties );
}
 

public ReadServerTimeoutTest(Hashtable env) throws IOException {
    super(env);
}
 

public void setConfirmedFulfillmentTimeRange(Hashtable confirmedFulfillmentTimeRange) {
  this.confirmedFulfillmentTimeRange = confirmedFulfillmentTimeRange;
}