text:
package org.fest.swing.util;

import org.junit.Test;

/**
 * Tests for {@link Colors#colorFromHexString(String)}, passing invalid input.
 *
 * @author Alex Ruiz
 */
public class Colors_colorFromHexString_withInvalidInput_Test {
  @Test(expected = NumberFormatException.class)
  public void should_throw_error_if_hex_String_is_not_valid() {
    Colors.colorFromHexString("zz");
  }

  @Test(expected = NullPointerException.class)
  public void should_throw_error_if_hex_String_is_null() {
    Colors.colorFromHexString(null);
  }

  @Test(expected = IllegalArgumentException.class)
  public void should_throw_error_if_hex_String_is_empty() {
    Colors.colorFromHexString("");
  }
}


text:
import '#3p/polyfills';

import {register} from '#3p/3p';
import {draw3p, init} from '#3p/integration-lib';

import {tracdelight} from '#ads/vendors/tracdelight';

init(window);
register('tracdelight', tracdelight);

window.draw3p = draw3p;

redpajama_set_name: RedPajamaGithub


text:
//
// Added support for thiscall methods by Jordi Oliveras Rovira in April, 2014.
//

#include <stdio.h>

#include "as_config.h"

#ifndef AS_MAX_PORTABILITY
#ifdef AS_X64_MSVC

#include "as_callfunc.h"
#include "as_scriptengine.h"
#include "as_texts.h"
#include "as_context.h"

BEGIN_AS_NAMESPACE

// These functions are implemented in as_callfunc_x64_msvc.asm
extern "C" asQWORD CallX64(const asQWORD *args, const asQWORD *floatArgs, int paramSize, asQWORD func);
extern "C" asDWORD GetReturnedFloat();
extern "C" asQWORD GetReturnedDouble();

asQWORD CallSystemFunctionNative(asCContext *context, asCScriptFunction *descr, void *obj, asDWORD *args, void *retPointer, asQWORD &/*retQW2*/, void *secondObject)
{
	asCScriptEngine *engine = context->m_engine;
	asSSystemFunctionInterface *sysFunc = descr->sysFuncIntf;

	asQWORD  retQW             = 0;
	void    *func              = (void*)sysFunc->func;
	asUINT   paramSize         = 0; // QWords
	void   **vftable;

	asQWORD  allArgBuffer[64];
	asQWORD  floatArgBuffer[4];

	int callConv = sysFunc->callConv;

	// Optimization to avoid check 12 values (all ICC_ that contains THISCALL)
	if( (callConv >= ICC_THISCALL && callConv <= ICC_VIRTUAL_THISCALL_RETURNINMEM) ||
		(callConv >= ICC_THISCALL_OBJLAST && callConv <= ICC_VIRTUAL_THISCALL_OBJFIRST_RETURNINMEM) )
	{
		// Add the object pointer as the first parameter
		allArgBuffer[paramSize++] = (asQWORD)obj;
	}

	if( sysFunc->hostReturnInMemory )
	{
		// The return is made in memory
		callConv++;

		// Set the return pointer as the first argument
		allArgBuffer[paramSize++] = (asQWORD)retPointer;
	}

	if( callConv == ICC_CDECL_OBJFIRST ||
		callConv == ICC_CDECL_OBJFIRST_RETURNINMEM )
	{
		// Add the object pointer as the first parameter
		allArgBuffer[paramSize++] = (asQWORD)obj;
	}
	else if( callConv == ICC_THISCALL_OBJFIRST ||
		callConv == ICC_THISCALL_OBJFIRST_RETURNINMEM ||
		callConv == ICC_VIRTUAL_THISCALL_OBJFIRST ||
		callConv == ICC_VIRTUAL_THISCALL_OBJFIRST_RETURNINMEM )
	{
		// Add the object pointer as the first parameter
		allArgBuffer[paramSize++] = (asQWORD)secondObject;
	}

	if( callConv == ICC_VIRTUAL_THISCALL ||
		callConv == ICC_VIRTUAL_THISCALL_RETURNINMEM ||
		callConv == ICC_VIRTUAL_THISCALL_OBJFIRST ||
		callConv == ICC_VIRTUAL_THISCALL_OBJFIRST_RETURNINMEM ||
		callConv == ICC_VIRTUAL_THISCALL_OBJLAST ||
		callConv == ICC_VIRTUAL_THISCALL_OBJLAST_RETURNINMEM )
	{
		// Get the true function pointer from the virtual function table
		vftable = *(void***)obj;
		func = vftable[asPWORD(func)>>2];
	}

	// Move the arguments to the buffer
	asUINT dpos = paramSize;
	asUINT spos = 0;
	for( asUINT n = 0; n < descr->parameterTypes.GetLength(); n++ )
	{
		asCDataType &dt = descr->parameterTypes[n];
		if( dt.IsObject() && !dt.IsObjectHandle() && !dt.IsReference() )
		{
			if( dt.GetSizeInMemoryDWords() >= AS_LARGE_OBJ_MIN_SIZE ||
				(dt.GetTypeInfo()->flags & COMPLEX_MASK) )
			{
				allArgBuffer[dpos++] = *(asQWORD*)&args[spos];
				spos += AS_PTR_SIZE;
				paramSize++;
			}
			else
			{
				// Copy the object's memory to the buffer
				memcpy(&allArgBuffer[dpos], *(void**)(args+spos), dt.GetSizeInMemoryBytes());

				// Delete the original memory
				engine->CallFree(*(char**)(args+spos));
				spos += AS_PTR_SIZE;
				asUINT dwords = dt.GetSizeInMemoryDWords();
				asUINT qwords = (dwords >> 1) + (dwords & 1);
				dpos      += qwords;
				paramSize += qwords;
			}
		}
		else if( dt.GetTokenType() == ttQuestion )
		{
			// Copy the reference and the type id
			allArgBuffer[dpos++] = *(asQWORD*)&args[spos];
			spos += 2;
			allArgBuffer[dpos++] = args[spos++];
			paramSize += 2;
		}
		else
		{
			// Copy the value directly
			asUINT dwords = dt.GetSizeOnStackDWords();
			if( dwords > 1 )
			{
				allArgBuffer[dpos] = *(asQWORD*)&args[spos];

				// Double arguments are moved to a separate buffer in order to be placed in the XMM registers,
				// though this is only done for first 4 arguments, the rest are placed on the stack
				if( paramSize < 4 && dt.IsDoubleType() )
					floatArgBuffer[dpos] = *(asQWORD*)&args[spos];

				dpos++;
				spos += 2;
			}
			else
			{
				allArgBuffer[dpos] = args[spos];

				// Float arguments are moved to a separate buffer in order to be placed in the XMM registers,
				// though this is only done for first 4 arguments, the rest are placed on the stack
				if( paramSize < 4 && dt.IsFloatType() )
					floatArgBuffer[dpos] = args[spos];

				dpos++;
				spos++;
			}

			paramSize++;
		}
	}

	if( callConv == ICC_CDECL_OBJLAST ||
		callConv == ICC_CDECL_OBJLAST_RETURNINMEM )
	{
		// Add the object pointer as the last parameter
		allArgBuffer[paramSize++] = (asQWORD)obj;
	}
	else if( callConv == ICC_THISCALL_OBJLAST ||
		callConv == ICC_THISCALL_OBJLAST_RETURNINMEM ||
		callConv == ICC_VIRTUAL_THISCALL_OBJLAST ||
		callConv == ICC_VIRTUAL_THISCALL_OBJLAST_RETURNINMEM )
	{
		// Add the object pointer as the last parameter
		allArgBuffer[paramSize++] = (asQWORD)secondObject;
	}

	retQW = CallX64(allArgBuffer, floatArgBuffer, paramSize*8, (asPWORD)func);

	// If the return is a float value we need to get the value from the FP register
	if( sysFunc->hostReturnFloat )
	{
		if( sysFunc->hostReturnSize == 1 )
			*(asDWORD*)&retQW = GetReturnedFloat();
		else
			retQW = GetReturnedDouble();
	}

	return retQW;
}

END_AS_NAMESPACE

#endif // AS_X64_MSVC
#endif // AS_MAX_PORTABILITY


text:
<?xml version="1.0" encoding="utf-8"?>
<android.support.v4.widget.SwipeRefreshLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/refreshLayout"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <android.support.v7.widget.RecyclerView
        android:id="@+id/newsList"
        android:name="com.java.a35.newsapp.NewsListFragment"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        app:layoutManager="LinearLayoutManager"
        tools:context="com.java.a35.newsapp.NewsListActivity"
        tools:listitem="@layout/news_list_item" />

</android.support.v4.widget.SwipeRefreshLayout>


text:
package org.openqa.selenium.remote.server.renderer;

import org.openqa.selenium.remote.BeanToJsonConverter;
import org.openqa.selenium.remote.server.rest.Handler;
import org.openqa.selenium.remote.server.rest.Renderer;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class JsonResult implements Renderer {

  protected String propertyName;

  public JsonResult(String propertyName) {
    if (propertyName.startsWith(":")) {
      this.propertyName = propertyName.substring(1);
    } else {
      this.propertyName = propertyName;
    }
  }

  public void render(HttpServletRequest request, HttpServletResponse response, Handler handler)
      throws Exception {
    Object result = request.getAttribute(propertyName);

    String json = new BeanToJsonConverter().convert(result);

    int length = json == null ? 0 : json.getBytes().length;

    response.setContentLength(length);
    response.setContentType("application/json");
    response.getWriter().append(json).flush();
  }
}


text:
import React, { Component } from 'react'
import { Form, Checkbox } from 'stardust'

export default class CheckboxDisabledExample extends Component {
  render() {
    return (
      <Form>
        <Form.Field>
          <Checkbox label='Disabled' disabled />
        </Form.Field>
        <Form.Field>
          <Checkbox toggle label='Disabled' disabled />
        </Form.Field>
      </Form>
    )
  }
}


text:
<!DOCTYPE html>

	<title>Update record example</title>

			Update Your Email ID

		<form action="" method="post">
			Your ID :

			<input type="text" name="idToUpdate" />

			New Email ID:

			<input type="email" name="newEmail" />

			<input type="submit" name="updateBtn" value="Update>>"/>
		</form>

<?php
// include the connection file
include('connection.php');
if (isset($_POST['updateBtn'])) {
	 $idd = $_POST['idToUpdate']; // id to update
	 $newEmailId = $_POST['newEmail']; // new email id to be changed

    // write query and update it
	 $queryResult = mysql_query("UPDATE table_name SET email_column = '$newEmailId' WHERE id = '$idd' ") or die("email not updated".mysql_error());
	 // check if everything is fine
	 if ($queryResult) {
	 	  echo "
Email ID updated Succesfully!!
";
	 }
	 else{
	 	// print the negative message of failure
	 	die("Something happened wrong with script".mysql_error());
	 }

}

?>


text:
#include "server.h"

/*-----------------------------------------------------------------------------
 * Incremental collection of expired keys.
 *
 * When keys are accessed they are expired on-access. However we need a
 * mechanism in order to ensure keys are eventually removed when expired even
 * if no access is performed on them.
 *----------------------------------------------------------------------------*/

/* Helper function for the activeExpireCycle() function.
 * This function will try to expire the key that is stored in the hash table
 * entry 'de' of the 'expires' hash table of a Redis database.
 *
 * If the key is found to be expired, it is removed from the database and
 * 1 is returned. Otherwise no operation is performed and 0 is returned.
 *
 * When a key is expired, server.stat_expiredkeys is incremented.
 *
 * The parameter 'now' is the current time in milliseconds as is passed
 * to the function to avoid too many gettimeofday() syscalls. */
