/* (non-Javadoc)
@see com.ibm.wsspi.pmi.factory.StatisticActionListener#statisticCreated(com.ibm.wsspi.pmi.stat.SPIStatistic)
498011
public void statisticCreated(SPIStatistic data) {
         switch(data.getId())
         {
             case WebAppModule.TOTAL_REQUESTS: 
             	totalRequests = (CountStatisticImpl)data; 
             	break;
             case WebAppModule.NUM_ERRORS: numErrors = (CountStatisticImpl)data; break;
             case WebAppModule.RESPONSE_TIME: responseTime = (TimeStatisticImpl)data;break;
             case WebAppModule.CONCURRENT_REQUESTS: currentRequests = (RangeStatisticImpl)data; break;
             case WebAppModule.ASYNC_CONTEXT_RESPONSE_TIME: this.asyncContextResponseTime = (TimeStatisticImpl)data;break;
             default:
                 break;
         }
		}
706448
@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        createSharedPreferences();
        createMapViews();
        createTileCaches();
        checkPermissionsAndCreateLayersAndControls();
    }
1074508
@Override
    public boolean onCreatePanelMenu(int featureId, Menu menu) {
        if (ActionBarSherlock.DEBUG) Log.d(TAG, "[onCreatePanelMenu] featureId: " + featureId + ", menu: " + menu);

        if (featureId == Window.FEATURE_OPTIONS_PANEL) {
            boolean result = onCreateOptionsMenu(menu);
            if (ActionBarSherlock.DEBUG) Log.d(TAG, "[onCreatePanelMenu] activity create result: " + result);

            MenuInflater inflater = getSupportMenuInflater();
            boolean show = false;
            ArrayList<Fragment> newMenus = null;
            if (mFragments.mAdded != null) {
                for (int i = 0; i < mFragments.mAdded.size(); i++) {
                    Fragment f = mFragments.mAdded.get(i);
                    if (f != null && !f.mHidden && f.mHasMenu && f.mMenuVisible && f instanceof OnCreateOptionsMenuListener) {
                        show = true;
                        ((OnCreateOptionsMenuListener)f).onCreateOptionsMenu(menu, inflater);
                        if (newMenus == null) {
                            newMenus = new ArrayList<Fragment>();
                        }
                        newMenus.add(f);
                    }
                }
            }

            if (mCreatedMenus != null) {
                for (int i = 0; i < mCreatedMenus.size(); i++) {
                    Fragment f = mCreatedMenus.get(i);
                    if (newMenus == null || !newMenus.contains(f)) {
                        f.onDestroyOptionsMenu();
                    }
                }
            }

            mCreatedMenus = newMenus;

            if (ActionBarSherlock.DEBUG) Log.d(TAG, "[onCreatePanelMenu] fragments create result: " + show);
            result |= show;

            if (ActionBarSherlock.DEBUG) Log.d(TAG, "[onCreatePanelMenu] returning " + result);
            return result;
        }
        return false;
    }
585490
public void createPackageContents() {
		if (isCreated) return;
		isCreated = true;

		// Create classes and their features
		betaDistributionTypeEClass = createEClass(BETA_DISTRIBUTION_TYPE);
		createEAttribute(betaDistributionTypeEClass, BETA_DISTRIBUTION_TYPE__SCALE);
		createEAttribute(betaDistributionTypeEClass, BETA_DISTRIBUTION_TYPE__SHAPE);

		binomialDistributionTypeEClass = createEClass(BINOMIAL_DISTRIBUTION_TYPE);
		createEAttribute(binomialDistributionTypeEClass, BINOMIAL_DISTRIBUTION_TYPE__PROBABILITY);
		createEAttribute(binomialDistributionTypeEClass, BINOMIAL_DISTRIBUTION_TYPE__TRIALS);

		booleanParameterTypeEClass = createEClass(BOOLEAN_PARAMETER_TYPE);
		createEAttribute(booleanParameterTypeEClass, BOOLEAN_PARAMETER_TYPE__VALUE);

		bpSimDataTypeEClass = createEClass(BP_SIM_DATA_TYPE);
		createEAttribute(bpSimDataTypeEClass, BP_SIM_DATA_TYPE__GROUP);
		createEReference(bpSimDataTypeEClass, BP_SIM_DATA_TYPE__SCENARIO);

		calendarEClass = createEClass(CALENDAR);
		createEAttribute(calendarEClass, CALENDAR__VALUE);
		createEAttribute(calendarEClass, CALENDAR__ID);
		createEAttribute(calendarEClass, CALENDAR__NAME);

		constantParameterEClass = createEClass(CONSTANT_PARAMETER);

		controlParametersEClass = createEClass(CONTROL_PARAMETERS);
		createEReference(controlParametersEClass, CONTROL_PARAMETERS__PROBABILITY);
		createEReference(controlParametersEClass, CONTROL_PARAMETERS__CONDITION);
		createEReference(controlParametersEClass, CONTROL_PARAMETERS__INTER_TRIGGER_TIMER);
		createEReference(controlParametersEClass, CONTROL_PARAMETERS__TRIGGER_COUNT);

		costParametersEClass = createEClass(COST_PARAMETERS);
		createEReference(costParametersEClass, COST_PARAMETERS__FIXED_COST);
		createEReference(costParametersEClass, COST_PARAMETERS__UNIT_COST);

		dateTimeParameterTypeEClass = createEClass(DATE_TIME_PARAMETER_TYPE);
		createEAttribute(dateTimeParameterTypeEClass, DATE_TIME_PARAMETER_TYPE__VALUE);

		distributionParameterEClass = createEClass(DISTRIBUTION_PARAMETER);
		createEAttribute(distributionParameterEClass, DISTRIBUTION_PARAMETER__CURRENCY_UNIT);
		createEAttribute(distributionParameterEClass, DISTRIBUTION_PARAMETER__TIME_UNIT);

		documentRootEClass = createEClass(DOCUMENT_ROOT);
		createEAttribute(documentRootEClass, DOCUMENT_ROOT__MIXED);
		createEReference(documentRootEClass, DOCUMENT_ROOT__XMLNS_PREFIX_MAP);
		createEReference(documentRootEClass, DOCUMENT_ROOT__XSI_SCHEMA_LOCATION);
		createEReference(documentRootEClass, DOCUMENT_ROOT__BETA_DISTRIBUTION);
		createEReference(documentRootEClass, DOCUMENT_ROOT__PARAMETER_VALUE);
		createEReference(documentRootEClass, DOCUMENT_ROOT__BINOMIAL_DISTRIBUTION);
		createEReference(documentRootEClass, DOCUMENT_ROOT__BOOLEAN_PARAMETER);
		createEReference(documentRootEClass, DOCUMENT_ROOT__BP_SIM_DATA);
		createEReference(documentRootEClass, DOCUMENT_ROOT__DATE_TIME_PARAMETER);
		createEReference(documentRootEClass, DOCUMENT_ROOT__DURATION_PARAMETER);
		createEReference(documentRootEClass, DOCUMENT_ROOT__ENUM_PARAMETER);
		createEReference(documentRootEClass, DOCUMENT_ROOT__ERLANG_DISTRIBUTION);
		createEReference(documentRootEClass, DOCUMENT_ROOT__EXPRESSION_PARAMETER);
		createEReference(documentRootEClass, DOCUMENT_ROOT__FLOATING_PARAMETER);
		createEReference(documentRootEClass, DOCUMENT_ROOT__GAMMA_DISTRIBUTION);
		createEReference(documentRootEClass, DOCUMENT_ROOT__LOG_NORMAL_DISTRIBUTION);
		createEReference(documentRootEClass, DOCUMENT_ROOT__NEGATIVE_EXPONENTIAL_DISTRIBUTION);
		createEReference(documentRootEClass, DOCUMENT_ROOT__NORMAL_DISTRIBUTION);
		createEReference(documentRootEClass, DOCUMENT_ROOT__NUMERIC_PARAMETER);
		createEReference(documentRootEClass, DOCUMENT_ROOT__POISSON_DISTRIBUTION);
		createEReference(documentRootEClass, DOCUMENT_ROOT__STRING_PARAMETER);
		createEReference(documentRootEClass, DOCUMENT_ROOT__TRIANGULAR_DISTRIBUTION);
		createEReference(documentRootEClass, DOCUMENT_ROOT__TRUNCATED_NORMAL_DISTRIBUTION);
		createEReference(documentRootEClass, DOCUMENT_ROOT__UNIFORM_DISTRIBUTION);
		createEReference(documentRootEClass, DOCUMENT_ROOT__USER_DISTRIBUTION);
		createEReference(documentRootEClass, DOCUMENT_ROOT__USER_DISTRIBUTION_DATA_POINT);
		createEReference(documentRootEClass, DOCUMENT_ROOT__WEIBULL_DISTRIBUTION);

		durationParameterTypeEClass = createEClass(DURATION_PARAMETER_TYPE);
		createEAttribute(durationParameterTypeEClass, DURATION_PARAMETER_TYPE__VALUE);

		elementParametersEClass = createEClass(ELEMENT_PARAMETERS);
		createEReference(elementParametersEClass, ELEMENT_PARAMETERS__TIME_PARAMETERS);
		createEReference(elementParametersEClass, ELEMENT_PARAMETERS__CONTROL_PARAMETERS);
		createEReference(elementParametersEClass, ELEMENT_PARAMETERS__RESOURCE_PARAMETERS);
		createEReference(elementParametersEClass, ELEMENT_PARAMETERS__PRIORITY_PARAMETERS);
		createEReference(elementParametersEClass, ELEMENT_PARAMETERS__COST_PARAMETERS);
		createEReference(elementParametersEClass, ELEMENT_PARAMETERS__PROPERTY_PARAMETERS);
		createEReference(elementParametersEClass, ELEMENT_PARAMETERS__VENDOR_EXTENSION);
		createEAttribute(elementParametersEClass, ELEMENT_PARAMETERS__ELEMENT_REF);
		createEAttribute(elementParametersEClass, ELEMENT_PARAMETERS__ID);

		elementParametersTypeEClass = createEClass(ELEMENT_PARAMETERS_TYPE);

		enumParameterTypeEClass = createEClass(ENUM_PARAMETER_TYPE);
		createEAttribute(enumParameterTypeEClass, ENUM_PARAMETER_TYPE__GROUP);
		createEAttribute(enumParameterTypeEClass, ENUM_PARAMETER_TYPE__PARAMETER_VALUE_GROUP);
		createEReference(enumParameterTypeEClass, ENUM_PARAMETER_TYPE__PARAMETER_VALUE);

		erlangDistributionTypeEClass = createEClass(ERLANG_DISTRIBUTION_TYPE);
		createEAttribute(erlangDistributionTypeEClass, ERLANG_DISTRIBUTION_TYPE__K);
		createEAttribute(erlangDistributionTypeEClass, ERLANG_DISTRIBUTION_TYPE__MEAN);

		expressionParameterTypeEClass = createEClass(EXPRESSION_PARAMETER_TYPE);
		createEAttribute(expressionParameterTypeEClass, EXPRESSION_PARAMETER_TYPE__VALUE);

		floatingParameterTypeEClass = createEClass(FLOATING_PARAMETER_TYPE);
		createEAttribute(floatingParameterTypeEClass, FLOATING_PARAMETER_TYPE__CURRENCY_UNIT);
		createEAttribute(floatingParameterTypeEClass, FLOATING_PARAMETER_TYPE__TIME_UNIT);
		createEAttribute(floatingParameterTypeEClass, FLOATING_PARAMETER_TYPE__VALUE);

		gammaDistributionTypeEClass = createEClass(GAMMA_DISTRIBUTION_TYPE);
		createEAttribute(gammaDistributionTypeEClass, GAMMA_DISTRIBUTION_TYPE__SCALE);
		createEAttribute(gammaDistributionTypeEClass, GAMMA_DISTRIBUTION_TYPE__SHAPE);

		logNormalDistributionTypeEClass = createEClass(LOG_NORMAL_DISTRIBUTION_TYPE);
		createEAttribute(logNormalDistributionTypeEClass, LOG_NORMAL_DISTRIBUTION_TYPE__MEAN);
		createEAttribute(logNormalDistributionTypeEClass, LOG_NORMAL_DISTRIBUTION_TYPE__STANDARD_DEVIATION);

		negativeExponentialDistributionTypeEClass = createEClass(NEGATIVE_EXPONENTIAL_DISTRIBUTION_TYPE);
		createEAttribute(negativeExponentialDistributionTypeEClass, NEGATIVE_EXPONENTIAL_DISTRIBUTION_TYPE__MEAN);

		normalDistributionTypeEClass = createEClass(NORMAL_DISTRIBUTION_TYPE);
		createEAttribute(normalDistributionTypeEClass, NORMAL_DISTRIBUTION_TYPE__MEAN);
		createEAttribute(normalDistributionTypeEClass, NORMAL_DISTRIBUTION_TYPE__STANDARD_DEVIATION);

		numericParameterTypeEClass = createEClass(NUMERIC_PARAMETER_TYPE);
		createEAttribute(numericParameterTypeEClass, NUMERIC_PARAMETER_TYPE__CURRENCY_UNIT);
		createEAttribute(numericParameterTypeEClass, NUMERIC_PARAMETER_TYPE__TIME_UNIT);
		createEAttribute(numericParameterTypeEClass, NUMERIC_PARAMETER_TYPE__VALUE);

		parameterEClass = createEClass(PARAMETER);
		createEAttribute(parameterEClass, PARAMETER__RESULT_REQUEST);
		createEAttribute(parameterEClass, PARAMETER__PARAMETER_VALUE_GROUP);
		createEReference(parameterEClass, PARAMETER__PARAMETER_VALUE);
		createEAttribute(parameterEClass, PARAMETER__KPI);
		createEAttribute(parameterEClass, PARAMETER__SLA);

		parameterValueEClass = createEClass(PARAMETER_VALUE);
		createEAttribute(parameterValueEClass, PARAMETER_VALUE__INSTANCE);
		createEAttribute(parameterValueEClass, PARAMETER_VALUE__RESULT);
		createEAttribute(parameterValueEClass, PARAMETER_VALUE__VALID_FOR);

		poissonDistributionTypeEClass = createEClass(POISSON_DISTRIBUTION_TYPE);
		createEAttribute(poissonDistributionTypeEClass, POISSON_DISTRIBUTION_TYPE__MEAN);

		priorityParametersEClass = createEClass(PRIORITY_PARAMETERS);
		createEReference(priorityParametersEClass, PRIORITY_PARAMETERS__INTERRUPTIBLE);
		createEReference(priorityParametersEClass, PRIORITY_PARAMETERS__PRIORITY);

		propertyParametersEClass = createEClass(PROPERTY_PARAMETERS);
		createEReference(propertyParametersEClass, PROPERTY_PARAMETERS__PROPERTY);

		propertyTypeEClass = createEClass(PROPERTY_TYPE);
		createEAttribute(propertyTypeEClass, PROPERTY_TYPE__NAME);

		resourceParametersEClass = createEClass(RESOURCE_PARAMETERS);
		createEReference(resourceParametersEClass, RESOURCE_PARAMETERS__SELECTION);
		createEReference(resourceParametersEClass, RESOURCE_PARAMETERS__AVAILABILITY);
		createEReference(resourceParametersEClass, RESOURCE_PARAMETERS__QUANTITY);
		createEReference(resourceParametersEClass, RESOURCE_PARAMETERS__ROLE);

		scenarioEClass = createEClass(SCENARIO);
		createEReference(scenarioEClass, SCENARIO__SCENARIO_PARAMETERS);
		createEReference(scenarioEClass, SCENARIO__ELEMENT_PARAMETERS);
		createEReference(scenarioEClass, SCENARIO__CALENDAR);
		createEReference(scenarioEClass, SCENARIO__VENDOR_EXTENSION);
		createEAttribute(scenarioEClass, SCENARIO__AUTHOR);
		createEAttribute(scenarioEClass, SCENARIO__CREATED);
		createEAttribute(scenarioEClass, SCENARIO__DESCRIPTION);
		createEAttribute(scenarioEClass, SCENARIO__ID);
		createEAttribute(scenarioEClass, SCENARIO__INHERITS);
		createEAttribute(scenarioEClass, SCENARIO__MODIFIED);
		createEAttribute(scenarioEClass, SCENARIO__NAME);
		createEAttribute(scenarioEClass, SCENARIO__RESULT);
		createEAttribute(scenarioEClass, SCENARIO__VENDOR);
		createEAttribute(scenarioEClass, SCENARIO__VERSION);

		scenarioParametersEClass = createEClass(SCENARIO_PARAMETERS);
		createEReference(scenarioParametersEClass, SCENARIO_PARAMETERS__START);
		createEReference(scenarioParametersEClass, SCENARIO_PARAMETERS__DURATION);
		createEReference(scenarioParametersEClass, SCENARIO_PARAMETERS__PROPERTY_PARAMETERS);
		createEAttribute(scenarioParametersEClass, SCENARIO_PARAMETERS__BASE_CURRENCY_UNIT);
		createEAttribute(scenarioParametersEClass, SCENARIO_PARAMETERS__BASE_TIME_UNIT);
		createEAttribute(scenarioParametersEClass, SCENARIO_PARAMETERS__REPLICATION);
		createEAttribute(scenarioParametersEClass, SCENARIO_PARAMETERS__SEED);

		scenarioParametersTypeEClass = createEClass(SCENARIO_PARAMETERS_TYPE);

		stringParameterTypeEClass = createEClass(STRING_PARAMETER_TYPE);
		createEAttribute(stringParameterTypeEClass, STRING_PARAMETER_TYPE__VALUE);

		timeParametersEClass = createEClass(TIME_PARAMETERS);
		createEReference(timeParametersEClass, TIME_PARAMETERS__TRANSFER_TIME);
		createEReference(timeParametersEClass, TIME_PARAMETERS__QUEUE_TIME);
		createEReference(timeParametersEClass, TIME_PARAMETERS__WAIT_TIME);
		createEReference(timeParametersEClass, TIME_PARAMETERS__SET_UP_TIME);
		createEReference(timeParametersEClass, TIME_PARAMETERS__PROCESSING_TIME);
		createEReference(timeParametersEClass, TIME_PARAMETERS__VALIDATION_TIME);
		createEReference(timeParametersEClass, TIME_PARAMETERS__REWORK_TIME);

		triangularDistributionTypeEClass = createEClass(TRIANGULAR_DISTRIBUTION_TYPE);
		createEAttribute(triangularDistributionTypeEClass, TRIANGULAR_DISTRIBUTION_TYPE__MAX);
		createEAttribute(triangularDistributionTypeEClass, TRIANGULAR_DISTRIBUTION_TYPE__MIN);
		createEAttribute(triangularDistributionTypeEClass, TRIANGULAR_DISTRIBUTION_TYPE__MODE);

		truncatedNormalDistributionTypeEClass = createEClass(TRUNCATED_NORMAL_DISTRIBUTION_TYPE);
		createEAttribute(truncatedNormalDistributionTypeEClass, TRUNCATED_NORMAL_DISTRIBUTION_TYPE__MAX);
		createEAttribute(truncatedNormalDistributionTypeEClass, TRUNCATED_NORMAL_DISTRIBUTION_TYPE__MEAN);
		createEAttribute(truncatedNormalDistributionTypeEClass, TRUNCATED_NORMAL_DISTRIBUTION_TYPE__MIN);
		createEAttribute(truncatedNormalDistributionTypeEClass, TRUNCATED_NORMAL_DISTRIBUTION_TYPE__STANDARD_DEVIATION);

		uniformDistributionTypeEClass = createEClass(UNIFORM_DISTRIBUTION_TYPE);
		createEAttribute(uniformDistributionTypeEClass, UNIFORM_DISTRIBUTION_TYPE__MAX);
		createEAttribute(uniformDistributionTypeEClass, UNIFORM_DISTRIBUTION_TYPE__MIN);

		userDistributionDataPointTypeEClass = createEClass(USER_DISTRIBUTION_DATA_POINT_TYPE);
		createEAttribute(userDistributionDataPointTypeEClass, USER_DISTRIBUTION_DATA_POINT_TYPE__PARAMETER_VALUE_GROUP);
		createEReference(userDistributionDataPointTypeEClass, USER_DISTRIBUTION_DATA_POINT_TYPE__PARAMETER_VALUE);
		createEAttribute(userDistributionDataPointTypeEClass, USER_DISTRIBUTION_DATA_POINT_TYPE__PROBABILITY);

		userDistributionTypeEClass = createEClass(USER_DISTRIBUTION_TYPE);
		createEAttribute(userDistributionTypeEClass, USER_DISTRIBUTION_TYPE__GROUP);
		createEReference(userDistributionTypeEClass, USER_DISTRIBUTION_TYPE__USER_DISTRIBUTION_DATA_POINT);
		createEAttribute(userDistributionTypeEClass, USER_DISTRIBUTION_TYPE__DISCRETE);

		vendorExtensionEClass = createEClass(VENDOR_EXTENSION);
		createEAttribute(vendorExtensionEClass, VENDOR_EXTENSION__ANY);
		createEAttribute(vendorExtensionEClass, VENDOR_EXTENSION__NAME);
		createEAttribute(vendorExtensionEClass, VENDOR_EXTENSION__ANY_ATTRIBUTE);

		weibullDistributionTypeEClass = createEClass(WEIBULL_DISTRIBUTION_TYPE);
		createEAttribute(weibullDistributionTypeEClass, WEIBULL_DISTRIBUTION_TYPE__SCALE);
		createEAttribute(weibullDistributionTypeEClass, WEIBULL_DISTRIBUTION_TYPE__SHAPE);

		// Create enums
		resultTypeEEnum = createEEnum(RESULT_TYPE);
		timeUnitEEnum = createEEnum(TIME_UNIT);

		// Create data types
		resultTypeObjectEDataType = createEDataType(RESULT_TYPE_OBJECT);
		timeUnitObjectEDataType = createEDataType(TIME_UNIT_OBJECT);
	}
750267
@Override
    public boolean fileCreated(File file) throws WatchingException {
        try {
            createApplicationBundle();
        } catch (Exception e) {
            throw new WatchingException(e.getMessage(), file, e);
        }
        return true;
    }
1027223
public static StatsInstanceImpl createGroupInstance(String name, StatsGroup igroup, ObjectName userProvidedMBeanObjectName, boolean bCreateDefaultMBean,
                                                        StatisticActions actionLsnr)
                    throws StatsFactoryException {
        StatsGroupImpl group = (StatsGroupImpl) igroup;

        // construct path
        String[] parentPath = group.getPath();
        String[] path = new String[parentPath.length + 1];

        for (int i = 0; i < parentPath.length; i++) {
            path[i] = parentPath[i];
        }
        path[parentPath.length] = name;

        StatsInstanceImpl instance = new StatsInstanceImpl(name, group.getModuleConfig(), path, actionLsnr);
        //instance._scListener = scl;

        instance._register(userProvidedMBeanObjectName, bCreateDefaultMBean);

        return instance;
    }
582586
def created(self):
        
        statistics = self._properties.get("statistics")
        if statistics is not None:
            millis = statistics.get("creationTime")
            if millis is not None:
                return _helpers._datetime_from_microseconds(millis * 1000.0)
851075
public void setMinDateCreated(String minDateCreated) {

        m_parameters.setMinDateCreated(CmsStringUtil.getLongValue(minDateCreated, Long.MIN_VALUE, "minDateCreated"));
    }
378909
public StatisticImpl getStatistic() {
        if (enabled) {
            if (proxy == null) {
                System.out.println("[SpdStatisticExternal] null proxy");
                return null;
            }

            proxy.updateStatisticOnRequest(dataId);

            // onReqStatistic will be updated by the component
            // the reference is kept in this class
            return onReqStatistic;
        } else
            return null;
    }
1111054
@Override
    synchronized public void surfaceCreated(SurfaceHolder holder) {
        Log.d(TAG, "surfaceCreated called = " + currentState);

        if (this.mediaPlayer != null) {
            this.mediaPlayer.setDisplay(surfaceHolder);

            // If is not prepared yet - tryToPrepare()
            if (!this.surfaceIsReady) {
                this.surfaceIsReady = true;
                if (this.currentState == State.INITIALIZED ||
                        this.currentState == State.PREPARING)
                    tryToPrepare();
            }
        }
    }
735834
@Override
	public void onViewCreated(View view, Bundle savedInstanceState) {
	
		super.onViewCreated(view, savedInstanceState);
		EventUtils.link(EVENT_CONFIGURATION);
	}
768761
@Override
    public void onCreate(final Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Toolbar myToolbar = findViewById(R.id.my_toolbar);
        setSupportActionBar(myToolbar);
        // Generate a ListView with Sample Maps
        final ArrayList<String> list = new ArrayList<>();
        list.add("OSMDroid Sample map (Start Here)");
        list.add("OSMapView with Minimap, ZoomControls, Animations, Scale Bar and MyLocationOverlay");
        list.add("OSMapView with ItemizedOverlay");
        list.add("OSMapView with Minimap and ZoomControls");
        list.add("Sample with tiles overlay");
        list.add("Sample with tiles overlay and secondary tile overlay");
        list.add("More Samples");

        list.add("Report a bug");
        list.add("Settings");
        list.add("Bug Drivers");
        list.add("Diagnostics");
        list.add("View the intro again");
        list.add("Licenses");
        if (BuildConfig.VERSION_CODE >= 11)
            list.add("Cache Analyzer");

        ListView lv = findViewById(R.id.activitylist);
        ArrayAdapter adapter = new ArrayAdapter<>(this, android.R.layout.simple_list_item_1, list);

        lv.setAdapter(adapter);
        lv.setOnItemClickListener(this);

    }
310820
@Override
    public void doSessionCreatedListeners() {
        runManagementTask(new Runnable() {
            @Override
            public void run() {
                try {
                    // The particular management listeners change on strategy, so get them here.
                    for (final SessionManagementListener listener : getManagementListeners()) {
                        listener.doSessionCreated(SessionManagementBeanImpl.this);
                    }

                    // XXX Should we include a 'markChanged()' here?
                } catch (Exception ex) {
                    logger.warn("Error during doSessionCreated session listener notifications:", ex);
                }
            }
        });
    }
800018
@Override
	public void onSimonCreated(Simon simon) {
		if (simon instanceof Stopwatch) {
			Stopwatch stopwatch = (Stopwatch) simon;
			LastSplits lastSplits = new LastSplits(capacity);
			lastSplits.setLogTemplate(createLogTemplate(stopwatch));
			stopwatch.setAttribute(ATTR_NAME_LAST_SPLITS, lastSplits);
		}

	}
783364
public void setCreativeSetStats(com.google.api.ads.admanager.axis.v201808.Long_StatsMapEntry[] creativeSetStats) {
        this.creativeSetStats = creativeSetStats;
    }
838260
public StatisticImpl[] getJ2EEStatistics() {
        ArrayList members = copyStatistics();
        if (members == null || members.size() == 0)
            return new StatisticImpl[0];

        StatisticImpl[] ret = new StatisticImpl[members.size()];
        for (int i = 0; i < ret.length; i++) {
            ret[i] = (StatisticImpl) members.get(i);
        }
        return ret;
    }
624510
@Override
	public void onCreate(final Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);

		final RelativeLayout rl = new RelativeLayout(this);

		this.mMapView = new MapView(this);
		this.mMapView.setTilesScaledToDpi(true);
		rl.addView(this.mMapView, new RelativeLayout.LayoutParams(LayoutParams.FILL_PARENT,
				LayoutParams.FILL_PARENT));

		/* Itemized Overlay */
		{
			/* Create a static ItemizedOverlay showing a some Markers on some cities. */
			final ArrayList<OverlayItem> items = new ArrayList<>();
			items.add(new OverlayItem("Hannover", "SampleDescription", new GeoPoint(52.370816, 9.735936)));
			items.add(new OverlayItem("Berlin", "SampleDescription", new GeoPoint(52.518333, 13.408333)));
			items.add(new OverlayItem("Washington", "SampleDescription", new GeoPoint(38.895000, -77.036667)));
			items.add(new OverlayItem("San Francisco", "SampleDescription", new GeoPoint(37.779300, -122.419200)));
			items.add(new OverlayItem("Tolaga Bay", "SampleDescription", new GeoPoint(-38.371000, 178.298000)));

			/* OnTapListener for the Markers, shows a simple Toast. */
			this.mMyLocationOverlay = new ItemizedIconOverlay<>(items,
					new ItemizedIconOverlay.OnItemGestureListener<OverlayItem>() {
						@Override
						public boolean onItemSingleTapUp(final int index, final OverlayItem item) {
							Toast.makeText(
									SampleWithMinimapItemizedoverlay.this,
									"Item '" + item.getTitle() + "' (index=" + index
											+ ") got single tapped up", Toast.LENGTH_LONG).show();
							return true; // We 'handled' this event.
						}

						@Override
						public boolean onItemLongPress(final int index, final OverlayItem item) {
							Toast.makeText(
									SampleWithMinimapItemizedoverlay.this,
									"Item '" + item.getTitle() + "' (index=" + index
											+ ") got long pressed", Toast.LENGTH_LONG).show();
							return true;
						}
					}, getApplicationContext());
			this.mMapView.getOverlays().add(this.mMyLocationOverlay);
		}

		/* MiniMap */
		{
			final MinimapOverlay miniMapOverlay = new MinimapOverlay(this,
					mMapView.getTileRequestCompleteHandler());
			this.mMapView.getOverlays().add(miniMapOverlay);
		}

		/* list of items currently displayed */
		{
			final MapEventsReceiver mReceive = new MapEventsReceiver() {
				@Override
				public boolean singleTapConfirmedHelper(GeoPoint p) {
					return false;
				}

				@Override
				public boolean longPressHelper(final GeoPoint p) {
					final List<OverlayItem> displayed = mMyLocationOverlay.getDisplayedItems();
					final StringBuilder buffer = new StringBuilder();
					String sep = "";
					for (final OverlayItem item : displayed) {
						buffer.append(sep).append('\'').append(item.getTitle()).append('\'');
						sep = ", ";
					}
					Toast.makeText(
							SampleWithMinimapItemizedoverlay.this,
							"Currently displayed: " + buffer.toString(), Toast.LENGTH_LONG).show();
					return true;
				}
			};
			mMapView.getOverlays().add(new MapEventsOverlay(mReceive));

			final RotationGestureOverlay rotationGestureOverlay = new RotationGestureOverlay(mMapView);
			rotationGestureOverlay.setEnabled(true);
			mMapView.getOverlays().add(rotationGestureOverlay);
		}

		this.setContentView(rl);

		// Default location and zoom level
		IMapController mapController = mMapView.getController();
		mapController.setZoom(5.);
		GeoPoint startPoint = new GeoPoint(50.936255, 6.957779);
		mapController.setCenter(startPoint);
	}