max_stars_count
int64 301
224k
| text
stringlengths 6
1.05M
| token_count
int64 3
727k
|
|---|---|---|
303 | #pragma once
#include "common/luax.h"
#include "contact/contact.h"
namespace Wrap_Contact
{
int GetPositions(lua_State* L);
int GetNormal(lua_State* L);
int GetFriction(lua_State* L);
int GetRestitution(lua_State* L);
int IsEnabled(lua_State* L);
int IsTouching(lua_State* L);
int SetFriction(lua_State* L);
int SetRestitution(lua_State* L);
int SetEnabled(lua_State* L);
int ResetFriction(lua_State* L);
int ResetRestitution(lua_State* L);
int SetTangentSpeed(lua_State* L);
int GetTangentSpeed(lua_State* L);
int GetChildren(lua_State* L);
int GetFixtures(lua_State* L);
int IsDestroyed(lua_State* L);
love::Contact* CheckContact(lua_State* L, int index);
int Register(lua_State* L);
} // namespace Wrap_Contact
| 316 |
475 | // Copyright (c) 2015-2016 <NAME>
// License: Academic Free License ("AFL") v. 3.0
// AFL License page: http://opensource.org/licenses/AFL-3.0
// http://vittorioromeo.info | <EMAIL>
#pragma once
#include <ecst/config.hpp>
#include <ecst/mp/edge.hpp>
#include <ecst/mp/adjacency_list/basic.hpp>
ECST_MP_ADJACENCY_LIST_NAMESPACE
{
namespace impl
{
template <typename TNodeDataPair>
constexpr auto ndp_goal(TNodeDataPair ndp)
{
return pair::fst(ndp);
}
template <typename TNodeDataPair>
constexpr auto ndp_data(TNodeDataPair ndp)
{
return pair::snd(ndp);
}
template <typename TNode, typename TNodeDataPair>
constexpr auto to_edge(TNode n, TNodeDataPair ndp)
{
return edge::make_data(n, ndp_goal(ndp), ndp_data(ndp));
}
template <typename TNode, typename TNDPList>
constexpr auto to_edge_list(TNode n, TNDPList ndp_list)
{
return list::transform(
[=](auto x)
{
return to_edge(n, x);
},
ndp_list);
}
}
}
ECST_MP_ADJACENCY_LIST_NAMESPACE_END
| 640 |
312 | <filename>core/sail/sail-spin/src/main/java/org/eclipse/rdf4j/sail/SailConnectionGraphQuery.java<gh_stars>100-1000
/*******************************************************************************
* Copyright (c) 2015 Eclipse RDF4J contributors, Aduna, and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Distribution License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*******************************************************************************/
package org.eclipse.rdf4j.sail;
import org.eclipse.rdf4j.common.iteration.CloseableIteration;
import org.eclipse.rdf4j.common.iteration.ConvertingIteration;
import org.eclipse.rdf4j.common.iteration.FilterIteration;
import org.eclipse.rdf4j.model.IRI;
import org.eclipse.rdf4j.model.Resource;
import org.eclipse.rdf4j.model.Statement;
import org.eclipse.rdf4j.model.Value;
import org.eclipse.rdf4j.model.ValueFactory;
import org.eclipse.rdf4j.query.BindingSet;
import org.eclipse.rdf4j.query.GraphQuery;
import org.eclipse.rdf4j.query.GraphQueryResult;
import org.eclipse.rdf4j.query.QueryEvaluationException;
import org.eclipse.rdf4j.query.QueryResults;
import org.eclipse.rdf4j.query.algebra.TupleExpr;
import org.eclipse.rdf4j.query.impl.IteratingGraphQueryResult;
import org.eclipse.rdf4j.query.parser.ParsedGraphQuery;
import org.eclipse.rdf4j.rio.RDFHandler;
import org.eclipse.rdf4j.rio.RDFHandlerException;
/**
* @author <NAME>
*/
public class SailConnectionGraphQuery extends SailConnectionQuery implements GraphQuery {
private final ValueFactory vf;
public SailConnectionGraphQuery(ParsedGraphQuery tupleQuery, SailConnection con, ValueFactory vf) {
super(tupleQuery, con);
this.vf = vf;
}
@Override
public ParsedGraphQuery getParsedQuery() {
return (ParsedGraphQuery) super.getParsedQuery();
}
@Override
public GraphQueryResult evaluate() throws QueryEvaluationException {
TupleExpr tupleExpr = getParsedQuery().getTupleExpr();
CloseableIteration<? extends BindingSet, QueryEvaluationException> bindingsIter1 = null;
CloseableIteration<? extends BindingSet, QueryEvaluationException> bindingsIter2 = null;
CloseableIteration<? extends BindingSet, QueryEvaluationException> bindingsIter3 = null;
CloseableIteration<Statement, QueryEvaluationException> stIter = null;
IteratingGraphQueryResult result = null;
boolean allGood = false;
try {
SailConnection sailCon = getSailConnection();
bindingsIter1 = sailCon.evaluate(tupleExpr, getActiveDataset(), getBindings(), getIncludeInferred());
// Filters out all partial and invalid matches
bindingsIter2 = new FilterIteration<BindingSet, QueryEvaluationException>(bindingsIter1) {
@Override
protected boolean accept(BindingSet bindingSet) {
Value context = bindingSet.getValue("context");
return bindingSet.getValue("subject") instanceof Resource
&& bindingSet.getValue("predicate") instanceof IRI
&& bindingSet.getValue("object") instanceof Value
&& (context == null || context instanceof Resource);
}
};
bindingsIter3 = enforceMaxQueryTime(bindingsIter2);
// Convert the BindingSet objects to actual RDF statements
stIter = new ConvertingIteration<BindingSet, Statement, QueryEvaluationException>(bindingsIter3) {
@Override
protected Statement convert(BindingSet bindingSet) {
Resource subject = (Resource) bindingSet.getValue("subject");
IRI predicate = (IRI) bindingSet.getValue("predicate");
Value object = bindingSet.getValue("object");
Resource context = (Resource) bindingSet.getValue("context");
if (context == null) {
return vf.createStatement(subject, predicate, object);
} else {
return vf.createStatement(subject, predicate, object, context);
}
}
};
result = new IteratingGraphQueryResult(getParsedQuery().getQueryNamespaces(), stIter);
allGood = true;
return result;
} catch (SailException e) {
throw new QueryEvaluationException(e.getMessage(), e);
} finally {
if (!allGood) {
try {
if (result != null) {
result.close();
}
} finally {
try {
if (stIter != null) {
stIter.close();
}
} finally {
try {
if (bindingsIter3 != null) {
bindingsIter3.close();
}
} finally {
try {
if (bindingsIter2 != null) {
bindingsIter2.close();
}
} finally {
if (bindingsIter1 != null) {
bindingsIter1.close();
}
}
}
}
}
}
}
}
@Override
public void evaluate(RDFHandler handler) throws QueryEvaluationException, RDFHandlerException {
GraphQueryResult queryResult = evaluate();
QueryResults.report(queryResult, handler);
}
}
| 1,724 |
746 | <gh_stars>100-1000
package org.protege.editor.owl.ui.explanation;
import org.protege.editor.core.prefs.Preferences;
import org.protege.editor.core.prefs.PreferencesManager;
import org.protege.editor.owl.model.inference.ReasonerPreferences;
import org.semanticweb.owlapi.model.OWLAxiom;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Collection;
public class ExplanationDialog extends JPanel {
public static final String PREFERENCES_SET_KEY = "EXPLANATION_PREFS_SET";
public static final String DEFAULT_EXPLANATION_ID = "PREFERRED_PLUGIN_ID";
private JPanel explanationContainer;
private ExplanationResult explanation;
private OWLAxiom axiom;
public ExplanationDialog(ExplanationManager explanationManager, OWLAxiom axiom) {
this.axiom = axiom;
setLayout(new BorderLayout());
Collection<ExplanationService> teachers = explanationManager.getTeachers(axiom);
if (teachers.size() == 1) {
explanation = teachers.iterator().next().explain(axiom);
}
else {
JComboBox<ExplanationService> selector = createComboBox(teachers);
add(selector, BorderLayout.NORTH);
}
explanationContainer = new JPanel();
explanationContainer.setLayout(new BoxLayout(explanationContainer, BoxLayout.Y_AXIS));
if (explanation != null) {
explanationContainer.add(explanation);
}
add(explanationContainer, BorderLayout.CENTER);
}
private JComboBox<ExplanationService> createComboBox(Collection<ExplanationService> explanationServices) {
ExplanationService[] teacherArray = explanationServices.toArray(new ExplanationService[explanationServices.size()]);
final JComboBox<ExplanationService> selector = new JComboBox<>(teacherArray);
if (teacherArray.length > 0) {
ExplanationService selected = teacherArray[0];
String id = getDefaultPluginId();
if (id != null) {
for (ExplanationService t : explanationServices) {
if (id.equals(t.getPluginId())) {
selected = t;
}
}
}
selector.setSelectedItem(selected);
explanation = selected.explain(axiom);
}
selector.addActionListener(e -> {
ExplanationService t = (ExplanationService) selector.getSelectedItem();
setDefaultPluginId(t.getPluginId());
explanationContainer.removeAll();
if (explanation != null) {
explanation.dispose();
}
explanation = t.explain(axiom);
explanationContainer.add(explanation);
revalidate();
});
return selector;
}
public String getDefaultPluginId() {
PreferencesManager prefMan = PreferencesManager.getInstance();
Preferences prefs = prefMan.getPreferencesForSet(PREFERENCES_SET_KEY, ReasonerPreferences.class);
return prefs.getString(DEFAULT_EXPLANATION_ID, null);
}
public void setDefaultPluginId(String id) {
PreferencesManager prefMan = PreferencesManager.getInstance();
Preferences prefs = prefMan.getPreferencesForSet(PREFERENCES_SET_KEY, ReasonerPreferences.class);
prefs.putString(DEFAULT_EXPLANATION_ID, id);
}
public void dispose() {
if (explanation != null) {
explanation.dispose();
}
}
}
| 1,444 |
692 | package com.hubspot.singularity.executor.config;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.hubspot.singularity.executor.SingularityExecutorLogrotateFrequency;
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import java.util.Optional;
public class SingularityExecutorLogrotateAdditionalFile {
private final String filename;
private final Optional<String> extension;
private final Optional<String> dateformat;
private final Optional<SingularityExecutorLogrotateFrequency> logrotateFrequencyOverride;
private final Optional<String> logrotateSizeOverride;
private final boolean deleteInExecutorCleanup;
@JsonCreator
@SuppressFBWarnings("NP_NULL_PARAM_DEREF_NONVIRTUAL")
public static SingularityExecutorLogrotateAdditionalFile fromString(String value) {
return new SingularityExecutorLogrotateAdditionalFile(
value,
Optional.empty(),
Optional.empty(),
null,
null,
false
);
}
@JsonCreator
public SingularityExecutorLogrotateAdditionalFile(
@JsonProperty("filename") String filename,
@JsonProperty("extension") Optional<String> extension,
@JsonProperty("dateformat") Optional<String> dateformat,
@JsonProperty(
"logrotateFrequencyOverride"
) SingularityExecutorLogrotateFrequency logrotateFrequencyOverride,
@JsonProperty("logrotateSizeOverride") String logrotateSizeOverride,
@JsonProperty("deleteInExecutorCleanup") boolean deleteInExecutorCleanup
) {
this.filename = filename;
this.extension = extension;
this.dateformat = dateformat;
this.logrotateFrequencyOverride = Optional.ofNullable(logrotateFrequencyOverride);
this.logrotateSizeOverride = Optional.ofNullable(logrotateSizeOverride);
this.deleteInExecutorCleanup = deleteInExecutorCleanup;
}
public String getFilename() {
return filename;
}
public Optional<String> getExtension() {
return extension;
}
public Optional<String> getDateformat() {
return dateformat;
}
public Optional<SingularityExecutorLogrotateFrequency> getLogrotateFrequencyOverride() {
return logrotateFrequencyOverride;
}
public Optional<String> getLogrotateSizeOverride() {
return logrotateSizeOverride;
}
public boolean isDeleteInExecutorCleanup() {
return deleteInExecutorCleanup;
}
}
| 758 |
528 | #include "src/traitsd.h"
#include "src/block4.h"
#include "constants/4dDouble.h"
#define CFP_ARRAY_TYPE cfp_array4d
#define CFP_REF_TYPE cfp_ref4d
#define CFP_PTR_TYPE cfp_ptr4d
#define CFP_ITER_TYPE cfp_iter4d
#define SUB_NAMESPACE array4d
#define SCALAR double
#define SCALAR_TYPE zfp_type_double
#define DIMENSIONALITY 4
#include "testCfpArray_source.c"
#include "testCfpArray4_source.c"
int main()
{
const struct CMUnitTest tests[] = {
cmocka_unit_test(when_seededRandomSmoothDataGenerated_expect_ChecksumMatches),
cmocka_unit_test(given_cfp_array4d_when_defaultCtor_expect_returnsNonNullPtr),
cmocka_unit_test_setup_teardown(given_cfp_array4d_when_ctor_expect_paramsSet, setupCfpArrLargeComplete, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_array4d_when_copyCtor_expect_paramsCopied, setupCfpArrLargeComplete, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_array4d_when_copyCtor_expect_cacheCopied, setupCfpArrLargeComplete, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_array4d_when_headerCtor_expect_copied, setupCfpArrLargeComplete, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_array4d_header_expect_matchingMetadata, setupCfpArrLargeComplete, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_array4d_header_when_bufferCtor_expect_copied, setupCfpArrLargeComplete, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_array4d_header_when_bufferCtor_expect_paramsCopied, setupCfpArrLargeComplete, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_array4d_when_setRate_expect_rateSet, setupCfpArrMinimal, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_array4d_when_setCacheSize_expect_cacheSizeSet, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_array4d_with_dirtyCache_when_flushCache_expect_cacheEntriesPersistedToMemory, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_array4d_when_clearCache_expect_cacheCleared, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_array4d_when_resize_expect_sizeChanged, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_array4d_when_setFlat_expect_entryWrittenToCacheOnly, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_array4d_when_getFlat_expect_entryReturned, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_array4d_when_set_expect_entryWrittenToCacheOnly, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_array4d_when_get_expect_entryReturned, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_array4d_when_ref_expect_arrayObjectValid, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_array4d_when_ptr_expect_arrayObjectValid, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_array4d_when_ref_flat_expect_entryReturned, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_array4d_when_ptr_flat_expect_entryReturned, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_array4d_when_begin_expect_objectValid, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_array4d_when_end_expect_objectValid, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_ref4d_when_get_expect_entryReturned, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_ref4d_when_set_expect_arrayUpdated, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_ref4d_when_ptr_expect_addressMatches, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_ref4d_when_copy_expect_arrayUpdated, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_ptr4d_when_get_set_expect_correct, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_ptr4d_when_get_at_set_at_expect_correct, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_ptr4d_when_ref_expect_addressMatches, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_ptr4d_when_ref_at_expect_correct, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_ptr4d_when_lt_expect_less, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_ptr4d_when_gt_expect_greater, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_ptr4d_when_leq_expect_less_or_equal, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_ptr4d_when_geq_expect_greater_or_equal, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_ptr4d_when_eq_expect_equal, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_ptr4d_when_neq_expect_not_equal, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_ptr4d_when_distance_expect_correct, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_ptr4d_when_next_expect_correct, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_ptr4d_when_prev_expect_correct, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_ptr4d_when_inc_expect_correct, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_ptr4d_when_dec_expect_correct, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_iter4d_when_get_set_expect_correct, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_iter4d_when_get_at_set_at_expect_correct, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_iter4d_when_ref_expect_correct, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_iter4d_when_ref_at_expect_correct, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_iter4d_when_ptr_expect_correct, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_iter4d_when_ptr_at_expect_correct, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_iter4d_when_lt_expect_less, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_iter4d_when_gt_expect_greater, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_iter4d_when_leq_expect_less_or_equal, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_iter4d_when_geq_expect_greater_or_equal, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_iter4d_when_eq_expect_equal, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_iter4d_when_neq_expect_not_equal, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_iter4d_when_distance_expect_correct, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_iter4d_when_next_expect_correct, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_iter4d_when_prev_expect_correct, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_iter4d_when_inc_expect_correct, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_iter4d_when_dec_expect_correct, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_iter4d_when_iterate_touch_all, setupCfpArrSmall, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_iter4d_when_get_index_expect_correct, setupCfpArrSmall, teardownCfpArr),
/* NOTE: 4D arrays only support 8bit rates so setupFixedRate1 and 2 aren't used for testing here */
cmocka_unit_test_setup_teardown(given_cfp_array4d_when_setArray_expect_compressedStreamChecksumMatches, setupFixedRate0, teardownCfpArr),
cmocka_unit_test_setup_teardown(given_cfp_array4d_when_getArray_expect_decompressedArrChecksumMatches, setupFixedRate0, teardownCfpArr),
};
return cmocka_run_group_tests(tests, prepCommonSetupVars, teardownCommonSetupVars);
}
| 3,644 |
369 | {
"dockerFile": "Dockerfile",
"extensions": [
"dart-code.flutter",
"darkriszty.markdown-table-prettify",
"foxundermoon.shell-format"
]
} | 69 |
435 | <filename>pycon-us-2019/videos/deepak-k-gupta-hello-world-of-machine-learning-using-scikit-learn-pycon-2019.json
{
"copyright_text": null,
"description": "***Welcome to the Machine Learning tutorial for absolute beginners.***\n\n This tutorial will not make you an expert in Machine Learning but\n will cover enough things to acquaint, enable and empower you to\n understand, explore and exploits the concept and idea behind it.\n\n--------------\n\n**We'll be learning by generating our own data with bare minimal data\npoints (5 - 10) so that we can manually verify our machine learning\nalgorithms to understand it better.**\n\n*This will also help us to see how changes in data can impact our\nMachine Learning Algorithms. At the end of this tutorial, we'll also be\nusing one real-world Dataset and play with it.*\n\n--------------\n\n*In this tutorial, I'll be covering at least 3 well-known ML\nalgorithms(KNN, Linear and Logistic Regression) along with all the maths\nbehind it. We'll end the tutorial with a real-world mapping application*\n\n*There is no major prerequisite for attending this, you just need to\nknow the basics of python language and I'll cover the rest. We'll be\nusing Scikit Learn for simplicity purpose, again, you don't need to have\nany prior experience with Scikit Learn or for that matter with Machine\nLearning*\n",
"duration": 11535,
"language": "eng",
"recorded": "2019-05-02T09:00:00",
"related_urls": [
{
"label": "Conference schedule",
"url": "https://us.pycon.org/2019/schedule/talks/"
},
{
"label": "Conference slides (speakerdeck)",
"url": "https://speakerdeck.com/pycon2019"
},
{
"label": "Conference slides (github)",
"url": "https://github.com/PyCon/2019-slides"
},
{
"label": "Talk schedule",
"url": "https://us.pycon.org/2019/schedule/presentation/71/"
}
],
"speakers": [
"<NAME>"
],
"tags": [
"tutorial"
],
"thumbnail_url": "https://i.ytimg.com/vi/bCDcI8SdjD8/hqdefault.jpg",
"title": "Hello World of Machine Learning Using Scikit Learn",
"videos": [
{
"type": "youtube",
"url": "https://www.youtube.com/watch?v=bCDcI8SdjD8"
}
]
}
| 771 |
375 | <filename>src/Eclipse-IDE/org.robotframework.ide.eclipse.main.plugin.tests/src/org/robotframework/red/junit/jupiter/ProjectExtension.java<gh_stars>100-1000
/*
* Copyright 2020 Nokia Solutions and Networks
* Licensed under the Apache License, Version 2.0,
* see license.txt file for details.
*/
package org.robotframework.red.junit.jupiter;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IFolder;
import org.eclipse.core.resources.IProject;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.Path;
import org.junit.jupiter.api.extension.AfterAllCallback;
import org.junit.jupiter.api.extension.AfterEachCallback;
import org.junit.jupiter.api.extension.BeforeAllCallback;
import org.junit.jupiter.api.extension.BeforeEachCallback;
import org.junit.jupiter.api.extension.Extension;
import org.junit.jupiter.api.extension.ExtensionConfigurationException;
import org.junit.jupiter.api.extension.ExtensionContext;
import org.junit.jupiter.api.extension.ExtensionContext.Namespace;
import org.junit.jupiter.api.extension.ExtensionContext.Store;
import org.rf.ide.core.project.RobotProjectConfig;
import org.rf.ide.core.testdata.text.read.EndOfLineBuilder.EndOfLineTypes;
import org.robotframework.ide.eclipse.main.plugin.project.RedEclipseProjectConfigWriter;
import org.robotframework.ide.eclipse.main.plugin.project.RobotProjectNature;
import com.google.common.base.Charsets;
import com.google.common.base.Splitter;
import com.google.common.io.CharStreams;
public class ProjectExtension
implements Extension, BeforeAllCallback, BeforeEachCallback, AfterEachCallback, AfterAllCallback {
private static final Namespace NAMESPACE = Namespace.create(ProjectExtension.class);
private static final String PROJECT_PARAM = "project.state";
public static void addRobotNature(final IProject project) throws CoreException {
RobotProjectNature.addRobotNature(project, null, p -> true);
}
public static void removeRobotNature(final IProject project) throws CoreException {
RobotProjectNature.removeRobotNature(project, null, p -> true);
}
public static void configure(final IProject project) throws IOException, CoreException {
configure(project, new RobotProjectConfig());
}
public static void configure(final IProject project, final RobotProjectConfig config)
throws IOException, CoreException {
createFile(project, RobotProjectConfig.FILENAME, "");
new RedEclipseProjectConfigWriter().writeConfiguration(config, project);
}
public static void deconfigure(final IProject project) throws CoreException {
project.findMember(RobotProjectConfig.FILENAME).delete(true, null);
}
public static IFolder getDir(final IProject project, final String dirPath) {
return project.getFolder(Path.fromPortableString(dirPath));
}
public static IFile getFile(final IProject project, final String filePath) {
return project.getFile(Path.fromPortableString(filePath));
}
public static List<String> getFileContent(final IProject project, final String filePath) {
return getFileContent(getFile(project, filePath));
}
public static List<String> getFileContent(final IFile file) {
try (final InputStream stream = file.getContents()) {
return Splitter.on('\n').splitToList(CharStreams.toString(new InputStreamReader(stream, Charsets.UTF_8)));
} catch (IOException | CoreException e) {
return new ArrayList<>();
}
}
public static IFile createFile(final IProject project, final String filePath, final String... lines)
throws IOException, CoreException {
return createFile(getFile(project, filePath), EndOfLineTypes.LF, lines);
}
public static IFile createFile(final IProject project, final String filePath, final EndOfLineTypes eolType,
final String... lines) throws IOException, CoreException {
return createFile(getFile(project, filePath), eolType, lines);
}
public static void createFile(final IProject project, final String filePath, final InputStream inputStream)
throws IOException, CoreException {
createFile(getFile(project, filePath), inputStream);
}
public static IFolder createDir(final IProject project, final String filePath)
throws IOException, CoreException {
return createDir(getDir(project, filePath));
}
@Override
public void beforeAll(final ExtensionContext context) throws Exception {
FieldsSupport.handleFields(context.getRequiredTestClass(), true, Project.class,
createAndSetNewProject(context, null));
}
@Override
public void beforeEach(final ExtensionContext context) throws Exception {
final Object testInstance = context.getRequiredTestInstance();
FieldsSupport.handleFields(testInstance.getClass(), false, Project.class,
createAndSetNewProject(context, testInstance));
}
@Override
public void afterEach(final ExtensionContext context) throws Exception {
cleanUpAfterTest(context);
final Object testInstance = context.getRequiredTestInstance();
FieldsSupport.handleFields(testInstance.getClass(), false, Project.class, deleteProject(testInstance));
}
@Override
public void afterAll(final ExtensionContext context) throws Exception {
FieldsSupport.handleFields(context.getRequiredTestClass(), true, Project.class, deleteProject(null));
}
private static Consumer<Field> createAndSetNewProject(final ExtensionContext context, final Object testInstance) {
return field -> {
assertSupportedType("field", field.getType());
final Project projectAnnotation = field.getAnnotation(Project.class);
String projectName = projectAnnotation.name();
if (projectName.isEmpty()) {
projectName = field.getDeclaringClass().getSimpleName();
}
projectName += projectAnnotation.nameSuffix();
final String[] directoryPaths = projectAnnotation.dirs();
final String[] filePaths = projectAnnotation.files();
final boolean createRedXml = projectAnnotation.createDefaultRedXml();
final boolean useRobotNature = projectAnnotation.useRobotNature();
final IProject project = ResourcesPlugin.getWorkspace().getRoot().getProject(projectName);
try {
project.create(null);
project.open(null);
createDirectories(project, directoryPaths);
createFiles(project, filePaths);
if (createRedXml) {
configure(project);
}
if (useRobotNature) {
addRobotNature(project);
}
project.refreshLocal(IResource.DEPTH_INFINITE, null);
if (field.getType() == IProject.class) {
field.set(testInstance, project);
} else if (field.getType() == StatefulProject.class) {
final StatefulProject statefulProject = new StatefulProject(project,
projectAnnotation.cleanUpAfterEach());
field.set(testInstance, statefulProject);
final String key = createStoreKey(context);
final Store store = context.getStore(NAMESPACE);
@SuppressWarnings("unchecked")
List<StatefulProject> projects = store.get(key, List.class);
if (projects == null) {
projects = new ArrayList<>();
store.put(key, projects);
}
projects.add(statefulProject);
}
} catch (CoreException | IllegalArgumentException | IllegalAccessException | IOException e) {
if (project.exists()) {
try {
project.delete(true, null);
} catch (final CoreException e1) {
}
}
}
};
}
private static void cleanUpAfterTest(final ExtensionContext context) {
final Store store = context.getStore(NAMESPACE);
final String staticLevelKey = PROJECT_PARAM + ":" + context.getRequiredTestClass().getSimpleName();
final String testLevelKey = PROJECT_PARAM + ":" + context.getRequiredTestClass().getSimpleName() + "#"
+ context.getRequiredTestMethod().getName();
@SuppressWarnings("unchecked")
final List<StatefulProject> staticLevelProject = store.get(staticLevelKey, List.class);
if (staticLevelProject != null) {
staticLevelProject.forEach(StatefulProject::cleanUp);
}
@SuppressWarnings("unchecked")
final List<StatefulProject> testLevelProject = store.get(testLevelKey, List.class);
if (testLevelProject != null) {
staticLevelProject.forEach(StatefulProject::cleanUp);
}
}
private static String createStoreKey(final ExtensionContext context) {
final String className = context.getRequiredTestClass().getSimpleName();
return PROJECT_PARAM + ":"
+ context.getTestMethod().map(method -> className + "#" + method.getName()).orElse(className);
}
private static void createDirectories(final IProject project, final String[] directoryPaths) throws CoreException {
for (final String dirPath : directoryPaths) {
final IFolder directory = getDir(project, dirPath);
directory.create(true, true, null);
}
}
private static void createFiles(final IProject project, final String[] filePaths)
throws IOException, CoreException {
for (final String filePath : filePaths) {
createFile(project, filePath);
}
}
private static IFile createFile(final IFile file, final EndOfLineTypes eolType, final String... lines)
throws IOException, CoreException {
try (InputStream source = new ByteArrayInputStream(
String.join(eolType.getRepresentation().get(0), lines).getBytes(Charsets.UTF_8))) {
return createFile(file, source);
}
}
private static IFile createFile(final IFile file, final InputStream fileSource) throws IOException, CoreException {
if (file.exists()) {
file.setContents(fileSource, true, false, null);
} else {
file.create(fileSource, true, null);
}
file.getProject().refreshLocal(IResource.DEPTH_INFINITE, null);
return file;
}
private static IFolder createDir(final IFolder directory) throws CoreException {
directory.create(true, true, null);
return directory;
}
private static Consumer<Field> deleteProject(final Object instance) {
return field -> {
try {
Object project = field.get(instance);
if (project instanceof StatefulProject) {
project = ((StatefulProject) project).getProject();
}
if (project instanceof IProject && ((IProject) project).exists()) {
((IProject) project).delete(true, null);
}
} catch (final Throwable e) {
} finally {
try {
field.set(instance, null);
} catch (IllegalArgumentException | IllegalAccessException e) {
}
}
};
}
private static void assertSupportedType(final String target, final Class<?> type) {
if (type != IProject.class && type != StatefulProject.class) {
throw new ExtensionConfigurationException("Can only resolve @" + Project.class.getSimpleName() + " "
+ target + " of type " + IProject.class.getName() + " or " + StatefulProject.class.getName()
+ " but was: " + type.getName());
}
}
}
| 5,136 |
489 | import pytest
@pytest.mark.tft
@pytest.mark.integration
@pytest.mark.parametrize(
"region",
[
"br1",
"eun1",
"euw1",
"jp1",
"kr",
"la1",
"la2",
"na",
"na1",
"oc1",
"tr1",
"ru",
"pbe1",
],
)
class TestLeagueApi:
def test_challenger(self, tft_context, region):
actual_response = tft_context.watcher.league.challenger(region)
tft_context.verify_api_call(
region, "/tft/league/v1/challenger", {}, actual_response
)
@pytest.mark.parametrize(
"encrypted_summoner_id",
["50", "424299938281", "9999999999999999999999", "rtbf12345"],
)
def test_by_summoner(self, tft_context, region, encrypted_summoner_id):
actual_response = tft_context.watcher.league.by_summoner(
region, encrypted_summoner_id
)
tft_context.verify_api_call(
region,
f"/tft/league/v1/entries/by-summoner/{encrypted_summoner_id}",
{},
actual_response,
)
@pytest.mark.parametrize("tier", ["IRON", "SILVER", "DIAMOND"])
@pytest.mark.parametrize("division", ["I", "IV"])
@pytest.mark.parametrize("page", [2, 420])
def test_entries(self, tft_context, region, tier, division, page):
actual_response = tft_context.watcher.league.entries(
region, tier, division, page=page
)
tft_context.verify_api_call(
region,
f"/tft/league/v1/entries/{tier}/{division}",
{"page": page},
actual_response,
)
def test_grandmaster(self, tft_context, region):
actual_response = tft_context.watcher.league.grandmaster(region)
tft_context.verify_api_call(
region, "/tft/league/v1/grandmaster", {}, actual_response
)
@pytest.mark.parametrize("league_id", [1, 500, 99999999999999])
def test_by_id(self, tft_context, region, league_id):
actual_response = tft_context.watcher.league.by_id(region, league_id)
tft_context.verify_api_call(
region, f"/tft/league/v1/leagues/{league_id}", {}, actual_response
)
def test_master(self, tft_context, region):
actual_response = tft_context.watcher.league.master(region)
tft_context.verify_api_call(
region, "/tft/league/v1/master", {}, actual_response
)
@pytest.mark.parametrize("queue", ["RANKED_TFT_TURBO"])
def test_rated_ladders(self, tft_context, region, queue):
actual_response = tft_context.watcher.league.rated_ladders(region, queue)
tft_context.verify_api_call(
region, f"/tft/league/v1/rated-ladders/{queue}/top", {}, actual_response
)
| 1,380 |
852 | #include "FWCore/PluginManager/interface/PluginManager.h"
#include "FWCore/PluginManager/interface/standard.h"
#include "FWCore/PluginManager/interface/SharedLibrary.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/ServiceRegistry/interface/ServiceRegistry.h"
//
#include "CondCore/CondDB/interface/ConnectionPool.h"
#include "CondCore/CondDB/interface/PayloadProxy.h"
//
#include "MyTestData.h"
//
#include <fstream>
#include <iomanip>
#include <cstdlib>
#include <iostream>
using namespace cond::persistency;
int run(const std::string& connectionString) {
try {
//*************
std::cout << "> Connecting with db in " << connectionString << std::endl;
ConnectionPool connPool;
connPool.setMessageVerbosity(coral::Debug);
Session session = connPool.createSession(connectionString, true);
session.transaction().start(false);
MyTestData d0(17);
MyTestData d1(999);
std::cout << "> Storing payload ptr=" << &d0 << std::endl;
cond::Hash p0 = session.storePayload(d0, boost::posix_time::microsec_clock::universal_time());
cond::Hash p1 = session.storePayload(d1, boost::posix_time::microsec_clock::universal_time());
IOVEditor editor;
if (!session.existsIov("MyNewIOV")) {
editor = session.createIov<MyTestData>("MyNewIOV", cond::lumiid, cond::SYNCH_HLT);
editor.setDescription("Test with MyTestData class");
editor.insert(1, p0);
editor.insert(cond::time::lumiTime(100, 11), p1);
editor.insert(cond::time::lumiTime(100, 21), p0);
editor.insert(cond::time::lumiTime(100, 31), p1);
editor.insert(cond::time::lumiTime(200, 11), p1);
editor.insert(cond::time::lumiTime(200, 21), p0);
editor.insert(cond::time::lumiTime(200, 31), p1);
editor.insert(cond::time::lumiTime(300, 11), p1);
editor.insert(cond::time::lumiTime(300, 21), p0);
editor.insert(cond::time::lumiTime(300, 31), p1);
editor.insert(cond::time::lumiTime(400, 11), p0);
editor.insert(cond::time::lumiTime(400, 12), p1);
editor.insert(cond::time::lumiTime(400, 13), p0);
std::cout << "> inserted iovs..." << std::endl;
editor.flush();
std::cout << "> iov changes flushed..." << std::endl;
}
session.transaction().commit();
std::cout << "> iov changes committed!..." << std::endl;
::sleep(2);
session.transaction().start();
auto arr0 = session.readIov("MyNewIOV").selectAll();
std::cout << "# Selecting all iovs..." << std::endl;
for (auto iiov : arr0) {
std::cout << "# since=" << iiov.since << " till:" << iiov.till << std::endl;
}
auto arr1 = session.readIov("MyNewIOV").selectRange(cond::time::lumiTime(100, 15), cond::time::lumiTime(300, 15));
std::cout << "# Selecting range (" << cond::time::lumiTime(100, 15) << "," << cond::time::lumiTime(300, 15) << ")"
<< std::endl;
for (auto iiov : arr1) {
std::cout << "# since=" << iiov.since << " till:" << iiov.till << std::endl;
}
auto pxn = session.readIov("MyNewIOV");
std::vector<cond::Time_t> inputTimes{10,
cond::time::lumiTime(100, 15),
cond::time::lumiTime(100, 25),
cond::time::lumiTime(100, 35),
cond::time::lumiTime(200, 15),
cond::time::lumiTime(200, 25),
cond::time::lumiTime(200, 35),
cond::time::lumiTime(300, 15),
cond::time::lumiTime(300, 25),
cond::time::lumiTime(300, 35),
cond::time::lumiTime(400, 11),
cond::time::lumiTime(400, 12),
cond::time::lumiTime(400, 13)};
for (auto t : inputTimes) {
cond::Iov_t iiov = pxn.getInterval(t);
std::cout << "#Target=" << t << " since=" << iiov.since << " till:" << iiov.till << std::endl;
}
std::cout << "#Nqueries:" << pxn.numberOfQueries() << std::endl;
session.transaction().commit();
cond::Iov_t iov;
auto requests = std::make_shared<std::vector<cond::Iov_t>>();
PayloadProxy<MyTestData> ppn(&iov, &session, &requests);
session.transaction().start(true);
auto iovP = session.readIov("MyNewIOV");
for (auto t : inputTimes) {
iov = iovP.getInterval(t);
ppn.initializeForNewIOV();
ppn.make();
std::cout << "PP: target=" << t << " since=" << iov.since << " till:" << iov.till << std::endl;
}
session.transaction().commit();
std::cout << "#PP: nqueries:" << iovP.numberOfQueries() << std::endl;
} catch (const std::exception& e) {
std::cout << "ERROR: " << e.what() << std::endl;
return -1;
} catch (...) {
std::cout << "UNEXPECTED FAILURE." << std::endl;
return -1;
}
std::cout << "## Run successfully completed." << std::endl;
return 0;
}
int main(int argc, char** argv) {
int ret = 0;
edmplugin::PluginManager::Config config;
edmplugin::PluginManager::configure(edmplugin::standard::config());
std::string connectionString0("sqlite_file:cms_conditions_3.db");
ret = run(connectionString0);
return ret;
}
| 2,445 |
1,133 | <filename>components/mroipac/filter/src/rescale_magnitude.c
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <complex.h>
/**
* Take the smoothed phase image from one file and the correctly scaled magnitude image from another and
* combine them in to one file
*/
int
rescale_magnitude(char *int_filename,char *sm_filename,int width,int length)
{
int i,j;
float complex *original,*smooth;
FILE *int_file,*sm_file;
int_file = fopen(int_filename,"rb");
sm_file = fopen(sm_filename,"rb+");
original = (float complex *)malloc(width*sizeof(float complex));
smooth = (float complex *)malloc(width*sizeof(float complex));
printf("Rescaling magnitude\n");
for(i=0;i<length;i++)
{
fread(original,sizeof(float complex),width,int_file);
fread(smooth,sizeof(float complex),width,sm_file);
for(j=0;j<width;j++)
{
float mag = cabs(original[j]);
float phase = carg(smooth[j]);
smooth[j] = mag*(cos(phase) + I*sin(phase));
}
if (i%1000) {fprintf(stderr,"\rline: %5d",i);}
fseek(sm_file,-width*sizeof(float complex),SEEK_CUR); // Back up to the begining of the line
fwrite(smooth,sizeof(float complex),width,sm_file); // Replace the line with the smooth, rescaled value
fflush(sm_file);
}
free(original);
free(smooth);
fclose(int_file);
fclose(sm_file);
return(EXIT_SUCCESS);
}
| 552 |
678 | /**
* This header is generated by class-dump-z 0.2b.
*
* Source: /System/Library/PrivateFrameworks/iLifeSlideshow.framework/iLifeSlideshow
*/
#import <iLifeSlideshow/MCAnimationKeyframe.h>
#import <iLifeSlideshow/MCObject.h>
@class MCAnimationPath, NSString;
@interface MCAnimationKeyframe : MCObject {
double mTimeOffset; // 12 = 0xc
int mTimeOffsetKind; // 20 = 0x14
NSString *mTimeOffsetArgument; // 24 = 0x18
double mPreControl; // 28 = 0x1c
double mPostControl; // 36 = 0x24
MCAnimationPath *mAnimationPath; // 44 = 0x2c
}
@property(assign, nonatomic) double timeOffset; // G=0x19d5; S=0x20f1; @synthesize=mTimeOffset
@property(assign, nonatomic) int timeOffsetKind; // G=0x19c5; S=0x2085; @synthesize=mTimeOffsetKind
@property(assign, nonatomic) double preControl; // G=0x19ad; S=0x1dbd; @synthesize=mPreControl
@property(assign, nonatomic) double postControl; // G=0x1995; S=0x1d3d; @synthesize=mPostControl
@property(assign) MCAnimationPath *animationPath; // G=0x1975; S=0x1985; @synthesize=mAnimationPath
@property(copy) NSString *timeOffsetArgument; // G=0x1f9d; S=0x1e3d;
+ (id)keyPathsForValuesAffectingValueForKey:(id)key; // 0x1bd9
- (id)init; // 0x1b49
- (id)initWithImprint:(id)imprint andMontage:(id)montage; // 0x2331
- (void)demolish; // 0x22d1
- (id)imprint; // 0x2171
// declared property setter: - (void)setTimeOffset:(double)offset; // 0x20f1
// declared property setter: - (void)setTimeOffsetKind:(int)kind; // 0x2085
// declared property getter: - (id)timeOffsetArgument; // 0x1f9d
// declared property setter: - (void)setTimeOffsetArgument:(id)argument; // 0x1e3d
// declared property setter: - (void)setPreControl:(double)control; // 0x1dbd
// declared property setter: - (void)setPostControl:(double)control; // 0x1d3d
- (id)description; // 0x1c89
// declared property getter: - (id)animationPath; // 0x1975
// declared property setter: - (void)setAnimationPath:(id)path; // 0x1985
// declared property getter: - (double)postControl; // 0x1995
// declared property getter: - (double)preControl; // 0x19ad
// declared property getter: - (int)timeOffsetKind; // 0x19c5
// declared property getter: - (double)timeOffset; // 0x19d5
@end
@interface MCAnimationKeyframe (Private)
- (int)relativeTimeCompare:(id)compare; // 0x381d
@end
| 867 |
618 | <reponame>xuejike/hprose-java_rl<filename>src/main/java/hprose/server/HproseServiceEvent.java
/**********************************************************\
| |
| hprose |
| |
| Official WebSite: http://www.hprose.com/ |
| http://www.hprose.org/ |
| |
\**********************************************************/
/**********************************************************\
* *
* HproseServiceEvent.java *
* *
* hprose service event interface for Java. *
* *
* LastModified: Apr 19, 2015 *
* Author: <NAME> <<EMAIL>> *
* *
\**********************************************************/
package hprose.server;
import hprose.common.HproseContext;
public interface HproseServiceEvent {
void onBeforeInvoke(String name, Object[] args, boolean byRef, HproseContext context) throws Throwable;
void onAfterInvoke(String name, Object[] args, boolean byRef, Object result, HproseContext context) throws Throwable;
Throwable onSendError(Throwable e, HproseContext context) throws Throwable;
void onServerError(Throwable e, HproseContext context);
}
| 893 |
14,668 | <reponame>dark-richie/crashpad
// Copyright 2019 The Crashpad Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "util/stream/file_output_stream.h"
#include "base/logging.h"
namespace crashpad {
FileOutputStream::FileOutputStream(FileHandle file_handle)
: writer_(file_handle), flush_needed_(false), flushed_(false) {}
FileOutputStream::~FileOutputStream() {
DCHECK(!flush_needed_);
}
bool FileOutputStream::Write(const uint8_t* data, size_t size) {
DCHECK(!flushed_);
if (!writer_.Write(data, size)) {
LOG(ERROR) << "Write: Failed";
return false;
}
flush_needed_ = true;
return true;
}
bool FileOutputStream::Flush() {
flush_needed_ = false;
flushed_ = true;
return true;
}
} // namespace crashpad
| 396 |
371 | <filename>rls/common/yaml_ops.py
#!/usr/bin/env python3
# encoding: utf-8
import os
from typing import Dict, NoReturn
import yaml
from rls.utils.display import colorize
from rls.utils.logging_utils import get_logger
logger = get_logger(__name__)
def save_config(dicpath: str, config: Dict, filename: str) -> NoReturn:
if not os.path.exists(dicpath):
os.makedirs(dicpath)
with open(os.path.join(dicpath, filename), 'w', encoding='utf-8') as fw:
yaml.dump(config, fw)
logger.info(
colorize(f'save config to {dicpath} successfully', color='green'))
def load_config(filename: str, not_find_error=True) -> Dict:
if os.path.exists(filename):
with open(filename, 'r', encoding='utf-8') as f:
x = yaml.safe_load(f.read())
logger.info(
colorize(f'load config from {filename} successfully', color='green'))
return x or {}
else:
if not_find_error:
raise Exception('cannot find this config.')
else:
logger.info(
colorize(f'load config from {filename} failed, cannot find file.', color='red'))
| 489 |
2,594 | /*
* Copyright (C) 2020 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License
*/
package com.android.tools.build.bundletool.androidtools;
import com.google.auto.value.AutoValue;
import com.google.common.collect.ImmutableList;
import java.time.Duration;
import javax.annotation.concurrent.Immutable;
/** Helper to execute native commands. Interface provided to enable testing. */
public interface CommandExecutor {
void execute(ImmutableList<String> command, CommandOptions options);
ImmutableList<String> executeAndCapture(ImmutableList<String> command, CommandOptions options);
/** Options for the execution of the native command. */
@AutoValue
@Immutable
abstract class CommandOptions {
abstract Duration getTimeout();
public static Builder builder() {
return new AutoValue_CommandExecutor_CommandOptions.Builder();
}
/** Builder for the {@link CommandOptions} class. */
@AutoValue.Builder
public abstract static class Builder {
public abstract Builder setTimeout(Duration timout);
public abstract CommandOptions build();
}
}
}
| 440 |
343 | // Copyright 2014 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Declares a handful of STL compatible allocators that interact with
// SyzyAsan subsystems. This is all with the goal of enhanced redzone
// reporting.
#ifndef SYZYGY_AGENT_ASAN_ALLOCATORS_H_
#define SYZYGY_AGENT_ASAN_ALLOCATORS_H_
#include <memory>
#include "syzygy/agent/asan/heap.h"
#include "syzygy/agent/asan/memory_notifier.h"
namespace agent {
namespace asan {
// An STL-compatible allocator that notifies a MemoryNotifier object of
// memory use.
// @tparam T The type of object that is returned by the allocator.
template <typename T>
class MemoryNotifierAllocator : public std::allocator<T> {
public:
typedef size_t size_type;
typedef T* pointer;
typedef const T* const_pointer;
// Functor that converts this allocator to an equivalent one for another
// type.
// @tparam T2 The type being casted to.
template <typename T2>
struct rebind {
typedef MemoryNotifierAllocator<T2> other;
};
// Constructor with a notifier object.
// @param memory_notifier A pointer to the memory notifier object
// that this allocate will notify.
explicit MemoryNotifierAllocator(
MemoryNotifierInterface* memory_notifier);
// Copy constructor. Necessary for STL compatibility.
MemoryNotifierAllocator(const MemoryNotifierAllocator& other);
// Copy constructor from another type. Necessary for STL compatibility.
// This simply copies the memory notifier API.
// @tparam T2 The type of the other allocator.
// @param other The allocator being copied.
template <typename T2>
MemoryNotifierAllocator(const MemoryNotifierAllocator<T2>& other);
// Allocates @p count objects of type T.
// @param count The number of objects to allocate.
// @param hint A hint as to where the objects should be allocated.
// @returns a pointer to the allocated objects, NULL if the allocation
// failed.
pointer allocate(size_type count, const void* hint = NULL);
// Deallocates a group of @p n objects.
// @param objects A pointer to the allocated objects. This must have
// previously been returned a call to 'allocate'.
// @param count The number of objects in the allocation.
void deallocate(pointer objects, size_type count);
// @returns the MemoryNotifier object used by this allocator.
MemoryNotifierInterface* memory_notifier() const;
protected:
MemoryNotifierInterface* memory_notifier_;
};
// An STL-compatible allocator that uses a HeapInterface object under the
// hood.
// @tparam T The type of object that is returned by the allocator.
template <typename T>
class HeapAllocator : public std::allocator<T> {
public:
typedef size_t size_type;
typedef T* pointer;
typedef const T* const_pointer;
// Functor that converts this allocator to an equivalent one for another
// type.
// @tparam T2 The type being casted to.
template <typename T2>
struct rebind {
typedef HeapAllocator<T2> other;
};
// Constructor with a notifier object.
// @param heap A pointer to the heap object that will be used to make the
// allocations.
explicit HeapAllocator(HeapInterface* heap);
// Copy constructor. Necessary for STL compatibility.
HeapAllocator(const HeapAllocator& other);
// Copy constructor from another type. Necessary for STL compatibility.
// This simply copies the memory notifier API.
// @tparam T2 The type of the other allocator.
// @param other The allocator being copied.
template <typename T2>
HeapAllocator(const HeapAllocator<T2>& other);
// Allocates @p count objects of type T.
// @param count The number of objects to allocate.
// @param hint A hint as to where the objects should be allocated.
// @returns a pointer to the allocated objects, NULL if the allocation
// failed.
pointer allocate(size_type count, const void* hint = NULL);
// Deallocates a group of @p n objects.
// @param objects A pointer to the allocated objects. This must have
// previously been returned a call to 'allocate'.
// @param count The number of objects in the allocation.
void deallocate(pointer objects, size_type count);
// @returns the Heap object used by this allocator.
HeapInterface* heap() const;
protected:
HeapInterface* heap_;
};
} // namespace asan
} // namespace agent
#include "syzygy/agent/asan/allocators_impl.h"
#endif // SYZYGY_AGENT_ASAN_ALLOCATORS_H_
| 1,471 |
5,169 | {
"name": "SomePod",
"version": "0.1.1",
"summary": "Here is the description which describes this produrc as it is",
"description": "A short description of SomePod. So you can use it for some of your swift application to make it more usefull",
"homepage": "https://bitbucket.org/victorbarskov/somepod",
"license": {
"type": "MIT",
"file": "LICENSE"
},
"authors": {
"<NAME>": "<EMAIL>"
},
"source": {
"git": "https://bitbucket.org/victorbarskov/somepod",
"tag": "0.1.1"
},
"platforms": {
"ios": "8.0"
},
"source_files": "SomePod/Classes/**/*"
}
| 236 |
4,224 | /************************************************************************************
* board.h
*
* Copyright (C) 2016-2018 <NAME>. All rights reserved.
* Authors: <NAME> <<EMAIL>>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* 3. Neither the name NuttX nor the names of its contributors may be
* used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
* OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
************************************************************************************/
#pragma once
/************************************************************************************
* Included Files
************************************************************************************/
#include "board_dma_map.h"
#include <nuttx/config.h>
#ifndef __ASSEMBLY__
# include <stdint.h>
#endif
#include "stm32_rcc.h"
/************************************************************************************
* Pre-processor Definitions
************************************************************************************/
/* Clocking *************************************************************************/
/* The KakuteF7 board provides the following clock sources:
*
* 8 MHz crystal for HSE
*
* So we have these clock source available within the STM32
*
* HSI: 16 MHz RC factory-trimmed
* HSE: 8 MHz crystal for HSE
*/
#define STM32_BOARD_XTAL 8000000ul
#define STM32_HSI_FREQUENCY 16000000ul
#define STM32_LSI_FREQUENCY 32000
#define STM32_HSE_FREQUENCY STM32_BOARD_XTAL
#define STM32_LSE_FREQUENCY 0
/* Main PLL Configuration.
*
* PLL source is HSE = 8,000,000
*
* PLL_VCO = (STM32_HSE_FREQUENCY / PLLM) * PLLN
* Subject to:
*
* 2 <= PLLM <= 63
* 192 <= PLLN <= 432
* 192 MHz <= PLL_VCO <= 432MHz
*
* SYSCLK = PLL_VCO / PLLP
* Subject to
*
* PLLP = {2, 4, 6, 8}
* SYSCLK <= 216 MHz
*
* USB OTG FS, SDMMC and RNG Clock = PLL_VCO / PLLQ
* Subject to
* The USB OTG FS requires a 48 MHz clock to work correctly. The SDMMC
* and the random number generator need a frequency lower than or equal
* to 48 MHz to work correctly.
*
* 2 <= PLLQ <= 15
*/
/* Highest SYSCLK with USB OTG FS clock = 48 MHz
*
* PLL_VCO = (8,000,000 / 8) * 432 = 432 MHz
* SYSCLK = 432 MHz / 2 = 216 MHz
* USB OTG FS, SDMMC and RNG Clock = 432 MHz / 9 = 48 MHz
*/
#define STM32_PLLCFG_PLLM RCC_PLLCFG_PLLM(8)
#define STM32_PLLCFG_PLLN RCC_PLLCFG_PLLN(432)
#define STM32_PLLCFG_PLLP RCC_PLLCFG_PLLP_2
#define STM32_PLLCFG_PLLQ RCC_PLLCFG_PLLQ(9)
#define STM32_VCO_FREQUENCY ((STM32_HSE_FREQUENCY / 8) * 432)
#define STM32_SYSCLK_FREQUENCY (STM32_VCO_FREQUENCY / 2)
#define STM32_OTGFS_FREQUENCY (STM32_VCO_FREQUENCY / 9)
/* Configure factors for PLLSAI clock */
#define CONFIG_STM32F7_PLLSAI 1
#define STM32_RCC_PLLSAICFGR_PLLSAIN RCC_PLLSAICFGR_PLLSAIN(384)
#define STM32_RCC_PLLSAICFGR_PLLSAIP RCC_PLLSAICFGR_PLLSAIP(8)
#define STM32_RCC_PLLSAICFGR_PLLSAIQ RCC_PLLSAICFGR_PLLSAIQ(4)
#define STM32_RCC_PLLSAICFGR_PLLSAIR RCC_PLLSAICFGR_PLLSAIR(2)
/* Configure Dedicated Clock Configuration Register */
#define STM32_RCC_DCKCFGR1_PLLI2SDIVQ RCC_DCKCFGR1_PLLI2SDIVQ(1)
#define STM32_RCC_DCKCFGR1_PLLSAIDIVQ RCC_DCKCFGR1_PLLSAIDIVQ(1)
#define STM32_RCC_DCKCFGR1_PLLSAIDIVR RCC_DCKCFGR1_PLLSAIDIVR(0)
#define STM32_RCC_DCKCFGR1_SAI1SRC RCC_DCKCFGR1_SAI1SEL(0)
#define STM32_RCC_DCKCFGR1_SAI2SRC RCC_DCKCFGR1_SAI2SEL(0)
#define STM32_RCC_DCKCFGR1_TIMPRESRC 0
#define STM32_RCC_DCKCFGR1_DFSDM1SRC 0
#define STM32_RCC_DCKCFGR1_ADFSDM1SRC 0
/* Configure factors for PLLI2S clock */
#define CONFIG_STM32F7_PLLI2S 1
#define STM32_RCC_PLLI2SCFGR_PLLI2SN RCC_PLLI2SCFGR_PLLI2SN(384)
#define STM32_RCC_PLLI2SCFGR_PLLI2SP RCC_PLLI2SCFGR_PLLI2SP(2)
#define STM32_RCC_PLLI2SCFGR_PLLI2SQ RCC_PLLI2SCFGR_PLLI2SQ(2)
#define STM32_RCC_PLLI2SCFGR_PLLI2SR RCC_PLLI2SCFGR_PLLI2SR(2)
/* Configure Dedicated Clock Configuration Register 2 */
#define STM32_RCC_DCKCFGR2_USART1SRC RCC_DCKCFGR2_USART1SEL_APB
#define STM32_RCC_DCKCFGR2_USART2SRC RCC_DCKCFGR2_USART2SEL_APB
#define STM32_RCC_DCKCFGR2_UART4SRC RCC_DCKCFGR2_UART4SEL_APB
#define STM32_RCC_DCKCFGR2_UART5SRC RCC_DCKCFGR2_UART5SEL_APB
#define STM32_RCC_DCKCFGR2_USART6SRC RCC_DCKCFGR2_USART6SEL_APB
#define STM32_RCC_DCKCFGR2_UART7SRC RCC_DCKCFGR2_UART7SEL_APB
#define STM32_RCC_DCKCFGR2_UART8SRC RCC_DCKCFGR2_UART8SEL_APB
#define STM32_RCC_DCKCFGR2_I2C1SRC RCC_DCKCFGR2_I2C1SEL_HSI
#define STM32_RCC_DCKCFGR2_I2C2SRC RCC_DCKCFGR2_I2C2SEL_HSI
#define STM32_RCC_DCKCFGR2_I2C3SRC RCC_DCKCFGR2_I2C3SEL_HSI
#define STM32_RCC_DCKCFGR2_I2C4SRC RCC_DCKCFGR2_I2C4SEL_HSI
#define STM32_RCC_DCKCFGR2_LPTIM1SRC RCC_DCKCFGR2_LPTIM1SEL_APB
#define STM32_RCC_DCKCFGR2_CECSRC RCC_DCKCFGR2_CECSEL_HSI
#define STM32_RCC_DCKCFGR2_CK48MSRC RCC_DCKCFGR2_CK48MSEL_PLL
#define STM32_RCC_DCKCFGR2_SDMMCSRC RCC_DCKCFGR2_SDMMCSEL_48MHZ
#define STM32_RCC_DCKCFGR2_SDMMC2SRC RCC_DCKCFGR2_SDMMC2SEL_48MHZ
#define STM32_RCC_DCKCFGR2_DSISRC RCC_DCKCFGR2_DSISEL_PHY
/* Several prescalers allow the configuration of the two AHB buses, the
* high-speed APB (APB2) and the low-speed APB (APB1) domains. The maximum
* frequency of the two AHB buses is 216 MHz while the maximum frequency of
* the high-speed APB domains is 108 MHz. The maximum allowed frequency of
* the low-speed APB domain is 54 MHz.
*/
/* AHB clock (HCLK) is SYSCLK (216 MHz) */
#define STM32_RCC_CFGR_HPRE RCC_CFGR_HPRE_SYSCLK /* HCLK = SYSCLK / 1 */
#define STM32_HCLK_FREQUENCY STM32_SYSCLK_FREQUENCY
#define STM32_BOARD_HCLK STM32_HCLK_FREQUENCY /* same as above, to satisfy compiler */
/* APB1 clock (PCLK1) is HCLK/4 (54 MHz) */
#define STM32_RCC_CFGR_PPRE1 RCC_CFGR_PPRE1_HCLKd4 /* PCLK1 = HCLK / 4 */
#define STM32_PCLK1_FREQUENCY (STM32_HCLK_FREQUENCY/4)
/* Timers driven from APB1 will be twice PCLK1 */
#define STM32_APB1_TIM2_CLKIN (2*STM32_PCLK1_FREQUENCY)
#define STM32_APB1_TIM3_CLKIN (2*STM32_PCLK1_FREQUENCY)
#define STM32_APB1_TIM4_CLKIN (2*STM32_PCLK1_FREQUENCY)
#define STM32_APB1_TIM5_CLKIN (2*STM32_PCLK1_FREQUENCY)
#define STM32_APB1_TIM6_CLKIN (2*STM32_PCLK1_FREQUENCY)
#define STM32_APB1_TIM7_CLKIN (2*STM32_PCLK1_FREQUENCY)
#define STM32_APB1_TIM12_CLKIN (2*STM32_PCLK1_FREQUENCY)
#define STM32_APB1_TIM13_CLKIN (2*STM32_PCLK1_FREQUENCY)
#define STM32_APB1_TIM14_CLKIN (2*STM32_PCLK1_FREQUENCY)
/* APB2 clock (PCLK2) is HCLK/2 (108MHz) */
#define STM32_RCC_CFGR_PPRE2 RCC_CFGR_PPRE2_HCLKd2 /* PCLK2 = HCLK / 2 */
#define STM32_PCLK2_FREQUENCY (STM32_HCLK_FREQUENCY/2)
/* Timers driven from APB2 will be twice PCLK2 */
#define STM32_APB2_TIM1_CLKIN (2*STM32_PCLK2_FREQUENCY)
#define STM32_APB2_TIM8_CLKIN (2*STM32_PCLK2_FREQUENCY)
#define STM32_APB2_TIM9_CLKIN (2*STM32_PCLK2_FREQUENCY)
#define STM32_APB2_TIM10_CLKIN (2*STM32_PCLK2_FREQUENCY)
#define STM32_APB2_TIM11_CLKIN (2*STM32_PCLK2_FREQUENCY)
/* FLASH wait states
*
* --------- ---------- -----------
* VDD MAX SYSCLK WAIT STATES
* --------- ---------- -----------
* 1.7-2.1 V 180 MHz 8
* 2.1-2.4 V 216 MHz 9
* 2.4-2.7 V 216 MHz 8
* 2.7-3.6 V 216 MHz 7
* --------- ---------- -----------
*/
#define BOARD_FLASH_WAITSTATES 7
/* LED definitions ******************************************************************/
/* LED index values for use with board_userled() */
#define BOARD_LED1 0
#define BOARD_NLEDS 1
#define BOARD_LED_BLUE BOARD_LED1
/* LED bits for use with board_userled_all() */
#define BOARD_LED1_BIT (1 << BOARD_LED1)
/* If CONFIG_ARCH_LEDS is defined, the usage by the board port is defined in
* include/board.h and src/stm32_leds.c. The LEDs are used to encode OS-related
* events as follows:
*
*
* SYMBOL Meaning LED state
* Red Green Blue
* ---------------------- -------------------------- ------ ------ ----*/
#define LED_STARTED 0 /* NuttX has been started OFF OFF OFF */
#define LED_HEAPALLOCATE 1 /* Heap has been allocated OFF OFF ON */
#define LED_IRQSENABLED 2 /* Interrupts enabled OFF ON OFF */
#define LED_STACKCREATED 3 /* Idle stack created OFF ON ON */
#define LED_INIRQ 4 /* In an interrupt N/C N/C GLOW */
#define LED_SIGNAL 5 /* In a signal handler N/C GLOW N/C */
#define LED_ASSERTION 6 /* An assertion failed GLOW N/C GLOW */
#define LED_PANIC 7 /* The system has crashed Blink OFF N/C */
#define LED_IDLE 8 /* MCU is is sleep mode ON OFF OFF */
/* Alternate function pin selections (see stm32f74xx75xx_pinmap.h) ******************************/
#define GPIO_USART1_RX GPIO_USART1_RX_1 /* PA10 */
#define GPIO_USART1_TX GPIO_USART1_TX_1 /* PA9 */
#define GPIO_USART2_RX GPIO_USART2_RX_2 /* PD6 */
#define GPIO_USART2_TX GPIO_USART2_TX_2 /* PD5 */
#define GPIO_USART3_RX GPIO_USART3_RX_1 /* PB11 */
#define GPIO_USART3_TX GPIO_USART3_TX_1 /* PB10 */
#define GPIO_UART4_RX GPIO_UART4_RX_1 /* PA1 */
#define GPIO_UART4_TX GPIO_UART4_TX_1 /* PA0 */
#define GPIO_USART6_RX GPIO_USART6_RX_1 /* PC7 */
#define GPIO_USART6_TX GPIO_USART6_TX_1 /* PC6 */
#define GPIO_UART7_RX GPIO_UART7_RX_1 /* PE7 */
#define GPIO_UART7_TX GPIO_UART7_TX_1 /* PE8 */
/* SPI
* SPI1 SD Card
* SPI2 is OSD AT7456E
* SPI4 is IMU
*/
#define GPIO_SPI1_MISO GPIO_SPI1_MISO_1 /* PA6 */
#define GPIO_SPI1_MOSI GPIO_SPI1_MOSI_1 /* PA7 */
#define GPIO_SPI1_SCK GPIO_SPI1_SCK_1 /* PA5 */
#define GPIO_SPI2_MISO GPIO_SPI2_MISO_1 /* PB14 */
#define GPIO_SPI2_MOSI GPIO_SPI2_MOSI_1 /* PB15 */
#define GPIO_SPI2_SCK GPIO_SPI2_SCK_3 /* PB13 */
#define GPIO_SPI4_MISO GPIO_SPI4_MISO_1 /* PE5 */
#define GPIO_SPI4_MOSI GPIO_SPI4_MOSI_1 /* PE6 */
#define GPIO_SPI4_SCK GPIO_SPI4_SCK_1 /* PE2 */
/* I2C
*/
#define GPIO_I2C1_SCL GPIO_I2C1_SCL_1 /* PB6 */
#define GPIO_I2C1_SDA GPIO_I2C1_SDA_1 /* PB7 */
#define GPIO_I2C1_SCL_GPIO (GPIO_OUTPUT | GPIO_OPENDRAIN |GPIO_SPEED_50MHz | GPIO_OUTPUT_SET | GPIO_PORTB | GPIO_PIN6)
#define GPIO_I2C1_SDA_GPIO (GPIO_OUTPUT | GPIO_OPENDRAIN |GPIO_SPEED_50MHz | GPIO_OUTPUT_SET | GPIO_PORTB | GPIO_PIN7)
/* USB
*
* OTG_FS_DM PA11
* OTG_FS_DP PA12
* VBUS PA8
*/
| 5,577 |
461 | #include <_ansi.h>
#include <ctype.h>
#undef isgraph_l
int
isgraph_l (int c, struct __locale_t *locale)
{
return __locale_ctype_ptr_l (locale)[c+1] & (_P|_U|_L|_N);
}
#undef isprint_l
int
isprint_l (int c, struct __locale_t *locale)
{
return __locale_ctype_ptr_l (locale)[c+1] & (_P|_U|_L|_N|_B);
}
| 160 |
316 | package com.rubengees.introduction.interfaces;
import android.support.annotation.NonNull;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import java.io.Serializable;
/**
* The interface to define a custom View.
* Note: You cannot use a anonymous class to implement this. See the CustomViewBuilderImpl in
* the sample.
*/
public interface CustomViewBuilder extends Serializable {
/**
* Returns the desired view for this slide.
*
* @param inflater The inflater.
* @param parent The parent of the new view. Only for inflation purposes. Do not add your
* View to this.
* @return The new View.
*/
@NonNull
View buildView(@NonNull LayoutInflater inflater, @NonNull ViewGroup parent);
}
| 260 |
456 | <reponame>StyXman/kgt<filename>src/svg/output.c
/*
* Copyright 2014-2019 <NAME>
*
* See LICENCE for the full copyright terms.
*/
/*
* Railroad Diagram SVG Output
*
* Output a SVG diagram of the abstract representation of railroads.
* The subset of SVG here is intended to suit RFC 7996.
*/
#define _BSD_SOURCE
#define _DEFAULT_SOURCE
#include <assert.h>
#include <limits.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <math.h>
#include "../txt.h"
#include "../ast.h"
#include "../xalloc.h"
#include "../rrd/rrd.h"
#include "../rrd/pretty.h"
#include "../rrd/node.h"
#include "../rrd/rrd.h"
#include "../rrd/list.h"
#include "../rrd/tnode.h"
#include "io.h"
#include "path.h"
extern const char *css_file;
WARN_UNUSED_RESULT
int
cat(const char *in, const char *indent);
struct render_context {
unsigned x, y;
struct path *paths;
const struct ast_rule *grammar;
};
static void node_walk_render(const struct tnode *n,
struct render_context *ctx, const char *base);
static int
svg_escputc(FILE *f, char c)
{
const char *name;
assert(f != NULL);
switch (c) {
case '&': return fputs("&", f);
case '<': return fputs("<", f);
case '>': return fputs(">", f);
case '\a': name = "BEL"; break;
case '\b': name = "BS"; break;
case '\f': name = "FF"; break;
case '\n': name = "LF"; break;
case '\r': name = "CR"; break;
case '\t': name = "TAB"; break;
case '\v': name = "VT"; break;
default:
if (!isprint((unsigned char) c)) {
return fprintf(f, "〈<tspan class='hex'>%02X</tspan>〉", (unsigned char) c);
}
return fprintf(f, "%c", c);
}
return fprintf(f, "〈<tspan class='esc'>%s</tspan>〉", name);
}
static void
svg_text(struct render_context *ctx, unsigned w, const struct txt *t, const char *class)
{
unsigned mid;
size_t i;
assert(ctx != NULL);
assert(t != NULL);
assert(t->p != NULL);
mid = w / 2;
printf(" <text x='%u' y='%u' text-anchor='middle'",
ctx->x + mid, ctx->y + 5);
if (class != NULL) {
printf(" class='%s'", class);
}
printf(">");
for (i = 0; i < t->n; i++) {
svg_escputc(stdout, t->p[i]);
}
printf("</text>\n");
}
static void
svg_string(struct render_context *ctx, unsigned w, const char *s, const char *class)
{
struct txt t;
assert(ctx != NULL);
assert(s != NULL);
t.p = s;
t.n = strlen(s);
svg_text(ctx, w, &t, class);
}
static void
svg_rect(struct render_context *ctx, unsigned w, unsigned r,
const char *class)
{
printf(" <rect x='%u' y='%u' height='%u' width='%u' rx='%u' ry='%u'",
ctx->x, ctx->y - 10,
20, w,
r, r);
if (class != NULL) {
printf(" class='%s'", class);
}
printf("/>\n");
}
static void
svg_textbox(struct render_context *ctx, const struct txt *t, unsigned w, unsigned r,
const char *class)
{
assert(t != NULL);
assert(t->p != NULL);
svg_rect(ctx, w, r, class);
svg_text(ctx, w, t, class);
ctx->x += w;
}
static void
svg_prose(struct render_context *ctx, const char *s, unsigned w)
{
assert(ctx != NULL);
assert(s != NULL);
svg_string(ctx, w, s, "prose");
ctx->x += w;
}
static void
svg_ellipsis(struct render_context *ctx, unsigned w, unsigned h)
{
ctx->x += 10;
ctx->y -= 10;
printf(" <line x1='%u' y1='%u' x2='%u' y2='%u' class='ellipsis'/>",
ctx->x - 5, ctx->y + 5,
ctx->x + w - 5, ctx->y + h + 5);
ctx->x += w;
ctx->y += 10;
}
static void
svg_arrow(struct render_context *ctx, unsigned x, unsigned y, int rtl)
{
unsigned h = 6;
assert(ctx != NULL);
/* XXX: should be markers, but aren't for RFC 7996 */
/* 2 for optical correction */
printf(" <path d='M%d %u l%d %u v%d z' class='arrow'/>\n",
(int) x + (rtl ? -2 : 2), y, rtl ? 4 : -4, h / 2, -h);
}
static void
centre(unsigned *lhs, unsigned *rhs, unsigned space, unsigned w)
{
assert(lhs != NULL);
assert(rhs != NULL);
assert(space >= w);
*lhs = (space - w) / 2;
*rhs = (space - w) - *lhs;
}
static void
justify(struct render_context *ctx, const struct tnode *n, unsigned space,
const char *base)
{
unsigned lhs, rhs;
centre(&lhs, &rhs, space, n->w * 10);
if (n->type != TNODE_ELLIPSIS) {
svg_path_h(&ctx->paths, ctx->x, ctx->y, lhs);
}
if (debug) {
svg_rect(ctx, lhs, 5, "debug justify");
}
ctx->x += lhs;
node_walk_render(n, ctx, base);
if (n->type != TNODE_ELLIPSIS) {
svg_path_h(&ctx->paths, ctx->x, ctx->y, rhs);
}
if (debug) {
svg_rect(ctx, rhs, 5, "debug justify");
}
ctx->x += rhs;
}
static void
bars(struct render_context *ctx, unsigned n, unsigned w)
{
svg_path_v(&ctx->paths, ctx->x, ctx->y, n);
ctx->x += w;
svg_path_v(&ctx->paths, ctx->x, ctx->y, n);
}
enum tile {
TILE_BL = 1 << 0, /* `- bottom left */
TILE_TL = 1 << 1, /* .- top left */
TILE_BR = 1 << 2, /* -' bottom right */
TILE_TR = 1 << 3, /* -. top right */
TILE_LINE = 1 << 4, /* horizontal line */
TILE_BL_N1 = 1 << 5,
TILE_BR_N1 = 1 << 6,
TILE_TR_N1 = 1 << 7
};
static void
render_tile(struct render_context *ctx, enum tile tile)
{
int y, dy;
int rx, ry;
switch (tile) {
case TILE_BL_N1: tile = TILE_BL; dy = -10; break;
case TILE_BR_N1: tile = TILE_BR; dy = -10; break;
case TILE_TR_N1: tile = TILE_TR; dy = -10; break;
case TILE_TL:
dy = 10;
break;
case TILE_BR:
case TILE_TR:
case TILE_LINE:
dy = 0;
break;
case TILE_BL:
default:
assert(!"unreached");
break;
}
switch (tile) {
case TILE_BL: y = 10; rx = 0; ry = y; break;
case TILE_TL: y = -10; rx = 0; ry = y; break;
case TILE_BR: y = -10; rx = 10; ry = 0; break;
case TILE_TR: y = 10; rx = 10; ry = 0; break;
case TILE_LINE:
svg_path_h(&ctx->paths, ctx->x, ctx->y + dy, 10);
ctx->x += 10;
return;
default:
assert(!"unreached");
}
if (debug) {
char s[16];
struct txt t;
snprintf(s, sizeof s, "%d", tile);
t.p = s;
t.n = strlen(s);
svg_textbox(ctx, &t, 10, 0, "debug tile");
ctx->x -= 10;
}
svg_path_q(&ctx->paths, ctx->x, ctx->y + dy, rx, ry, 10, y);
ctx->x += 10;
}
static void
render_tile_bm(struct render_context *ctx, unsigned u)
{
unsigned v;
if (u == 0) {
/* nothing to draw */
ctx->x += 10;
return;
}
for (v = u; v != 0; v &= v - 1) {
render_tile(ctx, v & -v);
if ((v & (v - 1)) != 0) {
ctx->x -= 10;
}
}
}
static void
render_tline_inner(struct render_context *ctx, enum tline tline, int rhs)
{
unsigned u[2];
assert(ctx != NULL);
switch (tline) {
case TLINE_A:
case TLINE_a: u[0] = TILE_LINE; u[1] = TILE_LINE; break;
case TLINE_B: u[0] = TILE_TL; u[1] = TILE_TR; break;
case TLINE_C:
case TLINE_c: u[0] = TILE_LINE; u[1] = TILE_LINE; break;
case TLINE_D:
case TLINE_d: u[0] = TILE_LINE; u[1] = TILE_LINE; break;
case TLINE_E: u[0] = TILE_BL_N1; u[1] = TILE_BR; break;
case TLINE_F: u[0] = 0; u[1] = 0; break;
case TLINE_G:
case TLINE_g: u[0] = TILE_BL_N1; u[1] = TILE_BR; break;
case TLINE_H:
case TLINE_h: u[0] = TILE_LINE | TILE_TL; u[1] = TILE_LINE | TILE_TR; break;
case TLINE_I:
case TLINE_i: u[0] = TILE_LINE | TILE_BL_N1; u[1] = TILE_LINE | TILE_BR; break;
case TLINE_J: u[0] = TILE_LINE; u[1] = TILE_LINE; break;
default: u[0] = 0; u[1] = 0; break;
}
render_tile_bm(ctx, u[rhs]);
}
static void
render_tline_outer(struct render_context *ctx, enum tline tline, int rhs)
{
unsigned u[2];
assert(ctx != NULL);
switch (tline) {
case TLINE_A:
case TLINE_a: u[0] = TILE_LINE | TILE_BR; u[1] = TILE_LINE | TILE_BL_N1; break;
case TLINE_C:
case TLINE_c: u[0] = TILE_LINE | TILE_TR; u[1] = TILE_LINE | TILE_TL; break;
case TLINE_D:
case TLINE_d: u[0] = TILE_LINE | TILE_BR | TILE_TR; u[1] = TILE_LINE | TILE_BL_N1 | TILE_TL; break;
case TLINE_H:
case TLINE_h: u[0] = TILE_LINE; u[1] = TILE_LINE; break;
case TLINE_I:
case TLINE_i: u[0] = TILE_LINE; u[1] = TILE_LINE; break;
case TLINE_J: u[0] = TILE_LINE; u[1] = TILE_LINE; break;
default: u[0] = 0; u[1] = 0; break;
}
render_tile_bm(ctx, u[rhs]);
}
static void
render_vlist(const struct tnode *n,
struct render_context *ctx, const char *base)
{
unsigned x, o, y;
size_t j;
assert(n != NULL);
assert(n->type == TNODE_VLIST);
assert(ctx != NULL);
o = ctx->y;
assert(n->u.vlist.o <= 1); /* currently only implemented for one node above the line */
if (n->u.vlist.o == 1) {
ctx->y -= n->a * 10;
}
x = ctx->x;
y = ctx->y;
/*
* A vlist of 0 items is a special case, meaning to draw
* a horizontal line only.
*/
if (n->u.vlist.n == 0 && n->w > 0) {
svg_path_h(&ctx->paths, ctx->x, ctx->y, n->w * 10);
} else for (j = 0; j < n->u.vlist.n; j++) {
ctx->x = x;
render_tline_outer(ctx, n->u.vlist.b[j], 0);
render_tline_inner(ctx, n->u.vlist.b[j], 0);
justify(ctx, n->u.vlist.a[j], n->w * 10 - 40, base);
render_tline_inner(ctx, n->u.vlist.b[j], 1);
render_tline_outer(ctx, n->u.vlist.b[j], 1);
ctx->y += 10;
if (j + 1 < n->u.vlist.n) {
ctx->y += (n->u.vlist.a[j]->d + n->u.vlist.a[j + 1]->a) * 10;
}
}
/* bars above the line */
if (n->u.vlist.o > 0) {
unsigned h;
h = 0;
for (j = 0; j < n->u.vlist.o; j++) {
if (j + 1 < n->u.vlist.n) {
h += (n->u.vlist.a[j]->d + n->u.vlist.a[j + 1]->a + 1) * 10;
}
}
ctx->x = x + 10;
ctx->y = y + 10;
h -= 20; /* for the tline corner pieces */
bars(ctx, h, n->w * 10 - 20);
}
/* bars below the line */
if (n->u.vlist.n > n->u.vlist.o + 1) {
unsigned h;
h = 0;
for (j = n->u.vlist.o; j < n->u.vlist.n; j++) {
if (j + 1 < n->u.vlist.n) {
h += (n->u.vlist.a[j]->d + n->u.vlist.a[j + 1]->a + 1) * 10;
}
}
ctx->x = x + 10;
ctx->y = o + 10;
h -= 20; /* for the tline corner pieces */
bars(ctx, h, n->w * 10 - 20);
}
ctx->x = x + n->w * 10;
ctx->y = o;
}
static void
render_hlist(const struct tnode *n,
struct render_context *ctx, const char *base)
{
size_t i;
assert(n != NULL);
assert(n->type == TNODE_HLIST);
assert(ctx != NULL);
for (i = 0; i < n->u.hlist.n; i++) {
node_walk_render(n->u.hlist.a[i], ctx, base);
if (i + 1 < n->u.hlist.n) {
svg_path_h(&ctx->paths, ctx->x, ctx->y, 20);
ctx->x += 20;
}
}
}
static void
node_walk_render(const struct tnode *n,
struct render_context *ctx, const char *base)
{
assert(ctx != NULL);
if (debug) {
svg_rect(ctx, n->w * 10, 2, "debug node");
}
switch (n->type) {
case TNODE_RTL_ARROW:
svg_path_h(&ctx->paths, ctx->x, ctx->y, 10);
svg_arrow(ctx, ctx->x + n->w * 5, ctx->y, 1);
ctx->x += n->w * 10;
break;
case TNODE_LTR_ARROW:
svg_path_h(&ctx->paths, ctx->x, ctx->y, 10);
svg_arrow(ctx, ctx->x + n->w * 5, ctx->y, 0);
ctx->x += n->w * 10;
break;
case TNODE_ELLIPSIS:
svg_ellipsis(ctx, 0, (n->a + n->d + 1) * 10);
break;
case TNODE_CI_LITERAL:
svg_textbox(ctx, &n->u.literal, n->w * 10, 8, "literal");
printf(" <text x='%u' y='%u' text-anchor='left' class='ci'>%s</text>\n",
ctx->x - 20 + 5, ctx->y + 5, "⧸i");
break;
case TNODE_CS_LITERAL:
svg_textbox(ctx, &n->u.literal, n->w * 10, 8, "literal");
break;
case TNODE_PROSE:
svg_prose(ctx, n->u.prose, n->w * 10);
break;
case TNODE_COMMENT: {
unsigned offset = 5;
ctx->y += n->d * 10;
/* TODO: - 5 again for loops with a backwards skip (because they're short) */
if (n->u.comment.tnode->type == TNODE_VLIST
&& n->u.comment.tnode->u.vlist.o == 0
&& n->u.comment.tnode->u.vlist.n == 2
&& ((n->u.comment.tnode->u.vlist.a[1]->type == TNODE_VLIST && n->u.comment.tnode->u.vlist.a[1]->u.vlist.n == 0) || n->u.comment.tnode->u.vlist.a[1]->type == TNODE_RTL_ARROW || n->u.comment.tnode->u.vlist.a[1]->type == TNODE_LTR_ARROW)) {
offset += 10;
}
ctx->y -= offset; /* off-grid */
svg_string(ctx, n->w * 10, n->u.comment.s, "comment");
ctx->y += offset;
ctx->y -= n->d * 10;
justify(ctx, n->u.comment.tnode, n->w * 10, base);
break;
}
case TNODE_RULE: {
/*
* We don't make something a link if it doesn't have a destination in
* the same document. That is, rules need not be defined in the same
* grammar.
*/
int dest_exists = !!ast_find_rule(ctx->grammar, n->u.name);
if (base != NULL && dest_exists) {
printf(" <a href='%s#%s'>\n", base, n->u.name); /* XXX: escape */
}
{
struct txt t;
t.p = n->u.name;
t.n = strlen(n->u.name);
svg_textbox(ctx, &t, n->w * 10, 0, "rule");
}
if (base != NULL && dest_exists) {
printf(" </a>\n");
}
break;
}
case TNODE_VLIST:
/* TODO: .n == 0 skips under loop alts are too close to the line */
render_vlist(n, ctx, base);
break;
case TNODE_HLIST:
render_hlist(n, ctx, base);
break;
}
}
void
svg_render_station(unsigned x, unsigned y)
{
unsigned gap = 4;
unsigned h = 12;
/* .5 to overlap the line width */
printf(" <path d='M%u.5 %u v%u m %u 0 v%d' class='station'/>\n",
x, y - h / 2, h, gap, -h);
}
void
svg_render_rule(const struct tnode *node, const char *base,
const struct ast_rule *grammar)
{
struct render_context ctx;
unsigned w;
w = (node->w + 8) * 10;
/*
* Just to save passing it along through every production;
* this is only used informatively, and has nothing to do
* with the structure of rendering.
*/
ctx.grammar = grammar;
ctx.paths = NULL;
ctx.x = 5;
ctx.y = node->a * 10 + 10;
svg_render_station(ctx.x, ctx.y);
ctx.x = 10;
svg_path_h(&ctx.paths, ctx.x, ctx.y, 20);
ctx.x = w - 50;
svg_path_h(&ctx.paths, ctx.x, ctx.y, 20);
ctx.x += 20;
svg_render_station(ctx.x, ctx.y);
ctx.x = 30;
ctx.y = node->a * 10 + 10;
node_walk_render(node, &ctx, base);
/*
* Consolidate adjacent nodes of the same type.
*/
svg_path_consolidate(&ctx.paths);
/*
* Next we consolidate on-the-fly to render a single path segment
* for a individual path with differently-typed items which connect
* in a sequence. This is just an effort to produce tidy markup.
*/
while (ctx.paths != NULL) {
struct path *p;
p = svg_path_find_start(ctx.paths);
printf(" <path d='M%d %d", p->x, p->y);
do {
unsigned nx, ny;
switch (p->type) {
case PATH_H: printf(" h%d", p->u.n); break;
case PATH_V: printf(" v%d", p->u.n); break;
case PATH_Q: printf(" q%d %d %d %d", p->u.q[0], p->u.q[1], p->u.q[2], p->u.q[3]); break;
}
svg_path_move(p, &nx, &ny);
svg_path_remove(&ctx.paths, p);
/* consolidate only when not debugging */
if (debug) {
break;
}
p = svg_path_find_following(ctx.paths, nx, ny);
} while (p != NULL);
printf("'/>\n");
}
}
static void
dim_prop_string(const char *s, unsigned *w, unsigned *a, unsigned *d)
{
const char *p;
double n;
assert(s != NULL);
assert(w != NULL);
assert(a != NULL);
assert(d != NULL);
n = 0.0;
/* estimate at proportional width */
for (p = s; *p != '\0'; p++) {
switch (tolower((unsigned char) *p)) {
case '|':
n += 0.3;
break;
case 't':
n += 0.45;
break;
case 'f':
case 'i':
case 'j':
case 'l':
n += 0.5;
break;
case '(': case ')':
case 'I':
n += 0.55;
break;
case ' ':
n += 0.6;
break;
case 'm':
n += 1.25;
break;
case 'w':
n += 1.2;
break;
case '1':
n += 0.75;
break;
default:
n += 0.8;
break;
}
if (isupper((unsigned char) *p)) {
n += 0.25;
}
}
n = ceil(n);
/* even numbers only, for sake of visual rhythm */
if (((unsigned) n & 1) == 1) {
n++;
}
*w = n + 1;
*a = 1;
*d = 1;
}
static void
dim_mono_txt(const struct txt *t, unsigned *w, unsigned *a, unsigned *d)
{
size_t i;
double n;
assert(t != NULL);
assert(t->p != NULL);
assert(w != NULL);
assert(a != NULL);
assert(d != NULL);
n = 0.0;
for (i = 0; i < t->n; i++) {
if (t->p[i] == '\t' || t->p[i] == '\a') {
n += 4.00;
continue;
}
if (!isprint((unsigned char) t->p[i])) {
n += 2.93; /* <XY> */
continue;
}
n += 1.0;
}
n = ceil(n);
*w = n + 1;
*a = 1;
*d = 1;
}
struct dim svg_dim = {
dim_mono_txt,
dim_prop_string,
0,
0,
0,
1,
2,
0
};
WARN_UNUSED_RESULT
int
svg_output(const struct ast_rule *grammar)
{
const struct ast_rule *p;
struct tnode **a;
unsigned z;
unsigned w, h;
unsigned i, n;
n = 0;
for (p = grammar; p; p = p->next) {
n++;
}
/*
* We store all tnodes for sake of calculating the viewport only;
* it's a shame this needs to be provided ahead of rendering each
* tnode, else we could do that on the fly.
*/
a = xmalloc(sizeof *a * n);
w = 0;
h = 0;
for (i = 0, p = grammar; p; p = p->next, i++) {
struct node *rrd;
if (!ast_to_rrd(p, &rrd)) {
perror("ast_to_rrd");
return 0;
}
if (prettify) {
rrd_pretty(&rrd);
}
a[i] = rrd_to_tnode(rrd, &svg_dim);
if (a[i]->w > w) {
w = a[i]->w;
}
h += a[i]->a + a[i]->d + 6;
node_free(rrd);
}
w += 12;
h += 5;
printf("<?xml version='1.0' encoding='utf-8'?>\n");
printf("<svg\n");
printf(" xmlns='http://www.w3.org/2000/svg'\n");
printf(" xmlns:xlink='http://www.w3.org/1999/xlink'\n");
printf("\n");
printf(" width='%u0' height='%u'>\n", w, h * 10 + 60);
printf("\n");
printf(" <style>\n");
printf(" rect, line, path { stroke-width: 1.5px; stroke: black; fill: transparent; }\n");
printf(" rect, line, path { stroke-linecap: square; stroke-linejoin: rounded; }\n");
if (debug) {
printf(" rect.debug { stroke: none; opacity: 0.75; }\n");
printf(" rect.debug.tile { fill: #cccccc; }\n");
printf(" rect.debug.node { fill: transparent; stroke-width: 1px; stroke: #ccccff; stroke-dasharray: 2 3; }\n");
printf(" rect.debug.justify { fill: #ccccff; }\n");
printf(" text.debug.tile { opacity: 0.3; font-family: monospace; font-weight: bold; stroke: none; }\n");
}
printf(" path { fill: transparent; }\n");
printf(" text.literal { font-family: monospace; }\n");
printf(" line.ellipsis { stroke-dasharray: 1 3.5; }\n");
printf(" tspan.hex { font-family: monospace; font-size: 90%%; }\n");
printf(" path.arrow { fill: black; }\n");
if (css_file != NULL) {
if (!cat(css_file, " ")) {
return 0;
}
}
printf(" </style>\n");
printf("\n");
z = 0;
for (i = 0, p = grammar; p; p = p->next, i++) {
printf(" <g transform='translate(%u %u)'>\n",
40, z * 10 + 50);
printf(" <text x='%d' y='%d'>%s:</text>\n",
-30, -10, p->name);
svg_render_rule(a[i], NULL, grammar);
printf(" </g>\n");
printf("\n");
z += a[i]->a + a[i]->d + 6;
}
for (i = 0, p = grammar; p; p = p->next, i++) {
tnode_free(a[i]);
}
free(a);
printf("</svg>\n");
return 1;
}
| 8,712 |
901 | /*
* Copyright 2017 Google Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.example.android.instant.analytics;
import android.content.Intent;
import android.net.Uri;
import androidx.annotation.NonNull;
import androidx.test.rule.ActivityTestRule;
import androidx.test.runner.AndroidJUnit4;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import static androidx.test.espresso.Espresso.onView;
import static androidx.test.espresso.action.ViewActions.clearText;
import static androidx.test.espresso.action.ViewActions.click;
import static androidx.test.espresso.action.ViewActions.typeText;
import static androidx.test.espresso.assertion.ViewAssertions.matches;
import static androidx.test.espresso.matcher.ViewMatchers.isDisplayed;
import static androidx.test.espresso.matcher.ViewMatchers.isEnabled;
import static androidx.test.espresso.matcher.ViewMatchers.withId;
import static androidx.test.espresso.matcher.ViewMatchers.withText;
import static org.hamcrest.Matchers.not;
@RunWith(AndroidJUnit4.class)
public class MainActivityTest {
@Rule
public ActivityTestRule rule = new ActivityTestRule<MainActivity>(MainActivity.class, true) {
@Override
protected Intent getActivityIntent() {
return new Intent()
.addCategory(Intent.CATEGORY_BROWSABLE)
.setAction(Intent.ACTION_VIEW)
.setData(Uri.parse("https://instant.android.example.com/analytics"));
}
};
@Test
public void isAddressableViaUrl() {
onView(withText(com.example.android.instant.analytics.R.string.btn_send_ecommerce_event)).check(matches(isDisplayed()));
}
@Test
public void submitDisabledWhileDataIncomplete() {
checkButtonDisabled();
onView(withId(com.example.android.instant.analytics.R.id.txtbx_currency)).perform(typeText("EUR"));
checkButtonDisabled();
onView(withId(com.example.android.instant.analytics.R.id.txtbx_currency)).perform(clearText());
onView(withId(com.example.android.instant.analytics.R.id.txtbx_order_amount)).perform(typeText("100"));
checkButtonDisabled();
onView(withId(com.example.android.instant.analytics.R.id.txtbx_order_amount)).perform(clearText());
onView(withId(com.example.android.instant.analytics.R.id.txtbx_order_number)).perform(typeText("1"));
checkButtonDisabled();
onView(withId(com.example.android.instant.analytics.R.id.txtbx_order_number)).perform(clearText());
onView(withId(com.example.android.instant.analytics.R.id.txtbx_currency)).perform(typeText("EUR"));
onView(withId(com.example.android.instant.analytics.R.id.txtbx_order_amount)).perform(typeText("100"));
checkButtonDisabled();
onView(withId(com.example.android.instant.analytics.R.id.txtbx_currency)).perform(clearText());
onView(withId(com.example.android.instant.analytics.R.id.txtbx_order_amount)).perform(clearText());
onView(withId(com.example.android.instant.analytics.R.id.txtbx_currency)).perform(typeText("EUR"));
onView(withId(com.example.android.instant.analytics.R.id.txtbx_order_number)).perform(typeText("1"));
checkButtonDisabled();
onView(withId(com.example.android.instant.analytics.R.id.txtbx_currency)).perform(clearText());
onView(withId(com.example.android.instant.analytics.R.id.txtbx_order_number)).perform(clearText());
onView(withId(com.example.android.instant.analytics.R.id.txtbx_order_amount)).perform(typeText("100"));
onView(withId(com.example.android.instant.analytics.R.id.txtbx_order_number)).perform(typeText("1"));
checkButtonDisabled();
onView(withId(com.example.android.instant.analytics.R.id.txtbx_order_amount)).perform(clearText());
onView(withId(com.example.android.instant.analytics.R.id.txtbx_order_number)).perform(clearText());
}
@Test
public void submitData() {
onView(withId(com.example.android.instant.analytics.R.id.txtbx_currency)).perform(typeText("EUR"));
onView(withId(com.example.android.instant.analytics.R.id.txtbx_order_amount)).perform(typeText("100"));
onView(withId(com.example.android.instant.analytics.R.id.txtbx_order_number)).perform(typeText("1"));
onView(withId(com.example.android.instant.analytics.R.id.btn_send_ecommerce_event)).perform(click());
}
@NonNull
private void checkButtonDisabled() {
onView(withId((com.example.android.instant.analytics.R.id.btn_send_ecommerce_event))).check(matches(not(isEnabled())));
}
}
| 1,963 |
1,139 | <filename>JSF/JSF_DataBoundComponents/src/main/java/com/journaldev/jsf/beans/Mobile.java
package com.journaldev.jsf.beans;
import java.util.ArrayList;
import java.util.Arrays;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.SessionScoped;
@ManagedBean(name = "mobilerecords", eager = true)
@SessionScoped
public class Mobile {
private String companyname;
private String modelnumber;
private String color;
private int quantity;
private double price;
private static final ArrayList<Mobile> mobiles =
new ArrayList<Mobile>(
Arrays.asList(
new Mobile("Nokia", "N213", "Black", 10, 2500),
new Mobile("Micromax", "A114", "White", 25, 9500),
new Mobile("MotoG", "M345", "Grey", 40, 15300),
new Mobile("Samsung", "S-512", "Blue", 15, 11000)
));
public ArrayList<Mobile> getMobiles() {
return mobiles;
}
public Mobile() {
}
public Mobile(String companyname, String modelnumber, String color,
int quantity, double price) {
this.companyname = companyname;
this.modelnumber = modelnumber;
this.color = color;
this.quantity = quantity;
this.price = price;
}
public String getCompanyname() {
return companyname;
}
public void setCompanyname(String companyname) {
this.companyname = companyname;
}
public String getModelnumber() {
return modelnumber;
}
public void setModelnumber(String modelnumber) {
this.modelnumber = modelnumber;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public int getQuantity() {
return quantity;
}
public void setQuantity(int quantity) {
this.quantity = quantity;
}
public double getPrice() {
return price;
}
public void setPrice(double price) {
this.price = price;
}
}
| 626 |
463 | <reponame>yanz08/rv8-wezh<filename>src/jit/jit-tracer.h
//
// jit-tracer.h
//
#ifndef rv_jit_tracer_h
#define rv_jit_tracer_h
namespace riscv {
template <typename P, typename I>
struct jit_tracer
{
typedef P processor_type;
typedef typename P::decode_type decode_type;
P &proc;
std::map<addr_t,size_t> labels;
std::vector<addr_t> callstack;
std::vector<decode_type> trace;
size_t inst_num;
jit_tracer(P &proc)
: proc(proc), inst_num(0) {}
bool supported_op(decode_type &dec)
{
static I isa;
return isa.supported_ops.test(dec.op);
}
void begin() {}
void end() {}
bool emit(decode_type &dec)
{
auto li = labels.find(dec.pc);
if (li != labels.end()) {
return false;
}
labels[dec.pc] = inst_num++;
switch (dec.op)
{
case jit_op_call: {
/* follow call */
addr_t link_addr = dec.pc + dec.sz;
callstack.push_back(link_addr);
trace.push_back(dec);
return true;
}
case rv_op_jal: {
/* follow jump */
addr_t link_addr = dec.pc + inst_length(dec.inst);
if (dec.rd == rv_ireg_ra) {
callstack.push_back(link_addr);
}
trace.push_back(dec);
return true;
}
case rv_op_jalr: {
if (dec.rd == rv_ireg_zero && dec.rs1 == rv_ireg_ra && callstack.size() > 0) {
/* follow return */
callstack.pop_back();
trace.push_back(dec);
return true;
} else {
/* terminate on indirect jump */
addr_t link_addr = dec.pc + inst_length(dec.inst);
if (dec.rd == rv_ireg_ra) {
callstack.push_back(link_addr);
}
trace.push_back(dec);
return false;
}
}
case rv_op_bne:
case rv_op_beq:
case rv_op_blt:
case rv_op_bge:
case rv_op_bltu:
case rv_op_bgeu: {
/* save branch condition */
switch (dec.op) {
case rv_op_bne:
dec.brc = proc.ireg[dec.rs1].r.x.val != proc.ireg[dec.rs2].r.x.val;
break;
case rv_op_beq:
dec.brc = proc.ireg[dec.rs1].r.x.val == proc.ireg[dec.rs2].r.x.val;
break;
case rv_op_blt:
dec.brc = proc.ireg[dec.rs1].r.x.val < proc.ireg[dec.rs2].r.x.val;
break;
case rv_op_bge:
dec.brc = proc.ireg[dec.rs1].r.x.val >= proc.ireg[dec.rs2].r.x.val;
break;
case rv_op_bltu:
dec.brc = proc.ireg[dec.rs1].r.xu.val < proc.ireg[dec.rs2].r.xu.val;
break;
case rv_op_bgeu:
dec.brc = proc.ireg[dec.rs1].r.xu.val >= proc.ireg[dec.rs2].r.xu.val;
break;
default:
dec.brc = false;
break;
}
/* follow branch */
addr_t branch_pc = dec.pc + dec.imm;
addr_t cont_pc = dec.pc + inst_length(dec.inst);
auto branch_i = labels.find(branch_pc);
auto cont_i = labels.find(cont_pc);
/* label basic blocks */
if (branch_i != labels.end()) trace[branch_i->second].brt = true;
if (cont_i != labels.end()) trace[cont_i->second].brt = true;
trace.push_back(dec);
return true;
}
default: {
/* save supported instruction */
if (supported_op(dec)) {
trace.push_back(dec);
return true;
}
}
}
return false;
}
};
}
#endif
| 1,709 |
639 | <filename>src/nnfusion/frontend/onnx_import/op/scatternd.cpp<gh_stars>100-1000
//*****************************************************************************
// Copyright 2017-2020 Intel Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//*****************************************************************************
//----------------------------------------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
//----------------------------------------------------------------------------------------------
#include <vector>
#include "../util/util.hpp"
#include "nnfusion/frontend/util/evaluator.hpp"
#include "scatternd.hpp"
static inline int64_t get_valid_array_idx(int64_t idx, int64_t last_idx)
{
return (idx >= 0) ? std::min(idx, last_idx) : std::max<int64_t>(0, last_idx + idx);
}
namespace nnfusion
{
namespace frontend
{
namespace onnx_import
{
namespace set_11
{
NamedNodeVector
TranslateScatterNDOp(const onnx::NodeProto& node_proto,
const NodeMap& all_ng_nodes,
std::shared_ptr<nnfusion::graph::Graph> m_graph)
{
auto input_indexes = GetAllInputIndex(all_ng_nodes, node_proto);
nnfusion::op::OpConfig::any myConfig;
auto generic_op = std::make_shared<nnfusion::op::GenericOp>(
node_proto.name(), "ScatterND", myConfig);
auto generic_gnode = m_graph->add_node_and_edge(generic_op, input_indexes);
NamedNodeVector ret{{node_proto.output(0), generic_gnode}};
return ret;
}
} // namespace set_11
} //namespace onnx_import
} // namespace frontend
} // namespace nnfusion
| 972 |
1,738 | <reponame>jeikabu/lumberyard
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
// Original file Copyright Crytek GMBH or its affiliates, used under license.
#ifndef CRYINCLUDE_CRYMOVIE_EVENTNODE_H
#define CRYINCLUDE_CRYMOVIE_EVENTNODE_H
#pragma once
#include "AnimNode.h"
class CAnimEventNode
: public CAnimNode
{
public:
AZ_CLASS_ALLOCATOR(CAnimEventNode, AZ::SystemAllocator, 0);
AZ_RTTI(CAnimEventNode, "{F9F306E0-FF9C-4FF4-B1CC-5A96746364FE}", CAnimNode);
CAnimEventNode();
CAnimEventNode(const int id);
//////////////////////////////////////////////////////////////////////////
// Overrides from CAnimNode
//////////////////////////////////////////////////////////////////////////
virtual void Animate(SAnimContext& ec);
virtual void CreateDefaultTracks();
virtual void OnReset();
//////////////////////////////////////////////////////////////////////////
// Supported tracks description.
//////////////////////////////////////////////////////////////////////////
virtual unsigned int GetParamCount() const;
virtual CAnimParamType GetParamType(unsigned int nIndex) const;
virtual bool GetParamInfoFromType(const CAnimParamType& paramId, SParamInfo& info) const;
static void Reflect(AZ::SerializeContext* serializeContext);
private:
void SetScriptValue();
private:
//! Last animated key in track.
int m_lastEventKey;
};
#endif // CRYINCLUDE_CRYMOVIE_EVENTNODE_H
| 580 |
3,702 | // Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
// This source code is licensed under the BSD-style license found in the
// LICENSE file in the root directory of this source tree. An additional grant
// of patent rights can be found in the PATENTS file in the same directory.
//
// The following only applies to changes made to this file as part of YugaByte development.
//
// Portions Copyright (c) YugaByte, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software distributed under the License
// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
// or implied. See the License for the specific language governing permissions and limitations
// under the License.
//
// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file. See the AUTHORS file for names of contributors.
#ifndef __STDC_FORMAT_MACROS
#define __STDC_FORMAT_MACROS
#endif
#include <inttypes.h>
#include <limits>
#include "yb/rocksdb/util/testharness.h"
#include "yb/rocksdb/util/rate_limiter.h"
#include "yb/rocksdb/util/random.h"
#include "yb/rocksdb/env.h"
namespace rocksdb {
class RateLimiterTest : public testing::Test {};
TEST_F(RateLimiterTest, StartStop) {
std::unique_ptr<RateLimiter> limiter(new GenericRateLimiter(100, 100, 10));
}
#ifndef OS_MACOSX
TEST_F(RateLimiterTest, Rate) {
auto* env = Env::Default();
struct Arg {
Arg(int32_t _target_rate, int _burst)
: limiter(new GenericRateLimiter(_target_rate, 100 * 1000, 10)),
request_size(_target_rate / 10),
burst(_burst) {}
std::unique_ptr<RateLimiter> limiter;
int32_t request_size;
int burst;
};
auto writer = [](void* p) {
auto* thread_env = Env::Default();
auto* arg = static_cast<Arg*>(p);
// Test for 10 seconds
auto until = thread_env->NowMicros() + 10 * 1000000;
Random r((uint32_t)(thread_env->NowNanos() %
std::numeric_limits<uint32_t>::max()));
while (thread_env->NowMicros() < until) {
for (int i = 0; i < static_cast<int>(r.Skewed(arg->burst) + 1); ++i) {
arg->limiter->Request(r.Uniform(arg->request_size - 1) + 1,
Env::IO_HIGH);
}
arg->limiter->Request(r.Uniform(arg->request_size - 1) + 1, Env::IO_LOW);
}
};
for (int i = 1; i <= 16; i *= 2) {
int32_t target = i * 1024 * 10;
Arg arg(target, i / 4 + 1);
int64_t old_total_bytes_through = 0;
for (int iter = 1; iter <= 2; ++iter) {
// second iteration changes the target dynamically
if (iter == 2) {
target *= 2;
arg.limiter->SetBytesPerSecond(target);
}
auto start = env->NowMicros();
for (int t = 0; t < i; ++t) {
env->StartThread(writer, &arg);
}
env->WaitForJoin();
auto elapsed = env->NowMicros() - start;
double rate =
(arg.limiter->GetTotalBytesThrough() - old_total_bytes_through) *
1000000.0 / elapsed;
old_total_bytes_through = arg.limiter->GetTotalBytesThrough();
fprintf(stderr,
"request size [1 - %" PRIi32 "], limit %" PRIi32
" KB/sec, actual rate: %lf KB/sec, elapsed %.2lf seconds\n",
arg.request_size - 1, target / 1024, rate / 1024,
elapsed / 1000000.0);
ASSERT_GE(rate / target, 0.8);
ASSERT_LE(rate / target, 1.2);
}
}
}
#endif
} // namespace rocksdb
int main(int argc, char** argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
| 1,527 |
2,338 | #ifndef ISL_VERSION_H
#define ISL_VERSION_H
#if defined(__cplusplus)
extern "C" {
#endif
const char *isl_version(void);
#if defined(__cplusplus)
}
#endif
#endif
| 72 |
443 | """Fill TestGroup.result
Revision ID: 3edf6ec6abd5
Revises: <PASSWORD>
Create Date: 2013-11-05 14:08:23.068195
"""
from __future__ import absolute_import, print_function
# revision identifiers, used by Alembic.
revision = '3edf6ec6abd5'
down_revision = '<PASSWORD>'
from alembic import op
from sqlalchemy.sql import select, table
import sqlalchemy as sa
def upgrade():
from changes.constants import Result
connection = op.get_bind()
testgroups_table = table(
'testgroup',
sa.Column('id', sa.GUID(), nullable=False),
sa.Column('result', sa.Enum(), nullable=True),
)
testgroups_m2m_table = table(
'testgroup_test',
sa.Column('group_id', sa.GUID(), nullable=False),
sa.Column('test_id', sa.GUID(), nullable=False),
)
testcases_table = table(
'test',
sa.Column('id', sa.GUID(), nullable=False),
sa.Column('result', sa.Enum(), nullable=True),
)
# perform data migrations
for testgroup in connection.execute(testgroups_table.select()):
# migrate group to suite
print("Migrating TestGroup %s" % (testgroup.id,))
query = select([testcases_table]).where(
sa.and_(
testgroups_m2m_table.c.test_id == testcases_table.c.id,
testgroups_m2m_table.c.group_id == testgroup.id,
)
)
result = Result.unknown
for testcase in connection.execute(query):
result = max(result, Result(testcase.result))
connection.execute(
testgroups_table.update().where(
testgroups_table.c.id == testgroup.id,
).values({
testgroups_table.c.result: result,
})
)
def downgrade():
pass
| 791 |
2,023 | <gh_stars>1000+
from urllib import quote_plus, FancyURLopener, URLopener, unwrap,\
toBytes, splittype
def retrieve(self, url, filename=None, reporthook=None, data=None,
maxtries=5, r_range=None):
"""retrieve(url) returns (filename, headers) for a local object
or (tempfilename, headers) for a remote object.
If it fails, it relaunches itself until the dl is complete or
maxtries == 0 (maxtries == -1 for unlimited tries).
Range tuple(start, end) indicates the range of the remote object
we have to retrieve (ignored for local files)"""
if maxtries < -1:
raise ValueError, 'maxtries must be at least equal with -1'
url = unwrap(toBytes(url))
if self.tempcache and url in self.tempcache:
return self.tempcache[url]
type, url1 = splittype(url)
if filename is None and (not type or type == 'file'):
try:
fp = self.open_local_file(url1)
hdrs = fp.info()
fp.close()
return url2pathname(splithost(url1)[1]), hdrs
except IOError, msg:
pass
if not r_range is None:
try:
self.addheader(('Range', 'bytes=%d-%d' % r_range))
except TypeError:
raise ValueError, 'r_range argument must be a tuple of two int : (start, end)'
fp = self.open(url, data)
try:
headers = fp.info()
if filename:
tfp = open(filename, 'ab')
else:
import tempfile
garbage, path = splittype(url)
garbage, path = splithost(path or "")
path, garbage = splitquery(path or "")
path, garbage = splitattr(path or "")
suffix = os.path.splitext(path)[1]
(fd, filename) = tempfile.mkstemp(suffix)
self.__tempfiles.append(filename)
tfp = os.fdopen(fd, 'ab')
try:
result = filename, headers
if self.tempcache is not None:
self.tempcache[url] = result
bs = 1024*8
size = -1
read = 0
blocknum = 0
if "content-length" in headers:
size = int(headers["Content-Length"])
elif r_range is not None:
size = r_range[1]
if reporthook:
reporthook(blocknum, bs, size)
while 1:
block = fp.read(bs)
if block == "":
break
read += len(block)
tfp.write(block)
blocknum += 1
if reporthook:
reporthook(blocknum, bs, size)
finally:
tfp.close()
finally:
fp.close()
# raise exception if actual size does not match content-length
# header and if maxtries <= 0
if size >= 0 and read < size:
if maxtries > 0 or maxtries == -1:
self.retrieve(url, filename, reporthook, data,
maxtries if maxtries == -1 else maxtries-1,
r_range=(read, size))
else:
raise ContentTooShortError("retrieval incomplete: got only %i out "
"of %i bytes" % (read, size), result)
return result
#to use our function in the opener
URLopener.retrieve = retrieve
| 1,944 |
2,288 | <filename>clightning/ccan/ccan/array_size/test/compile_fail-function-param.c
#include <ccan/array_size/array_size.h>
#include <stdlib.h>
struct foo {
unsigned int a, b;
};
int check_parameter(const struct foo *array);
int check_parameter(const struct foo *array)
{
#ifdef FAIL
return (ARRAY_SIZE(array) == 4);
#if !HAVE_TYPEOF || !HAVE_BUILTIN_TYPES_COMPATIBLE_P
#error "Unfortunately we don't fail if _array_size_chk is a noop."
#endif
#else
return sizeof(array) == 4 * sizeof(struct foo);
#endif
}
int main(void)
{
return check_parameter(NULL);
}
| 220 |
20,401 | <filename>deploy/android_demo/app/src/main/cpp/ocr_db_post_process.h
//
// Created by fujiayi on 2020/7/2.
//
#pragma once
#include <opencv2/opencv.hpp>
#include <vector>
std::vector<std::vector<std::vector<int>>>
boxes_from_bitmap(const cv::Mat &pred, const cv::Mat &bitmap);
std::vector<std::vector<std::vector<int>>>
filter_tag_det_res(const std::vector<std::vector<std::vector<int>>> &o_boxes,
float ratio_h, float ratio_w, const cv::Mat &srcimg); | 197 |
3,897 | <reponame>adelcrosge1/mbed-os
/**
* @file lp.c
* @brief Low power functions
*/
/* ****************************************************************************
* Copyright (C) Maxim Integrated Products, Inc., All Rights Reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL MAXIM INTEGRATED BE LIABLE FOR ANY CLAIM, DAMAGES
* OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
* OTHER DEALINGS IN THE SOFTWARE.
*
* Except as contained in this notice, the name of Maxim Integrated
* Products, Inc. shall not be used except as stated in the Maxim Integrated
* Products, Inc. Branding Policy.
*
* The mere transfer of this software does not imply any licenses
* of trade secrets, proprietary technology, copyrights, patents,
* trademarks, maskwork rights, or any other form of intellectual
* property whatsoever. Maxim Integrated Products, Inc. retains all
* ownership rights.
*
*
*************************************************************************** */
/***** Includes *****/
#include "lp.h"
#include "pwrseq_regs.h"
#include "mxc_errors.h"
#include "gcr_regs.h"
#include "mxc_device.h"
#include "mxc_errors.h"
#include "mxc_pins.h"
#include "mxc_sys.h"
#include "flc.h"
#include "mxc_delay.h"
/***** Functions *****/
void MXC_LP_ClearWakeStatus(void)
{
MXC_PWRSEQ->lp_wakefl = 0xFFFFFFFF;
/* These flags are slow to clear, so block until they do */
while(MXC_PWRSEQ->lp_wakefl & (MXC_PWRSEQ->lpwk_en));
}
void MXC_LP_EnableSRAM3(void)
{
MXC_PWRSEQ->lpmemsd &= ~MXC_F_PWRSEQ_LPMEMSD_SRAM3_OFF;
}
void MXC_LP_DisableSRAM3(void)
{
MXC_PWRSEQ->lpmemsd |= MXC_F_PWRSEQ_LPMEMSD_SRAM3_OFF;
}
void MXC_LP_EnableSRAM2(void)
{
MXC_PWRSEQ->lpmemsd &= ~MXC_F_PWRSEQ_LPMEMSD_SRAM2_OFF;
}
void MXC_LP_DisableSRAM2(void)
{
MXC_PWRSEQ->lpmemsd |= MXC_F_PWRSEQ_LPMEMSD_SRAM2_OFF;
}
void MXC_LP_EnableSRAM1(void)
{
MXC_PWRSEQ->lpmemsd &= ~MXC_F_PWRSEQ_LPMEMSD_SRAM1_OFF;
}
void MXC_LP_DisableSRAM1(void)
{
MXC_PWRSEQ->lpmemsd |= MXC_F_PWRSEQ_LPMEMSD_SRAM1_OFF;
}
void MXC_LP_EnableSRAM0(void)
{
MXC_PWRSEQ->lpmemsd &= ~MXC_F_PWRSEQ_LPMEMSD_SRAM0_OFF;
}
void MXC_LP_DisableSRAM0(void)
{
MXC_PWRSEQ->lpmemsd |= MXC_F_PWRSEQ_LPMEMSD_SRAM0_OFF;
}
void MXC_LP_EnableICacheLightSleep(void)
{
MXC_GCR->mem_ctrl |= (MXC_F_GCR_MEM_CTRL_ICACHE_RET);
}
void MXC_LP_DisableICacheLightSleep(void)
{
MXC_GCR->mem_ctrl &= ~(MXC_F_GCR_MEM_CTRL_ICACHE_RET);
}
void MXC_LP_EnableSysRAM3LightSleep(void)
{
MXC_GCR->mem_ctrl |= (MXC_F_GCR_MEM_CTRL_RAM3_LS);
}
void MXC_LP_DisableSysRAM3LightSleep(void)
{
MXC_GCR->mem_ctrl &= ~(MXC_F_GCR_MEM_CTRL_RAM3_LS);
}
void MXC_LP_EnableSysRAM2LightSleep(void)
{
MXC_GCR->mem_ctrl |= (MXC_F_GCR_MEM_CTRL_RAM2_LS);
}
void MXC_LP_DisableSysRAM2LightSleep(void)
{
MXC_GCR->mem_ctrl &= ~(MXC_F_GCR_MEM_CTRL_RAM2_LS);
}
void MXC_LP_EnableSysRAM1LightSleep(void)
{
MXC_GCR->mem_ctrl |= (MXC_F_GCR_MEM_CTRL_RAM1_LS);
}
void MXC_LP_DisableSysRAM1LightSleep(void)
{
MXC_GCR->mem_ctrl &= ~(MXC_F_GCR_MEM_CTRL_RAM1_LS);
}
void MXC_LP_EnableSysRAM0LightSleep(void)
{
MXC_GCR->mem_ctrl |= (MXC_F_GCR_MEM_CTRL_RAM0_LS);
}
void MXC_LP_DisableSysRAM0LightSleep(void)
{
MXC_GCR->mem_ctrl &= ~(MXC_F_GCR_MEM_CTRL_RAM0_LS);
}
void MXC_LP_EnableRTCAlarmWakeup(void)
{
MXC_GCR->pm |= MXC_F_GCR_PM_RTCWK_EN;
}
void MXC_LP_DisableRTCAlarmWakeup(void)
{
MXC_GCR->pm &= ~MXC_F_GCR_PM_RTCWK_EN;
}
void MXC_LP_EnableGPIOWakeup(unsigned int port, unsigned int mask)
{
MXC_GCR->pm |= MXC_F_GCR_PM_GPIOWK_EN;
//switch(port)
//{
/*case 0:*/ MXC_PWRSEQ->lpwk_en |= mask; //break;
//}
}
void MXC_LP_DisableGPIOWakeup(unsigned int port, unsigned int mask)
{
//switch(port)
//{
/* case 0:*/ MXC_PWRSEQ->lpwk_en &= ~mask; //break;
//}
if(MXC_PWRSEQ->lpwk_en == 0)
{
MXC_GCR->pm &= ~MXC_F_GCR_PM_GPIOWK_EN;
}
}
void MXC_LP_EnterSleepMode(void)
{
// Clear SLEEPDEEP bit
SCB->SCR &= ~SCB_SCR_SLEEPDEEP_Msk;
// Go into Sleep mode and wait for an interrupt to wake the processor
__WFI();
}
void MXC_LP_EnterDeepSleepMode(void)
{
// Set SLEEPDEEP bit
SCB->SCR |= SCB_SCR_SLEEPDEEP_Msk;
// Auto-powerdown 96 MHz oscillator when in deep sleep
MXC_GCR->pm |= MXC_F_GCR_PM_HFIOPD;
// Go into Deepsleep mode and wait for an interrupt to wake the processor
__WFI();
}
void MXC_LP_EnterBackupMode(void)
{
MXC_GCR->pm &= ~MXC_F_GCR_PM_MODE;
MXC_GCR->pm |= MXC_S_GCR_PM_MODE_BACKUP;
while(1);
}
void MXC_LP_EnterShutdownMode(void)
{
MXC_GCR->pm &= ~MXC_F_GCR_PM_MODE;
MXC_GCR->pm |= MXC_S_GCR_PM_MODE_SHUTDOWN;
while(1);
}
int MXC_LP_SetOperatingVoltage(mxc_lp_ovr_t ovr)
{
uint32_t current_clock, div;
int error;
// Ensure part is operating from internal LDO for core power
if(MXC_PWRSEQ->lp_ctrl & MXC_F_PWRSEQ_LP_CTRL_LDO_DIS) {
return E_BAD_STATE;
}
// Select the 8KHz nanoring (no guarantee 32KHz is attached) as system clock source
current_clock = MXC_GCR->clk_ctrl & MXC_F_GCR_CLK_CTRL_CLKSEL;
if(current_clock == MXC_SYS_CLOCK_HIRC) {
error = MXC_SYS_Clock_Select(MXC_SYS_CLOCK_NANORING);
if(error != E_NO_ERROR) {
return error;
}
}
// Set flash wait state for any clock so its not to low after clock changes.
MXC_GCR->mem_ctrl = (MXC_GCR->mem_ctrl & ~(MXC_F_GCR_MEM_CTRL_FWS)) | (0x5UL << MXC_F_GCR_MEM_CTRL_FWS_POS);
// Set the OVR bits
MXC_PWRSEQ->lp_ctrl &= ~(MXC_F_PWRSEQ_LP_CTRL_OVR);
MXC_PWRSEQ->lp_ctrl |= ovr;
// Set LVE bit
if(ovr == MXC_LP_OVR_0_9) {
MXC_FLC->ctrl |= MXC_F_FLC_CTRL_LVE;
} else {
MXC_FLC->ctrl &= ~(MXC_F_FLC_CTRL_LVE);
}
// Revert the clock to original state if it was HIRC
if(current_clock == MXC_SYS_CLOCK_HIRC) {
error = MXC_SYS_Clock_Select(MXC_SYS_CLOCK_HIRC);
if(error != E_NO_ERROR) {
return error;
}
}
// Update SystemCoreClock variable
SystemCoreClockUpdate();
// Get the clock divider
div = (MXC_GCR->clk_ctrl & MXC_F_GCR_CLK_CTRL_PSC) >> MXC_F_GCR_CLK_CTRL_PSC_POS;
// Set Flash Wait States
if(ovr == MXC_LP_OVR_0_9) {
if(div == 0) {
MXC_GCR->mem_ctrl = (MXC_GCR->mem_ctrl & ~(MXC_F_GCR_MEM_CTRL_FWS)) | (0x2UL << MXC_F_GCR_MEM_CTRL_FWS_POS);
} else {
MXC_GCR->mem_ctrl = (MXC_GCR->mem_ctrl & ~(MXC_F_GCR_MEM_CTRL_FWS)) | (0x1UL << MXC_F_GCR_MEM_CTRL_FWS_POS);
}
} else if(ovr == MXC_LP_OVR_1_0) {
if(div == 0) {
MXC_GCR->mem_ctrl = (MXC_GCR->mem_ctrl & ~(MXC_F_GCR_MEM_CTRL_FWS)) | (0x2UL << MXC_F_GCR_MEM_CTRL_FWS_POS);
} else {
MXC_GCR->mem_ctrl = (MXC_GCR->mem_ctrl & ~(MXC_F_GCR_MEM_CTRL_FWS)) | (0x1UL << MXC_F_GCR_MEM_CTRL_FWS_POS);
}
} else {
if(div == 0) {
MXC_GCR->mem_ctrl = (MXC_GCR->mem_ctrl & ~(MXC_F_GCR_MEM_CTRL_FWS)) | (0x4UL << MXC_F_GCR_MEM_CTRL_FWS_POS);
} else if(div == 1) {
MXC_GCR->mem_ctrl = (MXC_GCR->mem_ctrl & ~(MXC_F_GCR_MEM_CTRL_FWS)) | (0x2UL << MXC_F_GCR_MEM_CTRL_FWS_POS);
} else {
MXC_GCR->mem_ctrl = (MXC_GCR->mem_ctrl & ~(MXC_F_GCR_MEM_CTRL_FWS)) | (0x1UL << MXC_F_GCR_MEM_CTRL_FWS_POS);
}
}
// Caller must perform peripheral reset
return E_NO_ERROR;
}
void MXC_LP_EnableSRamRet0(void){
MXC_PWRSEQ->lp_ctrl |= MXC_F_PWRSEQ_LP_CTRL_RAMRET_SEL0;
}
void MXC_LP_DisableSRamRet0(void){
MXC_PWRSEQ->lp_ctrl &= ~MXC_F_PWRSEQ_LP_CTRL_RAMRET_SEL0;
}
void MXC_LP_EnableSRamRet1(void){
MXC_PWRSEQ->lp_ctrl |= MXC_F_PWRSEQ_LP_CTRL_RAMRET_SEL1;
}
void MXC_LP_DisableSRamRet1(void){
MXC_PWRSEQ->lp_ctrl &= ~MXC_F_PWRSEQ_LP_CTRL_RAMRET_SEL1;
}
void MXC_LP_EnableSRamRet2(void){
MXC_PWRSEQ->lp_ctrl |= MXC_F_PWRSEQ_LP_CTRL_RAMRET_SEL2;
}
void MXC_LP_DisableSRamRet2(void){
MXC_PWRSEQ->lp_ctrl &= ~MXC_F_PWRSEQ_LP_CTRL_RAMRET_SEL2;
}
void MXC_LP_EnableSRamRet3(void){
MXC_PWRSEQ->lp_ctrl |= MXC_F_PWRSEQ_LP_CTRL_RAMRET_SEL3;
}
void MXC_LP_DisableSRamRet3(void){
MXC_PWRSEQ->lp_ctrl &= ~MXC_F_PWRSEQ_LP_CTRL_RAMRET_SEL3;
}
void MXC_LP_EnableBlockDetect(void){
MXC_PWRSEQ->lp_ctrl &= ~MXC_F_PWRSEQ_LP_CTRL_VCORE_DET_BYPASS;
}
void MXC_LP_DisableBlockDetect(void){
MXC_PWRSEQ->lp_ctrl |= MXC_F_PWRSEQ_LP_CTRL_VCORE_DET_BYPASS;
}
void MXC_LP_EnableRamRetReg(void){
MXC_PWRSEQ->lp_ctrl |= MXC_F_PWRSEQ_LP_CTRL_RETREG_EN;
}
void MXC_LP_DisableRamRetReg(void){
MXC_PWRSEQ->lp_ctrl &= ~MXC_F_PWRSEQ_LP_CTRL_RETREG_EN;
}
void MXC_LP_EnableFastWk(void){
MXC_PWRSEQ->lp_ctrl |= MXC_F_PWRSEQ_LP_CTRL_FAST_WK_EN;
}
void MXC_LP_DisableFastWk(void){
MXC_PWRSEQ->lp_ctrl &= ~MXC_F_PWRSEQ_LP_CTRL_FAST_WK_EN;
}
void MXC_LP_EnableBandGap(void){
MXC_PWRSEQ->lp_ctrl &= ~MXC_F_PWRSEQ_LP_CTRL_BG_OFF;
}
void MXC_LP_DisableBandGap(void){
MXC_PWRSEQ->lp_ctrl |= MXC_F_PWRSEQ_LP_CTRL_BG_OFF;
}
void MXC_LP_EnableVCorePORSignal(void){
MXC_PWRSEQ->lp_ctrl &= ~MXC_F_PWRSEQ_LP_CTRL_VCORE_POR_DIS;
}
void MXC_LP_DisableVCorePORSignal(void){
MXC_PWRSEQ->lp_ctrl |= MXC_F_PWRSEQ_LP_CTRL_VCORE_POR_DIS;
}
void MXC_LP_EnableLDO(void){
MXC_PWRSEQ->lp_ctrl &= ~MXC_F_PWRSEQ_LP_CTRL_LDO_DIS;
}
void MXC_LP_DisableLDO(void){
MXC_PWRSEQ->lp_ctrl |= MXC_F_PWRSEQ_LP_CTRL_LDO_DIS;
}
void MXC_LP_EnableVCoreSVM(void){
MXC_PWRSEQ->lp_ctrl &= ~MXC_F_PWRSEQ_LP_CTRL_VCORE_SVM_DIS;
}
void MXC_LP_DisableVCoreSVM(void){
MXC_PWRSEQ->lp_ctrl |= MXC_F_PWRSEQ_LP_CTRL_VCORE_SVM_DIS;
}
void MXC_LP_EnableVDDIOPorMonitoF(void){
MXC_PWRSEQ->lp_ctrl &= ~MXC_F_PWRSEQ_LP_CTRL_VDDIO_POR_DIS;
}
void MXC_LP_DisableVDDIOPorMonitor(void){
MXC_PWRSEQ->lp_ctrl |= MXC_F_PWRSEQ_LP_CTRL_VDDIO_POR_DIS;
}
| 5,353 |
348 | {"nom":"Lahitère","circ":"7ème circonscription","dpt":"Haute-Garonne","inscrits":51,"abs":19,"votants":32,"blancs":6,"nuls":2,"exp":24,"res":[{"nuance":"REM","nom":"<NAME>","voix":16},{"nuance":"FN","nom":"Mme <NAME>","voix":8}]} | 95 |
348 | {"nom":"Lahosse","circ":"3ème circonscription","dpt":"Landes","inscrits":248,"abs":105,"votants":143,"blancs":12,"nuls":2,"exp":129,"res":[{"nuance":"SOC","nom":"<NAME>","voix":84},{"nuance":"REM","nom":"<NAME>","voix":45}]} | 90 |
3,200 | /**
* Copyright 2020-2021 Huawei Technologies Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <iostream>
#include "src/common/log_adapter.h"
#include "common/common_test.h"
#include "nnacl/fp32/activation_fp32.h"
#include "mindspore/lite/src/kernel_registry.h"
#include "mindspore/lite/src/lite_kernel.h"
namespace mindspore {
class TestActivationFp32 : public mindspore::CommonTest {
public:
TestActivationFp32() {}
};
TEST_F(TestActivationFp32, ReluFp32) {
float input[8] = {-3, -2, -1, 0, 1, 5, 6, 7};
float output[8] = {0};
Fp32Relu(input, 8, output);
float expect[8] = {0, 0, 0, 0, 1, 5, 6, 7};
for (int i = 0; i < 8; ++i) {
ASSERT_EQ(output[i], expect[i]);
}
}
TEST_F(TestActivationFp32, Relu6Fp32) {
float input[8] = {-3, -2, -1, 0, 1, 5, 6, 7};
float output[8] = {0};
Fp32Relu6(input, 8, output);
float expect[8] = {0, 0, 0, 0, 1, 5, 6, 6};
for (int i = 0; i < 8; ++i) {
ASSERT_EQ(output[i], expect[i]);
}
MS_LOG(INFO) << "TestActivationFp32 passed";
}
TEST_F(TestActivationFp32, LReluFp32) {
float input[8] = {-3, -2, -1, 0, 1, 5, 6, 7};
float output[8] = {0};
LRelu(input, 8, output, 0.01);
float expect[8] = {-0.03, -0.02, -0.01, 0, 1, 5, 6, 7};
for (int i = 0; i < 8; ++i) {
ASSERT_EQ(output[i], expect[i]);
}
MS_LOG(INFO) << "TestActivationFp32 passed";
}
TEST_F(TestActivationFp32, SigmoidFp32) {
float input[8] = {0, 1, 2, 3, 4, 5, 6, 7};
float output[8] = {0};
Sigmoid(input, 8, output);
// expect output {0.5, 0.731059, 0.880797, 0.952574, 0.982014, 0.993307, 0.997527, 0.999089};
printf("==================output data=================\n");
for (int i = 0; i < 8; ++i) {
std::cout << output[i] << " ";
}
std::cout << std::endl;
MS_LOG(INFO) << "TestSigmoidFp32 passed";
}
TEST_F(TestActivationFp32, SwishFp32) {
float input[8] = {0, 1, 2, 3, 4, 5, 6, 7};
float output[8] = {0};
Swish(input, 8, output);
float expect[8] = {0, 0.731059, 1.761594, 2.857722, 3.928056, 4.966535, 5.985162, 6.993623};
for (int i = 0; i < 8; ++i) {
EXPECT_NEAR(output[i], expect[i], 0.00001);
}
}
TEST_F(TestActivationFp32, TanhFp32) {
float input[7] = {-3, -2, -1, 0, 1, 2, 3};
float output[7] = {0};
Tanh(input, 7, output);
float expect[8] = {-0.995055, -0.964028, -0.761594, 0.000000, 0.761594, 0.964028, 0.995055};
for (int i = 0; i < 8; ++i) {
EXPECT_NEAR(output[i], expect[i], 0.00001);
}
MS_LOG(INFO) << "TanhFp32 passed";
}
TEST_F(TestActivationFp32, HSwishFp32) {
std::vector<lite::Tensor *> inputs_tensor;
std::vector<lite::Tensor *> outputs_tensor;
ActivationParameter op_param;
op_param.op_parameter_.type_ = schema::PrimitiveType_Activation;
op_param.type_ = schema::ActivationType_HSWISH;
op_param.alpha_ = 0.01;
std::vector<float> input = {-3.0, -2.0, -1.0, 0.0, 1.0, 5.0, 6.0, 7.0};
std::vector<int> in_shape = {8};
lite::Tensor input0_tensor;
inputs_tensor.push_back(&input0_tensor);
input0_tensor.set_data(input.data());
input0_tensor.set_shape(in_shape);
std::vector<float> output(8);
std::vector<int> output_shape = {8};
lite::Tensor output0_tensor;
outputs_tensor.push_back(&output0_tensor);
output0_tensor.set_data(output.data());
kernel::KernelKey desc = {kernel::KERNEL_ARCH::kCPU, kNumberTypeFloat32, schema::PrimitiveType_Activation};
auto creator = lite::KernelRegistry::GetInstance()->GetCreator(desc);
ASSERT_NE(creator, nullptr);
lite::InnerContext ctx;
ctx.thread_num_ = 7;
ASSERT_EQ(lite::RET_OK, ctx.Init());
auto *kernel = creator(inputs_tensor, outputs_tensor, reinterpret_cast<OpParameter *>(&op_param), &ctx, desc);
ASSERT_NE(kernel, nullptr);
auto output_tensor_shape = output0_tensor.shape();
auto ret = kernel->Prepare();
EXPECT_EQ(0, ret);
ret = kernel->Run();
EXPECT_EQ(0, ret);
std::vector<float> expect_output = {-0, -0.33333334, -0.33333334, 0, 0.6666667, 5, 6, 7};
ASSERT_EQ(0, CompareOutputData(output.data(), expect_output.data(), 8, 0.00001));
input0_tensor.set_data(nullptr);
output0_tensor.set_data(nullptr);
delete kernel;
}
TEST_F(TestActivationFp32, HardTanh1) {
std::vector<lite::Tensor *> inputs_tensor;
std::vector<lite::Tensor *> outputs_tensor;
ActivationParameter op_param;
op_param.op_parameter_.type_ = schema::PrimitiveType_Activation;
op_param.type_ = schema::ActivationType_HARD_TANH;
op_param.min_val_ = -1.0f;
op_param.max_val_ = 1.0f;
std::vector<float> input = {-2.0, -1.0, -0.5, 0.0, 0.5, 1.0, 5.0, 6.0};
std::vector<int> in_shape = {8};
lite::Tensor input0_tensor;
inputs_tensor.push_back(&input0_tensor);
input0_tensor.set_data(input.data());
input0_tensor.set_shape(in_shape);
std::vector<float> output(8);
std::vector<int> output_shape = {8};
lite::Tensor output0_tensor;
outputs_tensor.push_back(&output0_tensor);
output0_tensor.set_data(output.data());
kernel::KernelKey desc = {kernel::KERNEL_ARCH::kCPU, kNumberTypeFloat32, schema::PrimitiveType_Activation};
auto creator = lite::KernelRegistry::GetInstance()->GetCreator(desc);
ASSERT_NE(creator, nullptr);
lite::InnerContext ctx;
ctx.thread_num_ = 2;
ASSERT_EQ(lite::RET_OK, ctx.Init());
auto *kernel = creator(inputs_tensor, outputs_tensor, reinterpret_cast<OpParameter *>(&op_param), &ctx, desc);
ASSERT_NE(kernel, nullptr);
auto output_tensor_shape = output0_tensor.shape();
auto ret = kernel->Prepare();
EXPECT_EQ(0, ret);
ret = kernel->Run();
EXPECT_EQ(0, ret);
std::vector<float> expect_output = {-1.0, -1.0, -0.5, 0.0, 0.5, 1.0, 1.0, 1.0};
ASSERT_EQ(0, CompareOutputData(output.data(), expect_output.data(), 8, 0.00001));
input0_tensor.set_data(nullptr);
output0_tensor.set_data(nullptr);
delete kernel;
}
TEST_F(TestActivationFp32, HardTanh2) {
std::vector<lite::Tensor *> inputs_tensor;
std::vector<lite::Tensor *> outputs_tensor;
ActivationParameter op_param;
op_param.op_parameter_.type_ = schema::PrimitiveType_Activation;
op_param.type_ = schema::ActivationType_HARD_TANH;
op_param.min_val_ = -2.0f;
op_param.max_val_ = 2.0f;
std::vector<float> input = {-3.0, -2.0, -1.0, 0.0, 1.0, 5.0, 6.0, 7.0};
std::vector<int> in_shape = {8};
lite::Tensor input0_tensor;
inputs_tensor.push_back(&input0_tensor);
input0_tensor.set_data(input.data());
input0_tensor.set_shape(in_shape);
std::vector<float> output(8);
std::vector<int> output_shape = {8};
lite::Tensor output0_tensor;
outputs_tensor.push_back(&output0_tensor);
output0_tensor.set_data(output.data());
kernel::KernelKey desc = {kernel::KERNEL_ARCH::kCPU, kNumberTypeFloat32, schema::PrimitiveType_Activation};
auto creator = lite::KernelRegistry::GetInstance()->GetCreator(desc);
ASSERT_NE(creator, nullptr);
lite::InnerContext ctx;
ctx.thread_num_ = 2;
ASSERT_EQ(lite::RET_OK, ctx.Init());
auto *kernel = creator(inputs_tensor, outputs_tensor, reinterpret_cast<OpParameter *>(&op_param), &ctx, desc);
ASSERT_NE(kernel, nullptr);
auto output_tensor_shape = output0_tensor.shape();
auto ret = kernel->Prepare();
EXPECT_EQ(0, ret);
ret = kernel->Run();
EXPECT_EQ(0, ret);
std::vector<float> expect_output = {-2.0, -2.0, -1.0, 0.0, 1.0, 2.0, 2.0, 2.0};
ASSERT_EQ(0, CompareOutputData(output.data(), expect_output.data(), 8, 0.00001));
input0_tensor.set_data(nullptr);
output0_tensor.set_data(nullptr);
delete kernel;
}
TEST_F(TestActivationFp32, Softplus) {
std::vector<lite::Tensor *> inputs_tensor;
std::vector<lite::Tensor *> outputs_tensor;
ActivationParameter op_param;
op_param.op_parameter_.type_ = schema::PrimitiveType_Activation;
op_param.type_ = schema::ActivationType_SOFTPLUS;
std::vector<float> input = {1, 2, 3, 4, 5, -1, 6, 7, -10, -20, 20, 30, 14, 0};
std::vector<int> in_shape = {14};
lite::Tensor input0_tensor;
inputs_tensor.push_back(&input0_tensor);
input0_tensor.set_data(input.data());
input0_tensor.set_shape(in_shape);
std::vector<float> output(14);
std::vector<int> output_shape = {14};
lite::Tensor output0_tensor;
outputs_tensor.push_back(&output0_tensor);
output0_tensor.set_data(output.data());
kernel::KernelKey desc = {kernel::KERNEL_ARCH::kCPU, kNumberTypeFloat32, schema::PrimitiveType_Activation};
auto creator = lite::KernelRegistry::GetInstance()->GetCreator(desc);
ASSERT_NE(creator, nullptr);
lite::InnerContext ctx;
ctx.thread_num_ = 2;
ASSERT_EQ(lite::RET_OK, ctx.Init());
auto *kernel = creator(inputs_tensor, outputs_tensor, reinterpret_cast<OpParameter *>(&op_param), &ctx, desc);
ASSERT_NE(kernel, nullptr);
auto output_tensor_shape = output0_tensor.shape();
auto ret = kernel->Prepare();
EXPECT_EQ(0, ret);
ret = kernel->Run();
EXPECT_EQ(0, ret);
std::vector<float> expect_output = {1.3132616, 2.1269281, 3.0485871, 4.0181499, 5.0067153,
0.31326169, 6.0024757, 7.0009117, 0.0000453989, 0.0000000002,
20.00000000, 30.00000000, 14.0000000, 0.69314718};
ASSERT_EQ(0, CompareOutputData(output.data(), expect_output.data(), 14, 0.00001));
input0_tensor.set_data(nullptr);
output0_tensor.set_data(nullptr);
delete kernel;
}
} // namespace mindspore
| 4,077 |
432 | <gh_stars>100-1000
/*-
* Copyright (c) 2005 <NAME>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer,
* without modification.
* 2. Redistributions in binary form must reproduce at minimum a disclaimer
* similar to the "NO WARRANTY" disclaimer below ("Disclaimer") and any
* redistribution must be conditioned upon including a substantially
* similar Disclaimer requirement for further binary redistribution.
* 3. Neither the names of the above-listed copyright holders nor the names
* of any contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* Alternatively, this software may be distributed under the terms of the
* GNU General Public License ("GPL") version 2 as published by the Free
* Software Foundation.
*
* NO WARRANTY
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF NONINFRINGEMENT, MERCHANTABILITY
* AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
* THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY,
* OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
* IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGES.
*
* $FreeBSD$
*/
/*
* Defintions for the Atheros Wireless LAN controller driver.
*/
#ifndef _DEV_ATH_RATE_SAMPLE_H
#define _DEV_ATH_RATE_SAMPLE_H
/* per-device state */
struct sample_softc {
struct ath_ratectrl arc; /* base class */
int smoothing_rate; /* ewma percentage [0..99] */
int smoothing_minpackets;
int sample_rate; /* %time to try different tx rates */
int max_successive_failures;
int stale_failure_timeout; /* how long to honor max_successive_failures */
int min_switch; /* min time between rate changes */
int min_good_pct; /* min good percentage for a rate to be considered */
};
#define ATH_SOFTC_SAMPLE(sc) ((struct sample_softc *)sc->sc_rc)
struct rate_stats {
unsigned average_tx_time;
int successive_failures;
uint64_t tries;
uint64_t total_packets; /* pkts total since assoc */
uint64_t packets_acked; /* pkts acked since assoc */
int ewma_pct; /* EWMA percentage */
unsigned perfect_tx_time; /* transmit time for 0 retries */
int last_tx;
};
struct txschedule {
uint8_t t0, r0; /* series 0: tries, rate code */
uint8_t t1, r1; /* series 1: tries, rate code */
uint8_t t2, r2; /* series 2: tries, rate code */
uint8_t t3, r3; /* series 3: tries, rate code */
};
/*
* for now, we track performance for three different packet
* size buckets
*/
#define NUM_PACKET_SIZE_BINS 2
static const int packet_size_bins[NUM_PACKET_SIZE_BINS] = { 250, 1600 };
static inline int
bin_to_size(int index)
{
return packet_size_bins[index];
}
/* per-node state */
struct sample_node {
int static_rix; /* rate index of fixed tx rate */
#define SAMPLE_MAXRATES 64 /* NB: corresponds to hal info[32] */
uint64_t ratemask; /* bit mask of valid rate indices */
const struct txschedule *sched; /* tx schedule table */
const HAL_RATE_TABLE *currates;
struct rate_stats stats[NUM_PACKET_SIZE_BINS][SAMPLE_MAXRATES];
int last_sample_rix[NUM_PACKET_SIZE_BINS];
int current_sample_rix[NUM_PACKET_SIZE_BINS];
int packets_sent[NUM_PACKET_SIZE_BINS];
int current_rix[NUM_PACKET_SIZE_BINS];
int packets_since_switch[NUM_PACKET_SIZE_BINS];
unsigned ticks_since_switch[NUM_PACKET_SIZE_BINS];
int packets_since_sample[NUM_PACKET_SIZE_BINS];
unsigned sample_tt[NUM_PACKET_SIZE_BINS];
};
#ifdef _KERNEL
#define ATH_NODE_SAMPLE(an) ((struct sample_node *)&(an)[1])
#define IS_RATE_DEFINED(sn, rix) (((uint64_t)(sn)->ratemask & (1ULL<<((uint64_t) rix))) != 0)
#ifndef MIN
#define MIN(a,b) ((a) < (b) ? (a) : (b))
#endif
#ifndef MAX
#define MAX(a,b) ((a) > (b) ? (a) : (b))
#endif
#define WIFI_CW_MIN 31
#define WIFI_CW_MAX 1023
/*
* Calculate the transmit duration of a frame.
*/
static unsigned calc_usecs_unicast_packet(struct ath_softc *sc,
int length,
int rix, int short_retries,
int long_retries, int is_ht40)
{
const HAL_RATE_TABLE *rt = sc->sc_currates;
struct ieee80211com *ic = &sc->sc_ic;
int rts, cts;
unsigned t_slot = 20;
unsigned t_difs = 50;
unsigned t_sifs = 10;
int tt = 0;
int x = 0;
int cw = WIFI_CW_MIN;
int cix;
KASSERT(rt != NULL, ("no rate table, mode %u", sc->sc_curmode));
if (rix >= rt->rateCount) {
kprintf("bogus rix %d, max %u, mode %u\n",
rix, rt->rateCount, sc->sc_curmode);
return 0;
}
cix = rt->info[rix].controlRate;
/*
* XXX getting mac/phy level timings should be fixed for turbo
* rates, and there is probably a way to get this from the
* hal...
*/
switch (rt->info[rix].phy) {
case IEEE80211_T_OFDM:
t_slot = 9;
t_sifs = 16;
t_difs = 28;
/* fall through */
case IEEE80211_T_TURBO:
t_slot = 9;
t_sifs = 8;
t_difs = 28;
break;
case IEEE80211_T_HT:
t_slot = 9;
t_sifs = 8;
t_difs = 28;
break;
case IEEE80211_T_DS:
/* fall through to default */
default:
/* pg 205 ieee.802.11.pdf */
t_slot = 20;
t_difs = 50;
t_sifs = 10;
}
rts = cts = 0;
if ((ic->ic_flags & IEEE80211_F_USEPROT) &&
rt->info[rix].phy == IEEE80211_T_OFDM) {
if (ic->ic_protmode == IEEE80211_PROT_RTSCTS)
rts = 1;
else if (ic->ic_protmode == IEEE80211_PROT_CTSONLY)
cts = 1;
cix = rt->info[sc->sc_protrix].controlRate;
}
if (0 /*length > ic->ic_rtsthreshold */) {
rts = 1;
}
if (rts || cts) {
int ctsrate;
int ctsduration = 0;
/* NB: this is intentionally not a runtime check */
KASSERT(cix < rt->rateCount,
("bogus cix %d, max %u, mode %u\n", cix, rt->rateCount,
sc->sc_curmode));
ctsrate = rt->info[cix].rateCode | rt->info[cix].shortPreamble;
if (rts) /* SIFS + CTS */
ctsduration += rt->info[cix].spAckDuration;
/* XXX assumes short preamble */
ctsduration += ath_hal_pkt_txtime(sc->sc_ah, rt, length, rix,
is_ht40, 0);
if (cts) /* SIFS + ACK */
ctsduration += rt->info[cix].spAckDuration;
tt += (short_retries + 1) * ctsduration;
}
tt += t_difs;
/* XXX assumes short preamble */
tt += (long_retries+1)*ath_hal_pkt_txtime(sc->sc_ah, rt, length, rix,
is_ht40, 0);
tt += (long_retries+1)*(t_sifs + rt->info[rix].spAckDuration);
for (x = 0; x <= short_retries + long_retries; x++) {
cw = MIN(WIFI_CW_MAX, (cw + 1) * 2);
tt += (t_slot * cw/2);
}
return tt;
}
#endif /* _KERNEL */
#endif /* _DEV_ATH_RATE_SAMPLE_H */
| 2,810 |
1,091 | <reponame>meodaiduoi/onos<gh_stars>1000+
/*
* Copyright 2016-present Open Networking Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.onosproject.cluster.impl;
import com.google.common.base.Objects;
import com.google.common.collect.Maps;
import org.onosproject.cluster.ClusterService;
import org.onosproject.cluster.Leadership;
import org.onosproject.cluster.LeadershipAdminService;
import org.onosproject.cluster.LeadershipEvent;
import org.onosproject.cluster.LeadershipEventListener;
import org.onosproject.cluster.LeadershipService;
import org.onosproject.cluster.LeadershipStore;
import org.onosproject.cluster.LeadershipStoreDelegate;
import org.onosproject.cluster.NodeId;
import org.onosproject.event.AbstractListenerManager;
import org.osgi.service.component.annotations.Activate;
import org.osgi.service.component.annotations.Component;
import org.osgi.service.component.annotations.Deactivate;
import org.osgi.service.component.annotations.Reference;
import org.osgi.service.component.annotations.ReferenceCardinality;
import org.slf4j.Logger;
import java.util.Map;
import java.util.Set;
import static org.slf4j.LoggerFactory.getLogger;
/**
* Implementation of {@link LeadershipService} and {@link LeadershipAdminService}.
*/
@Component(immediate = true, service = {LeadershipService.class, LeadershipAdminService.class})
public class LeadershipManager
extends AbstractListenerManager<LeadershipEvent, LeadershipEventListener>
implements LeadershipService, LeadershipAdminService {
private final Logger log = getLogger(getClass());
private LeadershipStoreDelegate delegate = this::post;
@Reference(cardinality = ReferenceCardinality.MANDATORY)
protected ClusterService clusterService;
@Reference(cardinality = ReferenceCardinality.MANDATORY)
protected LeadershipStore store;
private NodeId localNodeId;
@Activate
public void activate() {
localNodeId = clusterService.getLocalNode().id();
store.setDelegate(delegate);
eventDispatcher.addSink(LeadershipEvent.class, listenerRegistry);
log.info("Started");
}
@Deactivate
public void deactivate() {
Maps.filterValues(store.getLeaderships(), v -> v.candidates().contains(localNodeId))
.keySet()
.forEach(this::withdraw);
store.unsetDelegate(delegate);
eventDispatcher.removeSink(LeadershipEvent.class);
log.info("Stopped");
}
@Override
public Leadership getLeadership(String topic) {
return store.getLeadership(topic);
}
@Override
public Set<String> ownedTopics(NodeId nodeId) {
return Maps.filterValues(store.getLeaderships(), v -> Objects.equal(nodeId, v.leaderNodeId())).keySet();
}
@Override
public Leadership runForLeadership(String topic) {
return store.addRegistration(topic);
}
@Override
public void withdraw(String topic) {
store.removeRegistration(topic);
}
@Override
public Map<String, Leadership> getLeaderBoard() {
return store.getLeaderships();
}
@Override
public boolean transferLeadership(String topic, NodeId to) {
return store.moveLeadership(topic, to);
}
@Override
public void unregister(NodeId nodeId) {
store.removeRegistration(nodeId);
}
@Override
public boolean promoteToTopOfCandidateList(String topic, NodeId nodeId) {
return store.makeTopCandidate(topic, nodeId);
}
}
| 1,316 |
5,079 | <gh_stars>1000+
# Revert field drop to keep the DB backward compatible with old Hue
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('axes', '0005_remove_accessattempt_trusted'),
]
operations = [
migrations.AddField(
model_name='accessattempt',
name='trusted',
field=models.BooleanField(db_index=True, default=False),
),
]
| 196 |
335 | <gh_stars>100-1000
package com.pgexercises.monitor;
import org.junit.Assert;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import java.net.URISyntaxException;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.regex.Pattern;
@SuppressWarnings("ConstantConditions")
public class UtilsTest {
@Rule
public ExpectedException expectedEx = ExpectedException.none();
@Test
public void testGoodBasicUri() throws URISyntaxException {
Assert.assertEquals("https://pgexercises.com", Utils.buildUri("https://pgexercises.com", Map.of()).toString());
}
@Test (expected = URISyntaxException.class)
public void testBadBasicUri() throws URISyntaxException {
Utils.buildUri("https://pgexercises.com[][][]", Map.of());
}
@SuppressWarnings("argument.type.incompatible")
@Test (expected = NullPointerException.class)
public void testNullParamsUri() throws URISyntaxException {
Utils.buildUri(null, null);
}
@Test
public void testParamsUri() throws URISyntaxException {
Assert.assertEquals("https://pgexercises.com?a=a", Utils.buildUri("https://pgexercises.com", new TreeMap(Map.of("a","a"))).toString());
}
@SuppressWarnings("argument.type.incompatible")
@Test (expected = NullPointerException.class)
public void testGetMatchesFromPageNullParams() throws Exception {
Utils.getMatchesFromPage(null, null, null);
}
@Test
public void testGetMatchesFromPage() throws Exception {
List<String> matches = Utils.getMatchesFromPage("test\ntest1:'data',test1:'data2',\ntest2", Pattern.compile("test1:'([a-z0-9]*)'"), "p");
Assert.assertEquals(List.of("pdata", "pdata2"), matches);
}
@SuppressWarnings("argument.type.incompatible")
@Test (expected = NullPointerException.class)
public void testGetSingleMatchFromPageNullParams() throws Exception {
Utils.getSingleMatchFromPage(null, null);
}
@Test
public void testGetSingleMatchFromPage() throws Exception {
String match = Utils.getSingleMatchFromPage("test\ntest1:'data',\ntest2", Pattern.compile("test1:'([a-z0-9]*)'"));
Assert.assertEquals("data", match);
}
@Test
public void testGetSingleMatchFromPageTooMany() throws Exception {
expectedEx.expectMessage("Expected match size of 1, got 2");
String match = Utils.getSingleMatchFromPage("test\ntest1:'data',test1:'data2',\ntest2", Pattern.compile("test1:'([a-z0-9]*)'"));
Assert.assertEquals("data", match);
}
}
| 988 |
10,225 | package io.quarkus.smallrye.reactivemessaging.signatures;
import static org.assertj.core.api.Assertions.assertThat;
import static org.awaitility.Awaitility.await;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import javax.enterprise.context.ApplicationScoped;
import javax.inject.Inject;
import org.eclipse.microprofile.reactive.messaging.Incoming;
import org.eclipse.microprofile.reactive.messaging.Outgoing;
import org.jboss.shrinkwrap.api.ShrinkWrap;
import org.jboss.shrinkwrap.api.spec.JavaArchive;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.RegisterExtension;
import org.reactivestreams.Publisher;
import io.quarkus.test.QuarkusUnitTest;
import io.smallrye.mutiny.Multi;
public class IncomingsTest {
@RegisterExtension
static final QuarkusUnitTest config = new QuarkusUnitTest()
.setArchiveProducer(() -> ShrinkWrap.create(JavaArchive.class)
.addClasses(ProducerOnA.class, ProducerOnB.class, MyBeanUsingMultipleIncomings.class));
@Inject
MyBeanUsingMultipleIncomings bean;
@Test
public void testIncomingsWithTwoSources() {
await().until(() -> bean.list().size() == 6);
assertThat(bean.list()).containsSubsequence("a", "b", "c");
assertThat(bean.list()).containsSubsequence("d", "e", "f");
}
@ApplicationScoped
public static class ProducerOnA {
@Outgoing("a")
public Publisher<String> produce() {
return Multi.createFrom().items("a", "b", "c");
}
}
@ApplicationScoped
public static class ProducerOnB {
@Outgoing("b")
public Publisher<String> produce() {
return Multi.createFrom().items("d", "e", "f");
}
}
@ApplicationScoped
public static class MyBeanUsingMultipleIncomings {
private final List<String> list = new CopyOnWriteArrayList<>();
@Incoming("a")
@Incoming("b")
public void consume(String s) {
list.add(s);
}
public List<String> list() {
return list;
}
}
}
| 853 |
1,467 | {
"version": "2.16.45",
"date": "2021-04-21",
"entries": [
{
"type": "feature",
"category": "AWSKendraFrontendService",
"contributor": "",
"description": "Amazon Kendra now enables users to override index-level boosting configurations for each query."
},
{
"type": "feature",
"category": "DynamoDB Enhanced Client",
"contributor": "",
"description": "Added method to BatchGetItem results to retrieve unprocessed keys for a given table."
},
{
"type": "feature",
"category": "AWS Ground Station",
"contributor": "",
"description": "Support new S3 Recording Config allowing customers to write downlink data directly to S3."
},
{
"type": "feature",
"category": "Amazon Redshift",
"contributor": "",
"description": "Add operations: AddPartner, DescribePartners, DeletePartner, and UpdatePartnerStatus to support tracking integration status with data partners."
},
{
"type": "feature",
"category": "AWS CloudFormation",
"contributor": "",
"description": "Added support for creating and updating stack sets with self-managed permissions from templates that reference macros."
},
{
"type": "feature",
"category": "Amazon Detective",
"contributor": "",
"description": "Added parameters to track the data volume in bytes for a member account. Deprecated the existing parameters that tracked the volume as a percentage of the allowed volume for a behavior graph. Changes reflected in MemberDetails object."
}
]
} | 745 |
432 | /*-
* Copyright (c) 2008-2010 <NAME> <<EMAIL>>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD: src/tools/regression/lib/msun/test-logarithm.c,v 1.3 2011/10/15 05:28:13 das Exp $
*/
/*
* Tests for corner cases in log*().
*/
#include <assert.h>
#include <fenv.h>
#include <float.h>
#include <math.h>
#include <stdio.h>
#ifdef __i386__
#include <ieeefp.h>
#endif
#define ALL_STD_EXCEPT (FE_DIVBYZERO | FE_INEXACT | FE_INVALID | \
FE_OVERFLOW | FE_UNDERFLOW)
#pragma STDC FENV_ACCESS ON
/*
* Test that a function returns the correct value and sets the
* exception flags correctly. The exceptmask specifies which
* exceptions we should check. We need to be lenient for several
* reasoons, but mainly because on some architectures it's impossible
* to raise FE_OVERFLOW without raising FE_INEXACT.
*
* These are macros instead of functions so that assert provides more
* meaningful error messages.
*
* XXX The volatile here is to avoid gcc's bogus constant folding and work
* around the lack of support for the FENV_ACCESS pragma.
*/
#define test(func, x, result, exceptmask, excepts) do { \
volatile long double _d = x; \
assert(feclearexcept(FE_ALL_EXCEPT) == 0); \
assert(fpequal((func)(_d), (result))); \
assert(((func), fetestexcept(exceptmask) == (excepts))); \
} while (0)
/* Test all the functions that compute log(x). */
#define testall0(x, result, exceptmask, excepts) do { \
test(log, x, result, exceptmask, excepts); \
test(logf, x, result, exceptmask, excepts); \
test(log2, x, result, exceptmask, excepts); \
test(log2f, x, result, exceptmask, excepts); \
test(log10, x, result, exceptmask, excepts); \
test(log10f, x, result, exceptmask, excepts); \
} while (0)
/* Test all the functions that compute log(1+x). */
#define testall1(x, result, exceptmask, excepts) do { \
test(log1p, x, result, exceptmask, excepts); \
test(log1pf, x, result, exceptmask, excepts); \
} while (0)
/*
* Determine whether x and y are equal, with two special rules:
* +0.0 != -0.0
* NaN == NaN
*/
int
fpequal(long double x, long double y)
{
return ((x == y && !signbit(x) == !signbit(y)) || isnan(x) && isnan(y));
}
void
run_generic_tests(void)
{
/* log(1) == 0, no exceptions raised */
testall0(1.0, 0.0, ALL_STD_EXCEPT, 0);
testall1(0.0, 0.0, ALL_STD_EXCEPT, 0);
testall1(-0.0, -0.0, ALL_STD_EXCEPT, 0);
/* log(NaN) == NaN, no exceptions raised */
testall0(NAN, NAN, ALL_STD_EXCEPT, 0);
testall1(NAN, NAN, ALL_STD_EXCEPT, 0);
/* log(Inf) == Inf, no exceptions raised */
testall0(INFINITY, INFINITY, ALL_STD_EXCEPT, 0);
testall1(INFINITY, INFINITY, ALL_STD_EXCEPT, 0);
/* log(x) == NaN for x < 0, invalid exception raised */
testall0(-INFINITY, NAN, ALL_STD_EXCEPT, FE_INVALID);
testall1(-INFINITY, NAN, ALL_STD_EXCEPT, FE_INVALID);
testall0(-1.0, NAN, ALL_STD_EXCEPT, FE_INVALID);
testall1(-1.5, NAN, ALL_STD_EXCEPT, FE_INVALID);
/* log(0) == -Inf, divide-by-zero exception */
testall0(0.0, -INFINITY, ALL_STD_EXCEPT & ~FE_INEXACT, FE_DIVBYZERO);
testall0(-0.0, -INFINITY, ALL_STD_EXCEPT & ~FE_INEXACT, FE_DIVBYZERO);
testall1(-1.0, -INFINITY, ALL_STD_EXCEPT & ~FE_INEXACT, FE_DIVBYZERO);
}
void
run_log2_tests(void)
{
int i;
/*
* We should insist that log2() return exactly the correct
* result and not raise an inexact exception for powers of 2.
*/
feclearexcept(FE_ALL_EXCEPT);
for (i = FLT_MIN_EXP - FLT_MANT_DIG; i < FLT_MAX_EXP; i++) {
assert(log2f(ldexpf(1.0, i)) == i);
assert(fetestexcept(ALL_STD_EXCEPT) == 0);
}
for (i = DBL_MIN_EXP - DBL_MANT_DIG; i < DBL_MAX_EXP; i++) {
assert(log2(ldexp(1.0, i)) == i);
assert(fetestexcept(ALL_STD_EXCEPT) == 0);
}
}
void
run_roundingmode_tests(void)
{
/*
* Corner cases in other rounding modes.
*/
fesetround(FE_DOWNWARD);
/* These are still positive per IEEE 754R */
testall0(1.0, 0.0, ALL_STD_EXCEPT, 0);
testall1(0.0, 0.0, ALL_STD_EXCEPT, 0);
fesetround(FE_TOWARDZERO);
testall0(1.0, 0.0, ALL_STD_EXCEPT, 0);
testall1(0.0, 0.0, ALL_STD_EXCEPT, 0);
fesetround(FE_UPWARD);
testall0(1.0, 0.0, ALL_STD_EXCEPT, 0);
testall1(0.0, 0.0, ALL_STD_EXCEPT, 0);
/* log1p(-0.0) == -0.0 even when rounding upwards */
testall1(-0.0, -0.0, ALL_STD_EXCEPT, 0);
fesetround(FE_TONEAREST);
}
int
main(int argc, char *argv[])
{
printf("1..3\n");
run_generic_tests();
printf("ok 1 - logarithm\n");
run_log2_tests();
printf("ok 2 - logarithm\n");
run_roundingmode_tests();
printf("ok 3 - logarithm\n");
return (0);
}
| 2,270 |
488 | <reponame>maurizioabba/rose
void AEInterpC( double ( *userrng )( void * ), void *rngstate )
{
int nBins;
double EOutAlph;
EOutAlph = nBins*( *userrng )( rngstate );
return;
}
| 84 |
536 | <reponame>HelloCoCooo/hangout
package com.ctrip.ops.sysdev.filters;
import com.ctrip.ops.sysdev.baseplugin.BaseOutput;
import lombok.extern.log4j.Log4j2;
import org.joda.time.DateTime;
import java.util.*;
import com.ctrip.ops.sysdev.baseplugin.BaseFilter;
@Log4j2
public class LinkMetric extends BaseFilter {
int reserveWindow;
int batchWindow;
String timestamp;
String fieldsLink;
String[] fields;
Map<Long, Object> metric;
Map<Long, Object> metricToEmit;
long lastEmitTime;
public LinkMetric(Map config) {
super(config);
}
protected void prepare() {
this.processExtraEventsFunc = true;
if (!config.containsKey("fieldsLink")) {
log.fatal("fieldsLink must be included in config");
System.exit(4);
}
this.fieldsLink = (String) config.get("fieldsLink");
if (!config.containsKey("timestamp")) {
this.timestamp = null;
}
this.timestamp = (String) config.get("timestamp");
this.fields = this.fieldsLink.split("->");
if (this.fields.length <= 1) {
log.fatal("fieldsLink should contain at least 2 fields");
System.exit(4);
}
if (!config.containsKey("reserveWindow")) {
log.fatal("reserveWindow must be included in config");
System.exit(4);
}
this.reserveWindow = (int) config.get("reserveWindow") * 1000;
if (!config.containsKey("batchWindow")) {
log.fatal("batchWindow must be included in config");
System.exit(4);
}
this.batchWindow = (int) config.get("batchWindow") * 1000;
this.metric = new HashMap();
this.metricToEmit = new HashMap();
this.lastEmitTime = System.currentTimeMillis();
}
@Override
protected Map filter(final Map event) {
if (System.currentTimeMillis() >= this.batchWindow + this.lastEmitTime) {
this.metricToEmit = this.metric;
this.metric = new HashMap();
this.metricToEmit.forEach((timestamp, s) -> {
this.metricToEvents((Map) s, 0).forEach((Map<String, Object> e) -> {
e.put(this.timestamp, timestamp);
this.postProcess(e, true);
if (this.nextFilter != null) {
e = this.nextFilter.process(e);
} else {
for (BaseOutput o : this.outputs
) {
o.process(e);
}
}
});
});
this.metricToEmit.clear();
this.lastEmitTime = System.currentTimeMillis();
}
long timestamp = System.currentTimeMillis();
if (this.timestamp != null) {
Object o = event.get(this.timestamp);
if (o != null && o.getClass() == DateTime.class) {
timestamp = ((DateTime) o).getMillis();
} else {
log.debug("timestamp is not instaceof Datetime. use currentTimeMillis");
}
}
if (System.currentTimeMillis() >= this.reserveWindow + timestamp) {
return event;
}
timestamp -= timestamp % this.batchWindow;
Map set;
if (this.metric.containsKey(timestamp)) {
set = (Map) this.metric.get(timestamp);
} else {
set = new HashMap<>();
this.metric.put(timestamp, set);
}
for (String field : this.fields) {
if (event.containsKey(field)) {
String v = event.get(field).toString();
if (set.containsKey(v)) {
set = (Map) set.get(v);
set.put("count", 1 + (long) set.get("count"));
} else {
Map o = new HashMap<String, Object>() {{
this.put("count", 1l);
}};
set.put(v, o);
set = o;
}
}
}
return event;
}
private List<Map<String, Object>> metricToEvents(Map metric, int level) {
String field = this.fields[level];
List<Map<String, Object>> rst = new ArrayList<>();
if (level + 1 == this.fields.length) {
metric.forEach((k, v) -> {
if (k.toString().contentEquals("count")) {
return;
}
Map<String, Object> event = new HashMap();
event.put(field, k);
event.put("count", ((Map) v).get("count"));
rst.add(event);
});
return rst;
}
metric.forEach((k, set) -> {
if (k.toString().contentEquals("count")) {
return;
}
this.metricToEvents((Map) set, level + 1).forEach((Map<String, Object> e) -> {
Map<String, Object> event = new HashMap();
event.put(field, k);
event.putAll(e);
rst.add(event);
});
});
return rst;
}
public List<Map<String, Object>> filterExtraEvents(Map event) {
if (metricToEmit.size() == 0) {
return null;
}
List<Map<String, Object>> events = new ArrayList();
this.metricToEmit.forEach((timestamp, s) -> {
this.metricToEvents((Map) s, 0).forEach((Map<String, Object> e) -> {
e.put(this.timestamp, timestamp);
this.postProcess(e, true);
events.add(e);
});
});
this.metricToEmit.clear();
this.lastEmitTime = System.currentTimeMillis();
return events;
}
}
| 2,968 |
587 | /*#######################################################################################
Copyright (c) 2017-2019 Kasugaccho
Copyright (c) 2018-2019 As Project
https://github.com/Kasugaccho/DungeonTemplateLibrary
<EMAIL>
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#######################################################################################*/
#ifndef INCLUDED_DUNGEON_TEMPLATE_LIBRARY_DTL_SHAPE_MAZE_DIG_HPP
#define INCLUDED_DUNGEON_TEMPLATE_LIBRARY_DTL_SHAPE_MAZE_DIG_HPP
/*#######################################################################################
日本語リファレンス (Reference-JP)
https://github.com/Kasugaccho/DungeonTemplateLibrary/wiki/dtl::shape::MazeDig-(形状クラス)/
#######################################################################################*/
#include <DTL/Base/Struct.hpp>
#include <DTL/Macros/constexpr.hpp>
#include <DTL/Macros/nodiscard.hpp>
#include <DTL/Random/RandomEngine.hpp>
#include <DTL/Range/RectBaseMaze.hpp>
#include <DTL/Type/Forward.hpp>
#include <DTL/Type/New.hpp>
#include <DTL/Type/SizeT.hpp>
#include <DTL/Type/SSizeT.hpp>
#include <DTL/Type/UniquePtr.hpp>
#include <DTL/Utility/DrawJaggedRandom.hpp>
/*#######################################################################################
[概要] "dtl名前空間"とは"DungeonTemplateLibrary"の全ての機能が含まれる名前空間である。
[Summary] The "dtl" is a namespace that contains all the functions of "DungeonTemplateLibrary".
#######################################################################################*/
namespace dtl {
inline namespace shape { //"dtl::shape"名前空間に属する
/*#######################################################################################
[概要] MazeDigとは "Matrixの描画範囲に描画値を設置する" 機能を持つクラスである。
[Summary] MazeDig is a class that sets drawing values in the drawing range of Matrix.
#######################################################################################*/
template<typename Matrix_Var_, typename Random_Engine_ = DTL_RANDOM_DEFAULT_RANDOM, typename UniquePtr_ = DTL_TYPE_UNIQUE_PTR<::dtl::type::size[]>>
class MazeDig : public ::dtl::range::RectBaseMaze<MazeDig<Matrix_Var_>, Matrix_Var_>,
public ::dtl::utility::DrawJaggedRandom<MazeDig<Matrix_Var_>, Matrix_Var_, Random_Engine_> {
private:
///// エイリアス (Alias) /////
using Index_Size = ::dtl::type::size;
using ShapeBase_t = ::dtl::range::RectBaseMaze<MazeDig, Matrix_Var_>;
using DrawBase_t = ::dtl::utility::DrawJaggedRandom<MazeDig, Matrix_Var_, Random_Engine_>;
friend DrawBase_t;
//穴掘り
template<typename Matrix_, typename ...Args_>
DTL_VERSIONING_CPP14_CONSTEXPR
void mazeDig_Dig(Matrix_&& matrix_, Random_Engine_& random_engine_, const ::dtl::type::size j_max, const ::dtl::type::size i_max, ::dtl::type::size x_, ::dtl::type::size y_, Args_&& ... args_) const noexcept {
::dtl::type::ssize dx{}, dy{};
for (::dtl::type::size random{ static_cast<::dtl::type::size>(random_engine_.get()) }, counter{}; counter < 4;) {
switch ((random + counter) & 3) {
case 0:dx = 0; dy = -2; break;
case 1:dx = -2; dy = 0; break;
case 2:dx = 0; dy = 2; break;
case 3:dx = 2; dy = 0; break;
default:dx = 0; dy = 0; break;
}
if (static_cast<::dtl::type::ssize>(x_ + dx) <= static_cast<::dtl::type::ssize>(this->start_x) ||
static_cast<::dtl::type::ssize>(y_ + dy) <= static_cast<::dtl::type::ssize>(this->start_y) ||
(x_ + dx) >= j_max || (y_ + dy) >= i_max || static_cast<Matrix_Var_>(matrix_.get(x_ + dx, y_ + dy)) == this->empty_value) {
++counter;
}
else if (matrix_.get(x_ + dx, y_ + dy) == this->wall_value) {
matrix_.set(x_ + (dx / 2), y_ + (dy / 2), this->empty_value, args_...);
matrix_.set(x_ + dx, y_ + dy, this->empty_value, args_...);
x_ += dx;
y_ += dy;
counter = 0;
random = static_cast<::dtl::type::size>(random_engine_.get());
}
}
return;
}
//迷路生成
template<typename Matrix_>
DTL_VERSIONING_CPP14_CONSTEXPR
::dtl::type::size mazeDig_CreateLoop(Matrix_&& matrix_, const ::dtl::type::size j_max, const ::dtl::type::size i_max, UniquePtr_& select_x, UniquePtr_& select_y) const noexcept {
::dtl::type::size select_id{};
for (::dtl::type::size i{ this->start_y + 1 }; i < i_max; i += 2)
for (::dtl::type::size j{ this->start_x + 1 }; j < j_max; j += 2) {
if (matrix_.get(j, i) != this->empty_value) continue;
if ((i >= this->start_y + 2 && matrix_.get(j, i - 2) == this->wall_value) || (j >= this->start_x + 2 && matrix_.get(j - 2, i) == this->wall_value)) {
select_x[select_id] = j;
select_y[select_id] = i;
++select_id;
}
else if ((j >= j_max - 1) && (i >= i_max - 1)) break;
else if ((i + 2 < (i_max + 1) && matrix_.get(j, i + 2) == this->wall_value) || (j + 2 < (j_max + 1) && matrix_.get(j + 2, i) == this->wall_value)) {
select_x[select_id] = j;
select_y[select_id] = i;
++select_id;
}
}
return select_id;
}
///// 基本処理 /////
template<typename Matrix_, typename ...Args_>
DTL_VERSIONING_CPP14_CONSTEXPR
bool drawNormal(Matrix_&& matrix_, Random_Engine_&& random_engine_, Args_&& ... args_) const noexcept {
const Index_Size end_x_{ this->calcEndX(matrix_.getX()) };
const Index_Size end_y_{ this->calcEndY(matrix_.getY()) };
matrix_.set(this->start_x + 1, this->start_y + 1, this->empty_value, args_...);
UniquePtr_ select_x{ DTL_TYPE_NEW ::dtl::type::size[(end_x_ - this->start_x) * (end_y_ - this->start_y)] };
if (!select_x) return false;
UniquePtr_ select_y{ DTL_TYPE_NEW ::dtl::type::size[(end_x_ - this->start_x) * (end_y_ - this->start_y)] };
if (!select_y) return false;
const ::dtl::type::size i_max{ ((((end_y_ - this->start_y) & 1) == 0) ? end_y_ - 2 : end_y_ - 1) };
const ::dtl::type::size j_max{ ((((end_x_ - this->start_x) & 1) == 0) ? end_x_ - 2 : end_x_ - 1) };
//座標を選ぶ
for (::dtl::type::size select_id{};;) {
select_id = this->mazeDig_CreateLoop(matrix_, j_max, i_max, select_x, select_y);
if (select_id == 0) break;
select_id = static_cast<::dtl::type::size>(random_engine_.get(select_id));
this->mazeDig_Dig(matrix_, random_engine_, j_max, i_max, select_x[select_id], select_y[select_id], args_...);
}
return true;
}
public:
///// コンストラクタ (Constructor) /////
using ShapeBase_t::ShapeBase_t;
};
}
}
#endif //Included Dungeon Template Library | 2,778 |
1,068 | import numpy as np
import argparse
import os
import torch
from torch.utils.data import TensorDataset,DataLoader
from trainer import SvDklTrainer
from azureml.core import Run
parser = argparse.ArgumentParser()
parser.add_argument('--data-folder', type=str, dest='data_folder', help='data folder mounting point')
parser.add_argument('--batch-size', type=int, dest='batch_size', default=512, help='mini batch size for training')
parser.add_argument('--epochs', type=int, dest='epochs', default=100, help='number of epochs')
parser.add_argument('--neural-net-lr', type=float, dest='nn_lr', default=1e-2,help='Neural net learning rate')
parser.add_argument('--likelihood-lr', type=float, dest='lh_lr', default=1e-2,help='Likelihood learning rate')
parser.add_argument('--grid-size', type=int, dest='grid_size', default=64, help='grid size of each dimension')
parser.add_argument('--grid-bounds', type=tuple, dest='grid_bounds', default=(-1,1), help='bound of the grid')
parser.add_argument('--latent-dim', type=int, dest='latent_dim', default=2, help='dimensionality of latent space')
parser.add_argument('--num-mixtures', type=int, dest='num_mixtures', default=4, help='number of mixture components')
args = parser.parse_args()
data_folder = args.data_folder
print('data folder', data_folder)
X_train,y_train = torch.FloatTensor(np.load(os.path.join(data_folder,'X_train.npy'))), torch.FloatTensor(np.load(os.path.join(data_folder,'y_train.npy')))
X_test,y_test = torch.FloatTensor(np.load(os.path.join(data_folder,'X_test.npy'))), torch.FloatTensor(np.load(os.path.join(data_folder,'y_test.npy')))
print('Training set loaded',X_train.size(),y_train.size())
print('Test set loaded',X_test.size(),y_test.size())
grid_bounds = (-1,1) if args.grid_bounds == -1 else (0,1)
hyper_params = {'nn_lr':args.nn_lr,
'lh_lr':args.lh_lr,
'batch_size':args.batch_size,
'epochs':args.epochs,
'grid_size':args.grid_size,
'grid_bounds':grid_bounds,
'latent_dim':args.latent_dim,
'input_dim':X_train.size(1),
'num_mixtures':args.num_mixtures
}
train_dataloader = DataLoader(TensorDataset(X_train,y_train),
batch_size = hyper_params['batch_size'],
shuffle = True)
test_dataloader = DataLoader(TensorDataset(X_test,y_test),
batch_size = hyper_params['batch_size'],
shuffle = True)
# start training
SEED = 999
torch.manual_seed(SEED)
torch.backends.cudnn.deterministic = True
run = Run.get_context()
trainer = SvDklTrainer(hyper_params, aml_run=run)
trainer.fit(train_dataloader)
trainer.eval(test_dataloader)
| 1,161 |
832 | <gh_stars>100-1000
//
// DCFlashButton.h
// CDDScanningCode
//
// Created by 陈甸甸 on 2018/1/5.
//Copyright © 2018年 陈甸甸. All rights reserved.
//
#import <UIKit/UIKit.h>
@interface DCFlashButton : UIButton
@end
| 96 |
10,225 | package io.quarkus.arc.deployment;
import java.util.Set;
import org.jboss.jandex.DotName;
import org.jboss.jandex.IndexView;
import io.quarkus.builder.item.SimpleBuildItem;
/**
* Represent a Jandex {@link IndexView} on the whole deployment that has a complete CDI-related information.
* As such, this index should be used for any CDI-oriented work.
*
* Compared to {@link io.quarkus.deployment.builditem.CombinedIndexBuildItem} this index can contain additional classes
* that were indexed while bean discovery was in progress.
*
* It also holds information about all programmatically registered beans and all generated bean classes.
*
* @see GeneratedBeanBuildItem
* @see AdditionalBeanBuildItem
* @see io.quarkus.deployment.builditem.CombinedIndexBuildItem
*/
public final class BeanArchiveIndexBuildItem extends SimpleBuildItem {
private final IndexView index;
private final Set<DotName> generatedClassNames;
public BeanArchiveIndexBuildItem(IndexView index, Set<DotName> generatedClassNames) {
this.index = index;
this.generatedClassNames = generatedClassNames;
}
public IndexView getIndex() {
return index;
}
public Set<DotName> getGeneratedClassNames() {
return generatedClassNames;
}
}
| 401 |
1,350 | // Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
// Code generated by Microsoft (R) AutoRest Code Generator.
package com.azure.resourcemanager.customerinsights.fluent.models;
import com.azure.core.annotation.Immutable;
import com.azure.core.util.logging.ClientLogger;
import com.azure.resourcemanager.customerinsights.models.RelationshipsLookup;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import java.util.List;
/** The response of suggest relationship links operation. */
@Immutable
public final class SuggestRelationshipLinksResponseInner {
@JsonIgnore private final ClientLogger logger = new ClientLogger(SuggestRelationshipLinksResponseInner.class);
/*
* The interaction name.
*/
@JsonProperty(value = "interactionName", access = JsonProperty.Access.WRITE_ONLY)
private String interactionName;
/*
* Suggested relationships for the type.
*/
@JsonProperty(value = "suggestedRelationships", access = JsonProperty.Access.WRITE_ONLY)
private List<RelationshipsLookup> suggestedRelationships;
/**
* Get the interactionName property: The interaction name.
*
* @return the interactionName value.
*/
public String interactionName() {
return this.interactionName;
}
/**
* Get the suggestedRelationships property: Suggested relationships for the type.
*
* @return the suggestedRelationships value.
*/
public List<RelationshipsLookup> suggestedRelationships() {
return this.suggestedRelationships;
}
/**
* Validates the instance.
*
* @throws IllegalArgumentException thrown if the instance is not valid.
*/
public void validate() {
if (suggestedRelationships() != null) {
suggestedRelationships().forEach(e -> e.validate());
}
}
}
| 631 |
3,765 | /**
* BSD-style license; for more info see http://pmd.sourceforge.net/license.html
*/
package net.sourceforge.pmd.lang.java.ast;
import net.sourceforge.pmd.lang.java.ast.ASTAnyTypeDeclaration.TypeKind;
/**
* Marker interface for type body declarations, such as annotation members, field or method declarations.
*
* @author <NAME>
*/
public interface ASTAnyTypeBodyDeclaration extends JavaNode {
/**
* Returns the child of this declaration,
* which can be cast to a more specific node
* type using {@link #getKind()} as a cue.
*
* <p>Returns null if this is an empty declaration,
* that is, a single semicolon.
*/
JavaNode getDeclarationNode();
/**
* Gets the kind of declaration this node contains.
* This is a cue for the node type the child of this
* declaration can be cast to.
*/
DeclarationKind getKind();
/**
* Kind of declaration. This is not deprecated because the node will
* go away entirely in 7.0.0 and one cannot avoid using it on master.
* See {@link TypeKind} for the reasons for deprecation.
*/
enum DeclarationKind {
/** See {@link ASTInitializer}. */
INITIALIZER,
/** See {@link ASTConstructorDeclaration}. */
CONSTRUCTOR,
/** See {@link ASTMethodDeclaration}. */
METHOD,
/** See {@link ASTFieldDeclaration}. */
FIELD,
/** See {@link ASTAnnotationMethodDeclaration}. */
ANNOTATION_METHOD,
/** See {@link ASTClassOrInterfaceDeclaration}. */
CLASS,
/** See {@link ASTEnumDeclaration}. */
ENUM,
/** See {@link ASTClassOrInterfaceDeclaration}. */
INTERFACE,
/** See {@link ASTAnnotationTypeDeclaration}. */
ANNOTATION,
/** No child, {@link #getDeclarationNode()} will return null. */
EMPTY,
/** See {@link ASTRecordDeclaration}. */
RECORD,
/** See {@link ASTRecordConstructorDeclaration}. */
RECORD_CONSTRUCTOR
}
}
| 775 |
1,094 | <gh_stars>1000+
/**
* Copyright (c) 2015 <NAME> <<EMAIL>>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include "akumuli.h"
#include "akumuli_def.h"
#include <boost/date_time/posix_time/posix_time.hpp>
#include <chrono>
namespace Akumuli {
using aku_Duration = aku_Timestamp;
/** aku_TimeStamp is a main datatype to represent date-time values.
* It stores number of nanoseconds since epoch so it can fit u64 and doesn't prone to year 2038
* problem.
*/
//! Timestamp parsing error
struct BadDateTimeFormat : std::runtime_error {
BadDateTimeFormat(const char* str) : std::runtime_error(str) {}
};
//! Static utility class for date-time utility functions
struct DateTimeUtil {
static aku_Timestamp from_std_chrono(std::chrono::system_clock::time_point timestamp);
static aku_Timestamp from_boost_ptime(boost::posix_time::ptime timestamp);
static boost::posix_time::ptime to_boost_ptime(aku_Timestamp timestamp);
/** Convert ISO formatter timestamp to aku_Timestamp value.
* @note This function implements ISO 8601 partially compatible parser. Most of the standard is not
* supported yet - extended formatting (only basic format is supported), fractions on minutes or hours (
* like "20150102T1230.999"), timezones (values is treated as UTC time).
*/
static aku_Timestamp from_iso_string(const char* iso_str);
/** Convert timestamp to string.
*/
static int to_iso_string(aku_Timestamp ts, char* buffer, size_t buffer_size);
/** Parse time-duration from string
* @throw BadDateTimeFormat on error
*/
static aku_Duration parse_duration(const char* str, size_t size);
};
}
| 696 |
16,461 | //
// ABI42_0_0AIRMapWMSTileManager.h
// AirMaps
//
// Created by nizam on 10/28/18.
// Copyright © 2018. All rights reserved.
//
#import <ABI42_0_0React/ABI42_0_0RCTViewManager.h>
@interface ABI42_0_0AIRMapWMSTileManager : ABI42_0_0RCTViewManager
@end
| 117 |
965 | //
// This file is part of Easylogging++ samples
//
// Sample to show how to implement log rotate using easylogging++
// Thanks to Darren for efforts (http://darrendev.blogspot.com.au/)
//
// Compile: g++ -std=c++11 -Wall -Werror logrotate.cpp -lpthread -o logrotate -DELPP_THREAD_SAFE
//
// Revision 1.0
// @author Darren
//
#include <thread>
#define ELPP_NO_DEFAULT_LOG_FILE
#include "easylogging++.h"
INITIALIZE_EASYLOGGINGPP
int main(int,char**){
el::Loggers::configureFromGlobal("logrotate.conf");
LOG(INFO)<<"The program has started!";
std::thread logRotatorThread([](){
const std::chrono::seconds wakeUpDelta = std::chrono::seconds(20);
auto nextWakeUp = std::chrono::system_clock::now() + wakeUpDelta;
while(true){
std::this_thread::sleep_until(nextWakeUp);
nextWakeUp += wakeUpDelta;
LOG(INFO) << "About to rotate log file!";
auto L = el::Loggers::getLogger("default");
if(L == nullptr)LOG(ERROR)<<"Oops, it is not called default!";
else L->reconfigure();
}
});
logRotatorThread.detach();
//Main thread
for(int n = 0; n < 1000; ++n){
LOG(TRACE) << n;
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
LOG(INFO) << "Shutting down.";
return 0;
}
| 601 |
381 | from rpython.jit.backend.x86.test.test_basic import Jit386Mixin
from rpython.jit.metainterp.test import test_call
class TestCall(Jit386Mixin, test_call.CallTest):
# for the individual tests see
# ====> ../../../metainterp/test/test_call.py
pass
| 98 |
510 | /* Copyright 2019-2021 Canaan Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "../caffe_importer.h"
#include <functional>
#include <nncase/ir/ops/bitcast.h>
#include <nncase/ir/ops/constant.h>
#include <nncase/ir/ops/matmul.h>
#include <nncase/ir/ops/transpose.h>
using namespace nncase;
using namespace nncase::importer;
using namespace nncase::ir;
using namespace caffe;
DEFINE_CAFFE_LOWER(InnerProduct)
{
// check if there are bn/scale/relu above
std::string input_name = get_real_input_names(op)[0];
auto &input = *output_tensors_.at(input_name);
auto ¶m = op.inner_product_param();
auto op_data = get_op_data(op, caffemodel);
auto input_b = load_tensor<2>(op_data.blobs(0));
std::vector<float> input_b_vec(input_b.begin(), input_b.end());
auto input_b_const = graph_.emplace<constant>(dt_float32, get_shape(op_data.blobs(0).shape()), input_b_vec);
input_b_const->name(op.name() + "/input_b_const");
axis_t weights_axis = param.transpose() ? axis_t { 0, 1 } : axis_t { 1, 0 };
auto tp_pre = graph_.emplace<nncase::ir::transpose>(dt_float32, get_shape(op_data.blobs(0).shape()), weights_axis);
auto normalized_axis = param.axis() >= 0 ? param.axis() : (input.shape().size() + param.axis());
size_t flattend_shape_a = 1;
size_t flattend_shape_b = 1;
for (size_t i = 0; i < normalized_axis; i++)
{
flattend_shape_a *= input.shape()[i];
}
for (size_t i = normalized_axis; i < input.shape().size(); i++)
{
flattend_shape_b *= input.shape()[i];
}
auto bc_pre = graph_.emplace<bitcast>(dt_float32, input.shape(), dt_float32, shape_t { flattend_shape_a, flattend_shape_b });
auto node = graph_.emplace<matmul>(bc_pre->output().shape(), tp_pre->output().shape(), value_range<float>::full());
shape_t bc_post_shape;
for (size_t i = 0; i < normalized_axis; i++)
{
bc_post_shape.push_back(input.shape()[i]);
}
bc_post_shape.push_back(param.num_output());
auto bc_post = graph_.emplace<bitcast>(dt_float32, node->output().shape(), dt_float32, bc_post_shape);
node->name(op.name() + "/matmul");
input_tensors_.emplace(&bc_pre->input(), input_name);
node->input_a().connect(bc_pre->output());
tp_pre->input().connect(input_b_const->output());
node->input_b().connect(tp_pre->output());
bc_post->input().connect(node->output());
if (param.bias_term())
{
auto bias = load_tensor<1>(op_data.blobs(1));
std::vector<float> bias_vec(bias.begin(), bias.end());
auto bias_const = graph_.emplace<constant>(dt_float32, get_shape(op_data.blobs(1).shape()), bias_vec);
bias_const->name(op.name() + "/bias_const");
node->bias().connect(bias_const->output());
}
else
{
std::vector<float> bias_vec(tp_pre->output().shape()[1], 0);
auto bias_const = graph_.emplace<constant>(dt_float32, shape_t { bias_vec.size() }, bias_vec);
bias_const->name(op.name() + "/bias_const");
node->bias().connect(bias_const->output());
}
output_tensors_.emplace(op.top(0), &bc_post->output());
}
| 1,437 |
5,269 | <reponame>srbhr/supertokens-core
/*
* Copyright (c) 2021, VRAI Labs and/or its affiliates. All rights reserved.
*
* This software is licensed under the Apache License, Version 2.0 (the
* "License") as published by the Apache Software Foundation.
*
* You may not use this file except in compliance with the License. You may
* obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
package io.supertokens.test.session;
import com.google.gson.Gson;
import io.supertokens.session.accessToken.AccessToken;
import io.supertokens.session.jwt.JWT;
import io.supertokens.session.jwt.JWT.JWTException;
import io.supertokens.test.Utils;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TestRule;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SignatureException;
import java.security.spec.InvalidKeySpecException;
import static org.junit.Assert.*;
public class JWTTest {
@Rule
public TestRule watchman = Utils.getOnFailure();
@AfterClass
public static void afterTesting() {
Utils.afterTesting();
}
@Before
public void beforeEach() {
Utils.reset();
}
// good use case
@Test
public void validUsage() throws Exception {
{
TestInput input = new TestInput("value");
io.supertokens.utils.Utils.PubPriKey rsa = io.supertokens.utils.Utils.generateNewPubPriKey();
String token = JWT.createJWT(new Gson().toJsonTree(input), rsa.privateKey, AccessToken.VERSION.V1);
TestInput output = new Gson().fromJson(JWT.verifyJWTAndGetPayload(token, rsa.publicKey).payload,
TestInput.class);
assertEquals(input, output);
}
{
TestInput input = new TestInput("value");
io.supertokens.utils.Utils.PubPriKey rsa = io.supertokens.utils.Utils.generateNewPubPriKey();
String token = JWT.createJWT(new Gson().toJsonTree(input), rsa.privateKey, AccessToken.VERSION.V2);
TestInput output = new Gson().fromJson(JWT.verifyJWTAndGetPayload(token, rsa.publicKey).payload,
TestInput.class);
assertEquals(input, output);
}
}
// wrong signature error
@Test
public void wrongSignatureUsage() throws Exception {
{
TestInput input = new TestInput("value");
io.supertokens.utils.Utils.PubPriKey rsa = io.supertokens.utils.Utils.generateNewPubPriKey();
String token = JWT.createJWT(new Gson().toJsonTree(input), rsa.privateKey, AccessToken.VERSION.V1);
try {
JWT.verifyJWTAndGetPayload(token, "signingKey2");
fail();
} catch (JWTException e) {
assertEquals("JWT verification failed", e.getMessage());
}
}
{
TestInput input = new TestInput("value");
io.supertokens.utils.Utils.PubPriKey rsa = io.supertokens.utils.Utils.generateNewPubPriKey();
String token = JWT.createJWT(new Gson().toJsonTree(input), rsa.privateKey, AccessToken.VERSION.V2);
try {
JWT.verifyJWTAndGetPayload(token, "signingKey2");
fail();
} catch (JWTException e) {
assertEquals("JWT verification failed", e.getMessage());
}
}
}
@Test
public void signingSuccess()
throws NoSuchAlgorithmException, InvalidKeySpecException, InvalidKeyException, SignatureException {
io.supertokens.utils.Utils.PubPriKey key = io.supertokens.utils.Utils.generateNewPubPriKey();
String signature = io.supertokens.utils.Utils.signWithPrivateKey("hello", key.privateKey);
assertTrue(io.supertokens.utils.Utils.verifyWithPublicKey("hello", signature, key.publicKey));
}
@Test
public void signingFailure()
throws NoSuchAlgorithmException, InvalidKeySpecException, InvalidKeyException, SignatureException {
io.supertokens.utils.Utils.PubPriKey key = io.supertokens.utils.Utils.generateNewPubPriKey();
String signature = io.supertokens.utils.Utils.signWithPrivateKey("hello", key.privateKey);
try {
io.supertokens.utils.Utils.verifyWithPublicKey("hello", signature + "random", key.publicKey);
fail();
} catch (IllegalArgumentException e) {
}
assertFalse(io.supertokens.utils.Utils.verifyWithPublicKey("helloo", signature, key.publicKey));
try {
io.supertokens.utils.Utils.verifyWithPublicKey("hello", signature,
key.publicKey.substring(0, 10) + "random" + key.publicKey.substring(10));
fail();
} catch (InvalidKeySpecException e) {
}
}
private static class TestInput {
final String key;
TestInput(String key) {
this.key = key;
}
@Override
public boolean equals(Object other) {
if (!(other instanceof TestInput)) {
return false;
}
TestInput otherTestInput = (TestInput) other;
return otherTestInput.key.equals(this.key);
}
}
}
| 2,356 |
2,038 | //
// WaxWatchLib.h
// WaxWatchLib
//
// Created by junzhan on 15/10/28.
// Copyright © 2015年 <EMAIL>. All rights reserved.
//
#import <Foundation/Foundation.h>
@interface WaxWatchLib : NSObject
@end
| 78 |
607 | <reponame>cdlaimin/Pixiv-Illustration-Collection-Backend<gh_stars>100-1000
package dev.cheerfun.pixivic.biz.sitemap.po;
import com.thoughtworks.xstream.annotations.XStreamAlias;
import com.thoughtworks.xstream.annotations.XStreamAsAttribute;
import com.thoughtworks.xstream.annotations.XStreamImplicit;
import dev.cheerfun.pixivic.biz.sitemap.constant.SiteMapConstant;
import lombok.Data;
import java.util.List;
/**
* @author OysterQAQ
* @version 1.0
* @date 2020/6/28 4:27 下午
* @description SiteMapIndex
*/
@Data
@XStreamAlias("sitemapindex")
public class SiteMapIndex {
@XStreamAlias("xmlns")
@XStreamAsAttribute
private String xmlns = SiteMapConstant.XMLNS;
@XStreamImplicit(itemFieldName = "sitemap")
private List<SiteMap> siteMapList;
public SiteMapIndex() {
}
public SiteMapIndex(List<SiteMap> siteMapList) {
this.siteMapList = siteMapList;
}
}
| 346 |
546 | <reponame>siliconarts/vortex
/*
* Copyright 1993-2010 NVIDIA Corporation. All rights reserved.
*
* Please refer to the NVIDIA end user license agreement (EULA) associated
* with this source code for terms and conditions that govern your use of
* this software. Any use, reproduction, disclosure, or distribution of
* this software and related documentation outside the terms of the EULA
* is strictly prohibited.
*
*/
/* Matrix transpose with Cuda
* Host code.
* This example transposes arbitrary-size matrices. It compares a naive
* transpose kernel that suffers from non-coalesced writes, to an optimized
* transpose with fully coalesced memory access and no bank conflicts. On
* a G80 GPU, the optimized transpose can be more than 10x faster for large
* matrices.
*/
// standard utility and system includes
#include "oclUtils.h"
#include "shrQATest.h"
#define BLOCK_DIM 16
// max GPU's to manage for multi-GPU parallel compute
const unsigned int MAX_GPU_COUNT = 8;
// global variables
cl_platform_id cpPlatform;
cl_uint uiNumDevices;
cl_device_id* cdDevices;
cl_context cxGPUContext;
cl_kernel ckKernel[MAX_GPU_COUNT];
cl_command_queue commandQueue[MAX_GPU_COUNT];
cl_program rv_program;
// forward declarations
// *********************************************************************
int runTest( int argc, const char** argv);
extern "C" void computeGold( float* reference, float* idata,
const unsigned int size_x, const unsigned int size_y );
// Main Program
// *********************************************************************
int main( int argc, const char** argv)
{
shrQAStart(argc, (char **)argv);
// set logfile name and start logs
shrSetLogFileName ("oclTranspose.txt");
shrLog("%s Starting...\n\n", argv[0]);
// run the main test
int result = runTest(argc, argv);
//oclCheckError(result, 0);
}
double transposeGPU(const char* kernelName, bool useLocalMem, cl_uint ciDeviceCount, float* h_idata, float* h_odata, unsigned int size_x, unsigned int size_y)
{
cl_mem d_odata[MAX_GPU_COUNT];
cl_mem d_idata[MAX_GPU_COUNT];
cl_kernel ckKernel[MAX_GPU_COUNT];
size_t szGlobalWorkSize[2];
size_t szLocalWorkSize[2];
cl_int ciErrNum;
// Create buffers for each GPU
// Each GPU will compute sizePerGPU rows of the result
size_t sizePerGPU = shrRoundUp(BLOCK_DIM, (size_x+ciDeviceCount-1) / ciDeviceCount);
// size of memory required to store the matrix
const size_t mem_size = sizeof(float) * size_x * size_y;
for(unsigned int i = 0; i < ciDeviceCount; ++i){
// allocate device memory and copy host to device memory
d_idata[i] = clCreateBuffer(cxGPUContext, CL_MEM_READ_ONLY | CL_MEM_COPY_HOST_PTR,
mem_size, h_idata, &ciErrNum);
//oclCheckError(ciErrNum, CL_SUCCESS);
// create buffer to store output
d_odata[i] = clCreateBuffer(cxGPUContext, CL_MEM_WRITE_ONLY ,
sizePerGPU*size_y*sizeof(float), NULL, &ciErrNum);
//oclCheckError(ciErrNum, CL_SUCCESS);
// create the naive transpose kernel
ckKernel[i] = clCreateKernel(rv_program, kernelName, &ciErrNum);
//oclCheckError(ciErrNum, CL_SUCCESS);
// set the args values for the naive kernel
size_t offset = i * sizePerGPU;
ciErrNum = clSetKernelArg(ckKernel[i], 0, sizeof(cl_mem), (void *) &d_odata[i]);
ciErrNum |= clSetKernelArg(ckKernel[i], 1, sizeof(cl_mem), (void *) &d_idata[0]);
ciErrNum |= clSetKernelArg(ckKernel[i], 2, sizeof(int), &offset);
ciErrNum |= clSetKernelArg(ckKernel[i], 3, sizeof(int), &size_x);
ciErrNum |= clSetKernelArg(ckKernel[i], 4, sizeof(int), &size_y);
if(useLocalMem)
{
ciErrNum |= clSetKernelArg(ckKernel[i], 5, (BLOCK_DIM + 1) * BLOCK_DIM * sizeof(float), 0 );
}
}
//oclCheckError(ciErrNum, CL_SUCCESS);
// set up execution configuration
szLocalWorkSize[0] = BLOCK_DIM;
szLocalWorkSize[1] = BLOCK_DIM;
szGlobalWorkSize[0] = sizePerGPU;
szGlobalWorkSize[1] = shrRoundUp(BLOCK_DIM, size_y);
// execute the kernel numIterations times
int numIterations = 100;
shrLog("\nProcessing a %d by %d matrix of floats...\n\n", size_x, size_y);
for (int i = -1; i < numIterations; ++i)
{
// Start time measurement after warmup
if( i == 0 ) shrDeltaT(0);
for(unsigned int k=0; k < ciDeviceCount; ++k){
ciErrNum |= clEnqueueNDRangeKernel(commandQueue[k], ckKernel[k], 2, NULL,
szGlobalWorkSize, szLocalWorkSize, 0, NULL, NULL);
}
//oclCheckError(ciErrNum, CL_SUCCESS);
}
// Block CPU till GPU is done
for(unsigned int k=0; k < ciDeviceCount; ++k){
ciErrNum |= clFinish(commandQueue[k]);
}
double time = shrDeltaT(0)/(double)numIterations;
//oclCheckError(ciErrNum, CL_SUCCESS);
// Copy back to host
for(unsigned int i = 0; i < ciDeviceCount; ++i){
size_t offset = i * sizePerGPU;
size_t size = MIN(size_x - i * sizePerGPU, sizePerGPU);
ciErrNum |= clEnqueueReadBuffer(commandQueue[i], d_odata[i], CL_TRUE, 0,
size * size_y * sizeof(float), &h_odata[offset * size_y],
0, NULL, NULL);
}
//oclCheckError(ciErrNum, CL_SUCCESS);
for(unsigned int i = 0; i < ciDeviceCount; ++i){
ciErrNum |= clReleaseMemObject(d_idata[i]);
ciErrNum |= clReleaseMemObject(d_odata[i]);
ciErrNum |= clReleaseKernel(ckKernel[i]);
}
//oclCheckError(ciErrNum, CL_SUCCESS);
return time;
}
uint8_t *kernel_bin = NULL;
static int read_kernel_file(const char* filename, uint8_t** data, size_t* size) {
if (nullptr == filename || nullptr == data || 0 == size)
return -1;
FILE* fp = fopen(filename, "r");
if (NULL == fp) {
fprintf(stderr, "Failed to load kernel.");
return -1;
}
fseek(fp , 0 , SEEK_END);
long fsize = ftell(fp);
rewind(fp);
*data = (uint8_t*)malloc(fsize);
*size = fread(*data, 1, fsize, fp);
fclose(fp);
return 0;
}
//! Run a simple test for CUDA
// *********************************************************************
int runTest( const int argc, const char** argv)
{
cl_int ciErrNum;
cl_uint ciDeviceCount;
unsigned int size_x = 2048;
unsigned int size_y = 2048;
int temp;
if( shrGetCmdLineArgumenti( argc, argv,"width", &temp) ){
size_x = temp;
}
if( shrGetCmdLineArgumenti( argc, argv,"height", &temp) ){
size_y = temp;
}
// size of memory required to store the matrix
const size_t mem_size = sizeof(float) * size_x * size_y;
//Get the NVIDIA platform
ciErrNum = oclGetPlatformID(&cpPlatform);
//oclCheckError(ciErrNum, CL_SUCCESS);
//Get the devices
ciErrNum = clGetDeviceIDs(cpPlatform, CL_DEVICE_TYPE_DEFAULT, 0, NULL, &uiNumDevices);
//oclCheckError(ciErrNum, CL_SUCCESS);
cdDevices = (cl_device_id *)malloc(uiNumDevices * sizeof(cl_device_id) );
ciErrNum = clGetDeviceIDs(cpPlatform, CL_DEVICE_TYPE_DEFAULT, uiNumDevices, cdDevices, NULL);
//oclCheckError(ciErrNum, CL_SUCCESS);
//Create the context
cxGPUContext = clCreateContext(0, uiNumDevices, cdDevices, NULL, NULL, &ciErrNum);
//oclCheckError(ciErrNum, CL_SUCCESS);
if(shrCheckCmdLineFlag(argc, (const char**)argv, "device"))
{
ciDeviceCount = 0;
// User specified GPUs
char* deviceList;
char* deviceStr;
shrGetCmdLineArgumentstr(argc, (const char**)argv, "device", &deviceList);
#ifdef WIN32
char* next_token;
deviceStr = strtok_s (deviceList," ,.-", &next_token);
#else
deviceStr = strtok (deviceList," ,.-");
#endif
ciDeviceCount = 0;
while(deviceStr != NULL)
{
// get and print the device for this queue
cl_device_id device = oclGetDev(cxGPUContext, atoi(deviceStr));
if( device == (cl_device_id)-1 ) {
shrLog(" Invalid Device: %s\n\n", deviceStr);
return -1;
}
shrLog("Device %d: ", atoi(deviceStr));
oclPrintDevName(LOGBOTH, device);
shrLog("\n");
// create command queue
commandQueue[ciDeviceCount] = clCreateCommandQueue(cxGPUContext, device, CL_QUEUE_PROFILING_ENABLE, &ciErrNum);
if (ciErrNum != CL_SUCCESS)
{
shrLog(" Error %i in clCreateCommandQueue call !!!\n\n", ciErrNum);
return ciErrNum;
}
++ciDeviceCount;
#ifdef WIN32
deviceStr = strtok_s (NULL," ,.-", &next_token);
#else
deviceStr = strtok (NULL," ,.-");
#endif
}
free(deviceList);
}
else
{
// Find out how many GPU's to compute on all available GPUs
size_t nDeviceBytes;
ciErrNum |= clGetContextInfo(cxGPUContext, CL_CONTEXT_DEVICES, 0, NULL, &nDeviceBytes);
ciDeviceCount = (cl_uint)nDeviceBytes/sizeof(cl_device_id);
if (ciErrNum != CL_SUCCESS)
{
shrLog(" Error %i in clGetDeviceIDs call !!!\n\n", ciErrNum);
return ciErrNum;
}
else if (ciDeviceCount == 0)
{
shrLog(" There are no devices supporting OpenCL (return code %i)\n\n", ciErrNum);
return -1;
}
// create command-queues
for(unsigned int i = 0; i < ciDeviceCount; ++i)
{
// get and print the device for this queue
cl_device_id device = oclGetDev(cxGPUContext, i);
shrLog("Device %d: ", i);
oclPrintDevName(LOGBOTH, device);
shrLog("\n");
// create command queue
commandQueue[i] = clCreateCommandQueue(cxGPUContext, device, CL_QUEUE_PROFILING_ENABLE, &ciErrNum);
if (ciErrNum != CL_SUCCESS)
{
shrLog(" Error %i in clCreateCommandQueue call !!!\n\n", ciErrNum);
return ciErrNum;
}
}
}
// allocate and initalize host memory
float* h_idata = (float*)malloc(mem_size);
float* h_odata = (float*) malloc(mem_size);
srand(15235911);
shrFillArray(h_idata, (size_x * size_y));
// Program Setup
size_t program_length;
char* source_path = shrFindFilePath("transpose.cl", argv[0]);
//oclCheckError(source_path != NULL, shrTRUE);
char *source = oclLoadProgSource(source_path, "", &program_length);
//oclCheckError(source != NULL, shrTRUE);
size_t kernel_size;
cl_int binary_status = 0;
cl_device_id device_id;
// create the program
rv_program = clCreateProgramWithBinary(
cxGPUContext, 1, &device_id, &kernel_size, (const uint8_t**)&kernel_bin, &binary_status, NULL);
//rv_program = clCreateProgramWithSource(cxGPUContext, 1,
// (const char **)&source, &program_length, &ciErrNum);
//oclCheckError(ciErrNum, CL_SUCCESS);
// build the program
ciErrNum = clBuildProgram(rv_program, 0, NULL, "-cl-fast-relaxed-math", NULL, NULL);
if (ciErrNum != CL_SUCCESS)
{
// write out standard error, Build Log and PTX, then return error
shrLogEx(LOGBOTH | ERRORMSG, ciErrNum, STDERROR);
oclLogBuildInfo(rv_program, oclGetFirstDev(cxGPUContext));
oclLogPtx(rv_program, oclGetFirstDev(cxGPUContext), "oclTranspose.ptx");
return(EXIT_FAILURE);
}
// Run Naive Kernel
#ifdef GPU_PROFILING
// Matrix Copy kernel runs to measure reference performance.
double uncoalescedCopyTime = transposeGPU("uncoalesced_copy", false, ciDeviceCount, h_idata, h_odata, size_x, size_y);
double simpleCopyTime = transposeGPU("simple_copy", false, ciDeviceCount, h_idata, h_odata, size_x, size_y);
double sharedCopyTime = transposeGPU("shared_copy", true, ciDeviceCount, h_idata, h_odata, size_x, size_y);
#endif
double naiveTime = transposeGPU("transpose_naive", false, ciDeviceCount, h_idata, h_odata, size_x, size_y);
double optimizedTime = transposeGPU("transpose", true, ciDeviceCount, h_idata, h_odata, size_x, size_y);
#ifdef GPU_PROFILING
// log times
shrLogEx(LOGBOTH | MASTER, 0, "oclTranspose-Outer-simple copy, Throughput = %.4f GB/s, Time = %.5f s, Size = %u fp32 elements, NumDevsUsed = %u, Workgroup = %u\n",
(1.0e-9 * double(size_x * size_y * sizeof(float))/simpleCopyTime), simpleCopyTime, (size_x * size_y), ciDeviceCount, BLOCK_DIM * BLOCK_DIM);
shrLogEx(LOGBOTH | MASTER, 0, "oclTranspose-Outer-shared memory copy, Throughput = %.4f GB/s, Time = %.5f s, Size = %u fp32 elements, NumDevsUsed = %u, Workgroup = %u\n",
(1.0e-9 * double(size_x * size_y * sizeof(float))/sharedCopyTime), sharedCopyTime, (size_x * size_y), ciDeviceCount, BLOCK_DIM * BLOCK_DIM);
shrLogEx(LOGBOTH | MASTER, 0, "oclTranspose-Outer-uncoalesced copy, Throughput = %.4f GB/s, Time = %.5f s, Size = %u fp32 elements, NumDevsUsed = %u, Workgroup = %u\n",
(1.0e-9 * double(size_x * size_y * sizeof(float))/uncoalescedCopyTime), uncoalescedCopyTime, (size_x * size_y), ciDeviceCount, BLOCK_DIM * BLOCK_DIM);
shrLogEx(LOGBOTH | MASTER, 0, "oclTranspose-Outer-naive, Throughput = %.4f GB/s, Time = %.5f s, Size = %u fp32 elements, NumDevsUsed = %u, Workgroup = %u\n",
(1.0e-9 * double(size_x * size_y * sizeof(float))/naiveTime), naiveTime, (size_x * size_y), ciDeviceCount, BLOCK_DIM * BLOCK_DIM);
shrLogEx(LOGBOTH | MASTER, 0, "oclTranspose-Outer-optimized, Throughput = %.4f GB/s, Time = %.5f s, Size = %u fp32 elements, NumDevsUsed = %u, Workgroup = %u\n",
(1.0e-9 * double(size_x * size_y * sizeof(float))/optimizedTime), optimizedTime, (size_x * size_y), ciDeviceCount, BLOCK_DIM * BLOCK_DIM);
#endif
// compute reference solution and cross check results
float* reference = (float*)malloc( mem_size);
computeGold( reference, h_idata, size_x, size_y);
shrLog("\nComparing results with CPU computation... \n\n");
shrBOOL res = shrComparef( reference, h_odata, size_x * size_y);
// cleanup memory
free(h_idata);
free(h_odata);
free(reference);
free(source);
free(source_path);
// cleanup OpenCL
ciErrNum = clReleaseProgram(rv_program);
for(unsigned int i = 0; i < ciDeviceCount; ++i)
{
ciErrNum |= clReleaseCommandQueue(commandQueue[i]);
}
ciErrNum |= clReleaseContext(cxGPUContext);
//oclCheckError(ciErrNum, CL_SUCCESS);
// pass or fail (cumulative... all tests in the loop)
shrQAFinishExit(argc, (const char **)argv, (1 == res) ? QA_PASSED : QA_FAILED);
return 0;
}
| 6,642 |
2,577 | /*
* Copyright Camunda Services GmbH and/or licensed to Camunda Services GmbH
* under one or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information regarding copyright
* ownership. Camunda licenses this file to you under the Apache License,
* Version 2.0; you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.camunda.bpm.engine.query;
import java.util.List;
import org.camunda.bpm.engine.AuthorizationException;
import org.camunda.bpm.engine.authorization.Permissions;
import org.camunda.bpm.engine.authorization.Resources;
import org.camunda.bpm.engine.exception.NotValidException;
import org.camunda.bpm.engine.history.DurationReportResult;
/**
* Describes basic methods for creating a report.
*
* @author <NAME>
*
* @since 7.5
*/
public interface Report {
/**
* <p>Executes the duration report query and returns a list of
* {@link DurationReportResult}s.</p>
*
* <p>Be aware that the resulting report must be interpreted by the
* caller itself.</p>
*
* @param periodUnit A {@link PeriodUnit period unit} to define
* the granularity of the report.
*
* @return a list of {@link DurationReportResult}s
*
* @throws AuthorizationException
* If the user has no {@link Permissions#READ_HISTORY} permission
* on any {@link Resources#PROCESS_DEFINITION}.
* @throws NotValidException
* When the given period unit is null.
*/
List<DurationReportResult> duration(PeriodUnit periodUnit);
}
| 601 |
815 | <gh_stars>100-1000
#ifndef FEDATASTRUCTURES_HEADER
#define FEDATASTRUCTURES_HEADER
#include <stdint.h> // for fixed-with types.
typedef struct Grid
{
uint64_t NumberOfPoints;
uint64_t NumberOfCells;
double* Points;
int64_t* Cells;
} Grid;
void InitializeGrid(Grid* grid, const unsigned int numPoints[3], const double spacing[3]);
void FinalizeGrid(Grid*);
typedef struct Attributes
{
// A structure for generating and storing point and cell fields.
// Velocity is stored at the points and pressure is stored
// for the cells. The current velocity profile is for a
// shearing flow with U(y,t) = y*t, V = 0 and W = 0.
// Pressure is constant through the domain.
double* Velocity;
float* Pressure;
Grid* GridPtr;
} Attributes;
void InitializeAttributes(Attributes* attributes, Grid* grid);
void FinalizeAttributes(Attributes* attributes);
void UpdateFields(Attributes* attributes, double time);
#endif
| 288 |
1,350 | <gh_stars>1000+
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
// Code generated by Microsoft (R) AutoRest Code Generator.
package com.azure.resourcemanager.security;
import com.azure.core.util.Context;
/** Samples for SubAssessments Get. */
public final class SubAssessmentsGetSamples {
/**
* Sample code: Get security recommendation task from security data location.
*
* @param securityManager Entry point to SecurityManager. API spec for Microsoft.Security (Azure Security Center)
* resource provider.
*/
public static void getSecurityRecommendationTaskFromSecurityDataLocation(
com.azure.resourcemanager.security.SecurityManager securityManager) {
securityManager
.subAssessments()
.getWithResponse(
"subscriptions/212f9889-769e-45ae-ab43-6da33674bd26/resourceGroups/DEMORG/providers/Microsoft.Compute/virtualMachines/vm2",
"1195afff-c881-495e-9bc5-1486211ae03f",
"95f7da9c-a2a4-1322-0758-fcd24ef09b85",
Context.NONE);
}
}
| 434 |
3,269 | // Time: O(n)
// Space: O(1)
class Solution {
public:
int minimumMoves(string s) {
int result = 0;
for (int i = 0; i < size(s); i += (s[i] == 'X') ? 3 : 1) {
result += (s[i] == 'X');
}
return result;
}
};
| 139 |
769 | <reponame>wasmup/stm32
// Define to prevent recursive inclusion -------------------------------------
#ifndef __UART_H
#define __UART_H
// USART1 HAL
#define USART1_PORT USART1
#define USART1_GPIO_TX GPIOA
#define USART1_GPIO_RX GPIOA
#define USART1_GPIO_AHB_TX RCC_AHBENR_GPIOAEN
#define USART1_GPIO_AHB_RX RCC_AHBENR_GPIOAEN
#define USART1_GPIO_PIN_TX GPIO_Pin_9
#define USART1_GPIO_PIN_RX GPIO_Pin_10
#define USART1_GPIO_TX_SRC GPIO_PinSource9
#define USART1_GPIO_RX_SRC GPIO_PinSource10
#define USART1_GPIO_AF GPIO_AF_USART1
#define USART1_DMA_PERIPH DMA1
#define USART1_DMA_RX DMA1_Channel5
#define USART1_DMA_TX DMA1_Channel4
#define USART1_DMA_RX_TCIF DMA_ISR_TCIF5
#define USART1_DMA_TX_TCIF DMA_ISR_TCIF4
#define USART1_DMA_RX_HTIF DMA_ISR_HTIF5
#define USART1_DMA_TX_HTIF DMA_ISR_HTIF4
#define USART1_DMA_RXF DMA_IFCR_CGIF5 | DMA_IFCR_CHTIF5 | DMA_IFCR_CTCIF5 | DMA_IFCR_CTEIF5
#define USART1_DMA_TXF DMA_IFCR_CGIF4 | DMA_IFCR_CHTIF4 | DMA_IFCR_CTCIF4 | DMA_IFCR_CTEIF4
// USART2 HAL
#define USART2_PORT USART2
#define USART2_GPIO_TX GPIOA
#define USART2_GPIO_RX GPIOA
#define USART2_GPIO_AHB_TX RCC_AHBENR_GPIOAEN
#define USART2_GPIO_AHB_RX RCC_AHBENR_GPIOAEN
#define USART2_GPIO_PIN_TX GPIO_Pin_2
#define USART2_GPIO_PIN_RX GPIO_Pin_3
#define USART2_GPIO_TX_SRC GPIO_PinSource2
#define USART2_GPIO_RX_SRC GPIO_PinSource3
#define USART2_GPIO_AF GPIO_AF_USART2
#define USART2_DMA_PERIPH DMA1
#define USART2_DMA_RX DMA1_Channel6
#define USART2_DMA_TX DMA1_Channel7
#define USART2_DMA_RX_TCIF DMA_ISR_TCIF6
#define USART2_DMA_TX_TCIF DMA_ISR_TCIF7
#define USART2_DMA_RX_HTIF DMA_ISR_HTIF6
#define USART2_DMA_TX_HTIF DMA_ISR_HTIF7
#define USART2_DMA_RXF DMA_IFCR_CGIF6 | DMA_IFCR_CHTIF6 | DMA_IFCR_CTCIF6 | DMA_IFCR_CTEIF6
#define USART2_DMA_TXF DMA_IFCR_CGIF7 | DMA_IFCR_CHTIF7 | DMA_IFCR_CTCIF7 | DMA_IFCR_CTEIF7
// USART3 HAL
#define USART3_PORT USART3
#define USART3_GPIO_TX GPIOC
#define USART3_GPIO_RX GPIOC
#define USART3_GPIO_AHB_TX RCC_AHBENR_GPIOCEN
#define USART3_GPIO_AHB_RX RCC_AHBENR_GPIOCEN
#define USART3_GPIO_PIN_TX GPIO_Pin_10
#define USART3_GPIO_PIN_RX GPIO_Pin_11
#define USART3_GPIO_TX_SRC GPIO_PinSource10
#define USART3_GPIO_RX_SRC GPIO_PinSource11
#define USART3_GPIO_AF GPIO_AF_USART3
#define USART3_DMA_PERIPH DMA1
#define USART3_DMA_RX DMA1_Channel3
#define USART3_DMA_TX DMA1_Channel2
#define USART3_DMA_RX_TCIF DMA_ISR_TCIF3
#define USART3_DMA_TX_TCIF DMA_ISR_TCIF2
#define USART3_DMA_RX_HTIF DMA_ISR_HTIF3
#define USART3_DMA_TX_HTIF DMA_ISR_HTIF2
#define USART3_DMA_RXF DMA_IFCR_CGIF3 | DMA_IFCR_CHTIF3 | DMA_IFCR_CTCIF3 | DMA_IFCR_CTEIF3
#define USART3_DMA_TXF DMA_IFCR_CGIF2 | DMA_IFCR_CHTIF2 | DMA_IFCR_CTCIF2 | DMA_IFCR_CTEIF2
// Chars for hexadecimal output
#define HEX_CHARS "0123456789ABCDEF"
// USART TX/RX mask
#define USART_TX USART_CR1_TE // Enable transmit
#define USART_RX USART_CR1_RE // Enable receive
// USART IRQ control mask
#define USART_IRQ_TXE USART_CR1_TXEIE
#define USART_IRQ_TC USART_CR1_TCIE
#define USART_IRQ_RXNE USART_CR1_RXNEIE
#define USART_IRQ_IDLE USART_CR1_IDLEIE
// USART DMA TX/RX mask
#define USART_DMA_TX USART_CR3_DMAT // USART transmitter DMA
#define USART_DMA_RX USART_CR3_DMAR // USART receiver DMA
// USART DMA circular mode
#define USART_DMA_BUF_CIRC DMA_CCR1_CIRC // DMA circular buffer mode
#define USART_DMA_BUF_NORMAL ((uint32_t)0x0) // DMA normal buffer mode
// Function prototypes
void UARTx_Init(USART_TypeDef* USARTx, uint32_t USART_DIR, uint32_t baudrate);
void UARTx_SetSpeed(USART_TypeDef* USARTx, uint32_t baudrate);
void UARTx_InitIRQ(USART_TypeDef* USARTx, uint32_t USART_IRQ, uint8_t priority);
void UARTx_ConfigureDMA(USART_TypeDef* USARTx, uint8_t DMA_DIR, uint32_t DMA_BUF, uint8_t *pBuf, uint32_t length);
void UARTx_SetDMA(USART_TypeDef* USARTx, uint8_t DMA_DIR, FunctionalState NewState);
void UART_SendChar(USART_TypeDef* USARTx, char ch);
void UART_SendInt(USART_TypeDef* USARTx, int32_t num);
void UART_SendIntLZ(USART_TypeDef* USARTx, int32_t num);
void UART_SendIntU(USART_TypeDef* USARTx, uint32_t num);
void UART_SendHex8(USART_TypeDef* USARTx, uint8_t num);
void UART_SendHex16(USART_TypeDef* USARTx, uint16_t num);
void UART_SendHex32(USART_TypeDef* USARTx, uint32_t num);
void UART_SendStr(USART_TypeDef* USARTx, char *str);
void UART_SendBuf(USART_TypeDef* USARTx, char *pBuf, uint16_t length);
void UART_SendBufPrintable(USART_TypeDef* USARTx, char *pBuf, uint16_t length, char subst);
void UART_SendBufHex(USART_TypeDef* USARTx, char *pBuf, uint16_t length);
#endif // __UART_H
| 2,430 |
826 | <reponame>julescmay/LuxCore
/***************************************************************************
* Copyright 1998-2020 by authors (see AUTHORS.txt) *
* *
* This file is part of LuxCoreRender. *
* *
* Licensed under the Apache License, Version 2.0 (the "License"); *
* you may not use this file except in compliance with the License. *
* You may obtain a copy of the License at *
* *
* http://www.apache.org/licenses/LICENSE-2.0 *
* *
* Unless required by applicable law or agreed to in writing, software *
* distributed under the License is distributed on an "AS IS" BASIS, *
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.*
* See the License for the specific language governing permissions and *
* limitations under the License. *
***************************************************************************/
#ifndef _SLG_MORTONCURVE_H
#define _SLG_MORTONCURVE_H
#include "luxrays/utils/utils.h"
namespace slg {
//------------------------------------------------------------------------------
// Morton related functions
//------------------------------------------------------------------------------
// Morton decode from https://fgiesen.wordpress.com/2009/12/13/decoding-morton-codes/
// Inverse of Part1By1 - "delete" all odd-indexed bits
inline u_int Compact1By1(u_int x) {
x &= 0x55555555; // x = -f-e -d-c -b-a -9-8 -7-6 -5-4 -3-2 -1-0
x = (x ^ (x >> 1)) & 0x33333333; // x = --fe --dc --ba --98 --76 --54 --32 --10
x = (x ^ (x >> 2)) & 0x0f0f0f0f; // x = ---- fedc ---- ba98 ---- 7654 ---- 3210
x = (x ^ (x >> 4)) & 0x00ff00ff; // x = ---- ---- fedc ba98 ---- ---- 7654 3210
x = (x ^ (x >> 8)) & 0x0000ffff; // x = ---- ---- ---- ---- fedc ba98 7654 3210
return x;
}
// Inverse of Part1By2 - "delete" all bits not at positions divisible by 3
inline u_int Compact1By2(u_int x) {
x &= 0x09249249; // x = ---- 9--8 --7- -6-- 5--4 --3- -2-- 1--0
x = (x ^ (x >> 2)) & 0x030c30c3; // x = ---- --98 ---- 76-- --54 ---- 32-- --10
x = (x ^ (x >> 4)) & 0x0300f00f; // x = ---- --98 ---- ---- 7654 ---- ---- 3210
x = (x ^ (x >> 8)) & 0xff0000ff; // x = ---- --98 ---- ---- ---- ---- 7654 3210
x = (x ^ (x >> 16)) & 0x000003ff; // x = ---- ---- ---- ---- ---- --98 7654 3210
return x;
}
inline u_int DecodeMorton2X(const u_int code) {
return Compact1By1(code >> 0);
}
inline u_int DecodeMorton2Y(const u_int code) {
return Compact1By1(code >> 1);
}
}
#endif /* _SLG_MORTONCURVE_H */
| 1,348 |
658 | <gh_stars>100-1000
#include <stddef.h>
#include <stdint.h>
#include <sys/idt.h>
#include <lib/blib.h>
#if bios == 1
static struct idt_entry idt_entries[32];
__attribute__((section(".realmode")))
struct idtr idt = {
sizeof(idt_entries) - 1,
(uintptr_t)idt_entries
};
static void register_interrupt_handler(size_t vec, void *handler, uint8_t type) {
uint32_t p = (uint32_t)handler;
idt_entries[vec].offset_lo = (uint16_t)p;
idt_entries[vec].selector = 0x18;
idt_entries[vec].unused = 0;
idt_entries[vec].type_attr = type;
idt_entries[vec].offset_hi = (uint16_t)(p >> 16);
}
extern void *exceptions[];
void init_idt(void) {
for (size_t i = 0; i < SIZEOF_ARRAY(idt_entries); i++)
register_interrupt_handler(i, exceptions[i], 0x8e);
asm volatile ("lidt %0" :: "m"(idt) : "memory");
}
#endif
| 386 |
575 | {
"key": "<KEY>",
"description": "This extension helps in retrieving the CPU/memory usage stats for MR extension.",
"name": "MR Test Extension",
"version": "1.0",
"manifest_version": 2,
"externally_connectable": {
"matches": [
"http://127.0.0.1:*/*"
]
},
"background": {
"scripts": ["script.js"],
"persistent": true
},
"permissions": [
"processes"
]
}
| 159 |
674 | package com.codeforvictory.superimageview.samples.superimageview.rounded_corners;
import com.codeforvictory.android.superimageview.crop.CropType;
import com.codeforvictory.superimageview.samples.superimageview.R;
import java.util.Arrays;
import java.util.List;
public final class ImageFactory {
private ImageFactory() {
throw new AssertionError("This shouldn't be initialized!");
}
public static List<Image> imagesWithoutRoundedCorners() {
return Arrays.asList(
// new Image(R.drawable.ball_vertical, false, CropType.NONE),
// new Image(R.drawable.ball_horizontal, false, CropType.NONE),
new Image(R.drawable.ball_vertical, false, CropType.TOP),
new Image(R.drawable.ball_vertical, false, CropType.BOTTOM),
new Image(R.drawable.ball_horizontal, false, CropType.TOP_LEFT),
new Image(R.drawable.ball_horizontal, false, CropType.LEFT),
new Image(R.drawable.ball_horizontal, false, CropType.BOTTOM_LEFT),
new Image(R.drawable.ball_horizontal, false, CropType.TOP_RIGHT),
new Image(R.drawable.ball_horizontal, false, CropType.BOTTOM_RIGHT),
new Image(R.drawable.ball_horizontal, false, CropType.RIGHT),
new Image(R.drawable.ball_vertical, false, CropType.TOP),
new Image(R.drawable.ball_vertical, false, CropType.BOTTOM),
new Image(R.drawable.ball_horizontal, false, CropType.TOP_LEFT),
new Image(R.drawable.ball_horizontal, false, CropType.LEFT),
new Image(R.drawable.ball_horizontal, false, CropType.BOTTOM_LEFT),
new Image(R.drawable.ball_horizontal, false, CropType.TOP_RIGHT),
new Image(R.drawable.ball_horizontal, false, CropType.BOTTOM_RIGHT),
new Image(R.drawable.ball_horizontal, false, CropType.RIGHT),
new Image(R.drawable.ball_vertical, false, CropType.TOP),
new Image(R.drawable.ball_vertical, false, CropType.BOTTOM),
new Image(R.drawable.ball_horizontal, false, CropType.TOP_LEFT),
new Image(R.drawable.ball_horizontal, false, CropType.LEFT),
new Image(R.drawable.ball_horizontal, false, CropType.BOTTOM_LEFT),
new Image(R.drawable.ball_horizontal, false, CropType.TOP_RIGHT),
new Image(R.drawable.ball_horizontal, false, CropType.BOTTOM_RIGHT),
new Image(R.drawable.ball_horizontal, false, CropType.RIGHT),
new Image(R.drawable.ball_vertical, false, CropType.TOP),
new Image(R.drawable.ball_vertical, false, CropType.BOTTOM),
new Image(R.drawable.ball_horizontal, false, CropType.TOP_LEFT),
new Image(R.drawable.ball_horizontal, false, CropType.LEFT),
new Image(R.drawable.ball_horizontal, false, CropType.BOTTOM_LEFT),
new Image(R.drawable.ball_horizontal, false, CropType.TOP_RIGHT),
new Image(R.drawable.ball_horizontal, false, CropType.BOTTOM_RIGHT),
new Image(R.drawable.ball_horizontal, false, CropType.RIGHT)
);
}
public static List<Image> imagesWithRoundedCorners() {
return Arrays.asList(
// new Image(R.drawable.ball_vertical, false, CropType.NONE),
// new Image(R.drawable.ball_horizontal, false, CropType.NONE),
new Image(R.drawable.ball_vertical, true, CropType.TOP),
new Image(R.drawable.ball_vertical, true, CropType.BOTTOM),
new Image(R.drawable.ball_horizontal, true, CropType.TOP_LEFT),
new Image(R.drawable.ball_horizontal, true, CropType.LEFT),
new Image(R.drawable.ball_horizontal, true, CropType.BOTTOM_LEFT),
new Image(R.drawable.ball_horizontal, true, CropType.TOP_RIGHT),
new Image(R.drawable.ball_horizontal, true, CropType.BOTTOM_RIGHT),
new Image(R.drawable.ball_horizontal, true, CropType.RIGHT),
new Image(R.drawable.ball_vertical, false, CropType.TOP),
new Image(R.drawable.ball_vertical, false, CropType.BOTTOM),
new Image(R.drawable.ball_horizontal, false, CropType.TOP_LEFT),
new Image(R.drawable.ball_horizontal, false, CropType.LEFT),
new Image(R.drawable.ball_horizontal, false, CropType.BOTTOM_LEFT),
new Image(R.drawable.ball_horizontal, false, CropType.TOP_RIGHT),
new Image(R.drawable.ball_horizontal, false, CropType.BOTTOM_RIGHT),
new Image(R.drawable.ball_horizontal, false, CropType.RIGHT),
new Image(R.drawable.ball_vertical, false, CropType.TOP),
new Image(R.drawable.ball_vertical, false, CropType.BOTTOM),
new Image(R.drawable.ball_horizontal, false, CropType.TOP_LEFT),
new Image(R.drawable.ball_horizontal, false, CropType.LEFT),
new Image(R.drawable.ball_horizontal, false, CropType.BOTTOM_LEFT),
new Image(R.drawable.ball_horizontal, false, CropType.TOP_RIGHT),
new Image(R.drawable.ball_horizontal, false, CropType.BOTTOM_RIGHT),
new Image(R.drawable.ball_horizontal, false, CropType.RIGHT),
new Image(R.drawable.ball_vertical, false, CropType.TOP),
new Image(R.drawable.ball_vertical, false, CropType.BOTTOM),
new Image(R.drawable.ball_horizontal, false, CropType.TOP_LEFT),
new Image(R.drawable.ball_horizontal, false, CropType.LEFT),
new Image(R.drawable.ball_horizontal, false, CropType.BOTTOM_LEFT),
new Image(R.drawable.ball_horizontal, false, CropType.TOP_RIGHT),
new Image(R.drawable.ball_horizontal, false, CropType.BOTTOM_RIGHT),
new Image(R.drawable.ball_horizontal, false, CropType.RIGHT)
);
}
}
| 2,370 |
389 | <reponame>dmcreyno/gosu-lang
/*
* Copyright 2014 <NAME>, Inc.
*/
package gw.lang.parser.statements;
import gw.lang.parser.IStatement;
import gw.lang.reflect.IFeatureInfo;
public interface IUsesStatement extends IStatement
{
String getTypeName();
boolean isFeatureSpace();
IFeatureInfo getFeatureInfo();
}
| 107 |
575 | <filename>ash/public/cpp/holding_space/holding_space_model.cc<gh_stars>100-1000
// Copyright 2020 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ash/public/cpp/holding_space/holding_space_model.h"
#include <algorithm>
#include "ash/public/cpp/holding_space/holding_space_model_observer.h"
#include "base/check.h"
namespace ash {
HoldingSpaceModel::HoldingSpaceModel() = default;
HoldingSpaceModel::~HoldingSpaceModel() = default;
void HoldingSpaceModel::AddItem(std::unique_ptr<HoldingSpaceItem> item) {
std::vector<std::unique_ptr<HoldingSpaceItem>> items;
items.push_back(std::move(item));
AddItems(std::move(items));
}
void HoldingSpaceModel::AddItems(
std::vector<std::unique_ptr<HoldingSpaceItem>> items) {
DCHECK(!items.empty());
std::vector<const HoldingSpaceItem*> item_ptrs;
for (std::unique_ptr<HoldingSpaceItem>& item : items) {
DCHECK(!GetItem(item->id()));
if (item->IsFinalized())
++finalized_item_counts_by_type_[item->type()];
item_ptrs.push_back(item.get());
items_.push_back(std::move(item));
}
for (auto& observer : observers_)
observer.OnHoldingSpaceItemsAdded(item_ptrs);
}
void HoldingSpaceModel::RemoveItem(const std::string& id) {
RemoveItems({id});
}
void HoldingSpaceModel::RemoveItems(const std::set<std::string>& item_ids) {
RemoveIf(base::BindRepeating(
[](const std::set<std::string>& item_ids, const HoldingSpaceItem* item) {
return base::Contains(item_ids, item->id());
},
std::cref(item_ids)));
}
void HoldingSpaceModel::FinalizeOrRemoveItem(const std::string& id,
const GURL& file_system_url) {
if (file_system_url.is_empty()) {
RemoveItem(id);
return;
}
auto item_it = std::find_if(
items_.begin(), items_.end(),
[&id](const std::unique_ptr<HoldingSpaceItem>& item) -> bool {
return id == item->id();
});
DCHECK(item_it != items_.end());
HoldingSpaceItem* item = item_it->get();
DCHECK(!item->IsFinalized());
item->Finalize(file_system_url);
++finalized_item_counts_by_type_[item->type()];
for (auto& observer : observers_)
observer.OnHoldingSpaceItemFinalized(item);
}
void HoldingSpaceModel::UpdateBackingFileForItem(
const std::string& id,
const base::FilePath& file_path,
const GURL& file_system_url) {
auto item_it = std::find_if(
items_.begin(), items_.end(),
[&id](const std::unique_ptr<HoldingSpaceItem>& item) -> bool {
return item->id() == id;
});
DCHECK(item_it != items_.end());
HoldingSpaceItem* item = item_it->get();
DCHECK(item->IsFinalized());
item->UpdateBackingFile(file_path, file_system_url);
for (auto& observer : observers_)
observer.OnHoldingSpaceItemUpdated(item);
}
void HoldingSpaceModel::RemoveIf(Predicate predicate) {
// Keep removed items around until `observers_` have been notified of removal.
std::vector<std::unique_ptr<HoldingSpaceItem>> items;
std::vector<const HoldingSpaceItem*> item_ptrs;
for (int i = items_.size() - 1; i >= 0; --i) {
std::unique_ptr<HoldingSpaceItem>& item = items_.at(i);
if (predicate.Run(item.get())) {
item_ptrs.push_back(item.get());
items.push_back(std::move(item));
items_.erase(items_.begin() + i);
if (item_ptrs.back()->IsFinalized())
--finalized_item_counts_by_type_[item_ptrs.back()->type()];
}
}
DCHECK_EQ(items.size(), item_ptrs.size());
if (!items.empty()) {
for (auto& observer : observers_)
observer.OnHoldingSpaceItemsRemoved(item_ptrs);
}
}
void HoldingSpaceModel::InvalidateItemImageIf(Predicate predicate) {
for (auto& item : items_) {
if (predicate.Run(item.get()))
item->InvalidateImage();
}
}
void HoldingSpaceModel::RemoveAll() {
// Clear the item list, but keep the items around until the observers have
// been notified of the item removal.
ItemList items;
items.swap(items_);
finalized_item_counts_by_type_.clear();
std::vector<const HoldingSpaceItem*> item_ptrs;
for (auto& item : items)
item_ptrs.push_back(item.get());
for (auto& observer : observers_)
observer.OnHoldingSpaceItemsRemoved(item_ptrs);
}
const HoldingSpaceItem* HoldingSpaceModel::GetItem(
const std::string& id) const {
auto item_it = std::find_if(
items_.begin(), items_.end(),
[&id](const std::unique_ptr<HoldingSpaceItem>& item) -> bool {
return item->id() == id;
});
if (item_it == items_.end())
return nullptr;
return item_it->get();
}
const HoldingSpaceItem* HoldingSpaceModel::GetItem(
HoldingSpaceItem::Type type,
const base::FilePath& file_path) const {
auto item_it = std::find_if(
items_.begin(), items_.end(),
[&type, &file_path](const std::unique_ptr<HoldingSpaceItem>& item) {
return item->type() == type && item->file_path() == file_path;
});
if (item_it == items_.end())
return nullptr;
return item_it->get();
}
bool HoldingSpaceModel::ContainsItem(HoldingSpaceItem::Type type,
const base::FilePath& file_path) const {
return GetItem(type, file_path) != nullptr;
}
bool HoldingSpaceModel::ContainsFinalizedItemOfType(
HoldingSpaceItem::Type type) const {
auto it = finalized_item_counts_by_type_.find(type);
return it != finalized_item_counts_by_type_.end() && it->second > 0u;
}
void HoldingSpaceModel::AddObserver(HoldingSpaceModelObserver* observer) {
observers_.AddObserver(observer);
}
void HoldingSpaceModel::RemoveObserver(HoldingSpaceModelObserver* observer) {
observers_.RemoveObserver(observer);
}
} // namespace ash
| 2,144 |
14,668 | <filename>ash/constants/ash_features.cc
// Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ash/constants/ash_features.h"
#include "ash/constants/ash_switches.h"
#include "base/command_line.h"
#include "base/feature_list.h"
#include "base/metrics/field_trial_params.h"
#include "base/system/sys_info.h"
#include "build/build_config.h"
#include "chromeos/constants/chromeos_features.h"
namespace ash {
namespace features {
namespace {
// Controls whether Instant Tethering supports hosts which use the background
// advertisement model.
const base::Feature kInstantTetheringBackgroundAdvertisementSupport{
"InstantTetheringBackgroundAdvertisementSupport",
base::FEATURE_ENABLED_BY_DEFAULT};
} // namespace
// Adjusts portrait mode split view to avoid the input field in the bottom
// window being occluded by the virtual keyboard.
const base::Feature kAdjustSplitViewForVK{"AdjustSplitViewForVK",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables the UI to support Ambient EQ if the device supports it.
// See https://crbug.com/1021193 for more details.
const base::Feature kAllowAmbientEQ{"AllowAmbientEQ",
base::FEATURE_DISABLED_BY_DEFAULT};
// Controls whether devices are updated before reboot after the first update.
const base::Feature kAllowRepeatedUpdates{"AllowRepeatedUpdates",
base::FEATURE_ENABLED_BY_DEFAULT};
// Shows settings for adjusting scroll acceleration/sensitivity for
// mouse/touchpad.
const base::Feature kAllowScrollSettings{"AllowScrollSettings",
base::FEATURE_DISABLED_BY_DEFAULT};
// Controls whether to enable Ambient mode feature.
const base::Feature kAmbientModeFeature{"ChromeOSAmbientMode",
base::FEATURE_ENABLED_BY_DEFAULT};
constexpr base::FeatureParam<bool> kAmbientModeCapturedOnPixelAlbumEnabled{
&kAmbientModeFeature, "CapturedOnPixelAlbumEnabled", false};
constexpr base::FeatureParam<bool> kAmbientModeCapturedOnPixelPhotosEnabled{
&kAmbientModeFeature, "CapturedOnPixelPhotosEnabled", false};
constexpr base::FeatureParam<bool> kAmbientModeCulturalInstitutePhotosEnabled{
&kAmbientModeFeature, "CulturalInstitutePhotosEnabled", false};
constexpr base::FeatureParam<bool> kAmbientModeDefaultFeedEnabled{
&kAmbientModeFeature, "DefaultFeedEnabled", false};
constexpr base::FeatureParam<bool> kAmbientModeEarthAndSpaceAlbumEnabled{
&kAmbientModeFeature, "EarthAndSpaceAlbumEnabled", true};
constexpr base::FeatureParam<bool> kAmbientModeFeaturedPhotoAlbumEnabled{
&kAmbientModeFeature, "FeaturedPhotoAlbumEnabled", true};
constexpr base::FeatureParam<bool> kAmbientModeFeaturedPhotosEnabled{
&kAmbientModeFeature, "FeaturedPhotosEnabled", true};
constexpr base::FeatureParam<bool> kAmbientModeFineArtAlbumEnabled{
&kAmbientModeFeature, "FineArtAlbumEnabled", false};
constexpr base::FeatureParam<bool> kAmbientModeGeoPhotosEnabled{
&kAmbientModeFeature, "GeoPhotosEnabled", true};
constexpr base::FeatureParam<bool> kAmbientModePersonalPhotosEnabled{
&kAmbientModeFeature, "PersonalPhotosEnabled", true};
constexpr base::FeatureParam<bool> kAmbientModeRssPhotosEnabled{
&kAmbientModeFeature, "RssPhotosEnabled", false};
constexpr base::FeatureParam<bool> kAmbientModeStreetArtAlbumEnabled{
&kAmbientModeFeature, "StreetArtAlbumEnabled", false};
// Controls whether to allow Dev channel to use Prod server feature.
const base::Feature kAmbientModeDevUseProdFeature{
"ChromeOSAmbientModeDevChannelUseProdServer",
base::FEATURE_DISABLED_BY_DEFAULT};
// Controls whether to enable Ambient mode album selection with photo previews.
const base::Feature kAmbientModePhotoPreviewFeature{
"ChromeOSAmbientModePhotoPreview", base::FEATURE_ENABLED_BY_DEFAULT};
// Controls whether to fetch ambient mode images using new url format.
const base::Feature kAmbientModeNewUrl{"ChromeOSAmbientModeNewUrl",
base::FEATURE_ENABLED_BY_DEFAULT};
// Controls whether to enable ARC account restrictions.
const base::Feature kArcAccountRestrictions{"ArcAccountRestrictions",
base::FEATURE_DISABLED_BY_DEFAULT};
// Controls whether to enable ARC ADB sideloading support.
const base::Feature kArcAdbSideloadingFeature{
"ArcAdbSideloading", base::FEATURE_DISABLED_BY_DEFAULT};
// Controls whether to enable support for ARC Input Overlay.
const base::Feature kArcInputOverlay{"ArcInputOverlay",
base::FEATURE_DISABLED_BY_DEFAULT};
// Controls whether to enable support for ARC ADB sideloading for managed
// accounts and/or devices.
const base::Feature kArcManagedAdbSideloadingSupport{
"ArcManagedAdbSideloadingSupport", base::FEATURE_DISABLED_BY_DEFAULT};
// Controls whether to enable assistive autocorrect.
const base::Feature kAssistAutoCorrect{"AssistAutoCorrect",
base::FEATURE_ENABLED_BY_DEFAULT};
// Controls whether to enable enhanced assistive emoji suggestions.
const base::Feature kAssistEmojiEnhanced{"AssistEmojiEnhanced",
base::FEATURE_DISABLED_BY_DEFAULT};
// Controls whether to enable assistive multi word suggestions.
const base::Feature kAssistMultiWord{"AssistMultiWord",
base::FEATURE_DISABLED_BY_DEFAULT};
// Controls whether to enable assistive multi word suggestions on an expanded
// list of surfaces.
const base::Feature kAssistMultiWordExpanded{"AssistMultiWordExpanded",
base::FEATURE_DISABLED_BY_DEFAULT};
// Controls whether to enable lacros support for the assistive multi word
// suggestions feature.
const base::Feature kAssistMultiWordLacrosSupport{
"AssistMultiWordLacrosSupport", base::FEATURE_DISABLED_BY_DEFAULT};
// Controls whether to enable assistive personal information.
const base::Feature kAssistPersonalInfo{"AssistPersonalInfo",
base::FEATURE_DISABLED_BY_DEFAULT};
// Controls whether to suggest addresses in assistive personal information. This
// is only effective when AssistPersonalInfo flag is enabled.
const base::Feature kAssistPersonalInfoAddress{
"AssistPersonalInfoAddress", base::FEATURE_ENABLED_BY_DEFAULT};
// Controls whether to suggest emails in assistive personal information. This is
// only effective when AssistPersonalInfo flag is enabled.
const base::Feature kAssistPersonalInfoEmail{"AssistPersonalInfoEmail",
base::FEATURE_ENABLED_BY_DEFAULT};
// Controls whether to suggest names in assistive personal information. This is
// only effective when AssistPersonalInfo flag is enabled.
const base::Feature kAssistPersonalInfoName{"AssistPersonalInfoName",
base::FEATURE_ENABLED_BY_DEFAULT};
// Controls whether to suggest phone numbers in assistive personal information.
// This is only effective when AssistPersonalInfo flag is enabled.
const base::Feature kAssistPersonalInfoPhoneNumber{
"AssistPersonalInfoPhoneNumber", base::FEATURE_ENABLED_BY_DEFAULT};
// Enables the Audio URL that is designed to help user debug or troubleshoot
// common issues on ChromeOS.
const base::Feature kAudioUrl{"AudioUrl", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables the Auto Night Light feature which sets the default schedule type to
// sunset-to-sunrise until the user changes it to something else. This feature
// is not exposed to the end user, and is enabled only via cros_config for
// certain devices.
const base::Feature kAutoNightLight{"AutoNightLight",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables or disables auto screen-brightness adjustment when ambient light
// changes.
const base::Feature kAutoScreenBrightness{"AutoScreenBrightness",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables the persistent desks bar at the top of the screen in clamshell mode
// when there are more than one desk.
const base::Feature kBentoBar{"BentoBar", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables or disables the usage of fixed Bluetooth A2DP packet size to improve
// audio performance in noisy environment.
const base::Feature kBluetoothFixA2dpPacketSize{
"BluetoothFixA2dpPacketSize", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables or disables the Chrome OS Bluetooth Revamp, which updates Bluetooth
// system UI and related infrastructure. See https://crbug.com/1010321.
const base::Feature kBluetoothRevamp{"BluetoothRevamp",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables or disables Bluetooth WBS microphone be selected as default
// audio input option.
const base::Feature kBluetoothWbsDogfood{"BluetoothWbsDogfood",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enable Big GL when using Borealis.
const base::Feature kBorealisBigGl{"BorealisBigGl",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enable experimental disk management changes for Borealis.
const base::Feature kBorealisDiskManagement{"BorealisDiskManagement",
base::FEATURE_DISABLED_BY_DEFAULT};
// Force the client to be on its beta version. If not set, the client will be on
// its stable version.
const base::Feature kBorealisForceBetaClient{"BorealisForceBetaClient",
base::FEATURE_DISABLED_BY_DEFAULT};
// Prevent Borealis' client from exercising ChromeOS integrations, in this mode
// it functions more like the linux client.
const base::Feature kBorealisLinuxMode{"BorealisLinuxMode",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enable TermsOfServiceURL policy for managed users.
// https://crbug.com/1221342
const base::Feature kManagedTermsOfService{"ManagedTermsOfService",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enable display of button on Arc provisioning failure dialog for network
// tests.
const base::Feature kButtonARCNetworkDiagnostics{
"ButtonARCNetworkDiagnostics", base::FEATURE_ENABLED_BY_DEFAULT};
// Enable or disable calendar view from the system tray. Also enables the system
// tray to show date in the shelf when the screen is sufficiently large.
const base::Feature kCalendarView{"CalendarView",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enable or disable manual crop document page to ChromeOS camera app. The flag
// will be deprecated after feature is fully launched: crbug.com/1259731.
const base::Feature kCameraAppDocumentManualCrop{
"CameraAppDocumentManualCrop", base::FEATURE_ENABLED_BY_DEFAULT};
// Controls whether the camera privacy switch toasts and notification should be
// displayed.
const base::Feature kCameraPrivacySwitchNotifications{
"CameraPrivacySwitchNotifications", base::FEATURE_ENABLED_BY_DEFAULT};
// If enabled, allow eSIM installation bypass the non-cellular internet
// connectivity check.
const base::Feature kCellularBypassESimInstallationConnectivityCheck{
"CellularBypassESimInstallationConnectivityCheck",
base::FEATURE_DISABLED_BY_DEFAULT};
// If enabled, the value of |kCellularUseAttachApn| should have no effect and
// and the LTE attach APN configuration will not be sent to the modem. This
// flag exists because the |kCellularUseAttachApn| flag can be enabled
// by command-line arguments via board overlays which takes precedence over
// server-side field trial config, which may be needed to turn off the Attach
// APN feature.
const base::Feature kCellularForbidAttachApn{"CellularForbidAttachApn",
base::FEATURE_DISABLED_BY_DEFAULT};
// If enabled, send the LTE attach APN configuration to the modem.
const base::Feature kCellularUseAttachApn{"CellularUseAttachApn",
base::FEATURE_ENABLED_BY_DEFAULT};
// If enabled, use external euicc in Cellular Setup and Settings.
const base::Feature kCellularUseExternalEuicc{
"CellularUseExternalEuicc", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables pasting a few recently copied items in a menu when pressing search +
// v.
const base::Feature kClipboardHistory{"ClipboardHistory",
base::FEATURE_ENABLED_BY_DEFAULT};
// If enabled, a blue new nudge will show on the context menu option for
// clipboard history.
const base::Feature kClipboardHistoryContextMenuNudge{
"ClipboardHistoryContextMenuNudge", base::FEATURE_DISABLED_BY_DEFAULT};
// If enabled, the clipboard nudge shown prefs will be reset at the start of
// each new user session.
const base::Feature kClipboardHistoryNudgeSessionReset{
"ClipboardHistoryNudgeSessionReset", base::FEATURE_DISABLED_BY_DEFAULT};
// If enabled, the clipboard history shortcut will appear in screenshot
// notifications.
const base::Feature kClipboardHistoryScreenshotNudge{
"ClipboardHistoryScreenshotNudge", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables compositing-based throttling to throttle appropriate frame sinks that
// do not need to be refreshed at high fps.
const base::Feature kCompositingBasedThrottling{
"CompositingBasedThrottling", base::FEATURE_ENABLED_BY_DEFAULT};
// Enables contextual nudges for gesture education.
const base::Feature kContextualNudges{"ContextualNudges",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables or disables Crosh System Web App. When enabled, crosh (Chrome OS
// Shell) will run as a tabbed System Web App rather than a normal browser tab.
const base::Feature kCroshSWA{"CroshSWA", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables upgrading the crostini container to debian bullseye.
const base::Feature kCrostiniBullseyeUpgrade{"CrostiniBullseyeUpgrade",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables or disables Crostini Disk Resizing.
const base::Feature kCrostiniDiskResizing{"CrostiniDiskResizing",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables or disables Crostini GPU support.
// Note that this feature can be overridden by login_manager based on
// whether a per-board build sets the USE virtio_gpu flag.
// Refer to: chromiumos/src/platform2/login_manager/chrome_setup.cc
const base::Feature kCrostiniGpuSupport{"CrostiniGpuSupport",
base::FEATURE_DISABLED_BY_DEFAULT};
// Force enable recreating the LXD DB at LXD launch.
const base::Feature kCrostiniResetLxdDb{"CrostiniResetLxdDb",
base::FEATURE_DISABLED_BY_DEFAULT};
// Do we use the default LXD version or try LXD 4?
const base::Feature kCrostiniUseLxd4{"CrostiniUseLxd4",
base::FEATURE_DISABLED_BY_DEFAULT};
// Use DLC instead of component updater for managing the Termina image if set
// (and component updater instead of DLC if not).
const base::Feature kCrostiniUseDlc{"CrostiniUseDlc",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables experimental UI creating and managing multiple Crostini containers.
const base::Feature kCrostiniMultiContainer{"CrostiniMultiContainer",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables or disables Crostini IME support.
const base::Feature kCrostiniImeSupport{"CrostiniImeSupport",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables or disables Crostini Virtual Keyboard support.
const base::Feature kCrostiniVirtualKeyboardSupport{
"CrostiniVirtualKeyboardSupport", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables or disables always using device-activity-status data to filter
// eligible host phones.
const base::Feature kCryptAuthV2AlwaysUseActiveEligibleHosts{
"kCryptAuthV2AlwaysUseActiveEligibleHosts",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables or disables using Cryptauth's GetDevicesActivityStatus API.
const base::Feature kCryptAuthV2DeviceActivityStatus{
"CryptAuthV2DeviceActivityStatus", base::FEATURE_ENABLED_BY_DEFAULT};
// Enables or disables use of the connectivity status from Cryptauth's
// GetDevicesActivityStatus API to sort devices.
const base::Feature kCryptAuthV2DeviceActivityStatusUseConnectivity{
"CryptAuthV2DeviceActivityStatusUseConnectivity",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables or disables use of last activity time to deduplicate eligible host
// phones in multidevice setup dropdown list. We assume that different copies
// of same device share the same last activity time but different last update
// time.
const base::Feature kCryptAuthV2DedupDeviceLastActivityTime{
"CryptAuthV2DedupDeviceLastActivityTime", base::FEATURE_ENABLED_BY_DEFAULT};
// Enables or disables the CryptAuth v2 DeviceSync flow. Regardless of this
// flag, v1 DeviceSync will continue to operate until it is disabled via the
// feature flag kDisableCryptAuthV1DeviceSync.
const base::Feature kCryptAuthV2DeviceSync{"CryptAuthV2DeviceSync",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables or disables the CryptAuth v2 Enrollment flow.
const base::Feature kCryptAuthV2Enrollment{"CryptAuthV2Enrollment",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables the Cryptohome recovery feature, which allows users to recover access
// to their profile and Cryptohome after performing an online authentication.
const base::Feature kCryptohomeRecoveryFlow{"CryptohomeRecoveryFlow",
base::FEATURE_DISABLED_BY_DEFAULT};
const base::Feature kDemoModeSWA{"DemoModeSWA",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables or disables Sync for desk templates on Chrome OS.
const base::Feature kDeskTemplateSync{"DeskTemplateSync",
base::FEATURE_DISABLED_BY_DEFAULT};
const base::Feature kDesksTemplates{"DesksTemplates",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables or disables the Diagnostics app.
const base::Feature kDiagnosticsApp{"DiagnosticsApp",
base::FEATURE_ENABLED_BY_DEFAULT};
// If enabled, the navigation panel will be shown in the diagnostics app.
const base::Feature kDiagnosticsAppNavigation{"DiagnosticsAppNavigation",
base::FEATURE_ENABLED_BY_DEFAULT};
// Disables the CryptAuth v1 DeviceSync flow. Note: During the first phase
// of the v2 DeviceSync rollout, v1 and v2 DeviceSync run in parallel. This flag
// is needed to disable the v1 service during the second phase of the rollout.
// kCryptAuthV2DeviceSync should be enabled before this flag is flipped.
const base::Feature kDisableCryptAuthV1DeviceSync{
"DisableCryptAuthV1DeviceSync", base::FEATURE_ENABLED_BY_DEFAULT};
// Disable idle sockets closing on memory pressure for NetworkContexts that
// belong to Profiles. It only applies to Profiles because the goal is to
// improve perceived performance of web browsing within the Chrome OS user
// session by avoiding re-estabshing TLS connections that require client
// certificates.
const base::Feature kDisableIdleSocketsCloseOnMemoryPressure{
"disable_idle_sockets_close_on_memory_pressure",
base::FEATURE_DISABLED_BY_DEFAULT};
// Disables "Office Editing for Docs, Sheets & Slides" component app so handlers
// won't be registered, making it possible to install another version for
// testing.
const base::Feature kDisableOfficeEditingComponentApp{
"DisableOfficeEditingComponentApp", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables indicators to hint where displays are connected.
const base::Feature kDisplayAlignAssist{"DisplayAlignAssist",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables the docked (a.k.a. picture-in-picture) magnifier.
// TODO(afakhry): Remove this after the feature is fully launched.
// https://crbug.com/709824.
const base::Feature kDockedMagnifier{"DockedMagnifier",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables dragging an unpinned open app to pinned app side to pin.
const base::Feature kDragUnpinnedAppToPin{"DragUnpinnedAppToPin",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables dragging and dropping an existing window to new desk in overview.
const base::Feature kDragWindowToNewDesk{"DragWindowToNewDesk",
base::FEATURE_DISABLED_BY_DEFAULT};
// If enabled, DriveFS will be used for Drive sync.
const base::Feature kDriveFs{"DriveFS", base::FEATURE_ENABLED_BY_DEFAULT};
// Enables duplex native messaging between DriveFS and extensions.
const base::Feature kDriveFsBidirectionalNativeMessaging{
"DriveFsBidirectionalNativeMessaging", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables DriveFS' experimental local files mirroring functionality.
const base::Feature kDriveFsMirroring{"DriveFsMirroring",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables the Eche Phone Hub permission onboarding.
const base::Feature kEchePhoneHubPermissionsOnboarding{
"EchePhoneHubPermissionsOnboarding", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables the System Web App (SWA) version of Eche.
const base::Feature kEcheSWA{"EcheSWA", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables the naive resize for the Eche window.
const base::Feature kEcheSWAResizing{"EcheSWAResizing",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables the Debug Mode of Eche.
const base::Feature kEcheSWADebugMode{"EcheSWADebugMode",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables background blur for the app list, shelf, unified system tray,
// autoclick menu, etc. Also enables the AppsGridView mask layer, slower devices
// may have choppier app list animations while in this mode. crbug.com/765292.
const base::Feature kEnableBackgroundBlur{"EnableBackgroundBlur",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables some trials aimed at improving user experiencing when using the
// trackpad to switch desks.
// TODO(https://crbug.com/1191545): Remove this after the feature is launched.
const base::Feature kEnableDesksTrackpadSwipeImprovements{
"EnableDesksTrackpadSwipeImprovements", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables the DNS proxy service providing support split and secure DNS
// for Chrome OS.
const base::Feature kEnableDnsProxy{"EnableDnsProxy",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables setting the device hostname.
const base::Feature kEnableHostnameSetting{"EnableHostnameSetting",
base::FEATURE_DISABLED_BY_DEFAULT};
// Controls whether the Wayland idle-inhibit-unstable-v1 protocol is enabled.
// On Ash, it determines whether the idle inhibit manager is bound by the exo
// Wayland server. On Lacros, it determines whether the power save blocker is
// invoked via Ozone Wayland (if enabled) or via crosapi (if disabled).
const base::Feature kEnableIdleInhibit{"EnableIdleInhibit",
base::FEATURE_DISABLED_BY_DEFAULT};
// If enabled, the input device cards will be shown in the diagnostics app.
const base::Feature kEnableInputInDiagnosticsApp{
"EnableInputInDiagnosticsApp", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables or disables noise cancellation UI toggle.
const base::Feature kEnableInputNoiseCancellationUi{
"EnableInputNoiseCancellationUi", base::FEATURE_ENABLED_BY_DEFAULT};
// Login WebUI was always loaded for legacy reasons even when it was not needed.
// When enabled, it will make login WebUI loaded only before showing it.
const base::Feature kEnableLazyLoginWebUILoading{
"EnableLazyLoginWebUILoading", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables LocalSearchService to be initialized.
const base::Feature kEnableLocalSearchService{"EnableLocalSearchService",
base::FEATURE_ENABLED_BY_DEFAULT};
// If enabled, the networking cards will be shown in the diagnostics app.
const base::Feature kEnableNetworkingInDiagnosticsApp{
"EnableNetworkingInDiagnosticsApp", base::FEATURE_ENABLED_BY_DEFAULT};
// Enables OAuth support when printing via the IPP protocol.
const base::Feature kEnableOAuthIpp{"EnableOAuthIpp",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables the OOBE ChromeVox hint dialog and announcement feature.
const base::Feature kEnableOobeChromeVoxHint{"EnableOobeChromeVoxHint",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables Polymer3 for OOBE
const base::Feature kEnableOobePolymer3{"EnableOobePolymer3",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables skipping of network screen.
const base::Feature kEnableOobeNetworkScreenSkip{
"EnableOobeNetworkScreenSkip", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables toggling Pciguard settings through Settings UI.
const base::Feature kEnablePciguardUi{"EnablePciguardUi",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables showing notification after the password change for SAML users.
const base::Feature kEnableSamlNotificationOnPasswordChangeSuccess{
"EnableSamlNotificationOnPasswordChangeSuccess",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables SAML re-authentication on the lock screen once the sign-in time
// limit expires.
const base::Feature kEnableSamlReauthenticationOnLockscreen{
"EnableSamlReauthenticationOnLockScreen", base::FEATURE_ENABLED_BY_DEFAULT};
// Enables WireGuard VPN, if running a compatible kernel.
const base::Feature kEnableWireGuard{"EnableWireGuard",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables Device End Of Lifetime warning notifications.
const base::Feature kEolWarningNotifications{"EolWarningNotifications",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables or disables enterprise policy control for eSIM cellular networks.
// See https://crbug.com/1231305.
const base::Feature kESimPolicy{"ESimPolicy",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enable or disable bubble showing when an application gains any UI lock.
const base::Feature kExoLockNotification{"ExoLockNotification",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enable or disable use of ordinal (unaccelerated) motion by Exo clients.
const base::Feature kExoOrdinalMotion{"ExoOrdinalMotion",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enable or disable pointer lock for Crostini windows.
const base::Feature kExoPointerLock{"ExoPointerLock",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables policy that controls feature to allow Family Link accounts on school
// owned devices.
const base::Feature kFamilyLinkOnSchoolDevice{"FamilyLinkOnSchoolDevice",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables the Fast Pair feature.
const base::Feature kFastPair{"FastPair", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables mounting various archive formats (in two tiers) in Files App. This
// flag controls the first tier, whose support is very good.
// https://crbug.com/1216245
const base::Feature kFilesArchivemount{"FilesArchivemount",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables mounting various archive formats (in two tiers) in Files App. This
// flag controls the second tier, whose support is more experimental.
// https://crbug.com/1216245
const base::Feature kFilesArchivemount2{"FilesArchivemount2",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enable the updated banner framework.
// https://crbug.com/1228128
const base::Feature kFilesBannerFramework{"FilesBannerFramework",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enable the simple archive extraction.
// https://crbug.com/953256
const base::Feature kFilesExtractArchive{"FilesExtractArchive",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables the System Web App (SWA) version of file manager.
const base::Feature kFilesSWA{"FilesSWA", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables partitioning of removable disks in file manager.
const base::Feature kFilesSinglePartitionFormat{
"FilesSinglePartitionFormat", base::FEATURE_DISABLED_BY_DEFAULT};
// Enable files app trash.
const base::Feature kFilesTrash{"FilesTrash",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables filters in Files app Recents view.
const base::Feature kFiltersInRecents{"FiltersInRecents",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables the firmware updater app.
const base::Feature kFirmwareUpdaterApp = {"FirmwareUpdaterApp",
base::FEATURE_DISABLED_BY_DEFAULT};
// When enabled, there will be an alert bubble showing up when the device
// returns from low brightness (e.g., sleep, closed cover) without a lock screen
// and the active window is in fullscreen.
// TODO(https://crbug.com/1107185): Remove this after the feature is launched.
const base::Feature kFullscreenAlertBubble{"EnableFullscreenBubble",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enable ChromeOS FuseBox service.
const base::Feature kFuseBox{"FuseBox", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables or disables handle of `closeView` message from Gaia. The message is
// supposed to end the flow.
const base::Feature kGaiaCloseViewMessage{"GaiaCloseViewMessage",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables the Gaia reauth endpoint with deleted user customization page.
const base::Feature kGaiaReauthEndpoint{"GaiaReauthEndpoint",
base::FEATURE_ENABLED_BY_DEFAULT};
// Controls gamepad vibration in Exo.
const base::Feature kGamepadVibration{"ExoGamepadVibration",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enable a D-Bus service for accessing gesture properties.
const base::Feature kGesturePropertiesDBusService{
"GesturePropertiesDBusService", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables editing with handwriting gestures within the virtual keyboard.
const base::Feature kHandwritingGestureEditing{
"HandwritingGestureEditing", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables new on-device recognition for legacy handwriting input.
const base::Feature kHandwritingLegacyRecognition{
"HandwritingLegacyRecognition", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables new on-device recognition for legacy handwriting input in all
// supported languages.
const base::Feature kHandwritingLegacyRecognitionAllLang{
"HandwritingLegacyRecognitionAllLang", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables the Background Page in the help app.
const base::Feature kHelpAppBackgroundPage{"HelpAppBackgroundPage",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables the Discover Tab in the help app.
const base::Feature kHelpAppDiscoverTab{"HelpAppDiscoverTab",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables or disables the Help App Discover tab notifications on non-stable
// Chrome OS channels. Used for testing.
const base::Feature kHelpAppDiscoverTabNotificationAllChannels{
"HelpAppDiscoverTabNotificationAllChannels",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enable showing search results from the help app in the launcher.
const base::Feature kHelpAppLauncherSearch{"HelpAppLauncherSearch",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables or disables the flag to synchronize launcher item colors. It is
// in effect only when kLauncherAppSort is enabled.
const base::Feature kLauncherItemColorSync{"LauncherItemColorSync",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enable the search service integration in the Help app.
const base::Feature kHelpAppSearchServiceIntegration{
"HelpAppSearchServiceIntegration", base::FEATURE_ENABLED_BY_DEFAULT};
// Enables a warning about connecting to hidden WiFi networks.
// https://crbug.com/903908
const base::Feature kHiddenNetworkWarning{"HiddenNetworkWarning",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables hiding of ARC media notifications. If this is enabled, all ARC
// notifications that are of the media type will not be shown. This
// is because they will be replaced by native media session notifications.
// TODO(beccahughes): Remove after launch. (https://crbug.com/897836)
const base::Feature kHideArcMediaNotifications{
"HideArcMediaNotifications", base::FEATURE_ENABLED_BY_DEFAULT};
// When enabled, shelf navigation controls and the overview tray item will be
// removed from the shelf in tablet mode (unless otherwise specified by user
// preferences, or policy).
const base::Feature kHideShelfControlsInTabletMode{
"HideShelfControlsInTabletMode", base::FEATURE_ENABLED_BY_DEFAULT};
// Enables V2 implementation for visual representation of in-progress items in
// Tote, the productivity feature that aims to reduce context switching by
// enabling users to collect content and transfer or access it later.
const base::Feature kHoldingSpaceInProgressAnimationV2{
"HoldingSpaceInProgressAnimationV2", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables in-progress downloads integration with the productivity feature that
// aims to reduce context switching by enabling users to collect content and
// transfer or access it later.
const base::Feature kHoldingSpaceInProgressDownloadsIntegration{
"HoldingSpaceInProgressDownloadsIntegration",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables in-progress downloads notification suppression with the productivity
// feature that aims to reduce context switching by enabling users to collect
// content and transfer or access it later.
const base::Feature kHoldingSpaceInProgressDownloadsNotificationSuppression{
"HoldingSpaceInProgressNotificationSuppression",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables incognito profile integration with the productivity feature that
// aims to reduce context switching by enabling users to collect content and
// transfer or access it later.
const base::Feature kHoldingSpaceIncognitoProfileIntegration{
"HoldingSpaceIncognitoProfileIntegration",
base::FEATURE_ENABLED_BY_DEFAULT};
// Controls whether the snooping protection prototype is enabled.
const base::Feature kSnoopingProtection{"SnoopingProtection",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enable or disable dark mode support for the Chrome OS virtual keyboard.
const base::Feature kVirtualKeyboardDarkMode{"VirtualKeyboardDarkMode",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enable or disable MOZC IME to use protobuf as interactive message format.
const base::Feature kImeMozcProto{"ImeMozcProto",
base::FEATURE_ENABLED_BY_DEFAULT};
// If enabled, options page for each input method will be opened in ChromeOS
// settings. Otherwise it will be opened in a new web page in Chrome browser.
const base::Feature kImeOptionsInSettings{"ImeOptionsInSettings",
base::FEATURE_ENABLED_BY_DEFAULT};
// If enabled, used to configure the heuristic rules for some advanced IME
// features (e.g. auto-correct).
const base::Feature kImeRuleConfig{"ImeRuleConfig",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enable or disable system emoji picker.
const base::Feature kImeSystemEmojiPicker{"SystemEmojiPicker",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enable or disable system emoji picker falling back to clipboard.
const base::Feature kImeSystemEmojiPickerClipboard{
"SystemEmojiPickerClipboard", base::FEATURE_DISABLED_BY_DEFAULT};
// Enable or disable system emoji picker extension
const base::Feature kImeSystemEmojiPickerExtension{
"SystemEmojiPickerExtension", base::FEATURE_DISABLED_BY_DEFAULT};
// Enable or disable a new UI for stylus writing on the virtual keyboard
const base::Feature kImeStylusHandwriting{"StylusHandwriting",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables improved keyboard shortcuts for activating desks at specified indices
// and toggling whether a window is assigned to all desks.
const base::Feature kImprovedDesksKeyboardShortcuts{
"ImprovedDesksKeyboardShortcuts", base::FEATURE_ENABLED_BY_DEFAULT};
// Enable or disable the improved screen capture settings.
const base::Feature kImprovedScreenCaptureSettings{
"ImprovedScreenCaptureSettings", base::FEATURE_ENABLED_BY_DEFAULT};
// Enables or disables Instant Tethering on Chrome OS.
const base::Feature kInstantTethering{"InstantTethering",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables using arrow keys for display arrangement in display settings page.
const base::Feature kKeyboardBasedDisplayArrangementInSettings{
"KeyboardBasedDisplayArrangementInSettings",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables to use lacros-chrome as a primary web browser on Chrome OS.
// This works only when LacrosSupport below is enabled.
// NOTE: Use crosapi::browser_util::IsLacrosPrimary() instead of checking
// the feature directly. Similar to LacrosSupport, this may not be allowed
// depending on user types and/or policies.
const base::Feature kLacrosPrimary{"LacrosPrimary",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables "Linux and Chrome OS" support. Allows a Linux version of Chrome
// ("lacros-chrome") to run as a Wayland client with this instance of Chrome
// ("ash-chrome") acting as the Wayland server and window manager.
// NOTE: Use crosapi::browser_util::IsLacrosEnabled() instead of checking the
// feature directly. Lacros is not allowed for certain user types and can be
// disabled by policy. These restrictions will be lifted when Lacros development
// is complete.
const base::Feature kLacrosSupport{"LacrosSupport",
base::FEATURE_DISABLED_BY_DEFAULT};
// Pretend that profile migration has been completed regardless of the actual
// state. Enabling this will allow users to use lacros without completing
// profile mgiration.
const base::Feature kForceProfileMigrationCompletion{
"ForceProfileMigrationCompletion", base::FEATURE_DISABLED_BY_DEFAULT};
// Enable this to turn on profile migration for non-googlers. Currently the
// feature is only limited to googlers only.
const base::Feature kLacrosProfileMigrationForAnyUser{
"LacrosProfileMigrationForAnyUser", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables or disables Language Packs for Handwriting Recognition.
// This feature turns on the download of language-specific Handwriting models
// via DLC.
const base::Feature kLanguagePacksHandwriting{
"LanguagePacksHandwriting", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables or disables the second language settings update.
const base::Feature kLanguageSettingsUpdate2{"LanguageSettingsUpdate2",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables or disables sorting app icons shown on the launcher.
const base::Feature kLauncherAppSort{"LauncherAppSort",
base::FEATURE_DISABLED_BY_DEFAULT};
// Uses short intervals for launcher nudge for testing if enabled.
const base::Feature kLauncherNudgeShortInterval{
"LauncherNudgeShortInterval", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables new flow for license packaged devices with enterprise license.
const base::Feature kLicensePackagedOobeFlow{"LicensePackagedOobeFlow",
base::FEATURE_ENABLED_BY_DEFAULT};
// Supports the feature to hide sensitive content in notifications on the lock
// screen. This option is effective when |kLockScreenNotification| is enabled.
const base::Feature kLockScreenHideSensitiveNotificationsSupport{
"LockScreenHideSensitiveNotificationsSupport",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables inline reply on notifications on the lock screen.
// This option is effective when |kLockScreenNotification| is enabled.
const base::Feature kLockScreenInlineReply{"LockScreenInlineReply",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables notifications on the lock screen.
const base::Feature kLockScreenNotifications{"LockScreenNotifications",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables lock screen media controls UI and use of media keys on the lock
// screen.
const base::Feature kLockScreenMediaControls{"LockScreenMediaControls",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables the redesigned managed device info UI in the system tray.
const base::Feature kManagedDeviceUIRedesign{"ManagedDeviceUIRedesign",
base::FEATURE_ENABLED_BY_DEFAULT};
// Whether audio files are opened by default in the ChromeOS media app.
const base::Feature kMediaAppHandlesAudio{"MediaAppHandlesAudio",
base::FEATURE_ENABLED_BY_DEFAULT};
// Whether PDF files are opened by default in the ChromeOS media app.
const base::Feature kMediaAppHandlesPdf{"MediaAppHandlesPdf",
base::FEATURE_DISABLED_BY_DEFAULT};
// Feature to continuously log PSI memory pressure data to UMA.
const base::Feature kMemoryPressureMetricsDetail{
"MemoryPressureMetricsDetail", base::FEATURE_ENABLED_BY_DEFAULT};
// Controls how frequently memory pressure is logged
const base::FeatureParam<int> kMemoryPressureMetricsDetailLogPeriod{
&kMemoryPressureMetricsDetail, "period", 10};
// Enables notification of when a microphone-using app is launched while the
// microphone is muted.
const base::Feature kMicMuteNotifications{"MicMuteNotifications",
base::FEATURE_ENABLED_BY_DEFAULT};
// Controls whether to enable the requirement of a minimum chrome version on the
// device through the policy DeviceMinimumVersion. If the requirement is
// not met and the warning time in the policy has expired, the user is
// restricted from using the session.
const base::Feature kMinimumChromeVersion{"MinimumChromeVersion",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables support for AADC regulation requirement and avoid nudging users in
// minor mode(e.g. under the age of 18) to provide unnecessary consents to share
// personal data.
const base::Feature kMinorModeRestriction{"MinorModeRestriction",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables the use of Mojo by Chrome-process code to communicate with Power
// Manager. In order to use mojo, this feature must be turned on and a callsite
// must use PowerManagerMojoClient::Get().
const base::Feature kMojoDBusRelay{"MojoDBusRelay",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables support for multilingual assistive typing on Chrome OS.
const base::Feature kMultilingualTyping{"MultilingualTyping",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables Nearby Connections to specificy KeepAlive interval and timeout while
// also making the Nearby Connections WebRTC defaults longer.
const base::Feature kNearbyKeepAliveFix{"NearbyKeepAliveFix",
base::FEATURE_ENABLED_BY_DEFAULT};
// Controls whether new Lockscreen reauth layout is shown or not.
const base::Feature kNewLockScreenReauthLayout{
"NewLockScreenReauthLayout", base::FEATURE_ENABLED_BY_DEFAULT};
// Enables the Night Light feature.
const base::Feature kNightLight{"NightLight", base::FEATURE_ENABLED_BY_DEFAULT};
// Enabled notification expansion animation.
const base::Feature kNotificationExpansionAnimation{
"NotificationExpansionAnimation", base::FEATURE_DISABLED_BY_DEFAULT};
// Shorten notification timeouts to 6 seconds.
const base::Feature kNotificationExperimentalShortTimeouts{
"NotificationExperimentalShortTimeouts", base::FEATURE_ENABLED_BY_DEFAULT};
// Enables notification scroll bar in UnifiedSystemTray.
const base::Feature kNotificationScrollBar{"NotificationScrollBar",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables notifications to be shown within context menus.
const base::Feature kNotificationsInContextMenu{
"NotificationsInContextMenu", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables new notifications UI and grouped notifications.
const base::Feature kNotificationsRefresh{"NotificationsRefresh",
base::FEATURE_DISABLED_BY_DEFAULT};
// Controls whether to enable on-device grammar check service.
const base::Feature kOnDeviceGrammarCheck{"OnDeviceGrammarCheck",
base::FEATURE_DISABLED_BY_DEFAULT};
// Whether the device supports on-device speech recognition.
const base::Feature kOnDeviceSpeechRecognition{
"OnDeviceSpeechRecognition", base::FEATURE_DISABLED_BY_DEFAULT};
// If enabled, EULA and ARC Terms of Service screens are skipped and merged
// into Consolidated Consent Screen.
const base::Feature kOobeConsolidatedConsent{"OobeConsolidatedConsent",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables or disables the Oobe quick start flow.
const base::Feature kOobeQuickStart{"OobeQuickStart",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables or disables the feedback tool new UX on Chrome OS.
// This tool under development will be rolled out via Finch.
// Enabling this flag will use the new feedback tool instead of the current
// tool on CrOS.
const base::Feature kOsFeedback{"OsFeedback",
base::FEATURE_DISABLED_BY_DEFAULT};
// If enabled, a new App Notifications subpage will appear in CrOS Apps section.
const base::Feature kOsSettingsAppNotificationsPage{
"OsSettingsAppNotificationsPage", base::FEATURE_ENABLED_BY_DEFAULT};
const base::Feature kOverviewButton{"OverviewButton",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables a notification warning users that their Thunderbolt device is not
// supported on their CrOS device.
const base::Feature kPcieBillboardNotification{
"PcieBillboardNotification", base::FEATURE_DISABLED_BY_DEFAULT};
// Limits the items on the shelf to the ones associated with windows the
// currently active desk.
const base::Feature kPerDeskShelf{"PerDeskShelf",
base::FEATURE_DISABLED_BY_DEFAULT};
// Allows tablet mode split screen to resize by moving windows instead of
// resizing. This reduces jank on low end devices.
const base::Feature kPerformantSplitViewResizing{
"PerformantSplitViewResizing", base::FEATURE_DISABLED_BY_DEFAULT};
// Provides a UI for users to customize their wallpapers, screensaver and
// avatars.
const base::Feature kPersonalizationHub{"PersonalizationHub",
base::FEATURE_DISABLED_BY_DEFAULT};
// Provides a UI for users to view information about their Android phone
// and perform phone-side actions within Chrome OS.
const base::Feature kPhoneHub{"PhoneHub", base::FEATURE_ENABLED_BY_DEFAULT};
// Enables the Camera Roll feature in Phone Hub, which allows users to access
// recent photos and videos taken on a connected Android device
const base::Feature kPhoneHubCameraRoll{"PhoneHubCameraRoll",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables the incoming/ongoing call notification feature in Phone Hub.
const base::Feature kPhoneHubCallNotification{
"PhoneHubCallNotification", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables the Recent Apps feature in Phone Hub, which allows users to relaunch
// the streamed app.
const base::Feature kPhoneHubRecentApps{"PhoneHubRecentApps",
base::FEATURE_DISABLED_BY_DEFAULT};
const base::Feature kPinSetupForManagedUsers{"PinSetupForManagedUsers",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables rounded corners for the Picture-in-picture window.
const base::Feature kPipRoundedCorners{"PipRoundedCorners",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables or disables the preference of using constant frame rate for camera
// when streaming.
const base::Feature kPreferConstantFrameRate{"PreferConstantFrameRate",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables a bubble-based launcher in clamshell mode. Changes the suggestions
// that appear in the launcher in both clamshell and tablet modes. Removes pages
// from the apps grid. This feature was previously named "AppListBubble".
// https://crbug.com/1204551
const base::Feature kProductivityLauncher{"ProductivityLauncher",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables animation in the productivity launcher.
const base::Feature kProductivityLauncherAnimation{
"ProductivityLauncherAnimation", base::FEATURE_ENABLED_BY_DEFAULT};
// Controls whether to enable Projector.
const base::Feature kProjector{"Projector", base::FEATURE_DISABLED_BY_DEFAULT};
// Controls whether to enable Projector for managed users.
const base::Feature kProjectorManagedUser{"ProjectorManagedUser",
base::FEATURE_DISABLED_BY_DEFAULT};
// Controls whether to enable Projector in status tray.
const base::Feature kProjectorFeaturePod{"ProjectorFeaturePod",
base::FEATURE_DISABLED_BY_DEFAULT};
// Controls whether to enable Projector annotator or marker tools.
// The annotator tools are newer and based on the ink library.
// The marker tools are older and based on fast ink.
// We are deprecating the old marker tools in favor of the annotator tools.
const base::Feature kProjectorAnnotator{"ProjectorAnnotator",
base::FEATURE_ENABLED_BY_DEFAULT};
// Controls whether the quick dim prototype is enabled.
const base::Feature kQuickDim{"QuickDim", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables or disables the Quick Settings Network revamp, which updates Network
// Quick Settings UI and related infrastructure. See https://crbug.com/1169479.
const base::Feature kQuickSettingsNetworkRevamp{
"QuickSettingsNetworkRevamp", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables or disables fingerprint quick unlock.
const base::Feature kQuickUnlockFingerprint{"QuickUnlockFingerprint",
base::FEATURE_DISABLED_BY_DEFAULT};
// Controls whether the PIN auto submit feature is enabled.
const base::Feature kQuickUnlockPinAutosubmit{"QuickUnlockPinAutosubmit",
base::FEATURE_ENABLED_BY_DEFAULT};
// TODO(crbug.com/1104164) - Remove this once most
// users have their preferences backfilled.
// Controls whether the PIN auto submit backfill operation should be performed.
const base::Feature kQuickUnlockPinAutosubmitBackfill{
"QuickUnlockPinAutosubmitBackfill", base::FEATURE_ENABLED_BY_DEFAULT};
// Enables suppression of Displays notifications other than resolution change.
const base::Feature kReduceDisplayNotifications{
"ReduceDisplayNotifications", base::FEATURE_ENABLED_BY_DEFAULT};
// Enables or disables Release Notes notifications on non-stable Chrome OS
// channels. Used for testing.
const base::Feature kReleaseNotesNotificationAllChannels{
"ReleaseNotesNotificationAllChannels", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables or disables Release Notes suggestion chip on Chrome OS.
const base::Feature kReleaseNotesSuggestionChip{
"ReleaseNotesSuggestionChip", base::FEATURE_ENABLED_BY_DEFAULT};
// Enables or disables Reven Log Source on Chrome OS. This adds hardware
// information to Feedback reports and chrome://system on CloudReady systems.
const base::Feature kRevenLogSource{"RevenLogSource",
base::FEATURE_ENABLED_BY_DEFAULT};
// When enabled, the overivew and desk reverse scrolling behaviors are changed
// and if the user performs the old gestures, a notification or toast will show
// up.
// TODO(https://crbug.com/1107183): Remove this after the feature is launched.
const base::Feature kReverseScrollGestures{"EnableReverseScrollGestures",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables the system tray to show more information in larger screen.
const base::Feature kScalableStatusArea{"ScalableStatusArea",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables or disables flatbed multi-page scanning.
const base::Feature kScanAppMultiPageScan{"ScanAppMultiPageScan",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables or disables use of Searchable PDF file type in the Scan app.
const base::Feature kScanAppSearchablePdf{"ScanAppSearchablePdf",
base::FEATURE_DISABLED_BY_DEFAULT};
// Overrides semantic colors in Chrome OS for easier debugging.
const base::Feature kSemanticColorsDebugOverride{
"SemanticColorDebugOverride", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables displaying separate network icons for different networks types.
// https://crbug.com/902409
const base::Feature kSeparateNetworkIcons{"SeparateNetworkIcons",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables or disables long kill timeout for session manager daemon. When
// enabled, session manager daemon waits for a longer time (e.g. 12s) for chrome
// to exit before sending SIGABRT. Otherwise, it uses the default time out
// (currently 3s).
const base::Feature kSessionManagerLongKillTimeout{
"SessionManagerLongKillTimeout", base::FEATURE_DISABLED_BY_DEFAULT};
// If enabled, the session manager daemon will abort the browser if its
// liveness checker detects a hang, i.e. the browser fails to acknowledge and
// respond sufficiently to periodic pings. IMPORTANT NOTE: the feature name
// here must match exactly the name of the feature in the open-source ChromeOS
// file session_manager_service.cc.
const base::Feature kSessionManagerLivenessCheck{
"SessionManagerLivenessCheck", base::FEATURE_ENABLED_BY_DEFAULT};
// Removes notifier settings from quick settings view.
const base::Feature kSettingsAppNotificationSettings{
"SettingsAppNotificationSettings", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables launcher nudge that animates the home button to guide users to open
// the launcher.
const base::Feature kShelfLauncherNudge{"ShelfLauncherNudge",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables the shelf party.
const base::Feature kShelfParty{"ShelfParty",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables or disables the new shimless rma flow.
const base::Feature kShimlessRMAFlow{"ShimlessRMAFlow",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables or disables a toggle to enable Bluetooth debug logs.
const base::Feature kShowBluetoothDebugLogToggle{
"ShowBluetoothDebugLogToggle", base::FEATURE_ENABLED_BY_DEFAULT};
// Whether to show domain-related questionnaire in feedback report UI
// (crbug/1241169).
const base::Feature kShowFeedbackReportQuestionnaire{
"FeedbackReportQuestionnaire", base::FEATURE_ENABLED_BY_DEFAULT};
// Shows the Play Store icon in Demo Mode.
const base::Feature kShowPlayInDemoMode{"ShowPlayInDemoMode",
base::FEATURE_ENABLED_BY_DEFAULT};
// Uses experimental component version for smart dim.
const base::Feature kSmartDimExperimentalComponent{
"SmartDimExperimentalComponent", base::FEATURE_DISABLED_BY_DEFAULT};
// Replaces Smart Lock UI in lock screen password box with new UI similar to
// fingerprint auth. Adds Smart Lock to "Lock screen and sign-in" section of
// settings.
const base::Feature kSmartLockUIRevamp{"SmartLockUIRevamp",
base::FEATURE_DISABLED_BY_DEFAULT};
// This feature:
// - Creates a new "Sync your settings" section in Chrome OS settings
// - Moves app, wallpaper and Wi-Fi sync to OS settings
// - Provides a separate toggle for OS preferences, distinct from browser
// preferences
// - Makes the OS ModelTypes run in sync transport mode, controlled by a single
// pref for the entire OS sync feature
const base::Feature kSyncSettingsCategorization{
"SyncSettingsCategorization", base::FEATURE_DISABLED_BY_DEFAULT};
// Updates the OOBE sync consent screen
//
// NOTE: The feature will be rolled out via a client-side Finch trial, so the
// actual state will vary. TODO(https://crbug.com/1227417): Migrate config in
// chrome/browser/ash/sync/sync_consent_optional_field_trial.cc
const base::Feature kSyncConsentOptional{"SyncConsentOptional",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables battery indicator for styluses in the palette tray
const base::Feature kStylusBatteryStatus{"StylusBatteryStatus",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables or disables using the system input engine for physical typing in
// Chinese.
const base::Feature kSystemChinesePhysicalTyping{
"SystemChinesePhysicalTyping", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables or disables the System Extensions platform.
const base::Feature kSystemExtensions{"SystemExtensions",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables or disables using the system input engine for physical typing in
// Japanese.
const base::Feature kSystemJapanesePhysicalTyping{
"SystemJapanesePhysicalTyping", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables or disables using the system input engine for physical typing in
// Korean.
const base::Feature kSystemKoreanPhysicalTyping{
"SystemKoreanPhysicalTyping", base::FEATURE_ENABLED_BY_DEFAULT};
// Enables the Chrome OS system-proxy daemon, only for system services. This
// means that system services like tlsdate, update engine etc. can opt to be
// authenticated to a remote HTTP web proxy via system-proxy.
const base::Feature kSystemProxyForSystemServices{
"SystemProxyForSystemServices", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables the UI to show tab cluster info.
const base::Feature kTabClusterUI{"TabClusterUI",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables Chrome OS Telemetry Extension.
const base::Feature kTelemetryExtension{"TelemetryExtension",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables SSH tabs in the Terminal System App.
const base::Feature kTerminalSSH{"TerminalSSH",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables tmux integration in the Terminal System App.
const base::Feature kTerminalTmuxIntegration{"TerminalTmuxIntegration",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables the Settings UI to show data usage for cellular networks.
const base::Feature kTrafficCountersSettingsUi{
"TrafficCountersSettingsUi", base::FEATURE_ENABLED_BY_DEFAULT};
// Enables trilinear filtering.
const base::Feature kTrilinearFiltering{"TrilinearFiltering",
base::FEATURE_DISABLED_BY_DEFAULT};
// Uses new AuthSession-based API in cryptohome to authenticate users during
// sign-in.
const base::Feature kUseAuthsessionAuthentication{
"UseAuthsessionAuthentication", base::FEATURE_DISABLED_BY_DEFAULT};
// Enables using the BluetoothSystem Mojo interface for Bluetooth operations.
const base::Feature kUseBluetoothSystemInAsh{"UseBluetoothSystemInAsh",
base::FEATURE_DISABLED_BY_DEFAULT};
// Use the staging URL as part of the "Messages" feature under "Connected
// Devices" settings.
const base::Feature kUseMessagesStagingUrl{"UseMessagesStagingUrl",
base::FEATURE_DISABLED_BY_DEFAULT};
// Remap search+click to right click instead of the legacy alt+click on
// Chrome OS.
const base::Feature kUseSearchClickForRightClick{
"UseSearchClickForRightClick", base::FEATURE_DISABLED_BY_DEFAULT};
// Use the Stork Production SM-DS address to fetch pending ESim profiles
const base::Feature kUseStorkSmdsServerAddress{
"UseStorkSmdsServerAddress", base::FEATURE_DISABLED_BY_DEFAULT};
// Use the staging server as part of the Wallpaper App to verify
// additions/removals of wallpapers.
const base::Feature kUseWallpaperStagingUrl{"UseWallpaperStagingUrl",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables or disables user activity prediction for power management on
// Chrome OS.
// Defined here rather than in //chrome alongside other related features so that
// PowerPolicyController can check it.
const base::Feature kUserActivityPrediction{"UserActivityPrediction",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enable or disable bordered key for virtual keyboard on Chrome OS.
const base::Feature kVirtualKeyboardBorderedKey{
"VirtualKeyboardBorderedKey", base::FEATURE_ENABLED_BY_DEFAULT};
// Enable or disable multipaste feature for virtual keyboard on Chrome OS.
const base::Feature kVirtualKeyboardMultipaste{
"VirtualKeyboardMultipaste", base::FEATURE_ENABLED_BY_DEFAULT};
// Enable or disable showing multipaste suggestions in virtual keyboard on
// Chrome OS.
const base::Feature kVirtualKeyboardMultipasteSuggestion{
"VirtualKeyboardMultipasteSuggestion", base::FEATURE_DISABLED_BY_DEFAULT};
// Controls whether to allow enabling wake on WiFi features in shill.
const base::Feature kWakeOnWifiAllowed{"WakeOnWifiAllowed",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enable new wallpaper experience SWA.
const base::Feature kWallpaperWebUI{"WallpaperWebUI",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enable full screen wallpaper preview in new wallpaper experience. Requires
// |kWallpaperWebUI| to also be enabled.
const base::Feature kWallpaperFullScreenPreview{
"WallpaperFullScreenPreview", base::FEATURE_DISABLED_BY_DEFAULT};
// Enable Google Photos integration in the new wallpaper experience. Note that
// this feature flag does not have any effect if `kWallpaperWebUI` is disabled.
const base::Feature kWallpaperGooglePhotosIntegration{
"WallpaperGooglePhotosIntegration", base::FEATURE_DISABLED_BY_DEFAULT};
// Enable different wallpapers per desk.
const base::Feature kWallpaperPerDesk{"WallpaperPerDesk",
base::FEATURE_DISABLED_BY_DEFAULT};
// Generates WebAPKs representing installed PWAs and installs them inside ARC.
const base::Feature kWebApkGenerator{"WebApkGenerator",
base::FEATURE_ENABLED_BY_DEFAULT};
// Enables special handling of Chrome tab drags from a WebUI tab strip.
// These will be treated similarly to a window drag, showing split view
// indicators in tablet mode, etc. The functionality is behind a flag right now
// since it is under development.
const base::Feature kWebUITabStripTabDragIntegration{
"WebUITabStripTabDragIntegration", base::FEATURE_ENABLED_BY_DEFAULT};
// Controls whether to enable MAC Address Randomization on WiFi connection.
const base::Feature kWifiConnectMacAddressRandomization{
"WifiConnectMacAddressRandomization", base::FEATURE_DISABLED_BY_DEFAULT};
// Controls whether to enable the syncing of deletes of Wi-Fi configurations.
// This only controls sending delete events to the Chrome Sync server.
const base::Feature kWifiSyncAllowDeletes{"WifiSyncAllowDeletes",
base::FEATURE_ENABLED_BY_DEFAULT};
// Controls whether to enable syncing of Wi-Fi configurations between
// ChromeOS and a connected Android phone.
const base::Feature kWifiSyncAndroid{"WifiSyncAndroid",
base::FEATURE_ENABLED_BY_DEFAULT};
// Controls whether to apply incoming Wi-Fi configuration delete events from
// the Chrome Sync server.
const base::Feature kWifiSyncApplyDeletes{"WifiSyncApplyDeletes",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables a window control menu to snap, float and move window to another desk.
// https://crbug.com/1240411
const base::Feature kWindowControlMenu{"WindowControlMenu",
base::FEATURE_DISABLED_BY_DEFAULT};
// Change window creation to be based on cursor position when there are multiple
// displays.
const base::Feature kWindowsFollowCursor{"WindowsFollowCursor",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables or disables Fresnel Device Active reporting on Chrome OS.
const base::Feature kDeviceActiveClient{"DeviceActiveClient",
base::FEATURE_DISABLED_BY_DEFAULT};
// Enables or disables whether to store UMA logs per-user and whether metrics
// consent is per-user.
const base::Feature kPerUserMetrics{"PerUserMetricsConsent",
base::FEATURE_DISABLED_BY_DEFAULT};
////////////////////////////////////////////////////////////////////////////////
bool AreContextualNudgesEnabled() {
if (!IsHideShelfControlsInTabletModeEnabled())
return false;
return base::FeatureList::IsEnabled(kContextualNudges);
}
bool AreDesksTemplatesEnabled() {
return base::FeatureList::IsEnabled(kDesksTemplates);
}
bool AreDesksTrackpadSwipeImprovementsEnabled() {
return base::FeatureList::IsEnabled(kEnableDesksTrackpadSwipeImprovements);
}
bool AreImprovedScreenCaptureSettingsEnabled() {
return base::FeatureList::IsEnabled(kImprovedScreenCaptureSettings);
}
bool DoWindowsFollowCursor() {
return base::FeatureList::IsEnabled(kWindowsFollowCursor);
}
bool IsAdjustSplitViewForVKEnabled() {
return base::FeatureList::IsEnabled(kAdjustSplitViewForVK);
}
bool IsAllowAmbientEQEnabled() {
return base::FeatureList::IsEnabled(kAllowAmbientEQ);
}
bool IsAmbientModeDevUseProdEnabled() {
return base::FeatureList::IsEnabled(kAmbientModeDevUseProdFeature);
}
bool IsAmbientModeEnabled() {
return base::FeatureList::IsEnabled(kAmbientModeFeature);
}
bool IsAmbientModePhotoPreviewEnabled() {
return base::FeatureList::IsEnabled(kAmbientModePhotoPreviewFeature);
}
bool IsAmbientModeNewUrlEnabled() {
return base::FeatureList::IsEnabled(kAmbientModeNewUrl);
}
bool IsAppNotificationsPageEnabled() {
return base::FeatureList::IsEnabled(kOsSettingsAppNotificationsPage);
}
bool IsArcInputOverlayEnabled() {
return base::FeatureList::IsEnabled(kArcInputOverlay);
}
bool IsArcNetworkDiagnosticsButtonEnabled() {
return IsNetworkingInDiagnosticsAppEnabled() &&
base::FeatureList::IsEnabled(kButtonARCNetworkDiagnostics);
}
bool IsAssistiveMultiWordEnabled() {
return base::FeatureList::IsEnabled(kAssistMultiWord);
}
bool IsAutoNightLightEnabled() {
return base::FeatureList::IsEnabled(kAutoNightLight);
}
bool IsBackgroundBlurEnabled() {
bool enabled_by_feature_flag =
base::FeatureList::IsEnabled(kEnableBackgroundBlur);
#if defined(ARCH_CPU_ARM_FAMILY)
// Enable background blur on Mali when GPU rasterization is enabled.
// See crbug.com/996858 for the condition.
return enabled_by_feature_flag &&
base::CommandLine::ForCurrentProcess()->HasSwitch(
switches::kAshEnableTabletMode);
#else
return enabled_by_feature_flag;
#endif
}
bool IsBentoBarEnabled() {
return base::FeatureList::IsEnabled(kBentoBar);
}
bool IsBluetoothRevampEnabled() {
return base::FeatureList::IsEnabled(kBluetoothRevamp);
}
bool IsCalendarViewEnabled() {
return base::FeatureList::IsEnabled(kCalendarView);
}
bool IsClipboardHistoryContextMenuNudgeEnabled() {
return base::FeatureList::IsEnabled(kClipboardHistoryContextMenuNudge);
}
bool IsClipboardHistoryEnabled() {
return base::FeatureList::IsEnabled(kClipboardHistory);
}
bool IsClipboardHistoryNudgeSessionResetEnabled() {
return base::FeatureList::IsEnabled(kClipboardHistoryNudgeSessionReset);
}
bool IsLauncherItemColorSyncEnabled() {
return IsLauncherAppSortEnabled() &&
base::FeatureList::IsEnabled(kLauncherItemColorSync);
}
bool IsClipboardHistoryScreenshotNudgeEnabled() {
return base::FeatureList::IsEnabled(kClipboardHistoryScreenshotNudge);
}
bool IsCompositingBasedThrottlingEnabled() {
return base::FeatureList::IsEnabled(kCompositingBasedThrottling);
}
bool IsCryptohomeRecoveryFlowEnabled() {
return base::FeatureList::IsEnabled(kCryptohomeRecoveryFlow);
}
bool IsDarkLightModeEnabled() {
return chromeos::features::IsDarkLightModeEnabled();
}
bool IsDemoModeSWAEnabled() {
return base::FeatureList::IsEnabled(kDemoModeSWA);
}
bool IsDeskTemplateSyncEnabled() {
return base::FeatureList::IsEnabled(kDeskTemplateSync);
}
bool IsDiagnosticsAppEnabled() {
return base::FeatureList::IsEnabled(kDiagnosticsApp);
}
bool IsDisplayAlignmentAssistanceEnabled() {
return base::FeatureList::IsEnabled(kDisplayAlignAssist);
}
bool IsDragUnpinnedAppToPinEnabled() {
return base::FeatureList::IsEnabled(kDragUnpinnedAppToPin);
}
bool IsDragWindowToNewDeskEnabled() {
return base::FeatureList::IsEnabled(kDragWindowToNewDesk);
}
bool IsEchePhoneHubPermissionsOnboarding() {
return base::FeatureList::IsEnabled(kEchePhoneHubPermissionsOnboarding);
}
bool IsEcheSWAEnabled() {
return base::FeatureList::IsEnabled(kEcheSWA);
}
bool IsEcheSWAResizingEnabled() {
return base::FeatureList::IsEnabled(kEcheSWAResizing);
}
bool IsEcheSWADebugModeEnabled() {
return base::FeatureList::IsEnabled(kEcheSWADebugMode);
}
bool IsESimPolicyEnabled() {
return base::FeatureList::IsEnabled(kESimPolicy);
}
bool IsFamilyLinkOnSchoolDeviceEnabled() {
return base::FeatureList::IsEnabled(kFamilyLinkOnSchoolDevice);
}
bool IsFastPairEnabled() {
return base::FeatureList::IsEnabled(kFastPair);
}
bool IsFileManagerSwaEnabled() {
return base::FeatureList::IsEnabled(kFilesSWA);
}
bool IsFirmwareUpdaterAppEnabled() {
return base::FeatureList::IsEnabled(kFirmwareUpdaterApp);
}
bool IsFullscreenAlertBubbleEnabled() {
return base::FeatureList::IsEnabled(kFullscreenAlertBubble);
}
bool IsGaiaCloseViewMessageEnabled() {
return base::FeatureList::IsEnabled(kGaiaCloseViewMessage);
}
bool IsGaiaReauthEndpointEnabled() {
return base::FeatureList::IsEnabled(kGaiaReauthEndpoint);
}
bool IsHideArcMediaNotificationsEnabled() {
return base::FeatureList::IsEnabled(kHideArcMediaNotifications);
}
bool IsHideShelfControlsInTabletModeEnabled() {
return base::FeatureList::IsEnabled(kHideShelfControlsInTabletMode);
}
bool IsHoldingSpaceInProgressAnimationV2Enabled() {
return base::FeatureList::IsEnabled(kHoldingSpaceInProgressAnimationV2);
}
bool IsHoldingSpaceInProgressDownloadsIntegrationEnabled() {
return base::FeatureList::IsEnabled(
kHoldingSpaceInProgressDownloadsIntegration);
}
bool IsHoldingSpaceInProgressDownloadsNotificationSuppressionEnabled() {
return base::FeatureList::IsEnabled(
kHoldingSpaceInProgressDownloadsNotificationSuppression);
}
bool IsHoldingSpaceIncognitoProfileIntegrationEnabled() {
return base::FeatureList::IsEnabled(kHoldingSpaceIncognitoProfileIntegration);
}
bool IsHostnameSettingEnabled() {
return base::FeatureList::IsEnabled(kEnableHostnameSetting);
}
bool IsSnoopingProtectionEnabled() {
return base::FeatureList::IsEnabled(kSnoopingProtection);
}
bool IsIdleInhibitEnabled() {
return base::FeatureList::IsEnabled(kEnableIdleInhibit);
}
bool IsImprovedDesksKeyboardShortcutsEnabled() {
return base::FeatureList::IsEnabled(kImprovedDesksKeyboardShortcuts);
}
bool IsInputInDiagnosticsAppEnabled() {
return base::FeatureList::IsEnabled(kEnableInputInDiagnosticsApp);
}
bool IsInputNoiseCancellationUiEnabled() {
return base::FeatureList::IsEnabled(kEnableInputNoiseCancellationUi);
}
bool IsInstantTetheringBackgroundAdvertisingSupported() {
return base::FeatureList::IsEnabled(
kInstantTetheringBackgroundAdvertisementSupport);
}
bool IsKeyboardBasedDisplayArrangementInSettingsEnabled() {
return base::FeatureList::IsEnabled(
kKeyboardBasedDisplayArrangementInSettings);
}
bool IsLauncherAppSortEnabled() {
return IsProductivityLauncherEnabled() &&
base::FeatureList::IsEnabled(kLauncherAppSort);
}
bool IsLauncherNudgeShortIntervalEnabled() {
return IsProductivityLauncherEnabled() &&
base::FeatureList::IsEnabled(kLauncherNudgeShortInterval);
}
bool IsLicensePackagedOobeFlowEnabled() {
return base::FeatureList::IsEnabled(kLicensePackagedOobeFlow);
}
bool IsLockScreenHideSensitiveNotificationsSupported() {
return base::FeatureList::IsEnabled(
kLockScreenHideSensitiveNotificationsSupport);
}
bool IsLockScreenInlineReplyEnabled() {
return base::FeatureList::IsEnabled(kLockScreenInlineReply);
}
bool IsLockScreenNotificationsEnabled() {
return base::FeatureList::IsEnabled(kLockScreenNotifications);
}
bool IsManagedDeviceUIRedesignEnabled() {
return base::FeatureList::IsEnabled(kManagedDeviceUIRedesign);
}
bool IsManagedTermsOfServiceEnabled() {
return base::FeatureList::IsEnabled(kManagedTermsOfService);
}
bool IsMicMuteNotificationsEnabled() {
return base::FeatureList::IsEnabled(kMicMuteNotifications);
}
bool IsMinimumChromeVersionEnabled() {
return base::FeatureList::IsEnabled(kMinimumChromeVersion);
}
bool IsMinorModeRestrictionEnabled() {
return base::FeatureList::IsEnabled(kMinorModeRestriction);
}
bool IsNearbyKeepAliveFixEnabled() {
return base::FeatureList::IsEnabled(kNearbyKeepAliveFix);
}
bool IsNetworkingInDiagnosticsAppEnabled() {
return base::FeatureList::IsEnabled(kEnableNetworkingInDiagnosticsApp) &&
base::FeatureList::IsEnabled(kDiagnosticsAppNavigation);
}
bool IsOAuthIppEnabled() {
return base::FeatureList::IsEnabled(kEnableOAuthIpp);
}
bool IsNewLockScreenReauthLayoutEnabled() {
return base::FeatureList::IsEnabled(kNewLockScreenReauthLayout);
}
bool IsNotificationExpansionAnimationEnabled() {
return base::FeatureList::IsEnabled(kNotificationExpansionAnimation);
}
bool IsNotificationExperimentalShortTimeoutsEnabled() {
return base::FeatureList::IsEnabled(kNotificationExperimentalShortTimeouts);
}
bool IsNotificationScrollBarEnabled() {
return base::FeatureList::IsEnabled(kNotificationScrollBar);
}
bool IsNotificationsInContextMenuEnabled() {
return base::FeatureList::IsEnabled(kNotificationsInContextMenu);
}
// True if `kNotificationsRefresh` or `kDarkLightMode` is enabled. Showing the
// new notifications UI if the D/L mode feature is enabled, since the new
// notifications UI supports D/L mode. These two features will be launched at
// the same time, or the new notifications UI will be launched earlier than D/L
// mode, so it is safe to do this.
bool IsNotificationsRefreshEnabled() {
return base::FeatureList::IsEnabled(kNotificationsRefresh) ||
IsDarkLightModeEnabled();
}
bool IsOobeChromeVoxHintEnabled() {
return base::FeatureList::IsEnabled(kEnableOobeChromeVoxHint);
}
bool IsOobePolymer3Enabled() {
return base::FeatureList::IsEnabled(kEnableOobePolymer3);
}
bool IsOobeNetworkScreenSkipEnabled() {
return base::FeatureList::IsEnabled(kEnableOobeNetworkScreenSkip);
}
bool IsOobeConsolidatedConsentEnabled() {
return base::FeatureList::IsEnabled(kOobeConsolidatedConsent);
}
bool IsOobeQuickStartEnabled() {
return base::FeatureList::IsEnabled(kOobeQuickStart);
}
bool IsPcieBillboardNotificationEnabled() {
return base::FeatureList::IsEnabled(kPcieBillboardNotification);
}
bool IsPciguardUiEnabled() {
return base::FeatureList::IsEnabled(kEnablePciguardUi);
}
bool IsPerDeskShelfEnabled() {
return base::FeatureList::IsEnabled(kPerDeskShelf);
}
bool IsPhoneHubCameraRollEnabled() {
return base::FeatureList::IsEnabled(kPhoneHubCameraRoll);
}
bool IsPerformantSplitViewResizingEnabled() {
return base::FeatureList::IsEnabled(kPerformantSplitViewResizing);
}
bool IsPersonalizationHubEnabled() {
return base::FeatureList::IsEnabled(kPersonalizationHub);
}
bool IsPhoneHubEnabled() {
return base::FeatureList::IsEnabled(kPhoneHub);
}
bool IsPhoneHubCallNotificationEnabled() {
return base::FeatureList::IsEnabled(kPhoneHubCallNotification);
}
bool IsPhoneHubRecentAppsEnabled() {
return base::FeatureList::IsEnabled(kPhoneHubRecentApps);
}
bool IsPinAutosubmitBackfillFeatureEnabled() {
return base::FeatureList::IsEnabled(kQuickUnlockPinAutosubmitBackfill);
}
bool IsPinAutosubmitFeatureEnabled() {
return base::FeatureList::IsEnabled(kQuickUnlockPinAutosubmit);
}
bool IsPinSetupForManagedUsersEnabled() {
return base::FeatureList::IsEnabled(kPinSetupForManagedUsers);
}
bool IsPipRoundedCornersEnabled() {
return base::FeatureList::IsEnabled(kPipRoundedCorners);
}
bool IsProductivityLauncherEnabled() {
return base::FeatureList::IsEnabled(kProductivityLauncher);
}
bool IsProductivityLauncherAnimationEnabled() {
return IsProductivityLauncherEnabled() &&
base::FeatureList::IsEnabled(kProductivityLauncherAnimation);
}
bool IsProjectorEnabled() {
return IsProjectorAllUserEnabled() || IsProjectorManagedUserEnabled();
}
bool IsProjectorAllUserEnabled() {
return base::FeatureList::IsEnabled(kProjector);
}
bool IsProjectorManagedUserEnabled() {
return base::FeatureList::IsEnabled(kProjectorManagedUser);
}
bool IsProjectorFeaturePodEnabled() {
return IsProjectorEnabled() &&
base::FeatureList::IsEnabled(kProjectorFeaturePod);
}
bool IsProjectorAnnotatorEnabled() {
return IsProjectorEnabled() &&
base::FeatureList::IsEnabled(kProjectorAnnotator);
}
bool IsQuickDimEnabled() {
return base::FeatureList::IsEnabled(kQuickDim);
}
bool IsQuickSettingsNetworkRevampEnabled() {
return base::FeatureList::IsEnabled(kQuickSettingsNetworkRevamp);
}
bool IsReduceDisplayNotificationsEnabled() {
return base::FeatureList::IsEnabled(kReduceDisplayNotifications);
}
bool IsReverseScrollGesturesEnabled() {
return base::FeatureList::IsEnabled(kReverseScrollGestures);
}
bool IsSamlNotificationOnPasswordChangeSuccessEnabled() {
return base::FeatureList::IsEnabled(
kEnableSamlNotificationOnPasswordChangeSuccess);
}
bool IsSamlReauthenticationOnLockscreenEnabled() {
return base::FeatureList::IsEnabled(kEnableSamlReauthenticationOnLockscreen);
}
bool IsScalableStatusAreaEnabled() {
return base::FeatureList::IsEnabled(kScalableStatusArea);
}
bool IsSeparateNetworkIconsEnabled() {
return base::FeatureList::IsEnabled(kSeparateNetworkIcons);
}
bool IsSettingsAppNotificationSettingsEnabled() {
return base::FeatureList::IsEnabled(kSettingsAppNotificationSettings);
}
bool IsShelfLauncherNudgeEnabled() {
return base::FeatureList::IsEnabled(kShelfLauncherNudge);
}
bool IsShimlessRMAFlowEnabled() {
return base::FeatureList::IsEnabled(kShimlessRMAFlow);
}
bool IsSyncSettingsCategorizationEnabled() {
return base::FeatureList::IsEnabled(kSyncSettingsCategorization);
}
bool IsSyncConsentOptionalEnabled() {
return base::FeatureList::IsEnabled(kSyncConsentOptional);
}
bool IsStylusBatteryStatusEnabled() {
return base::FeatureList::IsEnabled(kStylusBatteryStatus);
}
bool IsSystemChinesePhysicalTypingEnabled() {
return base::FeatureList::IsEnabled(kSystemChinesePhysicalTyping);
}
bool IsSystemJapanesePhysicalTypingEnabled() {
return base::FeatureList::IsEnabled(kSystemJapanesePhysicalTyping);
}
bool IsSystemKoreanPhysicalTypingEnabled() {
return base::FeatureList::IsEnabled(kSystemKoreanPhysicalTyping);
}
bool IsTabClusterUIEnabled() {
return base::FeatureList::IsEnabled(kTabClusterUI);
}
bool IsTrilinearFilteringEnabled() {
static bool use_trilinear_filtering =
base::FeatureList::IsEnabled(kTrilinearFiltering);
return use_trilinear_filtering;
}
bool IsUseStorkSmdsServerAddressEnabled() {
return base::FeatureList::IsEnabled(kUseStorkSmdsServerAddress);
}
bool IsWallpaperWebUIEnabled() {
return base::FeatureList::IsEnabled(kWallpaperWebUI);
}
bool IsWallpaperFullScreenPreviewEnabled() {
return IsWallpaperWebUIEnabled() &&
base::FeatureList::IsEnabled(kWallpaperFullScreenPreview);
}
bool IsWallpaperGooglePhotosIntegrationEnabled() {
return IsWallpaperWebUIEnabled() &&
base::FeatureList::IsEnabled(kWallpaperGooglePhotosIntegration);
}
bool IsWallpaperPerDeskEnabled() {
return base::FeatureList::IsEnabled(kWallpaperPerDesk);
}
bool IsWebUITabStripTabDragIntegrationEnabled() {
return base::FeatureList::IsEnabled(kWebUITabStripTabDragIntegration);
}
bool IsWifiSyncAndroidEnabled() {
return base::FeatureList::IsEnabled(kWifiSyncAndroid);
}
bool IsWindowControlMenuEnabled() {
return base::FeatureList::IsEnabled(kWindowControlMenu);
}
bool ShouldShowPlayStoreInDemoMode() {
return base::FeatureList::IsEnabled(kShowPlayInDemoMode);
}
bool ShouldUseAttachApn() {
// See comment on |kCellularForbidAttachApn| for details.
return !base::FeatureList::IsEnabled(kCellularForbidAttachApn) &&
base::FeatureList::IsEnabled(kCellularUseAttachApn);
}
bool ShouldUseV1DeviceSync() {
return !ShouldUseV2DeviceSync() ||
!base::FeatureList::IsEnabled(kDisableCryptAuthV1DeviceSync);
}
bool ShouldUseV2DeviceSync() {
return base::FeatureList::IsEnabled(kCryptAuthV2Enrollment) &&
base::FeatureList::IsEnabled(kCryptAuthV2DeviceSync);
}
namespace {
// The boolean flag indicating if "WebUITabStrip" feature is enabled in Chrome.
bool g_webui_tab_strip_enabled = false;
} // namespace
void SetWebUITabStripEnabled(bool enabled) {
g_webui_tab_strip_enabled = enabled;
}
bool IsWebUITabStripEnabled() {
return g_webui_tab_strip_enabled;
}
} // namespace features
} // namespace ash
| 28,929 |
739 | import os
import signal
class Screen:
@staticmethod
def wr(s):
# TODO: When Python is 3.5, update this to use only bytes
if isinstance(s, str):
s = bytes(s, "utf-8")
os.write(1, s)
@staticmethod
def wr_fixedw(s, width):
# Write string in a fixed-width field
s = s[:width]
Screen.wr(s)
Screen.wr(" " * (width - len(s)))
# Doesn't work here, as it doesn't advance cursor
#Screen.clear_num_pos(width - len(s))
@staticmethod
def cls():
Screen.wr(b"\x1b[2J")
@staticmethod
def goto(x, y):
# TODO: When Python is 3.5, update this to use bytes
Screen.wr("\x1b[%d;%dH" % (y + 1, x + 1))
@staticmethod
def clear_to_eol():
Screen.wr(b"\x1b[0K")
# Clear specified number of positions
@staticmethod
def clear_num_pos(num):
if num > 0:
Screen.wr("\x1b[%dX" % num)
@staticmethod
def attr_color(fg, bg=-1):
if bg == -1:
bg = fg >> 4
fg &= 0xf
# TODO: Switch to b"%d" % foo when py3.5 is everywhere
if bg is None:
if (fg > 8):
Screen.wr("\x1b[%d;1m" % (fg + 30 - 8))
else:
Screen.wr("\x1b[%dm" % (fg + 30))
else:
assert bg <= 8
if (fg > 8):
Screen.wr("\x1b[%d;%d;1m" % (fg + 30 - 8, bg + 40))
else:
Screen.wr("\x1b[0;%d;%dm" % (fg + 30, bg + 40))
@staticmethod
def attr_reset():
Screen.wr(b"\x1b[0m")
@staticmethod
def cursor(onoff):
if onoff:
Screen.wr(b"\x1b[?25h")
else:
Screen.wr(b"\x1b[?25l")
def draw_box(self, left, top, width, height):
# Use http://www.utf8-chartable.de/unicode-utf8-table.pl
# for utf-8 pseudographic reference
bottom = top + height - 1
self.goto(left, top)
# "┌"
self.wr(b"\xe2\x94\x8c")
# "─"
hor = b"\xe2\x94\x80" * (width - 2)
self.wr(hor)
# "┐"
self.wr(b"\xe2\x94\x90")
self.goto(left, bottom)
# "└"
self.wr(b"\xe2\x94\x94")
self.wr(hor)
# "┘"
self.wr(b"\xe2\x94\x98")
top += 1
while top < bottom:
# "│"
self.goto(left, top)
self.wr(b"\xe2\x94\x82")
self.goto(left + width - 1, top)
self.wr(b"\xe2\x94\x82")
top += 1
def clear_box(self, left, top, width, height):
# doesn't work
#self.wr("\x1b[%s;%s;%s;%s$z" % (top + 1, left + 1, top + height, left + width))
s = b" " * width
bottom = top + height
while top < bottom:
self.goto(left, top)
self.wr(s)
top += 1
def dialog_box(self, left, top, width, height, title=""):
self.clear_box(left + 1, top + 1, width - 2, height - 2)
self.draw_box(left, top, width, height)
if title:
#pos = (width - len(title)) / 2
pos = 1
self.goto(left + pos, top)
self.wr(title)
@classmethod
def init_tty(cls):
import tty, termios
cls.org_termios = termios.tcgetattr(0)
tty.setraw(0)
@classmethod
def deinit_tty(cls):
import termios
termios.tcsetattr(0, termios.TCSANOW, cls.org_termios)
@classmethod
def enable_mouse(cls):
# Mouse reporting - X10 compatibility mode
cls.wr(b"\x1b[?1000h")
@classmethod
def disable_mouse(cls):
# Mouse reporting - X10 compatibility mode
cls.wr(b"\x1b[?1000l")
@classmethod
def screen_size(cls):
import select
cls.wr(b"\x1b[18t")
res = select.select([0], [], [], 0.2)[0]
if not res:
return (80, 24)
resp = os.read(0, 32)
assert resp.startswith(b"\x1b[8;") and resp[-1:] == b"t"
vals = resp[:-1].split(b";")
return (int(vals[2]), int(vals[1]))
# Set function to redraw an entire (client) screen
# This is called to restore original screen, as we don't save it.
@classmethod
def set_screen_redraw(cls, handler):
cls.screen_redraw = handler
@classmethod
def set_screen_resize(cls, handler):
signal.signal(signal.SIGWINCH, lambda sig, stk: handler(cls))
| 2,394 |
49,076 | <reponame>spreoW/spring-framework
/*
* Copyright 2002-2020 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.context.annotation;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.List;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.support.RootBeanDefinition;
import org.springframework.beans.testfixture.beans.TestBean;
import org.springframework.util.ObjectUtils;
import static org.assertj.core.api.Assertions.assertThat;
import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
/**
* @author <NAME>
* @since 4.0
*/
public class LazyAutowiredAnnotationBeanPostProcessorTests {
private void doTestLazyResourceInjection(Class<? extends TestBeanHolder> annotatedBeanClass) {
AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext();
RootBeanDefinition abd = new RootBeanDefinition(annotatedBeanClass);
abd.setScope(BeanDefinition.SCOPE_PROTOTYPE);
ac.registerBeanDefinition("annotatedBean", abd);
RootBeanDefinition tbd = new RootBeanDefinition(TestBean.class);
tbd.setLazyInit(true);
ac.registerBeanDefinition("testBean", tbd);
ac.refresh();
ConfigurableListableBeanFactory bf = ac.getBeanFactory();
TestBeanHolder bean = ac.getBean("annotatedBean", TestBeanHolder.class);
assertThat(bf.containsSingleton("testBean")).isFalse();
assertThat(bean.getTestBean()).isNotNull();
assertThat(bean.getTestBean().getName()).isNull();
assertThat(bf.containsSingleton("testBean")).isTrue();
TestBean tb = (TestBean) ac.getBean("testBean");
tb.setName("tb");
assertThat(bean.getTestBean().getName()).isSameAs("tb");
assertThat(ObjectUtils.containsElement(bf.getDependenciesForBean("annotatedBean"), "testBean")).isTrue();
assertThat(ObjectUtils.containsElement(bf.getDependentBeans("testBean"), "annotatedBean")).isTrue();
}
@Test
public void testLazyResourceInjectionWithField() {
doTestLazyResourceInjection(FieldResourceInjectionBean.class);
AnnotationConfigApplicationContext ac = new AnnotationConfigApplicationContext();
RootBeanDefinition abd = new RootBeanDefinition(FieldResourceInjectionBean.class);
abd.setScope(BeanDefinition.SCOPE_PROTOTYPE);
ac.registerBeanDefinition("annotatedBean", abd);
RootBeanDefinition tbd = new RootBeanDefinition(TestBean.class);
tbd.setLazyInit(true);
ac.registerBeanDefinition("testBean", tbd);
ac.refresh();
FieldResourceInjectionBean bean = ac.getBean("annotatedBean", FieldResourceInjectionBean.class);
assertThat(ac.getBeanFactory().containsSingleton("testBean")).isFalse();
assertThat(bean.getTestBeans().isEmpty()).isFalse();
assertThat(bean.getTestBeans().get(0).getName()).isNull();
assertThat(ac.getBeanFactory().containsSingleton("testBean")).isTrue();
TestBean tb = (TestBean) ac.getBean("testBean");
tb.setName("tb");
assertThat(bean.getTestBean().getName()).isSameAs("tb");
}
@Test
public void testLazyResourceInjectionWithFieldAndCustomAnnotation() {
doTestLazyResourceInjection(FieldResourceInjectionBeanWithCompositeAnnotation.class);
}
@Test
public void testLazyResourceInjectionWithMethod() {
doTestLazyResourceInjection(MethodResourceInjectionBean.class);
}
@Test
public void testLazyResourceInjectionWithMethodLevelLazy() {
doTestLazyResourceInjection(MethodResourceInjectionBeanWithMethodLevelLazy.class);
}
@Test
public void testLazyResourceInjectionWithMethodAndCustomAnnotation() {
doTestLazyResourceInjection(MethodResourceInjectionBeanWithCompositeAnnotation.class);
}
@Test
public void testLazyResourceInjectionWithConstructor() {
doTestLazyResourceInjection(ConstructorResourceInjectionBean.class);
}
@Test
public void testLazyResourceInjectionWithConstructorLevelLazy() {
doTestLazyResourceInjection(ConstructorResourceInjectionBeanWithConstructorLevelLazy.class);
}
@Test
public void testLazyResourceInjectionWithConstructorAndCustomAnnotation() {
doTestLazyResourceInjection(ConstructorResourceInjectionBeanWithCompositeAnnotation.class);
}
@Test
public void testLazyResourceInjectionWithNonExistingTarget() {
DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
bf.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
AutowiredAnnotationBeanPostProcessor bpp = new AutowiredAnnotationBeanPostProcessor();
bpp.setBeanFactory(bf);
bf.addBeanPostProcessor(bpp);
RootBeanDefinition bd = new RootBeanDefinition(FieldResourceInjectionBean.class);
bd.setScope(BeanDefinition.SCOPE_PROTOTYPE);
bf.registerBeanDefinition("annotatedBean", bd);
FieldResourceInjectionBean bean = (FieldResourceInjectionBean) bf.getBean("annotatedBean");
assertThat(bean.getTestBean()).isNotNull();
assertThatExceptionOfType(NoSuchBeanDefinitionException.class).isThrownBy(() ->
bean.getTestBean().getName());
}
@Test
public void testLazyOptionalResourceInjectionWithNonExistingTarget() {
DefaultListableBeanFactory bf = new DefaultListableBeanFactory();
bf.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
AutowiredAnnotationBeanPostProcessor bpp = new AutowiredAnnotationBeanPostProcessor();
bpp.setBeanFactory(bf);
bf.addBeanPostProcessor(bpp);
RootBeanDefinition bd = new RootBeanDefinition(OptionalFieldResourceInjectionBean.class);
bd.setScope(BeanDefinition.SCOPE_PROTOTYPE);
bf.registerBeanDefinition("annotatedBean", bd);
OptionalFieldResourceInjectionBean bean = (OptionalFieldResourceInjectionBean) bf.getBean("annotatedBean");
assertThat(bean.getTestBean()).isNotNull();
assertThat(bean.getTestBeans()).isNotNull();
assertThat(bean.getTestBeans().isEmpty()).isTrue();
assertThatExceptionOfType(NoSuchBeanDefinitionException.class).isThrownBy(() ->
bean.getTestBean().getName());
}
public interface TestBeanHolder {
TestBean getTestBean();
}
public static class FieldResourceInjectionBean implements TestBeanHolder {
@Autowired @Lazy
private TestBean testBean;
@Autowired @Lazy
private List<TestBean> testBeans;
@Override
public TestBean getTestBean() {
return this.testBean;
}
public List<TestBean> getTestBeans() {
return testBeans;
}
}
public static class OptionalFieldResourceInjectionBean implements TestBeanHolder {
@Autowired(required = false) @Lazy
private TestBean testBean;
@Autowired(required = false) @Lazy
private List<TestBean> testBeans;
@Override
public TestBean getTestBean() {
return this.testBean;
}
public List<TestBean> getTestBeans() {
return this.testBeans;
}
}
public static class FieldResourceInjectionBeanWithCompositeAnnotation implements TestBeanHolder {
@LazyInject
private TestBean testBean;
@Override
public TestBean getTestBean() {
return this.testBean;
}
}
public static class MethodResourceInjectionBean implements TestBeanHolder {
private TestBean testBean;
@Autowired
public void setTestBean(@Lazy TestBean testBean) {
if (this.testBean != null) {
throw new IllegalStateException("Already called");
}
this.testBean = testBean;
}
@Override
public TestBean getTestBean() {
return this.testBean;
}
}
public static class MethodResourceInjectionBeanWithMethodLevelLazy implements TestBeanHolder {
private TestBean testBean;
@Autowired @Lazy
public void setTestBean(TestBean testBean) {
if (this.testBean != null) {
throw new IllegalStateException("Already called");
}
this.testBean = testBean;
}
@Override
public TestBean getTestBean() {
return this.testBean;
}
}
public static class MethodResourceInjectionBeanWithCompositeAnnotation implements TestBeanHolder {
private TestBean testBean;
@LazyInject
public void setTestBean(TestBean testBean) {
if (this.testBean != null) {
throw new IllegalStateException("Already called");
}
this.testBean = testBean;
}
@Override
public TestBean getTestBean() {
return this.testBean;
}
}
public static class ConstructorResourceInjectionBean implements TestBeanHolder {
private final TestBean testBean;
@Autowired
public ConstructorResourceInjectionBean(@Lazy TestBean testBean) {
this.testBean = testBean;
}
@Override
public TestBean getTestBean() {
return this.testBean;
}
}
public static class ConstructorResourceInjectionBeanWithConstructorLevelLazy implements TestBeanHolder {
private final TestBean testBean;
@Autowired @Lazy
public ConstructorResourceInjectionBeanWithConstructorLevelLazy(TestBean testBean) {
this.testBean = testBean;
}
@Override
public TestBean getTestBean() {
return this.testBean;
}
}
public static class ConstructorResourceInjectionBeanWithCompositeAnnotation implements TestBeanHolder {
private final TestBean testBean;
@LazyInject
public ConstructorResourceInjectionBeanWithCompositeAnnotation(TestBean testBean) {
this.testBean = testBean;
}
@Override
public TestBean getTestBean() {
return this.testBean;
}
}
@Autowired @Lazy
@Retention(RetentionPolicy.RUNTIME)
public @interface LazyInject {
}
}
| 3,467 |
381 | <gh_stars>100-1000
#include <string.h>
#include <stdint.h>
/**
* Efficient string hash function.
*/
__attribute__((unused))
static uint32_t string_hash(const char *str)
{
uint32_t hash = 0;
int32_t c;
while ((c = *str++))
{
hash = c + (hash << 6) + (hash << 16) - hash;
}
return hash;
}
/**
* Test two strings for equality.
*/
__attribute__((unused))
static int string_compare(const char *str1, const char *str2)
{
if (str1 == str2)
{
return 1;
}
if (str1 == NULL || str2 == NULL)
{
return 0;
}
return strcmp(str1, str2) == 0;
}
| 235 |
799 | import json
import io
BASE_URL = 'https://gateway.qg2.apps.qualys.eu/'
DATE_FORMAT = '%Y-%m-%dT%H:%M:%S.%fZ'
def load_mock_response(file_name: str) -> dict:
"""
Load one of the mock responses to be used for assertion.
Args:
file_name (str): Name of the mock response JSON file to return.
"""
with open(f'{file_name}', mode='r', encoding='utf-8') as json_file:
return json.loads(json_file.read())
def util_load_json(path) -> dict:
with io.open(path, mode='r', encoding='utf-8') as file:
return json.loads(file.read())
def util_load_file(path) -> str:
with io.open(path, mode='r', encoding='utf-8') as file:
return file.read()
def test_list_events_command(requests_mock) -> None:
"""
Scenario: List events.
Given:
- User has provided valid credentials.
- Headers and JWT token have been set.
When:
- list_events_command is called.
Then:
- Ensure number of items is correct.
- Ensure outputs prefix is correct.
- Ensure outputs key fields is correct.
"""
from QualysFIM import Client, list_events_command
mock_response = util_load_json('test_data/list_events.json')
requests_mock.post(f'{BASE_URL}fim/v2/events/search', json=mock_response)
requests_mock.post(f'{BASE_URL}/auth', json={})
client = Client(base_url=BASE_URL, verify=False, proxy=False, auth=('a', 'b'))
result = list_events_command(client, {'sort': 'most_recent'})
assert result.outputs_prefix == 'QualysFIM.Event'
assert len(result.raw_response) == 2
assert result.outputs_key_field == 'id'
def test_get_event_command(requests_mock) -> None:
"""
Scenario: List events.
Given:
- User has provided valid credentials.
- Headers and JWT token have been set.
When:
- get_event_command is called.
Then:
- Ensure outputs prefix is correct.
- Ensure outputs key fields is correct.
"""
from QualysFIM import Client, get_event_command
mock_response = util_load_json('test_data/get_event.json')
requests_mock.get(f'{BASE_URL}fim/v1/events/123456', json=mock_response)
requests_mock.post(f'{BASE_URL}/auth', json={})
client = Client(base_url=BASE_URL, verify=False, proxy=False, auth=('a', 'b'))
result = get_event_command(client, {'event_id': '123456'})
assert result.outputs_prefix == 'QualysFIM.Event'
assert result.outputs_key_field == 'id'
def test_list_incidents_command(requests_mock) -> None:
"""
Scenario: List incidents
Given:
- User has provided valid credentials.
- Headers and JWT token have been set.
When:
- list_incidents_command is called.
Then:
- Ensure number of items is correct.
- Ensure outputs prefix is correct.
- Ensure a sample value from the API matches what is generated in the context.
- Ensure outputs key fields is correct.
"""
from QualysFIM import Client, list_incidents_command
mock_response = util_load_json('test_data/list_incidents.json')
requests_mock.post(f'{BASE_URL}fim/v3/incidents/search', json=mock_response)
requests_mock.post(f'{BASE_URL}/auth', json={})
client = Client(base_url=BASE_URL, verify=False, proxy=False, auth=('a', 'b'))
result = list_incidents_command(client, {'sort': 'most_recent'})
assert result.outputs_prefix == 'QualysFIM.Incident'
assert len(result.raw_response) == 2
assert result.outputs[0].get('id') == '75539bfc-c0e7-4bcb-b55a-48065ef89ebe'
assert result.outputs[1].get('id') == '5a6d0462-1c2e-4e36-a13b-6264bd3c222f'
assert result.outputs_key_field == 'id'
def test_get_incident_events_command(requests_mock) -> None:
"""
Scenario: List incident's events
Given:
- User has provided valid credentials.
- Headers and JWT token have been set.
When:
- list_incidents_events_command is called.
Then:
- Ensure number of items is correct.
- Ensure outputs prefix is correct.
- Ensure outputs key fields is correct.
"""
from QualysFIM import Client, list_incident_events_command
mock_response = util_load_json('test_data/get_incident_events.json')
requests_mock.post(f'{BASE_URL}fim/v2/incidents/None/events/search',
json=mock_response)
requests_mock.post(f'{BASE_URL}/auth', json={})
client = Client(base_url=BASE_URL, verify=False, proxy=False, auth=('a', 'b'))
result = list_incident_events_command(client, {'limit': '10'})
assert result.outputs_prefix == 'QualysFIM.Event'
assert len(result.raw_response) == 10
assert result.outputs_key_field == 'id'
def test_create_incident_command(requests_mock) -> None:
"""
Scenario: Create Incident.
Given:
- User has provided valid credentials.
- Headers and JWT token have been set.
When:
- create_incident_command is called.
Then:
- Ensure outputs prefix is correct.
- Ensure outputs key fields is correct.
"""
from QualysFIM import Client, create_incident_command
mock_response = util_load_json('test_data/create_incident.json')
requests_mock.post(f'{BASE_URL}fim/v3/incidents/create', json=mock_response)
mock_response = util_load_json('test_data/list_incidents.json')
requests_mock.post(f'{BASE_URL}fim/v3/incidents/search', json=mock_response)
requests_mock.post(f'{BASE_URL}/auth', json={})
client = Client(base_url=BASE_URL, verify=False, proxy=False, auth=('a', 'b'))
result = create_incident_command(client, {'name': 'test'})
assert result.outputs_prefix == 'QualysFIM.Incident'
assert result.outputs_key_field == 'id'
def test_approve_incident_command(requests_mock) -> None:
"""
Scenario: Approve Incident.
Given:
- User has provided valid credentials.
- Headers and JWT token have been set.
When:
- approve_incident_command is called.
Then:
- Ensure outputs prefix is correct.
- Ensure outputs key fields is correct.
"""
from QualysFIM import Client, approve_incident_command
mock_response = util_load_json('test_data/approve_incident.json')
requests_mock.post(f'{BASE_URL}fim/v3/incidents/None/approve', json=mock_response)
requests_mock.post(f'{BASE_URL}/auth', json={})
client = Client(base_url=BASE_URL, verify=False, proxy=False, auth=('a', 'b'))
result = approve_incident_command(client, {'approval_status': 'test',
'change_type': 'test',
'comment': 'test',
'disposition_category': 'test'})
assert result.outputs_prefix == 'QualysFIM.Incident'
assert result.outputs_key_field == 'id'
def test_list_assets_command(requests_mock) -> None:
"""
Scenario: List Assets.
Given:
- User has provided valid credentials.
- Headers and JWT token have been set.
When:
- list_assets_command is called.
Then:
- Ensure number of items is correct.
- Ensure outputs prefix is correct.
- Ensure outputs key fields is correct.
"""
from QualysFIM import Client, list_assets_command
mock_response = util_load_json('test_data/list_assets.json')
requests_mock.post(f'{BASE_URL}fim/v3/assets/search', json=mock_response)
requests_mock.post(f'{BASE_URL}/auth', json={})
client = Client(base_url=BASE_URL, verify=False, proxy=False, auth=('a', 'b'))
result = list_assets_command(client, {})
assert result.outputs_prefix == 'QualysFIM.Asset'
assert len(result.outputs) == 2
assert result.outputs_key_field == 'id'
def test_fetch_incidents_command(requests_mock) -> None:
"""
Scenario: Fetch Incidents.
Given:
- User has provided valid credentials.
- Headers and JWT token have been set.
When:
- fetch_incidents is called.
Then:
- Ensure a sample value from the API matches what is generated in the context.
- Ensure occurred time is correct.
"""
from QualysFIM import Client, fetch_incidents
mock_response = util_load_json('test_data/fetch_incidents.json')
requests_mock.post(f'{BASE_URL}fim/v3/incidents/search', json=mock_response)
requests_mock.post(f'{BASE_URL}/auth', json={})
client = Client(base_url=BASE_URL, verify=False, proxy=False, auth=('a', 'b'))
next_run, incidents = fetch_incidents(client=client, last_run={}, fetch_filter='',
first_fetch_time='3 days', max_fetch='2')
raw_json = json.loads(incidents[0].get('rawJSON'))
assert raw_json.get('id') == '75539bfc-c0e7-4bcb-b55a-48065ef89ebe'
assert raw_json.get('createdBy').get('date') == 1613378492427
| 3,584 |
1,840 | /**
* Copyright Pravega Authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package io.pravega.segmentstore.server.logs.operations;
import com.google.common.base.Preconditions;
import io.pravega.common.io.serialization.RevisionDataInput;
import io.pravega.common.io.serialization.RevisionDataOutput;
import io.pravega.segmentstore.server.SegmentOperation;
import java.io.IOException;
import lombok.Getter;
/**
* Log Operation that indicates a StreamSegment is to be truncated.
*/
public class StreamSegmentTruncateOperation extends StorageOperation implements SegmentOperation {
//region Members
@Getter
private long streamSegmentId;
/**
* The Offset at which to truncate the StreamSegment.
*/
@Getter
private long streamSegmentOffset;
//endregion
//region Constructor
/**
* Creates a new instance of the StreamSegmentTruncateOperation class.
*
* @param streamSegmentId The Id of the StreamSegment to truncate.
* @param offset The Offset at which to truncate.
*/
public StreamSegmentTruncateOperation(long streamSegmentId, long offset) {
super(streamSegmentId);
Preconditions.checkArgument(offset >= 0, "offset must be a non-negative number.");
this.streamSegmentId = streamSegmentId;
this.streamSegmentOffset = offset;
}
/**
* Deserialization constructor.
*/
private StreamSegmentTruncateOperation() {
}
@Override
public long getLength() {
return 0;
}
//endregion
//region Operation Implementation
@Override
public String toString() {
return String.format("%s, Offset = %s", super.toString(), this.streamSegmentOffset);
}
//endregion
static class Serializer extends OperationSerializer<StreamSegmentTruncateOperation> {
private static final int SERIALIZATION_LENGTH = 3 * Long.BYTES;
@Override
protected OperationBuilder<StreamSegmentTruncateOperation> newBuilder() {
return new OperationBuilder<>(new StreamSegmentTruncateOperation());
}
@Override
protected byte getWriteVersion() {
return 0;
}
@Override
protected void declareVersions() {
version(0).revision(0, this::write00, this::read00);
}
private void write00(StreamSegmentTruncateOperation o, RevisionDataOutput target) throws IOException {
target.length(SERIALIZATION_LENGTH);
target.writeLong(o.getSequenceNumber());
target.writeLong(o.streamSegmentId);
target.writeLong(o.streamSegmentOffset);
}
private void read00(RevisionDataInput source, OperationBuilder<StreamSegmentTruncateOperation> b) throws IOException {
b.instance.setSequenceNumber(source.readLong());
b.instance.streamSegmentId = source.readLong();
b.instance.streamSegmentOffset = source.readLong();
}
}
}
| 1,241 |
14,668 | <gh_stars>1000+
# Copyright 2019 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import unittest
import make_runtime_features_utilities as util
from blinkbuild.name_style_converter import NameStyleConverter
def _feature(name,
depends_on=[],
implied_by=[],
origin_trial_feature_name=None):
return {
'name': name,
'depends_on': depends_on,
'implied_by': implied_by,
'origin_trial_feature_name': origin_trial_feature_name
}
class MakeRuntimeFeaturesUtilitiesTest(unittest.TestCase):
def test_cycle(self):
# Cycle: 'c' => 'd' => 'e' => 'c'
with self.assertRaisesRegexp(
AssertionError, 'Cycle found in depends_on/implied_by graph'):
util.origin_trials([
_feature('a', depends_on=['b']),
_feature('b'),
_feature('c', implied_by=['a', 'd']),
_feature('d', depends_on=['e']),
_feature('e', implied_by=['c'])
])
def test_bad_dependency(self):
with self.assertRaisesRegexp(AssertionError,
'a: Depends on non-existent-feature: x'):
util.origin_trials([_feature('a', depends_on=['x'])])
def test_bad_implication(self):
with self.assertRaisesRegexp(AssertionError,
'a: Implied by non-existent-feature: x'):
util.origin_trials([_feature('a', implied_by=['x'])])
with self.assertRaisesRegexp(
AssertionError,
'a: A feature must be in origin trial if implied by an origin trial feature: b'
):
util.origin_trials([
_feature('a', implied_by=['b']),
_feature('b', origin_trial_feature_name='b')
])
def test_both_dependency_and_implication(self):
with self.assertRaisesRegexp(
AssertionError,
'c: Only one of implied_by and depends_on is allowed'):
util.origin_trials([
_feature('a'),
_feature('b'),
_feature('c', depends_on=['a'], implied_by=['b'])
])
def test_origin_trials(self):
features = [
_feature(NameStyleConverter('a')),
_feature(
NameStyleConverter('b'),
depends_on=['a'],
origin_trial_feature_name='b'),
_feature(NameStyleConverter('c'), depends_on=['b']),
_feature(NameStyleConverter('d'), depends_on=['b']),
_feature(NameStyleConverter('e'), depends_on=['d'])
]
self.assertSetEqual(util.origin_trials(features), {'b', 'c', 'd', 'e'})
features = [
_feature('a'),
_feature('b', depends_on=['x', 'y']),
_feature('c', depends_on=['y', 'z']),
_feature('x', depends_on=['a']),
_feature('y', depends_on=['x'], origin_trial_feature_name='y'),
_feature('z', depends_on=['y'])
]
self.assertSetEqual(util.origin_trials(features), {'b', 'c', 'y', 'z'})
if __name__ == "__main__":
unittest.main()
| 1,656 |
1,875 | <reponame>CarnegieLearningWeb/teavm
/*
* Copyright 2017 <NAME>.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.teavm.classlib.java.util.jar;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.charset.Charset;
import java.nio.charset.CharsetEncoder;
import java.nio.charset.CoderResult;
import java.util.HashMap;
import java.util.Map;
public class TManifest implements Cloneable {
static final int LINE_LENGTH_LIMIT = 72;
private static final byte[] LINE_SEPARATOR = new byte[] { '\r', '\n' };
private static final byte[] VALUE_SEPARATOR = new byte[] { ':', ' ' };
private static final TAttributes.Name NAME_ATTRIBUTE = new TAttributes.Name("Name");
private TAttributes mainAttributes = new TAttributes();
private HashMap<String, TAttributes> entries = new HashMap<>();
static class Chunk {
int start;
int end;
Chunk(int start, int end) {
this.start = start;
this.end = end;
}
}
private HashMap<String, Chunk> chunks;
private TInitManifest im;
private int mainEnd;
public TManifest() {
super();
}
public TManifest(InputStream is) throws IOException {
super();
read(is);
}
@SuppressWarnings("unchecked")
public TManifest(TManifest man) {
mainAttributes = (TAttributes) man.mainAttributes.clone();
entries = (HashMap<String, TAttributes>) ((HashMap<String, TAttributes>) man.getEntries()).clone();
}
TManifest(InputStream is, boolean readChunks) throws IOException {
if (readChunks) {
chunks = new HashMap<>();
}
read(is);
}
public void clear() {
im = null;
entries.clear();
mainAttributes.clear();
}
public TAttributes getAttributes(String name) {
return getEntries().get(name);
}
public Map<String, TAttributes> getEntries() {
return entries;
}
public TAttributes getMainAttributes() {
return mainAttributes;
}
@Override
public Object clone() {
return new TManifest(this);
}
public void write(OutputStream os) throws IOException {
write(this, os);
}
public void read(InputStream is) throws IOException {
byte[] buf = readFully(is);
if (buf.length == 0) {
return;
}
// a workaround for HARMONY-5662
// replace EOF and NUL with another new line
// which does not trigger an error
byte b = buf[buf.length - 1];
if (0 == b || 26 == b) {
buf[buf.length - 1] = '\n';
}
// Attributes.Name.MANIFEST_VERSION is not used for
// the second parameter for RI compatibility
im = new TInitManifest(buf, mainAttributes, null);
mainEnd = im.getPos();
// FIXME
im.initEntries(entries, chunks);
im = null;
}
private byte[] readFully(InputStream is) throws IOException {
// Initial read
byte[] buffer = new byte[4096];
int count = is.read(buffer);
int nextByte = is.read();
// Did we get it all in one read?
if (nextByte == -1) {
byte[] dest = new byte[count];
System.arraycopy(buffer, 0, dest, 0, count);
return dest;
}
// Does it look like a manifest?
if (!containsLine(buffer, count)) {
throw new IOException("Manifest is too long");
}
// Requires additional reads
ByteArrayOutputStream baos = new ByteArrayOutputStream(count * 2);
baos.write(buffer, 0, count);
baos.write(nextByte);
while (true) {
count = is.read(buffer);
if (count == -1) {
return baos.toByteArray();
}
baos.write(buffer, 0, count);
}
}
private boolean containsLine(byte[] buffer, int length) {
for (int i = 0; i < length; i++) {
if (buffer[i] == 0x0A || buffer[i] == 0x0D) {
return true;
}
}
return false;
}
@Override
public int hashCode() {
return mainAttributes.hashCode() ^ getEntries().hashCode();
}
@Override
public boolean equals(Object o) {
if (o == null) {
return false;
}
if (o.getClass() != this.getClass()) {
return false;
}
if (!mainAttributes.equals(((TManifest) o).mainAttributes)) {
return false;
}
return getEntries().equals(((TManifest) o).getEntries());
}
Chunk getChunk(String name) {
return chunks.get(name);
}
void removeChunks() {
chunks = null;
}
int getMainAttributesEnd() {
return mainEnd;
}
static void write(TManifest manifest, OutputStream out) throws IOException {
CharsetEncoder encoder = Charset.defaultCharset().newEncoder();
ByteBuffer buffer = ByteBuffer.allocate(512);
String version = manifest.mainAttributes.getValue(TAttributes.Name.MANIFEST_VERSION);
if (version != null) {
writeEntry(out, TAttributes.Name.MANIFEST_VERSION, version, encoder, buffer);
for (Object o : manifest.mainAttributes.keySet()) {
TAttributes.Name name = (TAttributes.Name) o;
if (!name.equals(TAttributes.Name.MANIFEST_VERSION)) {
writeEntry(out, name, manifest.mainAttributes.getValue(name), encoder, buffer);
}
}
}
out.write(LINE_SEPARATOR);
for (String key : manifest.getEntries().keySet()) {
writeEntry(out, NAME_ATTRIBUTE, key, encoder, buffer);
TAttributes attrib = manifest.entries.get(key);
for (Object o : attrib.keySet()) {
TAttributes.Name name = (TAttributes.Name) o;
writeEntry(out, name, attrib.getValue(name), encoder, buffer);
}
out.write(LINE_SEPARATOR);
}
}
private static void writeEntry(OutputStream os, TAttributes.Name name,
String value, CharsetEncoder encoder, ByteBuffer bBuf) throws IOException {
byte[] out = name.getBytes();
if (out.length > LINE_LENGTH_LIMIT) {
throw new IOException();
}
os.write(out);
os.write(VALUE_SEPARATOR);
encoder.reset();
bBuf.clear().limit(LINE_LENGTH_LIMIT - out.length - 2);
CharBuffer cBuf = CharBuffer.wrap(value);
CoderResult r;
while (true) {
r = encoder.encode(cBuf, bBuf, true);
if (CoderResult.UNDERFLOW == r) {
r = encoder.flush(bBuf);
}
os.write(bBuf.array(), bBuf.arrayOffset(), bBuf.position());
os.write(LINE_SEPARATOR);
if (CoderResult.UNDERFLOW == r) {
break;
}
os.write(' ');
bBuf.clear().limit(LINE_LENGTH_LIMIT - 1);
}
}
}
| 3,368 |
582 | <filename>org.eclipse.gef/src/org/eclipse/gef/tools/DeselectAllTracker.java
/*******************************************************************************
* Copyright (c) 2000, 2010 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.gef.tools;
import org.eclipse.gef.EditPart;
/**
* A DragTracker whose job it is to deselect all {@link EditPart EditParts}.
*/
public class DeselectAllTracker extends SelectEditPartTracker {
/**
* Constructs a new DeselectAllTracker.
*
* @param ep
* the edit part that returned this tracker
*/
public DeselectAllTracker(EditPart ep) {
super(ep);
}
/**
* Calls {@link org.eclipse.gef.EditPartViewer#deselectAll()}.
*
* @see org.eclipse.gef.tools.AbstractTool#handleButtonDown(int)
*/
@Override
protected boolean handleButtonDown(int button) {
getCurrentViewer().deselectAll();
return true;
}
}
| 434 |
2,112 | <gh_stars>1000+
/*
* Copyright (c) Facebook, Inc. and its affiliates.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <algorithm>
#include <memory>
#include <thread>
#include <vector>
#include <glog/logging.h>
#include <folly/executors/MeteredExecutor.h>
#include <folly/experimental/FunctionScheduler.h>
#include <folly/hash/Hash.h>
#include <thrift/lib/cpp/concurrency/Thread.h>
#include <thrift/lib/cpp/concurrency/ThreadManager.h>
namespace apache {
namespace thrift {
namespace concurrency {
class SFQThreadManagerConfig {
public:
SFQThreadManagerConfig() = default;
SFQThreadManagerConfig& setPerturbInterval(std::chrono::milliseconds p) {
perturb_ = p;
return *this;
}
std::chrono::milliseconds getPerturbInterval() const { return perturb_; }
// Currently only supporting fair queuing for upstream source.
SFQThreadManagerConfig& setNumFairQueuesForUpstream(size_t numQueues) {
numQueues_ = numQueues;
return *this;
}
size_t getNumFairQueuesForUpstream() const { return numQueues_; }
SFQThreadManagerConfig& setExecutors(
std::array<std::shared_ptr<folly::Executor>, N_PRIORITIES> executors) {
executors_ = std::move(executors);
return *this;
}
std::array<std::shared_ptr<folly::Executor>, N_PRIORITIES>& getExecutors() {
return executors_;
}
private:
std::chrono::milliseconds perturb_{std::chrono::seconds(30)};
size_t numQueues_{1};
std::array<std::shared_ptr<folly::Executor>, N_PRIORITIES> executors_;
};
/**
* Stochastic fair queue thread manager (SFQTM)
* ============================================
*
* This TM variant aims to address fairness concerns in multi-tenant systems by
* fronting the CPU executor' UPSTREAM queue with a configurable number of
* sub-queues used to isolate different request "tenants". Usage of the SFQTM
* relies on users to identify different request tenants via encoding the data
* in the priority provided to getKeepAlive() calls for UPSTREAM sources.
*
* Fairness in concurrency
* -----------------------
* Fairness in the SFQTM context means that each tenant is allowed the same
* number of tasks to reside on the internal executor queue. As an example,
* let's say we have 2 tenants (A and B). When the internal executor's threads
* are busy running tasks and begins queuing tasks, its queue will contain at
* most a single task from A and a single task from B. As tasks from each tenant
* are scheduled on a thread, a new task for that tenant is pulled from the
* tenant's queue and placed in the internal executor's queue.
*
* Stochastic fairness
* -------------------
* For practical reasons related to memory utilization and performance, multiple
* tenants can potentially map to a single queue. When instantiating the
* SFQTM, we allocate a fixed number of queues and hash the tenant ID onto this
* fixed set of queues. This means that there is potential for multiple tenants
* to map onto the same queue, resulting in a shared request concurrency
* entitlement between them and unfairness. We mitigate this via perturbing the
* hash function periodically via 'perturb'. This ensures that even if there is
* a collision between two tenants, the condition will not be persistent. This
* perturbation may result in request reordering for a tenant under heavy load.
*
* Notes
* ~~~~~
* ** One may disable perturbing of the tenant hash by setting the period to
* 0 seconds.
*
* ** If unspecified in the execution scope, tenant ID is assumed to be
* zero.
*/
class SFQThreadManager : public ThreadManagerExecutorAdapter {
public:
explicit SFQThreadManager(SFQThreadManagerConfig config);
~SFQThreadManager() override;
[[nodiscard]] KeepAlive<> getKeepAlive(
ExecutionScope es, Source source) const override;
[[noreturn]] void add(
std::shared_ptr<Runnable>,
int64_t,
int64_t,
ThreadManager::Source) noexcept override {
LOG(FATAL)
<< "add*() is unsupported in SFQThreadManager, use getKeepAlive()";
}
// Return size of tenantQueue for a given priority and tenantId
size_t getTaskCount(ExecutionScope es);
private:
using ExecutorPtr = std::unique_ptr<folly::DefaultKeepAliveExecutor>;
void initPerturbation() {
perturbationSchedule_.addFunction(
[this]() mutable {
perturbVal_.fetch_add(1, std::memory_order_relaxed);
},
config_.getPerturbInterval(),
"sfq_perturb");
perturbationSchedule_.start();
}
uint64_t perturbId(uint64_t tenant, size_t val) const {
return folly::hash::hash_combine(tenant, val);
}
// Returns a metered executor associated with a tenant ID.
//
// Since we use a stochastic fair queue, we have a fixed number of metered
// queues and it's possible for multiple tenant IDs to collide on the same
// metered queue which manifests in unfairness for those tenants. We
// mitigate the issue by hashing the tenant IDs here with a periodically
// changing value so that it is unlikely to persist beyond the current
// period.
folly::MeteredExecutor* getMeteredExecutor(
size_t pri, uint64_t tenantId) const {
const size_t p = perturbVal_.load(std::memory_order_relaxed);
const uint64_t perturbedTenantId = perturbId(tenantId, p);
CHECK_LT(pri, fqs_.size());
const size_t perturbedIdx = perturbedTenantId % fqs_[pri].size();
return fqs_[pri][perturbedIdx].get();
}
// Set up the metered executors to act as fair queues.
void initQueues();
SFQThreadManagerConfig config_;
using MeteredExVec = std::vector<std::unique_ptr<folly::MeteredExecutor>>;
std::array<MeteredExVec, PRIORITY::N_PRIORITIES> fqs_;
std::atomic<size_t> perturbVal_{0};
folly::FunctionScheduler perturbationSchedule_;
};
} // namespace concurrency
} // namespace thrift
} // namespace apache
| 1,966 |
315 | <gh_stars>100-1000
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
unordered_map<ll,ll> arr;
ll Fibo(ll n)
{
if(n==0)
{
return 0;
}
if(arr[n]!=0)
{
return (arr[n]);
}
if(n&1)
{
ll x=(n+1)/2;
ll ans1=Fibo(x);
ans1=(ans1*ans1);
ll ans2=Fibo(x-1);
ans2=(ans2*ans2);
ll ans=(ans1+ans2);
arr[n]=ans;
return arr[n];
}
else
{
ll x=n/2;
ll ans1=Fibo(x);
ll ans2=Fibo(x-1);
ll ans3=Fibo(x+1);
//cout<<ans1<<ans2<<ans3;
ll ans=ans1*(ans2+ans3);
arr[n]=ans;
return arr[n];
}
}
int main()
{
arr[0]=0;
arr[1]=1;
arr[2]=1;
cout<<"Enter n to find the nth fibonacci number -\n";
ll n;
cin>>n;
ll ans=Fibo(n);
cout<<n<<"th Fibonacci number is "<<ans<<endl;
return 0;
}
| 549 |
3,102 | <filename>clang/include/clang/Frontend/MigratorOptions.h<gh_stars>1000+
//===--- MigratorOptions.h - MigratorOptions Options ------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This header contains the structures necessary for a front-end to specify
// various migration analysis.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_FRONTEND_MIGRATOROPTIONS_H
#define LLVM_CLANG_FRONTEND_MIGRATOROPTIONS_H
namespace clang {
class MigratorOptions {
public:
unsigned NoNSAllocReallocError : 1;
unsigned NoFinalizeRemoval : 1;
MigratorOptions() {
NoNSAllocReallocError = 0;
NoFinalizeRemoval = 0;
}
};
}
#endif
| 295 |
1,831 | /**
* Copyright (c) 2017-present, Facebook, Inc. and its affiliates.
* All rights reserved.
*
* This source code is licensed under the BSD-style license found in the
* LICENSE file in the root directory of this source tree.
*/
#pragma once
#include <map>
#include <vector>
#include "../Context.h"
#include "AdminCommandTable.h"
namespace facebook {
namespace logdevice {
namespace ldquery {
namespace tables {
class SyncSequencerRequests : public AdminCommandTable {
public:
explicit SyncSequencerRequests(std::shared_ptr<Context> ctx)
: AdminCommandTable(ctx) {}
static std::string getName() {
return "sync_sequencer_requests";
}
std::string getDescription() override {
return "List the currently running SyncSequencerRequests on that cluster. "
"See \"logdevice/common/SyncSequencerRequest.h\".";
}
TableColumns getFetchableColumns() const override {
return {
{"log_id", DataType::LOGID, "Log ID the SyncSequencerRequest is for."},
{"until_lsn", DataType::LSN, "Next LSN retrieved from the sequencer."},
{"last_released_lsn",
DataType::LSN,
"Last released LSN retrieved from the sequencer."},
{"last_status",
DataType::TEXT,
"Status of the last GetSeqStateRequest performed by "
"SyncSequencerRequest."},
};
}
std::string getCommandToSend(QueryContext& /*ctx*/) const override {
return std::string("info sync_sequencer_requests --json\n");
}
};
}}}} // namespace facebook::logdevice::ldquery::tables
| 541 |
523 | <gh_stars>100-1000
/* Copyright © 2013, Intel Corporation
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*/
#ifndef DLWRAP_H
#define DLWRAP_H
#define _GNU_SOURCE
#include <dlfcn.h>
/* Call the *real* dlopen. We have our own wrapper for dlopen that, of
* necessity must use claim the symbol 'dlopen'. So whenever anything
* internal needs to call the real, underlying dlopen function, the
* thing to call is dlwrap_real_dlopen.
*/
void *
dlwrap_real_dlopen(const char *filename, int flag);
/* Perform a dlopen on the libfips library itself.
*
* Many places in fips need to lookup symbols within the libfips
* library itself, (and not in any other library). This function
* provides a reliable way to get a handle for performing such
* lookups.
*
* The returned handle can be passed to dlwrap_real_dlsym for the
* lookups. */
void *
dlwrap_dlopen_libfips(void);
/* Call the *real* dlsym. We have our own wrapper for dlsym that, of
* necessity must use claim the symbol 'dlsym'. So whenever anything
* internal needs to call the real, underlying dlysm function, the
* thing to call is dlwrap_real_dlsym.
*/
void *
dlwrap_real_dlsym(void *handle, const char *symbol);
#define DEFER_TO_GL(library, func, name, args) \
({ \
void *lib = dlwrap_real_dlopen(library, RTLD_LAZY | RTLD_LOCAL); \
typeof(&func) real_func = dlwrap_real_dlsym(lib, name); \
/* gcc extension -- func's return value is the return value of \
* the statement. \
*/ \
real_func args; \
})
#endif
| 1,039 |
2,151 | <filename>services/video_capture/public/cpp/receiver_media_to_mojo_adapter.cc<gh_stars>1000+
// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "services/video_capture/public/cpp/receiver_media_to_mojo_adapter.h"
#include "media/capture/video/shared_memory_handle_provider.h"
#include "mojo/public/cpp/system/platform_handle.h"
namespace {
class ScopedAccessPermissionMojoToMediaAdapter
: public media::VideoCaptureDevice::Client::Buffer::ScopedAccessPermission {
public:
ScopedAccessPermissionMojoToMediaAdapter(
video_capture::mojom::ScopedAccessPermissionPtr access_permission)
: access_permission_(std::move(access_permission)) {}
private:
video_capture::mojom::ScopedAccessPermissionPtr access_permission_;
};
} // anonymous namespace
namespace video_capture {
ReceiverMediaToMojoAdapter::ReceiverMediaToMojoAdapter(
std::unique_ptr<media::VideoFrameReceiver> receiver)
: receiver_(std::move(receiver)) {}
ReceiverMediaToMojoAdapter::~ReceiverMediaToMojoAdapter() = default;
void ReceiverMediaToMojoAdapter::OnNewBuffer(
int32_t buffer_id,
media::mojom::VideoBufferHandlePtr buffer_handle) {
receiver_->OnNewBuffer(buffer_id, std::move(buffer_handle));
}
void ReceiverMediaToMojoAdapter::OnFrameReadyInBuffer(
int32_t buffer_id,
int32_t frame_feedback_id,
mojom::ScopedAccessPermissionPtr access_permission,
media::mojom::VideoFrameInfoPtr frame_info) {
receiver_->OnFrameReadyInBuffer(
buffer_id, frame_feedback_id,
std::make_unique<ScopedAccessPermissionMojoToMediaAdapter>(
std::move(access_permission)),
std::move(frame_info));
}
void ReceiverMediaToMojoAdapter::OnBufferRetired(int32_t buffer_id) {
receiver_->OnBufferRetired(buffer_id);
}
void ReceiverMediaToMojoAdapter::OnError() {
receiver_->OnError();
}
void ReceiverMediaToMojoAdapter::OnLog(const std::string& message) {
receiver_->OnLog(message);
}
void ReceiverMediaToMojoAdapter::OnStarted() {
receiver_->OnStarted();
}
void ReceiverMediaToMojoAdapter::OnStartedUsingGpuDecode() {
receiver_->OnStartedUsingGpuDecode();
}
} // namespace video_capture
| 776 |
5,169 | <gh_stars>1000+
{
"name": "QSNetworkTools",
"authors": {
"qiansheng": "<EMAIL>"
},
"license": "MIT",
"requires_arc": true,
"version": "0.0.1",
"homepage": "https://github.com/qs991011/QSNetworkTools",
"swift_version": "5.0",
"source_files": "source/*.swift",
"source": {
"git": "https://github.com/qs991011/QSNetworkTools.git",
"tag": "0.0.1"
},
"summary": "network tools",
"description": "base Alamofire network layer",
"platforms": {
"ios": "8.0"
},
"pod_target_xcconfig": {
"SWIFT_VERSION": "5.0"
}
}
| 248 |
3,139 | <filename>jme3-examples/src/main/java/jme3test/texture/TestTextureArray.java<gh_stars>1000+
package jme3test.texture;
import com.jme3.app.SimpleApplication;
import com.jme3.material.Material;
import com.jme3.math.Vector3f;
import com.jme3.renderer.Caps;
import com.jme3.scene.Geometry;
import com.jme3.scene.Mesh;
import com.jme3.scene.VertexBuffer.Type;
import com.jme3.texture.Image;
import com.jme3.texture.Texture;
import com.jme3.texture.TextureArray;
import com.jme3.util.BufferUtils;
import java.util.ArrayList;
import java.util.List;
public class TestTextureArray extends SimpleApplication
{
@Override
public void simpleInitApp()
{
Material mat = new Material(assetManager, "jme3test/texture/UnshadedArray.j3md");
for (Caps caps : renderManager.getRenderer().getCaps()) {
System.out.println(caps.name());
}
if(!renderManager.getRenderer().getCaps().contains(Caps.TextureArray)){
throw new UnsupportedOperationException("Your hardware does not support TextureArray");
}
Texture tex1 = assetManager.loadTexture( "Textures/Terrain/Pond/Pond.jpg");
Texture tex2 = assetManager.loadTexture("Textures/Terrain/Rock2/rock.jpg");
List<Image> images = new ArrayList<>();
images.add(tex1.getImage());
images.add(tex2.getImage());
TextureArray tex3 = new TextureArray(images);
tex3.setMinFilter(Texture.MinFilter.Trilinear);
mat.setTexture("ColorMap", tex3);
Mesh m = new Mesh();
Vector3f[] vertices = new Vector3f[8];
vertices[0] = new Vector3f(0, 0, 0);
vertices[1] = new Vector3f(3, 0, 0);
vertices[2] = new Vector3f(0, 3, 0);
vertices[3] = new Vector3f(3, 3, 0);
vertices[4] = new Vector3f(3, 0, 0);
vertices[5] = new Vector3f(6, 0, 0);
vertices[6] = new Vector3f(3, 3, 0);
vertices[7] = new Vector3f(6, 3, 0);
Vector3f[] texCoord = new Vector3f[8];
texCoord[0] = new Vector3f(0, 0, 0);
texCoord[1] = new Vector3f(1, 0, 0);
texCoord[2] = new Vector3f(0, 1, 0);
texCoord[3] = new Vector3f(1, 1, 0);
texCoord[4] = new Vector3f(0, 0, 1);
texCoord[5] = new Vector3f(1, 0, 1);
texCoord[6] = new Vector3f(0, 1, 1);
texCoord[7] = new Vector3f(1, 1, 1);
int[] indexes = { 2, 0, 1, 1, 3, 2 , 6, 4, 5, 5, 7, 6};
m.setBuffer(Type.Position, 3, BufferUtils.createFloatBuffer(vertices));
m.setBuffer(Type.TexCoord, 3, BufferUtils.createFloatBuffer(texCoord));
m.setBuffer(Type.Index, 1, BufferUtils.createIntBuffer(indexes));
m.updateBound();
Geometry geom = new Geometry("Mesh", m);
geom.setMaterial(mat);
rootNode.attachChild(geom);
}
/**
* @param args ignored
*/
public static void main(String[] args)
{
TestTextureArray app = new TestTextureArray();
app.start();
}
}
| 1,300 |
9,472 | <reponame>kzh3ka/japronto<filename>src/japronto/protocol/tracing.py
from functools import partial
from parser.libpicohttpparser import ffi
from request import HttpRequest
class TracingProtocol:
def __init__(self, on_headers_adapter: callable,
on_body_adapter: callable):
self.requests = []
self.error = None
self.on_headers_adapter = on_headers_adapter
self.on_body_adapter = on_body_adapter
self.on_headers_call_count = 0
self.on_body_call_count = 0
self.on_error_call_count = 0
def on_headers(self, *args):
self.request = self.on_headers_adapter(*args)
self.requests.append(self.request)
self.on_headers_call_count += 1
def on_body(self, body):
self.request.body = self.on_body_adapter(body)
self.on_body_call_count += 1
def on_error(self, error: str):
self.error = error
self.on_error_call_count += 1
def _request_from_cprotocol(method: memoryview, path: memoryview, version: int,
headers: memoryview):
method = method.tobytes().decode('ascii')
path = path.tobytes().decode('ascii')
version = "1.0" if version == 0 else "1.1"
headers_len = headers.nbytes // ffi.sizeof("struct phr_header")
headers_cdata = ffi.from_buffer(headers)
headers_cdata = ffi.cast(
'struct phr_header[{}]'.format(headers_len), headers_cdata)
headers = _extract_headers(headers_cdata)
return HttpRequest(method, path, version, headers)
def _body_from_cprotocol(body: memoryview):
return None if body is None else body.tobytes()
def _request_from_cffiprotocol(method: "char[]", path: "char[]", version: int,
headers: "struct phr_header[]"):
method = ffi.buffer(method)[:].decode('ascii')
path = ffi.buffer(path)[:].decode('ascii')
version = "1.0" if version == 0 else "1.1"
headers = _extract_headers(headers)
return HttpRequest(method, path, version, headers)
def _body_from_cffiprotocol(body: "char[]"):
return None if body is None else ffi.buffer(body)[:]
def _extract_headers(headers_cdata: "struct phr_header[]"):
headers = {}
for header in headers_cdata:
name = ffi.string(header.name, header.name_len).decode('ascii').title()
value = ffi.string(header.value, header.value_len).decode('latin1')
headers[name] = value
return headers
CTracingProtocol = partial(
TracingProtocol, on_headers_adapter=_request_from_cprotocol,
on_body_adapter=_body_from_cprotocol)
CffiTracingProtocol = partial(
TracingProtocol, on_headers_adapter=_request_from_cffiprotocol,
on_body_adapter=_body_from_cffiprotocol)
| 1,146 |
503 | <reponame>jerryleooo/rpc-benchmark-1
package benchmark.rpc.rapidoid.server;
import org.rapidoid.annotation.Controller;
import org.rapidoid.annotation.GET;
import benchmark.bean.User;
import benchmark.service.UserService;
import benchmark.service.UserServiceServerImpl;
@Controller
public class CreateUserController {
private final UserService userService = new UserServiceServerImpl();
@GET("create-user")
public boolean createUser(User user) {
return userService.createUser(user);
}
}
| 150 |
1,260 | // Copyright <NAME> 2013-2017
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE.md or copy at http://boost.org/LICENSE_1_0.txt)
#include <boost/hana/assert.hpp>
#include <boost/hana/equal.hpp>
#include <boost/hana/functional/apply.hpp>
#include <laws/base.hpp>
#include <support/tracked.hpp>
#include <type_traits>
#include <utility>
namespace hana = boost::hana;
template <int i = 0>
struct nonpod : Tracked {
nonpod() : Tracked{i} { }
};
struct NonCopyable {
NonCopyable() = default;
NonCopyable(NonCopyable const&) = delete;
NonCopyable& operator=(NonCopyable const&) = delete;
};
struct TestClass {
explicit TestClass(int x) : data(x) { }
TestClass(TestClass const&) = delete;
TestClass& operator=(TestClass const&) = delete;
int& operator()(NonCopyable&&) & { return data; }
int const& operator()(NonCopyable&&) const & { return data; }
int volatile& operator()(NonCopyable&&) volatile & { return data; }
int const volatile& operator()(NonCopyable&&) const volatile & { return data; }
int&& operator()(NonCopyable&&) && { return std::move(data); }
int const&& operator()(NonCopyable&&) const && { return std::move(data); }
int volatile&& operator()(NonCopyable&&) volatile && { return std::move(data); }
int const volatile&& operator()(NonCopyable&&) const volatile && { return std::move(data); }
int data;
};
struct DerivedFromTestClass : TestClass {
explicit DerivedFromTestClass(int x) : TestClass(x) { }
};
template <typename Signature, typename Expect, typename Functor>
void test_b12(Functor&& f) {
// Create the callable object.
using ClassFunc = Signature TestClass::*;
ClassFunc func_ptr = &TestClass::operator();
// Create the dummy arg.
NonCopyable arg;
// Check that the deduced return type of invoke is what is expected.
using DeducedReturnType = decltype(
hana::apply(func_ptr, std::forward<Functor>(f), std::move(arg))
);
static_assert(std::is_same<DeducedReturnType, Expect>::value, "");
// Run invoke and check the return value.
DeducedReturnType ret = hana::apply(func_ptr, std::forward<Functor>(f), std::move(arg));
BOOST_HANA_RUNTIME_CHECK(ret == 42);
}
template <typename Expect, typename Functor>
void test_b34(Functor&& f) {
// Create the callable object.
using ClassFunc = int TestClass::*;
ClassFunc func_ptr = &TestClass::data;
// Check that the deduced return type of invoke is what is expected.
using DeducedReturnType = decltype(
hana::apply(func_ptr, std::forward<Functor>(f))
);
static_assert(std::is_same<DeducedReturnType, Expect>::value, "");
// Run invoke and check the return value.
DeducedReturnType ret = hana::apply(func_ptr, std::forward<Functor>(f));
BOOST_HANA_RUNTIME_CHECK(ret == 42);
}
template <typename Expect, typename Functor>
void test_b5(Functor&& f) {
NonCopyable arg;
// Check that the deduced return type of invoke is what is expected.
using DeducedReturnType = decltype(
hana::apply(std::forward<Functor>(f), std::move(arg))
);
static_assert(std::is_same<DeducedReturnType, Expect>::value, "");
// Run invoke and check the return value.
DeducedReturnType ret = hana::apply(std::forward<Functor>(f), std::move(arg));
BOOST_HANA_RUNTIME_CHECK(ret == 42);
}
int& foo(NonCopyable&&) {
static int data = 42;
return data;
}
int main() {
// Test normal usage with a function object
{
hana::test::_injection<0> f{};
using hana::test::ct_eq;
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::apply(f),
f()
));
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::apply(f, ct_eq<0>{}),
f(ct_eq<0>{})
));
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::apply(f, ct_eq<0>{}, ct_eq<1>{}),
f(ct_eq<0>{}, ct_eq<1>{})
));
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::apply(f, ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}),
f(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{})
));
BOOST_HANA_CONSTANT_CHECK(hana::equal(
hana::apply(f, ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}, ct_eq<3>{}),
f(ct_eq<0>{}, ct_eq<1>{}, ct_eq<2>{}, ct_eq<3>{})
));
// Make sure we can use apply with non-PODs
hana::apply(f, nonpod<>{});
}
// Bullets 1 & 2 in the standard
{
TestClass cl(42);
test_b12<int&(NonCopyable&&) &, int&>(cl);
test_b12<int const&(NonCopyable&&) const &, int const&>(cl);
test_b12<int volatile&(NonCopyable&&) volatile &, int volatile&>(cl);
test_b12<int const volatile&(NonCopyable&&) const volatile &, int const volatile&>(cl);
test_b12<int&&(NonCopyable&&) &&, int&&>(std::move(cl));
test_b12<int const&&(NonCopyable&&) const &&, int const&&>(std::move(cl));
test_b12<int volatile&&(NonCopyable&&) volatile &&, int volatile&&>(std::move(cl));
test_b12<int const volatile&&(NonCopyable&&) const volatile &&, int const volatile&&>(std::move(cl));
}
{
DerivedFromTestClass cl(42);
test_b12<int&(NonCopyable&&) &, int&>(cl);
test_b12<int const&(NonCopyable&&) const &, int const&>(cl);
test_b12<int volatile&(NonCopyable&&) volatile &, int volatile&>(cl);
test_b12<int const volatile&(NonCopyable&&) const volatile &, int const volatile&>(cl);
test_b12<int&&(NonCopyable&&) &&, int&&>(std::move(cl));
test_b12<int const&&(NonCopyable&&) const &&, int const&&>(std::move(cl));
test_b12<int volatile&&(NonCopyable&&) volatile &&, int volatile&&>(std::move(cl));
test_b12<int const volatile&&(NonCopyable&&) const volatile &&, int const volatile&&>(std::move(cl));
}
{
TestClass cl_obj(42);
TestClass *cl = &cl_obj;
test_b12<int&(NonCopyable&&) &, int&>(cl);
test_b12<int const&(NonCopyable&&) const &, int const&>(cl);
test_b12<int volatile&(NonCopyable&&) volatile &, int volatile&>(cl);
test_b12<int const volatile&(NonCopyable&&) const volatile &, int const volatile&>(cl);
}
{
DerivedFromTestClass cl_obj(42);
DerivedFromTestClass *cl = &cl_obj;
test_b12<int&(NonCopyable&&) &, int&>(cl);
test_b12<int const&(NonCopyable&&) const &, int const&>(cl);
test_b12<int volatile&(NonCopyable&&) volatile &, int volatile&>(cl);
test_b12<int const volatile&(NonCopyable&&) const volatile &, int const volatile&>(cl);
}
// Bullets 3 & 4 in the standard
{
using Fn = TestClass;
Fn cl(42);
test_b34<int&>(cl);
test_b34<int const&>(static_cast<Fn const&>(cl));
test_b34<int volatile&>(static_cast<Fn volatile&>(cl));
test_b34<int const volatile&>(static_cast<Fn const volatile &>(cl));
test_b34<int&&>(static_cast<Fn &&>(cl));
test_b34<int const&&>(static_cast<Fn const&&>(cl));
test_b34<int volatile&&>(static_cast<Fn volatile&&>(cl));
test_b34<int const volatile&&>(static_cast<Fn const volatile&&>(cl));
}
{
using Fn = DerivedFromTestClass;
Fn cl(42);
test_b34<int&>(cl);
test_b34<int const&>(static_cast<Fn const&>(cl));
test_b34<int volatile&>(static_cast<Fn volatile&>(cl));
test_b34<int const volatile&>(static_cast<Fn const volatile &>(cl));
test_b34<int&&>(static_cast<Fn &&>(cl));
test_b34<int const&&>(static_cast<Fn const&&>(cl));
test_b34<int volatile&&>(static_cast<Fn volatile&&>(cl));
test_b34<int const volatile&&>(static_cast<Fn const volatile&&>(cl));
}
{
using Fn = TestClass;
Fn cl_obj(42);
Fn* cl = &cl_obj;
test_b34<int&>(cl);
test_b34<int const&>(static_cast<Fn const*>(cl));
test_b34<int volatile&>(static_cast<Fn volatile*>(cl));
test_b34<int const volatile&>(static_cast<Fn const volatile *>(cl));
}
{
using Fn = DerivedFromTestClass;
Fn cl_obj(42);
Fn* cl = &cl_obj;
test_b34<int&>(cl);
test_b34<int const&>(static_cast<Fn const*>(cl));
test_b34<int volatile&>(static_cast<Fn volatile*>(cl));
test_b34<int const volatile&>(static_cast<Fn const volatile *>(cl));
}
// Bullet 5 in the standard
using FooType = int&(NonCopyable&&);
{
FooType& fn = foo;
test_b5<int &>(fn);
}
{
FooType* fn = foo;
test_b5<int &>(fn);
}
{
using Fn = TestClass;
Fn cl(42);
test_b5<int&>(cl);
test_b5<int const&>(static_cast<Fn const&>(cl));
test_b5<int volatile&>(static_cast<Fn volatile&>(cl));
test_b5<int const volatile&>(static_cast<Fn const volatile &>(cl));
test_b5<int&&>(static_cast<Fn &&>(cl));
test_b5<int const&&>(static_cast<Fn const&&>(cl));
test_b5<int volatile&&>(static_cast<Fn volatile&&>(cl));
test_b5<int const volatile&&>(static_cast<Fn const volatile&&>(cl));
}
}
| 4,022 |
626 | <gh_stars>100-1000
import argparse
import gzip
import json
import os
import time
from os import listdir
from os.path import isfile, join
from whoosh.index import create_in
from whoosh.fields import *
def get_id_years(file_paths):
print('Collecting paper ids and their publication years...')
id_years = []
for file_num, file_path in enumerate(file_paths):
with gzip.open(file_path) as f:
for line_num, line in enumerate(f):
obj = json.loads(line.strip())
doc_id = obj['id']
if 'year' not in obj:
continue
year = int(obj['year'])
id_years.append((doc_id, year))
if line_num % 100000 == 0:
print('Processed {} lines. Collected {} docs.'.format(
line_num + 1, len(id_years)))
print('Sorting papers by year...')
id_years.sort(key = lambda x: x[1])
id_years = {id: year for id, year in id_years}
return id_years
def create_dataset(args):
print('Converting data...')
file_names = listdir(args.collection_path)
file_paths = []
for file_name in file_names:
file_path = join(args.collection_path, file_name)
if not isfile(file_path):
continue
if not file_path.endswith('.gz'):
continue
file_paths.append(file_path)
print('{} files found'.format(len(file_paths)))
# We need to create whoosh index files to do the key term extraction
schema = Schema(title=TEXT,
abstract=TEXT,
id=ID(stored=True))
if os.path.exists(args.whoosh_index):
assert False
else:
os.mkdir(args.whoosh_index)
whoosh_index = create_in(args.whoosh_index, schema)
writer = whoosh_index.writer()
id_years = get_id_years(file_paths)
doc_ids = set(id_years.keys())
line_num = 0
start_time = time.time()
for file_num, file_path in enumerate(file_paths):
with gzip.open(file_path) as f:
for line in f:
obj = json.loads(line.strip())
doc_id = obj['id']
writer.add_document(id=doc_id, title=obj['title'], abstract=obj['paperAbstract'])
line_num += 1
if line_num % 100000 == 0:
print("{} lines whoosh indexed in {} seconds\r".format(line_num, int(time.time()-start_time)))
writer.commit()
if __name__ == '__main__':
parser = argparse.ArgumentParser(
description='''Converts Open Research Corpus jsonl collection to Whoosh's index.''')
parser.add_argument('--collection_path', required=True, help='Open Research jsonl collection file')
parser.add_argument('--whoosh_index', required=True, help='whoosh index folder')
args = parser.parse_args()
create_dataset(args)
print('Done!')
| 1,190 |
335 | <reponame>Safal08/Hacktoberfest-1
{
"word": "Tongue",
"definitions": [
"The fleshy muscular organ in the mouth of a mammal, used for tasting, licking, swallowing, and (in humans) articulating speech.",
"The equivalent organ in other vertebrates, sometimes used (in snakes) as a scent organ or (in chameleons) for catching food.",
"An analogous organ in insects, formed from some of the mouthparts and used in feeding.",
"The tongue of an ox or lamb as food.",
"Used in reference to a person's style or manner of speaking.",
"A particular language.",
"A strip of leather or fabric under the laces in a shoe, attached only at the front end.",
"The pin of a buckle.",
"The free-swinging metal piece inside a bell which is made to strike the bell to produce the sound.",
"A long, low promontory of land.",
"A projecting strip on a wooden board fitting into a groove on another.",
"The vibrating reed of a musical instrument or organ pipe.",
"A jet of flame."
],
"parts-of-speech": "Noun"
} | 373 |
687 | /************************************************************************************
Heavy-light decomposition with segment trees in paths.
Used for finding maximum on the path between two vertices.
O(N) on building, O(logN ^ 2) on query.
Based on problem 1553 from acm.timus.ru
http://acm.timus.ru/problem.aspx?space=1&num=1553
************************************************************************************/
#include <iostream>
#include <fstream>
#include <cmath>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <cstdlib>
#include <cstdio>
#include <string>
#include <cstring>
#include <cassert>
#include <utility>
#include <iomanip>
using namespace std;
const int MAXN = 105000;
struct SegmentTree {
int * tree;
int size;
void init(int sz) {
tree = new int[4 * sz];
memset(tree, 0, 4 * sz * sizeof(int));
size = sz;
}
int getMax(int v, int from, int to, int l, int r) {
if (l > to || r < from)
return 0;
if (from == l && to == r)
return tree[v];
int mid = (from + to) / 2;
int res = getMax(v * 2, from, mid, l, min(r, mid));
res = max(res, getMax(v * 2 + 1, mid + 1, to, max(l, mid + 1), r));
return res;
}
int getMax(int l, int r) {
return getMax(1, 1, size, l, r);
}
void update(int v, int from, int to, int pos, int val) {
if (pos > to || pos < from)
return;
if (from == pos && to == pos) {
tree[v] = val;
return;
}
int mid = (from + to) / 2;
update(v * 2, from, mid, pos, val);
update(v * 2 + 1, mid + 1, to, pos, val);
tree[v] = max(tree[v * 2], tree[v * 2 + 1]);
}
void update(int pos, int val) {
update(1, 1, size, pos, val);
}
};
int n, qn;
char q;
int a, b;
int timer;
int sz[MAXN];
int tin[MAXN], tout[MAXN];
int val[MAXN];
vector <int> g[MAXN];
int p[MAXN];
int chain[MAXN], chainRoot[MAXN];
int chainSize[MAXN], chainPos[MAXN];
int chainNum;
SegmentTree tree[MAXN];
bool isHeavy(int from, int to) {
return sz[to] * 2 >= sz[from];
}
void dfs(int v, int par = -1) {
timer++;
tin[v] = timer;
p[v] = par;
sz[v] = 1;
for (int i = 0; i < (int) g[v].size(); i++) {
int to = g[v][i];
if (to == par)
continue;
dfs(to, v);
sz[v] += sz[to];
}
timer++;
tout[v] = timer;
}
int newChain(int root) {
chainNum++;
chainRoot[chainNum] = root;
return chainNum;
}
void buildHLD(int v, int curChain) {
chain[v] = curChain;
chainSize[curChain]++;
chainPos[v] = chainSize[curChain];
for (int i = 0; i < g[v].size(); i++) {
int to = g[v][i];
if (p[v] == to)
continue;
if (isHeavy(v, to))
buildHLD(to, curChain);
else
buildHLD(to, newChain(to));
}
}
bool isParent(int a, int b) {
return tin[a] <= tin[b] && tout[a] >= tout[b];
}
int getMax(int a, int b) {
int res = 0;
while (true) {
int curChain = chain[a];
if (isParent(chainRoot[curChain], b))
break;
res = max(res, tree[curChain].getMax(1, chainPos[a]));
a = p[chainRoot[curChain]];
}
while (true) {
int curChain = chain[b];
if (isParent(chainRoot[curChain], a))
break;
res = max(res, tree[curChain].getMax(1, chainPos[b]));
b = p[chainRoot[curChain]];
}
int from = chainPos[a], to = chainPos[b];
if (from > to)
swap(from, to);
res = max(res, tree[chain[a]].getMax(from, to));
return res;
}
int main() {
//assert(freopen("input.txt","r",stdin));
//assert(freopen("output.txt","w",stdout));
scanf("%d", &n);
for (int i = 1; i < n; i++) {
int from, to;
scanf("%d %d", &from, &to);
g[from].push_back(to);
g[to].push_back(from);
}
dfs(1);
buildHLD(1, newChain(1));
for (int i = 1; i <= chainNum; i++) {
tree[i].init(chainSize[i]);
}
scanf("%d\n", &qn);
for (int i = 1; i <= qn; i++) {
scanf("%c %d %d\n", &q, &a, &b);
if (q == 'I') {
val[a] += b;
tree[chain[a]].update(chainPos[a], val[a]);
}
else {
printf("%d\n", getMax(a, b));
}
}
return 0;
}
| 2,442 |
322 | <reponame>Daisy000888/Open-Vehicle-Monitoring-System-3<gh_stars>100-1000
/*
; Project: Open Vehicle Monitor System
; Date: 21th January 2019
;
; (C) 2019 <NAME> <<EMAIL>>
;
; Permission is hereby granted, free of charge, to any person obtaining a copy
; of this software and associated documentation files (the "Software"), to deal
; in the Software without restriction, including without limitation the rights
; to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
; copies of the Software, and to permit persons to whom the Software is
; furnished to do so, subject to the following conditions:
;
; The above copyright notice and this permission notice shall be included in
; all copies or substantial portions of the Software.
;
; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
; IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
; FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
; AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
; LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
; THE SOFTWARE.
*/
#include "vehicle_kianiroev.h"
//static const char *TAG = "v-kianiroev";
/**
* Handles incoming CAN-frames on bus 1, the C-bus
*/
void OvmsVehicleKiaNiroEv::IncomingFrameCan1(CAN_frame_t* p_frame)
{
uint8_t *d = p_frame->data.u8;
//ESP_LOGD(TAG, "IFC %03x 8 %02x %02x %02x %02x %02x %02x %02x %02x",
// p_frame->MsgID, d[0], d[1], d[2], d[3], d[4], d[5], d[6], d[7]);
// Check if response is from synchronous can message
if (kia_send_can.status == 0xff && p_frame->MsgID == (kia_send_can.id + 0x08))
{
//Store message bytes so that the async method can continue
kia_send_can.status = 3;
kia_send_can.byte[0] = d[0];
kia_send_can.byte[1] = d[1];
kia_send_can.byte[2] = d[2];
kia_send_can.byte[3] = d[3];
kia_send_can.byte[4] = d[4];
kia_send_can.byte[5] = d[5];
kia_send_can.byte[6] = d[6];
kia_send_can.byte[7] = d[7];
}
}
| 795 |
839 | <gh_stars>100-1000
/**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.cxf.tools.wsdlto.frontend.jaxws.processor.internal;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.logging.Level;
import javax.xml.namespace.QName;
import org.w3c.dom.Element;
import org.apache.cxf.common.util.StringUtils;
import org.apache.cxf.service.model.InterfaceInfo;
import org.apache.cxf.service.model.OperationInfo;
import org.apache.cxf.service.model.ServiceInfo;
import org.apache.cxf.tools.common.ToolConstants;
import org.apache.cxf.tools.common.ToolContext;
import org.apache.cxf.tools.common.ToolException;
import org.apache.cxf.tools.common.model.JavaInterface;
import org.apache.cxf.tools.common.model.JavaModel;
import org.apache.cxf.tools.util.ClassCollector;
import org.apache.cxf.tools.wsdlto.frontend.jaxws.customization.JAXWSBinding;
import org.apache.cxf.tools.wsdlto.frontend.jaxws.processor.internal.mapper.InterfaceMapper;
public class PortTypeProcessor extends AbstractProcessor {
private List<QName> operationMap = new ArrayList<>();
public PortTypeProcessor(ToolContext c) {
super(c);
}
public static JavaInterface getInterface(
ToolContext context,
ServiceInfo serviceInfo,
InterfaceInfo interfaceInfo) throws ToolException {
JavaInterface intf = interfaceInfo.getProperty("JavaInterface", JavaInterface.class);
if (intf == null) {
intf = new InterfaceMapper(context).map(interfaceInfo);
JAXWSBinding jaxwsBinding = null;
if (serviceInfo.getDescription() != null) {
jaxwsBinding = serviceInfo.getDescription().getExtensor(JAXWSBinding.class);
}
JAXWSBinding infBinding = interfaceInfo.getExtensor(JAXWSBinding.class);
if (infBinding != null && infBinding.getPackage() != null) {
intf.setPackageName(infBinding.getPackage());
} else if (jaxwsBinding != null && jaxwsBinding.getPackage() != null) {
intf.setPackageName(jaxwsBinding.getPackage());
}
if (infBinding != null && !infBinding.getPackageJavaDoc().isEmpty()) {
intf.setPackageJavaDoc(infBinding.getPackageJavaDoc());
} else if (jaxwsBinding != null && !jaxwsBinding.getPackageJavaDoc().isEmpty()) {
intf.setPackageJavaDoc(jaxwsBinding.getPackageJavaDoc());
}
String name = intf.getName();
if (infBinding != null
&& infBinding.getJaxwsClass() != null
&& infBinding.getJaxwsClass().getClassName() != null) {
name = infBinding.getJaxwsClass().getClassName();
if (name.contains(".")) {
intf.setPackageName(name.substring(0, name.lastIndexOf('.')));
name = name.substring(name.lastIndexOf('.') + 1);
}
intf.setClassJavaDoc(infBinding.getJaxwsClass().getComments());
}
if (StringUtils.isEmpty(intf.getClassJavaDoc())) {
intf.setClassJavaDoc(interfaceInfo.getDocumentation());
}
ClassCollector collector = context.get(ClassCollector.class);
if (context.optionSet(ToolConstants.CFG_AUTORESOLVE)) {
int count = 0;
String checkName = name;
while (collector.isReserved(intf.getPackageName(), checkName)) {
checkName = name + "_" + (++count);
}
name = checkName;
} else if (collector.isReserved(intf.getPackageName(), name)) {
throw new ToolException("RESERVED_SEI_NAME", LOG, name);
}
interfaceInfo.setProperty("InterfaceName", name);
intf.setName(name);
collector.addSeiClassName(intf.getPackageName(),
intf.getName(),
intf.getPackageName() + "." + intf.getName());
interfaceInfo.setProperty("JavaInterface", intf);
if (context.containsKey(ToolConstants.CFG_SEI_SUPER)) {
String[] supers = context.getArray(ToolConstants.CFG_SEI_SUPER);
for (String s : supers) {
intf.addSuperInterface(s);
}
}
}
return intf;
}
public void processClassNames(ServiceInfo serviceInfo) throws ToolException {
InterfaceInfo interfaceInfo = serviceInfo.getInterface();
if (interfaceInfo == null) {
return;
}
getInterface(context, serviceInfo, interfaceInfo);
}
public void process(ServiceInfo serviceInfo) throws ToolException {
operationMap.clear();
JavaModel jmodel = context.get(JavaModel.class);
InterfaceInfo interfaceInfo = serviceInfo.getInterface();
if (interfaceInfo == null) {
return;
}
JavaInterface intf = getInterface(context, serviceInfo, interfaceInfo);
intf.setJavaModel(jmodel);
Element handler = (Element)context.get(ToolConstants.HANDLER_CHAIN);
intf.setHandlerChains(handler);
Collection<OperationInfo> operations = interfaceInfo.getOperations();
for (OperationInfo operation : operations) {
if (isOverloading(operation.getName())) {
LOG.log(Level.WARNING, "SKIP_OVERLOADED_OPERATION", operation.getName());
continue;
}
OperationProcessor operationProcessor = new OperationProcessor(context);
operationProcessor.process(intf, operation);
}
jmodel.setLocation(intf.getLocation());
jmodel.addInterface(intf.getName(), intf);
}
private boolean isOverloading(QName operationName) {
if (operationMap.contains(operationName)) {
return true;
}
operationMap.add(operationName);
return false;
}
}
| 2,926 |
799 | import demistomock as demisto
from CommonServerPython import *
import requests
import json
import dateparser
import traceback
import urllib.parse
from typing import Any, Dict, Tuple, List, Optional, cast
''' CONSTANTS '''
DATE_FORMAT = '%Y-%m-%dT%H:%M:%SZ'
# Disable insecure warnings
requests.packages.urllib3.disable_warnings()
''' CLIENT CLASS '''
class Client(BaseClient):
"""Client class to interact with the service API
This Client implements API calls, and does not contain any Demisto logic.
Should only do requests and return data.
It inherits from BaseClient defined in CommonServer Python.
Most calls use _http_request() that handles proxy, SSL verification, etc.
"""
def xm_get_user(self, user: str):
"""Retrieves a user in xMatters. Good for testing authentication
:type user: ``str``
:param user: The user to retrieve
:return: Result from getting the user
:rtype: ``Dict[str, Any]``
"""
res = self._http_request(
method='GET',
url_suffix='/api/xm/1/people?webLogin=' + urllib.parse.quote(user)
)
return res
def xm_trigger_workflow(self, recipients: Optional[str] = None,
subject: Optional[str] = None, body: Optional[str] = None,
incident_id: Optional[str] = None,
close_task_id: Optional[str] = None) -> Dict[str, Any]:
"""Triggers a workflow in xMatters.
:type recipients: ``Optional[str]``
:param recipients: recipients for the xMatters alert.
:type subject: ``Optional[str]``
:param subject: Subject for the message in xMatters.
:type body: ``Optional[str]``
:param body: Body for the message in xMatters.
:type incident_id: ``Optional[str]``
:param incident_id: ID of incident that the message is related to.
:type close_task_id: ``Optional[str]``
:param close_task_id: Task ID from playbook to close.
:return: result of the http request
:rtype: ``Dict[str, Any]``
"""
request_params: Dict[str, Any] = {
}
if recipients:
request_params['recipients'] = recipients
if subject:
request_params['subject'] = subject
if body:
request_params['body'] = body
if incident_id:
request_params['incident_id'] = incident_id
if close_task_id:
request_params['close_task_id'] = close_task_id
res = self._http_request(
method='POST',
url_suffix='',
params=request_params,
)
return res
def search_alerts(self, max_fetch: int = 100, alert_status: Optional[str] = None, priority: Optional[str] = None,
start_time: Optional[int] = None, property_name: Optional[str] = None,
property_value: Optional[str] = None, request_id: Optional[str] = None,
from_time: Optional[str] = None, to_time: Optional[str] = None,
workflow: Optional[str] = None, form: Optional[str] = None) -> List[Dict[str, Any]]:
"""Searches for xMatters alerts using the '/events' API endpoint
All the parameters are passed directly to the API as HTTP POST parameters in the request
:type max_fetch: ``str``
:param max_fetch: The maximum number of events or incidents to retrieve
:type alert_status: ``Optional[str]``
:param alert_status: status of the alert to search for. Options are: 'ACTIVE' or 'SUSPENDED'
:type priority: ``Optional[str]``
:param priority:
severity of the alert to search for. Comma-separated values.
Options are: "LOW", "MEDIUM", "HIGH"
:type start_time: ``Optional[int]``
:param start_time: start timestamp (epoch in seconds) for the alert search
:type property_name: ``Optional[str]``
:param property_name: Name of property to match when searching for alerts.
:type property_value: ``Optional[str]``
:param property_value: Value of property to match when searching for alerts.
:type request_id: ``Optional[str]``
:param request_id: Matches requestId in xMatters.
:type from_time: ``Optional[str]``
:param from_time: UTC time of the beginning time to search for events.
:type to_time: ``Optional[str]``
:param to_time: UTC time of the end time to search for events.
:type workflow: ``Optional[str]``
:param workflow: Workflow that events are from in xMatters.
:type form: ``Optional[str]``
:param form: Form that events are from in xMatters.
:return: list containing the found xMatters events as dicts
:rtype: ``List[Dict[str, Any]]``
"""
request_params: Dict[str, Any] = {}
request_params['limit'] = max_fetch
if alert_status:
request_params['status'] = alert_status
if priority:
request_params['priority'] = priority
if from_time:
request_params['from'] = from_time
elif start_time:
request_params['from'] = start_time
if to_time:
request_params['to'] = to_time
if property_value and property_name:
request_params['propertyName'] = property_name
request_params['propertyValue'] = property_value
if request_id:
request_params['requestId'] = request_id
if workflow:
request_params['plan'] = workflow
if form:
request_params['form'] = form
res = self._http_request(
method='GET',
url_suffix='/api/xm/1/events',
params=request_params
)
data = res.get('data')
has_next = True
while has_next:
if 'links' in res and 'next' in res['links']:
res = self._http_request(
method='GET',
url_suffix=res.get('links').get('next')
)
for val in res.get('data'):
data.append(val)
else:
has_next = False
return data
def search_alert(self, event_id: str):
"""Searches for xMatters alerts using the '/events' API endpoint
The event_id is passed as a parameter to the API call.
:type event_id: ``Required[str]``
:param event_id: The event ID or UUID of the event to retrieve
"""
res = self._http_request(
method='GET',
url_suffix='/api/xm/1/events/' + event_id,
ok_codes=(200, 404)
)
return res
''' HELPER FUNCTIONS '''
def convert_to_demisto_severity(severity: str) -> int:
"""Maps xMatters severity to Cortex XSOAR severity
Converts the xMatters alert severity level ('Low', 'Medium',
'High') to Cortex XSOAR incident severity (1 to 4)
for mapping.
:type severity: ``str``
:param severity: severity as returned from the HelloWorld API (str)
:return: Cortex XSOAR Severity (1 to 4)
:rtype: ``int``
"""
# In this case the mapping is straightforward, but more complex mappings
# might be required in your integration, so a dedicated function is
# recommended. This mapping should also be documented.
return {
'low': 1, # low severity
'medium': 2, # medium severity
'high': 3, # high severity
}[severity.lower()]
def arg_to_timestamp(arg: Any, arg_name: str, required: bool = False) -> Optional[int]:
"""Converts an XSOAR argument to a timestamp (seconds from epoch)
This function is used to quickly validate an argument provided to XSOAR
via ``demisto.args()`` into an ``int`` containing a timestamp (seconds
since epoch). It will throw a ValueError if the input is invalid.
If the input is None, it will throw a ValueError if required is ``True``,
or ``None`` if required is ``False.
:type arg: ``Any``
:param arg: argument to convert
:type arg_name: ``str``
:param arg_name: argument name
:type required: ``bool``
:param required:
throws exception if ``True`` and argument provided is None
:return:
returns an ``int`` containing a timestamp (seconds from epoch) if conversion works
returns ``None`` if arg is ``None`` and required is set to ``False``
otherwise throws an Exception
:rtype: ``Optional[int]``
"""
if arg is None:
if required is True:
raise ValueError(f'Missing "{arg_name}"')
return None
if isinstance(arg, str) and arg.isdigit():
# timestamp is a str containing digits - we just convert it to int
return int(arg)
if isinstance(arg, str):
# we use dateparser to handle strings either in ISO8601 format, or
# relative time stamps.
# For example: format 2019-10-23T00:00:00 or "3 days", etc
date = dateparser.parse(arg, settings={'TIMEZONE': 'UTC'})
if date is None:
# if d is None it means dateparser failed to parse it
raise ValueError(f'Invalid date: {arg_name}')
return int(date.timestamp())
if isinstance(arg, (int, float)):
# Convert to int if the input is a float
return int(arg)
raise ValueError(f'Invalid date: "{arg_name}"')
''' COMMAND FUNCTIONS '''
def fetch_incidents(client: Client,
max_fetch: int = 100,
last_run: Dict[str, int] = {},
first_fetch_time: Optional[int] = None,
alert_status: Optional[str] = None,
priority: Optional[str] = None,
property_name: Optional[str] = None,
property_value: Optional[str] = None
) -> Tuple[Dict[str, int], List[dict]]:
"""This function retrieves new alerts every interval (default is 1 minute).
This function has to implement the logic of making sure that incidents are
fetched only onces and no incidents are missed. By default it's invoked by
XSOAR every minute. It will use last_run to save the timestamp of the last
incident it processed. If last_run is not provided, it should use the
integration parameter first_fetch_time to determine when to start fetching
the first time.
:type client: ``Client``
:param Client: xMatters client to use
:type last_run: ``Optional[Dict[str, int]]``
:param last_run:
A dict with a key containing the latest incident created time we got
from last fetch
:type first_fetch_time: ``Optional[int]``
:param first_fetch_time:
If last_run is None (first time we are fetching), it contains
the timestamp in milliseconds on when to start fetching incidents
:type alert_status: ``Optional[str]``
:param alert_status:
status of the alert to search for. Options are: 'ACTIVE',
'SUSPENDED', or 'TERMINATED'
:type max_fetch: ``str``
:param max_fetch:
The maximum number of events or incidents to fetch.
:type priority: ``str``
:param priority:
Comma-separated list of the priority to search for.
Options are: "LOW", "MEDIUM", "HIGH"
:type property_name: ``Optional[str]``
:param property_name: Property name to match with events.
:type property_value: ``Optional[str]``
:param property_value: Property value to match with events.
:return:
A tuple containing two elements:
next_run (``Dict[str, int]``): Contains the timestamp that will be
used in ``last_run`` on the next fetch.
incidents (``List[dict]``): List of incidents that will be created in XSOAR
:rtype: ``Tuple[Dict[str, int], List[dict]]``
"""
# Get the last fetch time, if exists
# last_run is a dict with a single key, called last_fetch
last_fetch = last_run.get('last_fetch', None)
# Handle first fetch time
if last_fetch is None:
# if missing, use what provided via first_fetch_time
last_fetch = first_fetch_time
else:
# otherwise use the stored last fetch
last_fetch = int(last_fetch)
# for type checking, making sure that latest_created_time is int
latest_created_time = cast(int, last_fetch)
# Initialize an empty list of incidents to return
# Each incident is a dict with a string as a key
incidents: List[Dict[str, Any]] = []
if last_fetch is not None:
start_time = timestamp_to_datestring(last_fetch * 1000)
else:
start_time = None
# demisto.info("This is the current timestamp: " + str(start_time))
# demisto.info("MS - last_fetch: " + str(last_fetch))
alerts = client.search_alerts(
max_fetch=max_fetch,
alert_status=alert_status,
start_time=start_time,
priority=priority,
property_name=property_name,
property_value=property_value
)
for alert in alerts:
try:
# If no created_time set is as epoch (0). We use time in ms so we must
# convert it from the HelloWorld API response
incident_created_time = alert.get('created')
# If no name is present it will throw an exception
if "name" in alert:
incident_name = alert['name']
else:
incident_name = "No Message Subject"
datetimeformat = '%Y-%m-%dT%H:%M:%S.000Z'
if isinstance(incident_created_time, str):
parseddate = dateparser.parse(incident_created_time)
if isinstance(parseddate, datetime):
occurred = parseddate.strftime(datetimeformat)
date = dateparser.parse(occurred, settings={'TIMEZONE': 'UTC'})
if isinstance(date, datetime):
incident_created_time = int(date.timestamp())
incident_created_time_ms = incident_created_time * 1000
else:
incident_created_time = 0
incident_created_time_ms = 0
else:
date = None
incident_created_time = 0
incident_created_time_ms = 0
else:
date = None
incident_created_time = 0
incident_created_time_ms = 0
demisto.info("MS - incident_created_time: " + str(last_fetch))
# to prevent duplicates, we are only adding incidents with creation_time > last fetched incident
if last_fetch:
if incident_created_time <= last_fetch:
continue
details = ""
if 'plan' in alert:
details = details + alert['plan']['name'] + " - "
if 'form' in alert:
details = details + alert['form']['name']
incident = {
'name': incident_name,
'details': details,
'occurred': timestamp_to_datestring(incident_created_time_ms),
'rawJSON': json.dumps(alert),
'type': 'xMatters Alert', # Map to a specific XSOAR incident Type
'severity': convert_to_demisto_severity(alert.get('priority', 'Low')),
}
incidents.append(incident)
# Update last run and add incident if the incident is newer than last fetch
if isinstance(date, datetime) and date.timestamp() > latest_created_time:
latest_created_time = incident_created_time
except Exception as e:
demisto.info("Issue with event")
demisto.info(str(alert))
demisto.info(str(e))
pass
# Save the next_run as a dict with the last_fetch key to be stored
next_run = {'last_fetch': latest_created_time}
return next_run, incidents
def event_reduce(e):
return {"Created": e.get('created'),
"Terminated": e.get('terminated'),
"ID": e.get('id'),
"EventID": e.get('eventId'),
"Name": e.get('name'),
"PlanName": e.get('plan').get('name'),
"FormName": e.get('form').get('name'),
"Status": e.get('status'),
"Priority": e.get('priority'),
"Properties": e.get('properties'),
"SubmitterName": e.get('submitter').get('targetName')}
def xm_trigger_workflow_command(client: Client, recipients: str,
subject: str, body: str, incident_id: str,
close_task_id: str) -> CommandResults:
out = client.xm_trigger_workflow(
recipients=recipients,
subject=subject,
body=body,
incident_id=incident_id,
close_task_id=close_task_id
)
"""
This function runs when the xm-trigger-workflow command is run.
:type client: ``Client``
:param Client: xMatters client to use
:type recipients: ``str``
:param recipients: Recipients to alert from xMatters.
:type subject: ``str``
:param subject: Subject of the alert in xMatters.
:type body: ``str``
:param body: Body of the alert in xMatters.
:type incident_id: ``str``
:param incident_id: Incident ID of the event in XSOAR.
:type close_task_id: ``str``
:param close_task_id: ID of task to close in a playbook.
:return: Output of xm-trigger-workflow command being run.
:rtype: ``CommandResults``
"""
outputs = {}
outputs['requestId'] = out['requestId']
return CommandResults(
readable_output="Successfully sent a message to xMatters.",
outputs=outputs,
outputs_prefix='xMatters.Workflow',
outputs_key_field='requestId'
)
def xm_get_events_command(client: Client, request_id: Optional[str] = None, status: Optional[str] = None,
priority: Optional[str] = None, from_time: Optional[str] = None,
to_time: Optional[str] = None, workflow: Optional[str] = None,
form: Optional[str] = None, property_name: Optional[str] = None,
property_value: Optional[str] = None) -> CommandResults:
"""
This function runs when the xm-get-events command is run.
:type client: ``Client``
:param Client: xMatters client to use
:type request_id: ``Optional[str]```
:param request_id: The the request ID associated with the events.
:type status: ``Optional[str]``
:param status:
status of the alert to search for. Options are: 'ACTIVE',
'SUSPENDED', or 'TERMINATED'
:type priority: ``Optional[str]``
:param priority:
Comma-separated list of the priority to search for.
Options are: "LOW", "MEDIUM", "HIGH"
:type from_time: ``Optional[str]``
:param from_time: UTC time for the start of the search.
:type to_time: ``Optional[str]``
:param to_time: UTC time for the end of the search.
:type workflow: ``Optional[str]``
:param workflow: Name of workflow to match the search.
:type form: ``Optional[str]``
:param form: Name of form to match in the search.
:type property_name: ``Optional[str]``
:param property_name: Property name to match with events.
:type property_value: ``Optional[str]``
:param property_value: Property value to match with events.
:return: Events from the search.
:rtype: ``CommandResults``
"""
out = client.search_alerts(
request_id=request_id,
alert_status=status,
priority=priority,
from_time=from_time,
to_time=to_time,
workflow=workflow,
form=form,
property_name=property_name,
property_value=property_value
)
reduced_out: Dict[str, List[Any]]
if len(out) == 0:
reduced_out = {"xMatters.GetEvent.Event": []}
readable_output = "Could not find Events with given criteria in xMatters"
else:
reduced_out = {"xMatters.GetEvents.Events": [event_reduce(event) for event in out]}
readable_output = f'Retrieved Events from xMatters: {reduced_out}'
return CommandResults(
readable_output=readable_output,
outputs=reduced_out,
outputs_prefix='xMatters.GetEvents',
outputs_key_field='event_id'
)
def xm_get_event_command(client: Client, event_id: str) -> CommandResults:
"""
This function is run when the xm-get-event command is run.
:type client: ``Client``
:param Client: xMatters client to use
:type event_id: ``str``
:param event_id: Event ID to search for in xMatters
:return: Output of xm-get-event command
:rtype: ``CommandResults``
"""
out = client.search_alert(event_id=event_id)
reduced_out: Dict[str, Any]
if out.get('code') == 404:
reduced_out = {"xMatters.GetEvent.Event": {}}
readable_output = f'Could not find Event "{event_id}" from xMatters'
else:
reduced = event_reduce(out)
reduced_out = {"xMatters.GetEvent.Event": reduced}
readable_output = f'Retrieved Event "{event_id}" from xMatters:\nEventID: {reduced.get("EventID")}\n' \
f'Created: {reduced.get("Created")}\nTerminated: {reduced.get("Terminated")}\n' \
f'Name: {reduced.get("Name")}\nStatus: {reduced.get("Status")}'
return CommandResults(
readable_output=readable_output,
outputs=reduced_out,
outputs_prefix='xMatters.GetEvent',
outputs_key_field='event_id'
)
def test_module(from_xm: Client, to_xm: Client, user: str, max_fetch: int) -> str:
"""Tests API connectivity and authentication'
Returning 'ok' indicates that the integration works like it is supposed to.
Connection to the service is successful.
Raises exceptions if something goes wrong.
:type from_xm: ``Client``
:param Client: xMatters client to use to pull events from
:type to_xm: ``Client``
:param Client: xMatters client to use to post an event to.
:return: 'ok' if test passed, anything else will fail the test.
:rtype: ``str``
"""
# INTEGRATION DEVELOPER TIP
# Client class should raise the exceptions, but if the test fails
# the exception text is printed to the Cortex XSOAR UI.
# If you have some specific errors you want to capture (i.e. auth failure)
# you should catch the exception here and return a string with a more
# readable output (for example return 'Authentication Error, API Key
# invalid').
# Cortex XSOAR will print everything you return different than 'ok' as
# an error
max_fetch_int = int(max_fetch)
try:
if max_fetch_int <= 0 or max_fetch_int > 200:
raise ValueError
except ValueError:
raise ValueError("Max Fetch must be between 0 and 201")
try:
to_xm.xm_trigger_workflow(
recipients='nobody',
subject='Test - please ignore',
body='Test - please ignore'
)
# return f'RequestId: {res["requestId"]}'
except DemistoException as e:
if 'Forbidden' in str(e):
return 'Authorization Error: Check the URL of an HTTP trigger in a flow'
else:
raise e
try:
from_xm.xm_get_user(user=user)
except DemistoException as e:
if 'Forbidden' in str(e):
return 'Authorization Error: Username and Password fields and verify the user exists'
else:
raise e
return 'ok'
''' MAIN FUNCTION '''
def main() -> None:
"""main function, parses params and runs command functions
:return:
:rtype:
"""
instance = demisto.params().get('instance')
username = demisto.params().get('username')
password = <PASSWORD>('password')
property_name = demisto.params().get('property_name')
property_value = demisto.params().get('property_value')
base_url = demisto.params().get('url')
max_fetch = demisto.params().get('max_fetch', 20)
# if your Client class inherits from BaseClient, SSL verification is
# handled out of the box by it, just pass ``verify_certificate`` to
# the Client constructor
verify_certificate = not demisto.params().get('insecure', False)
# How much time before the first fetch to retrieve incidents
first_fetch_time = arg_to_timestamp(
arg=demisto.params().get('first_fetch', '3 days'),
arg_name='First fetch time',
required=True
)
# Using assert as a type guard (since first_fetch_time is always an int when required=True)
assert isinstance(first_fetch_time, int)
# if your Client class inherits from BaseClient, system proxy is handled
# out of the box by it, just pass ``proxy`` to the Client constructor
proxy = demisto.params().get('proxy', False)
# INTEGRATION DEVELOPER TIP
# You can use functions such as ``demisto.debug()``, ``demisto.info()``,
# etc. to print information in the XSOAR server log. You can set the log
# level on the server configuration
# See: https://xsoar.pan.dev/docs/integrations/code-conventions#logging
demisto.debug(f'Command being called is {demisto.command()}')
try:
to_xm_client = Client(
base_url=base_url,
verify=verify_certificate,
auth=(username, password),
proxy=proxy)
from_xm_client = Client(
base_url="https://" + instance,
verify=verify_certificate,
auth=(username, password),
proxy=proxy)
if demisto.command() == 'xm-trigger-workflow':
return_results(xm_trigger_workflow_command(
to_xm_client,
demisto.args().get('recipients'),
demisto.args().get('subject'),
demisto.args().get('body'),
demisto.args().get('incident_id'),
demisto.args().get('close_task_id')
))
elif demisto.command() == 'fetch-incidents':
# Set and define the fetch incidents command to run after activated via integration settings.
alert_status = demisto.params().get('status', None)
priority = demisto.params().get('priority', None)
next_run, incidents = fetch_incidents(
client=from_xm_client,
last_run=demisto.getLastRun(), # getLastRun() gets the last run dict
first_fetch_time=first_fetch_time,
max_fetch=max_fetch,
alert_status=alert_status,
priority=priority,
property_name=property_name,
property_value=property_value
)
# saves next_run for the time fetch-incidents is invoked
demisto.setLastRun(next_run)
# fetch-incidents calls ``demisto.incidents()`` to provide the list
# of incidents to crate
demisto.incidents(incidents)
elif demisto.command() == 'xm-get-events':
return_results(xm_get_events_command(
client=from_xm_client,
request_id=demisto.args().get('request_id'),
status=demisto.args().get('status'),
priority=demisto.args().get('priority'),
from_time=demisto.args().get('from'),
to_time=demisto.args().get('to'),
workflow=demisto.args().get('workflow'),
form=demisto.args().get('form'),
property_name=demisto.args().get('property_name'),
property_value=demisto.args().get('property_value')
))
elif demisto.command() == 'xm-get-event':
return_results(xm_get_event_command(
client=from_xm_client,
event_id=demisto.args().get('event_id')
))
elif demisto.command() == 'test-module':
return_results(test_module(
from_xm=from_xm_client,
to_xm=to_xm_client,
user=username,
max_fetch=max_fetch
))
# Log exceptions and return errors
except Exception as e:
demisto.error(traceback.format_exc()) # print the traceback
return_error(f'Failed to execute {demisto.command()} command.\nError:\n{str(e)}')
''' ENTRY POINT '''
if __name__ in ('__main__', '__builtin__', 'builtins'):
main()
| 12,157 |
309 | <filename>examples/django_nyc_demo/noodles/views.py
import time
from django.shortcuts import render
from hendrix.experience import crosstown_traffic, hey_joe
def my_noodles(request):
llama = "Another noodle"
@crosstown_traffic()
def my_long_thing():
for i in range(5):
print("another noodle on the python console")
time.sleep(1)
hey_joe.send(llama, topic="noodly_messages")
hey_joe.broadcast("Notice to everybody: finished noodling.")
if request.META.get("wsgi.url_scheme") == "https":
websocket_prefix = "wss"
websocket_port = 9443
else:
websocket_prefix = "ws"
websocket_port = 9000
return render(request, 'noodles.html', {"websocket_prefix": websocket_prefix,
"websocket_port": websocket_port})
| 389 |
Subsets and Splits