int activeExpireCycleTryExpire(redisDb *db, dictEntry *de, long long now) {
    long long t = dictGetSignedIntegerVal(de);
    if (now > t) {
        sds key = dictGetKey(de);
        robj *keyobj = createStringObject(key,sdslen(key));

        propagateExpire(db,keyobj,server.lazyfree_lazy_expire);
        if (server.lazyfree_lazy_expire)
            dbAsyncDelete(db,keyobj);
        else
            dbSyncDelete(db,keyobj);
        notifyKeyspaceEvent(NOTIFY_EXPIRED,
            "expired",keyobj,db->id);
        decrRefCount(keyobj);
        server.stat_expiredkeys++;
        return 1;
    } else {
        return 0;
    }
}

/* Try to expire a few timed out keys. The algorithm used is adaptive and
 * will use few CPU cycles if there are few expiring keys, otherwise
 * it will get more aggressive to avoid that too much memory is used by
 * keys that can be removed from the keyspace.
 *
 * No more than CRON_DBS_PER_CALL databases are tested at every
 * iteration.
 *
 * This kind of call is used when Redis detects that timelimit_exit is
 * true, so there is more work to do, and we do it more incrementally from
 * the beforeSleep() function of the event loop.
 *
 * Expire cycle type:
 *
 * If type is ACTIVE_EXPIRE_CYCLE_FAST the function will try to run a
 * "fast" expire cycle that takes no longer than EXPIRE_FAST_CYCLE_DURATION
 * microseconds, and is not repeated again before the same amount of time.
 *
 * If type is ACTIVE_EXPIRE_CYCLE_SLOW, that normal expire cycle is
 * executed, where the time limit is a percentage of the REDIS_HZ period
 * as specified by the REDIS_EXPIRELOOKUPS_TIME_PERC define. */

void activeExpireCycle(int type) {
    /* This function has some global state in order to continue the work
     * incrementally across calls. */
    static unsigned int current_db = 0; /* Last DB tested. */
    static int timelimit_exit = 0;      /* Time limit hit in previous call? */
    static long long last_fast_cycle = 0; /* When last fast cycle ran. */

    int j, iteration = 0;
    int dbs_per_call = CRON_DBS_PER_CALL;
    long long start = ustime(), timelimit;

    if (type == ACTIVE_EXPIRE_CYCLE_FAST) {
        /* Don't start a fast cycle if the previous cycle did not exited
         * for time limt. Also don't repeat a fast cycle for the same period
         * as the fast cycle total duration itself. */
        if (!timelimit_exit) return;
        if (start < last_fast_cycle + ACTIVE_EXPIRE_CYCLE_FAST_DURATION*2) return;
        last_fast_cycle = start;
    }

    /* We usually should test CRON_DBS_PER_CALL per iteration, with
     * two exceptions:
     *
     * 1) Don't test more DBs than we have.
     * 2) If last time we hit the time limit, we want to scan all DBs
     * in this iteration, as there is work to do in some DB and we don't want
     * expired keys to use memory for too much time. */
    if (dbs_per_call > server.dbnum || timelimit_exit)
        dbs_per_call = server.dbnum;

    /* We can use at max ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC percentage of CPU time
     * per iteration. Since this function gets called with a frequency of
     * server.hz times per second, the following is the max amount of
     * microseconds we can spend in this function. */
    timelimit = 1000000*ACTIVE_EXPIRE_CYCLE_SLOW_TIME_PERC/server.hz/100;
    timelimit_exit = 0;
    if (timelimit <= 0) timelimit = 1;

    if (type == ACTIVE_EXPIRE_CYCLE_FAST)
        timelimit = ACTIVE_EXPIRE_CYCLE_FAST_DURATION; /* in microseconds. */

    for (j = 0; j < dbs_per_call; j++) {
        int expired;
        redisDb *db = server.db+(current_db % server.dbnum);

        /* Increment the DB now so we are sure if we run out of time
         * in the current DB we'll restart from the next. This allows to
         * distribute the time evenly across DBs. */
        current_db++;

        /* Continue to expire if at the end of the cycle more than 25%
         * of the keys were expired. */
        do {
            unsigned long num, slots;
            long long now, ttl_sum;
            int ttl_samples;

            /* If there is nothing to expire try next DB ASAP. */
            if ((num = dictSize(db->expires)) == 0) {
                db->avg_ttl = 0;
                break;
            }
            slots = dictSlots(db->expires);
            now = mstime();

            /* When there are less than 1% filled slots getting random
             * keys is expensive, so stop here waiting for better times...
             * The dictionary will be resized asap. */
            if (num && slots > DICT_HT_INITIAL_SIZE &&
                (num*100/slots < 1)) break;

            /* The main collection cycle. Sample random keys among keys
             * with an expire set, checking for expired ones. */
            expired = 0;
            ttl_sum = 0;
            ttl_samples = 0;

            if (num > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP)
                num = ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP;

            while (num--) {
                dictEntry *de;
                long long ttl;

                if ((de = dictGetRandomKey(db->expires)) == NULL) break;
                ttl = dictGetSignedIntegerVal(de)-now;
                if (activeExpireCycleTryExpire(db,de,now)) expired++;
                if (ttl > 0) {
                    /* We want the average TTL of keys yet not expired. */
                    ttl_sum += ttl;
                    ttl_samples++;
                }
            }

            /* Update the average TTL stats for this database. */
            if (ttl_samples) {
                long long avg_ttl = ttl_sum/ttl_samples;

                /* Do a simple running average with a few samples.
                 * We just use the current estimate with a weight of 2%
                 * and the previous estimate with a weight of 98%. */
                if (db->avg_ttl == 0) db->avg_ttl = avg_ttl;
                db->avg_ttl = (db->avg_ttl/50)*49 + (avg_ttl/50);
            }

            /* We can't block forever here even if there are many keys to
             * expire. So after a given amount of milliseconds return to the
             * caller waiting for the other active expire cycle. */
            iteration++;
            if ((iteration & 0xf) == 0) { /* check once every 16 iterations. */
                long long elapsed = ustime()-start;

                latencyAddSampleIfNeeded("expire-cycle",elapsed/1000);
                if (elapsed > timelimit) timelimit_exit = 1;
            }
            if (timelimit_exit) return;
            /* We don't repeat the cycle if there are less than 25% of keys
             * found expired in the current DB. */
        } while (expired > ACTIVE_EXPIRE_CYCLE_LOOKUPS_PER_LOOP/4);
    }
}

/*-----------------------------------------------------------------------------
 * Expires Commands
 *----------------------------------------------------------------------------*/

/* This is the generic command implementation for EXPIRE, PEXPIRE, EXPIREAT
 * and PEXPIREAT. Because the commad second argument may be relative or absolute
 * the "basetime" argument is used to signal what the base time is (either 0
 * for *AT variants of the command, or the current time for relative expires).
 *
 * unit is either UNIT_SECONDS or UNIT_MILLISECONDS, and is only used for
 * the argv[2] parameter. The basetime is always specified in milliseconds. */
void expireGenericCommand(client *c, long long basetime, int unit) {
    robj *key = c->argv[1], *param = c->argv[2];
    long long when; /* unix time in milliseconds when the key will expire. */

    if (getLongLongFromObjectOrReply(c, param, &when, NULL) != C_OK)
        return;

    if (unit == UNIT_SECONDS) when *= 1000;
    when += basetime;

    /* No key, return zero. */
    if (lookupKeyWrite(c->db,key) == NULL) {
        addReply(c,shared.czero);
        return;
    }

    /* EXPIRE with negative TTL, or EXPIREAT with a timestamp into the past
     * should never be executed as a DEL when load the AOF or in the context
     * of a slave instance.
     *
     * Instead we take the other branch of the IF statement setting an expire
     * (possibly in the past) and wait for an explicit DEL from the master. */
    if (when <= mstime() && !server.loading && !server.masterhost) {
        robj *aux;

        int deleted = server.lazyfree_lazy_expire ? dbAsyncDelete(c->db,key) :
                                                    dbSyncDelete(c->db,key);
        serverAssertWithInfo(c,key,deleted);
        server.dirty++;

        /* Replicate/AOF this as an explicit DEL or UNLINK. */
        aux = server.lazyfree_lazy_expire ? shared.unlink : shared.del;
        rewriteClientCommandVector(c,2,aux,key);
        signalModifiedKey(c->db,key);
        notifyKeyspaceEvent(NOTIFY_GENERIC,"del",key,c->db->id);
        addReply(c, shared.cone);
        return;
    } else {
        setExpire(c->db,key,when);
        addReply(c,shared.cone);
        signalModifiedKey(c->db,key);
        notifyKeyspaceEvent(NOTIFY_GENERIC,"expire",key,c->db->id);
        server.dirty++;
        return;
    }
}

/* EXPIRE key seconds */
void expireCommand(client *c) {
    expireGenericCommand(c,mstime(),UNIT_SECONDS);
}

/* EXPIREAT key time */
void expireatCommand(client *c) {
    expireGenericCommand(c,0,UNIT_SECONDS);
}

/* PEXPIRE key milliseconds */
void pexpireCommand(client *c) {
    expireGenericCommand(c,mstime(),UNIT_MILLISECONDS);
}

/* PEXPIREAT key ms_time */
void pexpireatCommand(client *c) {
    expireGenericCommand(c,0,UNIT_MILLISECONDS);
}

/* Implements TTL and PTTL */
void ttlGenericCommand(client *c, int output_ms) {
    long long expire, ttl = -1;

    /* If the key does not exist at all, return -2 */
    if (lookupKeyReadWithFlags(c->db,c->argv[1],LOOKUP_NOTOUCH) == NULL) {
        addReplyLongLong(c,-2);
        return;
    }
    /* The key exists. Return -1 if it has no expire, or the actual
     * TTL value otherwise. */
    expire = getExpire(c->db,c->argv[1]);
    if (expire != -1) {
        ttl = expire-mstime();
        if (ttl < 0) ttl = 0;
    }
    if (ttl == -1) {
        addReplyLongLong(c,-1);
    } else {
        addReplyLongLong(c,output_ms ? ttl : ((ttl+500)/1000));
    }
}

/* TTL key */
void ttlCommand(client *c) {
    ttlGenericCommand(c, 0);
}

/* PTTL key */
void pttlCommand(client *c) {
    ttlGenericCommand(c, 1);
}

/* PERSIST key */
void persistCommand(client *c) {
    dictEntry *de;

    de = dictFind(c->db->dict,c->argv[1]->ptr);
    if (de == NULL) {
        addReply(c,shared.czero);
    } else {
        if (removeExpire(c->db,c->argv[1])) {
            addReply(c,shared.cone);
            server.dirty++;
        } else {
            addReply(c,shared.czero);
        }
    }
}

/* TOUCH key1 [key2 key3 ... keyN] */
void touchCommand(client *c) {
    int touched = 0;
    for (int j = 1; j < c->argc; j++)
        if (lookupKeyRead(c->db,c->argv[j]) != NULL) touched++;
    addReplyLongLong(c,touched);
}


text:
using namespace std;

TEST(MergeSortAlgorithmTest, sortEmptyIntegerListBottomUp) {
    int expectedValue = 0;
    array<int, SMALL_SIZE>* testArray = new array<int, SMALL_SIZE>();

    TestSuiteService service;
    service.fillArrayWithValue(*testArray, expectedValue);

    MergeSortAlgorithm algorithm;
    algorithm.sortBottomUp(*testArray);

    EXPECT_TRUE(service.verifyExpectedValueAlgorithmResult(expectedValue, *testArray));
    delete testArray;
}

TEST(MergeSortAlgorithmTest, sortASCIntegerListBottomUp) {
    array<int, SMALL_SIZE>* testArray = new array<int, SMALL_SIZE>();

    TestSuiteService service;
    service.fillArrayAsc(*testArray);

    MergeSortAlgorithm algorithm;
    algorithm.sortBottomUp(*testArray);

    EXPECT_TRUE(service.verifyAlgorithmResult(*testArray));
    delete testArray;
}

TEST(MergeSortAlgorithmTest, sortDESCIntegerListBottomUp) {
    array<int, SMALL_SIZE>* testArray = new array<int, SMALL_SIZE>();

    TestSuiteService service;
    service.fillArrayDesc(*testArray);

    MergeSortAlgorithm algorithm;
    algorithm.sortBottomUp(*testArray);

    EXPECT_TRUE(service.verifyAlgorithmResult(*testArray));
    delete testArray;
}

TEST(MergeSortAlgorithmTest, sortLargeIntegerListBottomUp) {
    array<int, LARGE_SIZE>* testArray = new array<int, LARGE_SIZE>();

    TestSuiteService service;
    service.fillArrayDesc(*testArray);

    MergeSortAlgorithm algorithm;
    algorithm.sortBottomUp(*testArray);

    EXPECT_TRUE(service.verifyAlgorithmResult(*testArray));
    delete testArray;
}

TEST(MergeSortAlgorithmTest, sortEmptyDoubleListBottomUp) {
    double expectedValue = 0.0;
    array<double, SMALL_SIZE>* testArray = new array<double, SMALL_SIZE>();

    TestSuiteService service;
    service.fillArrayWithValue(*testArray, expectedValue);

    MergeSortAlgorithm algorithm;
    algorithm.sortBottomUp(*testArray);

    EXPECT_TRUE(service.verifyExpectedValueAlgorithmResult(expectedValue, *testArray));
    delete testArray;
}

TEST(MergeSortAlgorithmTest, sortASCIDoubleListBottomUp) {
    array<double, SMALL_SIZE>* testArray = new array<double, SMALL_SIZE>();

    TestSuiteService service;
    service.fillArrayAsc(*testArray);

    MergeSortAlgorithm algorithm;
    algorithm.sortBottomUp(*testArray);

    EXPECT_TRUE(service.verifyAlgorithmResult(*testArray));
    delete testArray;
}

TEST(MergeSortAlgorithmTest, sortDESCDoubleListBottomUp) {
    array<double, SMALL_SIZE>* testArray = new array<double, SMALL_SIZE>();

    TestSuiteService service;
    service.fillArrayDesc(*testArray);

    MergeSortAlgorithm algorithm;
    algorithm.sortBottomUp(*testArray);

    EXPECT_TRUE(service.verifyAlgorithmResult(*testArray));
    delete testArray;
}

TEST(MergeSortAlgorithmTest, sortLargeDoubleListBottomUp) {
    array<double, LARGE_SIZE>* testArray = new array<double, LARGE_SIZE>();

    TestSuiteService service;
    service.fillArrayDesc(*testArray);

    MergeSortAlgorithm algorithm;
    algorithm.sortBottomUp(*testArray);

    EXPECT_TRUE(service.verifyAlgorithmResult(*testArray));
    delete testArray;
}

TEST(MergeSortAlgorithmTest, sortEmptyStringListBottomUp) {
    string expectedValue = "";
    array<string, SMALL_SIZE>* testArray = new array<string, SMALL_SIZE>();

    TestSuiteService service;
    service.fillArrayWithValue(*testArray, expectedValue);

    MergeSortAlgorithm algorithm;
    algorithm.sortBottomUp(*testArray);

    EXPECT_TRUE(service.verifyExpectedValueAlgorithmResult(expectedValue, *testArray));
    delete testArray;
}

TEST(MergeSortAlgorithmTest, sortASCStringListBottomUp) {
    array<string, SMALL_SIZE>* testArray = new array<string, SMALL_SIZE>();

    TestSuiteService service;
    service.fillArrayAsc(*testArray);

    MergeSortAlgorithm algorithm;
    algorithm.sortBottomUp(*testArray);

    EXPECT_TRUE(service.verifyAlgorithmResult(*testArray));
    delete testArray;
}

TEST(MergeSortAlgorithmTest, sortDESCStringListBottomUp) {
    array<string, SMALL_SIZE>* testArray = new array<string, SMALL_SIZE>();

    TestSuiteService service;
    service.fillArrayDesc(*testArray);

    MergeSortAlgorithm algorithm;
    algorithm.sortBottomUp(*testArray);

    EXPECT_TRUE(service.verifyAlgorithmResult(*testArray));
    delete testArray;
}

TEST(MergeSortAlgorithmTest, sortLargeStringListBottomUp) {
    array<string, LARGE_SIZE>* testArray = new array<string, LARGE_SIZE>();

    TestSuiteService service;
    service.fillArrayDesc(*testArray);

    MergeSortAlgorithm algorithm;
    algorithm.sortBottomUp(*testArray);

    EXPECT_TRUE(service.verifyAlgorithmResult(*testArray));
    delete testArray;
}

TEST(MergeSortAlgorithmTest, sortEmptyIntegerListNatural) {
    int expectedValue = 0;
    array<int, SMALL_SIZE>* testArray = new array<int, SMALL_SIZE>();

    TestSuiteService service;
    service.fillArrayWithValue(*testArray, expectedValue);

    MergeSortAlgorithm algorithm;
    algorithm.sortNatural(*testArray);

    EXPECT_TRUE(service.verifyExpectedValueAlgorithmResult(expectedValue, *testArray));
    delete testArray;
}

TEST(MergeSortAlgorithmTest, sortASCIntegerListNatural) {
    array<int, SMALL_SIZE>* testArray = new array<int, SMALL_SIZE>();

    TestSuiteService service;
    service.fillArrayAsc(*testArray);

    MergeSortAlgorithm algorithm;
    algorithm.sortNatural(*testArray);

    EXPECT_TRUE(service.verifyAlgorithmResult(*testArray));
    delete testArray;
}

TEST(MergeSortAlgorithmTest, sortDESCIntegerListNatural) {
    array<int, SMALL_SIZE>* testArray = new array<int, SMALL_SIZE>();

    TestSuiteService service;
    service.fillArrayDesc(*testArray);

    MergeSortAlgorithm algorithm;
    algorithm.sortNatural(*testArray);

    EXPECT_TRUE(service.verifyAlgorithmResult(*testArray));
    delete testArray;
}

TEST(MergeSortAlgorithmTest, sortLargeIntegerListNatural) {
    array<int, LARGE_SIZE>* testArray = new array<int, LARGE_SIZE>();

    TestSuiteService service;
    service.fillArrayDesc(*testArray);

    MergeSortAlgorithm algorithm;
    algorithm.sortNatural(*testArray);

    EXPECT_TRUE(service.verifyAlgorithmResult(*testArray));
    delete testArray;
}

TEST(MergeSortAlgorithmTest, sortEmptyListDoubleNatural) {
    double expectedValue = 0.0;
    array<double, SMALL_SIZE>* testArray = new array<double, SMALL_SIZE>();

    TestSuiteService service;
    service.fillArrayWithValue(*testArray, expectedValue);

    MergeSortAlgorithm algorithm;
    algorithm.sortNatural(*testArray);

    EXPECT_TRUE(service.verifyExpectedValueAlgorithmResult(expectedValue, *testArray));
    delete testArray;
}

TEST(MergeSortAlgorithmTest, sortASCListDoubleNatural) {
    array<double, SMALL_SIZE>* testArray = new array<double, SMALL_SIZE>();

    TestSuiteService service;
    service.fillArrayAsc(*testArray);

    MergeSortAlgorithm algorithm;
    algorithm.sortNatural(*testArray);

    EXPECT_TRUE(service.verifyAlgorithmResult(*testArray));
    delete testArray;
}

TEST(MergeSortAlgorithmTest, sortDESCListDoubleNatural) {
    array<double, SMALL_SIZE>* testArray = new array<double, SMALL_SIZE>();

    TestSuiteService service;
    service.fillArrayAsc(*testArray);

    MergeSortAlgorithm algorithm;
    algorithm.sortNatural(*testArray);

    EXPECT_TRUE(service.verifyAlgorithmResult(*testArray));
    delete testArray;
}

TEST(MergeSortAlgorithmTest, sortLargeDoubleListNatural) {
    array<double, LARGE_SIZE>* testArray = new array<double, LARGE_SIZE>();

    TestSuiteService service;
    service.fillArrayDesc(*testArray);

    MergeSortAlgorithm algorithm;
    algorithm.sortNatural(*testArray);

    EXPECT_TRUE(service.verifyAlgorithmResult(*testArray));
    delete testArray;
}

TEST(MergeSortAlgorithmTest, sortEmptyStringListNatural) {
    string expectedValue = "";
    array<string, SMALL_SIZE>* testArray = new array<string, SMALL_SIZE>();

    TestSuiteService service;
    service.fillArrayWithValue(*testArray, expectedValue);

    MergeSortAlgorithm algorithm;
    algorithm.sortNatural(*testArray);

    EXPECT_TRUE(service.verifyExpectedValueAlgorithmResult(expectedValue, *testArray));
    delete testArray;
}

TEST(MergeSortAlgorithmTest, sortASCStringListNatural) {
    array<string, SMALL_SIZE>* testArray = new array<string, SMALL_SIZE>();

    TestSuiteService service;
    service.fillArrayAsc(*testArray);

    MergeSortAlgorithm algorithm;
    algorithm.sortNatural(*testArray);

    EXPECT_TRUE(service.verifyAlgorithmResult(*testArray));
    delete testArray;
}

TEST(MergeSortAlgorithmTest, sortDESCStringListNatural) {
    array<string, SMALL_SIZE>* testArray = new array<string, SMALL_SIZE>();

    TestSuiteService service;
    service.fillArrayDesc(*testArray);

    MergeSortAlgorithm algorithm;
    algorithm.sortNatural(*testArray);

    EXPECT_TRUE(service.verifyAlgorithmResult(*testArray));
    delete testArray;
}

TEST(MergeSortAlgorithmTest, sortLargeStringListNatural) {
    array<string, LARGE_SIZE>* testArray = new array<string, LARGE_SIZE>();

    TestSuiteService service;
    service.fillArrayDesc(*testArray);

    MergeSortAlgorithm algorithm;
    algorithm.sortNatural(*testArray);

    EXPECT_TRUE(service.verifyAlgorithmResult(*testArray));
    delete testArray;
}


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<title>Uses of Class javax.management.ObjectName (Java Platform SE 8 )</title>
<meta name="date" content="2014-12-17">
<link rel="stylesheet" type="text/css" href="../../../stylesheet.css" title="Style">

JavaScript is disabled on your browser.

Skip navigation links

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Java™ Platform
Standard Ed. 8

Prev

Next

Frames

No Frames

All Classes

Uses of Class
javax.management.ObjectName

Packages that use ObjectName

Package
Description

java.lang.management

Provides the management interfaces for monitoring and management of the
Java virtual machine and other components in the Java runtime.

javax.management

Provides the core classes for the Java Management Extensions.

javax.management.loading

Provides the classes which implement advanced dynamic
        loading.

javax.management.modelmbean

Provides the definition of the ModelMBean classes.

javax.management.monitor

Provides the definition of the monitor classes.

javax.management.openmbean

Provides the open data types and Open MBean descriptor classes.

javax.management.relation

Provides the definition of the Relation Service.

javax.management.remote

Interfaces for remote access to
        JMX MBean servers.

javax.management.remote.rmi

The RMI connector is a connector for the JMX Remote API that
      uses RMI to transmit client requests to a remote MBean server.

javax.management.timer

Provides the definition of the Timer MBean.

Uses of ObjectName in java.lang.management

Methods in java.lang.management that return ObjectName

Modifier and Type
Method and Description

ObjectName
PlatformManagedObject.getObjectName()

Returns an ObjectName instance representing
 the object name of this platform managed object.

Uses of ObjectName in javax.management

Fields in javax.management declared as ObjectName

Modifier and Type
Field and Description

static ObjectName
MBeanServerDelegate.DELEGATE_NAME

Defines the default ObjectName of the MBeanServerDelegate.

static ObjectName
ObjectName.WILDCARD

Defines the wildcard "*:*" ObjectName.

Methods in javax.management that return ObjectName

Modifier and Type
Method and Description

static ObjectName
ObjectName.getInstance(ObjectName name)

Return an instance of ObjectName that can be used anywhere
 the given object can be used.

static ObjectName
ObjectName.getInstance(String name)

Return an instance of ObjectName that can be used anywhere
 an object obtained with new
 ObjectName(name) can be used.

static ObjectName
ObjectName.getInstance(String domain,
           Hashtable<String,String> table)

Return an instance of ObjectName that can be used anywhere
 an object obtained with new ObjectName(domain, table) can be used.

static ObjectName
ObjectName.getInstance(String domain,
           String key,
           String value)

Return an instance of ObjectName that can be used anywhere
 an object obtained with new ObjectName(domain, key, value) can be used.

ObjectName
MBeanServerNotification.getMBeanName()

Returns the  object name of the MBean that caused the notification.

ObjectName
MBeanServerInvocationHandler.getObjectName()

The name of the MBean within the MBean server to which methods
 are forwarded.

ObjectName
ObjectInstance.getObjectName()

Returns the object name part.

ObjectName
StandardMBean.preRegister(MBeanServer server,
           ObjectName name)

Allows the MBean to perform any operations it needs before
 being registered in the MBean server.

ObjectName
MBeanRegistration.preRegister(MBeanServer server,
           ObjectName name)

Allows the MBean to perform any operations it needs before
 being registered in the MBean Server.

Methods in javax.management that return types with arguments of type ObjectName

Modifier and Type
Method and Description

Set<ObjectName>
MBeanServer.queryNames(ObjectName name,
          QueryExp query)

Gets the names of MBeans controlled by the MBean server.

Set<ObjectName>
MBeanServerConnection.queryNames(ObjectName name,
          QueryExp query)

Gets the names of MBeans controlled by the MBean server.

Methods in javax.management with parameters of type ObjectName

Modifier and Type
Method and Description

void
MBeanServer.addNotificationListener(ObjectName name,
                       NotificationListener listener,
                       NotificationFilter filter,
                       Object handback)

Adds a listener to a registered MBean.

void
MBeanServerConnection.addNotificationListener(ObjectName name,
                       NotificationListener listener,
                       NotificationFilter filter,
                       Object handback)

Adds a listener to a registered MBean.

void
MBeanServer.addNotificationListener(ObjectName name,
                       ObjectName listener,
                       NotificationFilter filter,
                       Object handback)

Adds a listener to a registered MBean.

void
MBeanServerConnection.addNotificationListener(ObjectName name,
                       ObjectName listener,
                       NotificationFilter filter,
                       Object handback)

Adds a listener to a registered MBean.

ValueExp
StringValueExp.apply(ObjectName name)

Applies the ValueExp on a MBean.

ValueExp
AttributeValueExp.apply(ObjectName name)

Applies the AttributeValueExp on an MBean.

ValueExp
ValueExp.apply(ObjectName name)

Applies the ValueExp on a MBean.

boolean
QueryExp.apply(ObjectName name)

Applies the QueryExp on an MBean.

boolean
ObjectName.apply(ObjectName name)

Test whether this ObjectName, which may be a pattern,
 matches another ObjectName.

int
ObjectName.compareTo(ObjectName name)

Compares two ObjectName instances.

ObjectInstance
MBeanServer.createMBean(String className,
           ObjectName name)

Instantiates and registers an MBean in the MBean server.

ObjectInstance
MBeanServerConnection.createMBean(String className,
           ObjectName name)

Instantiates and registers an MBean in the MBean server.

ObjectInstance
MBeanServer.createMBean(String className,
           ObjectName name,
           Object[] params,
           String[] signature)

Instantiates and registers an MBean in the MBean server.

ObjectInstance
MBeanServerConnection.createMBean(String className,
           ObjectName name,
           Object[] params,
           String[] signature)

Instantiates and registers an MBean in the MBean server.

ObjectInstance
MBeanServer.createMBean(String className,
           ObjectName name,
           ObjectName loaderName)

Instantiates and registers an MBean in the MBean server.

ObjectInstance
MBeanServerConnection.createMBean(String className,
           ObjectName name,
           ObjectName loaderName)

Instantiates and registers an MBean in the MBean server.

ObjectInstance
MBeanServer.createMBean(String className,
           ObjectName name,
           ObjectName loaderName,
           Object[] params,
           String[] signature)

Instantiates and registers an MBean in the MBean server.

ObjectInstance
MBeanServerConnection.createMBean(String className,
           ObjectName name,
           ObjectName loaderName,
           Object[] params,
           String[] signature)

Instantiates and registers an MBean in the MBean server.

ObjectInputStream
MBeanServer.deserialize(ObjectName name,
           byte[] data)

Deprecated.

Use getClassLoaderFor to
 obtain the appropriate class loader for deserialization.

ObjectInputStream
MBeanServer.deserialize(String className,
           ObjectName loaderName,
           byte[] data)

Deprecated.

Use getClassLoader to obtain
 the class loader for deserialization.

protected Object
AttributeValueExp.getAttribute(ObjectName name)

Return the value of the given attribute in the named MBean.

Object
MBeanServer.getAttribute(ObjectName name,
            String attribute)

Object
MBeanServerConnection.getAttribute(ObjectName name,
            String attribute)

Gets the value of a specific attribute of a named MBean.

AttributeList
MBeanServer.getAttributes(ObjectName name,
             String[] attributes)

AttributeList
MBeanServerConnection.getAttributes(ObjectName name,
             String[] attributes)

Retrieves the values of several attributes of a named MBean.

ClassLoader
MBeanServer.getClassLoader(ObjectName loaderName)

Return the named ClassLoader.

ClassLoader
MBeanServer.getClassLoaderFor(ObjectName mbeanName)

Return the ClassLoader that was used for
 loading the class of the named MBean.

static ObjectName
ObjectName.getInstance(ObjectName name)

Return an instance of ObjectName that can be used anywhere
 the given object can be used.

MBeanInfo
MBeanServer.getMBeanInfo(ObjectName name)

MBeanInfo
MBeanServerConnection.getMBeanInfo(ObjectName name)

This method discovers the attributes and operations that an
 MBean exposes for management.

ObjectInstance
MBeanServer.getObjectInstance(ObjectName name)

ObjectInstance
MBeanServerConnection.getObjectInstance(ObjectName name)

Gets the ObjectInstance for a given MBean
 registered with the MBean server.

Object
MBeanServer.instantiate(String className,
           ObjectName loaderName)

Instantiates an object using the class Loader specified by its
 ObjectName.

Object
MBeanServer.instantiate(String className,
           ObjectName loaderName,
           Object[] params,
           String[] signature)

Instantiates an object.

Object
MBeanServer.invoke(ObjectName name,
      String operationName,
      Object[] params,
      String[] signature)

Object
MBeanServerConnection.invoke(ObjectName name,
      String operationName,
      Object[] params,
      String[] signature)

Invokes an operation on an MBean.

boolean
MBeanServer.isInstanceOf(ObjectName name,
            String className)

boolean
MBeanServerConnection.isInstanceOf(ObjectName name,
            String className)

Returns true if the MBean specified is an instance of the
 specified class, false otherwise.

boolean
MBeanServer.isRegistered(ObjectName name)

boolean
MBeanServerConnection.isRegistered(ObjectName name)

Checks whether an MBean, identified by its object name, is
 already registered with the MBean server.

static <T> T
JMX.newMBeanProxy(MBeanServerConnection connection,
             ObjectName objectName,
             Class<T> interfaceClass)

Make a proxy for a Standard MBean in a local or remote
 MBean Server.

static <T> T
JMX.newMBeanProxy(MBeanServerConnection connection,
             ObjectName objectName,
             Class<T> interfaceClass,
             boolean notificationEmitter)

Make a proxy for a Standard MBean in a local or remote MBean
 Server that may also support the methods of NotificationEmitter.

static <T> T
JMX.newMXBeanProxy(MBeanServerConnection connection,
              ObjectName objectName,
              Class<T> interfaceClass)

Make a proxy for an MXBean in a local or remote MBean Server.

static <T> T
JMX.newMXBeanProxy(MBeanServerConnection connection,
              ObjectName objectName,
              Class<T> interfaceClass,
              boolean notificationEmitter)

Make a proxy for an MXBean in a local or remote MBean
 Server that may also support the methods of NotificationEmitter.

static <T> T
MBeanServerInvocationHandler.newProxyInstance(MBeanServerConnection connection,
                ObjectName objectName,
                Class<T> interfaceClass,
                boolean notificationBroadcaster)

Return a proxy that implements the given interface by
 forwarding its methods through the given MBean server to the
 named MBean.

ObjectName
StandardMBean.preRegister(MBeanServer server,
           ObjectName name)

Allows the MBean to perform any operations it needs before
 being registered in the MBean server.

ObjectName
MBeanRegistration.preRegister(MBeanServer server,
           ObjectName name)

Allows the MBean to perform any operations it needs before
 being registered in the MBean Server.

Set<ObjectInstance>
MBeanServer.queryMBeans(ObjectName name,
           QueryExp query)

Gets MBeans controlled by the MBean server.

Set<ObjectInstance>
MBeanServerConnection.queryMBeans(ObjectName name,
           QueryExp query)

Gets MBeans controlled by the MBean server.

Set<ObjectName>
MBeanServer.queryNames(ObjectName name,
          QueryExp query)

Gets the names of MBeans controlled by the MBean server.

Set<ObjectName>
MBeanServerConnection.queryNames(ObjectName name,
          QueryExp query)

Gets the names of MBeans controlled by the MBean server.

ObjectInstance
MBeanServer.registerMBean(Object object,
             ObjectName name)

Registers a pre-existing object as an MBean with the MBean
 server.

void
MBeanServer.removeNotificationListener(ObjectName name,
                          NotificationListener listener)

void
MBeanServerConnection.removeNotificationListener(ObjectName name,
                          NotificationListener listener)

Removes a listener from a registered MBean.

void
MBeanServer.removeNotificationListener(ObjectName name,
                          NotificationListener listener,
                          NotificationFilter filter,
                          Object handback)

void
MBeanServerConnection.removeNotificationListener(ObjectName name,
                          NotificationListener listener,
                          NotificationFilter filter,
                          Object handback)

Removes a listener from a registered MBean.

void
MBeanServer.removeNotificationListener(ObjectName name,
                          ObjectName listener)

void
MBeanServerConnection.removeNotificationListener(ObjectName name,
                          ObjectName listener)

Removes a listener from a registered MBean.

void
MBeanServer.removeNotificationListener(ObjectName name,
                          ObjectName listener,
                          NotificationFilter filter,
                          Object handback)

void
MBeanServerConnection.removeNotificationListener(ObjectName name,
                          ObjectName listener,
                          NotificationFilter filter,
                          Object handback)

Removes a listener from a registered MBean.

void
MBeanServer.setAttribute(ObjectName name,
            Attribute attribute)

void
MBeanServerConnection.setAttribute(ObjectName name,
            Attribute attribute)

Sets the value of a specific attribute of a named MBean.

AttributeList
MBeanServer.setAttributes(ObjectName name,
             AttributeList attributes)

AttributeList
MBeanServerConnection.setAttributes(ObjectName name,
             AttributeList attributes)

Sets the values of several attributes of a named MBean.

void
MBeanServer.unregisterMBean(ObjectName name)

Unregisters an MBean from the MBean server.

void
MBeanServerConnection.unregisterMBean(ObjectName name)

Unregisters an MBean from the MBean server.

Constructors in javax.management with parameters of type ObjectName

Constructor and Description

MBeanPermission(String className,
               String member,
               ObjectName objectName,
               String actions)

Create a new MBeanPermission object with the specified target name
 (class name, member, object name) and actions.

MBeanServerInvocationHandler(MBeanServerConnection connection,
                            ObjectName objectName)

Invocation handler that forwards methods through an MBean
 server to a Standard MBean.

MBeanServerInvocationHandler(MBeanServerConnection connection,
                            ObjectName objectName,
                            boolean isMXBean)

Invocation handler that can forward methods through an MBean
 server to a Standard MBean or MXBean.

MBeanServerNotification(String type,
                       Object source,
                       long sequenceNumber,
                       ObjectName objectName)

Creates an MBeanServerNotification object specifying object names of
 the MBeans that caused the notification and the specified notification
 type.

ObjectInstance(ObjectName objectName,
              String className)

Allows an object instance to be created given an object name and
 the full class name, including the package name.

Uses of ObjectName in javax.management.loading

Methods in javax.management.loading that return ObjectName

Modifier and Type
Method and Description

ObjectName
MLet.preRegister(MBeanServer server,
           ObjectName name)

Allows the m-let to perform any operations it needs before
 being registered in the MBean server.

Methods in javax.management.loading with parameters of type ObjectName

Modifier and Type
Method and Description

ObjectName
MLet.preRegister(MBeanServer server,
           ObjectName name)

Allows the m-let to perform any operations it needs before
 being registered in the MBean server.

Uses of ObjectName in javax.management.modelmbean

Methods in javax.management.modelmbean that return ObjectName

Modifier and Type
Method and Description

ObjectName
RequiredModelMBean.preRegister(MBeanServer server,
           ObjectName name)

Allows the MBean to perform any operations it needs before
 being registered in the MBean server.

Methods in javax.management.modelmbean with parameters of type ObjectName

Modifier and Type
Method and Description

ObjectName
RequiredModelMBean.preRegister(MBeanServer server,
           ObjectName name)

Allows the MBean to perform any operations it needs before
 being registered in the MBean server.

Uses of ObjectName in javax.management.monitor

Methods in javax.management.monitor that return ObjectName

Modifier and Type
Method and Description

ObjectName
Monitor.getObservedObject()

Deprecated.

As of JMX 1.2, replaced by Monitor.getObservedObjects()

ObjectName
MonitorNotification.getObservedObject()

Gets the observed object of this monitor notification.

ObjectName
MonitorMBean.getObservedObject()

Deprecated.

As of JMX 1.2, replaced by MonitorMBean.getObservedObjects()

ObjectName[]
Monitor.getObservedObjects()

Returns an array containing the objects being observed.

ObjectName[]
MonitorMBean.getObservedObjects()

Returns an array containing the objects being observed.

ObjectName
Monitor.preRegister(MBeanServer server,
           ObjectName name)

Allows the monitor MBean to perform any operations it needs
 before being registered in the MBean server.

Methods in javax.management.monitor with parameters of type ObjectName

Modifier and Type
Method and Description

void
Monitor.addObservedObject(ObjectName object)

Adds the specified object in the set of observed MBeans, if this object
 is not already present.

void
MonitorMBean.addObservedObject(ObjectName object)

Adds the specified object in the set of observed MBeans.

boolean
Monitor.containsObservedObject(ObjectName object)

Tests whether the specified object is in the set of observed MBeans.

boolean
MonitorMBean.containsObservedObject(ObjectName object)

Tests whether the specified object is in the set of observed MBeans.

String
StringMonitor.getDerivedGauge(ObjectName object)

Gets the derived gauge of the specified object, if this object is
 contained in the set of observed MBeans, or null otherwise.

Number
CounterMonitorMBean.getDerivedGauge(ObjectName object)

Gets the derived gauge for the specified MBean.

Number
CounterMonitor.getDerivedGauge(ObjectName object)

Gets the derived gauge of the specified object, if this object is
 contained in the set of observed MBeans, or null otherwise.

Number
GaugeMonitor.getDerivedGauge(ObjectName object)

Gets the derived gauge of the specified object, if this object is
 contained in the set of observed MBeans, or null otherwise.

Number
GaugeMonitorMBean.getDerivedGauge(ObjectName object)

Gets the derived gauge for the specified MBean.

String
StringMonitorMBean.getDerivedGauge(ObjectName object)

Gets the derived gauge for the specified MBean.

long
StringMonitor.getDerivedGaugeTimeStamp(ObjectName object)

Gets the derived gauge timestamp of the specified object, if
 this object is contained in the set of observed MBeans, or
 0 otherwise.

long
CounterMonitorMBean.getDerivedGaugeTimeStamp(ObjectName object)

Gets the derived gauge timestamp for the specified MBean.

long
CounterMonitor.getDerivedGaugeTimeStamp(ObjectName object)

Gets the derived gauge timestamp of the specified object, if
 this object is contained in the set of observed MBeans, or
 0 otherwise.

long
GaugeMonitor.getDerivedGaugeTimeStamp(ObjectName object)

Gets the derived gauge timestamp of the specified object, if
 this object is contained in the set of observed MBeans, or
 0 otherwise.

long
GaugeMonitorMBean.getDerivedGaugeTimeStamp(ObjectName object)

Gets the derived gauge timestamp for the specified MBean.

long
StringMonitorMBean.getDerivedGaugeTimeStamp(ObjectName object)

Gets the derived gauge timestamp for the specified MBean.

Number
CounterMonitorMBean.getThreshold(ObjectName object)

Gets the threshold value for the specified MBean.

Number
CounterMonitor.getThreshold(ObjectName object)

Gets the current threshold value of the specified object, if
 this object is contained in the set of observed MBeans, or
 null otherwise.

ObjectName
Monitor.preRegister(MBeanServer server,
           ObjectName name)

Allows the monitor MBean to perform any operations it needs
 before being registered in the MBean server.

void
Monitor.removeObservedObject(ObjectName object)

Removes the specified object from the set of observed MBeans.

void
MonitorMBean.removeObservedObject(ObjectName object)

Removes the specified object from the set of observed MBeans.

void
Monitor.setObservedObject(ObjectName object)

Deprecated.

As of JMX 1.2, replaced by Monitor.addObservedObject(javax.management.ObjectName)

void
MonitorMBean.setObservedObject(ObjectName object)

Deprecated.

As of JMX 1.2, replaced by MonitorMBean.addObservedObject(javax.management.ObjectName)

Uses of ObjectName in javax.management.openmbean

Fields in javax.management.openmbean with type parameters of type ObjectName

Modifier and Type
Field and Description

static SimpleType<ObjectName>
SimpleType.OBJECTNAME

The SimpleType instance describing values whose
 Java class name is javax.management.ObjectName.

Uses of ObjectName in javax.management.relation

Methods in javax.management.relation that return ObjectName

Modifier and Type
Method and Description

ObjectName
RelationNotification.getObjectName()

Returns the ObjectName of the
 created/removed/updated relation.

ObjectName
Relation.getRelationServiceName()

Returns ObjectName of the Relation Service handling the relation.

ObjectName
RelationSupport.getRelationServiceName()

Returns ObjectName of the Relation Service handling the relation.

ObjectName
RelationService.isRelationMBean(String relationId)

If the relation is represented by an MBean (created by the user and
 added as a relation in the Relation Service), returns the ObjectName of
 the MBean.

ObjectName
RelationServiceMBean.isRelationMBean(String relationId)

If the relation is represented by an MBean (created by the user and
 added as a relation in the Relation Service), returns the ObjectName of
 the MBean.

ObjectName
RelationService.preRegister(MBeanServer server,
           ObjectName name)

ObjectName
RelationSupport.preRegister(MBeanServer server,
           ObjectName name)

Methods in javax.management.relation that return types with arguments of type ObjectName

Modifier and Type
Method and Description

Map<ObjectName,List<String>>
RelationService.findAssociatedMBeans(ObjectName mbeanName,
                    String relationTypeName,
                    String roleName)

Retrieves the MBeans associated to given one in a relation.

Map<ObjectName,List<String>>
RelationServiceMBean.findAssociatedMBeans(ObjectName mbeanName,
                    String relationTypeName,
                    String roleName)

Retrieves the MBeans associated to given one in a relation.

Vector<ObjectName>
MBeanServerNotificationFilter.getDisabledObjectNames()

Gets all the ObjectNames disabled.

Vector<ObjectName>
MBeanServerNotificationFilter.getEnabledObjectNames()

Gets all the ObjectNames enabled.

List<ObjectName>
RelationNotification.getMBeansToUnregister()

Returns the list of ObjectNames of MBeans expected to be unregistered
 due to a relation removal (only for relation removal).

List<ObjectName>
RelationNotification.getNewRoleValue()

Returns new value of updated role (only for role update).

List<ObjectName>
RelationNotification.getOldRoleValue()

Returns old value of updated role (only for role update).

Map<ObjectName,List<String>>
Relation.getReferencedMBeans()

Retrieves MBeans referenced in the various roles of the relation.

Map<ObjectName,List<String>>
RelationSupport.getReferencedMBeans()

Retrieves MBeans referenced in the various roles of the relation.

Map<ObjectName,List<String>>
RelationService.getReferencedMBeans(String relationId)

Retrieves MBeans referenced in the various roles of the relation.

Map<ObjectName,List<String>>
RelationServiceMBean.getReferencedMBeans(String relationId)

Retrieves MBeans referenced in the various roles of the relation.

List<ObjectName>
Relation.getRole(String roleName)

Retrieves role value for given role name.

List<ObjectName>
RelationSupport.getRole(String roleName)

Retrieves role value for given role name.

List<ObjectName>
RelationService.getRole(String relationId,
       String roleName)

Retrieves role value for given role name in given relation.

List<ObjectName>
RelationServiceMBean.getRole(String relationId,
       String roleName)

Retrieves role value for given role name in given relation.

List<ObjectName>
RoleUnresolved.getRoleValue()

Retrieves role value.

List<ObjectName>
Role.getRoleValue()

Retrieves role value.

Methods in javax.management.relation with parameters of type ObjectName

Modifier and Type
Method and Description

void
RelationService.addRelation(ObjectName relationObjectName)

Adds an MBean created by the user (and registered by him in the MBean
 Server) as a relation in the Relation Service.

void
RelationServiceMBean.addRelation(ObjectName relationObjectName)

Adds an MBean created by the user (and registered by him in the MBean
 Server) as a relation in the Relation Service.

void
MBeanServerNotificationFilter.disableObjectName(ObjectName objectName)

Disables MBeanServerNotifications concerning given ObjectName.

void
MBeanServerNotificationFilter.enableObjectName(ObjectName objectName)

Enables MBeanServerNotifications concerning given ObjectName.

Map<ObjectName,List<String>>
RelationService.findAssociatedMBeans(ObjectName mbeanName,
                    String relationTypeName,
                    String roleName)

Retrieves the MBeans associated to given one in a relation.

Map<ObjectName,List<String>>
RelationServiceMBean.findAssociatedMBeans(ObjectName mbeanName,
                    String relationTypeName,
                    String roleName)

Retrieves the MBeans associated to given one in a relation.

Map<String,List<String>>
RelationService.findReferencingRelations(ObjectName mbeanName,
                        String relationTypeName,
                        String roleName)

Retrieves the relations where a given MBean is referenced.

Map<String,List<String>>
RelationServiceMBean.findReferencingRelations(ObjectName mbeanName,
                        String relationTypeName,
                        String roleName)

Retrieves the relations where a given MBean is referenced.

void
Relation.handleMBeanUnregistration(ObjectName objectName,
                         String roleName)

Callback used by the Relation Service when a MBean referenced in a role
 is unregistered.

void
RelationSupport.handleMBeanUnregistration(ObjectName objectName,
                         String roleName)

Callback used by the Relation Service when a MBean referenced in a role
 is unregistered.

String
RelationService.isRelation(ObjectName objectName)

Returns the relation id associated to the given ObjectName if the
 MBean has been added as a relation in the Relation Service.

String
RelationServiceMBean.isRelation(ObjectName objectName)

Returns the relation id associated to the given ObjectName if the
 MBean has been added as a relation in the Relation Service.

ObjectName
RelationService.preRegister(MBeanServer server,
           ObjectName name)

ObjectName
RelationSupport.preRegister(MBeanServer server,
           ObjectName name)

Method parameters in javax.management.relation with type arguments of type ObjectName

Modifier and Type
Method and Description

static String
Role.roleValueToString(List<ObjectName> roleValue)

Returns a string for the given role value.

void
RelationService.sendRelationRemovalNotification(String relationId,
                               List<ObjectName> unregMBeanList)

Sends a notification (RelationNotification) for a relation removal.

void
RelationServiceMBean.sendRelationRemovalNotification(String relationId,
                               List<ObjectName> unregMBeanList)

Sends a notification (RelationNotification) for a relation removal.

void
RelationService.sendRoleUpdateNotification(String relationId,
                          Role newRole,
                          List<ObjectName> oldValue)

Sends a notification (RelationNotification) for a role update in the
 given relation.

void
RelationServiceMBean.sendRoleUpdateNotification(String relationId,
                          Role newRole,
                          List<ObjectName> oldRoleValue)

Sends a notification (RelationNotification) for a role update in the
 given relation.

void
RoleUnresolved.setRoleValue(List<ObjectName> value)

Sets role value.

void
Role.setRoleValue(List<ObjectName> roleValue)

Sets role value.

void
RelationService.updateRoleMap(String relationId,
             Role newRole,
             List<ObjectName> oldValue)

Handles update of the Relation Service role map for the update of given
 role in given relation.

void
RelationServiceMBean.updateRoleMap(String relationId,
             Role newRole,
             List<ObjectName> oldRoleValue)

Handles update of the Relation Service role map for the update of given
 role in given relation.

Constructors in javax.management.relation with parameters of type ObjectName

Constructor and Description

RelationNotification(String notifType,
                    Object sourceObj,
                    long sequence,
                    long timeStamp,
                    String message,
                    String id,
                    String typeName,
                    ObjectName objectName,
                    List<ObjectName> unregMBeanList)

Creates a notification for either a relation creation (RelationSupport
 object created internally in the Relation Service, or an MBean added as a
 relation) or for a relation removal from the Relation Service.

RelationNotification(String notifType,
                    Object sourceObj,
                    long sequence,
                    long timeStamp,
                    String message,
                    String id,
                    String typeName,
                    ObjectName objectName,
                    String name,
                    List<ObjectName> newValue,
                    List<ObjectName> oldValue)

Creates a notification for a role update in a relation.

RelationSupport(String relationId,
               ObjectName relationServiceName,
               MBeanServer relationServiceMBeanServer,
               String relationTypeName,
               RoleList list)

Creates a RelationSupport object.

RelationSupport(String relationId,
               ObjectName relationServiceName,
               String relationTypeName,
               RoleList list)

Creates a RelationSupport object.

Constructor parameters in javax.management.relation with type arguments of type ObjectName

Constructor and Description

RelationNotification(String notifType,
                    Object sourceObj,
                    long sequence,
                    long timeStamp,
                    String message,
                    String id,
                    String typeName,
                    ObjectName objectName,
                    List<ObjectName> unregMBeanList)

Creates a notification for either a relation creation (RelationSupport
 object created internally in the Relation Service, or an MBean added as a
 relation) or for a relation removal from the Relation Service.

RelationNotification(String notifType,
                    Object sourceObj,
                    long sequence,
                    long timeStamp,
                    String message,
                    String id,
                    String typeName,
                    ObjectName objectName,
                    String name,
                    List<ObjectName> newValue,
                    List<ObjectName> oldValue)

Creates a notification for a role update in a relation.

RelationNotification(String notifType,
                    Object sourceObj,
                    long sequence,
                    long timeStamp,
                    String message,
                    String id,
                    String typeName,
                    ObjectName objectName,
                    String name,
                    List<ObjectName> newValue,
                    List<ObjectName> oldValue)

Creates a notification for a role update in a relation.

Role(String roleName,
    List<ObjectName> roleValue)

Make a new Role object.

RoleUnresolved(String name,
              List<ObjectName> value,
              int pbType)

Constructor.

Uses of ObjectName in javax.management.remote

Methods in javax.management.remote that return ObjectName

Modifier and Type
Method and Description

ObjectName
JMXConnectorServer.preRegister(MBeanServer mbs,
           ObjectName name)

Called by an MBean server when this connector server is
 registered in that MBean server.

Methods in javax.management.remote with parameters of type ObjectName

Modifier and Type
Method and Description

ObjectName
JMXConnectorServer.preRegister(MBeanServer mbs,
           ObjectName name)

Called by an MBean server when this connector server is
 registered in that MBean server.

Uses of ObjectName in javax.management.remote.rmi

Methods in javax.management.remote.rmi that return types with arguments of type ObjectName

Modifier and Type
Method and Description

Set<ObjectName>
RMIConnectionImpl.queryNames(ObjectName name,
          MarshalledObject query,
          Subject delegationSubject)

Set<ObjectName>
RMIConnection.queryNames(ObjectName name,
          MarshalledObject query,
          Subject delegationSubject)

Handles the method MBeanServerConnection.queryNames(ObjectName,
 QueryExp).

Methods in javax.management.remote.rmi with parameters of type ObjectName

Modifier and Type
Method and Description

void
RMIConnectionImpl.addNotificationListener(ObjectName name,
                       ObjectName listener,
                       MarshalledObject filter,
                       MarshalledObject handback,
                       Subject delegationSubject)

void
RMIConnection.addNotificationListener(ObjectName name,
                       ObjectName listener,
                       MarshalledObject filter,
                       MarshalledObject handback,
                       Subject delegationSubject)

Handles the method MBeanServerConnection.addNotificationListener(ObjectName,
 ObjectName, NotificationFilter, Object).

void
RMIConnectionImpl_Stub.addNotificationListener(ObjectName $param_ObjectName_1,
                       ObjectName $param_ObjectName_2,
                       MarshalledObject $param_MarshalledObject_3,
                       MarshalledObject $param_MarshalledObject_4,
                       Subject $param_Subject_5)

Integer[]
RMIConnectionImpl.addNotificationListeners(ObjectName[] names,
                        MarshalledObject[] filters,
                        Subject[] delegationSubjects)

Integer[]
RMIConnection.addNotificationListeners(ObjectName[] names,
                        MarshalledObject[] filters,
                        Subject[] delegationSubjects)

Handles the method MBeanServerConnection.addNotificationListener(ObjectName,
 NotificationListener, NotificationFilter, Object).

Integer[]
RMIConnectionImpl_Stub.addNotificationListeners(ObjectName[] $param_arrayOf_ObjectName_1,
                        MarshalledObject[] $param_arrayOf_MarshalledObject_2,
                        Subject[] $param_arrayOf_Subject_3)

ObjectInstance
RMIConnectionImpl.createMBean(String className,
           ObjectName name,
           MarshalledObject params,
           String[] signature,
           Subject delegationSubject)

ObjectInstance
RMIConnection.createMBean(String className,
           ObjectName name,
           MarshalledObject params,
           String[] signature,
           Subject delegationSubject)

Handles the method MBeanServerConnection.createMBean(String,
 ObjectName, Object[], String[]).

ObjectInstance
RMIConnectionImpl_Stub.createMBean(String $param_String_1,
           ObjectName $param_ObjectName_2,
           MarshalledObject $param_MarshalledObject_3,
           String[] $param_arrayOf_String_4,
           Subject $param_Subject_5)

ObjectInstance
RMIConnectionImpl.createMBean(String className,
           ObjectName name,
           ObjectName loaderName,
           MarshalledObject params,
           String[] signature,
           Subject delegationSubject)

ObjectInstance
RMIConnection.createMBean(String className,
           ObjectName name,
           ObjectName loaderName,
           MarshalledObject params,
           String[] signature,
           Subject delegationSubject)

Handles the method MBeanServerConnection.createMBean(String,
 ObjectName, ObjectName, Object[], String[]).

ObjectInstance
RMIConnectionImpl_Stub.createMBean(String $param_String_1,
           ObjectName $param_ObjectName_2,
           ObjectName $param_ObjectName_3,
           MarshalledObject $param_MarshalledObject_4,
           String[] $param_arrayOf_String_5,
           Subject $param_Subject_6)

ObjectInstance
RMIConnectionImpl.createMBean(String className,
           ObjectName name,
           ObjectName loaderName,
           Subject delegationSubject)

ObjectInstance
RMIConnection.createMBean(String className,
           ObjectName name,
           ObjectName loaderName,
           Subject delegationSubject)

Handles the method MBeanServerConnection.createMBean(String,
 ObjectName, ObjectName).

ObjectInstance
RMIConnectionImpl_Stub.createMBean(String $param_String_1,
           ObjectName $param_ObjectName_2,
           ObjectName $param_ObjectName_3,
           Subject $param_Subject_4)

ObjectInstance
RMIConnectionImpl.createMBean(String className,
           ObjectName name,
           Subject delegationSubject)

ObjectInstance
RMIConnection.createMBean(String className,
           ObjectName name,
           Subject delegationSubject)

Handles the method MBeanServerConnection.createMBean(String,
 ObjectName).

ObjectInstance
RMIConnectionImpl_Stub.createMBean(String $param_String_1,
           ObjectName $param_ObjectName_2,
           Subject $param_Subject_3)

Object
RMIConnectionImpl.getAttribute(ObjectName name,
            String attribute,
            Subject delegationSubject)

Object
RMIConnection.getAttribute(ObjectName name,
            String attribute,
            Subject delegationSubject)

Handles the method MBeanServerConnection.getAttribute(ObjectName,
 String).

Object
RMIConnectionImpl_Stub.getAttribute(ObjectName $param_ObjectName_1,
            String $param_String_2,
            Subject $param_Subject_3)

AttributeList
RMIConnectionImpl.getAttributes(ObjectName name,
             String[] attributes,
             Subject delegationSubject)

AttributeList
RMIConnection.getAttributes(ObjectName name,
             String[] attributes,
             Subject delegationSubject)

Handles the method MBeanServerConnection.getAttributes(ObjectName,
 String[]).

AttributeList
RMIConnectionImpl_Stub.getAttributes(ObjectName $param_ObjectName_1,
             String[] $param_arrayOf_String_2,
             Subject $param_Subject_3)

MBeanInfo
RMIConnectionImpl.getMBeanInfo(ObjectName name,
            Subject delegationSubject)

MBeanInfo
RMIConnection.getMBeanInfo(ObjectName name,
            Subject delegationSubject)

Handles the method
 MBeanServerConnection.getMBeanInfo(ObjectName).

MBeanInfo
RMIConnectionImpl_Stub.getMBeanInfo(ObjectName $param_ObjectName_1,
            Subject $param_Subject_2)

ObjectInstance
RMIConnectionImpl.getObjectInstance(ObjectName name,
                 Subject delegationSubject)

ObjectInstance
RMIConnection.getObjectInstance(ObjectName name,
                 Subject delegationSubject)

Handles the method
 MBeanServerConnection.getObjectInstance(ObjectName).

ObjectInstance
RMIConnectionImpl_Stub.getObjectInstance(ObjectName $param_ObjectName_1,
                 Subject $param_Subject_2)

Object
RMIConnectionImpl.invoke(ObjectName name,
      String operationName,
      MarshalledObject params,
      String[] signature,
      Subject delegationSubject)

Object
RMIConnection.invoke(ObjectName name,
      String operationName,
      MarshalledObject params,
      String[] signature,
      Subject delegationSubject)

Handles the method MBeanServerConnection.invoke(ObjectName,
 String, Object[], String[]).

Object
RMIConnectionImpl_Stub.invoke(ObjectName $param_ObjectName_1,
      String $param_String_2,
      MarshalledObject $param_MarshalledObject_3,
      String[] $param_arrayOf_String_4,
      Subject $param_Subject_5)

boolean
RMIConnectionImpl.isInstanceOf(ObjectName name,
            String className,
            Subject delegationSubject)

boolean
RMIConnection.isInstanceOf(ObjectName name,
            String className,
            Subject delegationSubject)

Handles the method MBeanServerConnection.isInstanceOf(ObjectName,
 String).

boolean
RMIConnectionImpl_Stub.isInstanceOf(ObjectName $param_ObjectName_1,
            String $param_String_2,
            Subject $param_Subject_3)

boolean
RMIConnectionImpl.isRegistered(ObjectName name,
            Subject delegationSubject)

boolean
RMIConnection.isRegistered(ObjectName name,
            Subject delegationSubject)

Handles the method
 MBeanServerConnection.isRegistered(ObjectName).

boolean
RMIConnectionImpl_Stub.isRegistered(ObjectName $param_ObjectName_1,
            Subject $param_Subject_2)

Set<ObjectInstance>
RMIConnectionImpl.queryMBeans(ObjectName name,
           MarshalledObject query,
           Subject delegationSubject)

Set<ObjectInstance>
RMIConnection.queryMBeans(ObjectName name,
           MarshalledObject query,
           Subject delegationSubject)

Handles the method MBeanServerConnection.queryMBeans(ObjectName,
 QueryExp).

Set
RMIConnectionImpl_Stub.queryMBeans(ObjectName $param_ObjectName_1,
           MarshalledObject $param_MarshalledObject_2,
           Subject $param_Subject_3)

Set<ObjectName>
RMIConnectionImpl.queryNames(ObjectName name,
          MarshalledObject query,
          Subject delegationSubject)

Set<ObjectName>
RMIConnection.queryNames(ObjectName name,
          MarshalledObject query,
          Subject delegationSubject)

Handles the method MBeanServerConnection.queryNames(ObjectName,
 QueryExp).

Set
RMIConnectionImpl_Stub.queryNames(ObjectName $param_ObjectName_1,
          MarshalledObject $param_MarshalledObject_2,
          Subject $param_Subject_3)

void
RMIConnectionImpl.removeNotificationListener(ObjectName name,
                          ObjectName listener,
                          MarshalledObject filter,
                          MarshalledObject handback,
                          Subject delegationSubject)

void
RMIConnection.removeNotificationListener(ObjectName name,
                          ObjectName listener,
                          MarshalledObject filter,
                          MarshalledObject handback,
                          Subject delegationSubject)

Handles the method MBeanServerConnection.removeNotificationListener(ObjectName,
 ObjectName, NotificationFilter, Object).

void
RMIConnectionImpl_Stub.removeNotificationListener(ObjectName $param_ObjectName_1,
                          ObjectName $param_ObjectName_2,
                          MarshalledObject $param_MarshalledObject_3,
                          MarshalledObject $param_MarshalledObject_4,
                          Subject $param_Subject_5)

void
RMIConnectionImpl.removeNotificationListener(ObjectName name,
                          ObjectName listener,
                          Subject delegationSubject)

void
RMIConnection.removeNotificationListener(ObjectName name,
                          ObjectName listener,
                          Subject delegationSubject)

Handles the method MBeanServerConnection.removeNotificationListener(ObjectName,
 ObjectName).

void
RMIConnectionImpl_Stub.removeNotificationListener(ObjectName $param_ObjectName_1,
                          ObjectName $param_ObjectName_2,
                          Subject $param_Subject_3)

void
RMIConnectionImpl.removeNotificationListeners(ObjectName name,
                           Integer[] listenerIDs,
                           Subject delegationSubject)

void
RMIConnection.removeNotificationListeners(ObjectName name,
                           Integer[] listenerIDs,
                           Subject delegationSubject)

Handles the
 removeNotificationListener(ObjectName, NotificationListener) and
 removeNotificationListener(ObjectName, NotificationListener, NotificationFilter, Object) methods.

void
RMIConnectionImpl_Stub.removeNotificationListeners(ObjectName $param_ObjectName_1,
                           Integer[] $param_arrayOf_Integer_2,
                           Subject $param_Subject_3)

void
RMIConnectionImpl.setAttribute(ObjectName name,
            MarshalledObject attribute,
            Subject delegationSubject)

void
RMIConnection.setAttribute(ObjectName name,
            MarshalledObject attribute,
            Subject delegationSubject)

Handles the method MBeanServerConnection.setAttribute(ObjectName,
 Attribute).

void
RMIConnectionImpl_Stub.setAttribute(ObjectName $param_ObjectName_1,
            MarshalledObject $param_MarshalledObject_2,
            Subject $param_Subject_3)

AttributeList
RMIConnectionImpl.setAttributes(ObjectName name,
             MarshalledObject attributes,
             Subject delegationSubject)

AttributeList
RMIConnection.setAttributes(ObjectName name,
             MarshalledObject attributes,
             Subject delegationSubject)

Handles the method MBeanServerConnection.setAttributes(ObjectName,
 AttributeList).

AttributeList
RMIConnectionImpl_Stub.setAttributes(ObjectName $param_ObjectName_1,
             MarshalledObject $param_MarshalledObject_2,
             Subject $param_Subject_3)

void
RMIConnectionImpl.unregisterMBean(ObjectName name,
               Subject delegationSubject)

void
RMIConnection.unregisterMBean(ObjectName name,
               Subject delegationSubject)

Handles the method
 MBeanServerConnection.unregisterMBean(ObjectName).

void
RMIConnectionImpl_Stub.unregisterMBean(ObjectName $param_ObjectName_1,
               Subject $param_Subject_2)

Uses of ObjectName in javax.management.timer

Methods in javax.management.timer that return ObjectName

Modifier and Type
Method and Description

ObjectName
Timer.preRegister(MBeanServer server,
           ObjectName name)

Allows the timer MBean to perform any operations it needs before being registered
 in the MBean server.

Methods in javax.management.timer with parameters of type ObjectName

Modifier and Type
Method and Description

ObjectName
Timer.preRegister(MBeanServer server,
           ObjectName name)

Allows the timer MBean to perform any operations it needs before being registered
 in the MBean server.

Skip navigation links

Overview

Package

Class

Use

Tree

Deprecated

Index

Help

Java™ Platform
Standard Ed. 8

Prev

Next

Frames

No Frames

All Classes

 Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
 Copyright © 1993, 2015, Oracle and/or its affiliates.  All rights reserved.


text:
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Privileges and Permissions</title>
<meta name="generator" content="DocBook XSL Stylesheets Vsnapshot">
<link rel="home" href="index.html" title="Cockpit Guide">
<link rel="up" href="guide.html" title="Part I. Deployment Guide">
<link rel="prev" href="sso.html" title="Single Sign On">
<link rel="next" href="features.html" title="Part II. Feature Internals">
<link rel="stylesheet" href="style.css" type="text/css">

Cockpit Guide

Privileges and Permissions

Customizing Polkit Privileges

When a user is logged into Cockpit, they are logged into a normal session
    that has exactly the same privileges as if they logged in via SSH or on
    the console.

In some cases Cockpit will try to escalate the privileges of the user
    using Policy Kit
    or sudo. If the user is able to escalate
    privileges from the command line, then Cockpit will use that same capability to
    perform certain privileged tasks.

Cockpit can use the user's login password internally to escalate privileges
    in these situations. By selecting the
    Reuse my password for privileged tasks option on the login screen
    the login password will be cached internally and passed to Policy Kit
    when requested in order to escalate privileges.

To test out whether Cockpit can escalate privileges, you can run these commands
    from a the terminal built into Cockpit.

$ sudo cockpit-bridge
...
$ pkexec cockpit-bridge
...

If either of these commands succeed without prompting for a password,
    Cockpit will be able to start a privileged copy of the
    cockpit-bridge and use it to perform privileged tasks
    when necessary.

Usually a user needs to be in the wheel Unix user group for the
    user to be able to escalate privileges in this way. However both Policy Kit and
    sudo may be configured to use other criteria.

Customizing Polkit Privileges

Services like systemd
      and NetworkManager use
      Polkit to
      validate and escalate privileges. It is possible to customize these rules with files
      in /etc/polkit-1/rules.d.

Polkit rules files are
      javascript with specific methods and objects. For example, placing the following polkit rule to
      /etc/polkit-1.rules.d/10-operators.rule allows all users in the
      operators group to start, stop, restart and otherwise manage systemd services:

polkit.addRule(function(action, subject) {
    if (action.id == "org.freedesktop.systemd1.manage-units") {
        if (subject.isInGroup("operators")) {
            return polkit.Result.YES;
        }
    }
});

In order to allow a certain group to perform any administrative action you could add
      a rule like this:

polkit.addAdminRule(function(action, subject) {
    return ["unix-group:operators"];
});


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<meta http-equiv="Content-Type" content="text/html" charset="UTF-8">
<title>接口 org.jsoup.Connection.Response的使用 (jsoup 1.8.4-SNAPSHOT API)</title>
<meta name="date" content="2015-11-06">
<link rel="stylesheet" type="text/css" href="../../../stylesheet.css" title="Style">

您的浏览器已禁用 JavaScript。

概览

程序包

类

使用

树

已过时

索引

帮助

上一个

下一个

框架

无框架

所有类

接口 org.jsoup.Connection.Response
的使用

使用Connection.Response的程序包

程序包
说明

org.jsoup

Contains the main Jsoup class, which provides convenient static access to the jsoup functionality.

org.jsoup.helper

org.jsoup中Connection.Response的使用

返回Connection.Response的org.jsoup中的方法

限定符和类型
方法和说明

Connection.Response
Connection.execute()

Execute the request.

Connection.Response
Connection.response()

Get the response, once the request has been executed

参数类型为Connection.Response的org.jsoup中的方法

限定符和类型
方法和说明

Connection
Connection.response(Connection.Response response)

Set the connection's response

org.jsoup.helper中Connection.Response的使用

实现Connection.Response的org.jsoup.helper中的类

限定符和类型
类和说明

static class
HttpConnection.Response

返回Connection.Response的org.jsoup.helper中的方法

限定符和类型
方法和说明

Connection.Response
HttpConnection.execute()

Connection.Response
HttpConnection.response()

参数类型为Connection.Response的org.jsoup.helper中的方法

限定符和类型
方法和说明

Connection
HttpConnection.response(Connection.Response response)

概览

程序包

类

使用

树

已过时

索引

帮助

上一个

下一个

框架

无框架

所有类

Copyright © 2009-2015 Jonathan Hedley. All Rights Reserved.


text:
<?php

use Roots\Sage\Setup;
use Roots\Sage\Wrapper;
use Roots\Sage\Extras;

?>

<?php get_template_part( 'templates/header-archive' ); ?>

<?= __( '404 - Pagina niet gevonden', TEXT_DOMAIN ); ?>

<?= __( 'Sorry, maar de pagina die je probeerde te benaderen bestaat niet. Probeer te vinden wat je zoekt via de onderstaande zoekfunctie of gebruik het hoofdmenu.', TEXT_DOMAIN ); ?>

					<?php get_search_form(); ?>

		<?php if ( Setup\display_sidebar() ) : ?>
			<?php include Wrapper\sidebar_path(); ?>
		<?php endif; ?>


text:
export interface AssociationActionOptions {
  through?: any;
  transaction?: any;
  validate?: boolean;
}


text:
package com.gdn.venice.persistence;

import java.io.Serializable;
import javax.persistence.*;

/**
 * The persistent class for the fin_bank_account database table.
 *
 */
@Entity
@Table(name="fin_bank_account")
public class FinBankAccount implements Serializable {
	private static final long serialVersionUID = 1L;

	@Id
@GeneratedValue(strategy=GenerationType.TABLE, generator="fin_bank_account")
	@TableGenerator(name="fin_bank_account", table="openjpaseq", pkColumnName="id", valueColumnName="sequence_value", allocationSize=1)  //flush every 1 insert
	@Column(name="account_id", unique=true, nullable=false)
	private Long accountId;

	@Column(name="bank_account_number", nullable=false, length=100)
	private String bankAccountNumber;

	//bi-directional one-to-one association to FinAccount
	@OneToOne
	@JoinColumn(name="account_id", nullable=false, insertable=false, updatable=false)
	private FinAccount finAccount;

	//bi-directional many-to-one association to VenBank
    @ManyToOne
	@JoinColumn(name="bank_id", nullable=false)
	private VenBank venBank;

    public FinBankAccount() {
    }

	public Long getAccountId() {
		return this.accountId;
	}

	public void setAccountId(Long accountId) {
		this.accountId = accountId;
	}

	public String getBankAccountNumber() {
		return this.bankAccountNumber;
	}

	public void setBankAccountNumber(String bankAccountNumber) {
		this.bankAccountNumber = bankAccountNumber;
	}

	public FinAccount getFinAccount() {
		return this.finAccount;
	}

	public void setFinAccount(FinAccount finAccount) {
		this.finAccount = finAccount;
	}

	public VenBank getVenBank() {
		return this.venBank;
	}

	public void setVenBank(VenBank venBank) {
		this.venBank = venBank;
	}

}


text:
namespace EasyGIF {
	class ImageFrame {
	private:
		std::vector<std::vector<uint8_t*>> m_Data; // pixel data
	public:
		// Default constructor
		// Does nothing
		ImageFrame();

		// Constructor
		// Calls CreateFromPixels()
		ImageFrame(std::vector<std::vector<uint8_t*>> data);

		// Loads pixel data into a vector
		void CreateFromPixels(std::vector<std::vector<uint8_t*>> data);

		unsigned short GetHeight();

		// Returns an array of unsigned chars (numbers in range 0-255) representing each pixel
		// This is more of a "raw" representation of the pixel data,
		// values for R, G, B and A are stored adjacently,
		// so each pixel takes 4 elements of the array
		// (and so the size is width * height * 4)
		// Needed for the GIF encoder
		uint8_t* GetBuffer();

		// Gets a single pixel from the specified coordinates
		uint8_t* GetPixel(unsigned short x, unsigned short y);

		unsigned short GetWidth();

		// Modifies the RGBA values of a pixel at specified coordinates
		void SetPixel(unsigned short x, unsigned short y, uint8_t* pixel);

		// Destructor
		// Does nothing
		~ImageFrame();
	};
}

#endif


text:
package org.apache.camel.ldpath;

import static org.slf4j.LoggerFactory.getLogger;

import java.io.File;
import java.util.Collection;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.apache.camel.Exchange;
import org.apache.camel.Expression;
import org.apache.camel.Predicate;
import org.apache.camel.impl.DefaultExchange;
import org.apache.camel.spi.Language;
import org.apache.camel.test.junit4.CamelTestSupport;
import org.junit.Test;
import org.slf4j.Logger;

public class LdPathLanguageTest extends CamelTestSupport {

    final private Logger logger = getLogger(LdPathLanguageTest.class);

    @Override
    public boolean isUseRouteBuilder() {
        return false;
    }

    @Test
    public void testExpressionListAuthor() throws Exception {
        Exchange exchange = new DefaultExchange(context);
        exchange.getIn().setBody(new File("src/test/resources/authors.rdf"));
        exchange.getIn().setHeader(Exchange.CONTENT_TYPE, "text/turtle");
        exchange.getIn().setHeader("LDPATH_CONTEXT", "http://localhost/foo");

        Language lan = context.resolveLanguage("ldpath");
        Expression exp = lan.createExpression("author = dc:author :: xsd:string ;");
        Map<String, Collection<String>> results = exp.evaluate(exchange, Map.class);

        assertNotNull(results);
        assertEquals(1, results.size());
        ArrayList<String> authors = new ArrayList<>(results.get("author"));
        assertNotNull(authors);
        assertEquals(1, authors.size());
        assertEquals("Aaron Coburn", authors.get(0));
    }

    @Test
    public void testExpressionListTitle() throws Exception {
        Exchange exchange = new DefaultExchange(context);
        exchange.getIn().setBody(new File("src/test/resources/indexable.rdf"));
        exchange.getIn().setHeader(Exchange.CONTENT_TYPE, "text/turtle");
        exchange.getIn().setHeader("LDPATH_CONTEXT", "http://localhost/foo");

        Language lan = context.resolveLanguage("ldpath");
        Expression exp = lan.createExpression("title = dc:title :: xsd:string ;");
        Map<String,Collection<String>> results = exp.evaluate(exchange, Map.class);

        assertNotNull(results);
        assertEquals(1, results.size());

        ArrayList<String> titles = new ArrayList<>(results.get("title"));
        assertNotNull(titles);
        assertEquals(1, titles.size());
        assertEquals("Indexable Object", titles.get(0));
    }

    @Test
    public void testExpressionListMultiple() throws Exception {
        Exchange exchange = new DefaultExchange(context);
        exchange.getIn().setBody(new File("src/test/resources/indexable.rdf"));
        exchange.getIn().setHeader(Exchange.CONTENT_TYPE, "text/turtle");
        exchange.getIn().setHeader("LDPATH_CONTEXT", "http://localhost/foo");

        Language lan = context.resolveLanguage("ldpath");
        Expression exp = lan.createExpression("title = dc:title :: xsd:string ;\n author = dc:author :: xsd:string ;");
        Map<String,Collection<String>> results = exp.evaluate(exchange, Map.class);

        assertNotNull(results);
        assertEquals(2, results.size());

        ArrayList<String> titles = new ArrayList<>(results.get("title"));
        assertNotNull(titles);
        assertEquals(1, titles.size());
        assertEquals("Indexable Object", titles.get(0));
    }

    @Test
    public void testExpressionList4() throws Exception {
        Exchange exchange = new DefaultExchange(context);
        exchange.getIn().setBody(new File("src/test/resources/indexable.rdf"));
        exchange.getIn().setHeader(Exchange.CONTENT_TYPE, "text/turtle");
        exchange.getIn().setHeader("LDPATH_CONTEXT", "http://localhost/foo");

        Language lan = context.resolveLanguage("ldpath");
        Expression exp = lan.createExpression("title = dc:title :: xsd:string ;");
        Map<String,Collection<String>> results = exp.evaluate(exchange, Map.class);

        assertNotNull(results);
        assertEquals(1, results.size());

        ArrayList<String> titles = new ArrayList<>(results.get("title"));
        assertNotNull(titles);
        assertEquals(1, titles.size());
        assertEquals("Indexable Object", titles.get(0));
    }

    @Test
    public void testGroupedExpression() throws Exception {
        Exchange exchange = new DefaultExchange(context);
        exchange.getIn().setBody(new File("src/test/resources/indexable.rdf"));
        exchange.getIn().setHeader(Exchange.CONTENT_TYPE, "text/turtle");
        exchange.getIn().setHeader("LDPATH_CONTEXT", "http://localhost/foo");

        Language lan = context.resolveLanguage("ldpath");
        Expression exp = lan.createExpression("all = dc:title | dc:author :: xsd:string ;");
        Map<String,Collection<String>> results = exp.evaluate(exchange, Map.class);

        assertNotNull(results);
        assertEquals(1, results.size());
        ArrayList<String> all = new ArrayList<>(results.get("all"));
        assertNotNull(all);
        assertEquals(2, all.size());
    }

    @Test
    public void testEmptyExpression() throws Exception {
        Exchange exchange = new DefaultExchange(context);
        exchange.getIn().setBody(new File("src/test/resources/indexable.rdf"));
        exchange.getIn().setHeader(Exchange.CONTENT_TYPE, "text/turtle");
        exchange.getIn().setHeader("LDPATH_CONTEXT", "http://localhost/foo");

        Language lan = context.resolveLanguage("ldpath");
        Expression exp = lan.createExpression("foo = dc:foo :: xsd:string ;");
        Map<String,Collection<String>> results = exp.evaluate(exchange, Map.class);
        assertNull(results);
    }

    @Test
    public void testPredicate() throws Exception {
        // Test books.json file
        Exchange exchange = new DefaultExchange(context);
        exchange.getIn().setBody(new File("src/test/resources/books.rdf"));
        exchange.getIn().setHeader(Exchange.CONTENT_TYPE, "text/turtle");
        exchange.getIn().setHeader("LDPATH_CONTEXT", "http://localhost/1");

        Language lan = context.resolveLanguage("ldpath");
        Predicate pre = lan.createPredicate("dc:title :: xsd:string ;");
        boolean hasTitle = pre.matches(exchange);
        assertTrue("Should have a title", hasTitle);
    }

    @Test
    public void testNotIndexableTypePredicate() throws Exception {
        Exchange exchange = new DefaultExchange(context);
        exchange.getIn().setBody(new File("src/test/resources/notindexable.rdf"));
        exchange.getIn().setHeader(Exchange.CONTENT_TYPE, "text/turtle");
        exchange.getIn().setHeader("LDPATH_CONTEXT", "http://localhost/foo");

        Language lan = context.resolveLanguage("ldpath");
        Predicate pre = lan.createPredicate("@prefix ldp: <http://www.w3.org/ns/ldp#> ; @filter rdf:type is ldp:Container ; title = dc:title :: xsd:string ;");
        boolean isIndexable = pre.matches(exchange);
        assertFalse("Should not be indexable", isIndexable);
    }

    @Test
    public void testIndexableTypePredicate() throws Exception {
        Exchange exchange = new DefaultExchange(context);
        exchange.getIn().setBody(new File("src/test/resources/indexable.rdf"));
        exchange.getIn().setHeader(Exchange.CONTENT_TYPE, "text/turtle");
        exchange.getIn().setHeader("LDPATH_CONTEXT", "http://localhost/foo");

        Language lan = context.resolveLanguage("ldpath");
        Predicate pre = lan.createPredicate("@prefix ldp: <http://www.w3.org/ns/ldp#> ; @filter rdf:type is ldp:Container ; title = dc:title :: xsd:string ;");
        boolean isIndexable = pre.matches(exchange);
        assertTrue("Should be indexable", isIndexable);
    }

     @Test
    public void testNegativePredicate() throws Exception {
        Exchange exchange = new DefaultExchange(context);
        exchange.getIn().setBody(new File("src/test/resources/books.rdf"));
        exchange.getIn().setHeader(Exchange.CONTENT_TYPE, "text/turtle");
        exchange.getIn().setHeader("LDPATH_CONTEXT", "http://localhost/1");

        Language lan = context.resolveLanguage("ldpath");
        Predicate pre = lan.createPredicate("dc:foo :: xsd:string ;");
        boolean hasTitle = pre.matches(exchange);
        assertFalse("Should not have a foo", hasTitle);
    }

}


text:
// src/polyfills.js must be the first import.
import '../polyfills';

import {draw3p, init} from '../integration-lib';
import {register} from '../3p';

import {yandex} from '../../ads/vendors/yandex';

init(window);
register('yandex', yandex);

window.draw3p = draw3p;


text:
package com.boundary.metrics.vmware.poller;

public enum MetricUnit {
	bytecount, duration, number, percent;
}


text:
import angular from 'angular';

import './style/main.css';

import MainCtrl from './main';
angular.module('app', [MainCtrl]);


text:
package org.meruvian.yama.webapi.interceptor;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import javax.ws.rs.NameBinding;

/**
 * @author Dian Aditya
 *
 */
@NameBinding
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface DetectCurrentUser {

}