max_stars_count
int64 301
224k
| text
stringlengths 6
1.05M
| token_count
int64 3
727k
|
|---|---|---|
2,150 | <gh_stars>1000+
# Copyright (c) Facebook, Inc. and its affiliates.
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
from yacs.config import CfgNode as CN
from pyrobot.cfg.config import get_cfg_defaults
_C = get_cfg_defaults()
# whether the robot has an arm or not
_C.HAS_ARM = True
# whether the robot has a mobile base or not
_C.HAS_BASE = True
# whether the robot has a camera or not
_C.HAS_CAMERA = True
# whether the robot has a gripper or not
_C.HAS_GRIPPER = True
# whether the robot has a common shared class among all components
_C.HAS_COMMON = True
# Camera specific setting
_CAMERAC = _C.CAMERA
# CAMERA class name
_CAMERAC.CLASS = "LoCoBotCamera"
# Base specific settings
_BASEC = _C.BASE
# BASE class name
_BASEC.CLASS = "LoCoBotBase"
# Arm specific settings
_ARMC = _C.ARM
# Arm class name
_ARMC.CLASS = "LoCoBotArm"
# Gripper specific settings
_GRIPPERC = _C.GRIPPER
# Arm class name
_GRIPPERC.CLASS = "LoCoBotGripper"
_COMMONC = _C.COMMON
# Name of the common class variable that will be shared in Robot class
_COMMONC.NAME = "simulator"
# Class type to assign to 'simulator' variable
_COMMONC.CLASS = "VrepSim"
_C.COMMON.SIMULATOR = CN()
# Contains all of the simulator config
_SIMULATORC = _C.COMMON.SIMULATOR
def get_cfg():
return _C.clone()
| 476 |
7,451 | from ..objecttype import ObjectType
from ..schema import Schema
from ..uuid import UUID
class Query(ObjectType):
uuid = UUID(input=UUID())
def resolve_uuid(self, info, input):
return input
schema = Schema(query=Query)
def test_uuidstring_query():
uuid_value = "dfeb3bcf-70fd-11e7-a61a-6003088f8204"
result = schema.execute("""{ uuid(input: "%s") }""" % uuid_value)
assert not result.errors
assert result.data == {"uuid": uuid_value}
def test_uuidstring_query_variable():
uuid_value = "dfeb3bcf-70fd-11e7-a61a-6003088f8204"
result = schema.execute(
"""query Test($uuid: UUID){ uuid(input: $uuid) }""",
variables={"uuid": uuid_value},
)
assert not result.errors
assert result.data == {"uuid": uuid_value}
| 323 |
2,782 | <reponame>mendskyz/Android
package course.examples.contentproviders.stringcontentprovider;
class DataRecord {
private static int id;
// Unique ID
private final int _id;
// Display Name
private final String _data;
DataRecord(String _data) {
this._data = _data;
this._id = id++;
}
String getData() {
return _data;
}
int getID() {
return _id;
}
}
| 136 |
7,892 | <gh_stars>1000+
/*
Copyright 2012-2016 <NAME> <http://drobilla.net>
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
#include <assert.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "lv2/atom/forge.h"
#include "lv2/atom/util.h"
#include "lv2/midi/midi.h"
#include "sratom/sratom.h"
#define NS_RDF (const uint8_t*)"http://www.w3.org/1999/02/22-rdf-syntax-ns#"
#define NS_XSD (const uint8_t*)"http://www.w3.org/2001/XMLSchema#"
#define USTR(str) ((const uint8_t*)(str))
static const SerdStyle style = (SerdStyle)(
SERD_STYLE_ABBREVIATED|SERD_STYLE_RESOLVED|SERD_STYLE_CURIED);
typedef enum {
MODE_SUBJECT,
MODE_BODY,
MODE_SEQUENCE
} ReadMode;
struct SratomImpl {
LV2_URID_Map* map;
LV2_Atom_Forge forge;
SerdEnv* env;
SerdNode base_uri;
SerdURI base;
SerdStatementSink write_statement;
SerdEndSink end_anon;
void* handle;
LV2_URID atom_Event;
LV2_URID atom_frameTime;
LV2_URID atom_beatTime;
LV2_URID midi_MidiEvent;
unsigned next_id;
SratomObjectMode object_mode;
uint32_t seq_unit;
struct {
SordNode* atom_childType;
SordNode* atom_frameTime;
SordNode* atom_beatTime;
SordNode* rdf_first;
SordNode* rdf_rest;
SordNode* rdf_type;
SordNode* rdf_value;
SordNode* xsd_base64Binary;
} nodes;
bool pretty_numbers;
};
static void
read_node(Sratom* sratom,
LV2_Atom_Forge* forge,
SordWorld* world,
SordModel* model,
const SordNode* node,
ReadMode mode);
Sratom*
sratom_new(LV2_URID_Map* map)
{
Sratom* sratom = (Sratom*)calloc(1, sizeof(Sratom));
if (sratom) {
sratom->map = map;
sratom->atom_Event = map->map(map->handle, LV2_ATOM__Event);
sratom->atom_frameTime = map->map(map->handle, LV2_ATOM__frameTime);
sratom->atom_beatTime = map->map(map->handle, LV2_ATOM__beatTime);
sratom->midi_MidiEvent = map->map(map->handle, LV2_MIDI__MidiEvent);
sratom->object_mode = SRATOM_OBJECT_MODE_BLANK;
lv2_atom_forge_init(&sratom->forge, map);
}
return sratom;
}
void
sratom_free(Sratom* sratom)
{
if (sratom) {
serd_node_free(&sratom->base_uri);
free(sratom);
}
}
void
sratom_set_env(Sratom* sratom, SerdEnv* env)
{
sratom->env = env;
}
void
sratom_set_sink(Sratom* sratom,
const char* base_uri,
SerdStatementSink sink,
SerdEndSink end_sink,
void* handle)
{
if (base_uri) {
serd_node_free(&sratom->base_uri);
sratom->base_uri = serd_node_new_uri_from_string(
USTR(base_uri), NULL, NULL);
serd_uri_parse(sratom->base_uri.buf, &sratom->base);
}
sratom->write_statement = sink;
sratom->end_anon = end_sink;
sratom->handle = handle;
}
void
sratom_set_pretty_numbers(Sratom* sratom,
bool pretty_numbers)
{
sratom->pretty_numbers = pretty_numbers;
}
void
sratom_set_object_mode(Sratom* sratom,
SratomObjectMode object_mode)
{
sratom->object_mode = object_mode;
}
static void
gensym(SerdNode* out, char c, unsigned num)
{
out->n_bytes = out->n_chars = snprintf(
(char*)out->buf, 10, "%c%u", c, num);
}
static void
list_append(Sratom* sratom,
LV2_URID_Unmap* unmap,
unsigned* flags,
SerdNode* s,
SerdNode* p,
SerdNode* node,
uint32_t size,
uint32_t type,
const void* body)
{
// Generate a list node
gensym(node, 'l', sratom->next_id);
sratom->write_statement(sratom->handle, *flags, NULL,
s, p, node, NULL, NULL);
// _:node rdf:first value
*flags = SERD_LIST_CONT;
*p = serd_node_from_string(SERD_URI, NS_RDF "first");
sratom_write(sratom, unmap, *flags, node, p, type, size, body);
// Set subject to node and predicate to rdf:rest for next time
gensym(node, 'l', ++sratom->next_id);
*s = *node;
*p = serd_node_from_string(SERD_URI, NS_RDF "rest");
}
static void
list_end(SerdStatementSink sink,
void* handle,
const unsigned flags,
SerdNode* s,
SerdNode* p)
{
// _:node rdf:rest rdf:nil
const SerdNode nil = serd_node_from_string(SERD_URI, NS_RDF "nil");
sink(handle, flags, NULL, s, p, &nil, NULL, NULL);
}
static void
start_object(Sratom* sratom,
uint32_t* flags,
const SerdNode* subject,
const SerdNode* predicate,
const SerdNode* node,
const char* type)
{
if (subject && predicate) {
sratom->write_statement(sratom->handle, *flags|SERD_ANON_O_BEGIN, NULL,
subject, predicate, node, NULL, NULL);
// Start abbreviating object properties
*flags |= SERD_ANON_CONT;
// Object is in a list, stop list abbreviating if necessary
*flags &= ~SERD_LIST_CONT;
}
if (type) {
SerdNode p = serd_node_from_string(SERD_URI, NS_RDF "type");
SerdNode o = serd_node_from_string(SERD_URI, USTR(type));
sratom->write_statement(sratom->handle, *flags, NULL,
node, &p, &o, NULL, NULL);
}
}
static bool
path_is_absolute(const char* path)
{
return (path[0] == '/'
|| (isalpha(path[0]) && path[1] == ':'
&& (path[2] == '/' || path[2] == '\\')));
}
static SerdNode
number_type(const Sratom* sratom, const uint8_t* type)
{
if (sratom->pretty_numbers &&
(!strcmp((const char*)type, (const char*)NS_XSD "int") ||
!strcmp((const char*)type, (const char*)NS_XSD "long"))) {
return serd_node_from_string(SERD_URI, NS_XSD "integer");
} else if (sratom->pretty_numbers &&
(!strcmp((const char*)type, (const char*)NS_XSD "float") ||
!strcmp((const char*)type, (const char*)NS_XSD "double"))) {
return serd_node_from_string(SERD_URI, NS_XSD "decimal");
} else {
return serd_node_from_string(SERD_URI, type);
}
}
int
sratom_write(Sratom* sratom,
LV2_URID_Unmap* unmap,
uint32_t flags,
const SerdNode* subject,
const SerdNode* predicate,
uint32_t type_urid,
uint32_t size,
const void* body)
{
const char* const type = unmap->unmap(unmap->handle, type_urid);
uint8_t idbuf[12] = "b0000000000";
SerdNode id = serd_node_from_string(SERD_BLANK, idbuf);
uint8_t nodebuf[12] = "b0000000000";
SerdNode node = serd_node_from_string(SERD_BLANK, nodebuf);
SerdNode object = SERD_NODE_NULL;
SerdNode datatype = SERD_NODE_NULL;
SerdNode language = SERD_NODE_NULL;
bool new_node = false;
if (type_urid == 0 && size == 0) {
object = serd_node_from_string(SERD_URI, USTR(NS_RDF "nil"));
} else if (type_urid == sratom->forge.String) {
object = serd_node_from_string(SERD_LITERAL, (const uint8_t*)body);
} else if (type_urid == sratom->forge.Chunk) {
datatype = serd_node_from_string(SERD_URI, NS_XSD "base64Binary");
object = serd_node_new_blob(body, size, true);
new_node = true;
} else if (type_urid == sratom->forge.Literal) {
const LV2_Atom_Literal_Body* lit = (const LV2_Atom_Literal_Body*)body;
const uint8_t* str = USTR(lit + 1);
object = serd_node_from_string(SERD_LITERAL, str);
if (lit->datatype) {
datatype = serd_node_from_string(
SERD_URI, USTR(unmap->unmap(unmap->handle, lit->datatype)));
} else if (lit->lang) {
const char* lang = unmap->unmap(unmap->handle, lit->lang);
const char* prefix = "http://lexvo.org/id/iso639-3/";
const size_t prefix_len = strlen(prefix);
if (lang && !strncmp(lang, prefix, prefix_len)) {
language = serd_node_from_string(
SERD_LITERAL, USTR(lang + prefix_len));
} else {
fprintf(stderr, "Unknown language URID %d\n", lit->lang);
}
}
} else if (type_urid == sratom->forge.URID) {
const uint32_t urid = *(const uint32_t*)body;
const uint8_t* str = USTR(unmap->unmap(unmap->handle, urid));
object = serd_node_from_string(SERD_URI, str);
} else if (type_urid == sratom->forge.Path) {
const uint8_t* str = USTR(body);
if (path_is_absolute((const char*)str)) {
new_node = true;
object = serd_node_new_file_uri(str, NULL, NULL, true);
} else {
if (!sratom->base_uri.buf ||
strncmp((const char*)sratom->base_uri.buf, "file://", 7)) {
fprintf(stderr, "warning: Relative path but base is not a file URI.\n");
fprintf(stderr, "warning: Writing ambiguous atom:Path literal.\n");
object = serd_node_from_string(SERD_LITERAL, str);
datatype = serd_node_from_string(SERD_URI, USTR(LV2_ATOM__Path));
} else {
new_node = true;
SerdNode rel = serd_node_new_file_uri(str, NULL, NULL, true);
object = serd_node_new_uri_from_node(&rel, &sratom->base, NULL);
serd_node_free(&rel);
}
}
} else if (type_urid == sratom->forge.URI) {
const uint8_t* str = USTR(body);
object = serd_node_from_string(SERD_URI, str);
} else if (type_urid == sratom->forge.Int) {
new_node = true;
object = serd_node_new_integer(*(const int32_t*)body);
datatype = number_type(sratom, NS_XSD "int");
} else if (type_urid == sratom->forge.Long) {
new_node = true;
object = serd_node_new_integer(*(const int64_t*)body);
datatype = number_type(sratom, NS_XSD "long");
} else if (type_urid == sratom->forge.Float) {
new_node = true;
object = serd_node_new_decimal(*(const float*)body, 8);
datatype = number_type(sratom, NS_XSD "float");
} else if (type_urid == sratom->forge.Double) {
new_node = true;
object = serd_node_new_decimal(*(const double*)body, 16);
datatype = number_type(sratom, NS_XSD "double");
} else if (type_urid == sratom->forge.Bool) {
const int32_t val = *(const int32_t*)body;
datatype = serd_node_from_string(SERD_URI, NS_XSD "boolean");
object = serd_node_from_string(SERD_LITERAL,
USTR(val ? "true" : "false"));
} else if (type_urid == sratom->midi_MidiEvent) {
new_node = true;
datatype = serd_node_from_string(SERD_URI, USTR(LV2_MIDI__MidiEvent));
uint8_t* str = (uint8_t*)calloc(size * 2 + 1, 1);
for (uint32_t i = 0; i < size; ++i) {
snprintf((char*)str + (2 * i), size * 2 + 1, "%02X",
(unsigned)*((const uint8_t*)body + i));
}
object = serd_node_from_string(SERD_LITERAL, USTR(str));
} else if (type_urid == sratom->atom_Event) {
const LV2_Atom_Event* ev = (const LV2_Atom_Event*)body;
gensym(&id, 'e', sratom->next_id++);
start_object(sratom, &flags, subject, predicate, &id, NULL);
SerdNode time;
SerdNode p;
if (sratom->seq_unit == sratom->atom_beatTime) {
time = serd_node_new_decimal(ev->time.beats, 16);
p = serd_node_from_string(SERD_URI, USTR(LV2_ATOM__beatTime));
datatype = number_type(sratom, NS_XSD "double");
} else {
time = serd_node_new_integer(ev->time.frames);
p = serd_node_from_string(SERD_URI, USTR(LV2_ATOM__frameTime));
datatype = number_type(sratom, NS_XSD "long");
}
sratom->write_statement(sratom->handle, SERD_ANON_CONT, NULL,
&id, &p, &time, &datatype, &language);
serd_node_free(&time);
p = serd_node_from_string(SERD_URI, NS_RDF "value");
sratom_write(sratom, unmap, SERD_ANON_CONT, &id, &p,
ev->body.type, ev->body.size, LV2_ATOM_BODY(&ev->body));
if (sratom->end_anon) {
sratom->end_anon(sratom->handle, &id);
}
} else if (type_urid == sratom->forge.Tuple) {
gensym(&id, 't', sratom->next_id++);
start_object(sratom, &flags, subject, predicate, &id, type);
SerdNode p = serd_node_from_string(SERD_URI, NS_RDF "value");
flags |= SERD_LIST_O_BEGIN;
LV2_ATOM_TUPLE_BODY_FOREACH(body, size, i) {
list_append(sratom, unmap, &flags, &id, &p, &node,
i->size, i->type, LV2_ATOM_BODY(i));
}
list_end(sratom->write_statement, sratom->handle, flags, &id, &p);
if (sratom->end_anon) {
sratom->end_anon(sratom->handle, &id);
}
} else if (type_urid == sratom->forge.Vector) {
const LV2_Atom_Vector_Body* vec = (const LV2_Atom_Vector_Body*)body;
gensym(&id, 'v', sratom->next_id++);
start_object(sratom, &flags, subject, predicate, &id, type);
SerdNode p = serd_node_from_string(SERD_URI, (const uint8_t*)LV2_ATOM__childType);
SerdNode child_type = serd_node_from_string(
SERD_URI, (const uint8_t*)unmap->unmap(unmap->handle, vec->child_type));
sratom->write_statement(sratom->handle, flags, NULL, &id, &p, &child_type, NULL, NULL);
p = serd_node_from_string(SERD_URI, NS_RDF "value");
flags |= SERD_LIST_O_BEGIN;
for (const char* i = (const char*)(vec + 1);
i < (const char*)vec + size;
i += vec->child_size) {
list_append(sratom, unmap, &flags, &id, &p, &node,
vec->child_size, vec->child_type, i);
}
list_end(sratom->write_statement, sratom->handle, flags, &id, &p);
if (sratom->end_anon) {
sratom->end_anon(sratom->handle, &id);
}
} else if (lv2_atom_forge_is_object_type(&sratom->forge, type_urid)) {
const LV2_Atom_Object_Body* obj = (const LV2_Atom_Object_Body*)body;
const char* otype = unmap->unmap(unmap->handle,
obj->otype);
if (lv2_atom_forge_is_blank(&sratom->forge, type_urid, obj)) {
gensym(&id, 'b', sratom->next_id++);
start_object(sratom, &flags, subject, predicate, &id, otype);
} else {
id = serd_node_from_string(
SERD_URI, (const uint8_t*)unmap->unmap(unmap->handle, obj->id));
flags = 0;
start_object(sratom, &flags, NULL, NULL, &id, otype);
}
LV2_ATOM_OBJECT_BODY_FOREACH(obj, size, prop) {
const char* const key = unmap->unmap(unmap->handle, prop->key);
SerdNode pred = serd_node_from_string(SERD_URI, USTR(key));
sratom_write(sratom, unmap, flags, &id, &pred,
prop->value.type, prop->value.size,
LV2_ATOM_BODY(&prop->value));
}
if (sratom->end_anon && (flags & SERD_ANON_CONT)) {
sratom->end_anon(sratom->handle, &id);
}
} else if (type_urid == sratom->forge.Sequence) {
const LV2_Atom_Sequence_Body* seq = (const LV2_Atom_Sequence_Body*)body;
gensym(&id, 'v', sratom->next_id++);
start_object(sratom, &flags, subject, predicate, &id, type);
SerdNode p = serd_node_from_string(SERD_URI, NS_RDF "value");
flags |= SERD_LIST_O_BEGIN;
LV2_ATOM_SEQUENCE_BODY_FOREACH(seq, size, ev) {
sratom->seq_unit = seq->unit;
list_append(sratom, unmap, &flags, &id, &p, &node,
sizeof(LV2_Atom_Event) + ev->body.size,
sratom->atom_Event,
ev);
}
list_end(sratom->write_statement, sratom->handle, flags, &id, &p);
if (sratom->end_anon && subject && predicate) {
sratom->end_anon(sratom->handle, &id);
}
} else {
gensym(&id, 'b', sratom->next_id++);
start_object(sratom, &flags, subject, predicate, &id, type);
SerdNode p = serd_node_from_string(SERD_URI, NS_RDF "value");
SerdNode o = serd_node_new_blob(body, size, true);
datatype = serd_node_from_string(SERD_URI, NS_XSD "base64Binary");
sratom->write_statement(sratom->handle, flags, NULL, &id, &p, &o, &datatype, NULL);
if (sratom->end_anon && subject && predicate) {
sratom->end_anon(sratom->handle, &id);
}
serd_node_free(&o);
}
if (object.buf) {
SerdNode def_s = serd_node_from_string(SERD_BLANK, USTR("atom"));
SerdNode def_p = serd_node_from_string(SERD_URI, USTR(NS_RDF "value"));
if (!subject) {
subject = &def_s;
}
if (!predicate) {
predicate = &def_p;
}
sratom->write_statement(sratom->handle, flags, NULL,
subject, predicate, &object, &datatype, &language);
}
if (new_node) {
serd_node_free(&object);
}
return 0;
}
char*
sratom_to_turtle(Sratom* sratom,
LV2_URID_Unmap* unmap,
const char* base_uri,
const SerdNode* subject,
const SerdNode* predicate,
uint32_t type,
uint32_t size,
const void* body)
{
SerdURI buri = SERD_URI_NULL;
SerdNode base = serd_node_new_uri_from_string(USTR(base_uri), &sratom->base, &buri);
SerdEnv* env = sratom->env ? sratom->env : serd_env_new(NULL);
SerdChunk str = { NULL, 0 };
SerdWriter* writer = serd_writer_new(
SERD_TURTLE, style, env, &buri, serd_chunk_sink, &str);
serd_env_set_base_uri(env, &base);
sratom_set_sink(sratom, base_uri,
(SerdStatementSink)serd_writer_write_statement,
(SerdEndSink)serd_writer_end_anon,
writer);
sratom_write(sratom, unmap, SERD_EMPTY_S,
subject, predicate, type, size, body);
serd_writer_finish(writer);
serd_writer_free(writer);
if (!sratom->env) {
serd_env_free(env);
}
serd_node_free(&base);
return (char*)serd_chunk_sink_finish(&str);
}
static void
read_list_value(Sratom* sratom,
LV2_Atom_Forge* forge,
SordWorld* world,
SordModel* model,
const SordNode* node,
ReadMode mode)
{
SordNode* fst = sord_get(model, node, sratom->nodes.rdf_first, NULL, NULL);
SordNode* rst = sord_get(model, node, sratom->nodes.rdf_rest, NULL, NULL);
if (fst && rst) {
read_node(sratom, forge, world, model, fst, mode);
read_list_value(sratom, forge, world, model, rst, mode);
}
sord_node_free(world, rst);
sord_node_free(world, fst);
}
static void
read_resource(Sratom* sratom,
LV2_Atom_Forge* forge,
SordWorld* world,
SordModel* model,
const SordNode* node,
LV2_URID otype)
{
LV2_URID_Map* map = sratom->map;
SordQuad q = { node, NULL, NULL, NULL };
SordIter* i = sord_find(model, q);
SordQuad match;
for (; !sord_iter_end(i); sord_iter_next(i)) {
sord_iter_get(i, match);
const SordNode* p = match[SORD_PREDICATE];
const SordNode* o = match[SORD_OBJECT];
const char* p_uri = (const char*)sord_node_get_string(p);
uint32_t p_urid = map->map(map->handle, p_uri);
if (!(sord_node_equals(p, sratom->nodes.rdf_type) &&
sord_node_get_type(o) == SORD_URI &&
map->map(map->handle, (const char*)sord_node_get_string(o)) == otype)) {
lv2_atom_forge_key(forge, p_urid);
read_node(sratom, forge, world, model, o, MODE_BODY);
}
}
sord_iter_free(i);
}
static uint32_t
atom_size(Sratom* sratom, uint32_t type_urid)
{
if (type_urid == sratom->forge.Int) {
return sizeof(int32_t);
} else if (type_urid == sratom->forge.Long) {
return sizeof(int64_t);
} else if (type_urid == sratom->forge.Float) {
return sizeof(float);
} else if (type_urid == sratom->forge.Double) {
return sizeof(double);
} else if (type_urid == sratom->forge.Bool) {
return sizeof(int32_t);
} else if (type_urid == sratom->forge.URID) {
return sizeof(uint32_t);
}
return 0;
}
static void
read_literal(Sratom* sratom, LV2_Atom_Forge* forge, const SordNode* node)
{
assert(sord_node_get_type(node) == SORD_LITERAL);
size_t len = 0;
const char* str = (const char*)sord_node_get_string_counted(node, &len);
SordNode* datatype = sord_node_get_datatype(node);
const char* language = sord_node_get_language(node);
if (datatype) {
const char* type_uri = (const char*)sord_node_get_string(datatype);
if (!strcmp(type_uri, (const char*)NS_XSD "int") ||
!strcmp(type_uri, (const char*)NS_XSD "integer")) {
lv2_atom_forge_int(forge, strtol(str, NULL, 10));
} else if (!strcmp(type_uri, (const char*)NS_XSD "long")) {
lv2_atom_forge_long(forge, strtol(str, NULL, 10));
} else if (!strcmp(type_uri, (const char*)NS_XSD "float") ||
!strcmp(type_uri, (const char*)NS_XSD "decimal")) {
lv2_atom_forge_float(forge, serd_strtod(str, NULL));
} else if (!strcmp(type_uri, (const char*)NS_XSD "double")) {
lv2_atom_forge_double(forge, serd_strtod(str, NULL));
} else if (!strcmp(type_uri, (const char*)NS_XSD "boolean")) {
lv2_atom_forge_bool(forge, !strcmp(str, "true"));
} else if (!strcmp(type_uri, (const char*)NS_XSD "base64Binary")) {
size_t size = 0;
void* body = serd_base64_decode(USTR(str), len, &size);
lv2_atom_forge_atom(forge, size, forge->Chunk);
lv2_atom_forge_write(forge, body, size);
free(body);
} else if (!strcmp(type_uri, LV2_ATOM__Path)) {
lv2_atom_forge_path(forge, str, len);
} else if (!strcmp(type_uri, LV2_MIDI__MidiEvent)) {
lv2_atom_forge_atom(forge, len / 2, sratom->midi_MidiEvent);
for (const char* s = str; s < str + len; s += 2) {
unsigned num;
sscanf(s, "%2X", &num);
const uint8_t c = num;
lv2_atom_forge_raw(forge, &c, 1);
}
lv2_atom_forge_pad(forge, len / 2);
} else {
lv2_atom_forge_literal(
forge, str, len,
sratom->map->map(sratom->map->handle, type_uri),
0);
}
} else if (language) {
const char* prefix = "http://lexvo.org/id/iso639-3/";
const size_t lang_len = strlen(prefix) + strlen(language);
char* lang_uri = (char*)calloc(lang_len + 1, 1);
snprintf(lang_uri, lang_len + 1, "%s%s", prefix, language);
lv2_atom_forge_literal(
forge, str, len, 0,
sratom->map->map(sratom->map->handle, lang_uri));
free(lang_uri);
} else {
lv2_atom_forge_string(forge, str, len);
}
}
static void
read_object(Sratom* sratom,
LV2_Atom_Forge* forge,
SordWorld* world,
SordModel* model,
const SordNode* node,
ReadMode mode)
{
LV2_URID_Map* map = sratom->map;
size_t len = 0;
const char* str = (const char*)sord_node_get_string_counted(node, &len);
SordNode* type = sord_get(
model, node, sratom->nodes.rdf_type, NULL, NULL);
SordNode* value = sord_get(
model, node, sratom->nodes.rdf_value, NULL, NULL);
const uint8_t* type_uri = NULL;
uint32_t type_urid = 0;
if (type) {
type_uri = sord_node_get_string(type);
type_urid = map->map(map->handle, (const char*)type_uri);
}
LV2_Atom_Forge_Frame frame = { 0, 0 };
if (mode == MODE_SEQUENCE) {
SordNode* time = sord_get(
model, node, sratom->nodes.atom_beatTime, NULL, NULL);
uint32_t seq_unit;
if (time) {
const char* time_str = (const char*)sord_node_get_string(time);
lv2_atom_forge_beat_time(forge, serd_strtod(time_str, NULL));
seq_unit = sratom->atom_beatTime;
} else {
time = sord_get(model, node, sratom->nodes.atom_frameTime, NULL, NULL);
const char* time_str = time
? (const char*)sord_node_get_string(time)
: "";
lv2_atom_forge_frame_time(forge, serd_strtod(time_str, NULL));
seq_unit = sratom->atom_frameTime;
}
read_node(sratom, forge, world, model, value, MODE_BODY);
sord_node_free(world, time);
sratom->seq_unit = seq_unit;
} else if (type_urid == sratom->forge.Tuple) {
lv2_atom_forge_tuple(forge, &frame);
read_list_value(sratom, forge, world, model, value, MODE_BODY);
} else if (type_urid == sratom->forge.Sequence) {
const LV2_Atom_Forge_Ref ref = lv2_atom_forge_sequence_head(forge, &frame, 0);
sratom->seq_unit = 0;
read_list_value(sratom, forge, world, model, value, MODE_SEQUENCE);
LV2_Atom_Sequence* seq = (LV2_Atom_Sequence*)lv2_atom_forge_deref(forge, ref);
seq->body.unit = (sratom->seq_unit == sratom->atom_frameTime) ? 0 : sratom->seq_unit;
} else if (type_urid == sratom->forge.Vector) {
SordNode* child_type_node = sord_get(
model, node, sratom->nodes.atom_childType, NULL, NULL);
uint32_t child_type = map->map(
map->handle, (const char*)sord_node_get_string(child_type_node));
uint32_t child_size = atom_size(sratom, child_type);
if (child_size > 0) {
LV2_Atom_Forge_Ref ref = lv2_atom_forge_vector_head(
forge, &frame, child_size, child_type);
read_list_value(sratom, forge, world, model, value, MODE_BODY);
lv2_atom_forge_pop(forge, &frame);
frame.ref = 0;
lv2_atom_forge_pad(forge, lv2_atom_forge_deref(forge, ref)->size);
}
sord_node_free(world, child_type_node);
} else if (value && sord_node_equals(sord_node_get_datatype(value),
sratom->nodes.xsd_base64Binary)) {
size_t vlen = 0;
const uint8_t* vstr = sord_node_get_string_counted(value, &vlen);
size_t size = 0;
void* body = serd_base64_decode(vstr, vlen, &size);
lv2_atom_forge_atom(forge, size, type_urid);
lv2_atom_forge_write(forge, body, size);
free(body);
} else if (sord_node_get_type(node) == SORD_URI) {
lv2_atom_forge_object(
forge, &frame, map->map(map->handle, str), type_urid);
read_resource(sratom, forge, world, model, node, type_urid);
} else {
lv2_atom_forge_object(forge, &frame, 0, type_urid);
read_resource(sratom, forge, world, model, node, type_urid);
}
if (frame.ref) {
lv2_atom_forge_pop(forge, &frame);
}
sord_node_free(world, value);
sord_node_free(world, type);
}
static void
read_node(Sratom* sratom,
LV2_Atom_Forge* forge,
SordWorld* world,
SordModel* model,
const SordNode* node,
ReadMode mode)
{
LV2_URID_Map* map = sratom->map;
size_t len = 0;
const char* str = (const char*)sord_node_get_string_counted(node, &len);
if (sord_node_get_type(node) == SORD_LITERAL) {
read_literal(sratom, forge, node);
} else if (sord_node_get_type(node) == SORD_URI &&
!(sratom->object_mode == SRATOM_OBJECT_MODE_BLANK_SUBJECT
&& mode == MODE_SUBJECT)) {
if (!strcmp(str, (const char*)NS_RDF "nil")) {
lv2_atom_forge_atom(forge, 0, 0);
} else if (!strncmp(str, "file://", 7)) {
SerdURI uri;
serd_uri_parse((const uint8_t*)str, &uri);
SerdNode rel = serd_node_new_relative_uri(&uri, &sratom->base, NULL, NULL);
uint8_t* path = serd_file_uri_parse(rel.buf, NULL);
lv2_atom_forge_path(forge, (const char*)path, strlen((const char*)path));
serd_free(path);
serd_node_free(&rel);
} else {
lv2_atom_forge_urid(forge, map->map(map->handle, str));
}
} else {
read_object(sratom, forge, world, model, node, mode);
}
}
void
sratom_read(Sratom* sratom,
LV2_Atom_Forge* forge,
SordWorld* world,
SordModel* model,
const SordNode* node)
{
sratom->nodes.atom_childType = sord_new_uri(world, USTR(LV2_ATOM__childType));
sratom->nodes.atom_frameTime = sord_new_uri(world, USTR(LV2_ATOM__frameTime));
sratom->nodes.atom_beatTime = sord_new_uri(world, USTR(LV2_ATOM__beatTime));
sratom->nodes.rdf_first = sord_new_uri(world, NS_RDF "first");
sratom->nodes.rdf_rest = sord_new_uri(world, NS_RDF "rest");
sratom->nodes.rdf_type = sord_new_uri(world, NS_RDF "type");
sratom->nodes.rdf_value = sord_new_uri(world, NS_RDF "value");
sratom->nodes.xsd_base64Binary = sord_new_uri(world, NS_XSD "base64Binary");
sratom->next_id = 1;
read_node(sratom, forge, world, model, node, MODE_SUBJECT);
sord_node_free(world, sratom->nodes.xsd_base64Binary);
sord_node_free(world, sratom->nodes.rdf_value);
sord_node_free(world, sratom->nodes.rdf_type);
sord_node_free(world, sratom->nodes.rdf_rest);
sord_node_free(world, sratom->nodes.rdf_first);
sord_node_free(world, sratom->nodes.atom_frameTime);
sord_node_free(world, sratom->nodes.atom_beatTime);
sord_node_free(world, sratom->nodes.atom_childType);
memset(&sratom->nodes, 0, sizeof(sratom->nodes));
}
LV2_Atom_Forge_Ref
sratom_forge_sink(LV2_Atom_Forge_Sink_Handle handle,
const void* buf,
uint32_t size)
{
SerdChunk* chunk = (SerdChunk*)handle;
const LV2_Atom_Forge_Ref ref = chunk->len + 1;
serd_chunk_sink(buf, size, chunk);
return ref;
}
LV2_Atom*
sratom_forge_deref(LV2_Atom_Forge_Sink_Handle handle, LV2_Atom_Forge_Ref ref)
{
SerdChunk* chunk = (SerdChunk*)handle;
return (LV2_Atom*)(chunk->buf + ref - 1);
}
LV2_Atom*
sratom_from_turtle(Sratom* sratom,
const char* base_uri,
const SerdNode* subject,
const SerdNode* predicate,
const char* str)
{
SerdChunk out = { NULL, 0 };
SerdNode base = serd_node_new_uri_from_string(USTR(base_uri), &sratom->base, NULL);
SordWorld* world = sord_world_new();
SordModel* model = sord_new(world, SORD_SPO, false);
SerdEnv* env = sratom->env ? sratom->env : serd_env_new(&base);
SerdReader* reader = sord_new_reader(model, env, SERD_TURTLE, NULL);
if (!serd_reader_read_string(reader, (const uint8_t*)str)) {
SordNode* s = sord_node_from_serd_node(world, env, subject, 0, 0);
lv2_atom_forge_set_sink(
&sratom->forge, sratom_forge_sink, sratom_forge_deref, &out);
if (subject && predicate) {
SordNode* p = sord_node_from_serd_node(world, env, predicate, 0, 0);
SordNode* o = sord_get(model, s, p, NULL, NULL);
if (o) {
sratom_read(sratom, &sratom->forge, world, model, o);
sord_node_free(world, o);
} else {
fprintf(stderr, "Failed to find node\n");
}
} else {
sratom_read(sratom, &sratom->forge, world, model, s);
}
} else {
fprintf(stderr, "Failed to read Turtle\n");
}
serd_reader_free(reader);
if (!sratom->env) {
serd_env_free(env);
}
sord_free(model);
sord_world_free(world);
serd_node_free(&base);
return (LV2_Atom*)out.buf;
}
| 14,505 |
5,169 | <reponame>Gantios/Specs
{
"name": "Kekka",
"version": "0.8.1",
"summary": "Kekka (結果) means Result. This small framework is inspired from Haskell's monadic types.",
"description": "This is a small framework with fundamental types like Result and Future\nwhich are expressed in pure functional way. This work is inspired by \nhaskell implementation of monad and its properties. Everything is based on \nfundamental reasoning.\n\n- Result<T> is a complete Functor and Monad. It is a contextual type over\na computation that can pass or fail.\n\n- Future<T> (analogous to Promise) is a complete Functor and Monad too. It \nabstracts over nested callback and asynchronous API whereby enabling client \nto focus as if the completion is given as soon as it is executed.",
"homepage": "https://github.com/kandelvijaya/Kekka.git",
"license": "MIT",
"authors": {
"kandelvijaya": "<EMAIL>"
},
"social_media_url": "http://twitter.com/kandelvijaya",
"platforms": {
"ios": "9.0"
},
"source": {
"git": "https://github.com/kandelvijaya/Kekka.git",
"tag": "0.8.1"
},
"source_files": "Kekka/Classes/**/*",
"pod_target_xcconfig": {
"SWIFT_VERSION": "4"
}
}
| 412 |
4,403 | package cn.hutool.poi.excel.sax;
import cn.hutool.core.text.StrBuilder;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.poi.excel.cell.FormulaCellValue;
import cn.hutool.poi.excel.sax.handler.RowHandler;
import org.apache.poi.ss.usermodel.BuiltinFormats;
import org.apache.poi.xssf.model.SharedStringsTable;
import org.apache.poi.xssf.model.StylesTable;
import org.apache.poi.xssf.usermodel.XSSFCellStyle;
import org.xml.sax.Attributes;
import org.xml.sax.helpers.DefaultHandler;
import java.util.ArrayList;
import java.util.List;
/**
* sheetData标签内容读取处理器
*
* <pre>
* <sheetData></sheetData>
* </pre>
* @since 5.5.3
*/
public class SheetDataSaxHandler extends DefaultHandler {
// 单元格的格式表，对应style.xml
protected StylesTable stylesTable;
// excel 2007 的共享字符串表,对应sharedString.xml
protected SharedStringsTable sharedStringsTable;
// sheet的索引，从0开始
protected int sheetIndex;
// 当前非空行
protected int index;
// 当前列
private int curCell;
// 单元数据类型
private CellDataType cellDataType;
// 当前行号，从0开始
private long rowNumber;
// 当前列坐标， 如A1，B5
private String curCoordinate;
// 当前节点名称
private ElementName curElementName;
// 前一个列的坐标
private String preCoordinate;
// 行的最大列坐标
private String maxCellCoordinate;
// 单元格样式
private XSSFCellStyle xssfCellStyle;
// 单元格存储的格式化字符串，nmtFmt的formatCode属性的值
private String numFmtString;
// 是否处于sheetData标签内，sax只解析此标签内的内容，其它标签忽略
private boolean isInSheetData;
// 上一次的内容
private final StrBuilder lastContent = StrUtil.strBuilder();
// 上一次的内容
private final StrBuilder lastFormula = StrUtil.strBuilder();
// 存储每行的列元素
private List<Object> rowCellList = new ArrayList<>();
public SheetDataSaxHandler(RowHandler rowHandler){
this.rowHandler = rowHandler;
}
/**
* 行处理器
*/
protected RowHandler rowHandler;
/**
* 设置行处理器
*
* @param rowHandler 行处理器
*/
public void setRowHandler(RowHandler rowHandler) {
this.rowHandler = rowHandler;
}
/**
* 读到一个xml开始标签时的回调处理方法
*/
@Override
public void startElement(String uri, String localName, String qName, Attributes attributes) {
if ("sheetData".equals(qName)) {
this.isInSheetData = true;
return;
}
if (false == this.isInSheetData) {
// 非sheetData标签，忽略解析
return;
}
final ElementName name = ElementName.of(qName);
this.curElementName = name;
if (null != name) {
switch (name) {
case row:
// 行开始
startRow(attributes);
break;
case c:
// 单元格元素
startCell(attributes);
break;
}
}
}
/**
* 标签结束的回调处理方法
*/
@Override
public void endElement(String uri, String localName, String qName) {
if ("sheetData".equals(qName)) {
// sheetData结束，不再解析别的标签
this.isInSheetData = false;
return;
}
if (false == this.isInSheetData) {
// 非sheetData标签，忽略解析
return;
}
this.curElementName = null;
if (ElementName.c.match(qName)) { // 单元格结束
endCell();
} else if (ElementName.row.match(qName)) {// 行结束
endRow();
}
// 其它标签忽略
}
@Override
public void characters(char[] ch, int start, int length) {
if (false == this.isInSheetData) {
// 非sheetData标签，忽略解析
return;
}
final ElementName elementName = this.curElementName;
if (null != elementName) {
switch (elementName) {
case v:
// 得到单元格内容的值
lastContent.append(ch, start, length);
break;
case f:
// 得到单元格内容的值
lastFormula.append(ch, start, length);
break;
}
} else{
// 按理说内容应该为"<v>内容</v>"，但是某些特别的XML内容不在v或f标签中，此处做一些兼容
// issue#1303@Github
lastContent.append(ch, start, length);
}
}
// --------------------------------------------------------------------------------------- Private method start
/**
* 行开始
*
* @param attributes 属性列表
*/
private void startRow(Attributes attributes) {
final String rValue = AttributeName.r.getValue(attributes);
if (null != rValue) {
this.rowNumber = Long.parseLong(rValue) - 1;
}
}
/**
* 单元格开始
*
* @param attributes 属性列表
*/
private void startCell(Attributes attributes) {
// 获取当前列坐标
final String tempCurCoordinate = AttributeName.r.getValue(attributes);
// 前一列为null，则将其设置为"@",A为第一列，ascii码为65，前一列即为@，ascii码64
if (preCoordinate == null) {
preCoordinate = String.valueOf(ExcelSaxUtil.CELL_FILL_CHAR);
} else {
// 存在，则前一列要设置为上一列的坐标
preCoordinate = curCoordinate;
}
// 重置当前列
curCoordinate = tempCurCoordinate;
// 设置单元格类型
setCellType(attributes);
// 清空之前的数据
lastContent.reset();
lastFormula.reset();
}
/**
* 一行结尾
*/
private void endRow() {
// 最大列坐标以第一个非空行的为准
if (index == 0) {
maxCellCoordinate = curCoordinate;
}
// 补全一行尾部可能缺失的单元格
if (maxCellCoordinate != null) {
fillBlankCell(curCoordinate, maxCellCoordinate, true);
}
rowHandler.handle(sheetIndex, rowNumber, rowCellList);
// 一行结束
// 新建一个新列，之前的列抛弃（可能被回收或rowHandler处理）
rowCellList = new ArrayList<>(curCell + 1);
// 行数增加
index++;
// 当前列置0
curCell = 0;
// 置空当前列坐标和前一列坐标
curCoordinate = null;
preCoordinate = null;
}
/**
* 一个单元格结尾
*/
private void endCell() {
// 补全单元格之间的空格
fillBlankCell(preCoordinate, curCoordinate, false);
final String contentStr = StrUtil.trim(lastContent);
Object value = ExcelSaxUtil.getDataValue(this.cellDataType, contentStr, this.sharedStringsTable, this.numFmtString);
if (false == this.lastFormula.isEmpty()) {
value = new FormulaCellValue(StrUtil.trim(lastFormula), value);
}
addCellValue(curCell++, value);
}
/**
* 在一行中的指定列增加值
*
* @param index 位置
* @param value 值
*/
private void addCellValue(int index, Object value) {
this.rowCellList.add(index, value);
this.rowHandler.handleCell(this.sheetIndex, this.rowNumber, index, value, this.xssfCellStyle);
}
/**
* 填充空白单元格，如果前一个单元格大于后一个，不需要填充<br>
*
* @param preCoordinate 前一个单元格坐标
* @param curCoordinate 当前单元格坐标
* @param isEnd 是否为最后一个单元格
*/
private void fillBlankCell(String preCoordinate, String curCoordinate, boolean isEnd) {
if (false == curCoordinate.equals(preCoordinate)) {
int len = ExcelSaxUtil.countNullCell(preCoordinate, curCoordinate);
if (isEnd) {
len++;
}
while (len-- > 0) {
addCellValue(curCell++, StrUtil.EMPTY);
}
}
}
/**
* 设置单元格的类型
*
* @param attributes 属性
*/
private void setCellType(Attributes attributes) {
// numFmtString的值
numFmtString = StrUtil.EMPTY;
this.cellDataType = CellDataType.of(AttributeName.t.getValue(attributes));
// 获取单元格的xf索引，对应style.xml中cellXfs的子元素xf
if (null != this.stylesTable) {
final String xfIndexStr = AttributeName.s.getValue(attributes);
if (null != xfIndexStr) {
this.xssfCellStyle = stylesTable.getStyleAt(Integer.parseInt(xfIndexStr));
// 单元格存储格式的索引，对应style.xml中的numFmts元素的子元素索引
final int numFmtIndex = xssfCellStyle.getDataFormat();
this.numFmtString = ObjectUtil.defaultIfNull(
xssfCellStyle.getDataFormatString(),
BuiltinFormats.getBuiltinFormat(numFmtIndex));
if (CellDataType.NUMBER == this.cellDataType && ExcelSaxUtil.isDateFormat(numFmtIndex, numFmtString)) {
cellDataType = CellDataType.DATE;
}
}
}
}
// --------------------------------------------------------------------------------------- Private method end
}
| 3,873 |
852 | import FWCore.ParameterSet.Config as cms
from DQMOffline.Trigger.DiDispStaMuonMonitor_cfi import hltDiDispStaMuonMonitoring
hltDiDispStaMuonCosmicMonitoring = hltDiDispStaMuonMonitoring.clone()
hltDiDispStaMuonCosmicMonitoring.FolderName = cms.string('HLT/EXO/DiDispStaMuon/DoubleL2Mu23NoVtx_2Cha_CosmicSeed/')
hltDiDispStaMuonCosmicMonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_DoubleL2Mu23NoVtx_2Cha_CosmicSeed_v*") #HLT_ZeroBias_v*
## Efficiency trigger
hltDispStaMuon23Monitoring = hltDiDispStaMuonMonitoring.clone()
hltDispStaMuon23Monitoring.FolderName = cms.string('HLT/EXO/DiDispStaMuon/L2Mu23NoVtx_2Cha/')
hltDispStaMuon23Monitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_L2Mu23NoVtx_2Cha_v*") #HLT_ZeroBias_v*
hltDispStaMuon23CosmicMonitoring = hltDiDispStaMuonMonitoring.clone()
hltDispStaMuon23CosmicMonitoring.FolderName = cms.string('HLT/EXO/DiDispStaMuon/L2Mu23NoVtx_2Cha_CosmicSeed/')
hltDispStaMuon23CosmicMonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_L2Mu23NoVtx_2Cha_CosmicSeed_v*") #HLT_ZeroBias_v*
## Backup trigger
hltDiDispStaMuon25Monitoring = hltDiDispStaMuonMonitoring.clone()
hltDiDispStaMuon25Monitoring.FolderName = cms.string('HLT/EXO/DiDispStaMuon/DoubleL2Mu25NoVtx_2Cha/')
hltDiDispStaMuon25Monitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_DoubleL2Mu25NoVtx_2Cha_v*") #HLT_ZeroBias_v*
hltDiDispStaMuon25CosmicMonitoring = hltDiDispStaMuonMonitoring.clone()
hltDiDispStaMuon25CosmicMonitoring.FolderName = cms.string('HLT/EXO/DiDispStaMuon/DoubleL2Mu25NoVtx_2Cha_CosmicSeed/')
hltDiDispStaMuon25CosmicMonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_DoubleL2Mu25NoVtx_2Cha_CosmicSeed_v*") #HLT_ZeroBias_v*
hltDiDispStaMuon30Monitoring = hltDiDispStaMuonMonitoring.clone()
hltDiDispStaMuon30Monitoring.FolderName = cms.string('HLT/EXO/DiDispStaMuon/DoubleL2Mu30NoVtx_2Cha_Eta2p4/')
hltDiDispStaMuon30Monitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_DoubleL2Mu30NoVtx_2Cha_Eta2p4_v*") #HLT_ZeroBias_v*
hltDiDispStaMuon30CosmicMonitoring = hltDiDispStaMuonMonitoring.clone()
hltDiDispStaMuon30CosmicMonitoring.FolderName = cms.string('HLT/EXO/DiDispStaMuon/DoubleL2Mu30NoVtx_2Cha_CosmicSeed_Eta2p4/')
hltDiDispStaMuon30CosmicMonitoring.numGenericTriggerEventPSet.hltPaths = cms.vstring("HLT_DoubleL2Mu30NoVtx_2Cha_CosmicSeed_Eta2p4_v*") #HLT_ZeroBias_v*
exoHLTdispStaMuonMonitoring = cms.Sequence(
hltDiDispStaMuonMonitoring
+ hltDiDispStaMuonCosmicMonitoring
+ hltDispStaMuon23Monitoring
+ hltDispStaMuon23CosmicMonitoring
+ hltDiDispStaMuon25Monitoring
+ hltDiDispStaMuon25CosmicMonitoring
+ hltDiDispStaMuon30Monitoring
+ hltDiDispStaMuon30CosmicMonitoring
)
| 1,270 |
511 | /****************************************************************************
*
* Copyright 2018 Samsung Electronics 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.
*
****************************************************************************/
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// <string>
// basic_string<charT,traits,Allocator>&
// assign(const basic_string<charT,traits>& str);
#include <string>
#include <cassert>
#include "libcxx_tc_common.h"
#include "test_macros.h"
#include "test_allocator.h"
template <class S>
static int
test(S s, S str, S expected)
{
s.assign(str);
LIBCPP_ASSERT(s.__invariants());
TC_ASSERT_EXPR(s == expected);
return 0;
}
template <class S>
static int
testAlloc(S s, S str, const typename S::allocator_type& a)
{
s.assign(str);
LIBCPP_ASSERT(s.__invariants());
TC_ASSERT_EXPR(s == str);
TC_ASSERT_EXPR(s.get_allocator() == a);
return 0;
}
int tc_libcxx_strings_string_assign_string(void)
{
{
typedef std::string S;
TC_ASSERT_FUNC((test(S(), S(), S())));
TC_ASSERT_FUNC((test(S(), S("12345"), S("12345"))));
TC_ASSERT_FUNC((test(S(), S("1234567890"), S("1234567890"))));
TC_ASSERT_FUNC((test(S(), S("12345678901234567890"), S("12345678901234567890"))));
TC_ASSERT_FUNC((test(S("12345"), S(), S())));
TC_ASSERT_FUNC((test(S("12345"), S("12345"), S("12345"))));
TC_ASSERT_FUNC((test(S("12345"), S("1234567890"), S("1234567890"))));
TC_ASSERT_FUNC((test(S("12345"), S("12345678901234567890"), S("12345678901234567890"))));
TC_ASSERT_FUNC((test(S("1234567890"), S(), S())));
TC_ASSERT_FUNC((test(S("1234567890"), S("12345"), S("12345"))));
TC_ASSERT_FUNC((test(S("1234567890"), S("1234567890"), S("1234567890"))));
TC_ASSERT_FUNC((test(S("1234567890"), S("12345678901234567890"), S("12345678901234567890"))));
TC_ASSERT_FUNC((test(S("12345678901234567890"), S(), S())));
TC_ASSERT_FUNC((test(S("12345678901234567890"), S("12345"), S("12345"))));
TC_ASSERT_FUNC((test(S("12345678901234567890"), S("1234567890"), S("1234567890"))));
test(S("12345678901234567890"), S("12345678901234567890"),
S("12345678901234567890"));
TC_ASSERT_FUNC((testAlloc(S(), S(), std::allocator<char>())));
TC_ASSERT_FUNC((testAlloc(S(), S("12345"), std::allocator<char>())));
TC_ASSERT_FUNC((testAlloc(S(), S("1234567890"), std::allocator<char>())));
TC_ASSERT_FUNC((testAlloc(S(), S("12345678901234567890"), std::allocator<char>())));
}
{ // LWG#5579 make sure assign takes the allocators where appropriate
typedef other_allocator<char> A; // has POCCA --> true
typedef std::basic_string<char, std::char_traits<char>, A> S;
TC_ASSERT_FUNC((testAlloc(S(A(5)), S(A(3)), A(3))));
TC_ASSERT_FUNC((testAlloc(S(A(5)), S("1"), A())));
TC_ASSERT_FUNC((testAlloc(S(A(5)), S("1", A(7)), A(7))));
TC_ASSERT_FUNC((testAlloc(S(A(5)), S("1234567890123456789012345678901234567890123456789012345678901234567890", A(7)), A(7))));
}
#if TEST_STD_VER > 14
{
typedef std::string S;
static_assert(noexcept(S().assign(S())), ""); // LWG#2063
}
#endif
TC_SUCCESS_RESULT();
return 0;
}
| 1,590 |
2,189 | // Copyright (c) 2011-present, Facebook, Inc. All rights reserved.
// This source code is licensed under both the GPLv2 (found in the
// COPYING file in the root directory) and Apache 2.0 License
// (found in the LICENSE.Apache file in the root directory).
//
// 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.
#include "util/threadpool_imp.h"
#include "monitoring/thread_status_util.h"
#include "port/port.h"
#ifndef OS_WIN
# include <unistd.h>
#endif
#ifdef OS_LINUX
# include <sys/syscall.h>
# include <sys/resource.h>
#endif
#include <stdlib.h>
#include <algorithm>
#include <atomic>
#include <condition_variable>
#include <mutex>
#include <sstream>
#include <thread>
#include <vector>
namespace rocksdb {
void ThreadPoolImpl::PthreadCall(const char* label, int result) {
if (result != 0) {
fprintf(stderr, "pthread %s: %s\n", label, strerror(result));
abort();
}
}
struct ThreadPoolImpl::Impl {
Impl();
~Impl();
void JoinThreads(bool wait_for_jobs_to_complete);
void SetBackgroundThreadsInternal(int num, bool allow_reduce);
int GetBackgroundThreads();
unsigned int GetQueueLen() const {
return queue_len_.load(std::memory_order_relaxed);
}
void LowerIOPriority();
void LowerCPUPriority();
void WakeUpAllThreads() {
bgsignal_.notify_all();
}
void BGThread(size_t thread_id);
void StartBGThreads();
void Submit(std::function<void()>&& schedule,
std::function<void()>&& unschedule, void* tag);
int UnSchedule(void* arg);
void SetHostEnv(Env* env) { env_ = env; }
Env* GetHostEnv() const { return env_; }
bool HasExcessiveThread() const {
return static_cast<int>(bgthreads_.size()) > total_threads_limit_;
}
// Return true iff the current thread is the excessive thread to terminate.
// Always terminate the running thread that is added last, even if there are
// more than one thread to terminate.
bool IsLastExcessiveThread(size_t thread_id) const {
return HasExcessiveThread() && thread_id == bgthreads_.size() - 1;
}
bool IsExcessiveThread(size_t thread_id) const {
return static_cast<int>(thread_id) >= total_threads_limit_;
}
// Return the thread priority.
// This would allow its member-thread to know its priority.
Env::Priority GetThreadPriority() const { return priority_; }
// Set the thread priority.
void SetThreadPriority(Env::Priority priority) { priority_ = priority; }
private:
static void* BGThreadWrapper(void* arg);
bool low_io_priority_;
bool low_cpu_priority_;
Env::Priority priority_;
Env* env_;
int total_threads_limit_;
std::atomic_uint queue_len_; // Queue length. Used for stats reporting
bool exit_all_threads_;
bool wait_for_jobs_to_complete_;
// Entry per Schedule()/Submit() call
struct BGItem {
void* tag = nullptr;
std::function<void()> function;
std::function<void()> unschedFunction;
};
using BGQueue = std::deque<BGItem>;
BGQueue queue_;
std::mutex mu_;
std::condition_variable bgsignal_;
std::vector<port::Thread> bgthreads_;
};
inline
ThreadPoolImpl::Impl::Impl()
:
low_io_priority_(false),
low_cpu_priority_(false),
priority_(Env::LOW),
env_(nullptr),
total_threads_limit_(0),
queue_len_(),
exit_all_threads_(false),
wait_for_jobs_to_complete_(false),
queue_(),
mu_(),
bgsignal_(),
bgthreads_() {
}
inline
ThreadPoolImpl::Impl::~Impl() { assert(bgthreads_.size() == 0U); }
void ThreadPoolImpl::Impl::JoinThreads(bool wait_for_jobs_to_complete) {
std::unique_lock<std::mutex> lock(mu_);
assert(!exit_all_threads_);
wait_for_jobs_to_complete_ = wait_for_jobs_to_complete;
exit_all_threads_ = true;
// prevent threads from being recreated right after they're joined, in case
// the user is concurrently submitting jobs.
total_threads_limit_ = 0;
lock.unlock();
bgsignal_.notify_all();
for (auto& th : bgthreads_) {
th.join();
}
bgthreads_.clear();
exit_all_threads_ = false;
wait_for_jobs_to_complete_ = false;
}
inline
void ThreadPoolImpl::Impl::LowerIOPriority() {
std::lock_guard<std::mutex> lock(mu_);
low_io_priority_ = true;
}
inline
void ThreadPoolImpl::Impl::LowerCPUPriority() {
std::lock_guard<std::mutex> lock(mu_);
low_cpu_priority_ = true;
}
void ThreadPoolImpl::Impl::BGThread(size_t thread_id) {
bool low_io_priority = false;
bool low_cpu_priority = false;
while (true) {
// Wait until there is an item that is ready to run
std::unique_lock<std::mutex> lock(mu_);
// Stop waiting if the thread needs to do work or needs to terminate.
while (!exit_all_threads_ && !IsLastExcessiveThread(thread_id) &&
(queue_.empty() || IsExcessiveThread(thread_id))) {
bgsignal_.wait(lock);
}
if (exit_all_threads_) { // mechanism to let BG threads exit safely
if (!wait_for_jobs_to_complete_ ||
queue_.empty()) {
break;
}
}
if (IsLastExcessiveThread(thread_id)) {
// Current thread is the last generated one and is excessive.
// We always terminate excessive thread in the reverse order of
// generation time.
auto& terminating_thread = bgthreads_.back();
terminating_thread.detach();
bgthreads_.pop_back();
if (HasExcessiveThread()) {
// There is still at least more excessive thread to terminate.
WakeUpAllThreads();
}
break;
}
auto func = std::move(queue_.front().function);
queue_.pop_front();
queue_len_.store(static_cast<unsigned int>(queue_.size()),
std::memory_order_relaxed);
bool decrease_io_priority = (low_io_priority != low_io_priority_);
bool decrease_cpu_priority = (low_cpu_priority != low_cpu_priority_);
lock.unlock();
#ifdef OS_LINUX
if (decrease_cpu_priority) {
setpriority(
PRIO_PROCESS,
// Current thread.
0,
// Lowest priority possible.
19);
low_cpu_priority = true;
}
if (decrease_io_priority) {
#define IOPRIO_CLASS_SHIFT (13)
#define IOPRIO_PRIO_VALUE(class, data) (((class) << IOPRIO_CLASS_SHIFT) | data)
// Put schedule into IOPRIO_CLASS_IDLE class (lowest)
// These system calls only have an effect when used in conjunction
// with an I/O scheduler that supports I/O priorities. As at
// kernel 2.6.17 the only such scheduler is the Completely
// Fair Queuing (CFQ) I/O scheduler.
// To change scheduler:
// echo cfq > /sys/block/<device_name>/queue/schedule
// Tunables to consider:
// /sys/block/<device_name>/queue/slice_idle
// /sys/block/<device_name>/queue/slice_sync
syscall(SYS_ioprio_set, 1, // IOPRIO_WHO_PROCESS
0, // current thread
IOPRIO_PRIO_VALUE(3, 0));
low_io_priority = true;
}
#else
(void)decrease_io_priority; // avoid 'unused variable' error
(void)decrease_cpu_priority;
#endif
func();
}
}
// Helper struct for passing arguments when creating threads.
struct BGThreadMetadata {
ThreadPoolImpl::Impl* thread_pool_;
size_t thread_id_; // Thread count in the thread.
BGThreadMetadata(ThreadPoolImpl::Impl* thread_pool, size_t thread_id)
: thread_pool_(thread_pool), thread_id_(thread_id) {}
};
void* ThreadPoolImpl::Impl::BGThreadWrapper(void* arg) {
BGThreadMetadata* meta = reinterpret_cast<BGThreadMetadata*>(arg);
size_t thread_id = meta->thread_id_;
ThreadPoolImpl::Impl* tp = meta->thread_pool_;
#ifdef ROCKSDB_USING_THREAD_STATUS
// initialize it because compiler isn't good enough to see we don't use it
// uninitialized
ThreadStatus::ThreadType thread_type = ThreadStatus::NUM_THREAD_TYPES;
switch (tp->GetThreadPriority()) {
case Env::Priority::HIGH:
thread_type = ThreadStatus::HIGH_PRIORITY;
break;
case Env::Priority::LOW:
thread_type = ThreadStatus::LOW_PRIORITY;
break;
case Env::Priority::BOTTOM:
thread_type = ThreadStatus::BOTTOM_PRIORITY;
break;
case Env::Priority::TOTAL:
assert(false);
return nullptr;
}
assert(thread_type != ThreadStatus::NUM_THREAD_TYPES);
ThreadStatusUtil::RegisterThread(tp->GetHostEnv(), thread_type);
#endif
delete meta;
tp->BGThread(thread_id);
#ifdef ROCKSDB_USING_THREAD_STATUS
ThreadStatusUtil::UnregisterThread();
#endif
return nullptr;
}
void ThreadPoolImpl::Impl::SetBackgroundThreadsInternal(int num,
bool allow_reduce) {
std::unique_lock<std::mutex> lock(mu_);
if (exit_all_threads_) {
lock.unlock();
return;
}
if (num > total_threads_limit_ ||
(num < total_threads_limit_ && allow_reduce)) {
total_threads_limit_ = std::max(0, num);
WakeUpAllThreads();
StartBGThreads();
}
}
int ThreadPoolImpl::Impl::GetBackgroundThreads() {
std::unique_lock<std::mutex> lock(mu_);
return total_threads_limit_;
}
void ThreadPoolImpl::Impl::StartBGThreads() {
// Start background thread if necessary
while ((int)bgthreads_.size() < total_threads_limit_) {
port::Thread p_t(&BGThreadWrapper,
new BGThreadMetadata(this, bgthreads_.size()));
// Set the thread name to aid debugging
#if defined(_GNU_SOURCE) && defined(__GLIBC_PREREQ)
#if __GLIBC_PREREQ(2, 12)
auto th_handle = p_t.native_handle();
std::string thread_priority = Env::PriorityToString(GetThreadPriority());
std::ostringstream thread_name_stream;
thread_name_stream << "rocksdb:";
for (char c : thread_priority) {
thread_name_stream << static_cast<char>(tolower(c));
}
thread_name_stream << bgthreads_.size();
pthread_setname_np(th_handle, thread_name_stream.str().c_str());
#endif
#endif
bgthreads_.push_back(std::move(p_t));
}
}
void ThreadPoolImpl::Impl::Submit(std::function<void()>&& schedule,
std::function<void()>&& unschedule, void* tag) {
std::lock_guard<std::mutex> lock(mu_);
if (exit_all_threads_) {
return;
}
StartBGThreads();
// Add to priority queue
queue_.push_back(BGItem());
auto& item = queue_.back();
item.tag = tag;
item.function = std::move(schedule);
item.unschedFunction = std::move(unschedule);
queue_len_.store(static_cast<unsigned int>(queue_.size()),
std::memory_order_relaxed);
if (!HasExcessiveThread()) {
// Wake up at least one waiting thread.
bgsignal_.notify_one();
} else {
// Need to wake up all threads to make sure the one woken
// up is not the one to terminate.
WakeUpAllThreads();
}
}
int ThreadPoolImpl::Impl::UnSchedule(void* arg) {
int count = 0;
std::vector<std::function<void()>> candidates;
{
std::lock_guard<std::mutex> lock(mu_);
// Remove from priority queue
BGQueue::iterator it = queue_.begin();
while (it != queue_.end()) {
if (arg == (*it).tag) {
if (it->unschedFunction) {
candidates.push_back(std::move(it->unschedFunction));
}
it = queue_.erase(it);
count++;
} else {
++it;
}
}
queue_len_.store(static_cast<unsigned int>(queue_.size()),
std::memory_order_relaxed);
}
// Run unschedule functions outside the mutex
for (auto& f : candidates) {
f();
}
return count;
}
ThreadPoolImpl::ThreadPoolImpl() :
impl_(new Impl()) {
}
ThreadPoolImpl::~ThreadPoolImpl() {
}
void ThreadPoolImpl::JoinAllThreads() {
impl_->JoinThreads(false);
}
void ThreadPoolImpl::SetBackgroundThreads(int num) {
impl_->SetBackgroundThreadsInternal(num, true);
}
int ThreadPoolImpl::GetBackgroundThreads() {
return impl_->GetBackgroundThreads();
}
unsigned int ThreadPoolImpl::GetQueueLen() const {
return impl_->GetQueueLen();
}
void ThreadPoolImpl::WaitForJobsAndJoinAllThreads() {
impl_->JoinThreads(true);
}
void ThreadPoolImpl::LowerIOPriority() {
impl_->LowerIOPriority();
}
void ThreadPoolImpl::LowerCPUPriority() {
impl_->LowerCPUPriority();
}
void ThreadPoolImpl::IncBackgroundThreadsIfNeeded(int num) {
impl_->SetBackgroundThreadsInternal(num, false);
}
void ThreadPoolImpl::SubmitJob(const std::function<void()>& job) {
auto copy(job);
impl_->Submit(std::move(copy), std::function<void()>(), nullptr);
}
void ThreadPoolImpl::SubmitJob(std::function<void()>&& job) {
impl_->Submit(std::move(job), std::function<void()>(), nullptr);
}
void ThreadPoolImpl::Schedule(void(*function)(void* arg1), void* arg,
void* tag, void(*unschedFunction)(void* arg)) {
if (unschedFunction == nullptr) {
impl_->Submit(std::bind(function, arg), std::function<void()>(), tag);
} else {
impl_->Submit(std::bind(function, arg), std::bind(unschedFunction, arg),
tag);
}
}
int ThreadPoolImpl::UnSchedule(void* arg) {
return impl_->UnSchedule(arg);
}
void ThreadPoolImpl::SetHostEnv(Env* env) { impl_->SetHostEnv(env); }
Env* ThreadPoolImpl::GetHostEnv() const { return impl_->GetHostEnv(); }
// Return the thread priority.
// This would allow its member-thread to know its priority.
Env::Priority ThreadPoolImpl::GetThreadPriority() const {
return impl_->GetThreadPriority();
}
// Set the thread priority.
void ThreadPoolImpl::SetThreadPriority(Env::Priority priority) {
impl_->SetThreadPriority(priority);
}
ThreadPool* NewThreadPool(int num_threads) {
ThreadPoolImpl* thread_pool = new ThreadPoolImpl();
thread_pool->SetBackgroundThreads(num_threads);
return thread_pool;
}
} // namespace rocksdb
| 5,137 |
863 | #-*- coding:utf-8 -*-
"""
This module contains main implementations that encapsulate
retrieval-related statistics about the quality of the recommender's
recommendations.
"""
# Authors: <NAME> <<EMAIL>>
# License: BSD Style.
import operator
import numpy as np
from base import RecommenderEvaluator
from metrics import root_mean_square_error
from metrics import mean_absolute_error
from metrics import normalized_mean_absolute_error
from metrics import evaluation_error
from cross_validation import KFold
from metrics import precision_score
from metrics import recall_score
from metrics import f1_score
from sampling import SplitSampling
from scikits.learn.base import clone
from ..models.utils import ItemNotFoundError, UserNotFoundError
#Collaborative Filtering Evaluator
#==================================
evaluation_metrics = {
'rmse': root_mean_square_error,
'mae': mean_absolute_error,
'nmae': normalized_mean_absolute_error,
'precision': precision_score,
'recall': recall_score,
'f1score': f1_score
}
def check_sampling(sampling, n):
"""Input checker utility for building a
sampling in a user friendly way.
Parameters
===========
sampling: a float, a sampling generator instance, or None
The input specifying which sampling generator to use.
It can be an float, in which case it is the the proportion of
the dataset to include in the training set in SplitSampling.
None, in which case all the elements are used,
or another object, that will then be used as a cv generator.
n: an integer.
The number of elements.
"""
if sampling is None:
sampling = 1.0
if operator.isNumberType(sampling):
sampling = SplitSampling(n, evaluation_fraction=sampling)
return sampling
def check_cv(cv, n):
"""Input checker utility for building a
cross validation in a user friendly way.
Parameters
===========
sampling: an integer, a cv generator instance, or None
The input specifying which cv generator to use.
It can be an integer, in which case it is the number
of folds in a KFold, None, in which case 3 fold is used,
or another object, that will then be used as a cv generator.
n: an integer.
The number of elements.
"""
if cv is None:
cv = 3
if operator.isNumberType(cv):
cv = KFold(n, cv, indices=True)
return cv
class CfEvaluator(RecommenderEvaluator):
"""
Examples
--------
>>> from scikits.crab.similarities import UserSimilarity
>>> from scikits.crab.metrics import euclidean_distances
>>> from scikits.crab.models import MatrixPreferenceDataModel
>>> from scikits.crab.recommenders.knn import UserBasedRecommender
>>> from scikits.crab.metrics.classes import CfEvaluator
>>> from scikits.crab.recommenders.knn.neighborhood_strategies import NearestNeighborsStrategy
>>> movies = {'<NAME>': {'Lady in the Water': 2.5, \
'Snakes on a Plane': 3.5, \
'Just My Luck': 3.0, 'Superman Returns': 3.5, 'You, Me and Dupree': 2.5, \
'The Night Listener': 3.0}, \
'<NAME>': {'Lady in the Water': 3.0, 'Snakes on a Plane': 3.5, \
'Just My Luck': 1.5, 'Superman Returns': 5.0, 'The Night Listener': 3.0, \
'You, Me and Dupree': 3.5}, \
'<NAME>': {'Lady in the Water': 2.5, 'Snakes on a Plane': 3.0, \
'Superman Returns': 3.5, 'The Night Listener': 4.0}, \
'<NAME>': {'Snakes on a Plane': 3.5, 'Just My Luck': 3.0, \
'The Night Listener': 4.5, 'Superman Returns': 4.0, \
'You, Me and Dupree': 2.5}, \
'<NAME>': {'Lady in the Water': 3.0, 'Snakes on a Plane': 4.0, \
'Just My Luck': 2.0, 'Superman Returns': 3.0, 'The Night Listener': 3.0, \
'You, Me and Dupree': 2.0}, \
'Sheldom': {'Lady in the Water': 3.0, 'Snakes on a Plane': 4.0, \
'The Night Listener': 3.0, 'Superman Returns': 5.0, \
'You, Me and Dupree': 3.5}, \
'<NAME>': {'Snakes on a Plane':4.5,'You, Me and Dupree':1.0, \
'Superman Returns':4.0}, \
'<NAME>': {}}
>>> model = MatrixPreferenceDataModel(movies)
>>> similarity = UserSimilarity(model, euclidean_distances)
>>> neighborhood = NearestNeighborsStrategy()
>>> recsys = UserBasedRecommender(model, similarity, neighborhood)
>>> evaluator = CfEvaluator()
>>> all_scores = evaluator.evaluate(recsys, permutation=False)
>>> all_scores
{'rmse': 0.23590725429603751, 'recall': 1.0, 'precision': 1.0, \
'mae': 0.21812065003607684, 'f1score': 1.0, 'nmae': 0.054530162509019209}
>>> rmse = evaluator.evaluate_on_split(recsys, metric='rmse', permutation=False)
>>> rmse
({'error': [{'rmse': 0.35355339059327379}, \
{'rmse': 0.97109049202292397}, \
{'rmse': 0.39418387598407179}]}, \
{'final_error': {'avg': {'rmse': 0.57294258620008975}, \
'stdev': {'rmse': 0.28202130565981975}}})
"""
def _build_recommender(self, dataset, recommender):
"""
Build a clone recommender with the given dataset
as the training set.
Parameters
----------
dataset: dict
The dataset with the user's preferences.
recommender: A scikits.crab.base.BaseRecommender object.
The given recommender to be cloned.
"""
recommender_training = clone(recommender)
#if the recommender's model has the build_model implemented.
if not recommender.model.has_preference_values():
recommender_training.model.dataset = \
recommender_training.model._load_dataset(dataset.copy())
else:
recommender_training.model.dataset = dataset
if hasattr(recommender_training.model, 'build_model'):
recommender_training.model.build_model()
return recommender_training
def evaluate(self, recommender, metric=None, **kwargs):
"""
Evaluates the predictor
Parameters
----------
recommender: The BaseRecommender instance
The recommender instance to be evaluated.
metric: [None|'rmse'|'f1score'|'precision'|'recall'|'nmae'|'mae']
If metrics is None, all metrics available will be evaluated.
Otherwise it will return the specified metric evaluated.
sampling_users: float or sampling, optional, default = None
If an float is passed, it is the percentage of evaluated
users. If sampling_users is None, all users are used in the
evaluation. Specific sampling objects can be passed, see
scikits.crab.metrics.sampling module for the list of possible
objects.
sampling_ratings: float or sampling, optional, default = None
If an float is passed, it is the percentage of evaluated
ratings. If sampling_ratings is None, 70% will be used in the
training set and 30% in the test set. Specific sampling objects
can be passed, see scikits.crab.metrics.sampling module
for the list of possible objects.
at: integer, optional, default = None
This number at is the 'at' value, as in 'precision at 5'. For
example this would mean precision or recall evaluated by removing
the top 5 preferences for a user and then finding the percentage of
those 5 items included in the top 5 recommendations for that user.
If at is None, it will consider all the top 3 elements.
Returns
-------
Returns a dictionary containing the evaluation results:
(NMAE, MAE, RMSE, Precision, Recall, F1-Score)
"""
sampling_users = kwargs.pop('sampling_users', None)
sampling_ratings = kwargs.pop('sampling_ratings', 0.7)
permutation = kwargs.pop('permutation', True)
at = kwargs.pop('at', 3)
if metric not in evaluation_metrics and metric is not None:
raise ValueError('metric %s is not recognized. valid keywords \
are %s' % (metric, evaluation_metrics.keys()))
n_users = recommender.model.users_count()
sampling_users = check_sampling(sampling_users, n_users)
users_set, _ = sampling_users.split(permutation=permutation)
training_set = {}
testing_set = {}
#Select the users to be evaluated.
user_ids = recommender.model.user_ids()
for user_id in user_ids[users_set]:
#Select the ratings to be evaluated.
preferences = recommender.model.preferences_from_user(user_id)
sampling_eval = check_sampling(sampling_ratings, \
len(preferences))
train_set, test_set = sampling_eval.split(indices=True,
permutation=permutation)
preferences = list(preferences)
if recommender.model.has_preference_values():
training_set[user_id] = dict((preferences[idx]
for idx in train_set)) if preferences else {}
testing_set[user_id] = [preferences[idx]
for idx in test_set] if preferences else []
else:
training_set[user_id] = dict(((preferences[idx], 1.0)
for idx in train_set)) if preferences else {}
testing_set[user_id] = [(preferences[idx], 1.0)
for idx in test_set] if preferences else []
#Evaluate the recommender.
recommender_training = self._build_recommender(training_set, \
recommender)
real_preferences = []
estimated_preferences = []
for user_id, preferences in testing_set.iteritems():
for item_id, preference in preferences:
#Estimate the preferences
try:
estimated = recommender_training.estimate_preference(
user_id, item_id)
real_preferences.append(preference)
except ItemNotFoundError:
# It is possible that an item exists in the test data but
# not training data in which case an exception will be
# throw. Just ignore it and move on
continue
estimated_preferences.append(estimated)
#Return the error results.
if metric in ['rmse', 'mae', 'nmae']:
eval_function = evaluation_metrics[metric]
if metric == 'nmae':
return {metric: eval_function(real_preferences,
estimated_preferences,
recommender.model.maximum_preference_value(),
recommender.model.minimum_preference_value())}
return {metric: eval_function(real_preferences,
estimated_preferences)}
#IR_Statistics
relevant_arrays = []
real_arrays = []
#Select the users to be evaluated.
user_ids = recommender.model.user_ids()
for user_id in user_ids[users_set]:
preferences = recommender.model.preferences_from_user(user_id)
preferences = list(preferences)
if len(preferences) < 2 * at:
# Really not enough prefs to meaningfully evaluate the user
continue
# List some most-preferred items that would count as most
if not recommender.model.has_preference_values():
preferences = [(preference, 1.0) for preference in preferences]
preferences = sorted(preferences, key=lambda x: x[1], reverse=True)
relevant_item_ids = [item_id for item_id, preference
in preferences[:at]]
if len(relevant_item_ids) == 0:
continue
training_set = {}
for other_user_id in recommender.model.user_ids():
preferences_other_user = \
recommender.model.preferences_from_user(other_user_id)
if not recommender.model.has_preference_values():
preferences_other_user = [(preference, 1.0)
for preference in preferences_other_user]
if other_user_id == user_id:
preferences_other_user = \
[pref for pref in preferences_other_user \
if pref[0] not in relevant_item_ids]
if preferences_other_user:
training_set[other_user_id] = \
dict(preferences_other_user)
else:
training_set[other_user_id] = dict(preferences_other_user)
#Evaluate the recommender
recommender_training = self._build_recommender(training_set, \
recommender)
try:
preferences = \
recommender_training.model.preferences_from_user(user_id)
preferences = list(preferences)
if not preferences:
continue
except:
#Excluded all prefs for the user. move on.
continue
recommended_items = recommender_training.recommend(user_id, at)
relevant_arrays.append(list(relevant_item_ids))
real_arrays.append(list(recommended_items))
relevant_arrays = np.array(relevant_arrays)
real_arrays = np.array(real_arrays)
#Return the IR results.
if metric in ['precision', 'recall', 'f1score']:
eval_function = evaluation_metrics[metric]
return {metric: eval_function(real_arrays, relevant_arrays)}
if metric is None:
#Return all
mae, nmae, rmse = evaluation_error(real_preferences,
estimated_preferences,
recommender.model.maximum_preference_value(),
recommender.model.minimum_preference_value())
f = f1_score(real_arrays, relevant_arrays)
r = recall_score(real_arrays, relevant_arrays)
p = precision_score(real_arrays, relevant_arrays)
return {'mae': mae, 'nmae': nmae, 'rmse': rmse,
'precision': p, 'recall': r, 'f1score': f}
def evaluate_on_split(self, recommender, metric=None, cv=None, **kwargs):
"""
Evaluate on the folds of a dataset split
Parameters
----------
recommender: The BaseRecommender instance
The recommender instance to be evaluated.
metric: [None|'rmse'|'f1score'|'precision'|'recall'|'nmae'|'mae']
If metrics is None, all metrics available will be evaluated.
Otherwise it will return the specified metric evaluated.
sampling_users: float or sampling, optional, default = None
If an float is passed, it is the percentage of evaluated
users. If sampling_users is None, all users are used in the
evaluation. Specific sampling objects can be passed, see
scikits.crab.metrics.sampling module for the list of possible
objects.
cv: integer or crossvalidation, optional, default = None
If an integer is passed, it is the number of fold (default 3).
Specific sampling objects can be passed, see
scikits.crab.metrics.cross_validation module for the list of
possible objects.
at: integer, optional, default = None
This number at is the 'at' value, as in 'precision at 5'. For
example this would mean precision or recall evaluated by removing
the top 5 preferences for a user and then finding the percentage of
those 5 items included in the top 5 recommendations for that user.
If at is None, it will consider all the top 3 elements.
Returns
-------
score: dict
a dictionary containing the average results over
the different permutations on the split.
permutation_scores : array, shape = [n_permutations]
The scores obtained for each permutations.
"""
sampling_users = kwargs.pop('sampling_users', 0.7)
permutation = kwargs.pop('permutation', True)
at = kwargs.pop('at', 3)
if metric not in evaluation_metrics and metric is not None:
raise ValueError('metric %s is not recognized. valid keywords \
are %s' % (metric, evaluation_metrics.keys()))
permutation_scores_error = []
permutation_scores_ir = []
final_score_error = {'avg': {}, 'stdev': {}}
final_score_ir = {'avg': {}, 'stdev': {}}
n_users = recommender.model.users_count()
sampling_users = check_sampling(sampling_users, n_users)
users_set, _ = sampling_users.split(permutation=permutation)
total_ratings = []
#Select the users to be evaluated.
user_ids = recommender.model.user_ids()
for user_id in user_ids[users_set]:
#Select the ratings to be evaluated.
preferences = recommender.model.preferences_from_user(user_id)
preferences = list(preferences)
total_ratings.extend([(user_id, preference)
for preference in preferences])
n_ratings = len(total_ratings)
cross_val = check_cv(cv, n_ratings)
#Defining the splits and run on the splits.
for train_set, test_set in cross_val:
training_set = {}
testing_set = {}
for idx in train_set:
user_id, pref = total_ratings[idx]
if recommender.model.has_preference_values():
training_set.setdefault(user_id, {})
training_set[user_id][pref[0]] = pref[1]
else:
training_set.setdefault(user_id, {})
training_set[user_id][pref] = 1.0
for idx in test_set:
user_id, pref = total_ratings[idx]
if recommender.model.has_preference_values():
testing_set.setdefault(user_id, [])
testing_set[user_id].append(pref)
else:
testing_set.setdefault(user_id, [])
testing_set[user_id].append((pref, 1.0))
#Evaluate the recommender.
recommender_training = self._build_recommender(training_set, \
recommender)
real_preferences = []
estimated_preferences = []
for user_id, preferences in testing_set.iteritems():
for item_id, preference in preferences:
#Estimate the preferences
try:
estimated = recommender_training.estimate_preference(
user_id, item_id)
real_preferences.append(preference)
except:
# It is possible that an item exists
#in the test data but
# not training data in which case
#an exception will be
# throw. Just ignore it and move on
continue
estimated_preferences.append(estimated)
#Return the error results.
if metric in ['rmse', 'mae', 'nmae']:
eval_function = evaluation_metrics[metric]
if metric == 'nmae':
permutation_scores_error.append({
metric: eval_function(real_preferences,
estimated_preferences,
recommender.model.maximum_preference_value(),
recommender.model.minimum_preference_value())})
else:
permutation_scores_error.append(
{metric: eval_function(real_preferences,
estimated_preferences)})
elif metric is None:
#Return all
mae, nmae, rmse = evaluation_error(real_preferences,
estimated_preferences,
recommender.model.maximum_preference_value(),
recommender.model.minimum_preference_value())
permutation_scores_error.append({'mae': mae, 'nmae': nmae,
'rmse': rmse})
#IR_Statistics (Precision, Recall and F1-Score)
n_users = recommender.model.users_count()
cross_val = check_cv(cv, n_users)
for train_idx, test_idx in cross_val:
relevant_arrays = []
real_arrays = []
for user_id in user_ids[train_idx]:
preferences = recommender.model.preferences_from_user(user_id)
preferences = list(preferences)
if len(preferences) < 2 * at:
# Really not enough prefs to meaningfully evaluate the user
continue
# List some most-preferred items that would count as most
if not recommender.model.has_preference_values():
preferences = [(preference, 1.0) for preference in preferences]
preferences = sorted(preferences, key=lambda x: x[1], reverse=True)
relevant_item_ids = [item_id for item_id, preference
in preferences[:at]]
if len(relevant_item_ids) == 0:
continue
#Build the training set.
training_set = {}
for other_user_id in recommender.model.user_ids():
preferences_other_user = \
recommender.model.preferences_from_user(other_user_id)
if not recommender.model.has_preference_values():
preferences_other_user = [(preference, 1.0)
for preference in preferences_other_user]
if other_user_id == user_id:
preferences_other_user = \
[pref for pref in preferences_other_user \
if pref[0] not in relevant_item_ids]
if preferences_other_user:
training_set[other_user_id] = \
dict(preferences_other_user)
else:
training_set[other_user_id] = dict(preferences_other_user)
#Evaluate the recommender
recommender_training = self._build_recommender(training_set, \
recommender)
try:
preferences = \
recommender_training.model.preferences_from_user(user_id)
preferences = list(preferences)
if not preferences:
continue
except:
#Excluded all prefs for the user. move on.
continue
recommended_items = recommender_training.recommend(user_id, at)
relevant_arrays.append(list(relevant_item_ids))
real_arrays.append(list(recommended_items))
relevant_arrays = np.array(relevant_arrays)
real_arrays = np.array(real_arrays)
#Return the IR results.
if metric in ['precision', 'recall', 'f1score']:
eval_function = evaluation_metrics[metric]
permutation_scores_ir.append({metric: eval_function(real_arrays,
relevant_arrays)})
elif metric is None:
f = f1_score(real_arrays, relevant_arrays)
r = recall_score(real_arrays, relevant_arrays)
p = precision_score(real_arrays, relevant_arrays)
permutation_scores_ir.append({'precision': p, 'recall': r, 'f1score': f})
#Compute the final score for Error Statistics
for result in permutation_scores_error:
for key in result:
final_score_error['avg'].setdefault(key, [])
final_score_error['avg'][key].append(result[key])
for key in final_score_error['avg']:
final_score_error['stdev'][key] = np.std(final_score_error['avg'][key])
final_score_error['avg'][key] = np.average(final_score_error['avg'][key])
#Compute the final score for IR statistics
for result in permutation_scores_ir:
for key in result:
final_score_ir['avg'].setdefault(key, [])
final_score_ir['avg'][key].append(result[key])
for key in final_score_ir['avg']:
final_score_ir['stdev'][key] = np.std(final_score_ir['avg'][key])
final_score_ir['avg'][key] = np.average(final_score_ir['avg'][key])
permutation_scores = {}
scores = {}
if permutation_scores_error:
permutation_scores['error'] = permutation_scores_error
scores['final_error'] = final_score_error
if permutation_scores_ir:
permutation_scores['ir'] = permutation_scores_ir
scores.setdefault('final_error', {})
scores['final_error'].setdefault('avg', {})
scores['final_error'].setdefault('stdev', {})
scores['final_error']['avg'].update(final_score_ir['avg'])
scores['final_error']['stdev'].update(final_score_ir['stdev'])
return permutation_scores, scores
| 12,139 |
23,901 | <filename>eli5_retrieval_large_lm/check_flags.py<gh_stars>1000+
# coding=utf-8
# Copyright 2021 The Google Research 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.
"""Converts a json file to absl-py command line flags."""
import re
from typing import List
from absl import app
import colorama
def main(argv):
base_pat = re.compile(r"_?FLAG_[\w_]+")
good_pat = re.compile(r"^_?FLAG_[\w_]+\.value")
define_pat = re.compile(r"^_?FLAG_[\w_]+\s*=\s*flags.DEFINE_")
at_least_one_bad = False
with open(argv[1]) as fin:
for i, line in enumerate(fin):
start = 0
match = base_pat.search(line, start)
while match:
m_good_pat = good_pat.search(line[match.start():])
m_define_pat = define_pat.search(line[match.start():])
start = match.end() # Matches should be non-overlapping
# Verify if all m_base_pat matches overlap partially with at least one
# match of an acceptable way to write things.
# Matches can only start at the same position if they are for the
# Same flag.
if not (m_good_pat or m_define_pat):
at_least_one_bad = True
new_substr = (
f"{colorama.Fore.RED}{colorama.Style.BRIGHT}"
f"{match.group(0)}{colorama.Style.RESET_ALL}"
)
new_text = (
line[:match.start(0)] + new_substr + line[match.end(0):].rstrip()
)
# Prints different errors on the same line in the original text
# as separate errors in the output
print(
f"line {colorama.Style.BRIGHT}{i + 1}{colorama.Style.RESET_ALL}: "
f"{new_text}"
)
match = base_pat.search(line, start)
if at_least_one_bad:
exit(-1)
if __name__ == "__main__":
app.run(main)
| 935 |
34,359 | /*++
Copyright (c) Microsoft Corporation
Licensed under the MIT license.
Module Name:
- SettingsTab.h
Abstract:
- The SettingsTab is a tab whose content is a Settings UI control. They can
coexist in a TabView with all other types of tabs, like the TerminalTab.
There should only be at most one SettingsTab open at any given time.
Author(s):
- <NAME> - October 2020
--*/
#pragma once
#include "TabBase.h"
#include "SettingsTab.g.h"
namespace winrt::TerminalApp::implementation
{
struct SettingsTab : SettingsTabT<SettingsTab, TabBase>
{
public:
SettingsTab(winrt::Microsoft::Terminal::Settings::Editor::MainPage settingsUI);
void UpdateSettings(Microsoft::Terminal::Settings::Model::CascadiaSettings settings);
void Focus(winrt::Windows::UI::Xaml::FocusState focusState) override;
std::vector<Microsoft::Terminal::Settings::Model::ActionAndArgs> BuildStartupActions() const override;
private:
void _MakeTabViewItem() override;
winrt::fire_and_forget _CreateIcon();
};
}
| 386 |
362 | <reponame>google-admin/Accessibility-Test-Framework-for-Android
/*
* Copyright (C) 2015 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.google.android.apps.common.testing.accessibility.framework.uielement;
import static com.google.common.base.Preconditions.checkNotNull;
import static java.lang.Boolean.TRUE;
import com.google.android.apps.common.testing.accessibility.framework.replacements.LayoutParams;
import com.google.android.apps.common.testing.accessibility.framework.replacements.Rect;
import com.google.android.apps.common.testing.accessibility.framework.replacements.SpannableString;
import com.google.android.apps.common.testing.accessibility.framework.replacements.TextUtils;
import com.google.android.apps.common.testing.accessibility.framework.uielement.proto.AccessibilityHierarchyProtos.ViewHierarchyActionProto;
import com.google.android.apps.common.testing.accessibility.framework.uielement.proto.AccessibilityHierarchyProtos.ViewHierarchyElementProto;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Objects;
import org.checkerframework.checker.nullness.qual.MonotonicNonNull;
import org.checkerframework.checker.nullness.qual.Nullable;
import org.checkerframework.dataflow.qual.Pure;
/**
* Representation of a {@link android.view.View} hierarchy for accessibility checking
*
* <p>These views hold references to surrounding {@link ViewHierarchyElement}s in its local view
* hierarchy and the containing {@link WindowHierarchyElement}. An individual view may be uniquely
* identified in the context of its containing {@link WindowHierarchyElement} by the {@code id}
* value returned by {@link #getId()}, or it may be uniquely identified in the context of its
* containing {@link AccessibilityHierarchy} by the {@code long} returned by {@link
* #getCondensedUniqueId()}.
*/
public class ViewHierarchyElement {
protected final int id;
protected final @Nullable Integer parentId;
// Created lazily, because many views are leafs.
protected @MonotonicNonNull List<Integer> childIds;
// This field is set to a non-null value after construction.
private @MonotonicNonNull WindowHierarchyElement windowElement;
protected final @Nullable CharSequence packageName;
protected final @Nullable CharSequence className;
protected final @Nullable CharSequence accessibilityClassName;
protected final @Nullable String resourceName;
protected final @Nullable SpannableString contentDescription;
protected final @Nullable SpannableString text;
protected final boolean importantForAccessibility;
protected final @Nullable Boolean visibleToUser;
protected final boolean clickable;
protected final boolean longClickable;
protected final boolean focusable;
protected final @Nullable Boolean editable;
protected final @Nullable Boolean scrollable;
protected final @Nullable Boolean canScrollForward;
protected final @Nullable Boolean canScrollBackward;
protected final @Nullable Boolean checkable;
protected final @Nullable Boolean checked;
protected final @Nullable Boolean hasTouchDelegate;
protected final @Nullable Rect boundsInScreen;
protected final @Nullable Integer nonclippedHeight;
protected final @Nullable Integer nonclippedWidth;
protected final @Nullable Float textSize;
protected final @Nullable Integer textColor;
protected final @Nullable Integer backgroundDrawableColor;
protected final @Nullable Integer typefaceStyle;
protected final boolean enabled;
protected final @Nullable Integer drawingOrder;
protected final ImmutableList<ViewHierarchyAction> actionList;
protected final @Nullable LayoutParams layoutParams;
protected final @Nullable SpannableString hintText; // only for TextView
protected final @Nullable Integer hintTextColor; // only for TextView
protected final List<Rect> textCharacterLocations;
// Populated only after a hierarchy is constructed
protected @Nullable Long labeledById;
protected @Nullable Long accessibilityTraversalBeforeId;
protected @Nullable Long accessibilityTraversalAfterId;
protected List<Rect> touchDelegateBounds;
// A list of identifiers that represents all the superclasses of the corresponding view element.
protected final List<Integer> superclassViews;
protected ViewHierarchyElement(
int id,
@Nullable Integer parentId,
List<Integer> childIds,
@Nullable CharSequence packageName,
@Nullable CharSequence className,
@Nullable CharSequence accessibilityClassName,
@Nullable String resourceName,
@Nullable SpannableString contentDescription,
@Nullable SpannableString text,
boolean importantForAccessibility,
@Nullable Boolean visibleToUser,
boolean clickable,
boolean longClickable,
boolean focusable,
@Nullable Boolean editable,
@Nullable Boolean scrollable,
@Nullable Boolean canScrollForward,
@Nullable Boolean canScrollBackward,
@Nullable Boolean checkable,
@Nullable Boolean checked,
@Nullable Boolean hasTouchDelegate,
List<Rect> touchDelegateBounds,
@Nullable Rect boundsInScreen,
@Nullable Integer nonclippedHeight,
@Nullable Integer nonclippedWidth,
@Nullable Float textSize,
@Nullable Integer textColor,
@Nullable Integer backgroundDrawableColor,
@Nullable Integer typefaceStyle,
boolean enabled,
@Nullable Long labeledById,
@Nullable Long accessibilityTraversalBeforeId,
@Nullable Long accessibilityTraversalAfterId,
@Nullable Integer drawingOrder,
List<Integer> superclassViews,
List<? extends ViewHierarchyAction> actionList,
@Nullable LayoutParams layoutParams,
@Nullable SpannableString hintText,
@Nullable Integer hintTextColor,
List<Rect> textCharacterLocations) {
this.id = id;
this.parentId = parentId;
if (!childIds.isEmpty()) {
this.childIds = new ArrayList<>(childIds.size());
this.childIds.addAll(childIds);
}
this.packageName = packageName;
this.className = className;
this.accessibilityClassName = accessibilityClassName;
this.resourceName = resourceName;
this.contentDescription = contentDescription;
this.text = text;
this.importantForAccessibility = importantForAccessibility;
this.visibleToUser = visibleToUser;
this.clickable = clickable;
this.longClickable = longClickable;
this.focusable = focusable;
this.editable = editable;
this.scrollable = scrollable;
this.canScrollForward = canScrollForward;
this.canScrollBackward = canScrollBackward;
this.checkable = checkable;
this.checked = checked;
this.hasTouchDelegate = hasTouchDelegate;
this.touchDelegateBounds = touchDelegateBounds;
this.boundsInScreen = boundsInScreen;
this.nonclippedHeight = nonclippedHeight;
this.nonclippedWidth = nonclippedWidth;
this.textSize = textSize;
this.textColor = textColor;
this.backgroundDrawableColor = backgroundDrawableColor;
this.typefaceStyle = typefaceStyle;
this.enabled = enabled;
this.labeledById = labeledById;
this.accessibilityTraversalBeforeId = accessibilityTraversalBeforeId;
this.accessibilityTraversalAfterId = accessibilityTraversalAfterId;
this.drawingOrder = drawingOrder;
this.superclassViews = superclassViews;
if (actionList != null && !actionList.isEmpty()) {
this.actionList = ImmutableList.copyOf(actionList);
} else {
this.actionList = ImmutableList.of();
}
this.layoutParams = layoutParams;
this.hintText = hintText;
this.hintTextColor = hintTextColor;
this.textCharacterLocations = textCharacterLocations;
}
ViewHierarchyElement(ViewHierarchyElementProto proto) {
checkNotNull(proto);
// Bookkeeping
this.id = proto.getId();
this.parentId = (proto.getParentId() != -1) ? proto.getParentId() : null;
if (proto.getChildIdsCount() > 0) {
this.childIds = new ArrayList<>(proto.getChildIdsCount());
this.childIds.addAll(proto.getChildIdsList());
}
packageName = proto.hasPackageName() ? proto.getPackageName() : null;
className = proto.hasClassName() ? proto.getClassName() : null;
accessibilityClassName =
proto.hasAccessibilityClassName() ? proto.getAccessibilityClassName() : null;
resourceName = proto.hasResourceName() ? proto.getResourceName() : null;
contentDescription =
proto.hasContentDescription() ? new SpannableString(proto.getContentDescription()) : null;
text = proto.hasText() ? new SpannableString(proto.getText()) : null;
importantForAccessibility = proto.getImportantForAccessibility();
visibleToUser = proto.hasVisibleToUser() ? proto.getVisibleToUser() : null;
clickable = proto.getClickable();
longClickable = proto.getLongClickable();
focusable = proto.getFocusable();
editable = proto.hasEditable() ? proto.getEditable() : null;
scrollable = proto.hasScrollable() ? proto.getScrollable() : null;
canScrollForward = proto.hasCanScrollForward() ? proto.getCanScrollForward() : null;
canScrollBackward = proto.hasCanScrollBackward() ? proto.getCanScrollBackward() : null;
checkable = proto.hasCheckable() ? proto.getCheckable() : null;
checked = proto.hasChecked() ? proto.getChecked() : null;
hasTouchDelegate = proto.hasHasTouchDelegate() ? proto.getHasTouchDelegate() : null;
if (proto.getTouchDelegateBoundsCount() > 0) {
ImmutableList.Builder<Rect> builder = ImmutableList.<Rect>builder();
for (int i = 0; i < proto.getTouchDelegateBoundsCount(); ++i) {
builder.add(new Rect(proto.getTouchDelegateBounds(i)));
}
touchDelegateBounds = builder.build();
} else {
touchDelegateBounds = ImmutableList.of();
}
boundsInScreen = proto.hasBoundsInScreen() ? new Rect(proto.getBoundsInScreen()) : null;
nonclippedHeight = proto.hasNonclippedHeight() ? proto.getNonclippedHeight() : null;
nonclippedWidth = proto.hasNonclippedWidth() ? proto.getNonclippedWidth() : null;
textSize = proto.hasTextSize() ? proto.getTextSize() : null;
textColor = proto.hasTextColor() ? proto.getTextColor() : null;
backgroundDrawableColor =
proto.hasBackgroundDrawableColor() ? proto.getBackgroundDrawableColor() : null;
typefaceStyle = proto.hasTypefaceStyle() ? proto.getTypefaceStyle() : null;
enabled = proto.getEnabled();
labeledById = proto.hasLabeledById() ? proto.getLabeledById() : null;
accessibilityTraversalBeforeId =
proto.hasAccessibilityTraversalBeforeId()
? proto.getAccessibilityTraversalBeforeId()
: null;
accessibilityTraversalAfterId =
proto.hasAccessibilityTraversalAfterId() ? proto.getAccessibilityTraversalAfterId() : null;
superclassViews = proto.getSuperclassesList();
drawingOrder = proto.hasDrawingOrder() ? proto.getDrawingOrder() : null;
ImmutableList.Builder<ViewHierarchyAction> actionBuilder = new ImmutableList.Builder<>();
for (ViewHierarchyActionProto actionProto : proto.getActionsList()) {
actionBuilder.add(new ViewHierarchyAction(actionProto));
}
actionList = actionBuilder.build();
layoutParams = proto.hasLayoutParams() ? new LayoutParams(proto.getLayoutParams()) : null;
hintText = proto.hasHintText() ? new SpannableString(proto.getHintText()) : null;
hintTextColor = proto.hasHintTextColor() ? proto.getHintTextColor() : null;
ImmutableList.Builder<Rect> characterLocations = ImmutableList.<Rect>builder();
if (proto.getTextCharacterLocationsCount() > 0) {
for (int i = 0; i < proto.getTextCharacterLocationsCount(); ++i) {
characterLocations.add(new Rect(proto.getTextCharacterLocations(i)));
}
}
textCharacterLocations = characterLocations.build();
}
/**
* Returns the value uniquely identifying this window within the context of its containing {@link
* WindowHierarchyElement}.
*/
public int getId() {
return id;
}
/**
* @return a value uniquely representing this {@link ViewHierarchyElement} and its containing
* {@link WindowHierarchyElement} in the context of it's containing
* {@link AccessibilityHierarchy}.
*/
public long getCondensedUniqueId() {
return (((long) getWindow().getId() << 32) | getId());
}
/**
* @return The parent {@link ViewHierarchyElement} of this view, or {@code null} if this is a root
* view.
* @see android.view.accessibility.AccessibilityNodeInfo#getParent()
* @see android.view.View#getParent()
*/
@Pure
public @Nullable ViewHierarchyElement getParentView() {
Integer parentIdtmp = parentId;
return (parentIdtmp != null) ? getWindow().getViewById(parentIdtmp) : null;
}
/**
* @return The number of child {@link ViewHierarchyElement}s rooted at this view
* @see android.view.accessibility.AccessibilityNodeInfo#getChildCount()
* @see android.view.ViewGroup#getChildCount()
*/
public int getChildViewCount() {
return (childIds == null) ? 0 : childIds.size();
}
/**
* @param atIndex The index of the child {@link ViewHierarchyElement} to obtain. Must be &ge 0 and
* < {@link #getChildViewCount()}.
* @return The requested child, or {@code null} if no such child exists at the given
* {@code atIndex}
* @throws NoSuchElementException if {@code atIndex} is less than 0 or greater than
* {@code getChildViewCount() - 1}
*/
public ViewHierarchyElement getChildView(int atIndex) {
if ((atIndex < 0) || (childIds == null) || (atIndex >= childIds.size())) {
throw new NoSuchElementException();
}
return getWindow().getViewById(childIds.get(atIndex));
}
/**
* @return an unmodifiable {@link List} containing this {@link ViewHierarchyElement} and any
* descendants, direct or indirect, in depth-first ordering.
*/
public List<? extends ViewHierarchyElement> getSelfAndAllDescendants() {
List<ViewHierarchyElement> listToPopulate = new ArrayList<>();
listToPopulate.add(this);
for (int i = 0; i < getChildViewCount(); ++i) {
listToPopulate.addAll(getChildView(i).getSelfAndAllDescendants());
}
return Collections.unmodifiableList(listToPopulate);
}
/**
* @return The containing {@link WindowHierarchyElement} of this view.
*/
public WindowHierarchyElement getWindow() {
// The type is explicit because the @MonotonicNonNull field is not read as @Nullable.
return Preconditions.<@Nullable WindowHierarchyElement>checkNotNull(windowElement);
}
/**
* @return The package name to which this view belongs, or {@code null} if one cannot be
* determined
* @see android.view.accessibility.AccessibilityNodeInfo#getPackageName()
* @see android.content.Context#getPackageName()
*/
public @Nullable CharSequence getPackageName() {
return packageName;
}
/**
* @return The class name to which this view belongs, or {@code null} if one cannot be determined
* @see android.view.accessibility.AccessibilityNodeInfo#getPackageName()
* @see android.view.View#getClass()
*/
public @Nullable CharSequence getClassName() {
return className;
}
/**
* @return The view id's associated resource name, or {@code null} if one cannot be determined or
* is not available
* @see android.view.accessibility.AccessibilityNodeInfo#getViewIdResourceName()
* @see android.view.View#getId()
* @see android.content.res.Resources#getResourceName(int)
*/
@Pure
public @Nullable String getResourceName() {
return resourceName;
}
/**
* Check if the {@link android.view.View} this element represents matches a particular class.
*
* @param referenceClassName the name of the class to check against the class of this element.
* @return true if the {@code android.view.View} this element represents is an instance of the
* class whose name is {@code referenceClassName}. False if it does not.
*/
public boolean checkInstanceOf(String referenceClassName) {
AccessibilityHierarchy hierarchy = getWindow().getAccessibilityHierarchy();
Integer id = hierarchy.getViewElementClassNames().getIdentifierForClassName(referenceClassName);
if (id == null) {
return false;
}
return superclassViews.contains(id);
}
/**
* Check if the {@link android.view.View} this element represents matches one of the classes.
*
* @param referenceClassNameList the list of names of classes to check against the class of this
* element.
* @return true if the {@code android.view.View} this element represents is an instance of at
* least one of the class names in {@code referenceClassNameList}. False if it does not.
*/
public boolean checkInstanceOfAny(List<String> referenceClassNameList) {
for (String referenceClassName : referenceClassNameList) {
if (checkInstanceOf(referenceClassName)) {
return true;
}
}
return false;
}
/**
* @return This view's content description, or {@code null} if one is not present
* @see android.view.accessibility.AccessibilityNodeInfo#getContentDescription()
* @see android.view.View#getContentDescription()
*/
public @Nullable SpannableString getContentDescription() {
return contentDescription;
}
/**
* Indicates whether the element is important for accessibility and would be reported to
* accessibility services.
*
* @see android.view.View#isImportantForAccessibility()
*/
public boolean isImportantForAccessibility() {
return importantForAccessibility;
}
/**
* @return This view's text content, or {@code null} if none is present
* @see android.view.accessibility.AccessibilityNodeInfo#getText()
* @see android.widget.TextView#getText()
* @see android.widget.TextView#getHint()
*/
public @Nullable SpannableString getText() {
return text;
}
/**
* @return {@link Boolean#TRUE} if the element is visible to the user, {@link Boolean#FALSE} if
* not, or {@code null} if this cannot be determined.
* @see android.view.accessibility.AccessibilityNodeInfo#isVisibleToUser()
*/
public @Nullable Boolean isVisibleToUser() {
return visibleToUser;
}
/**
* Indicates whether this view reports that it reacts to click events or not.
*
* @see android.view.accessibility.AccessibilityNodeInfo#isClickable()
* @see android.view.View#isClickable()
*/
public boolean isClickable() {
return clickable;
}
/**
* Indicates whether this view reports that it reacts to long click events or not.
*
* @see android.view.accessibility.AccessibilityNodeInfo#isLongClickable()
* @see android.view.View#isLongClickable()
*/
public boolean isLongClickable() {
return longClickable;
}
/**
* Indicates whether this view reports that it is currently able to take focus.
*
* @see android.view.accessibility.AccessibilityNodeInfo#isFocusable()
* @see android.view.View#isFocusable()
*/
public boolean isFocusable() {
return focusable;
}
/**
* @return {@link Boolean#TRUE} if the element is editable, {@link Boolean#FALSE} if not, or
* {@code null} if this cannot be determined.
*/
public @Nullable Boolean isEditable() {
return editable;
}
/**
* @return {@link Boolean#TRUE} if the element is potentially scrollable or indicated as a
* scrollable container, {@link Boolean#FALSE} if not, or {@code null} if this cannot be
* determined. Scrollable in this context refers only to a element's potential for being
* scrolled, and doesn't indicate if the container holds enough wrapped content to scroll. To
* determine if an element is actually scrollable based on contents use {@link
* #canScrollForward} or {@link #canScrollBackward}.
*/
public @Nullable Boolean isScrollable() {
return scrollable;
}
/**
* @return {@link Boolean#TRUE} if the element is scrollable in the "forward" direction, typically
* meaning either vertically downward or horizontally to the right (in left-to-right
* locales), {@link Boolean#FALSE} if not, or {@code null if this cannot be determined.
*/
public @Nullable Boolean canScrollForward() {
return canScrollForward;
}
/**
* @return {@link Boolean#TRUE} if the element is scrollable in the "backward" direction,
* typically meaning either vertically downward or horizontally to the right (in
* left-to-right locales), {@link Boolean#FALSE} if not, or {@code null if this cannot be
* determined.
*/
public @Nullable Boolean canScrollBackward() {
return canScrollBackward;
}
/**
* @return {@link Boolean#TRUE} if the element is checkable, {@link Boolean#FALSE} if not, or
* {@code null} if this cannot be determined.
*/
public @Nullable Boolean isCheckable() {
return checkable;
}
/**
* @return {@link Boolean#TRUE} if the element is checked, {@link Boolean#FALSE} if not, or {@code
* null} if this cannot be determined.
*/
public @Nullable Boolean isChecked() {
return checked;
}
/**
* Returns {@link Boolean#TRUE} if the element has a {@link android.view.TouchDelegate}, {@link
* Boolean#FALSE} if not, or {@code null} if this cannot be determined. This indicates only that
* this element may be responsible for delegating its touches to another element.
*/
public @Nullable Boolean hasTouchDelegate() {
return hasTouchDelegate;
}
/**
* Returns a list of the touchable bounds of this element if rectangular {@link
* android.view.TouchDelegate}s are used to modify this delegatee's hit region from another
* delegating element.
*
* <p>NOTE: This is distinct from {@link #hasTouchDelegate()}, that indicates whether the element
* may be a delegator of touches.
*/
public List<Rect> getTouchDelegateBounds() {
return touchDelegateBounds;
}
/** Returns a list of character locations in screen coordinates. */
public List<Rect> getTextCharacterLocations() {
return textCharacterLocations;
}
/**
* Retrieves the visible bounds of this element in absolute screen coordinates.
*
* <p>NOTE: This method provides dimensions that may be reduced in size due to clipping effects
* from parent elements. To determine nonclipped dimensions, consider using {@link
* #getNonclippedHeight()} and {@link #getNonclippedWidth}.
*
* @return the view's bounds, or {@link Rect#EMPTY} if the view's bounds are unavailable, such as
* when it is positioned off-screen.
* @see android.view.accessibility.AccessibilityNodeInfo#getBoundsInScreen(android.graphics.Rect)
* @see android.view.View#getGlobalVisibleRect(android.graphics.Rect)
*/
public Rect getBoundsInScreen() {
return (boundsInScreen != null) ? boundsInScreen : Rect.EMPTY;
}
/**
* @return the height of this element (in raw pixels) not taking into account clipping effects
* applied by parent elements.
* @see android.view.View#getHeight()
*/
public @Nullable Integer getNonclippedHeight() {
return nonclippedHeight;
}
/**
* @return the width of this element (in raw pixels) not taking into account clipping effects
* applied by parent elements.
* @see android.view.View#getWidth()
*/
public @Nullable Integer getNonclippedWidth() {
return nonclippedWidth;
}
/**
* @return The size (in raw pixels) of the default text appearing in this view, or {@code null} if
* this cannot be determined
* @see android.widget.TextView#getTextSize()
*/
public @Nullable Float getTextSize() {
return textSize;
}
/**
* @return The color of the default text appearing in this view, or {@code null} if this cannot be
* determined
* @see android.widget.TextView#getCurrentTextColor()
*/
public @Nullable Integer getTextColor() {
return textColor;
}
/**
* @return The color of this View's background drawable, or {@code null} if the view does not have
* a {@link android.graphics.drawable.ColorDrawable} background
* @see android.view.View#getBackground()
* @see android.graphics.drawable.ColorDrawable#getColor()
*/
public @Nullable Integer getBackgroundDrawableColor() {
return backgroundDrawableColor;
}
/**
* Returns The style attributes of the {@link android.graphics.Typeface} of the default text
* appearing in this view, or @code null} if this cannot be determined.
*
* @see android.widget.TextView#getTypeface()
* @see android.graphics.Typeface#getStyle()
* @see android.graphics.Typeface#NORMAL
* @see android.graphics.Typeface#BOLD
* @see android.graphics.Typeface#ITALIC
* @see android.graphics.Typeface#BOLD_ITALIC
*/
@Pure
public @Nullable Integer getTypefaceStyle() {
return typefaceStyle;
}
/**
* Returns the enabled status for this view.
*
* @see android.view.View#isEnabled()
* @see android.view.accessibility.AccessibilityNodeInfo#isEnabled()
*/
public boolean isEnabled() {
return enabled;
}
/**
* @return The class name as reported to accessibility services, or {@code null} if this cannot be
* determined
* <p>NOTE: Unavailable for instances originally created from a {@link android.view.View}
* @see android.view.accessibility.AccessibilityNodeInfo#getClassName()
*/
public @Nullable CharSequence getAccessibilityClassName() {
return accessibilityClassName;
}
/**
* Returns the {@link ViewHierarchyElement} which acts as a label for this element, or {@code
* null} if this element is not labeled by another
*
* @see android.view.accessibility.AccessibilityNodeInfo#getLabeledBy()
* @see android.view.accessibility.AccessibilityNodeInfo#getLabelFor()
* @see android.view.View#getLabelFor()
*/
@Pure
public @Nullable ViewHierarchyElement getLabeledBy() {
return getViewHierarchyElementById(labeledById);
}
/**
* @return a view before which this one is visited in accessibility traversal
* @see android.view.accessibility.AccessibilityNodeInfo#getTraversalBefore()
* @see android.view.View#getAccessibilityTraversalBefore()
*/
public @Nullable ViewHierarchyElement getAccessibilityTraversalBefore() {
return getViewHierarchyElementById(accessibilityTraversalBeforeId);
}
/**
* @return a view after which this one is visited in accessibility traversal
* @see android.view.accessibility.AccessibilityNodeInfo#getTraversalAfter()
* @see android.view.View#getAccessibilityTraversalAfter()
*/
public @Nullable ViewHierarchyElement getAccessibilityTraversalAfter() {
return getViewHierarchyElementById(accessibilityTraversalAfterId);
}
/**
* Returns this element's drawing order within its parent, or {@code null} if the element's
* drawing order is not available.
*
* @see android.view.accessibility.AccessibilityNodeInfo#getDrawingOrder()
*/
public @Nullable Integer getDrawingOrder() {
return drawingOrder;
}
/**
* Returns how the element wants to be laid out in its parent, or {@code null} if the info is not
* available.
*
* @see android.view.ViewGroup.LayoutParams
*/
public @Nullable LayoutParams getLayoutParams() {
return layoutParams;
}
/**
* Returns the hint that is displayed when this view is a TextView and the text of the TextView is
* empty, or {@code null} if the view is not a TextView, or if the info in not available.
*
* @see android.widget.TextView#getHint()
*/
public @Nullable SpannableString getHintText() {
return hintText;
}
/**
* Returns the current color selected to paint the hint text, or {@code null} if this cannot be
* determined.
*
* @see android.widget.TextView#getCurrentHintTextColor()
*/
public @Nullable Integer getHintTextColor() {
return hintTextColor;
}
/**
* Returns {@code true} if this element {@link #isVisibleToUser} and its visible bounds are
* adjacent to the scrollable edge of a scrollable container. This would indicate that the element
* may be partially obscured by the container.
*/
public boolean isAgainstScrollableEdge() {
return TRUE.equals(isVisibleToUser()) && isAgaistScrollableEdgeOfAncestor(this);
}
private boolean isAgaistScrollableEdgeOfAncestor(ViewHierarchyElement view) {
ViewHierarchyElement ancestor = view.getParentView();
if (ancestor == null) {
return false;
}
// See if this element is at the top or left edge of a scrollable container that can be scrolled
// backward.
if (TRUE.equals(ancestor.canScrollBackward())) {
Rect scrollableBounds = ancestor.getBoundsInScreen();
Rect descendantBounds = this.getBoundsInScreen();
if ((descendantBounds.getTop() <= scrollableBounds.getTop())
|| (descendantBounds.getLeft() <= scrollableBounds.getLeft())) {
return true;
}
}
// See if this element is at the bottom or right edge of a scrollable container that can be
// scrolled forward.
if (TRUE.equals(ancestor.canScrollForward())) {
Rect scrollableBounds = ancestor.getBoundsInScreen();
Rect descendantBounds = this.getBoundsInScreen();
if ((descendantBounds.getBottom() >= scrollableBounds.getBottom())
|| (descendantBounds.getRight() >= scrollableBounds.getRight())) {
return true;
}
}
// Recurse for ancestors.
return isAgaistScrollableEdgeOfAncestor(ancestor);
}
@Override
public int hashCode() {
return getId();
}
@Override
public boolean equals(@Nullable Object object) {
if (object == this) {
return true;
}
if (!(object instanceof ViewHierarchyElement)) {
return false;
}
ViewHierarchyElement element = (ViewHierarchyElement) object;
if (!propertiesEquals((ViewHierarchyElement) object)) {
return false;
}
for (int i = 0; i < getChildViewCount(); i++) {
if (!getChildView(i).equals(element.getChildView(i))) {
return false;
}
}
return true;
}
/**
* Returns a list of identifiers that represents all the superclasses of the corresponding view
* element.
*/
List<Integer> getSuperclassList() {
return superclassViews;
}
/** Add a view class id to superclass list. */
void addIdToSuperclassViewList(int id) {
this.superclassViews.add(id);
}
/** Returns a list of actions exposed by this view element. */
ImmutableList<ViewHierarchyAction> getActionList() {
return actionList;
}
ViewHierarchyElementProto toProto() {
ViewHierarchyElementProto.Builder builder = ViewHierarchyElementProto.newBuilder();
// Bookkeeping
builder.setId(id);
if (parentId != null) {
builder.setParentId(parentId);
}
if ((childIds != null) && !childIds.isEmpty()) {
builder.addAllChildIds(childIds);
}
// View properties
if (!TextUtils.isEmpty(packageName)) {
builder.setPackageName(packageName.toString());
}
if (!TextUtils.isEmpty(className)) {
builder.setClassName(className.toString());
}
if (!TextUtils.isEmpty(resourceName)) {
builder.setResourceName(resourceName);
}
if (!TextUtils.isEmpty(contentDescription)) {
builder.setContentDescription(contentDescription.toProto());
}
if (!TextUtils.isEmpty(text)) {
builder.setText(text.toProto());
}
builder.setImportantForAccessibility(importantForAccessibility);
if (visibleToUser != null) {
builder.setVisibleToUser(visibleToUser);
}
builder.setClickable(clickable).setLongClickable(longClickable).setFocusable(focusable);
if (editable != null) {
builder.setEditable(editable);
}
if (scrollable != null) {
builder.setScrollable(scrollable);
}
if (canScrollForward != null) {
builder.setCanScrollForward(canScrollForward);
}
if (canScrollBackward != null) {
builder.setCanScrollBackward(canScrollBackward);
}
if (checkable != null) {
builder.setCheckable(checkable);
}
if (checked != null) {
builder.setChecked(checked);
}
if (hasTouchDelegate != null) {
builder.setHasTouchDelegate(hasTouchDelegate);
}
for (Rect bounds : touchDelegateBounds) {
builder.addTouchDelegateBounds(bounds.toProto());
}
if (boundsInScreen != null) {
builder.setBoundsInScreen(boundsInScreen.toProto());
}
if (nonclippedHeight != null) {
builder.setNonclippedHeight(nonclippedHeight);
}
if (nonclippedWidth != null) {
builder.setNonclippedWidth(nonclippedWidth);
}
if (textSize != null) {
builder.setTextSize(textSize);
}
if (textColor != null) {
builder.setTextColor(textColor);
}
if (backgroundDrawableColor != null) {
builder.setBackgroundDrawableColor(backgroundDrawableColor);
}
if (typefaceStyle != null) {
builder.setTypefaceStyle(typefaceStyle);
}
builder.setEnabled(enabled);
if (labeledById != null) {
builder.setLabeledById(labeledById);
}
if (accessibilityClassName != null) {
builder.setAccessibilityClassName(accessibilityClassName.toString());
}
if (accessibilityTraversalBeforeId != null) {
builder.setAccessibilityTraversalBeforeId(accessibilityTraversalBeforeId);
}
if (accessibilityTraversalAfterId != null) {
builder.setAccessibilityTraversalAfterId(accessibilityTraversalAfterId);
}
if (drawingOrder != null) {
builder.setDrawingOrder(drawingOrder);
}
if (layoutParams != null) {
builder.setLayoutParams(layoutParams.toProto());
}
if (!TextUtils.isEmpty(hintText)) {
builder.setHintText(hintText.toProto());
}
if (hintTextColor != null) {
builder.setHintTextColor(hintTextColor);
}
builder.addAllSuperclasses(superclassViews);
for (ViewHierarchyAction action : actionList) {
builder.addActions(action.toProto());
}
for (Rect rect : textCharacterLocations) {
builder.addTextCharacterLocations(rect.toProto());
}
return builder.build();
}
/** Set the containing {@link WindowHierarchyElement} of this view. */
void setWindow(WindowHierarchyElement window) {
this.windowElement = window;
}
/**
* @param child The child {@link ViewHierarchyElement} to add as a child of this view
*/
void addChild(ViewHierarchyElement child) {
if (childIds == null) {
childIds = new ArrayList<>();
}
childIds.add(child.id);
}
/**
* Denotes that {@code labelingElement} acts as a label for this element
*
* @param labelingElement The element that labels this element, or {@code null} if this element is
* not labeled by another
*/
void setLabeledBy(ViewHierarchyElement labelingElement) {
labeledById = (labelingElement != null) ? labelingElement.getCondensedUniqueId() : null;
}
/**
* Sets a view before which this one is visited in accessibility traversal. A screen-reader must
* visit the content of this view before the content of the one it precedes.
*/
void setAccessibilityTraversalBefore(ViewHierarchyElement element) {
accessibilityTraversalBeforeId = element.getCondensedUniqueId();
}
/**
* Sets a view after which this one is visited in accessibility traversal. A screen-reader must
* visit the content of the other view before the content of this one.
*/
void setAccessibilityTraversalAfter(ViewHierarchyElement element) {
accessibilityTraversalAfterId = element.getCondensedUniqueId();
}
/**
* Adds a Rect to this element's list of {@code TouchDelegate} hit-Rect bounds, indicating it may
* receive touches via another element within these bounds.
*
* <p>NOTE: This should be invoked only on instances from an AccessibilityHierarchy built from
* {@link android.view.accessibility.AccessibilityNodeInfo}. Hierarchies built from other
* structures expect this field to be Immutable after construction.
*/
void addTouchDelegateBounds(Rect bounds) {
touchDelegateBounds.add(bounds);
}
private @Nullable ViewHierarchyElement getViewHierarchyElementById(@Nullable Long id) {
return (id != null) ? getWindow().getAccessibilityHierarchy().getViewById(id) : null;
}
private boolean propertiesEquals(ViewHierarchyElement element) {
return (getCondensedUniqueId() == element.getCondensedUniqueId())
&& (getChildViewCount() == element.getChildViewCount())
&& TextUtils.equals(getPackageName(), element.getPackageName())
&& TextUtils.equals(getClassName(), element.getClassName())
&& TextUtils.equals(getResourceName(), element.getResourceName())
&& isImportantForAccessibility() == element.isImportantForAccessibility()
&& TextUtils.equals(getContentDescription(), element.getContentDescription())
&& TextUtils.equals(getText(), element.getText())
&& Objects.equals(getTextColor(), element.getTextColor())
&& Objects.equals(getBackgroundDrawableColor(), element.getBackgroundDrawableColor())
&& Objects.equals(isVisibleToUser(), element.isVisibleToUser())
&& (isClickable() == element.isClickable())
&& (isLongClickable() == element.isLongClickable())
&& (isFocusable() == element.isFocusable())
&& Objects.equals(isEditable(), element.isEditable())
&& Objects.equals(isScrollable(), element.isScrollable())
&& Objects.equals(canScrollForward(), element.canScrollForward())
&& Objects.equals(canScrollBackward(), element.canScrollBackward())
&& Objects.equals(isCheckable(), element.isCheckable())
&& Objects.equals(isChecked(), element.isChecked())
&& Objects.equals(hasTouchDelegate(), element.hasTouchDelegate())
&& Objects.equals(getTouchDelegateBounds(), element.getTouchDelegateBounds())
&& Objects.equals(getBoundsInScreen(), element.getBoundsInScreen())
&& Objects.equals(getNonclippedWidth(), element.getNonclippedWidth())
&& Objects.equals(getNonclippedHeight(), element.getNonclippedHeight())
&& Objects.equals(getTextSize(), element.getTextSize())
&& Objects.equals(getTypefaceStyle(), element.getTypefaceStyle())
&& (isEnabled() == element.isEnabled())
&& condensedUniqueIdEquals(getLabeledBy(), element.getLabeledBy())
&& TextUtils.equals(getAccessibilityClassName(), element.getAccessibilityClassName())
&& condensedUniqueIdEquals(
getAccessibilityTraversalAfter(), element.getAccessibilityTraversalAfter())
&& condensedUniqueIdEquals(
getAccessibilityTraversalBefore(), element.getAccessibilityTraversalBefore())
&& Objects.equals(getDrawingOrder(), element.getDrawingOrder())
&& Objects.equals(getLayoutParams(), element.getLayoutParams())
&& TextUtils.equals(getHintText(), element.getHintText())
&& Objects.equals(getHintTextColor(), element.getHintTextColor());
}
private static boolean condensedUniqueIdEquals(
@Nullable ViewHierarchyElement ve1, @Nullable ViewHierarchyElement ve2) {
return (ve1 == null)
? (ve2 == null)
: ((ve2 != null) && (ve1.getCondensedUniqueId() == ve2.getCondensedUniqueId()));
}
}
| 13,161 |
2,023 | import cStringIO
import tokenize
from collections import defaultdict, deque
from decimal import Decimal
from functools import partial
__version__ = "1.1"
__author__ = "<NAME>"
__all__ = ["parse", "parseOne"]
# For defining the default type for the defaultdict as to not use eval(type):
# TODO: better method?
TYPES = {
"int": int,
"long": long,
"float": float,
"Decimal": Decimal,
"bool": bool,
"str": str,
"list": list,
"tuple": tuple,
"set": set,
"deque": deque,
"dict": dict,
"defaultdict": defaultdict,
"None": None
}
def _error(tok, msg):
raise SyntaxError("%s token(%s, '%s') at %s = from/to [row, col]"
% (msg, tokenize.tok_name[tok[0]],
tok[1], str(tok[2:4])))
_fail = partial(_error, msg="malformed expression")
def _parse(token, src):
try:
return _dispatcher[token[0]](token, src)
except KeyError:
_error(token, "unknown token type")
def _parseBool(token, src):
# bool
return token[1] == "True"
def _parseDecimal(token, src):
# Decimal("number")
_tests(src, (('(', 'open'),), "malformed Decimal")
token = src.next()
if token[0] != tokenize.STRING:
_error(token, "malformed Decimal string")
out = Decimal(token[1][1:-1])
_tests(src, ((')', 'close'),), "malformed Decimal")
return out
def _parseDefaultdict(token, src):
# defaultdict(<type 'type'>, {...})
tests = (('(', 'open'), ('<', 'typeopen'), ('type', 'typestring'))
_tests(src, tests, "malformed defaultdict")
token = src.next()
try:
dicttype = TYPES[token[1][1:-1]]
except KeyError:
_error(token, "unknown defaultdict type")
tests = (('>', 'typeclose'), (',', 'typesep'))
_tests(src, tests, "malformed defaultdict")
dd = _parse(src.next(), src)
if type(dd) != dict:
_error(src.next(), "malformed defaultdict dict '%s' - next" % str(dd))
out = defaultdict(dicttype, dd)
_tests(src, ((')', 'close'),), "malformed defaultdict")
return out
def _parseName(token, src):
try:
return _dispatchName[token[1]](token, src)
except KeyError:
_fail(token)
def _parseNone(token, src):
# None
return None
def _parseNumber(token, src):
# int, float, long
try:
if token[1][-1] == "L":
return long(token[1], 0)
return int(token[1], 0)
except ValueError:
return float(token[1])
def _parseOp(token, src):
if token[1] == "{":
# {dict}
out = {}
token = src.next()
while token[1] != "}":
key = _parse(token, src)
_tests(src, ((':', 'separator'),), "malformed dictionary")
value = _parse(src.next(), src)
out[key] = value
token = src.next()
if token[1] == ",":
token = src.next()
return out
elif token[1] in ("[", "("):
# [list], (tuple)
container = list if token[1] == "[" else tuple
out = []
token = src.next()
while token[0] != tokenize.OP and token[1] not in ("]", ")"):
out.append(_parse(token, src))
token = src.next()
if token[1] == ",":
token = src.next()
return container(out)
else:
_fail(token)
def _parsePass(token, src):
# just continue...
return _parse(src.next(), src)
def _parseSet(token, src):
# set([...]), deque([...])
container = set if token[1] == "set" else deque
name = token[1]
_tests(src, (('(', 'open'),), "malformed %s" % name)
lst = _parse(src.next(), src)
if type(lst) != list:
_error(src.next(), "malformed %s list '%s' - next" % (name, str(lst)))
_tests(src, ((')', 'close'),), "malformed %s" % name)
return container(lst)
def _parseString(token, src):
# str
return token[1][1:-1].decode("string-escape")
def _tests(src, tests, base_msg):
for sym, msg in tests:
token = src.next()
if token[1] != sym:
_error(token, "%s %s" % (base_msg, msg))
return
def _tokenize(source):
src = cStringIO.StringIO(source).readline
return tokenize.generate_tokens(src)
_dispatcher = {
tokenize.ENDMARKER: _parsePass,
tokenize.INDENT: _parsePass,
tokenize.NAME: _parseName,
tokenize.NL: _parsePass,
tokenize.NEWLINE: _parsePass,
tokenize.NUMBER: _parseNumber,
tokenize.OP: _parseOp,
tokenize.STRING: _parseString,
}
_dispatchName = {
"set": _parseSet,
"deque": _parseSet,
"defaultdict": _parseDefaultdict,
"Decimal": _parseDecimal,
"None": _parseNone,
"True": _parseBool,
"False": _parseBool,
}
def parse(source):
""" Parses a type string to their type objects for all basic types.
Yields [nested] type objects.
Raises SyntaxError and SemanticError on failures.
Supported types:
* containers: defaultdict, deque, dict, list, tuple, set
* basic types: Decimal, bool, float, int, long, str
* None type
"""
src = _tokenize(source)
for token in src:
yield _parse(token, src)
def parseOne(source):
""" Parses only the next type object from source and returns it together
with the remaining [possibly empty] string as an object, string tuple.
"""
src = _tokenize(source)
obj = _parse(src.next(), src)
try:
next = src.next()
except StopIteration:
rest = ""
else:
rest = source.split('\n')[next[2][0] - 1:]
if len(rest) == 0:
rest = ""
else:
rest[0] = rest[0][next[2][1]:]
rest = '\n'.join(rest)
finally:
return obj, rest
| 2,601 |
1,806 | <reponame>yoav-orca/pants
# Copyright 2020 Pants project contributors (see CONTRIBUTORS.md).
# Licensed under the Apache License, Version 2.0 (see LICENSE).
from abc import ABCMeta, abstractmethod
from pathlib import Path
from textwrap import dedent
from typing import ClassVar, Iterable, List, Optional, Tuple, Type
from pants.core.goals.check import Check, CheckRequest, CheckResult, CheckResults, check
from pants.core.util_rules.distdir import DistDir
from pants.engine.addresses import Address
from pants.engine.fs import Workspace
from pants.engine.target import FieldSet, MultipleSourcesField, Target, Targets
from pants.engine.unions import UnionMembership
from pants.testutil.option_util import create_options_bootstrapper
from pants.testutil.rule_runner import MockGet, RuleRunner, mock_console, run_rule_with_mocks
from pants.util.logging import LogLevel
class MockTarget(Target):
alias = "mock_target"
core_fields = (MultipleSourcesField,)
class MockCheckFieldSet(FieldSet):
required_fields = (MultipleSourcesField,)
class MockCheckRequest(CheckRequest, metaclass=ABCMeta):
field_set_type = MockCheckFieldSet
checker_name: ClassVar[str]
@staticmethod
@abstractmethod
def exit_code(_: Iterable[Address]) -> int:
pass
@property
def check_results(self) -> CheckResults:
addresses = [config.address for config in self.field_sets]
return CheckResults(
[
CheckResult(
self.exit_code(addresses),
"",
"",
)
],
checker_name=self.checker_name,
)
class SuccessfulRequest(MockCheckRequest):
checker_name = "SuccessfulChecker"
@staticmethod
def exit_code(_: Iterable[Address]) -> int:
return 0
class FailingRequest(MockCheckRequest):
checker_name = "FailingChecker"
@staticmethod
def exit_code(_: Iterable[Address]) -> int:
return 1
class ConditionallySucceedsRequest(MockCheckRequest):
checker_name = "ConditionallySucceedsChecker"
@staticmethod
def exit_code(addresses: Iterable[Address]) -> int:
if any(address.target_name == "bad" for address in addresses):
return 127
return 0
class SkippedRequest(MockCheckRequest):
@staticmethod
def exit_code(_) -> int:
return 0
@property
def check_results(self) -> CheckResults:
return CheckResults([], checker_name="SkippedChecker")
class InvalidField(MultipleSourcesField):
pass
class InvalidFieldSet(MockCheckFieldSet):
required_fields = (InvalidField,)
class InvalidRequest(MockCheckRequest):
field_set_type = InvalidFieldSet
checker_name = "InvalidChecker"
@staticmethod
def exit_code(_: Iterable[Address]) -> int:
return -1
def make_target(address: Optional[Address] = None) -> Target:
if address is None:
address = Address("", target_name="tests")
return MockTarget({}, address)
def run_typecheck_rule(
*, request_types: List[Type[CheckRequest]], targets: List[Target]
) -> Tuple[int, str]:
union_membership = UnionMembership({CheckRequest: request_types})
with mock_console(create_options_bootstrapper()) as (console, stdio_reader):
rule_runner = RuleRunner()
result: Check = run_rule_with_mocks(
check,
rule_args=[
console,
Workspace(rule_runner.scheduler, _enforce_effects=False),
Targets(targets),
DistDir(relpath=Path("dist")),
union_membership,
],
mock_gets=[
MockGet(
output_type=CheckResults,
input_type=CheckRequest,
mock=lambda field_set_collection: field_set_collection.check_results,
),
],
union_membership=union_membership,
)
assert not stdio_reader.get_stdout()
return result.exit_code, stdio_reader.get_stderr()
def test_invalid_target_noops() -> None:
exit_code, stderr = run_typecheck_rule(request_types=[InvalidRequest], targets=[make_target()])
assert exit_code == 0
assert stderr == ""
def test_summary() -> None:
good_address = Address("", target_name="good")
bad_address = Address("", target_name="bad")
exit_code, stderr = run_typecheck_rule(
request_types=[
ConditionallySucceedsRequest,
FailingRequest,
SkippedRequest,
SuccessfulRequest,
],
targets=[make_target(good_address), make_target(bad_address)],
)
assert exit_code == FailingRequest.exit_code([bad_address])
assert stderr == dedent(
"""\
𐄂 ConditionallySucceedsChecker failed.
𐄂 FailingChecker failed.
- SkippedChecker skipped.
✓ SuccessfulChecker succeeded.
"""
)
def test_streaming_output_skip() -> None:
results = CheckResults([], checker_name="typechecker")
assert results.level() == LogLevel.DEBUG
assert results.message() == "typechecker skipped."
def test_streaming_output_success() -> None:
results = CheckResults([CheckResult(0, "stdout", "stderr")], checker_name="typechecker")
assert results.level() == LogLevel.INFO
assert results.message() == dedent(
"""\
typechecker succeeded.
stdout
stderr
"""
)
def test_streaming_output_failure() -> None:
results = CheckResults([CheckResult(18, "stdout", "stderr")], checker_name="typechecker")
assert results.level() == LogLevel.ERROR
assert results.message() == dedent(
"""\
typechecker failed (exit code 18).
stdout
stderr
"""
)
def test_streaming_output_partitions() -> None:
results = CheckResults(
[
CheckResult(21, "", "", partition_description="ghc8.1"),
CheckResult(0, "stdout", "stderr", partition_description="ghc9.2"),
],
checker_name="typechecker",
)
assert results.level() == LogLevel.ERROR
assert results.message() == dedent(
"""\
typechecker failed (exit code 21).
Partition #1 - ghc8.1:
Partition #2 - ghc9.2:
stdout
stderr
"""
)
| 2,601 |
2,111 | /*
* nvbio
* Copyright (c) 2011-2014, NVIDIA CORPORATION. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * 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.
* * Neither the name of the NVIDIA CORPORATION 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 NVIDIA CORPORATION 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
#include <nvbio/basic/types.h>
#include <nvbio/basic/numbers.h>
#include <cmath>
#include <limits>
namespace nvbio {
///
/// A generic small vector class with the dimension set at compile-time
///
template <typename T, uint32 DIM>
struct StaticVectorBase
{
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
const T& operator[] (const uint32 i) const { return data[i]; }
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
T& operator[] (const uint32 i) { return data[i]; }
T data[DIM];
};
///
/// A generic small vector class with the dimension set at compile-time
///
template <typename T>
struct StaticVectorBase<T,2>
{
typedef typename vector_type<T,2>::type base_type;
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
StaticVectorBase<T,2>() {}
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
StaticVectorBase<T,2>(const base_type v) : data(v) {}
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
const T& operator[] (const uint32 i) const { return (&data.x)[i]; }
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
T& operator[] (const uint32 i) { return (&data.x)[i]; }
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
operator base_type() const { return data; }
base_type data;
};
///
/// A generic small vector class with the dimension set at compile-time
///
template <typename T>
struct StaticVectorBase<T,3>
{
typedef typename vector_type<T,3>::type base_type;
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
StaticVectorBase<T,3>() {}
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
StaticVectorBase<T,3>(const base_type v) : data(v) {}
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
const T& operator[] (const uint32 i) const { return (&data.x)[i]; }
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
T& operator[] (const uint32 i) { return (&data.x)[i]; }
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
operator base_type() const { return data; }
base_type data;
};
///
/// A generic small vector class with the dimension set at compile-time
///
template <typename T>
struct StaticVectorBase<T,4>
{
typedef typename vector_type<T,4>::type base_type;
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
StaticVectorBase<T,4>() {}
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
StaticVectorBase<T,4>(const base_type v) : data(v) {}
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
const T& operator[] (const uint32 i) const { return (&data.x)[i]; }
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
T& operator[] (const uint32 i) { return (&data.x)[i]; }
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
operator base_type() const { return data; }
base_type data;
};
///
/// A generic small vector class with the dimension set at compile-time
///
template <typename T, uint32 DIM>
struct StaticVector : public StaticVectorBase<T,DIM>
{
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
StaticVector() {}
//NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
//StaticVector(const T* v);
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
explicit StaticVector(const T v);
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
StaticVector<T,DIM>& operator= (const StaticVectorBase<T,DIM>& op);
};
template <typename T,uint32 DIM_T> struct vector_traits< StaticVectorBase<T,DIM_T> > { typedef T value_type; const static uint32 DIM = DIM_T; };
template <typename T, uint32 DIM>
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
StaticVector<T,DIM> operator+ (const StaticVector<T,DIM>& op1, const StaticVector<T,DIM>& op2);
template <typename T, uint32 DIM>
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
StaticVector<T,DIM>& operator+= (StaticVector<T,DIM>& op1, const StaticVector<T,DIM>& op2);
template <typename T, uint32 DIM>
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
StaticVector<T,DIM> operator- (const StaticVector<T,DIM>& op1, const StaticVector<T,DIM>& op2);
template <typename T, uint32 DIM>
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
StaticVector<T,DIM>& operator-= (StaticVector<T,DIM>& op1, const StaticVector<T,DIM>& op2);
template <typename T, uint32 DIM>
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
StaticVector<T,DIM> operator* (const StaticVector<T,DIM>& op1, const StaticVector<T,DIM>& op2);
template <typename T, uint32 DIM>
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
StaticVector<T,DIM>& operator*= (StaticVector<T,DIM>& op1, const StaticVector<T,DIM>& op2);
template <typename T, uint32 DIM>
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
StaticVector<T,DIM> operator/ (const StaticVector<T,DIM>& op1, const StaticVector<T,DIM>& op2);
template <typename T, uint32 DIM>
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
StaticVector<T,DIM>& operator/= (StaticVector<T,DIM>& op1, const StaticVector<T,DIM>& op2);
template <typename T, uint32 DIM>
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
StaticVector<T,DIM> min(const StaticVector<T,DIM>& op1, const StaticVector<T,DIM>& op2);
template <typename T, uint32 DIM>
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
StaticVector<T,DIM> max(const StaticVector<T,DIM>& op1, const StaticVector<T,DIM>& op2);
template <typename T, uint32 DIM>
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
bool any(const StaticVector<T,DIM>& op);
template <typename T, uint32 DIM>
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
bool all(const StaticVector<T,DIM>& op);
template <typename T, uint32 DIM>
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
bool operator== (const StaticVector<T,DIM>& op1, const StaticVector<T,DIM>& op2);
template <typename T, uint32 DIM>
NVBIO_FORCEINLINE NVBIO_HOST_DEVICE
bool operator!= (const StaticVector<T,DIM>& op1, const StaticVector<T,DIM>& op2);
} // namespace nvbio
#include <nvbio/basic/static_vector_inl.h>
| 2,755 |
3,200 | <reponame>GuoSuiming/mindspore<gh_stars>1000+
# Copyright 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.
# ============================================================================
"""test_bleu_score"""
import math
import pytest
from mindspore.nn.metrics import BleuScore
def test_bleu_score():
"""test_bleu_score"""
candidate_corpus = [['i', 'have', 'a', 'pen', 'on', 'my', 'desk']]
reference_corpus = [[['i', 'have', 'a', 'pen', 'in', 'my', 'desk'],
['there', 'is', 'a', 'pen', 'on', 'the', 'desk']]]
metric = BleuScore(n_gram=4, smooth=False)
metric.clear()
metric.update(candidate_corpus, reference_corpus)
bleu_score = metric.eval()
assert math.isclose(bleu_score, 0.5946035575013605, abs_tol=0.0001)
def test_bleu_score_update1():
"""test_bleu_score_update1"""
candidate_corpus = ['the cat is on the mat'.split()]
metric = BleuScore()
metric.clear()
with pytest.raises(ValueError):
metric.update(candidate_corpus)
def test_bleu_score_update2():
"""test_bleu_score_update2"""
candidate_corpus = [['the cat is on the mat'.split()], ['a cat is on the mat'.split()]]
reference_corpus = [['there is a cat on the mat'.split(), 'a cat is on the mat'.split()]]
metric = BleuScore()
metric.clear()
with pytest.raises(ValueError):
metric.update(candidate_corpus, reference_corpus)
def test_bleu_score_init1():
"""test_bleu_score_init1"""
with pytest.raises(TypeError):
BleuScore(n_gram="3")
def test_bleu_score_init2():
"""test_bleu_score_init2"""
with pytest.raises(TypeError):
BleuScore(smooth=5)
def test_bleu_score_runtime():
"""test_bleu_score_runtime"""
metric = BleuScore()
metric.clear()
with pytest.raises(RuntimeError):
metric.eval()
| 879 |
340 | package com.mikepenz.materialize;
import android.app.Activity;
import android.graphics.Color;
import android.os.Build;
import androidx.annotation.ColorInt;
import androidx.annotation.ColorRes;
import androidx.annotation.IdRes;
import androidx.core.content.ContextCompat;
import android.view.View;
import android.view.ViewGroup;
import android.view.WindowManager;
import android.widget.FrameLayout;
import com.mikepenz.materialize.util.UIUtils;
import com.mikepenz.materialize.view.IScrimInsetsLayout;
import com.mikepenz.materialize.view.ScrimInsetsFrameLayout;
/**
* Created by mikepenz on 07.07.15.
*/
public class MaterializeBuilder {
// the activity to use
protected Activity mActivity;
protected ViewGroup mRootView;
protected ViewGroup mContentRoot;
protected IScrimInsetsLayout mScrimInsetsLayout;
/**
* default constructor
*/
public MaterializeBuilder() {
}
/**
* constructor with activity instead of
*
* @param activity
*/
public MaterializeBuilder(Activity activity) {
this.mRootView = (ViewGroup) activity.findViewById(android.R.id.content);
this.mActivity = activity;
}
/**
* Pass the activity you use the drawer in ;)
* This is required if you want to set any values by resource
*
* @param activity
* @return
*/
public MaterializeBuilder withActivity(Activity activity) {
this.mRootView = (ViewGroup) activity.findViewById(android.R.id.content);
this.mActivity = activity;
return this;
}
/**
* Pass the rootView of the MaterializeBuilder which will be used to inflate the views in
*
* @param rootView
* @return
*/
public MaterializeBuilder withRootView(ViewGroup rootView) {
this.mRootView = rootView;
return this;
}
/**
* Pass the rootView as resource of the DrawerBuilder which will be used to inflate the views in
*
* @param rootViewRes
* @return
*/
public MaterializeBuilder withRootView(@IdRes int rootViewRes) {
if (mActivity == null) {
throw new RuntimeException("please pass an activity first to use this call");
}
return withRootView((ViewGroup) mActivity.findViewById(rootViewRes));
}
//defines if it should add the ScrimInsetsLayout
protected boolean mUseScrimInsetsLayout = true;
/**
* Defines if we should use the ScrimInsetsLayout in addition
*
* @param useScrimInsetsLayout defines to add the ScrimInsetsLayout
* @return this
*/
public MaterializeBuilder withUseScrimInsetsLayout(boolean useScrimInsetsLayout) {
this.mUseScrimInsetsLayout = useScrimInsetsLayout;
return this;
}
//the statusBar color
protected int mStatusBarColor = 0;
protected int mStatusBarColorRes = -1;
/**
* Set the statusBarColor color for this activity
*
* @param statusBarColor
* @return this
*/
public MaterializeBuilder withStatusBarColor(@ColorInt int statusBarColor) {
this.mStatusBarColor = statusBarColor;
return this;
}
/**
* Set the statusBarColor color for this activity from a resource
*
* @param statusBarColorRes
* @return
*/
public MaterializeBuilder withStatusBarColorRes(@ColorRes int statusBarColorRes) {
this.mStatusBarColorRes = statusBarColorRes;
return this;
}
//set to true if we want a transparent statusbar
protected boolean mTransparentStatusBar = false;
/**
* @param transparentStatusBar
* @return
*/
public MaterializeBuilder withTransparentStatusBar(boolean transparentStatusBar) {
this.mTransparentStatusBar = transparentStatusBar;
return this;
}
// set to disable the translucent statusBar Programmatically
protected boolean mTranslucentStatusBarProgrammatically = false;
/**
* set this to false if you want no translucent statusBar. or
* if you want to create this behavior only by theme.
*
* @param translucentStatusBarProgrammatically
* @return
*/
public MaterializeBuilder withTranslucentStatusBarProgrammatically(boolean translucentStatusBarProgrammatically) {
this.mTranslucentStatusBarProgrammatically = translucentStatusBarProgrammatically;
return this;
}
//set to true if we want a transparent statusBar
protected boolean mStatusBarPadding = false;
/**
* @param statusBarPadding
* @return
*/
public MaterializeBuilder withStatusBarPadding(boolean statusBarPadding) {
this.mStatusBarPadding = statusBarPadding;
return this;
}
// set if the ScrimInsetsLayout should tint the StatusBar
protected boolean mTintStatusBar = true;
/**
* set if the ScrimInsetsLayout should tint the StatusBar
*
* @param tintedStatusBar
* @return
*/
public MaterializeBuilder withTintedStatusBar(boolean tintedStatusBar) {
this.mTintStatusBar = tintedStatusBar;
return this;
}
// set to disable the translucent statusBar Programmatically
protected boolean mTranslucentNavigationBarProgrammatically = false;
/**
* set this to true if you want a translucent navigation bar.
*
* @param translucentNavigationBarProgrammatically
* @return
*/
public MaterializeBuilder withTranslucentNavigationBarProgrammatically(boolean translucentNavigationBarProgrammatically) {
this.mTranslucentNavigationBarProgrammatically = translucentNavigationBarProgrammatically;
//if we enable the programmatically translucent navigationBar we want also the normal navigationBar behavior
return this;
}
//set to true if we want a transparent navigationBar
protected boolean mTransparentNavigationBar = false;
/**
* @param navigationBar
* @return
*/
public MaterializeBuilder withTransparentNavigationBar(boolean navigationBar) {
this.mTransparentNavigationBar = navigationBar;
return this;
}
//set to true if we want a transparent navigationBar
protected boolean mNavigationBarPadding = false;
/**
* @param navigationBarPadding
* @return
*/
public MaterializeBuilder withNavigationBarPadding(boolean navigationBarPadding) {
this.mNavigationBarPadding = navigationBarPadding;
return this;
}
// set if the ScrimInsetsLayout should tint the NavigationBar
protected boolean mTintNavigationBar = false;
/**
* set if the ScrimInsetsLayout should tint the NavigationBar
*
* @param tintedNavigationBar
* @return
*/
public MaterializeBuilder withTintedNavigationBar(boolean tintedNavigationBar) {
this.mTintNavigationBar = tintedNavigationBar;
if (tintedNavigationBar) {
withTranslucentNavigationBarProgrammatically(true);
}
return this;
}
// set non translucent NavigationBar mode
protected boolean mFullscreen = false;
/**
* Set to true if the used theme has a translucent statusBar
* and navigationBar and you want to manage the padding on your own.
*
* @param fullscreen
* @return
*/
public MaterializeBuilder withFullscreen(boolean fullscreen) {
this.mFullscreen = fullscreen;
if (fullscreen) {
withTranslucentNavigationBarProgrammatically(true);
withTintedStatusBar(false);
withTintedNavigationBar(false);
}
return this;
}
// set to no systemUI visible mode
protected boolean mSystemUIHidden = false;
/**
* Set to true if you use your app in complete fullscreen mode
* with hidden statusBar and navigationBar
*
* @param systemUIHidden
* @return
*/
public MaterializeBuilder withSystemUIHidden(boolean systemUIHidden) {
this.mSystemUIHidden = systemUIHidden;
if (systemUIHidden) {
withFullscreen(systemUIHidden);
}
return this;
}
// a viewGroup which contains the ScrimInsetsFrameLayout as child
protected ViewGroup mContainer = null;
/**
* set a container view here if you want the ScrimInsetsFrameLayout to be hosted inside another viewGroup
*
* @param container
* @return
*/
public MaterializeBuilder withContainer(ViewGroup container) {
this.mContainer = container;
return this;
}
// the layoutParams for the container
protected ViewGroup.LayoutParams mContainerLayoutParams = null;
/**
* set the layout params for the container which will host the ScrimInsetsFrameLayout
*
* @param layoutParams
* @return
*/
public MaterializeBuilder withContainerLayoutParams(ViewGroup.LayoutParams layoutParams) {
this.mContainerLayoutParams = layoutParams;
return this;
}
/**
* set the layout which will host the ScrimInsetsFrameLayout and its layoutParams
*
* @param container
* @param layoutParams
* @return
*/
public MaterializeBuilder withContainer(ViewGroup container, ViewGroup.LayoutParams layoutParams) {
this.mContainer = container;
this.mContainerLayoutParams = layoutParams;
return this;
}
public Materialize build() {
//we need an activity for this
if (mActivity == null) {
throw new RuntimeException("please pass an activity");
}
if (mUseScrimInsetsLayout) {
// if the user has not set a drawerLayout use the default one :D
mScrimInsetsLayout = (ScrimInsetsFrameLayout) mActivity.getLayoutInflater().inflate(R.layout.materialize, mRootView, false);
//check if the activity was initialized correctly
if (mRootView == null || mRootView.getChildCount() == 0) {
throw new RuntimeException("You have to set your layout for this activity with setContentView() first. Or you build the drawer on your own with .buildView()");
}
//get the content view
View originalContentView = mRootView.getChildAt(0);
boolean alreadyInflated = originalContentView.getId() == R.id.materialize_root;
// define the statusBarColor
if (mStatusBarColor == 0 && mStatusBarColorRes != -1) {
mStatusBarColor = ContextCompat.getColor(mActivity, mStatusBarColorRes);
} else if (mStatusBarColor == 0) {
mStatusBarColor = UIUtils.getThemeColorFromAttrOrRes(mActivity, R.attr.colorPrimaryDark, R.color.materialize_primary_dark);
}
//handling statusBar / navigationBar tinting
mScrimInsetsLayout.setInsetForeground(mStatusBarColor);
mScrimInsetsLayout.setTintStatusBar(mTintStatusBar);
mScrimInsetsLayout.setTintNavigationBar(mTintNavigationBar);
//if we are fullscreen remove all insets
mScrimInsetsLayout.setSystemUIVisible(!mFullscreen && !mSystemUIHidden);
//only add the new layout if it wasn't done before
if (!alreadyInflated) {
// remove the contentView
mRootView.removeView(originalContentView);
} else {
//if it was already inflated we have to clean up again
mRootView.removeAllViews();
}
//create the layoutParams to use for the contentView
FrameLayout.LayoutParams layoutParamsContentView = new FrameLayout.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT,
ViewGroup.LayoutParams.MATCH_PARENT
);
//add the contentView to the drawer content frameLayout
mScrimInsetsLayout.getView().addView(originalContentView, layoutParamsContentView);
//if we have a mContainer we use this one
mContentRoot = mScrimInsetsLayout.getView();
if (mContainer != null) {
mContentRoot = mContainer;
mContentRoot.addView(mScrimInsetsLayout.getView(), new ViewGroup.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT,
ViewGroup.LayoutParams.MATCH_PARENT
));
}
//set the id so we can check if it was already inflated
mContentRoot.setId(R.id.materialize_root);
//make sure we have the correct layoutParams
if (mContainerLayoutParams == null) {
mContainerLayoutParams = new ViewGroup.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT,
ViewGroup.LayoutParams.MATCH_PARENT
);
}
//add the drawerLayout to the root
mRootView.addView(mContentRoot, mContainerLayoutParams);
} else {
//we need an container in this case
if (mContainer == null) {
throw new RuntimeException("please pass a container");
}
View originalContentView = mRootView.getChildAt(0);
// remove the contentView
mRootView.removeView(originalContentView);
//create the layoutParams to use for the contentView
FrameLayout.LayoutParams layoutParamsContentView = new FrameLayout.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT,
ViewGroup.LayoutParams.MATCH_PARENT
);
mContainer.addView(originalContentView, layoutParamsContentView);
//make sure we have the correct layoutParams
if (mContainerLayoutParams == null) {
mContainerLayoutParams = new ViewGroup.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT,
ViewGroup.LayoutParams.MATCH_PARENT
);
}
//add the drawerLayout to the root
mRootView.addView(mContainer, mContainerLayoutParams);
}
//set the flags if we want to hide the system ui
if (mSystemUIHidden) {
if (Build.VERSION.SDK_INT >= 16) {
View decorView = this.mActivity.getWindow().getDecorView();
decorView.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_STABLE
| View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION
| View.SYSTEM_UI_FLAG_LAYOUT_FULLSCREEN
| View.SYSTEM_UI_FLAG_HIDE_NAVIGATION
| View.SYSTEM_UI_FLAG_FULLSCREEN
| View.SYSTEM_UI_FLAG_IMMERSIVE_STICKY);
}
}
//do some magic specific to the statusBar
if (mTranslucentStatusBarProgrammatically) {
if (Build.VERSION.SDK_INT >= 21) {
//this.mActivity.getWindow().clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION);
UIUtils.setTranslucentStatusFlag(mActivity, false);
}
}
//do some magic specific to the navigationBar
if (mTranslucentNavigationBarProgrammatically) {
if (Build.VERSION.SDK_INT >= 21) {
//this.mActivity.getWindow().clearFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_NAVIGATION);
UIUtils.setTranslucentNavigationFlag(mActivity, true);
}
}
if (mTransparentStatusBar || mTransparentNavigationBar) {
// add FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS flag to the window
if (Build.VERSION.SDK_INT >= 21) {
this.mActivity.getWindow().addFlags(WindowManager.LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS);
}
}
//we do this if we want a complete transparent statusBar
if (mTransparentStatusBar) {
// finally change the color
if (Build.VERSION.SDK_INT >= 21) {
UIUtils.setTranslucentStatusFlag(mActivity, false);
this.mActivity.getWindow().setStatusBarColor(Color.TRANSPARENT);
}
}
//we do this if we want a complete transparent navigationBar
if (mTransparentNavigationBar) {
// finally change the color
if (Build.VERSION.SDK_INT >= 21) {
UIUtils.setTranslucentNavigationFlag(mActivity, true);
this.mActivity.getWindow().setNavigationBarColor(Color.TRANSPARENT);
}
}
//do some magic specific to the statusBar
int paddingTop = 0;
if (mStatusBarPadding && Build.VERSION.SDK_INT >= 21) {
paddingTop = UIUtils.getStatusBarHeight(mActivity);
}
int paddingBottom = 0;
if (mNavigationBarPadding && Build.VERSION.SDK_INT >= 21) {
paddingBottom = UIUtils.getNavigationBarHeight(mActivity);
}
if (mStatusBarPadding || mNavigationBarPadding && Build.VERSION.SDK_INT >= 21) {
mScrimInsetsLayout.getView().setPadding(0, paddingTop, 0, paddingBottom);
}
//set activity to null as we do not need it anymore
this.mActivity = null;
//create a Materialize object with the builder
return new Materialize(this);
}
}
| 6,983 |
642 | package com.jeesuite.springweb.ext.feign;
import static feign.Util.CONTENT_ENCODING;
import static feign.Util.CONTENT_LENGTH;
import static feign.Util.ENCODING_DEFLATE;
import static feign.Util.ENCODING_GZIP;
import static java.lang.String.format;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.Collection;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.zip.DeflaterOutputStream;
import java.util.zip.GZIPOutputStream;
import org.apache.commons.lang3.StringUtils;
import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.LoadBalancerClient;
import com.jeesuite.common.WebConstants;
import com.jeesuite.common.model.AuthUser;
import com.jeesuite.common.util.WebUtils;
import com.jeesuite.springweb.CurrentRuntimeContext;
import com.jeesuite.springweb.client.CustomRequestHostHolder;
import feign.Client;
import feign.Request;
import feign.Request.Options;
import feign.Response;
/**
*
* <br>
* Class Name : CustomLoadBalancerFeignClient
*
* @author jiangwei
* @version 1.0.0
* @date 2019年12月19日
*/
public class CustomLoadBalancerFeignClient implements Client{
private LoadBalancerClient loadBalancer;
public CustomLoadBalancerFeignClient(LoadBalancerClient loadBalancer) {
this.loadBalancer = loadBalancer;
}
@Override
public Response execute(Request request, Options options) throws IOException {
HttpURLConnection connection = convertAndSend(request, options);
return convertResponse(connection, request);
}
HttpURLConnection convertAndSend(Request request, Options options) throws IOException {
String vipAddress = StringUtils.split(request.url(), "/")[1];
String realAddress = CustomRequestHostHolder.getMapping(vipAddress);
if(StringUtils.isBlank(realAddress)){
ServiceInstance instance = loadBalancer.choose(vipAddress);
if(instance == null)throw new RuntimeException("Load balancer does not have available server for client:" + vipAddress);
realAddress = instance.getHost() + ":" + instance.getPort();
}
String url = request.url().replace(vipAddress, realAddress);
final HttpURLConnection connection =
(HttpURLConnection) new URL(url).openConnection();
connection.setConnectTimeout(options.connectTimeoutMillis());
connection.setReadTimeout(options.readTimeoutMillis());
connection.setAllowUserInteraction(false);
connection.setInstanceFollowRedirects(options.isFollowRedirects());
connection.setRequestMethod(request.httpMethod().name());
Collection<String> contentEncodingValues = request.headers().get(CONTENT_ENCODING);
boolean gzipEncodedRequest =
contentEncodingValues != null && contentEncodingValues.contains(ENCODING_GZIP);
boolean deflateEncodedRequest =
contentEncodingValues != null && contentEncodingValues.contains(ENCODING_DEFLATE);
boolean hasAcceptHeader = false;
Integer contentLength = null;
for (String field : request.headers().keySet()) {
if (field.equalsIgnoreCase("Accept")) {
hasAcceptHeader = true;
}
for (String value : request.headers().get(field)) {
if (field.equals(CONTENT_LENGTH)) {
if (!gzipEncodedRequest && !deflateEncodedRequest) {
contentLength = Integer.valueOf(value);
connection.addRequestProperty(field, value);
}
} else {
connection.addRequestProperty(field, value);
}
}
}
// Some servers choke on the default accept string.
if (!hasAcceptHeader) {
connection.addRequestProperty("Accept", "*/*");
}
//headers
Map<String, String> customHeaders = WebUtils.getCustomHeaders();
customHeaders.forEach( (k,v) -> {
connection.addRequestProperty(k, v);
} );
if(!customHeaders.containsKey(WebConstants.HEADER_AUTH_USER)){
AuthUser session = CurrentRuntimeContext.getCurrentUser();
if(session != null){
connection.addRequestProperty(WebConstants.HEADER_AUTH_USER, session.toEncodeString());
}
}
if (request.body() != null) {
if (contentLength != null) {
connection.setFixedLengthStreamingMode(contentLength);
} else {
connection.setChunkedStreamingMode(8196);
}
connection.setDoOutput(true);
OutputStream out = connection.getOutputStream();
if (gzipEncodedRequest) {
out = new GZIPOutputStream(out);
} else if (deflateEncodedRequest) {
out = new DeflaterOutputStream(out);
}
try {
out.write(request.body());
} finally {
try {
out.close();
} catch (IOException suppressed) { // NOPMD
}
}
}
return connection;
}
Response convertResponse(HttpURLConnection connection, Request request) throws IOException {
int status = connection.getResponseCode();
String reason = connection.getResponseMessage();
if (status < 0) {
throw new IOException(format("Invalid status(%s) executing %s %s", status,
connection.getRequestMethod(), connection.getURL()));
}
Map<String, Collection<String>> headers = new LinkedHashMap<String, Collection<String>>();
for (Map.Entry<String, List<String>> field : connection.getHeaderFields().entrySet()) {
// response message
if (field.getKey() != null) {
headers.put(field.getKey(), field.getValue());
}
}
Integer length = connection.getContentLength();
if (length == -1) {
length = null;
}
InputStream stream;
if (status >= 400) {
stream = connection.getErrorStream();
} else {
stream = connection.getInputStream();
}
return Response.builder()
.status(status)
.reason(reason)
.headers(headers)
.request(request)
.body(stream, length)
.build();
}
}
| 2,389 |
763 | package org.batfish.datamodel.packet_policy;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo;
import com.google.common.collect.ImmutableSet;
import com.google.common.testing.EqualsTester;
import org.apache.commons.lang3.SerializationUtils;
import org.batfish.common.util.BatfishObjectMapper;
import org.junit.Test;
/** Tests of {@link FibLookupOutgoingInterfaceIsOneOf} */
public class FibLookupOutgoingInterfaceIsOneOfTest {
@Test
public void testEquals() {
FibLookupOutgoingInterfaceIsOneOf expr =
new FibLookupOutgoingInterfaceIsOneOf(IngressInterfaceVrf.instance(), ImmutableSet.of());
new EqualsTester()
.addEqualityGroup(
expr,
expr,
new FibLookupOutgoingInterfaceIsOneOf(
IngressInterfaceVrf.instance(), ImmutableSet.of()))
.addEqualityGroup(
new FibLookupOutgoingInterfaceIsOneOf(new LiteralVrfName("foo"), ImmutableSet.of()))
.addEqualityGroup(
new FibLookupOutgoingInterfaceIsOneOf(
IngressInterfaceVrf.instance(), ImmutableSet.of("Iface")))
.addEqualityGroup(new Object())
.testEquals();
}
@Test
public void testJavaSerialization() {
FibLookupOutgoingInterfaceIsOneOf expr =
new FibLookupOutgoingInterfaceIsOneOf(IngressInterfaceVrf.instance(), ImmutableSet.of());
assertThat(SerializationUtils.clone(expr), equalTo(expr));
}
@Test
public void testJsonSerialization() {
FibLookupOutgoingInterfaceIsOneOf expr =
new FibLookupOutgoingInterfaceIsOneOf(
IngressInterfaceVrf.instance(), ImmutableSet.of("iface"));
assertThat(
BatfishObjectMapper.clone(expr, FibLookupOutgoingInterfaceIsOneOf.class), equalTo(expr));
}
}
| 692 |
330 | <gh_stars>100-1000
package org.enso.interpreter.node.expression.literal;
import com.oracle.truffle.api.frame.VirtualFrame;
import com.oracle.truffle.api.nodes.NodeInfo;
import org.enso.compiler.core.IR;
import org.enso.compiler.core.IR$Literal$Text;
import org.enso.interpreter.node.ExpressionNode;
import org.enso.interpreter.runtime.data.text.Text;
import org.enso.interpreter.runtime.tag.Patchable;
/** Node representing a constant String value. */
@NodeInfo(shortName = "StringLiteral", description = "Constant string literal expression")
public class TextLiteralNode extends ExpressionNode implements Patchable {
private final Text value;
private TextLiteralNode(String value) {
this.value = Text.create(value);
}
/**
* Creates an instance of this node.
*
* @param value the textual value to represent
* @return a node representing the literal {@code value}
*/
public static TextLiteralNode build(String value) {
return new TextLiteralNode(value);
}
/**
* Returns the constant value of this string literal.
*
* @param frame the stack frame for execution
* @return the string value this node was created with
*/
@Override
public Text executeGeneric(VirtualFrame frame) {
return value;
}
@Override
public Object parsePatch(IR.Expression ir) {
if (ir instanceof IR$Literal$Text t) {
return Text.create(t.text());
}
return null;
}
}
| 467 |
14,668 | // 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.
#ifndef COMPONENTS_CRONET_ANDROID_CRONET_INTEGRATED_MODE_STATE_H_
#define COMPONENTS_CRONET_ANDROID_CRONET_INTEGRATED_MODE_STATE_H_
#include "base/task/thread_pool/thread_pool_instance.h"
namespace cronet {
/**
* Set a shared network task runner into Cronet in integrated mode. All the
* Cronet network tasks would be running in this task runner. This method should
* be invoked in native side before creating Cronet instance.
*/
void SetIntegratedModeNetworkTaskRunner(
base::SingleThreadTaskRunner* network_task_runner);
/**
* Get the task runner for Cronet integrated mode. It would be invoked in the
* initialization of CronetURLRequestContext. This method must be invoked after
* SetIntegratedModeNetworkTaskRunner.
*/
base::SingleThreadTaskRunner* GetIntegratedModeNetworkTaskRunner();
} // namespace cronet
#endif // COMPONENTS_CRONET_ANDROID_CRONET_INTEGRATED_MODE_STATE_H_
| 317 |
376 | #pragma once
#include <Register/Utility.hpp>
namespace Kvasir {
//General Purpose Input_Output Port (PK)
namespace PkData{ ///<PK Data Register
using Addr = Register::Address<0x400c0a00,0xfffffffc,0x00000000,unsigned>;
///PK0
constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::ReadWriteAccess,unsigned> pk0{};
///PK1
constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::ReadWriteAccess,unsigned> pk1{};
}
namespace PkCr{ ///<PK Control Register
using Addr = Register::Address<0x400c0a04,0xfffffffc,0x00000000,unsigned>;
///PK0C
constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::ReadWriteAccess,unsigned> pk0c{};
///PK1C
constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::ReadWriteAccess,unsigned> pk1c{};
}
namespace PkFr1{ ///<PK Function Register 1
using Addr = Register::Address<0x400c0a08,0xfffffffc,0x00000000,unsigned>;
///PK0F1
constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> pk0f1{};
///PK1F1
constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::ReadWriteAccess,unsigned> pk1f1{};
}
namespace PkOd{ ///<PK Open Drain Control Register
using Addr = Register::Address<0x400c0a28,0xfffffffc,0x00000000,unsigned>;
///PK0OD
constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::ReadWriteAccess,unsigned> pk0od{};
///PK1OD
constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::ReadWriteAccess,unsigned> pk1od{};
}
namespace PkPup{ ///<PK Pull-Up Control Register
using Addr = Register::Address<0x400c0a2c,0xfffffffc,0x00000000,unsigned>;
///PK0UP
constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::ReadWriteAccess,unsigned> pk0up{};
///PK1UP
constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::ReadWriteAccess,unsigned> pk1up{};
}
namespace PkPkn{ ///<PK Pull-Down Control Register
using Addr = Register::Address<0x400c0a30,0xfffffffc,0x00000000,unsigned>;
///PK0DN
constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::ReadWriteAccess,unsigned> pk0dn{};
///PK1DN
constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::ReadWriteAccess,unsigned> pk1dn{};
}
namespace PkIe{ ///<PK Input Enable Control Register
using Addr = Register::Address<0x400c0a38,0xfffffffc,0x00000000,unsigned>;
///PK0IE
constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::ReadWriteAccess,unsigned> pk0ie{};
///PK1IE
constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::ReadWriteAccess,unsigned> pk1ie{};
}
}
| 1,263 |
1,792 | package org.hongxi.whatsmars.common.profile;
public class ProfileUtils {
private static final String PROFILE_ENV_NAME = "PROFILE";
private static final String DEFAULT_PROFILE = "test";
public static String getProfile() {
String profile = System.getProperty(PROFILE_ENV_NAME);
return profile == null || profile.trim().length() == 0 ? DEFAULT_PROFILE : profile;
}
}
| 135 |
32,544 | package com.baeldung.junit5.templates;
public class UserIdGeneratorTestCase {
private String displayName;
private boolean isFeatureEnabled;
private String firstName;
private String lastName;
private String expectedUserId;
public UserIdGeneratorTestCase(String displayName, boolean isFeatureEnabled, String firstName, String lastName, String expectedUserId) {
this.displayName = displayName;
this.isFeatureEnabled = isFeatureEnabled;
this.firstName = firstName;
this.lastName = lastName;
this.expectedUserId = expectedUserId;
}
public String getDisplayName() {
return displayName;
}
public boolean isFeatureEnabled() {
return isFeatureEnabled;
}
public String getFirstName() {
return firstName;
}
public String getLastName() {
return lastName;
}
public String getExpectedUserId() {
return expectedUserId;
}
}
| 344 |
3,432 | <gh_stars>1000+
package org.telegram.abilitybots.api.sender;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.telegram.telegrambots.meta.api.methods.BotApiMethod;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import org.telegram.telegrambots.meta.api.objects.Message;
import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
import org.telegram.telegrambots.meta.exceptions.TelegramApiRequestException;
import org.telegram.telegrambots.meta.updateshandlers.SentCallback;
import java.util.Optional;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.*;
class SilentSenderTest {
private SilentSender silent;
private MessageSender sender;
@BeforeEach
void setUp() {
sender = mock(MessageSender.class);
silent = new SilentSender(sender);
}
@Test
void returnsEmptyOnError() throws TelegramApiException {
when(sender.execute(any())).thenThrow(TelegramApiException.class);
Optional execute = silent.execute(null);
assertFalse(execute.isPresent(), "Execution of a bot API method with execption results in a nonempty optional");
}
@Test
void returnOptionalOnSuccess() throws TelegramApiException {
String data = "data";
when(sender.execute(any())).thenReturn(data);
Optional execute = silent.execute(null);
assertEquals(data, execute.get(), "Silent execution resulted in a different object");
}
@Test
void callsAsyncVariantOfExecute() throws TelegramApiException {
SendMessage methodObject = new SendMessage();
NoOpCallback callback = new NoOpCallback();
silent.executeAsync(methodObject, callback);
verify(sender, only()).executeAsync(methodObject, callback);
}
private class NoOpCallback implements SentCallback<Message> {
@Override
public void onResult(BotApiMethod<Message> method, Message response) {
}
@Override
public void onError(BotApiMethod<Message> method, TelegramApiRequestException apiException) {
}
@Override
public void onException(BotApiMethod<Message> method, Exception exception) {
}
}
;
} | 718 |
1,351 | <reponame>cmcfarlen/trafficserver<gh_stars>1000+
/** @file
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.
*/
/**
* @file test_content_range.cc
* @brief Unit test for slice ContentRange
*/
#define CATCH_CONFIG_MAIN /* include main function */
#include "../Config.h"
#include "catch.hpp" /* catch unit-test framework */
#include <array>
#include <getopt.h>
TEST_CASE("config default", "[AWS][slice][utility]")
{
Config const config;
int64_t const defval = Config::blockbytesdefault;
CHECK(defval == config.m_blockbytes);
}
TEST_CASE("config bytesfrom valid parsing", "[AWS][slice][utility]")
{
static std::array<std::string, 6> const teststrings = {{
"1000",
"1m",
"5g",
"2k",
"3kb",
"1z",
}};
constexpr std::array<int64_t, 6> const expvals = {{
1000,
1024 * 1024,
int64_t(1024) * 1024 * 1024 * 5,
1024 * 2,
1024 * 3,
1,
}};
for (size_t index = 0; index < teststrings.size(); ++index) {
std::string const &teststr = teststrings[index];
int64_t const &exp = expvals[index];
int64_t const got = Config::bytesFrom(teststr.c_str());
CHECK(got == exp);
if (got != exp) {
INFO(teststr.c_str());
}
}
}
TEST_CASE("config bytesfrom invalid parsing", "[AWS][slice][utility]")
{
static std::array<std::string, 5> const badstrings = {{
"abc", // alpha
"g00", // giga
"M00", // mega
"k00", // kilo
"-500", // negative
}};
for (std::string const &badstr : badstrings) {
int64_t const val = Config::bytesFrom(badstr.c_str());
CHECK(0 == val);
if (0 != val) {
INFO(badstr.c_str());
}
}
}
TEST_CASE("config fromargs validate sizes", "[AWS][slice][utility]")
{
char const *const appname = "slice.so";
int64_t blockBytesMax = 128 * 1024 * 1024, blockBytesMin = 256 * 1024;
CHECK(blockBytesMax == Config::blockbytesmax);
CHECK(blockBytesMin == Config::blockbytesmin);
std::vector<std::string> const argkws = {"-b ", "--blockbytes=", "blockbytes:"};
std::vector<std::pair<std::string, bool>> const tests = {{"4m", true},
{"1", false},
{"32m", true},
{"64m", true},
{"256k", true},
{"128m", true},
{"10m", true},
{std::to_string(blockBytesMax), true},
{std::to_string(blockBytesMax + 1), false},
{std::to_string(blockBytesMax - 1), true},
{std::to_string(blockBytesMin), true},
{std::to_string(blockBytesMin + 1), true},
{std::to_string(blockBytesMin - 1), false}};
for (std::string const &kw : argkws) { // test each argument keyword with each test pair
for (std::pair<std::string, bool> const &test : tests) {
// getopt uses global variables; ensure the index is reset each iteration
optind = 0;
// set up args
std::vector<char *> argv;
std::string arg = kw + test.first;
argv.push_back((char *)appname);
argv.push_back((char *)arg.c_str());
// configure slice
Config *const config = new Config;
config->fromArgs(argv.size(), argv.data());
// validate that the configured m_blockbytes are what we expect
CHECK(test.second == (config->m_blockbytes != config->blockbytesdefault));
// failed; print additional info
if (test.second != (config->m_blockbytes != config->blockbytesdefault)) {
INFO(test.first.c_str());
INFO(config->m_blockbytes);
}
// validate that the result of bytesFrom aligns with the current value of config->m_blockbytes as expected
int64_t const blockbytes = config->bytesFrom(test.first.c_str());
CHECK(test.second == (config->m_blockbytes == blockbytes));
// failed; print additional info
if (test.second != (config->m_blockbytes == blockbytes)) {
INFO(blockbytes);
INFO(config->m_blockbytes);
}
delete config;
}
}
}
| 2,367 |
428 | <reponame>ishine/pase<filename>setup.py
from setuptools import setup
setup(
name='PASE',
version='0.1.1-dev',
packages=['pase', 'pase.models', 'pase.models.WorkerScheduler', 'pase.models.Minions'],
)
| 91 |
438 | <filename>src/languages/es-ES/fun/meme.json
{
"DESCRIPTION": "Envia un meme aleatorio.",
"USAGE": "meme",
"TITLE": "De {{SUBREDDIT}}",
"FOOTER": "👍 {{UPVOTES}} 👎 {{DOWNVOTES}}"
}
| 90 |
1,408 | package com.pancm;
/**
* @author pancm
* @Title: springboot-study
* @Description:
* @Version:1.0.0
* @Since:jdk1.8
* @date 2020/9/21
*/
public class TaskTest {
}
| 70 |
348 | {"nom":"Saint-Sorlin-en-Valloire","circ":"4ème circonscription","dpt":"Drôme","inscrits":1589,"abs":754,"votants":835,"blancs":16,"nuls":3,"exp":816,"res":[{"nuance":"LR","nom":"Mme <NAME>","voix":250},{"nuance":"FN","nom":"M. <NAME>","voix":154},{"nuance":"REM","nom":"Mme <NAME>","voix":152},{"nuance":"SOC","nom":"<NAME>","voix":124},{"nuance":"FI","nom":"Mme <NAME>","voix":71},{"nuance":"ECO","nom":"Mme <NAME>","voix":23},{"nuance":"COM","nom":"<NAME>","voix":22},{"nuance":"DVD","nom":"<NAME>","voix":7},{"nuance":"DIV","nom":"Mme <NAME>","voix":4},{"nuance":"EXG","nom":"Mme <NAME>","voix":3},{"nuance":"DIV","nom":"Mme <NAME>","voix":3},{"nuance":"DVD","nom":"M. <NAME>","voix":1},{"nuance":"DVD","nom":"<NAME>","voix":1},{"nuance":"EXD","nom":"Mme <NAME>","voix":1},{"nuance":"DVG","nom":"Mme <NAME>","voix":0}]} | 335 |
2,701 | <gh_stars>1000+
/*
* Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
* SPDX-License-Identifier: Apache-2.0
*
* 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 ARC4_ALT_H
#define ARC4_ALT_H
#ifdef __cplusplus
extern "C" {
#endif
#if defined(MBEDTLS_ARC4_ALT)
#include "esp_arc4.h"
typedef esp_arc4_context mbedtls_arc4_context;
#define mbedtls_arc4_init(_ctx) { }
#define mbedtls_arc4_free(_ctx) { }
#define mbedtls_arc4_setup(_ctx, _s, _l) esp_arc4_setup(_ctx, _s, _l)
#define mbedtls_arc4_crypt(_ctx, _l, _i, _o) esp_arc4_encrypt(_ctx, _l, _i, _o)
#endif /* MBEDTLS_ARC4_ALT */
#ifdef __cplusplus
}
#endif
#endif
| 491 |
679 | /**************************************************************
*
* 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.
*
*************************************************************/
#ifndef SC_ADDIN_HXX
#define SC_ADDIN_HXX
#include <com/sun/star/sheet/XAddIn.hpp>
#include <com/sun/star/lang/XServiceName.hpp>
#include <com/sun/star/lang/XServiceInfo.hpp>
#include <stardiv/starcalc/test/XTestAddIn.hpp>
#include <cppuhelper/implbase4.hxx> // helper for implementations
com::sun::star::uno::Reference<com::sun::star::uno::XInterface> ScTestAddIn_CreateInstance(
const com::sun::star::uno::Reference<com::sun::star::lang::XMultiServiceFactory>& );
class ScTestAddIn : public cppu::WeakImplHelper4<
com::sun::star::sheet::XAddIn,
stardiv::starcalc::test::XTestAddIn,
com::sun::star::lang::XServiceName,
com::sun::star::lang::XServiceInfo >
{
private:
com::sun::star::uno::Reference<com::sun::star::sheet::XVolatileResult> xAlphaResult; //! Test
com::sun::star::uno::Reference<com::sun::star::sheet::XVolatileResult> xNumResult; //! Test
com::sun::star::lang::Locale aFuncLoc;
public:
ScTestAddIn();
virtual ~ScTestAddIn();
// SMART_UNO_DECLARATION( ScTestAddIn, UsrObject );
// friend Reflection * ScTestAddIn_getReflection();
// virtual BOOL queryInterface( Uik, XInterfaceRef& );
// virtual XIdlClassRef getIdlClass(void);
static UString getImplementationName_Static();
static ::com::sun::star::uno::Sequence< ::rtl::OUString > getSupportedServiceNames_Static();
// XAddIn
virtual ::rtl::OUString SAL_CALL getProgrammaticFuntionName( const ::rtl::OUString& aDisplayName ) throw(::com::sun::star::uno::RuntimeException);
virtual ::rtl::OUString SAL_CALL getDisplayFunctionName( const ::rtl::OUString& aProgrammaticName ) throw(::com::sun::star::uno::RuntimeException);
virtual ::rtl::OUString SAL_CALL getFunctionDescription( const ::rtl::OUString& aProgrammaticName ) throw(::com::sun::star::uno::RuntimeException);
virtual ::rtl::OUString SAL_CALL getDisplayArgumentName( const ::rtl::OUString& aProgrammaticFunctionName, sal_Int32 nArgument ) throw(::com::sun::star::uno::RuntimeException);
virtual ::rtl::OUString SAL_CALL getArgumentDescription( const ::rtl::OUString& aProgrammaticFunctionName, sal_Int32 nArgument ) throw(::com::sun::star::uno::RuntimeException);
virtual ::rtl::OUString SAL_CALL getProgrammaticCategoryName( const ::rtl::OUString& aProgrammaticFunctionName ) throw(::com::sun::star::uno::RuntimeException);
virtual ::rtl::OUString SAL_CALL getDisplayCategoryName( const ::rtl::OUString& aProgrammaticFunctionName ) throw(::com::sun::star::uno::RuntimeException);
// XLocalizable
virtual void SAL_CALL setLocale( const ::com::sun::star::lang::Locale& eLocale ) throw(::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::lang::Locale SAL_CALL getLocale( ) throw(::com::sun::star::uno::RuntimeException);
// XTestAddIn
virtual sal_Int32 SAL_CALL countParams( const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any >& aArgs ) throw(::com::sun::star::uno::RuntimeException);
virtual double SAL_CALL addOne( double fValue ) throw(::com::sun::star::uno::RuntimeException);
virtual ::rtl::OUString SAL_CALL repeatStr( const ::rtl::OUString& aStr, sal_Int32 nCount ) throw(::com::sun::star::uno::RuntimeException);
virtual ::rtl::OUString SAL_CALL getDateString( const ::com::sun::star::uno::Reference< ::com::sun::star::beans::XPropertySet >& xCaller, double fValue ) throw(::com::sun::star::uno::RuntimeException);
virtual sal_Int32 SAL_CALL getColorValue( const ::com::sun::star::uno::Reference< ::com::sun::star::table::XCellRange >& xRange ) throw(::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Sequence< double > > SAL_CALL transpose( const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Sequence< double > >& aMatrix ) throw(::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Sequence< sal_Int32 > > SAL_CALL transposeInt( const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Sequence< sal_Int32 > >& aMatrix ) throw(::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::uno::Reference< ::com::sun::star::sheet::XVolatileResult > SAL_CALL callAsync( const ::rtl::OUString& aString ) throw(::com::sun::star::uno::RuntimeException);
virtual ::rtl::OUString SAL_CALL repeatMultiple( sal_Int32 nCount, const ::com::sun::star::uno::Any& aFirst, const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any >& aFollow ) throw(::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::uno::Any SAL_CALL getStrOrVal( sal_Int32 nFlag ) throw(::com::sun::star::uno::RuntimeException);
// XServiceName
virtual ::rtl::OUString SAL_CALL getServiceName( ) throw(::com::sun::star::uno::RuntimeException);
// XServiceInfo
virtual ::rtl::OUString SAL_CALL getImplementationName( ) throw(::com::sun::star::uno::RuntimeException);
virtual sal_Bool SAL_CALL supportsService( const ::rtl::OUString& ServiceName ) throw(::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL getSupportedServiceNames( ) throw(::com::sun::star::uno::RuntimeException);
};
#endif
| 2,055 |
872 | <filename>934 Shortest Bridge.py<gh_stars>100-1000
#!/usr/bin/python3
"""
In a given 2D binary array A, there are two islands. (An island is a
4-directionally connected group of 1s not connected to any other 1s.)
Now, we may change 0s to 1s so as to connect the two islands together to form 1
island.
Return the smallest number of 0s that must be flipped. (It is guaranteed that
the answer is at least 1.)
Example 1:
Input: [[0,1],[1,0]]
Output: 1
Example 2:
Input: [[0,1,0],[0,0,0],[0,0,1]]
Output: 2
Example 3:
Input: [[1,1,1,1,1],[1,0,0,0,1],[1,0,1,0,1],[1,0,0,0,1],[1,1,1,1,1]]
Output: 1
Note:
1 <= A.length = A[0].length <= 100
A[i][j] == 0 or A[i][j] == 1
"""
from typing import List
dirs = ((0, -1), (0, 1), (-1, 0), (1, 0))
class Solution:
def shortestBridge(self, A: List[List[int]]) -> int:
"""
market component 1 and component 2
iterate 0 and BFS, min(dist1 + dist2 - 1)?
O(N * N) high complexity
BFS grow from 1 component
"""
m, n = len(A), len(A[0])
# coloring
colors = [[None for _ in range(n)] for _ in range(m)]
color = 0
for i in range(m):
for j in range(n):
if A[i][j] == 1 and colors[i][j] is None:
self.dfs(A, i, j, colors, color)
color += 1
assert color == 2
# BFS
step = 0
q = []
visited = [[False for _ in range(n)] for _ in range(m)]
for i in range(m):
for j in range(n):
if colors[i][j] == 0:
visited[i][j] = True
q.append((i, j))
while q:
cur_q = []
for i, j in q:
for I, J in self.nbr(A, i, j):
if not visited[I][J]:
if colors[I][J] == None:
visited[I][J] = True # pre-check, dedup
cur_q.append((I, J))
elif colors[I][J] == 1:
return step
step += 1
q = cur_q
raise
def nbr(self, A, i, j):
m, n = len(A), len(A[0])
for di, dj in dirs:
I = i + di
J = j + dj
if 0 <= I < m and 0 <= J < n:
yield I, J
def dfs(self, A, i, j, colors, color):
colors[i][j] = color
for I, J in self.nbr(A, i, j):
if colors[I][J] is None and A[I][J] == 1:
self.dfs(A, I, J, colors, color)
if __name__ == "__main__":
assert Solution().shortestBridge([[1,1,1,1,1],[1,0,0,0,1],[1,0,1,0,1],[1,0,0,0,1],[1,1,1,1,1]]) == 1
| 1,468 |
907 | // Copyright 2017 <NAME>. All rights reserved.
// Use of this source code is governed by the MIT license that can be found in
// the LICENSE file.
zval *_value_init() {
zval *tmp = malloc(sizeof(zval));
ZVAL_NULL(tmp);
return tmp;
}
// Destroy and free engine value.
void _value_destroy(engine_value *val) {
zval_dtor(val->internal);
free(val->internal);
free(val);
}
int _value_truth(zval *val) {
return (Z_TYPE_P(val) == IS_TRUE) ? 1 : ((Z_TYPE_P(val) == IS_FALSE) ? 0 : -1);
}
void _value_set_string(zval **val, char *str) {
ZVAL_STRING(*val, str);
}
static int _value_current_key_get(HashTable *ht, zend_string **str_index, zend_ulong *num_index) {
return zend_hash_get_current_key(ht, str_index, num_index);
}
static void _value_current_key_set(HashTable *ht, engine_value *val) {
zval tmp;
zend_hash_get_current_key_zval(ht, &tmp);
add_next_index_zval(val->internal, &tmp);
}
static void _value_array_next_get(HashTable *ht, engine_value *val) {
zval *tmp = NULL;
if ((tmp = zend_hash_get_current_data(ht)) != NULL) {
value_set_zval(val, tmp);
zend_hash_move_forward(ht);
}
}
static void _value_array_index_get(HashTable *ht, unsigned long index, engine_value *val) {
zval *tmp = NULL;
if ((tmp = zend_hash_index_find(ht, index)) != NULL) {
value_set_zval(val, tmp);
}
}
static void _value_array_key_get(HashTable *ht, char *key, engine_value *val) {
zval *tmp = NULL;
zend_string *str = zend_string_init(key, strlen(key), 0);
if ((tmp = zend_hash_find(ht, str)) != NULL) {
value_set_zval(val, tmp);
}
zend_string_release(str);
}
| 642 |
561 | <reponame>ddesmond/gaffer<gh_stars>100-1000
//////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2019, Cinesite VFX Ltd. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// * 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.
//
// * Neither the name of Cinesite VFX Ltd. nor the names of any
// other contributors to this software 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.
//
//////////////////////////////////////////////////////////////////////////
#ifndef GAFFEROSL_SHADINGENGINEALGO_H
#define GAFFEROSL_SHADINGENGINEALGO_H
#include "GafferOSL/ShadingEngine.h"
namespace GafferOSL
{
/// ShadingEngineAlgo provides convenience functions to aid the use of
/// GafferOSL::ShadingEngine.
namespace ShadingEngineAlgo
{
/// Returns an RGB CompoundData image representation of the specified shading
/// network output. The output doesn't have to be the networks output and can
/// reference the output of any shader within the network that can be connected
/// to a color input. A copy of the network is taken for shading. Return is as
/// per shadedPointsToImageData, may throw as per ShadingEngine::shade.
///
/// Note: P is set to ( 0, 0, 0 ) for all shading points.
///
/// Note: Shading carried out by this method is not cancellable, and uses a
/// default context. As such, any shaders in the network that query time
/// will use the default frame of 1. This is to allow use in cancel-unaware
/// code paths.
GAFFEROSL_API IECore::CompoundDataPtr shadeUVTexture(
const IECoreScene::ShaderNetwork *shaderNetwork,
const Imath::V2i &resolution,
IECoreScene::ShaderNetwork::Parameter output = IECoreScene::ShaderNetwork::Parameter()
);
}
}
#endif // GAFFEROSL_SHADINGENGINEALGO_H
| 898 |
4,935 | #ifndef ASYNC_BATON
#define ASYNC_BATON
#include <condition_variable>
#include <memory>
#include <mutex>
#include <nan.h>
#include "lock_master.h"
#include "nodegit.h"
#include "thread_pool.h"
namespace nodegit {
// Base class for Batons used for callbacks (for example,
// JS functions passed as callback parameters,
// or field properties of configuration objects whose values are callbacks)
class AsyncBaton {
public:
typedef std::function<void(void *)> AsyncCallback;
typedef std::function<void(AsyncBaton *)> CompletionCallback;
AsyncBaton();
AsyncBaton(const AsyncBaton &) = delete;
AsyncBaton(AsyncBaton &&) = delete;
AsyncBaton &operator=(const AsyncBaton &) = delete;
AsyncBaton &operator=(AsyncBaton &&) = delete;
virtual ~AsyncBaton() {}
void Done();
Nan::AsyncResource *GetAsyncResource();
void SetCallbackError(v8::Local<v8::Value> error);
protected:
void ExecuteAsyncPerform(AsyncCallback asyncCallback, AsyncCallback asyncCancelCb, CompletionCallback onCompletion);
private:
void SignalCompletion();
void WaitForCompletion();
Nan::AsyncResource *asyncResource;
Nan::Global<v8::Value> &callbackErrorHandle;
ThreadPool::Callback onCompletion;
std::unique_ptr<std::mutex> completedMutex;
std::condition_variable completedCondition;
bool hasCompleted;
};
void deleteBaton(AsyncBaton *baton);
template<typename ResultT>
class AsyncBatonWithResult : public AsyncBaton {
public:
ResultT defaultResult; // result returned if the callback doesn't return anything valid
ResultT result;
AsyncBatonWithResult(const ResultT &defaultResult)
: defaultResult(defaultResult) {
}
ResultT ExecuteAsync(AsyncBaton::AsyncCallback asyncCallback, AsyncBaton::AsyncCallback asyncCancelCb, AsyncBaton::CompletionCallback onCompletion = nullptr) {
result = 0;
ExecuteAsyncPerform(asyncCallback, asyncCancelCb, onCompletion);
return result;
}
};
class AsyncBatonWithNoResult : public AsyncBaton {
public:
void ExecuteAsync(AsyncBaton::AsyncCallback asyncCallback, AsyncBaton::AsyncCallback asyncCancelCb, AsyncBaton::CompletionCallback onCompletion = nullptr) {
ExecuteAsyncPerform(asyncCallback, asyncCancelCb, onCompletion);
}
};
}
#endif
| 854 |
308 | from ddtrace import config
from .. import trace_utils
from ...constants import ANALYTICS_SAMPLE_RATE_KEY
from ...constants import SPAN_MEASURED_KEY
from ...ext import SpanTypes
from ...ext import http
from ...internal.compat import stringify
from ..asyncio import context_provider
CONFIG_KEY = "datadog_trace"
REQUEST_CONTEXT_KEY = "datadog_context"
REQUEST_CONFIG_KEY = "__datadog_trace_config"
REQUEST_SPAN_KEY = "__datadog_request_span"
async def trace_middleware(app, handler):
"""
``aiohttp`` middleware that traces the handler execution.
Because handlers are run in different tasks for each request, we attach the Context
instance both to the Task and to the Request objects. In this way:
* the Task is used by the internal automatic instrumentation
* the ``Context`` attached to the request can be freely used in the application code
"""
async def attach_context(request):
# application configs
tracer = app[CONFIG_KEY]["tracer"]
service = app[CONFIG_KEY]["service"]
distributed_tracing = app[CONFIG_KEY]["distributed_tracing_enabled"]
# Create a new context based on the propagated information.
trace_utils.activate_distributed_headers(
tracer,
int_config=config.aiohttp,
request_headers=request.headers,
override=distributed_tracing,
)
# trace the handler
request_span = tracer.trace(
"aiohttp.request",
service=service,
span_type=SpanTypes.WEB,
)
request_span.set_tag(SPAN_MEASURED_KEY)
# Configure trace search sample rate
# DEV: aiohttp is special case maintains separate configuration from config api
analytics_enabled = app[CONFIG_KEY]["analytics_enabled"]
if (config.analytics_enabled and analytics_enabled is not False) or analytics_enabled is True:
request_span.set_tag(ANALYTICS_SAMPLE_RATE_KEY, app[CONFIG_KEY].get("analytics_sample_rate", True))
# attach the context and the root span to the request; the Context
# may be freely used by the application code
request[REQUEST_CONTEXT_KEY] = request_span.context
request[REQUEST_SPAN_KEY] = request_span
request[REQUEST_CONFIG_KEY] = app[CONFIG_KEY]
try:
response = await handler(request)
return response
except Exception:
request_span.set_traceback()
raise
return attach_context
async def on_prepare(request, response):
"""
The on_prepare signal is used to close the request span that is created during
the trace middleware execution.
"""
# safe-guard: discard if we don't have a request span
request_span = request.get(REQUEST_SPAN_KEY, None)
if not request_span:
return
# default resource name
resource = stringify(response.status)
if request.match_info.route.resource:
# collect the resource name based on http resource type
res_info = request.match_info.route.resource.get_info()
if res_info.get("path"):
resource = res_info.get("path")
elif res_info.get("formatter"):
resource = res_info.get("formatter")
elif res_info.get("prefix"):
resource = res_info.get("prefix")
# prefix the resource name by the http method
resource = "{} {}".format(request.method, resource)
request_span.resource = resource
# DEV: aiohttp is special case maintains separate configuration from config api
trace_query_string = request[REQUEST_CONFIG_KEY].get("trace_query_string")
if trace_query_string is None:
trace_query_string = config.http.trace_query_string
if trace_query_string:
request_span.set_tag(http.QUERY_STRING, request.query_string)
trace_utils.set_http_meta(
request_span,
config.aiohttp,
method=request.method,
url=str(request.url), # DEV: request.url is a yarl's URL object
status_code=response.status,
request_headers=request.headers,
response_headers=response.headers,
)
request_span.finish()
def trace_app(app, tracer, service="aiohttp-web"):
"""
Tracing function that patches the ``aiohttp`` application so that it will be
traced using the given ``tracer``.
:param app: aiohttp application to trace
:param tracer: tracer instance to use
:param service: service name of tracer
"""
# safe-guard: don't trace an application twice
if getattr(app, "__datadog_trace", False):
return
setattr(app, "__datadog_trace", True)
# configure datadog settings
app[CONFIG_KEY] = {
"tracer": tracer,
"service": config._get_service(default=service),
"distributed_tracing_enabled": None,
"analytics_enabled": None,
"analytics_sample_rate": 1.0,
}
# the tracer must work with asynchronous Context propagation
tracer.configure(context_provider=context_provider)
# add the async tracer middleware as a first middleware
# and be sure that the on_prepare signal is the last one
app.middlewares.insert(0, trace_middleware)
app.on_response_prepare.append(on_prepare)
| 2,000 |
7,706 | <filename>common/src/main/java/com/google/tsunami/common/version/Token.java
/*
* Copyright 2020 Google LLC
*
* 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.google.tsunami.common.version;
import com.google.auto.value.AutoOneOf;
import com.google.common.base.Ascii;
import com.google.errorprone.annotations.Immutable;
/**
* Represents a token from a version string.
*
* <p>A token is the smallest meaningful piece of a version string. For example, there are 3 tokens
* in version 2.1.1: [token(2), token(1), token(1)].
*/
@Immutable
@AutoOneOf(Token.Kind.class)
abstract class Token implements Comparable<Token> {
static final Token EMPTY = Token.fromKnownQualifier(KnownQualifier.ABSENT);
/** All types of a token, required by the AutoOneOf annotation. */
public enum Kind {
NUMERIC,
TEXT
}
abstract Kind getKind();
abstract long getNumeric();
static Token fromNumeric(long numeric) {
return AutoOneOf_Token.numeric(numeric);
}
boolean isNumeric() {
return getKind().equals(Kind.NUMERIC);
}
abstract String getText();
static Token fromText(String string) {
return AutoOneOf_Token.text(Ascii.toLowerCase(string));
}
boolean isText() {
return getKind().equals(Kind.TEXT);
}
static Token fromKnownQualifier(KnownQualifier knownQualifier) {
return AutoOneOf_Token.text(knownQualifier.getQualifierText());
}
boolean isKnownQualifier() {
return isText() && KnownQualifier.isKnownQualifier(getText());
}
boolean isEmptyToken() {
return isText() && getText().isEmpty();
}
@Override
public int compareTo(Token other) {
// Empty tokens are always the same.
if (this.isEmptyToken() && other.isEmptyToken()) {
return 0;
}
/*
* If the tokens under comparison are one Empty token and one Numeric token, then Empty token
* should always be less than Numeric token, e.g. version 2.1 is less than 2.1.1 (i.e.
* 2.1.empty < 2.1.1, empty < 1).
*/
if (this.isEmptyToken() && other.isNumeric()) {
return -1;
}
if (this.isNumeric() && other.isEmptyToken()) {
return 1;
}
/*
* For Numeric and Text tokens, we follow the specification from http://semver.org#spec-item-11:
* 1. Numeric tokens are compared numerically.
* 2. Text tokens are compared lexically, case insensitively.
* 3. Numeric identifiers always have lower precedence than non-numeric identifiers.
*
* For all the known qualifiers, we apply the comparison rules defined by KnownQualifier.
*/
if (this.isNumeric() && other.isNumeric()) {
return Long.compare(this.getNumeric(), other.getNumeric());
}
if (this.isKnownQualifier() && other.isKnownQualifier()) {
return KnownQualifier.fromText(this.getText())
.compareTo(KnownQualifier.fromText(other.getText()));
}
if (this.isText() && other.isText()) {
return this.getText().compareToIgnoreCase(other.getText());
}
// Cross type comparison, Numeric token is always less than Text tokens.
return this.getKind().compareTo(other.getKind());
}
}
| 1,198 |
4,772 | <reponame>fjacobs/spring-data-examples
package example.repo;
import example.model.Customer1646;
import java.util.List;
import org.springframework.data.repository.CrudRepository;
public interface Customer1646Repository extends CrudRepository<Customer1646, Long> {
List<Customer1646> findByLastName(String lastName);
}
| 103 |
385 | /*
This file is generated from version {{revision}}.
*/
#pragma ACME revision * echo v2018.10
#pragma ACME revision acme/test/revision cat input.h | wc -c
#pragma ACME stats wc wc -l
#pragma ACME stats files ls dummy | wc -l
// This particular file has exactly {{revision:acme/test/revision}} bytes,
// while there's {{stats:files}} more processed file with {{stats:wc}} lines.
| 132 |
945 | /*=========================================================================
*
* Copyright NumFOCUS
*
* 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.txt
*
* 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 "itkVersorRigid3DTransform.h"
#include "itkCenteredTransformInitializer.h"
#include "itkImageRegionIterator.h"
namespace
{
constexpr unsigned int Dimension = 3;
// This function assumes that the center of mass of both images is the
// geometrical center.
template <typename TFixedImage, typename TMovingImage>
bool
RunTest(itk::SmartPointer<TFixedImage> fixedImage, itk::SmartPointer<TMovingImage> movingImage)
{
using FixedImageType = TFixedImage;
using MovingImageType = TMovingImage;
bool pass = true;
// Transform Type
using TransformType = itk::VersorRigid3DTransform<double>;
// calculate image centers
TransformType::InputPointType fixedCenter;
TransformType::InputPointType movingCenter;
using ContinuousIndexType = itk::ContinuousIndex<double, Dimension>;
const typename FixedImageType::RegionType & fixedRegion = fixedImage->GetLargestPossibleRegion();
const typename FixedImageType::SizeType & fixedSize = fixedRegion.GetSize();
const typename FixedImageType::IndexType & fixedIndex = fixedRegion.GetIndex();
ContinuousIndexType fixedCenterIndex;
for (unsigned int i = 0; i < Dimension; ++i)
{
assert(0 < fixedSize[i]);
fixedCenterIndex[i] = static_cast<double>(fixedIndex[i]) + static_cast<double>(fixedSize[i] - 1) / 2.0;
}
fixedImage->TransformContinuousIndexToPhysicalPoint(fixedCenterIndex, fixedCenter);
const typename MovingImageType::RegionType & movingRegion = movingImage->GetLargestPossibleRegion();
const typename MovingImageType::SizeType & movingSize = movingRegion.GetSize();
const typename MovingImageType::IndexType & movingIndex = movingRegion.GetIndex();
ContinuousIndexType movingCenterIndex;
for (unsigned int i = 0; i < Dimension; ++i)
{
assert(0 < movingSize[i]);
movingCenterIndex[i] = static_cast<double>(movingIndex[i]) + static_cast<double>(movingSize[i] - 1) / 2.0;
}
movingImage->TransformContinuousIndexToPhysicalPoint(movingCenterIndex, movingCenter);
TransformType::InputVectorType relativeCenter = movingCenter - fixedCenter;
TransformType::Pointer transform = TransformType::New();
using InitializerType = itk::CenteredTransformInitializer<TransformType, FixedImageType, MovingImageType>;
typename InitializerType::Pointer initializer = InitializerType::New();
initializer->SetFixedImage(fixedImage);
initializer->SetMovingImage(movingImage);
initializer->SetTransform(transform);
transform->SetIdentity();
initializer->GeometryOn();
initializer->InitializeTransform();
std::cout << std::endl << std::endl;
std::cout << "Testing Geometric Mode " << std::endl;
// transform->Print( std::cout );
const TransformType::InputPointType & center1 = transform->GetCenter();
const TransformType::OutputVectorType & translation1 = transform->GetTranslation();
const TransformType::OffsetType & offset1 = transform->GetOffset();
const double tolerance = 1e-3;
// Verfications for the Geometry Mode
for (unsigned int k = 0; k < Dimension; ++k)
{
if (std::fabs(center1[k] - fixedCenter[k]) > tolerance)
{
std::cerr << "Center differs from expected value" << std::endl;
std::cerr << "It should be " << fixedCenter << std::endl;
std::cerr << "but it is " << center1 << std::endl;
pass = false;
break;
}
if (std::fabs(translation1[k] - relativeCenter[k]) > tolerance)
{
std::cerr << "Translation differs from expected value" << std::endl;
std::cerr << "It should be " << relativeCenter << std::endl;
std::cerr << "but it is " << translation1 << std::endl;
pass = false;
break;
}
if (std::fabs(offset1[k] - relativeCenter[k]) > tolerance)
{
std::cerr << "Offset differs from expected value" << std::endl;
std::cerr << "It should be " << relativeCenter << std::endl;
std::cerr << "but it is " << offset1 << std::endl;
pass = false;
break;
}
}
transform->SetIdentity();
initializer->MomentsOn();
initializer->InitializeTransform();
std::cout << std::endl << std::endl;
std::cout << "Testing Moments Mode " << std::endl;
// transform->Print( std::cout );
const TransformType::InputPointType & center2 = transform->GetCenter();
const TransformType::OutputVectorType & translation2 = transform->GetTranslation();
const TransformType::OffsetType & offset2 = transform->GetOffset();
// Verfications for the Moments Mode
for (unsigned int k = 0; k < Dimension; ++k)
{
if (std::fabs(center2[k] - fixedCenter[k]) > tolerance)
{
std::cerr << "Center differs from expected value" << std::endl;
std::cerr << "It should be " << fixedCenter << std::endl;
std::cerr << "but it is " << center2 << std::endl;
pass = false;
break;
}
if (std::fabs(translation2[k] - relativeCenter[k]) > tolerance)
{
std::cerr << "Translation differs from expected value" << std::endl;
std::cerr << "It should be " << relativeCenter << std::endl;
std::cerr << "but it is " << translation2 << std::endl;
pass = false;
break;
}
if (std::fabs(offset2[k] - relativeCenter[k]) > tolerance)
{
std::cerr << "Offset differs from expected value" << std::endl;
std::cerr << "It should be " << relativeCenter << std::endl;
std::cerr << "but it is " << offset2 << std::endl;
pass = false;
break;
}
}
return pass;
}
template <typename TImage>
void
PopulateImage(itk::SmartPointer<TImage> image)
{
image->Allocate();
image->FillBuffer(0);
using ImageType = TImage;
using RegionType = typename ImageType::RegionType;
using SizeType = typename ImageType::SizeType;
using IndexType = typename ImageType::IndexType;
const RegionType & region = image->GetLargestPossibleRegion();
const SizeType & size = region.GetSize();
const IndexType & index = region.GetIndex();
RegionType internalRegion;
SizeType internalSize;
IndexType internalIndex;
constexpr unsigned int border = 20;
assert(2 * border < size[0]);
assert(2 * border < size[1]);
assert(2 * border < size[2]);
internalIndex[0] = index[0] + border;
internalIndex[1] = index[1] + border;
internalIndex[2] = index[2] + border;
internalSize[0] = size[0] - 2 * border;
internalSize[1] = size[1] - 2 * border;
internalSize[2] = size[2] - 2 * border;
internalRegion.SetSize(internalSize);
internalRegion.SetIndex(internalIndex);
using Iterator = itk::ImageRegionIterator<ImageType>;
Iterator it(image, internalRegion);
it.GoToBegin();
while (!it.IsAtEnd())
{
it.Set(200);
++it;
}
}
} // namespace
/**
* This program tests the use of the CenteredTransformInitializer class
*
*
*/
int
itkCenteredTransformInitializerTest(int, char *[])
{
bool pass = true;
std::cout << std::endl << std::endl;
std::cout << "Running tests with itk::Image" << std::endl;
{
// Create Images
using FixedImageType = itk::Image<unsigned char, Dimension>;
using MovingImageType = itk::Image<unsigned char, Dimension>;
using SizeType = FixedImageType::SizeType;
using SpacingType = FixedImageType::SpacingType;
using PointType = FixedImageType::PointType;
using IndexType = FixedImageType::IndexType;
using RegionType = FixedImageType::RegionType;
SizeType size;
size[0] = 100;
size[1] = 100;
size[2] = 60;
PointType fixedOrigin;
fixedOrigin[0] = 0.0;
fixedOrigin[1] = 0.0;
fixedOrigin[2] = 0.0;
PointType movingOrigin;
movingOrigin[0] = 29.0;
movingOrigin[1] = 17.0;
movingOrigin[2] = 13.0;
SpacingType spacing;
spacing[0] = 1.5;
spacing[1] = 1.5;
spacing[2] = 2.5;
IndexType index;
index[0] = 0;
index[1] = 0;
index[2] = 0;
RegionType region;
region.SetSize(size);
region.SetIndex(index);
FixedImageType::Pointer fixedImage = FixedImageType::New();
MovingImageType::Pointer movingImage = MovingImageType::New();
fixedImage->SetRegions(region);
fixedImage->SetSpacing(spacing);
fixedImage->SetOrigin(fixedOrigin);
movingImage->SetRegions(region);
movingImage->SetSpacing(spacing);
movingImage->SetOrigin(movingOrigin);
PopulateImage(fixedImage);
PopulateImage(movingImage);
pass &= RunTest(fixedImage, movingImage);
}
std::cout << std::endl << std::endl;
std::cout << "Running tests with itk::Image" << std::endl;
{
// Create Images
using FixedImageType = itk::Image<unsigned char, Dimension>;
using MovingImageType = itk::Image<unsigned char, Dimension>;
using SizeType = FixedImageType::SizeType;
using SpacingType = FixedImageType::SpacingType;
using PointType = FixedImageType::PointType;
using IndexType = FixedImageType::IndexType;
using RegionType = FixedImageType::RegionType;
using DirectionType = FixedImageType::DirectionType;
SizeType size;
size[0] = 100;
size[1] = 100;
size[2] = 60;
PointType fixedOrigin;
fixedOrigin[0] = 0.0;
fixedOrigin[1] = 0.0;
fixedOrigin[2] = 0.0;
PointType movingOrigin;
movingOrigin[0] = 29.0;
movingOrigin[1] = 17.0;
movingOrigin[2] = 13.0;
SpacingType spacing;
spacing[0] = 1.5;
spacing[1] = 1.5;
spacing[2] = 2.5;
IndexType fixedIndex;
fixedIndex[0] = 0;
fixedIndex[1] = 0;
fixedIndex[2] = 0;
IndexType movingIndex;
movingIndex[0] = 10;
movingIndex[1] = 20;
movingIndex[2] = 30;
RegionType fixedRegion;
fixedRegion.SetSize(size);
fixedRegion.SetIndex(fixedIndex);
RegionType movingRegion;
movingRegion.SetSize(size);
movingRegion.SetIndex(movingIndex);
using VersorType = itk::Versor<itk::SpacePrecisionType>;
VersorType x;
x.SetRotationAroundX(0.5);
VersorType y;
y.SetRotationAroundY(1.0);
VersorType z;
z.SetRotationAroundZ(1.5);
DirectionType fixedDirection = (x * y * z).GetMatrix();
DirectionType movingDirection = (z * y * x).GetMatrix();
FixedImageType::Pointer fixedImage = FixedImageType::New();
MovingImageType::Pointer movingImage = MovingImageType::New();
fixedImage->SetRegions(fixedRegion);
fixedImage->SetSpacing(spacing);
fixedImage->SetOrigin(fixedOrigin);
fixedImage->SetDirection(fixedDirection);
movingImage->SetRegions(movingRegion);
movingImage->SetSpacing(spacing);
movingImage->SetOrigin(movingOrigin);
movingImage->SetDirection(movingDirection);
PopulateImage(fixedImage);
PopulateImage(movingImage);
pass &= RunTest(fixedImage, movingImage);
}
if (!pass)
{
std::cout << "Test FAILED." << std::endl;
return EXIT_FAILURE;
}
std::cout << "Test PASSED." << std::endl;
return EXIT_SUCCESS;
}
| 4,084 |
32,544 | package com.baeldung.okhttp.download;
import okhttp3.Call;
import okhttp3.MediaType;
import okhttp3.OkHttpClient;
import okhttp3.Protocol;
import okhttp3.Request;
import okhttp3.Response;
import okhttp3.ResponseBody;
import org.jetbrains.annotations.NotNull;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;
import java.io.InputStream;
import static org.junit.Assert.assertEquals;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyDouble;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class BinaryFileDownloaderUnitTest {
@Mock
private OkHttpClient client;
@Mock
private BinaryFileWriter writer;
@InjectMocks
private BinaryFileDownloader tested;
@Test
public void givenUrlAndResponse_whenDownload_thenExpectFileWritten() throws Exception {
String url = "http://example.com/file";
Call call = mock(Call.class);
when(client.newCall(any(Request.class))).thenReturn(call);
ResponseBody body = ResponseBody.create("BODY", MediaType.get("application/text"));
Response response = createResponse(url, body);
when(call.execute()).thenReturn(response);
when(writer.write(any(), anyDouble())).thenReturn(1L);
try (BinaryFileDownloader tested = new BinaryFileDownloader(client, writer)) {
long size = tested.download(url);
assertEquals(1L, size);
verify(writer).write(any(InputStream.class), anyDouble());
}
verify(writer).close();
}
@Test(expected = IllegalStateException.class)
public void givenUrlAndResponseWithNullBody_whenDownload_thenExpectIllegalStateException() throws Exception {
String url = "http://example.com/file";
Call call = mock(Call.class);
when(client.newCall(any(Request.class))).thenReturn(call);
Response response = createResponse(url, null);
when(call.execute()).thenReturn(response);
tested.download(url);
verify(writer, times(0)).write(any(InputStream.class), anyDouble());
}
@NotNull
private Response createResponse(String url, ResponseBody body) {
Request request = new Request.Builder().url(url).build();
return new Response.Builder().code(200).request(request).protocol(Protocol.HTTP_2).message("Message").body(body).build();
}
} | 953 |
4,333 | <gh_stars>1000+
"""Semantic adversarial examples
"""
from cleverhans.attacks.attack import Attack
class Semantic(Attack):
"""
Semantic adversarial examples
https://arxiv.org/abs/1703.06857
Note: data must either be centered (so that the negative image can be
made by simple negation) or must be in the interval [-1, 1]
:param model: cleverhans.model.Model
:param center: bool
If True, assumes data has 0 mean so the negative image is just negation.
If False, assumes data is in the interval [0, max_val]
:param max_val: float
Maximum value allowed in the input data
:param sess: optional tf.Session
:param dtypestr: dtype of data
:param kwargs: passed through to the super constructor
"""
def __init__(
self, model, center, max_val=1.0, sess=None, dtypestr="float32", **kwargs
):
super(Semantic, self).__init__(model, sess, dtypestr, **kwargs)
self.center = center
self.max_val = max_val
if hasattr(model, "dataset_factory"):
if "center" in model.dataset_factory.kwargs:
assert center == model.dataset_factory.kwargs["center"]
def generate(self, x, **kwargs):
if self.center:
return -x
return self.max_val - x
| 512 |
877 | <filename>framework/src/main/java/org/checkerframework/framework/type/DefaultTypeHierarchy.java
package org.checkerframework.framework.type;
import java.util.List;
import java.util.Set;
import javax.lang.model.element.AnnotationMirror;
import javax.lang.model.element.ElementKind;
import javax.lang.model.element.ExecutableElement;
import javax.lang.model.element.TypeElement;
import javax.lang.model.type.TypeKind;
import javax.lang.model.util.Types;
import org.checkerframework.common.basetype.BaseTypeChecker;
import org.checkerframework.framework.qual.Covariant;
import org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedArrayType;
import org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedDeclaredType;
import org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedIntersectionType;
import org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedNullType;
import org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedPrimitiveType;
import org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedTypeVariable;
import org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedUnionType;
import org.checkerframework.framework.type.AnnotatedTypeMirror.AnnotatedWildcardType;
import org.checkerframework.framework.type.visitor.AbstractAtmComboVisitor;
import org.checkerframework.framework.util.AnnotatedTypes;
import org.checkerframework.framework.util.AtmCombo;
import org.checkerframework.javacutil.AnnotationUtils;
import org.checkerframework.javacutil.BugInCF;
import org.checkerframework.javacutil.TreeUtils;
import org.checkerframework.javacutil.TypesUtils;
/**
* Default implementation of TypeHierarchy that implements the JLS specification with minor
* deviations as outlined by the Checker Framework manual. Changes to the JLS include forbidding
* covariant array types, raw types, and allowing covariant type arguments depending on various
* options passed to DefaultTypeHierarchy.
*
* <p>Subtyping rules of the JLS can be found in <a
* href="https://docs.oracle.com/javase/specs/jls/se11/html/jls-4.html#jls-4.10">section 4.10,
* "Subtyping"</a>.
*
* <p>Note: The visit methods of this class must be public but it is intended to be used through a
* TypeHierarchy interface reference which will only allow isSubtype to be called. Clients should
* not call the visit methods.
*
* <p>The visit methods return true if the first argument is a subtype of the second argument.
*/
public class DefaultTypeHierarchy extends AbstractAtmComboVisitor<Boolean, Void>
implements TypeHierarchy {
/**
* The type-checker that is associated with this.
*
* <p>Used for processingEnvironment when needed.
*/
protected final BaseTypeChecker checker;
/** The qualifier hierarchy that is associated with this. */
protected final QualifierHierarchy qualifierHierarchy;
/** The equality comparer. */
protected final StructuralEqualityComparer equalityComparer;
/** Whether to ignore raw types. */
protected final boolean ignoreRawTypes;
/** Whether to make array subtyping invariant with respect to array component types. */
protected final boolean invariantArrayComponents;
/** The top annotation of the hierarchy currently being checked. */
protected AnnotationMirror currentTop;
/** Stores the result of isSubtype, if that result is true. */
protected final SubtypeVisitHistory isSubtypeVisitHistory;
/**
* Stores the result of {@link #areEqualInHierarchy(AnnotatedTypeMirror, AnnotatedTypeMirror)} for
* type arguments. Prevents infinite recursion on types that refer to themselves. (Stores both
* true and false results.)
*/
protected final StructuralEqualityVisitHistory areEqualVisitHistory;
/** The Covariant.value field/element. */
final ExecutableElement covariantValueElement;
/**
* Creates a DefaultTypeHierarchy.
*
* @param checker the type-checker that is associated with this
* @param qualifierHierarchy the qualifier hierarchy that is associated with this
* @param ignoreRawTypes whether to ignore raw types
* @param invariantArrayComponents whether to make array subtyping invariant with respect to array
* component types
*/
public DefaultTypeHierarchy(
final BaseTypeChecker checker,
final QualifierHierarchy qualifierHierarchy,
boolean ignoreRawTypes,
boolean invariantArrayComponents) {
this.checker = checker;
this.qualifierHierarchy = qualifierHierarchy;
this.isSubtypeVisitHistory = new SubtypeVisitHistory();
this.areEqualVisitHistory = new StructuralEqualityVisitHistory();
this.equalityComparer = createEqualityComparer();
this.ignoreRawTypes = ignoreRawTypes;
this.invariantArrayComponents = invariantArrayComponents;
covariantValueElement =
TreeUtils.getMethod(Covariant.class, "value", 0, checker.getProcessingEnvironment());
}
/**
* Create the equality comparer.
*
* @return the equality comparer
*/
protected StructuralEqualityComparer createEqualityComparer() {
return new StructuralEqualityComparer(areEqualVisitHistory);
}
/**
* Returns true if subtype {@literal <:} supertype.
*
* <p>This implementation iterates over all top annotations and invokes {@link
* #isSubtype(AnnotatedTypeMirror, AnnotatedTypeMirror, AnnotationMirror)}. Most type systems
* should not override this method, but instead override {@link #isSubtype(AnnotatedTypeMirror,
* AnnotatedTypeMirror, AnnotationMirror)} or some of the {@code visitXXX} methods.
*
* @param subtype expected subtype
* @param supertype expected supertype
* @return true if subtype is a subtype of supertype or equal to it
*/
@Override
public boolean isSubtype(final AnnotatedTypeMirror subtype, final AnnotatedTypeMirror supertype) {
for (final AnnotationMirror top : qualifierHierarchy.getTopAnnotations()) {
if (!isSubtype(subtype, supertype, top)) {
return false;
}
}
return true;
}
/**
* Returns true if {@code subtype <: supertype}, but only for the hierarchy of which {@code top}
* is the top.
*
* @param subtype expected subtype
* @param supertype expected supertype
* @param top the top of the hierarchy for which we want to make a comparison
* @return true if {@code subtype} is a subtype of, or equal to, {@code supertype} in the
* qualifier hierarchy whose top is {@code top}
*/
protected boolean isSubtype(
final AnnotatedTypeMirror subtype,
final AnnotatedTypeMirror supertype,
final AnnotationMirror top) {
assert top != null;
currentTop = top;
return AtmCombo.accept(subtype, supertype, null, this);
}
/**
* Returns error message for the case when two types shouldn't be compared.
*
* @return error message for the case when two types shouldn't be compared
*/
@Override
protected String defaultErrorMessage(
final AnnotatedTypeMirror subtype, final AnnotatedTypeMirror supertype, final Void p) {
return "Incomparable types ("
+ subtype
+ ", "
+ supertype
+ ") visitHistory = "
+ isSubtypeVisitHistory;
}
/**
* Compare the primary annotations of {@code subtype} and {@code supertype}. Neither type can be
* missing annotations.
*
* @param subtype a type that might be a subtype (with respect to primary annotations)
* @param supertype a type that might be a supertype (with respect to primary annotations)
* @return true if the primary annotation on subtype {@literal <:} primary annotation on supertype
* for the current top.
*/
protected boolean isPrimarySubtype(AnnotatedTypeMirror subtype, AnnotatedTypeMirror supertype) {
final AnnotationMirror subtypeAnno = subtype.getAnnotationInHierarchy(currentTop);
final AnnotationMirror supertypeAnno = supertype.getAnnotationInHierarchy(currentTop);
if (checker.getTypeFactory().hasQualifierParameterInHierarchy(supertype, currentTop)
&& checker.getTypeFactory().hasQualifierParameterInHierarchy(subtype, currentTop)) {
// If the types have a class qualifier parameter, the qualifiers must be equivalent.
return qualifierHierarchy.isSubtype(subtypeAnno, supertypeAnno)
&& qualifierHierarchy.isSubtype(supertypeAnno, subtypeAnno);
}
return qualifierHierarchy.isSubtype(subtypeAnno, supertypeAnno);
}
/**
* Like {@link #isSubtype(AnnotatedTypeMirror, AnnotatedTypeMirror)}, but uses a cache to prevent
* infinite recursion on recursive types.
*
* @param subtype a type that may be a subtype
* @param supertype a type that may be a supertype
* @return true if subtype {@literal <:} supertype
*/
protected boolean isSubtypeCaching(
final AnnotatedTypeMirror subtype, final AnnotatedTypeMirror supertype) {
if (isSubtypeVisitHistory.contains(subtype, supertype, currentTop)) {
// visitHistory only contains pairs in a subtype relationship.
return true;
}
boolean result = isSubtype(subtype, supertype, currentTop);
// The call to put has no effect if result is false.
isSubtypeVisitHistory.put(subtype, supertype, currentTop, result);
return result;
}
/**
* Are all the types in {@code subtypes} a subtype of {@code supertype}?
*
* <p>The underlying type mirrors of {@code subtypes} must be subtypes of the underlying type
* mirror of {@code supertype}.
*/
protected boolean areAllSubtypes(
final Iterable<? extends AnnotatedTypeMirror> subtypes, final AnnotatedTypeMirror supertype) {
for (final AnnotatedTypeMirror subtype : subtypes) {
if (!isSubtype(subtype, supertype, currentTop)) {
return false;
}
}
return true;
}
protected boolean areEqualInHierarchy(
final AnnotatedTypeMirror type1, final AnnotatedTypeMirror type2) {
return equalityComparer.areEqualInHierarchy(type1, type2, currentTop);
}
/**
* Returns true if {@code outside} contains {@code inside}, that is, if the set of types denoted
* by {@code outside} is a superset of, or equal to, the set of types denoted by {@code inside}.
*
* <p>Containment is described in <a
* href="https://docs.oracle.com/javase/specs/jls/se11/html/jls-4.html#jls-4.5.1">JLS section
* 4.5.1 "Type Arguments of Parameterized Types"</a>.
*
* <p>As described in <a
* href=https://docs.oracle.com/javase/specs/jls/se11/html/jls-4.html#jls-4.10.2>JLS section
* 4.10.2 Subtyping among Class and Interface Types</a>, a declared type S is considered a
* supertype of another declared type T only if all of S's type arguments "contain" the
* corresponding type arguments of the subtype T.
*
* @param inside a possibly-contained type; its underlying type is contained by {@code outside}'s
* underlying type
* @param outside a possibly-containing type; its underlying type contains {@code inside}'s
* underlying type
* @param canBeCovariant whether or not type arguments are allowed to be covariant
* @return true if inside is contained by outside, or if canBeCovariant == true and {@code inside
* <: outside}
*/
protected boolean isContainedBy(
AnnotatedTypeMirror inside, AnnotatedTypeMirror outside, boolean canBeCovariant) {
Boolean previousResult = areEqualVisitHistory.get(inside, outside, currentTop);
if (previousResult != null) {
return previousResult;
}
if (shouldIgnoreUninferredTypeArgs(inside) || shouldIgnoreUninferredTypeArgs(outside)) {
areEqualVisitHistory.put(inside, outside, currentTop, true);
return true;
}
if (outside.getKind() == TypeKind.WILDCARD) {
// This is all cases except bullet 6, "T <= T".
AnnotatedWildcardType outsideWildcard = (AnnotatedWildcardType) outside;
// Add a placeholder in case of recursion, to prevent infinite regress.
areEqualVisitHistory.put(inside, outside, currentTop, true);
boolean result =
isContainedWithinBounds(
inside,
outsideWildcard.getSuperBound(),
outsideWildcard.getExtendsBound(),
canBeCovariant);
areEqualVisitHistory.put(inside, outside, currentTop, result);
return result;
}
if ((TypesUtils.isCapturedTypeVariable(outside.getUnderlyingType())
&& !TypesUtils.isCapturedTypeVariable(inside.getUnderlyingType()))) {
// TODO: This branch should be removed after #979 is fixed.
// This workaround is only needed when outside is a captured type variable,
// but inside is not.
AnnotatedTypeVariable outsideTypeVar = (AnnotatedTypeVariable) outside;
// Add a placeholder in case of recursion, to prevent infinite regress.
areEqualVisitHistory.put(inside, outside, currentTop, true);
boolean result =
isContainedWithinBounds(
inside,
outsideTypeVar.getLowerBound(),
outsideTypeVar.getUpperBound(),
canBeCovariant);
areEqualVisitHistory.put(inside, outside, currentTop, result);
return result;
}
// The remainder of the method is bullet 6, "T <= T".
if (canBeCovariant) {
return isSubtype(inside, outside, currentTop);
}
return areEqualInHierarchy(inside, outside);
}
/**
* Let {@code outside} be {@code ? super outsideLower extends outsideUpper}. Returns true if
* {@code outside} contains {@code inside}, that is, if the set of types denoted by {@code
* outside} is a superset of, or equal to, the set of types denoted by {@code inside}.
*
* <p>This method is a helper method for {@link #isContainedBy(AnnotatedTypeMirror,
* AnnotatedTypeMirror, boolean)}.
*
* @param inside a possibly-contained type
* @param outsideLower the lower bound of the possibly-containing type
* @param outsideUpper the upper bound of the possibly-containing type
* @param canBeCovariant whether or not type arguments are allowed to be covariant
* @return true if inside is contained by outside, or if canBeCovariant == true and {@code inside
* <: outside}
*/
protected boolean isContainedWithinBounds(
AnnotatedTypeMirror inside,
AnnotatedTypeMirror outsideLower,
AnnotatedTypeMirror outsideUpper,
boolean canBeCovariant) {
try {
if (canBeCovariant) {
if (outsideLower.getKind() == TypeKind.NULL) {
return isSubtype(inside, outsideUpper);
} else {
return isSubtype(outsideLower, inside);
}
}
// If inside is a wildcard, then isSubtype(outsideLower, inside) calls isSubtype(outsideLower,
// inside.getLowerBound()) and isSubtype(inside, outsideUpper) calls
// isSubtype(inside.getUpperBound(), outsideUpper). This is slightly different from the
// algorithm in the JLS. Only one of the Java type bounds can be specified, but there can be
// annotations on both the upper and lower bound of a wildcard.
return isSubtype(outsideLower, inside) && isSubtype(inside, outsideUpper);
} catch (Throwable ex) {
// Work around:
// https://bugs.java.com/bugdatabase/view_bug.do?bug_id=JDK-8265255
if (ex.getMessage().contains("AsSuperVisitor")) {
return false;
}
throw ex;
}
}
/**
* Returns true if {@code type} is an uninferred type argument and if the checker should not issue
* warnings about uninferred type arguments.
*
* @param type type to check
* @return true if {@code type} is an uninferred type argument and if the checker should not issue
* warnings about uninferred type arguments
*/
private boolean shouldIgnoreUninferredTypeArgs(AnnotatedTypeMirror type) {
return type.atypeFactory.ignoreUninferredTypeArguments
&& type.getKind() == TypeKind.WILDCARD
&& ((AnnotatedWildcardType) type).isUninferredTypeArgument();
}
// ------------------------------------------------------------------------
// The rest of this file is the visitor methods. It is a lot of methods, one for each
// combination of types.
// ------------------------------------------------------------------------
// Arrays as subtypes
@Override
public Boolean visitArray_Array(
AnnotatedArrayType subtype, AnnotatedArrayType supertype, Void p) {
return isPrimarySubtype(subtype, supertype)
&& (invariantArrayComponents
? areEqualInHierarchy(subtype.getComponentType(), supertype.getComponentType())
: isSubtype(subtype.getComponentType(), supertype.getComponentType(), currentTop));
}
@Override
public Boolean visitArray_Declared(
AnnotatedArrayType subtype, AnnotatedDeclaredType supertype, Void p) {
return isPrimarySubtype(subtype, supertype);
}
@Override
public Boolean visitArray_Null(AnnotatedArrayType subtype, AnnotatedNullType supertype, Void p) {
return isPrimarySubtype(subtype, supertype);
}
@Override
public Boolean visitArray_Intersection(
AnnotatedArrayType subtype, AnnotatedIntersectionType supertype, Void p) {
return isSubtype(
AnnotatedTypes.castedAsSuper(subtype.atypeFactory, subtype, supertype),
supertype,
currentTop);
}
@Override
public Boolean visitArray_Wildcard(
AnnotatedArrayType subtype, AnnotatedWildcardType supertype, Void p) {
return visitType_Wildcard(subtype, supertype);
}
@Override
public Boolean visitArray_Typevar(
AnnotatedArrayType subtype, AnnotatedTypeVariable superType, Void p) {
return visitType_Typevar(subtype, superType);
}
// ------------------------------------------------------------------------
// Declared as subtype
@Override
public Boolean visitDeclared_Array(
AnnotatedDeclaredType subtype, AnnotatedArrayType supertype, Void p) {
return isPrimarySubtype(subtype, supertype);
}
@Override
public Boolean visitDeclared_Declared(
AnnotatedDeclaredType subtype, AnnotatedDeclaredType supertype, Void p) {
if (!isPrimarySubtype(subtype, supertype)) {
return false;
}
AnnotatedTypeFactory factory = subtype.atypeFactory;
if (factory.ignoreUninferredTypeArguments
&& (factory.containsUninferredTypeArguments(subtype)
|| factory.containsUninferredTypeArguments(supertype))) {
// Calling castedAsSuper may cause the uninferredTypeArguments to be lost. So, just
// return true here.
return true;
}
if (isSubtypeVisitHistory.contains(subtype, supertype, currentTop)) {
return true;
}
final boolean result =
visitTypeArgs(
subtype, supertype, subtype.isUnderlyingTypeRaw(), supertype.isUnderlyingTypeRaw());
isSubtypeVisitHistory.put(subtype, supertype, currentTop, result);
return result;
}
/**
* Returns true if the type arguments in {@code supertype} contain the type arguments in {@code
* subtype} and false otherwise. See {@link #isContainedBy} for an explanation of containment.
*
* @param subtype a possible subtype
* @param supertype a possible supertype
* @param subtypeRaw whether {@code subtype} is a raw type
* @param supertypeRaw whether {@code supertype} is a raw type
* @return true if the type arguments in {@code supertype} contain the type arguments in {@code
* subtype} and false otherwise
*/
protected boolean visitTypeArgs(
AnnotatedDeclaredType subtype,
AnnotatedDeclaredType supertype,
final boolean subtypeRaw,
final boolean supertypeRaw) {
AnnotatedTypeFactory typeFactory = subtype.atypeFactory;
// JLS 11: 4.10.2. Subtyping among Class and Interface Types
// 4th paragraph, bullet 1.
AnnotatedDeclaredType subtypeAsSuper =
AnnotatedTypes.castedAsSuper(typeFactory, subtype, supertype);
if (ignoreRawTypes && (subtypeRaw || supertypeRaw)) {
return true;
}
final List<? extends AnnotatedTypeMirror> subtypeTypeArgs = subtypeAsSuper.getTypeArguments();
final List<? extends AnnotatedTypeMirror> supertypeTypeArgs = supertype.getTypeArguments();
if (subtypeTypeArgs.size() != supertypeTypeArgs.size()) {
throw new BugInCF("Type arguments are not the same size: %s %s", subtypeAsSuper, supertype);
}
// This method, `visitTypeArgs`, is called even if `subtype` doesn't have type arguments.
if (subtypeTypeArgs.isEmpty()) {
return true;
}
final TypeElement supertypeElem = (TypeElement) supertype.getUnderlyingType().asElement();
AnnotationMirror covariantAnno = typeFactory.getDeclAnnotation(supertypeElem, Covariant.class);
List<Integer> covariantArgIndexes =
(covariantAnno == null)
? null
: AnnotationUtils.getElementValueArray(
covariantAnno, covariantValueElement, Integer.class);
// JLS 11: 4.10.2. Subtyping among Class and Interface Types
// 4th paragraph, bullet 2
try {
if (isContainedMany(
subtypeAsSuper.getTypeArguments(), supertypeTypeArgs, covariantArgIndexes)) {
return true;
}
} catch (Exception e) {
// Some types need to be captured first, so ignore crashes.
}
// 5th paragraph:
// Instead of calling isSubtype with the captured type, just check for containment.
AnnotatedDeclaredType capturedSubtype =
(AnnotatedDeclaredType) typeFactory.applyCaptureConversion(subtype);
AnnotatedDeclaredType capturedSubtypeAsSuper =
AnnotatedTypes.castedAsSuper(typeFactory, capturedSubtype, supertype);
return isContainedMany(
capturedSubtypeAsSuper.getTypeArguments(), supertypeTypeArgs, covariantArgIndexes);
}
/**
* Calls {@link #isContainedBy(AnnotatedTypeMirror, AnnotatedTypeMirror, boolean)} on the two
* lists of type arguments. Returns true if every type argument in {@code supertypeTypeArgs}
* contains the type argument at the same index in {@code subtypeTypeArgs}.
*
* @param subtypeTypeArgs subtype arguments
* @param supertypeTypeArgs supertype arguments
* @param covariantArgIndexes indexes into the type arguments list which correspond to the type
* arguments that are marked @{@link Covariant}.
* @return whether {@code supertypeTypeArgs} contain {@code subtypeTypeArgs}
*/
protected boolean isContainedMany(
List<? extends AnnotatedTypeMirror> subtypeTypeArgs,
List<? extends AnnotatedTypeMirror> supertypeTypeArgs,
List<Integer> covariantArgIndexes) {
for (int i = 0; i < supertypeTypeArgs.size(); i++) {
AnnotatedTypeMirror superTypeArg = supertypeTypeArgs.get(i);
AnnotatedTypeMirror subTypeArg = subtypeTypeArgs.get(i);
boolean covariant = covariantArgIndexes != null && covariantArgIndexes.contains(i);
if (!isContainedBy(subTypeArg, superTypeArg, covariant)) {
return false;
}
}
return true;
}
@Override
public Boolean visitDeclared_Intersection(
AnnotatedDeclaredType subtype, AnnotatedIntersectionType supertype, Void p) {
return visitType_Intersection(subtype, supertype);
}
@Override
public Boolean visitDeclared_Null(
AnnotatedDeclaredType subtype, AnnotatedNullType supertype, Void p) {
return isPrimarySubtype(subtype, supertype);
}
@Override
public Boolean visitDeclared_Primitive(
AnnotatedDeclaredType subtype, AnnotatedPrimitiveType supertype, Void p) {
// We do an asSuper first because in some cases unboxing implies a more specific annotation
// e.g. @UnknownInterned Integer => @Interned int because primitives are always interned
final AnnotatedPrimitiveType subAsSuper =
AnnotatedTypes.castedAsSuper(subtype.atypeFactory, subtype, supertype);
if (subAsSuper == null) {
return isPrimarySubtype(subtype, supertype);
}
return isPrimarySubtype(subAsSuper, supertype);
}
@Override
public Boolean visitDeclared_Typevar(
AnnotatedDeclaredType subtype, AnnotatedTypeVariable supertype, Void p) {
return visitType_Typevar(subtype, supertype);
}
@Override
public Boolean visitDeclared_Union(
AnnotatedDeclaredType subtype, AnnotatedUnionType supertype, Void p) {
Types types = checker.getTypeUtils();
for (AnnotatedDeclaredType supertypeAltern : supertype.getAlternatives()) {
if (TypesUtils.isErasedSubtype(
subtype.getUnderlyingType(), supertypeAltern.getUnderlyingType(), types)
&& isSubtype(subtype, supertypeAltern, currentTop)) {
return true;
}
}
return false;
}
@Override
public Boolean visitDeclared_Wildcard(
AnnotatedDeclaredType subtype, AnnotatedWildcardType supertype, Void p) {
return visitType_Wildcard(subtype, supertype);
}
// ------------------------------------------------------------------------
// Intersection as subtype
@Override
public Boolean visitIntersection_Declared(
AnnotatedIntersectionType subtype, AnnotatedDeclaredType supertype, Void p) {
return visitIntersection_Type(subtype, supertype);
}
@Override
public Boolean visitIntersection_Primitive(
AnnotatedIntersectionType subtype, AnnotatedPrimitiveType supertype, Void p) {
for (AnnotatedTypeMirror subtypeBound : subtype.getBounds()) {
if (TypesUtils.isBoxedPrimitive(subtypeBound.getUnderlyingType())
&& isSubtype(subtypeBound, supertype, currentTop)) {
return true;
}
}
return false;
}
@Override
public Boolean visitIntersection_Intersection(
AnnotatedIntersectionType subtype, AnnotatedIntersectionType supertype, Void p) {
Types types = checker.getTypeUtils();
for (AnnotatedTypeMirror subBound : subtype.getBounds()) {
for (AnnotatedTypeMirror superBound : supertype.getBounds()) {
if (TypesUtils.isErasedSubtype(
subBound.getUnderlyingType(), superBound.getUnderlyingType(), types)
&& !isSubtype(subBound, superBound, currentTop)) {
return false;
}
}
}
return true;
}
@Override
public Boolean visitIntersection_Null(
AnnotatedIntersectionType subtype, AnnotatedNullType supertype, Void p) {
// this can occur through capture conversion/comparing bounds
for (AnnotatedTypeMirror bound : subtype.getBounds()) {
if (isPrimarySubtype(bound, supertype)) {
return true;
}
}
return false;
}
@Override
public Boolean visitIntersection_Typevar(
AnnotatedIntersectionType subtype, AnnotatedTypeVariable supertype, Void p) {
return visitIntersection_Type(subtype, supertype);
}
@Override
public Boolean visitIntersection_Wildcard(
AnnotatedIntersectionType subtype, AnnotatedWildcardType supertype, Void p) {
return visitIntersection_Type(subtype, supertype);
}
// ------------------------------------------------------------------------
// Null as subtype
@Override
public Boolean visitNull_Array(AnnotatedNullType subtype, AnnotatedArrayType supertype, Void p) {
return isPrimarySubtype(subtype, supertype);
}
@Override
public Boolean visitNull_Declared(
AnnotatedNullType subtype, AnnotatedDeclaredType supertype, Void p) {
return isPrimarySubtype(subtype, supertype);
}
@Override
public Boolean visitNull_Typevar(
AnnotatedNullType subtype, AnnotatedTypeVariable supertype, Void p) {
return visitType_Typevar(subtype, supertype);
}
@Override
public Boolean visitNull_Wildcard(
AnnotatedNullType subtype, AnnotatedWildcardType supertype, Void p) {
return visitType_Wildcard(subtype, supertype);
}
@Override
public Boolean visitNull_Null(AnnotatedNullType subtype, AnnotatedNullType supertype, Void p) {
// this can occur when comparing typevar lower bounds since they are usually null types
return isPrimarySubtype(subtype, supertype);
}
@Override
public Boolean visitNull_Union(AnnotatedNullType subtype, AnnotatedUnionType supertype, Void p) {
for (AnnotatedDeclaredType supertypeAltern : supertype.getAlternatives()) {
if (isSubtype(subtype, supertypeAltern, currentTop)) {
return true;
}
}
return false;
}
@Override
public Boolean visitNull_Intersection(
AnnotatedNullType subtype, AnnotatedIntersectionType supertype, Void p) {
return isPrimarySubtype(subtype, supertype);
}
@Override
public Boolean visitNull_Primitive(
AnnotatedNullType subtype, AnnotatedPrimitiveType supertype, Void p) {
return isPrimarySubtype(subtype, supertype);
}
// ------------------------------------------------------------------------
// Primitive as subtype
@Override
public Boolean visitPrimitive_Declared(
AnnotatedPrimitiveType subtype, AnnotatedDeclaredType supertype, Void p) {
// see comment in visitDeclared_Primitive
final AnnotatedDeclaredType subAsSuper =
AnnotatedTypes.castedAsSuper(subtype.atypeFactory, subtype, supertype);
if (subAsSuper == null) {
return isPrimarySubtype(subtype, supertype);
}
return isPrimarySubtype(subAsSuper, supertype);
}
@Override
public Boolean visitPrimitive_Primitive(
AnnotatedPrimitiveType subtype, AnnotatedPrimitiveType supertype, Void p) {
return isPrimarySubtype(subtype, supertype);
}
@Override
public Boolean visitPrimitive_Intersection(
AnnotatedPrimitiveType subtype, AnnotatedIntersectionType supertype, Void p) {
return visitType_Intersection(subtype, supertype);
}
@Override
public Boolean visitPrimitive_Typevar(
AnnotatedPrimitiveType subtype, AnnotatedTypeVariable supertype, Void p) {
return AtmCombo.accept(subtype, supertype.getUpperBound(), null, this);
}
@Override
public Boolean visitPrimitive_Wildcard(
AnnotatedPrimitiveType subtype, AnnotatedWildcardType supertype, Void p) {
if (supertype.atypeFactory.ignoreUninferredTypeArguments
&& supertype.isUninferredTypeArgument()) {
return true;
}
// this can occur when passing a primitive to a method on a raw type (see test
// checker/tests/nullness/RawAndPrimitive.java). This can also occur because we don't box
// primitives when we should and don't capture convert.
return isPrimarySubtype(subtype, supertype.getSuperBound());
}
// ------------------------------------------------------------------------
// Union as subtype
@Override
public Boolean visitUnion_Declared(
AnnotatedUnionType subtype, AnnotatedDeclaredType supertype, Void p) {
return visitUnion_Type(subtype, supertype);
}
@Override
public Boolean visitUnion_Intersection(
AnnotatedUnionType subtype, AnnotatedIntersectionType supertype, Void p) {
// For example:
// <T extends Throwable & Cloneable> void method(T param) {}
// ...
// catch (Exception1 | Exception2 union) { // Assuming Exception1 and Exception2 implement
// Cloneable
// method(union);
// This case happens when checking that the inferred type argument is a subtype of the
// declared type argument of method.
// See org.checkerframework.common.basetype.BaseTypeVisitor#checkTypeArguments
return visitUnion_Type(subtype, supertype);
}
@Override
public Boolean visitUnion_Union(
AnnotatedUnionType subtype, AnnotatedUnionType supertype, Void p) {
// For example:
// <T> void method(T param) {}
// ...
// catch (Exception1 | Exception2 union) {
// method(union);
// This case happens when checking the arguments to method after type variable substitution
return visitUnion_Type(subtype, supertype);
}
@Override
public Boolean visitUnion_Wildcard(
AnnotatedUnionType subtype, AnnotatedWildcardType supertype, Void p) {
// For example:
// } catch (RuntimeException | IOException e) {
// ArrayList<? super Exception> lWildcard = new ArrayList<>();
// lWildcard.add(e);
return visitType_Wildcard(subtype, supertype);
}
@Override
public Boolean visitUnion_Typevar(
AnnotatedUnionType subtype, AnnotatedTypeVariable supertype, Void p) {
// For example:
// } catch (RuntimeException | IOException e) {
// ArrayList<? super Exception> lWildcard = new ArrayList<>();
// lWildcard.add(e);
return visitType_Typevar(subtype, supertype);
}
// ------------------------------------------------------------------------
// typevar as subtype
@Override
public Boolean visitTypevar_Declared(
AnnotatedTypeVariable subtype, AnnotatedDeclaredType supertype, Void p) {
return visitTypevar_Type(subtype, supertype);
}
@Override
public Boolean visitTypevar_Intersection(
AnnotatedTypeVariable subtype, AnnotatedIntersectionType supertype, Void p) {
// this can happen when checking type param bounds
return visitType_Intersection(subtype, supertype);
}
@Override
public Boolean visitTypevar_Primitive(
AnnotatedTypeVariable subtype, AnnotatedPrimitiveType supertype, Void p) {
return visitTypevar_Type(subtype, supertype);
}
@Override
public Boolean visitTypevar_Array(
AnnotatedTypeVariable subtype, AnnotatedArrayType supertype, Void p) {
// This happens when the type variable is a captured wildcard.
return visitTypevar_Type(subtype, supertype);
}
@Override
public Boolean visitTypevar_Typevar(
AnnotatedTypeVariable subtype, AnnotatedTypeVariable supertype, Void p) {
if (AnnotatedTypes.haveSameDeclaration(checker.getTypeUtils(), subtype, supertype)) {
// The underlying types of subtype and supertype are uses of the same type parameter, but they
// may have different primary annotations.
boolean subtypeHasAnno = subtype.getAnnotationInHierarchy(currentTop) != null;
boolean supertypeHasAnno = supertype.getAnnotationInHierarchy(currentTop) != null;
if (subtypeHasAnno && supertypeHasAnno) {
// If both have primary annotations then just check the primary annotations
// as the bounds are the same.
return isPrimarySubtype(subtype, supertype);
} else if (!subtypeHasAnno && !supertypeHasAnno) {
// two unannotated uses of the same type parameter are of the same type
return areEqualInHierarchy(subtype, supertype);
} else if (subtypeHasAnno && !supertypeHasAnno) {
// This is the case "@A T <: T" where T is a type variable.
Set<AnnotationMirror> superLBs =
AnnotatedTypes.findEffectiveLowerBoundAnnotations(qualifierHierarchy, supertype);
AnnotationMirror superLB =
qualifierHierarchy.findAnnotationInHierarchy(superLBs, currentTop);
return qualifierHierarchy.isSubtype(subtype.getAnnotationInHierarchy(currentTop), superLB);
} else if (!subtypeHasAnno && supertypeHasAnno) {
// This is the case "T <: @A T" where T is a type variable.
return qualifierHierarchy.isSubtype(
subtype.getEffectiveAnnotationInHierarchy(currentTop),
supertype.getAnnotationInHierarchy(currentTop));
}
}
if (AnnotatedTypes.areCorrespondingTypeVariables(
checker.getProcessingEnvironment().getElementUtils(), subtype, supertype)) {
if (areEqualInHierarchy(subtype, supertype)) {
return true;
}
}
if (TypesUtils.isCapturedTypeVariable(subtype.getUnderlyingType())
&& TypesUtils.isCapturedTypeVariable(supertype.getUnderlyingType())) {
// This should be removed when 979 is fixed.
// This case happens when the captured type variables should be the same type, but
// aren't because type argument inference isn't implemented correctly.
return isContainedWithinBounds(
subtype, supertype.getLowerBound(), supertype.getUpperBound(), false);
}
if (supertype.getLowerBound().getKind() != TypeKind.NULL) {
return visit(subtype, supertype.getLowerBound(), p);
}
// check that the upper bound of the subtype is below the lower bound of the supertype
return visitTypevar_Type(subtype, supertype);
}
@Override
public Boolean visitTypevar_Null(
AnnotatedTypeVariable subtype, AnnotatedNullType supertype, Void p) {
return visitTypevar_Type(subtype, supertype);
}
@Override
public Boolean visitTypevar_Wildcard(
AnnotatedTypeVariable subtype, AnnotatedWildcardType supertype, Void p) {
return visitType_Wildcard(subtype, supertype);
}
// ------------------------------------------------------------------------
// wildcard as subtype
@Override
public Boolean visitWildcard_Array(
AnnotatedWildcardType subtype, AnnotatedArrayType supertype, Void p) {
return visitWildcard_Type(subtype, supertype);
}
@Override
public Boolean visitWildcard_Declared(
AnnotatedWildcardType subtype, AnnotatedDeclaredType supertype, Void p) {
if (subtype.isUninferredTypeArgument()) {
if (subtype.atypeFactory.ignoreUninferredTypeArguments) {
return true;
} else if (supertype.getTypeArguments().isEmpty()) {
// visitWildcard_Type doesn't check uninferred type arguments, because the
// underlying Java types may not be in the correct relationship. But, if the
// declared type does not have type arguments, then checking primary annotations is
// sufficient.
// For example, if the wildcard is ? extends @Nullable Object and the supertype is
// @Nullable String, then it is safe to return true. However if the supertype is
// @NullableList<@NonNull String> then it's not possible to decide if it is a
// subtype of the wildcard.
AnnotationMirror subtypeAnno = subtype.getEffectiveAnnotationInHierarchy(currentTop);
AnnotationMirror supertypeAnno = supertype.getAnnotationInHierarchy(currentTop);
return qualifierHierarchy.isSubtype(subtypeAnno, supertypeAnno);
}
}
return visitWildcard_Type(subtype, supertype);
}
@Override
public Boolean visitWildcard_Intersection(
AnnotatedWildcardType subtype, AnnotatedIntersectionType supertype, Void p) {
return visitWildcard_Type(subtype, supertype);
}
@Override
public Boolean visitWildcard_Primitive(
AnnotatedWildcardType subtype, AnnotatedPrimitiveType supertype, Void p) {
if (subtype.isUninferredTypeArgument()) {
AnnotationMirror subtypeAnno = subtype.getEffectiveAnnotationInHierarchy(currentTop);
AnnotationMirror supertypeAnno = supertype.getAnnotationInHierarchy(currentTop);
return qualifierHierarchy.isSubtype(subtypeAnno, supertypeAnno);
}
return visitWildcard_Type(subtype, supertype);
}
@Override
public Boolean visitWildcard_Typevar(
AnnotatedWildcardType subtype, AnnotatedTypeVariable supertype, Void p) {
return visitWildcard_Type(subtype, supertype);
}
@Override
public Boolean visitWildcard_Wildcard(
AnnotatedWildcardType subtype, AnnotatedWildcardType supertype, Void p) {
return visitWildcard_Type(subtype, supertype);
}
// ------------------------------------------------------------------------
// These "visit" methods are utility methods that aren't part of the visit interface
// but that handle cases that more than one visit method shares in common.
/**
* An intersection is a supertype if all of its bounds are a supertype of subtype.
*
* @param subtype the possible subtype
* @param supertype the possible supertype
* @return true {@code subtype} is a subtype of {@code supertype}
*/
protected boolean visitType_Intersection(
AnnotatedTypeMirror subtype, AnnotatedIntersectionType supertype) {
if (isSubtypeVisitHistory.contains(subtype, supertype, currentTop)) {
return true;
}
boolean result = true;
for (AnnotatedTypeMirror bound : supertype.getBounds()) {
// Only call isSubtype if the Java type is actually a subtype; otherwise,
// only check primary qualifiers.
if (TypesUtils.isErasedSubtype(
subtype.getUnderlyingType(), bound.getUnderlyingType(), subtype.atypeFactory.types)
&& !isSubtype(subtype, bound, currentTop)) {
result = false;
break;
}
}
isSubtypeVisitHistory.put(subtype, supertype, currentTop, result);
return result;
}
/**
* An intersection is a subtype if one of its bounds is a subtype of {@code supertype}.
*
* @param subtype an intersection type
* @param supertype an annotated type
* @return whether {@code subtype} is a subtype of {@code supertype}
*/
protected boolean visitIntersection_Type(
AnnotatedIntersectionType subtype, AnnotatedTypeMirror supertype) {
Types types = checker.getTypeUtils();
// The primary annotations of the bounds should already be the same as the annotations on
// the intersection type.
for (AnnotatedTypeMirror subtypeBound : subtype.getBounds()) {
if (TypesUtils.isErasedSubtype(
subtypeBound.getUnderlyingType(), supertype.getUnderlyingType(), types)
&& isSubtype(subtypeBound, supertype, currentTop)) {
return true;
}
}
return false;
}
/**
* A type variable is a supertype if its lower bound is above subtype.
*
* @param subtype a type that might be a subtype
* @param supertype a type that might be a supertype
* @return true if {@code subtype} is a subtype of {@code supertype}
*/
protected boolean visitType_Typevar(
AnnotatedTypeMirror subtype, AnnotatedTypeVariable supertype) {
return isSubtypeCaching(subtype, supertype.getLowerBound());
}
/**
* A type variable is a subtype if its upper bound is below the supertype.
*
* @param subtype a type that might be a subtype
* @param supertype a type that might be a supertype
* @return true if {@code subtype} is a subtype of {@code supertype}
*/
protected boolean visitTypevar_Type(
AnnotatedTypeVariable subtype, AnnotatedTypeMirror supertype) {
AnnotatedTypeMirror subtypeUpperBound = subtype.getUpperBound();
if (TypesUtils.isBoxedPrimitive(subtypeUpperBound.getUnderlyingType())
&& supertype instanceof AnnotatedPrimitiveType) {
subtypeUpperBound =
subtype.atypeFactory.getUnboxedType((AnnotatedDeclaredType) subtypeUpperBound);
}
if (supertype.getKind() == TypeKind.DECLARED
&& TypesUtils.getTypeElement(supertype.getUnderlyingType()).getKind()
== ElementKind.INTERFACE) {
// The supertype is an interface.
subtypeUpperBound = getNonWildcardOrTypeVarUpperBound(subtypeUpperBound);
if (subtypeUpperBound.getKind() == TypeKind.INTERSECTION) {
// Only compare the primary annotations.
Types types = checker.getTypeUtils();
for (AnnotatedTypeMirror bound :
((AnnotatedIntersectionType) subtypeUpperBound).getBounds()) {
// Make sure the upper bound is no wildcard or type variable.
bound = getNonWildcardOrTypeVarUpperBound(bound);
if (TypesUtils.isErasedSubtype(
bound.getUnderlyingType(), supertype.getUnderlyingType(), types)
&& isPrimarySubtype(bound, supertype)) {
return true;
}
}
return false;
}
}
return isSubtypeCaching(subtypeUpperBound, supertype);
}
/**
* If {@code type} is a type variable or wildcard recur on its upper bound until an upper bound is
* found that is neither a type variable nor a wildcard.
*
* @param type the type
* @return if {@code type} is a type variable or wildcard, recur on its upper bound until an upper
* bound is found that is neither a type variable nor a wildcard. Otherwise, return {@code
* type} itself.
*/
private AnnotatedTypeMirror getNonWildcardOrTypeVarUpperBound(AnnotatedTypeMirror type) {
while (type.getKind() == TypeKind.TYPEVAR || type.getKind() == TypeKind.WILDCARD) {
if (type.getKind() == TypeKind.TYPEVAR) {
type = ((AnnotatedTypeVariable) type).getUpperBound();
}
if (type.getKind() == TypeKind.WILDCARD) {
type = ((AnnotatedWildcardType) type).getExtendsBound();
}
}
return type;
}
/**
* A union type is a subtype if ALL of its alternatives are subtypes of supertype.
*
* @param subtype the potential subtype to check
* @param supertype the supertype to check
* @return whether all the alternatives of subtype are subtypes of supertype
*/
protected boolean visitUnion_Type(AnnotatedUnionType subtype, AnnotatedTypeMirror supertype) {
return areAllSubtypes(subtype.getAlternatives(), supertype);
}
/**
* Check a wildcard type's relation against a subtype.
*
* @param subtype the potential subtype to check
* @param supertype the wildcard supertype to check
* @return whether the subtype is a subtype of the supertype's super bound
*/
protected boolean visitType_Wildcard(
AnnotatedTypeMirror subtype, AnnotatedWildcardType supertype) {
if (supertype.isUninferredTypeArgument()) { // TODO: REMOVE WHEN WE FIX TYPE ARG INFERENCE
// Can't call isSubtype because underlying Java types won't be subtypes.
return supertype.atypeFactory.ignoreUninferredTypeArguments;
}
return isSubtype(subtype, supertype.getSuperBound(), currentTop);
}
/**
* Check a wildcard type's relation against a supertype.
*
* @param subtype the potential wildcard subtype to check
* @param supertype the supertype to check
* @return whether the subtype's extends bound is a subtype of the supertype
*/
protected boolean visitWildcard_Type(
AnnotatedWildcardType subtype, AnnotatedTypeMirror supertype) {
if (subtype.isUninferredTypeArgument()) {
return subtype.atypeFactory.ignoreUninferredTypeArguments;
}
if (supertype.getKind() == TypeKind.WILDCARD) {
// This can happen at a method invocation where a type variable in the method
// declaration is substituted with a wildcard.
// For example:
// <T> void method(Gen<T> t) {}
// Gen<?> x;
// method(x);
// visitWildcard_Type is called when checking the method call `method(x)`,
// and also when checking lambdas.
boolean subtypeHasAnno = subtype.getAnnotationInHierarchy(currentTop) != null;
boolean supertypeHasAnno = supertype.getAnnotationInHierarchy(currentTop) != null;
if (subtypeHasAnno && supertypeHasAnno) {
// If both have primary annotations then just check the primary annotations
// as the bounds are the same.
return isPrimarySubtype(subtype, supertype);
} else if (!subtypeHasAnno && !supertypeHasAnno && areEqualInHierarchy(subtype, supertype)) {
// Two unannotated uses of wildcard types are the same type
return true;
}
}
return isSubtype(subtype.getExtendsBound(), supertype, currentTop);
}
}
| 15,725 |
519 | # BSD 3-Clause License; see https://github.com/scikit-hep/awkward-1.0/blob/main/LICENSE
from __future__ import absolute_import
import pytest # noqa: F401
import numpy as np # noqa: F401
import awkward as ak # noqa: F401
pytestmark = pytest.mark.skipif(
ak._util.py27, reason="No Python 2.7 support in Awkward 2.x"
)
def test_UnknownType():
assert str(ak._v2.types.unknowntype.UnknownType()) == "unknown"
assert (
str(ak._v2.types.unknowntype.UnknownType({"x": 123}))
== 'unknown[parameters={"x": 123}]'
)
assert str(ak._v2.types.unknowntype.UnknownType(None, "override")) == "override"
assert (
str(ak._v2.types.unknowntype.UnknownType({"x": 123}, "override")) == "override"
)
assert (
str(ak._v2.types.unknowntype.UnknownType({"__categorical__": True}))
== "categorical[type=unknown]"
)
assert (
str(ak._v2.types.unknowntype.UnknownType({"__categorical__": True, "x": 123}))
== 'categorical[type=unknown[parameters={"x": 123}]]'
)
assert (
str(ak._v2.types.unknowntype.UnknownType({"__categorical__": True}, "override"))
== "categorical[type=override]"
)
assert repr(ak._v2.types.unknowntype.UnknownType()) == "UnknownType()"
assert (
repr(
ak._v2.types.unknowntype.UnknownType(
parameters={"__categorical__": True}, typestr="override"
)
)
== "UnknownType(parameters={'__categorical__': True}, typestr='override')"
)
@pytest.mark.skipif(
ak._util.win,
reason="NumPy does not have float16, float128, and complex256 -- on Windows",
)
def test_NumpyType():
assert str(ak._v2.types.numpytype.NumpyType("bool")) == "bool"
assert str(ak._v2.types.numpytype.NumpyType("int8")) == "int8"
assert str(ak._v2.types.numpytype.NumpyType("uint8")) == "uint8"
assert str(ak._v2.types.numpytype.NumpyType("int16")) == "int16"
assert str(ak._v2.types.numpytype.NumpyType("uint16")) == "uint16"
assert str(ak._v2.types.numpytype.NumpyType("int32")) == "int32"
assert str(ak._v2.types.numpytype.NumpyType("uint32")) == "uint32"
assert str(ak._v2.types.numpytype.NumpyType("int64")) == "int64"
assert str(ak._v2.types.numpytype.NumpyType("uint64")) == "uint64"
assert str(ak._v2.types.numpytype.NumpyType("float16")) == "float16"
assert str(ak._v2.types.numpytype.NumpyType("float32")) == "float32"
assert str(ak._v2.types.numpytype.NumpyType("float64")) == "float64"
assert str(ak._v2.types.numpytype.NumpyType("float128")) == "float128"
assert str(ak._v2.types.numpytype.NumpyType("complex64")) == "complex64"
assert str(ak._v2.types.numpytype.NumpyType("complex128")) == "complex128"
assert str(ak._v2.types.numpytype.NumpyType("complex256")) == "complex256"
assert (
str(ak._v2.types.numpytype.NumpyType("bool", {"x": 123}))
== 'bool[parameters={"x": 123}]'
)
assert str(ak._v2.types.numpytype.NumpyType("bool", None, "override")) == "override"
assert (
str(ak._v2.types.numpytype.NumpyType("bool", {"x": 123}, "override"))
== "override"
)
assert (
str(ak._v2.types.numpytype.NumpyType("bool", {"__categorical__": True}))
== "categorical[type=bool]"
)
assert (
str(
ak._v2.types.numpytype.NumpyType(
"bool", {"__categorical__": True, "x": 123}
)
)
== 'categorical[type=bool[parameters={"x": 123}]]'
)
assert (
str(
ak._v2.types.numpytype.NumpyType(
"bool", {"__categorical__": True}, "override"
)
)
== "categorical[type=override]"
)
assert str(ak._v2.types.numpytype.NumpyType("datetime64")) == "datetime64"
assert (
str(ak._v2.types.numpytype.NumpyType("datetime64", {"__unit__": "Y"}))
== 'datetime64[unit="Y"]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("datetime64", {"__unit__": "M"}))
== 'datetime64[unit="M"]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("datetime64", {"__unit__": "W"}))
== 'datetime64[unit="W"]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("datetime64", {"__unit__": "D"}))
== 'datetime64[unit="D"]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("datetime64", {"__unit__": "h"}))
== 'datetime64[unit="h"]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("datetime64", {"__unit__": "m"}))
== 'datetime64[unit="m"]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("datetime64", {"__unit__": "s"}))
== 'datetime64[unit="s"]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("datetime64", {"__unit__": "ms"}))
== 'datetime64[unit="ms"]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("datetime64", {"__unit__": "us"}))
== 'datetime64[unit="us"]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("datetime64", {"__unit__": "ns"}))
== 'datetime64[unit="ns"]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("datetime64", {"__unit__": "ps"}))
== 'datetime64[unit="ps"]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("datetime64", {"__unit__": "fs"}))
== 'datetime64[unit="fs"]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("datetime64", {"__unit__": "as"}))
== 'datetime64[unit="as"]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("datetime64", {"__unit__": "10s"}))
== 'datetime64[unit="10s"]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("datetime64", {"__unit__": "1s"}))
== 'datetime64[unit="s"]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("datetime64", {"__unit__": "s", "x": 123}))
== 'datetime64[unit="s", parameters={"x": 123}]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("datetime64", {"x": 123}))
== 'datetime64[parameters={"x": 123}]'
)
assert str(ak._v2.types.numpytype.NumpyType("timedelta64")) == "timedelta64"
assert (
str(ak._v2.types.numpytype.NumpyType("timedelta64", {"__unit__": "Y"}))
== 'timedelta64[unit="Y"]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("timedelta64", {"__unit__": "M"}))
== 'timedelta64[unit="M"]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("timedelta64", {"__unit__": "W"}))
== 'timedelta64[unit="W"]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("timedelta64", {"__unit__": "D"}))
== 'timedelta64[unit="D"]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("timedelta64", {"__unit__": "h"}))
== 'timedelta64[unit="h"]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("timedelta64", {"__unit__": "m"}))
== 'timedelta64[unit="m"]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("timedelta64", {"__unit__": "s"}))
== 'timedelta64[unit="s"]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("timedelta64", {"__unit__": "ms"}))
== 'timedelta64[unit="ms"]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("timedelta64", {"__unit__": "us"}))
== 'timedelta64[unit="us"]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("timedelta64", {"__unit__": "ns"}))
== 'timedelta64[unit="ns"]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("timedelta64", {"__unit__": "ps"}))
== 'timedelta64[unit="ps"]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("timedelta64", {"__unit__": "fs"}))
== 'timedelta64[unit="fs"]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("timedelta64", {"__unit__": "as"}))
== 'timedelta64[unit="as"]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("timedelta64", {"__unit__": "10s"}))
== 'timedelta64[unit="10s"]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("timedelta64", {"__unit__": "1s"}))
== 'timedelta64[unit="s"]'
)
assert (
str(
ak._v2.types.numpytype.NumpyType("timedelta64", {"__unit__": "s", "x": 123})
)
== 'timedelta64[unit="s", parameters={"x": 123}]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("timedelta64", {"x": 123}))
== 'timedelta64[parameters={"x": 123}]'
)
assert (
str(ak._v2.types.numpytype.NumpyType("uint8", {"__array__": "char"})) == "char"
)
assert (
str(ak._v2.types.numpytype.NumpyType("uint8", {"__array__": "byte"})) == "byte"
)
assert (
repr(ak._v2.types.numpytype.NumpyType(primitive="bool")) == "NumpyType('bool')"
)
assert (
repr(
ak._v2.types.numpytype.NumpyType(
primitive="bool",
parameters={"__categorical__": True},
typestr="override",
)
)
== "NumpyType('bool', parameters={'__categorical__': True}, typestr='override')"
)
assert (
repr(
ak._v2.types.numpytype.NumpyType(
primitive="datetime64", parameters={"__unit__": "s"}
)
)
== "NumpyType('datetime64', parameters={'__unit__': 's'})"
)
assert (
repr(
ak._v2.types.numpytype.NumpyType(
primitive="uint8", parameters={"__array__": "char"}
)
)
== "NumpyType('uint8', parameters={'__array__': 'char'})"
)
assert (
repr(
ak._v2.types.numpytype.NumpyType(
primitive="uint8", parameters={"__array__": "byte"}
)
)
== "NumpyType('uint8', parameters={'__array__': 'byte'})"
)
def test_RegularType():
assert (
str(
ak._v2.types.regulartype.RegularType(
ak._v2.types.unknowntype.UnknownType(), 10
)
)
== "10 * unknown"
)
assert (
str(
ak._v2.types.regulartype.RegularType(
ak._v2.types.unknowntype.UnknownType(), 0
)
)
== "0 * unknown"
)
with pytest.raises(ValueError):
ak._v2.types.regulartype.RegularType(ak._v2.types.unknowntype.UnknownType(), -1)
assert (
str(
ak._v2.types.regulartype.RegularType(
ak._v2.types.unknowntype.UnknownType(), 10, {"x": 123}
)
)
== '[10 * unknown, parameters={"x": 123}]'
)
assert (
str(
ak._v2.types.regulartype.RegularType(
ak._v2.types.unknowntype.UnknownType(), 10, None, "override"
)
)
== "override"
)
assert (
str(
ak._v2.types.regulartype.RegularType(
ak._v2.types.unknowntype.UnknownType(), 10, {"x": 123}, "override"
)
)
== "override"
)
assert (
str(
ak._v2.types.regulartype.RegularType(
ak._v2.types.unknowntype.UnknownType(), 10, {"__categorical__": True}
)
)
== "categorical[type=10 * unknown]"
)
assert (
str(
ak._v2.types.regulartype.RegularType(
ak._v2.types.unknowntype.UnknownType(),
10,
{"__categorical__": True, "x": 123},
)
)
== 'categorical[type=[10 * unknown, parameters={"x": 123}]]'
)
assert (
str(
ak._v2.types.regulartype.RegularType(
ak._v2.types.unknowntype.UnknownType(),
10,
{"__categorical__": True},
"override",
)
)
== "categorical[type=override]"
)
assert (
str(
ak._v2.types.regulartype.RegularType(
ak._v2.types.numpytype.NumpyType("uint8", {"__array__": "char"}),
10,
{"__array__": "string"},
)
)
== "string[10]"
)
assert (
str(
ak._v2.types.regulartype.RegularType(
ak._v2.types.numpytype.NumpyType("uint8", {"__array__": "byte"}),
10,
{"__array__": "bytestring"},
)
)
== "bytes[10]"
)
assert (
repr(
ak._v2.types.regulartype.RegularType(
content=ak._v2.types.unknowntype.UnknownType(), size=10
)
)
== "RegularType(UnknownType(), 10)"
)
assert (
repr(
ak._v2.types.regulartype.RegularType(
content=ak._v2.types.unknowntype.UnknownType(),
size=10,
parameters={"__categorical__": True},
typestr="override",
)
)
== "RegularType(UnknownType(), 10, parameters={'__categorical__': True}, typestr='override')"
)
assert (
repr(
ak._v2.types.regulartype.RegularType(
content=ak._v2.types.numpytype.NumpyType(
primitive="uint8", parameters={"__array__": "char"}
),
parameters={"__array__": "string"},
size=10,
)
)
== "RegularType(NumpyType('uint8', parameters={'__array__': 'char'}), 10, parameters={'__array__': 'string'})"
)
assert (
repr(
ak._v2.types.regulartype.RegularType(
content=ak._v2.types.numpytype.NumpyType(
primitive="uint8", parameters={"__array__": "byte"}
),
parameters={"__array__": "bytestring"},
size=10,
)
)
== "RegularType(NumpyType('uint8', parameters={'__array__': 'byte'}), 10, parameters={'__array__': 'bytestring'})"
)
def test_ListType():
assert (
str(ak._v2.types.listtype.ListType(ak._v2.types.unknowntype.UnknownType()))
== "var * unknown"
)
assert (
str(
ak._v2.types.listtype.ListType(
ak._v2.types.unknowntype.UnknownType(), {"x": 123}
)
)
== '[var * unknown, parameters={"x": 123}]'
)
assert (
str(
ak._v2.types.listtype.ListType(
ak._v2.types.unknowntype.UnknownType(), None, "override"
)
)
== "override"
)
assert (
str(
ak._v2.types.listtype.ListType(
ak._v2.types.unknowntype.UnknownType(), {"x": 123}, "override"
)
)
== "override"
)
assert (
str(
ak._v2.types.listtype.ListType(
ak._v2.types.unknowntype.UnknownType(), {"__categorical__": True}
)
)
== "categorical[type=var * unknown]"
)
assert (
str(
ak._v2.types.listtype.ListType(
ak._v2.types.unknowntype.UnknownType(),
{"__categorical__": True, "x": 123},
)
)
== 'categorical[type=[var * unknown, parameters={"x": 123}]]'
)
assert (
str(
ak._v2.types.listtype.ListType(
ak._v2.types.unknowntype.UnknownType(),
{"__categorical__": True},
"override",
)
)
== "categorical[type=override]"
)
assert (
str(
ak._v2.types.listtype.ListType(
ak._v2.types.numpytype.NumpyType("uint8", {"__array__": "char"}),
{"__array__": "string"},
)
)
== "string"
)
assert (
str(
ak._v2.types.listtype.ListType(
ak._v2.types.numpytype.NumpyType("uint8", {"__array__": "byte"}),
{"__array__": "bytestring"},
)
)
== "bytes"
)
assert (
repr(
ak._v2.types.listtype.ListType(
content=ak._v2.types.unknowntype.UnknownType()
)
)
== "ListType(UnknownType())"
)
assert (
repr(
ak._v2.types.listtype.ListType(
content=ak._v2.types.unknowntype.UnknownType(),
parameters={"__categorical__": True},
typestr="override",
)
)
== "ListType(UnknownType(), parameters={'__categorical__': True}, typestr='override')"
)
assert (
repr(
ak._v2.types.listtype.ListType(
content=ak._v2.types.numpytype.NumpyType(
primitive="uint8", parameters={"__array__": "char"}
),
parameters={"__array__": "string"},
)
)
== "ListType(NumpyType('uint8', parameters={'__array__': 'char'}), parameters={'__array__': 'string'})"
)
assert (
repr(
ak._v2.types.listtype.ListType(
content=ak._v2.types.numpytype.NumpyType(
primitive="uint8", parameters={"__array__": "byte"}
),
parameters={"__array__": "bytestring"},
)
)
== "ListType(NumpyType('uint8', parameters={'__array__': 'byte'}), parameters={'__array__': 'bytestring'})"
)
@pytest.mark.skipif(
ak._util.py27 or ak._util.py35, reason="Python 2.7, 3.5 have unstable dict order."
)
def test_RecordType():
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
None,
)
)
== "(unknown, bool)"
)
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
["x", "y"],
)
)
== "{x: unknown, y: bool}"
)
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
None,
{"__record__": "Name"},
)
)
== "Name[unknown, bool]"
)
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
["x", "y"],
{"__record__": "Name"},
)
)
== "Name[x: unknown, y: bool]"
)
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
None,
None,
"override",
)
)
== "override"
)
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
["x", "y"],
None,
"override",
)
)
== "override"
)
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
None,
{"__record__": "Name"},
"override",
)
)
== "override"
)
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
["x", "y"],
{"__record__": "Name"},
"override",
)
)
== "override"
)
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
None,
{"x": 123},
)
)
== 'tuple[[unknown, bool], parameters={"x": 123}]'
)
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
["x", "y"],
{"x": 123},
)
)
== 'struct[["x", "y"], [unknown, bool], parameters={"x": 123}]'
)
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
None,
{"__record__": "Name", "x": 123},
)
)
== 'Name[unknown, bool, parameters={"x": 123}]'
)
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
["x", "y"],
{"__record__": "Name", "x": 123},
)
)
== 'Name[x: unknown, y: bool, parameters={"x": 123}]'
)
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
None,
{"x": 123},
"override",
)
)
== "override"
)
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
["x", "y"],
{"x": 123},
"override",
)
)
== "override"
)
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
None,
{"__record__": "Name", "x": 123},
"override",
)
)
== "override"
)
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
["x", "y"],
{"__record__": "Name", "x": 123},
"override",
)
)
== "override"
)
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
None,
{"__categorical__": True},
)
)
== "categorical[type=(unknown, bool)]"
)
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
["x", "y"],
{"__categorical__": True},
)
)
== "categorical[type={x: unknown, y: bool}]"
)
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
None,
{"__record__": "Name", "__categorical__": True},
)
)
== "categorical[type=Name[unknown, bool]]"
)
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
["x", "y"],
{"__record__": "Name", "__categorical__": True},
)
)
== "categorical[type=Name[x: unknown, y: bool]]"
)
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
None,
{"__categorical__": True},
"override",
)
)
== "categorical[type=override]"
)
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
["x", "y"],
{"__categorical__": True},
"override",
)
)
== "categorical[type=override]"
)
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
None,
{"__record__": "Name", "__categorical__": True},
"override",
)
)
== "categorical[type=override]"
)
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
["x", "y"],
{"__record__": "Name", "__categorical__": True},
"override",
)
)
== "categorical[type=override]"
)
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
None,
{"x": 123, "__categorical__": True},
)
)
== 'categorical[type=tuple[[unknown, bool], parameters={"x": 123}]]'
)
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
["x", "y"],
{"x": 123, "__categorical__": True},
)
)
== 'categorical[type=struct[["x", "y"], [unknown, bool], parameters={"x": 123}]]'
)
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
None,
{"__record__": "Name", "x": 123, "__categorical__": True},
)
)
== 'categorical[type=Name[unknown, bool, parameters={"x": 123}]]'
)
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
["x", "y"],
{"__record__": "Name", "x": 123, "__categorical__": True},
)
)
== 'categorical[type=Name[x: unknown, y: bool, parameters={"x": 123}]]'
)
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
None,
{"x": 123, "__categorical__": True},
"override",
)
)
== "categorical[type=override]"
)
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
["x", "y"],
{"x": 123, "__categorical__": True},
"override",
)
)
== "categorical[type=override]"
)
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
None,
{"__record__": "Name", "x": 123, "__categorical__": True},
"override",
)
)
== "categorical[type=override]"
)
assert (
str(
ak._v2.types.recordtype.RecordType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
["x", "y"],
{"__record__": "Name", "x": 123, "__categorical__": True},
"override",
)
)
== "categorical[type=override]"
)
assert (
repr(
ak._v2.types.recordtype.RecordType(
contents=[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
keys=None,
)
)
== "RecordType([UnknownType(), NumpyType('bool')], None)"
)
assert (
repr(
ak._v2.types.recordtype.RecordType(
contents=[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
keys=["x", "y"],
)
)
== "RecordType([UnknownType(), NumpyType('bool')], ['x', 'y'])"
)
assert (
repr(
ak._v2.types.recordtype.RecordType(
contents=[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
keys=None,
parameters={"__record__": "Name", "x": 123, "__categorical__": True},
typestr="override",
)
)
== "RecordType([UnknownType(), NumpyType('bool')], None, parameters={'__record__': 'Name', 'x': 123, '__categorical__': True}, typestr='override')"
)
assert (
repr(
ak._v2.types.recordtype.RecordType(
contents=[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
keys=None,
parameters={"__record__": "Name", "x": 123, "__categorical__": True},
)
)
== "RecordType([UnknownType(), NumpyType('bool')], None, parameters={'__record__': 'Name', 'x': 123, '__categorical__': True})"
)
assert (
repr(
ak._v2.types.recordtype.RecordType(
contents=[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
keys=["x", "y"],
parameters={"__record__": "Name", "x": 123, "__categorical__": True},
typestr="override",
)
)
== "RecordType([UnknownType(), NumpyType('bool')], ['x', 'y'], parameters={'__record__': 'Name', 'x': 123, '__categorical__': True}, typestr='override')"
)
@pytest.mark.skipif(
ak._util.py27 or ak._util.py35, reason="Python 2.7, 3.5 have unstable dict order."
)
def test_OptionType():
assert (
str(ak._v2.types.optiontype.OptionType(ak._v2.types.unknowntype.UnknownType()))
== "?unknown"
)
assert (
str(
ak._v2.types.optiontype.OptionType(
ak._v2.types.listtype.ListType(ak._v2.types.unknowntype.UnknownType())
)
)
== "option[var * unknown]"
)
assert (
str(
ak._v2.types.optiontype.OptionType(
ak._v2.types.regulartype.RegularType(
ak._v2.types.unknowntype.UnknownType(), 10
)
)
)
== "option[10 * unknown]"
)
assert (
str(
ak._v2.types.optiontype.OptionType(
ak._v2.types.unknowntype.UnknownType(), {"x": 123}
)
)
== 'option[unknown, parameters={"x": 123}]'
)
assert (
str(
ak._v2.types.optiontype.OptionType(
ak._v2.types.listtype.ListType(ak._v2.types.unknowntype.UnknownType()),
{"x": 123},
)
)
== 'option[var * unknown, parameters={"x": 123}]'
)
assert (
str(
ak._v2.types.optiontype.OptionType(
ak._v2.types.regulartype.RegularType(
ak._v2.types.unknowntype.UnknownType(), 10
),
{"x": 123},
)
)
== 'option[10 * unknown, parameters={"x": 123}]'
)
assert (
str(
ak._v2.types.optiontype.OptionType(
ak._v2.types.unknowntype.UnknownType(), None, "override"
)
)
== "override"
)
assert (
str(
ak._v2.types.optiontype.OptionType(
ak._v2.types.listtype.ListType(ak._v2.types.unknowntype.UnknownType()),
None,
"override",
)
)
== "override"
)
assert (
str(
ak._v2.types.optiontype.OptionType(
ak._v2.types.regulartype.RegularType(
ak._v2.types.unknowntype.UnknownType(), 10
),
None,
"override",
)
)
== "override"
)
assert (
str(
ak._v2.types.optiontype.OptionType(
ak._v2.types.unknowntype.UnknownType(), {"x": 123}, "override"
)
)
== "override"
)
assert (
str(
ak._v2.types.optiontype.OptionType(
ak._v2.types.listtype.ListType(ak._v2.types.unknowntype.UnknownType()),
{"x": 123},
"override",
)
)
== "override"
)
assert (
str(
ak._v2.types.optiontype.OptionType(
ak._v2.types.regulartype.RegularType(
ak._v2.types.unknowntype.UnknownType(), 10
),
{"x": 123},
"override",
)
)
== "override"
)
assert (
str(
ak._v2.types.optiontype.OptionType(
ak._v2.types.unknowntype.UnknownType(), {"__categorical__": True}
)
)
== "categorical[type=?unknown]"
)
assert (
str(
ak._v2.types.optiontype.OptionType(
ak._v2.types.listtype.ListType(ak._v2.types.unknowntype.UnknownType()),
{"__categorical__": True},
)
)
== "categorical[type=option[var * unknown]]"
)
assert (
str(
ak._v2.types.optiontype.OptionType(
ak._v2.types.regulartype.RegularType(
ak._v2.types.unknowntype.UnknownType(), 10
),
{"__categorical__": True},
)
)
== "categorical[type=option[10 * unknown]]"
)
assert (
str(
ak._v2.types.optiontype.OptionType(
ak._v2.types.unknowntype.UnknownType(),
{"x": 123, "__categorical__": True},
)
)
== 'categorical[type=option[unknown, parameters={"x": 123}]]'
)
assert (
str(
ak._v2.types.optiontype.OptionType(
ak._v2.types.listtype.ListType(ak._v2.types.unknowntype.UnknownType()),
{"x": 123, "__categorical__": True},
)
)
== 'categorical[type=option[var * unknown, parameters={"x": 123}]]'
)
assert (
str(
ak._v2.types.optiontype.OptionType(
ak._v2.types.regulartype.RegularType(
ak._v2.types.unknowntype.UnknownType(), 10
),
{"x": 123, "__categorical__": True},
)
)
== 'categorical[type=option[10 * unknown, parameters={"x": 123}]]'
)
assert (
str(
ak._v2.types.optiontype.OptionType(
ak._v2.types.unknowntype.UnknownType(),
{"__categorical__": True},
"override",
)
)
== "categorical[type=override]"
)
assert (
str(
ak._v2.types.optiontype.OptionType(
ak._v2.types.listtype.ListType(ak._v2.types.unknowntype.UnknownType()),
{"__categorical__": True},
"override",
)
)
== "categorical[type=override]"
)
assert (
str(
ak._v2.types.optiontype.OptionType(
ak._v2.types.regulartype.RegularType(
ak._v2.types.unknowntype.UnknownType(), 10
),
{"__categorical__": True},
"override",
)
)
== "categorical[type=override]"
)
assert (
str(
ak._v2.types.optiontype.OptionType(
ak._v2.types.unknowntype.UnknownType(),
{"x": 123, "__categorical__": True},
"override",
)
)
== "categorical[type=override]"
)
assert (
str(
ak._v2.types.optiontype.OptionType(
ak._v2.types.listtype.ListType(ak._v2.types.unknowntype.UnknownType()),
{"x": 123, "__categorical__": True},
"override",
)
)
== "categorical[type=override]"
)
assert (
str(
ak._v2.types.optiontype.OptionType(
ak._v2.types.regulartype.RegularType(
ak._v2.types.unknowntype.UnknownType(), 10
),
{"x": 123, "__categorical__": True},
"override",
)
)
== "categorical[type=override]"
)
assert (
repr(
ak._v2.types.optiontype.OptionType(
content=ak._v2.types.unknowntype.UnknownType()
)
)
== "OptionType(UnknownType())"
)
assert (
repr(
ak._v2.types.optiontype.OptionType(
content=ak._v2.types.listtype.ListType(
ak._v2.types.unknowntype.UnknownType()
)
)
)
== "OptionType(ListType(UnknownType()))"
)
assert (
repr(
ak._v2.types.optiontype.OptionType(
content=ak._v2.types.regulartype.RegularType(
ak._v2.types.unknowntype.UnknownType(), 10
),
parameters={"x": 123, "__categorical__": True},
typestr="override",
)
)
== "OptionType(RegularType(UnknownType(), 10), parameters={'x': 123, '__categorical__': True}, typestr='override')"
)
@pytest.mark.skipif(
ak._util.py27 or ak._util.py35, reason="Python 2.7, 3.5 have unstable dict order."
)
def test_UnionType():
assert (
str(
ak._v2.types.uniontype.UnionType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
]
)
)
== "union[unknown, bool]"
)
assert (
str(
ak._v2.types.uniontype.UnionType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
{"x": 123},
)
)
== 'union[unknown, bool, parameters={"x": 123}]'
)
assert (
str(
ak._v2.types.uniontype.UnionType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
None,
"override",
)
)
== "override"
)
assert (
str(
ak._v2.types.uniontype.UnionType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
{"x": 123},
"override",
)
)
== "override"
)
assert (
str(
ak._v2.types.uniontype.UnionType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
{"__categorical__": True},
)
)
== "categorical[type=union[unknown, bool]]"
)
assert (
str(
ak._v2.types.uniontype.UnionType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
{"x": 123, "__categorical__": True},
)
)
== 'categorical[type=union[unknown, bool, parameters={"x": 123}]]'
)
assert (
str(
ak._v2.types.uniontype.UnionType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
{"__categorical__": True},
"override",
)
)
== "categorical[type=override]"
)
assert (
str(
ak._v2.types.uniontype.UnionType(
[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
{"x": 123, "__categorical__": True},
"override",
)
)
== "categorical[type=override]"
)
assert (
repr(
ak._v2.types.uniontype.UnionType(
contents=[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
]
)
)
== "UnionType([UnknownType(), NumpyType('bool')])"
)
assert (
repr(
ak._v2.types.uniontype.UnionType(
contents=[
ak._v2.types.unknowntype.UnknownType(),
ak._v2.types.numpytype.NumpyType("bool"),
],
parameters={"x": 123, "__categorical__": True},
typestr="override",
)
)
== "UnionType([UnknownType(), NumpyType('bool')], parameters={'x': 123, '__categorical__': True}, typestr='override')"
)
def test_ArrayType():
assert (
str(
ak._v2.types.arraytype.ArrayType(ak._v2.types.unknowntype.UnknownType(), 10)
)
== "10 * unknown"
)
assert (
str(ak._v2.types.arraytype.ArrayType(ak._v2.types.unknowntype.UnknownType(), 0))
== "0 * unknown"
)
with pytest.raises(ValueError):
ak._v2.types.arraytype.ArrayType(ak._v2.types.unknowntype.UnknownType(), -1)
# ArrayType should not have these arguments (should not be a Type subclass)
with pytest.raises(TypeError):
ak._v2.types.arraytype.ArrayType(
ak._v2.types.unknowntype.UnknownType(), 10, {"x": 123}
)
with pytest.raises(TypeError):
ak._v2.types.arraytype.ArrayType(
ak._v2.types.unknowntype.UnknownType(), 10, None, "override"
)
assert (
repr(
ak._v2.types.arraytype.ArrayType(
content=ak._v2.types.unknowntype.UnknownType(), length=10
)
)
== "ArrayType(UnknownType(), 10)"
)
@pytest.mark.skipif(
ak._util.py27 or ak._util.py35, reason="Python 2.7, 3.5 have unstable dict order."
)
def test_EmptyForm():
assert (
str(ak._v2.forms.emptyform.EmptyForm())
== """{
"class": "EmptyArray"
}"""
)
assert (
str(
ak._v2.forms.emptyform.EmptyForm(
has_identifier=True, parameters={"x": 123}, form_key="hello"
)
)
== """{
"class": "EmptyArray",
"has_identifier": true,
"parameters": {
"x": 123
},
"form_key": "hello"
}"""
)
assert repr(ak._v2.forms.emptyform.EmptyForm()) == "EmptyForm()"
assert (
repr(
ak._v2.forms.emptyform.EmptyForm(
has_identifier=True, parameters={"x": 123}, form_key="hello"
)
)
== "EmptyForm(has_identifier=True, parameters={'x': 123}, form_key='hello')"
)
assert ak._v2.forms.emptyform.EmptyForm().tolist(verbose=False) == {
"class": "EmptyArray"
}
assert ak._v2.forms.emptyform.EmptyForm().tolist() == {
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.emptyform.EmptyForm(
has_identifier=True, parameters={"x": 123}, form_key="hello"
).tolist(verbose=False) == {
"class": "EmptyArray",
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
assert ak._v2.forms.from_iter({"class": "EmptyArray"}).tolist() == {
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.from_iter(
{
"class": "EmptyArray",
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
).tolist() == {
"class": "EmptyArray",
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
@pytest.mark.skipif(
ak._util.py27 or ak._util.py35, reason="Python 2.7, 3.5 have unstable dict order."
)
@pytest.mark.skipif(
ak._util.win,
reason="NumPy does not have float16, float128, and complex256 -- on Windows",
)
def test_NumpyForm():
assert (
str(ak._v2.forms.numpyform.NumpyForm("bool"))
== """{
"class": "NumpyArray",
"primitive": "bool"
}"""
)
assert (
repr(ak._v2.forms.numpyform.NumpyForm(primitive="bool")) == "NumpyForm('bool')"
)
assert (
repr(
ak._v2.forms.numpyform.NumpyForm(
primitive="bool",
inner_shape=[1, 2, 3],
has_identifier=True,
parameters={"x": 123},
form_key="hello",
)
)
== "NumpyForm('bool', inner_shape=(1, 2, 3), has_identifier=True, parameters={'x': 123}, form_key='hello')"
)
assert ak._v2.forms.numpyform.NumpyForm("bool").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "bool",
}
assert ak._v2.forms.numpyform.NumpyForm("bool").tolist() == {
"class": "NumpyArray",
"primitive": "bool",
"inner_shape": [],
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.numpyform.NumpyForm(
"bool",
inner_shape=[1, 2, 3],
has_identifier=True,
parameters={"x": 123},
form_key="hello",
).tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "bool",
"inner_shape": [1, 2, 3],
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
assert ak._v2.forms.numpyform.NumpyForm("bool").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "bool",
}
assert ak._v2.forms.numpyform.NumpyForm("int8").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "int8",
}
assert ak._v2.forms.numpyform.NumpyForm("uint8").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "uint8",
}
assert ak._v2.forms.numpyform.NumpyForm("int16").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "int16",
}
assert ak._v2.forms.numpyform.NumpyForm("uint16").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "uint16",
}
assert ak._v2.forms.numpyform.NumpyForm("int32").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "int32",
}
assert ak._v2.forms.numpyform.NumpyForm("uint32").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "uint32",
}
assert ak._v2.forms.numpyform.NumpyForm("int64").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "int64",
}
assert ak._v2.forms.numpyform.NumpyForm("uint64").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "uint64",
}
assert ak._v2.forms.numpyform.NumpyForm("float16").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "float16",
}
assert ak._v2.forms.numpyform.NumpyForm("float32").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "float32",
}
assert ak._v2.forms.numpyform.NumpyForm("float64").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "float64",
}
assert ak._v2.forms.numpyform.NumpyForm("float128").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "float128",
}
assert ak._v2.forms.numpyform.NumpyForm("complex64").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "complex64",
}
assert ak._v2.forms.numpyform.NumpyForm("complex128").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "complex128",
}
assert ak._v2.forms.numpyform.NumpyForm("complex256").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "complex256",
}
assert ak._v2.forms.numpyform.NumpyForm("datetime64").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "datetime64",
}
assert ak._v2.forms.numpyform.NumpyForm(
"datetime64", parameters={"__unit__": "s"}
).tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "datetime64",
"parameters": {"__unit__": "s"},
}
assert ak._v2.forms.numpyform.NumpyForm(
"datetime64", parameters={"__unit__": "s", "x": 123}
).tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "datetime64",
"parameters": {"__unit__": "s", "x": 123},
}
assert ak._v2.forms.numpyform.NumpyForm("timedelta64").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "timedelta64",
}
assert ak._v2.forms.numpyform.NumpyForm(
"timedelta64", parameters={"__unit__": "s"}
).tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "timedelta64",
"parameters": {"__unit__": "s"},
}
assert ak._v2.forms.numpyform.NumpyForm(
"timedelta64", parameters={"__unit__": "s", "x": 123}
).tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "timedelta64",
"parameters": {"__unit__": "s", "x": 123},
}
assert ak._v2.forms.numpyform.from_dtype(np.dtype("bool")).tolist(
verbose=False
) == {
"class": "NumpyArray",
"primitive": "bool",
}
assert ak._v2.forms.numpyform.from_dtype(np.dtype("int8")).tolist(
verbose=False
) == {
"class": "NumpyArray",
"primitive": "int8",
}
assert ak._v2.forms.numpyform.from_dtype(np.dtype("uint8")).tolist(
verbose=False
) == {
"class": "NumpyArray",
"primitive": "uint8",
}
assert ak._v2.forms.numpyform.from_dtype(np.dtype("int16")).tolist(
verbose=False
) == {
"class": "NumpyArray",
"primitive": "int16",
}
assert ak._v2.forms.numpyform.from_dtype(np.dtype("uint16")).tolist(
verbose=False
) == {
"class": "NumpyArray",
"primitive": "uint16",
}
assert ak._v2.forms.numpyform.from_dtype(np.dtype("int32")).tolist(
verbose=False
) == {
"class": "NumpyArray",
"primitive": "int32",
}
assert ak._v2.forms.numpyform.from_dtype(np.dtype("uint32")).tolist(
verbose=False
) == {
"class": "NumpyArray",
"primitive": "uint32",
}
assert ak._v2.forms.numpyform.from_dtype(np.dtype("int64")).tolist(
verbose=False
) == {
"class": "NumpyArray",
"primitive": "int64",
}
assert ak._v2.forms.numpyform.from_dtype(np.dtype("uint64")).tolist(
verbose=False
) == {
"class": "NumpyArray",
"primitive": "uint64",
}
assert ak._v2.forms.numpyform.from_dtype(np.dtype("float16")).tolist(
verbose=False
) == {
"class": "NumpyArray",
"primitive": "float16",
}
assert ak._v2.forms.numpyform.from_dtype(np.dtype("float32")).tolist(
verbose=False
) == {
"class": "NumpyArray",
"primitive": "float32",
}
assert ak._v2.forms.numpyform.from_dtype(np.dtype("float64")).tolist(
verbose=False
) == {
"class": "NumpyArray",
"primitive": "float64",
}
assert ak._v2.forms.numpyform.from_dtype(np.dtype("float128")).tolist(
verbose=False
) == {
"class": "NumpyArray",
"primitive": "float128",
}
assert ak._v2.forms.numpyform.from_dtype(np.dtype("complex64")).tolist(
verbose=False
) == {
"class": "NumpyArray",
"primitive": "complex64",
}
assert ak._v2.forms.numpyform.from_dtype(np.dtype("complex128")).tolist(
verbose=False
) == {
"class": "NumpyArray",
"primitive": "complex128",
}
assert ak._v2.forms.numpyform.from_dtype(np.dtype("complex256")).tolist(
verbose=False
) == {
"class": "NumpyArray",
"primitive": "complex256",
}
assert ak._v2.forms.numpyform.from_dtype(np.dtype("M8")).tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "datetime64",
}
assert ak._v2.forms.numpyform.from_dtype(np.dtype("M8[s]")).tolist(
verbose=False
) == {
"class": "NumpyArray",
"primitive": "datetime64",
"parameters": {"__unit__": "s"},
}
assert ak._v2.forms.numpyform.from_dtype(
np.dtype("M8[s]"), parameters={"x": 123}
).tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "datetime64",
"parameters": {"__unit__": "s", "x": 123},
}
assert ak._v2.forms.numpyform.from_dtype(np.dtype("m8")).tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "timedelta64",
}
assert ak._v2.forms.numpyform.from_dtype(np.dtype("m8[s]")).tolist(
verbose=False
) == {
"class": "NumpyArray",
"primitive": "timedelta64",
"parameters": {"__unit__": "s"},
}
assert ak._v2.forms.numpyform.from_dtype(
np.dtype("m8[s]"), parameters={"x": 123}
).tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "timedelta64",
"parameters": {"__unit__": "s", "x": 123},
}
assert ak._v2.forms.numpyform.from_dtype(np.dtype(("bool", (1, 2, 3)))).tolist(
verbose=False
) == {
"class": "NumpyArray",
"primitive": "bool",
"inner_shape": [1, 2, 3],
}
with pytest.raises(TypeError):
ak._v2.forms.from_dtype(np.dtype("O")).tolist(verbose=False)
with pytest.raises(TypeError):
ak._v2.forms.from_dtype(
np.dtype([("one", np.int64), ("two", np.float64)])
).tolist(verbose=False)
assert ak._v2.forms.from_iter("bool").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "bool",
}
assert ak._v2.forms.from_iter("int8").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "int8",
}
assert ak._v2.forms.from_iter("uint8").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "uint8",
}
assert ak._v2.forms.from_iter("int16").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "int16",
}
assert ak._v2.forms.from_iter("uint16").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "uint16",
}
assert ak._v2.forms.from_iter("int32").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "int32",
}
assert ak._v2.forms.from_iter("uint32").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "uint32",
}
assert ak._v2.forms.from_iter("int64").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "int64",
}
assert ak._v2.forms.from_iter("uint64").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "uint64",
}
assert ak._v2.forms.from_iter("float16").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "float16",
}
assert ak._v2.forms.from_iter("float32").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "float32",
}
assert ak._v2.forms.from_iter("float64").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "float64",
}
assert ak._v2.forms.from_iter("float128").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "float128",
}
assert ak._v2.forms.from_iter("complex64").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "complex64",
}
assert ak._v2.forms.from_iter("complex128").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "complex128",
}
assert ak._v2.forms.from_iter("complex256").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "complex256",
}
assert ak._v2.forms.from_iter("datetime64").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "datetime64",
}
assert ak._v2.forms.from_iter(
{
"class": "NumpyArray",
"primitive": "datetime64",
"parameters": {"__unit__": "s"},
}
).tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "datetime64",
"parameters": {"__unit__": "s"},
}
assert ak._v2.forms.from_iter(
{
"class": "NumpyArray",
"primitive": "datetime64",
"parameters": {"__unit__": "s", "x": 123},
}
).tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "datetime64",
"parameters": {"__unit__": "s", "x": 123},
}
assert ak._v2.forms.from_iter("timedelta64").tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "timedelta64",
}
assert ak._v2.forms.from_iter(
{
"class": "NumpyArray",
"primitive": "timedelta64",
"parameters": {"__unit__": "s"},
}
).tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "timedelta64",
"parameters": {"__unit__": "s"},
}
assert ak._v2.forms.from_iter(
{
"class": "NumpyArray",
"primitive": "timedelta64",
"parameters": {"__unit__": "s", "x": 123},
}
).tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "timedelta64",
"parameters": {"__unit__": "s", "x": 123},
}
assert ak._v2.forms.from_iter({"class": "NumpyArray", "primitive": "bool"}).tolist(
verbose=False
) == {
"class": "NumpyArray",
"primitive": "bool",
}
assert ak._v2.forms.from_iter({"class": "NumpyArray", "primitive": "int8"}).tolist(
verbose=False
) == {
"class": "NumpyArray",
"primitive": "int8",
}
assert ak._v2.forms.from_iter({"class": "NumpyArray", "primitive": "uint8"}).tolist(
verbose=False
) == {
"class": "NumpyArray",
"primitive": "uint8",
}
assert ak._v2.forms.from_iter({"class": "NumpyArray", "primitive": "int16"}).tolist(
verbose=False
) == {
"class": "NumpyArray",
"primitive": "int16",
}
assert ak._v2.forms.from_iter(
{"class": "NumpyArray", "primitive": "uint16"}
).tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "uint16",
}
assert ak._v2.forms.from_iter({"class": "NumpyArray", "primitive": "int32"}).tolist(
verbose=False
) == {
"class": "NumpyArray",
"primitive": "int32",
}
assert ak._v2.forms.from_iter(
{"class": "NumpyArray", "primitive": "uint32"}
).tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "uint32",
}
assert ak._v2.forms.from_iter({"class": "NumpyArray", "primitive": "int64"}).tolist(
verbose=False
) == {
"class": "NumpyArray",
"primitive": "int64",
}
assert ak._v2.forms.from_iter(
{"class": "NumpyArray", "primitive": "uint64"}
).tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "uint64",
}
assert ak._v2.forms.from_iter(
{"class": "NumpyArray", "primitive": "float16"}
).tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "float16",
}
assert ak._v2.forms.from_iter(
{"class": "NumpyArray", "primitive": "float32"}
).tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "float32",
}
assert ak._v2.forms.from_iter(
{"class": "NumpyArray", "primitive": "float64"}
).tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "float64",
}
assert ak._v2.forms.from_iter(
{"class": "NumpyArray", "primitive": "float128"}
).tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "float128",
}
assert ak._v2.forms.from_iter(
{"class": "NumpyArray", "primitive": "complex64"}
).tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "complex64",
}
assert ak._v2.forms.from_iter(
{"class": "NumpyArray", "primitive": "complex128"}
).tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "complex128",
}
assert ak._v2.forms.from_iter(
{"class": "NumpyArray", "primitive": "complex256"}
).tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "complex256",
}
assert ak._v2.forms.from_iter(
{"class": "NumpyArray", "primitive": "datetime64"}
).tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "datetime64",
}
assert ak._v2.forms.from_iter(
{"class": "NumpyArray", "primitive": "timedelta64"}
).tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "timedelta64",
}
assert ak._v2.forms.from_iter(
{
"class": "NumpyArray",
"primitive": "bool",
"inner_shape": [1, 2, 3],
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
).tolist(verbose=False) == {
"class": "NumpyArray",
"primitive": "bool",
"inner_shape": [1, 2, 3],
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
@pytest.mark.skipif(
ak._util.py27 or ak._util.py35, reason="Python 2.7, 3.5 have unstable dict order."
)
def test_RegularForm():
assert (
str(
ak._v2.forms.regularform.RegularForm(ak._v2.forms.emptyform.EmptyForm(), 10)
)
== """{
"class": "RegularArray",
"size": 10,
"content": {
"class": "EmptyArray"
}
}"""
)
assert (
str(
ak._v2.forms.regularform.RegularForm(
ak._v2.forms.emptyform.EmptyForm(),
10,
has_identifier=True,
parameters={"x": 123},
form_key="hello",
)
)
== """{
"class": "RegularArray",
"size": 10,
"content": {
"class": "EmptyArray"
},
"has_identifier": true,
"parameters": {
"x": 123
},
"form_key": "hello"
}"""
)
assert (
repr(
ak._v2.forms.regularform.RegularForm(
content=ak._v2.forms.emptyform.EmptyForm(), size=10
)
)
== "RegularForm(EmptyForm(), 10)"
)
assert (
repr(
ak._v2.forms.regularform.RegularForm(
content=ak._v2.forms.emptyform.EmptyForm(),
size=10,
has_identifier=True,
parameters={"x": 123},
form_key="hello",
)
)
== "RegularForm(EmptyForm(), 10, has_identifier=True, parameters={'x': 123}, form_key='hello')"
)
assert ak._v2.forms.regularform.RegularForm(
ak._v2.forms.emptyform.EmptyForm(), 10
).tolist(verbose=False) == {
"class": "RegularArray",
"size": 10,
"content": {"class": "EmptyArray"},
}
assert ak._v2.forms.regularform.RegularForm(
ak._v2.forms.emptyform.EmptyForm(), 10
).tolist() == {
"class": "RegularArray",
"size": 10,
"content": {
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.regularform.RegularForm(
content=ak._v2.forms.emptyform.EmptyForm(),
size=10,
has_identifier=True,
parameters={"x": 123},
form_key="hello",
).tolist(verbose=False) == {
"class": "RegularArray",
"size": 10,
"content": {"class": "EmptyArray"},
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
assert ak._v2.forms.from_iter(
{"class": "RegularArray", "size": 10, "content": {"class": "EmptyArray"}}
).tolist() == {
"class": "RegularArray",
"size": 10,
"content": {
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.from_iter(
{
"class": "RegularArray",
"size": 10,
"content": {"class": "EmptyArray"},
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
).tolist(verbose=False) == {
"class": "RegularArray",
"size": 10,
"content": {"class": "EmptyArray"},
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
assert ak._v2.forms.regularform.RegularForm(
ak._v2.forms.numpyform.NumpyForm("bool"), 10
).tolist() == {
"class": "RegularArray",
"content": {
"class": "NumpyArray",
"primitive": "bool",
"inner_shape": [],
"has_identifier": False,
"parameters": {},
"form_key": None,
},
"size": 10,
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.regularform.RegularForm(
ak._v2.forms.numpyform.NumpyForm("bool"), 10
).tolist(verbose=False) == {
"class": "RegularArray",
"content": "bool",
"size": 10,
}
@pytest.mark.skipif(
ak._util.py27 or ak._util.py35, reason="Python 2.7, 3.5 have unstable dict order."
)
def test_ListForm():
assert (
str(
ak._v2.forms.listform.ListForm(
"i32", "i32", ak._v2.forms.emptyform.EmptyForm()
)
)
== """{
"class": "ListArray",
"starts": "i32",
"stops": "i32",
"content": {
"class": "EmptyArray"
}
}"""
)
assert (
str(
ak._v2.forms.listform.ListForm(
"u32", "u32", ak._v2.forms.emptyform.EmptyForm()
)
)
== """{
"class": "ListArray",
"starts": "u32",
"stops": "u32",
"content": {
"class": "EmptyArray"
}
}"""
)
assert (
str(
ak._v2.forms.listform.ListForm(
"i64", "i64", ak._v2.forms.emptyform.EmptyForm()
)
)
== """{
"class": "ListArray",
"starts": "i64",
"stops": "i64",
"content": {
"class": "EmptyArray"
}
}"""
)
assert (
str(
ak._v2.forms.listform.ListForm(
"i32",
"i32",
ak._v2.forms.emptyform.EmptyForm(),
has_identifier=True,
parameters={"x": 123},
form_key="hello",
)
)
== """{
"class": "ListArray",
"starts": "i32",
"stops": "i32",
"content": {
"class": "EmptyArray"
},
"has_identifier": true,
"parameters": {
"x": 123
},
"form_key": "hello"
}"""
)
assert (
repr(
ak._v2.forms.listform.ListForm(
starts="i32", stops="i32", content=ak._v2.forms.emptyform.EmptyForm()
)
)
== "ListForm('i32', 'i32', EmptyForm())"
)
assert (
repr(
ak._v2.forms.listform.ListForm(
starts="i32",
stops="i32",
content=ak._v2.forms.emptyform.EmptyForm(),
has_identifier=True,
parameters={"x": 123},
form_key="hello",
)
)
== "ListForm('i32', 'i32', EmptyForm(), has_identifier=True, parameters={'x': 123}, form_key='hello')"
)
assert ak._v2.forms.listform.ListForm(
"i32", "i32", ak._v2.forms.emptyform.EmptyForm()
).tolist(verbose=False) == {
"class": "ListArray",
"starts": "i32",
"stops": "i32",
"content": {"class": "EmptyArray"},
}
assert ak._v2.forms.listform.ListForm(
"i32", "i32", ak._v2.forms.emptyform.EmptyForm()
).tolist() == {
"class": "ListArray",
"starts": "i32",
"stops": "i32",
"content": {
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.listform.ListForm(
starts="i32",
stops="i32",
content=ak._v2.forms.emptyform.EmptyForm(),
has_identifier=True,
parameters={"x": 123},
form_key="hello",
).tolist(verbose=False) == {
"class": "ListArray",
"starts": "i32",
"stops": "i32",
"content": {"class": "EmptyArray"},
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
assert ak._v2.forms.from_iter(
{
"class": "ListArray",
"starts": "i32",
"stops": "i32",
"content": {"class": "EmptyArray"},
}
).tolist() == {
"class": "ListArray",
"starts": "i32",
"stops": "i32",
"content": {
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.from_iter(
{
"class": "ListArray",
"starts": "u32",
"stops": "u32",
"content": {"class": "EmptyArray"},
}
).tolist() == {
"class": "ListArray",
"starts": "u32",
"stops": "u32",
"content": {
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.from_iter(
{
"class": "ListArray",
"starts": "i64",
"stops": "i64",
"content": {"class": "EmptyArray"},
}
).tolist() == {
"class": "ListArray",
"starts": "i64",
"stops": "i64",
"content": {
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.from_iter(
{
"class": "ListArray",
"starts": "i32",
"stops": "i32",
"content": {"class": "EmptyArray"},
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
).tolist(verbose=False) == {
"class": "ListArray",
"starts": "i32",
"stops": "i32",
"content": {"class": "EmptyArray"},
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
@pytest.mark.skipif(
ak._util.py27 or ak._util.py35, reason="Python 2.7, 3.5 have unstable dict order."
)
def test_ListOffsetForm():
assert (
str(
ak._v2.forms.listoffsetform.ListOffsetForm(
"i32", ak._v2.forms.emptyform.EmptyForm()
)
)
== """{
"class": "ListOffsetArray",
"offsets": "i32",
"content": {
"class": "EmptyArray"
}
}"""
)
assert (
str(
ak._v2.forms.listoffsetform.ListOffsetForm(
"u32", ak._v2.forms.emptyform.EmptyForm()
)
)
== """{
"class": "ListOffsetArray",
"offsets": "u32",
"content": {
"class": "EmptyArray"
}
}"""
)
assert (
str(
ak._v2.forms.listoffsetform.ListOffsetForm(
"i64", ak._v2.forms.emptyform.EmptyForm()
)
)
== """{
"class": "ListOffsetArray",
"offsets": "i64",
"content": {
"class": "EmptyArray"
}
}"""
)
assert (
str(
ak._v2.forms.listoffsetform.ListOffsetForm(
"i32",
ak._v2.forms.emptyform.EmptyForm(),
has_identifier=True,
parameters={"x": 123},
form_key="hello",
)
)
== """{
"class": "ListOffsetArray",
"offsets": "i32",
"content": {
"class": "EmptyArray"
},
"has_identifier": true,
"parameters": {
"x": 123
},
"form_key": "hello"
}"""
)
assert (
repr(
ak._v2.forms.listoffsetform.ListOffsetForm(
offsets="i32", content=ak._v2.forms.emptyform.EmptyForm()
)
)
== "ListOffsetForm('i32', EmptyForm())"
)
assert (
repr(
ak._v2.forms.listoffsetform.ListOffsetForm(
offsets="i32",
content=ak._v2.forms.emptyform.EmptyForm(),
has_identifier=True,
parameters={"x": 123},
form_key="hello",
)
)
== "ListOffsetForm('i32', EmptyForm(), has_identifier=True, parameters={'x': 123}, form_key='hello')"
)
assert ak._v2.forms.listoffsetform.ListOffsetForm(
"i32", ak._v2.forms.emptyform.EmptyForm()
).tolist(verbose=False) == {
"class": "ListOffsetArray",
"offsets": "i32",
"content": {"class": "EmptyArray"},
}
assert ak._v2.forms.listoffsetform.ListOffsetForm(
"i32", ak._v2.forms.emptyform.EmptyForm()
).tolist() == {
"class": "ListOffsetArray",
"offsets": "i32",
"content": {
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.listoffsetform.ListOffsetForm(
offsets="i32",
content=ak._v2.forms.emptyform.EmptyForm(),
has_identifier=True,
parameters={"x": 123},
form_key="hello",
).tolist(verbose=False) == {
"class": "ListOffsetArray",
"offsets": "i32",
"content": {"class": "EmptyArray"},
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
assert ak._v2.forms.from_iter(
{
"class": "ListOffsetArray",
"offsets": "i32",
"content": {"class": "EmptyArray"},
}
).tolist() == {
"class": "ListOffsetArray",
"offsets": "i32",
"content": {
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.from_iter(
{
"class": "ListOffsetArray",
"offsets": "u32",
"content": {"class": "EmptyArray"},
}
).tolist() == {
"class": "ListOffsetArray",
"offsets": "u32",
"content": {
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.from_iter(
{
"class": "ListOffsetArray",
"offsets": "i64",
"content": {"class": "EmptyArray"},
}
).tolist() == {
"class": "ListOffsetArray",
"offsets": "i64",
"content": {
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.from_iter(
{
"class": "ListOffsetArray",
"offsets": "i32",
"content": {"class": "EmptyArray"},
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
).tolist(verbose=False) == {
"class": "ListOffsetArray",
"offsets": "i32",
"content": {"class": "EmptyArray"},
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
@pytest.mark.skipif(
ak._util.py27 or ak._util.py35, reason="Python 2.7, 3.5 have unstable dict order."
)
def test_RecordForm():
assert (
str(
ak._v2.forms.recordform.RecordForm(
[
ak._v2.forms.emptyform.EmptyForm(),
ak._v2.forms.numpyform.NumpyForm("bool"),
],
None,
)
)
== """{
"class": "RecordArray",
"contents": [
{
"class": "EmptyArray"
},
"bool"
]
}"""
)
assert (
str(
ak._v2.forms.recordform.RecordForm(
[
ak._v2.forms.emptyform.EmptyForm(),
ak._v2.forms.numpyform.NumpyForm("bool"),
],
["x", "y"],
)
)
== """{
"class": "RecordArray",
"contents": {
"x": {
"class": "EmptyArray"
},
"y": "bool"
}
}"""
)
assert (
str(
ak._v2.forms.recordform.RecordForm(
[
ak._v2.forms.emptyform.EmptyForm(),
ak._v2.forms.numpyform.NumpyForm("bool"),
],
None,
has_identifier=True,
parameters={"x": 123},
form_key="hello",
)
)
== """{
"class": "RecordArray",
"contents": [
{
"class": "EmptyArray"
},
"bool"
],
"has_identifier": true,
"parameters": {
"x": 123
},
"form_key": "hello"
}"""
)
assert (
str(
ak._v2.forms.recordform.RecordForm(
[
ak._v2.forms.emptyform.EmptyForm(),
ak._v2.forms.numpyform.NumpyForm("bool"),
],
["x", "y"],
has_identifier=True,
parameters={"x": 123},
form_key="hello",
)
)
== """{
"class": "RecordArray",
"contents": {
"x": {
"class": "EmptyArray"
},
"y": "bool"
},
"has_identifier": true,
"parameters": {
"x": 123
},
"form_key": "hello"
}"""
)
assert (
repr(
ak._v2.forms.recordform.RecordForm(
[
ak._v2.forms.emptyform.EmptyForm(),
ak._v2.forms.numpyform.NumpyForm("bool"),
],
None,
)
)
== "RecordForm([EmptyForm(), NumpyForm('bool')], None)"
)
assert (
repr(
ak._v2.forms.recordform.RecordForm(
[
ak._v2.forms.emptyform.EmptyForm(),
ak._v2.forms.numpyform.NumpyForm("bool"),
],
["x", "y"],
)
)
== "RecordForm([EmptyForm(), NumpyForm('bool')], ['x', 'y'])"
)
assert (
repr(
ak._v2.forms.recordform.RecordForm(
contents=[
ak._v2.forms.emptyform.EmptyForm(),
ak._v2.forms.numpyform.NumpyForm("bool"),
],
keys=None,
has_identifier=True,
parameters={"x": 123},
form_key="hello",
)
)
== "RecordForm([EmptyForm(), NumpyForm('bool')], None, has_identifier=True, parameters={'x': 123}, form_key='hello')"
)
assert (
repr(
ak._v2.forms.recordform.RecordForm(
contents=[
ak._v2.forms.emptyform.EmptyForm(),
ak._v2.forms.numpyform.NumpyForm("bool"),
],
keys=["x", "y"],
has_identifier=True,
parameters={"x": 123},
form_key="hello",
)
)
== "RecordForm([EmptyForm(), NumpyForm('bool')], ['x', 'y'], has_identifier=True, parameters={'x': 123}, form_key='hello')"
)
assert ak._v2.forms.recordform.RecordForm(
[ak._v2.forms.emptyform.EmptyForm(), ak._v2.forms.numpyform.NumpyForm("bool")],
None,
).tolist(verbose=False) == {
"class": "RecordArray",
"contents": [
{"class": "EmptyArray"},
"bool",
],
}
assert ak._v2.forms.recordform.RecordForm(
[ak._v2.forms.emptyform.EmptyForm(), ak._v2.forms.numpyform.NumpyForm("bool")],
["x", "y"],
).tolist(verbose=False) == {
"class": "RecordArray",
"contents": {
"x": {"class": "EmptyArray"},
"y": "bool",
},
}
assert ak._v2.forms.recordform.RecordForm(
[ak._v2.forms.emptyform.EmptyForm(), ak._v2.forms.numpyform.NumpyForm("bool")],
None,
).tolist() == {
"class": "RecordArray",
"contents": [
{
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
{
"class": "NumpyArray",
"primitive": "bool",
"inner_shape": [],
"has_identifier": False,
"parameters": {},
"form_key": None,
},
],
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.recordform.RecordForm(
[ak._v2.forms.emptyform.EmptyForm(), ak._v2.forms.numpyform.NumpyForm("bool")],
["x", "y"],
).tolist() == {
"class": "RecordArray",
"contents": {
"x": {
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
"y": {
"class": "NumpyArray",
"primitive": "bool",
"inner_shape": [],
"has_identifier": False,
"parameters": {},
"form_key": None,
},
},
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.recordform.RecordForm(
contents=[
ak._v2.forms.emptyform.EmptyForm(),
ak._v2.forms.numpyform.NumpyForm("bool"),
],
keys=None,
has_identifier=True,
parameters={"x": 123},
form_key="hello",
).tolist(verbose=False) == {
"class": "RecordArray",
"contents": [
{"class": "EmptyArray"},
"bool",
],
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
assert ak._v2.forms.recordform.RecordForm(
contents=[
ak._v2.forms.emptyform.EmptyForm(),
ak._v2.forms.numpyform.NumpyForm("bool"),
],
keys=["x", "y"],
has_identifier=True,
parameters={"x": 123},
form_key="hello",
).tolist(verbose=False) == {
"class": "RecordArray",
"contents": {
"x": {"class": "EmptyArray"},
"y": "bool",
},
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
assert ak._v2.forms.from_iter(
{
"class": "RecordArray",
"contents": [
{"class": "EmptyArray"},
"bool",
],
}
).tolist() == {
"class": "RecordArray",
"contents": [
{
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
{
"class": "NumpyArray",
"primitive": "bool",
"inner_shape": [],
"has_identifier": False,
"parameters": {},
"form_key": None,
},
],
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.from_iter(
{
"class": "RecordArray",
"contents": {
"x": {"class": "EmptyArray"},
"y": "bool",
},
}
).tolist() == {
"class": "RecordArray",
"contents": {
"x": {
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
"y": {
"class": "NumpyArray",
"primitive": "bool",
"inner_shape": [],
"has_identifier": False,
"parameters": {},
"form_key": None,
},
},
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.from_iter(
{
"class": "RecordArray",
"contents": [
{"class": "EmptyArray"},
"bool",
],
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
).tolist(verbose=False) == {
"class": "RecordArray",
"contents": [
{"class": "EmptyArray"},
"bool",
],
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
assert ak._v2.forms.from_iter(
{
"class": "RecordArray",
"contents": {
"x": {"class": "EmptyArray"},
"y": "bool",
},
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
).tolist(verbose=False) == {
"class": "RecordArray",
"contents": {
"x": {"class": "EmptyArray"},
"y": "bool",
},
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
@pytest.mark.skipif(
ak._util.py27 or ak._util.py35, reason="Python 2.7, 3.5 have unstable dict order."
)
def test_IndexedForm():
assert (
str(
ak._v2.forms.indexedform.IndexedForm(
"i32", ak._v2.forms.emptyform.EmptyForm()
)
)
== """{
"class": "IndexedArray",
"index": "i32",
"content": {
"class": "EmptyArray"
}
}"""
)
assert (
str(
ak._v2.forms.indexedform.IndexedForm(
"u32", ak._v2.forms.emptyform.EmptyForm()
)
)
== """{
"class": "IndexedArray",
"index": "u32",
"content": {
"class": "EmptyArray"
}
}"""
)
assert (
str(
ak._v2.forms.indexedform.IndexedForm(
"i64", ak._v2.forms.emptyform.EmptyForm()
)
)
== """{
"class": "IndexedArray",
"index": "i64",
"content": {
"class": "EmptyArray"
}
}"""
)
assert (
str(
ak._v2.forms.indexedform.IndexedForm(
"i32",
ak._v2.forms.emptyform.EmptyForm(),
has_identifier=True,
parameters={"x": 123},
form_key="hello",
)
)
== """{
"class": "IndexedArray",
"index": "i32",
"content": {
"class": "EmptyArray"
},
"has_identifier": true,
"parameters": {
"x": 123
},
"form_key": "hello"
}"""
)
assert (
repr(
ak._v2.forms.indexedform.IndexedForm(
index="i32", content=ak._v2.forms.emptyform.EmptyForm()
)
)
== "IndexedForm('i32', EmptyForm())"
)
assert (
repr(
ak._v2.forms.indexedform.IndexedForm(
index="i32",
content=ak._v2.forms.emptyform.EmptyForm(),
has_identifier=True,
parameters={"x": 123},
form_key="hello",
)
)
== "IndexedForm('i32', EmptyForm(), has_identifier=True, parameters={'x': 123}, form_key='hello')"
)
assert ak._v2.forms.indexedform.IndexedForm(
"i32", ak._v2.forms.emptyform.EmptyForm()
).tolist(verbose=False) == {
"class": "IndexedArray",
"index": "i32",
"content": {"class": "EmptyArray"},
}
assert ak._v2.forms.indexedform.IndexedForm(
"i32", ak._v2.forms.emptyform.EmptyForm()
).tolist() == {
"class": "IndexedArray",
"index": "i32",
"content": {
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.indexedform.IndexedForm(
index="i32",
content=ak._v2.forms.emptyform.EmptyForm(),
has_identifier=True,
parameters={"x": 123},
form_key="hello",
).tolist(verbose=False) == {
"class": "IndexedArray",
"index": "i32",
"content": {"class": "EmptyArray"},
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
assert ak._v2.forms.from_iter(
{
"class": "IndexedArray",
"index": "i32",
"content": {"class": "EmptyArray"},
}
).tolist() == {
"class": "IndexedArray",
"index": "i32",
"content": {
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.from_iter(
{
"class": "IndexedArray",
"index": "u32",
"content": {"class": "EmptyArray"},
}
).tolist() == {
"class": "IndexedArray",
"index": "u32",
"content": {
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.from_iter(
{
"class": "IndexedArray",
"index": "i64",
"content": {"class": "EmptyArray"},
}
).tolist() == {
"class": "IndexedArray",
"index": "i64",
"content": {
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.from_iter(
{
"class": "IndexedArray",
"index": "i32",
"content": {"class": "EmptyArray"},
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
).tolist(verbose=False) == {
"class": "IndexedArray",
"index": "i32",
"content": {"class": "EmptyArray"},
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
@pytest.mark.skipif(
ak._util.py27 or ak._util.py35, reason="Python 2.7, 3.5 have unstable dict order."
)
def test_IndexedOptionForm():
assert (
str(
ak._v2.forms.indexedoptionform.IndexedOptionForm(
"i32", ak._v2.forms.emptyform.EmptyForm()
)
)
== """{
"class": "IndexedOptionArray",
"index": "i32",
"content": {
"class": "EmptyArray"
}
}"""
)
assert (
str(
ak._v2.forms.indexedoptionform.IndexedOptionForm(
"i64", ak._v2.forms.emptyform.EmptyForm()
)
)
== """{
"class": "IndexedOptionArray",
"index": "i64",
"content": {
"class": "EmptyArray"
}
}"""
)
assert (
str(
ak._v2.forms.indexedoptionform.IndexedOptionForm(
"i32",
ak._v2.forms.emptyform.EmptyForm(),
has_identifier=True,
parameters={"x": 123},
form_key="hello",
)
)
== """{
"class": "IndexedOptionArray",
"index": "i32",
"content": {
"class": "EmptyArray"
},
"has_identifier": true,
"parameters": {
"x": 123
},
"form_key": "hello"
}"""
)
assert (
repr(
ak._v2.forms.indexedoptionform.IndexedOptionForm(
index="i32", content=ak._v2.forms.emptyform.EmptyForm()
)
)
== "IndexedOptionForm('i32', EmptyForm())"
)
assert (
repr(
ak._v2.forms.indexedoptionform.IndexedOptionForm(
index="i32",
content=ak._v2.forms.emptyform.EmptyForm(),
has_identifier=True,
parameters={"x": 123},
form_key="hello",
)
)
== "IndexedOptionForm('i32', EmptyForm(), has_identifier=True, parameters={'x': 123}, form_key='hello')"
)
assert ak._v2.forms.indexedoptionform.IndexedOptionForm(
"i32", ak._v2.forms.emptyform.EmptyForm()
).tolist(verbose=False) == {
"class": "IndexedOptionArray",
"index": "i32",
"content": {"class": "EmptyArray"},
}
assert ak._v2.forms.indexedoptionform.IndexedOptionForm(
"i32", ak._v2.forms.emptyform.EmptyForm()
).tolist() == {
"class": "IndexedOptionArray",
"index": "i32",
"content": {
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.indexedoptionform.IndexedOptionForm(
index="i32",
content=ak._v2.forms.emptyform.EmptyForm(),
has_identifier=True,
parameters={"x": 123},
form_key="hello",
).tolist(verbose=False) == {
"class": "IndexedOptionArray",
"index": "i32",
"content": {"class": "EmptyArray"},
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
assert ak._v2.forms.from_iter(
{
"class": "IndexedOptionArray",
"index": "i32",
"content": {"class": "EmptyArray"},
}
).tolist() == {
"class": "IndexedOptionArray",
"index": "i32",
"content": {
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.from_iter(
{
"class": "IndexedOptionArray",
"index": "i64",
"content": {"class": "EmptyArray"},
}
).tolist() == {
"class": "IndexedOptionArray",
"index": "i64",
"content": {
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.from_iter(
{
"class": "IndexedOptionArray",
"index": "i32",
"content": {"class": "EmptyArray"},
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
).tolist(verbose=False) == {
"class": "IndexedOptionArray",
"index": "i32",
"content": {"class": "EmptyArray"},
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
@pytest.mark.skipif(
ak._util.py27 or ak._util.py35, reason="Python 2.7, 3.5 have unstable dict order."
)
def test_ByteMaskedForm():
assert (
str(
ak._v2.forms.bytemaskedform.ByteMaskedForm(
"i8", ak._v2.forms.emptyform.EmptyForm(), True
)
)
== """{
"class": "ByteMaskedArray",
"mask": "i8",
"valid_when": true,
"content": {
"class": "EmptyArray"
}
}"""
)
assert (
str(
ak._v2.forms.bytemaskedform.ByteMaskedForm(
"i8", ak._v2.forms.emptyform.EmptyForm(), False
)
)
== """{
"class": "ByteMaskedArray",
"mask": "i8",
"valid_when": false,
"content": {
"class": "EmptyArray"
}
}"""
)
assert (
str(
ak._v2.forms.bytemaskedform.ByteMaskedForm(
"i8",
ak._v2.forms.emptyform.EmptyForm(),
True,
has_identifier=True,
parameters={"x": 123},
form_key="hello",
)
)
== """{
"class": "ByteMaskedArray",
"mask": "i8",
"valid_when": true,
"content": {
"class": "EmptyArray"
},
"has_identifier": true,
"parameters": {
"x": 123
},
"form_key": "hello"
}"""
)
assert (
repr(
ak._v2.forms.bytemaskedform.ByteMaskedForm(
mask="i8", content=ak._v2.forms.emptyform.EmptyForm(), valid_when=True
)
)
== "ByteMaskedForm('i8', EmptyForm(), True)"
)
assert (
repr(
ak._v2.forms.bytemaskedform.ByteMaskedForm(
mask="i8",
content=ak._v2.forms.emptyform.EmptyForm(),
valid_when=True,
has_identifier=True,
parameters={"x": 123},
form_key="hello",
)
)
== "ByteMaskedForm('i8', EmptyForm(), True, has_identifier=True, parameters={'x': 123}, form_key='hello')"
)
assert ak._v2.forms.bytemaskedform.ByteMaskedForm(
"i8", ak._v2.forms.emptyform.EmptyForm(), True
).tolist(verbose=False) == {
"class": "ByteMaskedArray",
"mask": "i8",
"valid_when": True,
"content": {"class": "EmptyArray"},
}
assert ak._v2.forms.bytemaskedform.ByteMaskedForm(
"i8", ak._v2.forms.emptyform.EmptyForm(), True
).tolist() == {
"class": "ByteMaskedArray",
"mask": "i8",
"valid_when": True,
"content": {
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.bytemaskedform.ByteMaskedForm(
mask="i8",
content=ak._v2.forms.emptyform.EmptyForm(),
valid_when=True,
has_identifier=True,
parameters={"x": 123},
form_key="hello",
).tolist(verbose=False) == {
"class": "ByteMaskedArray",
"mask": "i8",
"valid_when": True,
"content": {"class": "EmptyArray"},
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
assert ak._v2.forms.from_iter(
{
"class": "ByteMaskedArray",
"mask": "i8",
"valid_when": True,
"content": {"class": "EmptyArray"},
}
).tolist() == {
"class": "ByteMaskedArray",
"mask": "i8",
"valid_when": True,
"content": {
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.from_iter(
{
"class": "ByteMaskedArray",
"mask": "i64",
"valid_when": True,
"content": {"class": "EmptyArray"},
}
).tolist() == {
"class": "ByteMaskedArray",
"mask": "i64",
"valid_when": True,
"content": {
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.from_iter(
{
"class": "ByteMaskedArray",
"mask": "i8",
"valid_when": True,
"content": {"class": "EmptyArray"},
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
).tolist(verbose=False) == {
"class": "ByteMaskedArray",
"mask": "i8",
"valid_when": True,
"content": {"class": "EmptyArray"},
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
@pytest.mark.skipif(
ak._util.py27 or ak._util.py35, reason="Python 2.7, 3.5 have unstable dict order."
)
def test_BitMaskedForm():
assert (
str(
ak._v2.forms.bitmaskedform.BitMaskedForm(
"u8", ak._v2.forms.emptyform.EmptyForm(), True, True
)
)
== """{
"class": "BitMaskedArray",
"mask": "u8",
"valid_when": true,
"lsb_order": true,
"content": {
"class": "EmptyArray"
}
}"""
)
assert (
str(
ak._v2.forms.bitmaskedform.BitMaskedForm(
"u8", ak._v2.forms.emptyform.EmptyForm(), False, True
)
)
== """{
"class": "BitMaskedArray",
"mask": "u8",
"valid_when": false,
"lsb_order": true,
"content": {
"class": "EmptyArray"
}
}"""
)
assert (
str(
ak._v2.forms.bitmaskedform.BitMaskedForm(
"u8", ak._v2.forms.emptyform.EmptyForm(), True, False
)
)
== """{
"class": "BitMaskedArray",
"mask": "u8",
"valid_when": true,
"lsb_order": false,
"content": {
"class": "EmptyArray"
}
}"""
)
assert (
str(
ak._v2.forms.bitmaskedform.BitMaskedForm(
"u8", ak._v2.forms.emptyform.EmptyForm(), False, False
)
)
== """{
"class": "BitMaskedArray",
"mask": "u8",
"valid_when": false,
"lsb_order": false,
"content": {
"class": "EmptyArray"
}
}"""
)
assert (
str(
ak._v2.forms.bitmaskedform.BitMaskedForm(
"u8",
ak._v2.forms.emptyform.EmptyForm(),
True,
False,
has_identifier=True,
parameters={"x": 123},
form_key="hello",
)
)
== """{
"class": "BitMaskedArray",
"mask": "u8",
"valid_when": true,
"lsb_order": false,
"content": {
"class": "EmptyArray"
},
"has_identifier": true,
"parameters": {
"x": 123
},
"form_key": "hello"
}"""
)
assert (
repr(
ak._v2.forms.bitmaskedform.BitMaskedForm(
mask="u8",
content=ak._v2.forms.emptyform.EmptyForm(),
valid_when=True,
lsb_order=False,
)
)
== "BitMaskedForm('u8', EmptyForm(), True, False)"
)
assert (
repr(
ak._v2.forms.bitmaskedform.BitMaskedForm(
mask="u8",
content=ak._v2.forms.emptyform.EmptyForm(),
valid_when=True,
lsb_order=False,
has_identifier=True,
parameters={"x": 123},
form_key="hello",
)
)
== "BitMaskedForm('u8', EmptyForm(), True, False, has_identifier=True, parameters={'x': 123}, form_key='hello')"
)
assert ak._v2.forms.bitmaskedform.BitMaskedForm(
"u8", ak._v2.forms.emptyform.EmptyForm(), True, False
).tolist(verbose=False) == {
"class": "BitMaskedArray",
"mask": "u8",
"valid_when": True,
"lsb_order": False,
"content": {"class": "EmptyArray"},
}
assert ak._v2.forms.bitmaskedform.BitMaskedForm(
"u8", ak._v2.forms.emptyform.EmptyForm(), True, False
).tolist() == {
"class": "BitMaskedArray",
"mask": "u8",
"valid_when": True,
"lsb_order": False,
"content": {
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.bitmaskedform.BitMaskedForm(
mask="u8",
content=ak._v2.forms.emptyform.EmptyForm(),
valid_when=True,
lsb_order=False,
has_identifier=True,
parameters={"x": 123},
form_key="hello",
).tolist(verbose=False) == {
"class": "BitMaskedArray",
"mask": "u8",
"valid_when": True,
"lsb_order": False,
"content": {"class": "EmptyArray"},
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
assert ak._v2.forms.from_iter(
{
"class": "BitMaskedArray",
"mask": "u8",
"valid_when": True,
"lsb_order": False,
"content": {"class": "EmptyArray"},
}
).tolist() == {
"class": "BitMaskedArray",
"mask": "u8",
"valid_when": True,
"lsb_order": False,
"content": {
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.from_iter(
{
"class": "BitMaskedArray",
"mask": "i64",
"valid_when": True,
"lsb_order": False,
"content": {"class": "EmptyArray"},
}
).tolist() == {
"class": "BitMaskedArray",
"mask": "i64",
"valid_when": True,
"lsb_order": False,
"content": {
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.from_iter(
{
"class": "BitMaskedArray",
"mask": "u8",
"valid_when": True,
"lsb_order": False,
"content": {"class": "EmptyArray"},
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
).tolist(verbose=False) == {
"class": "BitMaskedArray",
"mask": "u8",
"valid_when": True,
"lsb_order": False,
"content": {"class": "EmptyArray"},
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
@pytest.mark.skipif(
ak._util.py27 or ak._util.py35, reason="Python 2.7, 3.5 have unstable dict order."
)
def test_UnmaskedForm():
assert (
str(ak._v2.forms.unmaskedform.UnmaskedForm(ak._v2.forms.emptyform.EmptyForm()))
== """{
"class": "UnmaskedArray",
"content": {
"class": "EmptyArray"
}
}"""
)
assert (
str(
ak._v2.forms.unmaskedform.UnmaskedForm(
ak._v2.forms.emptyform.EmptyForm(),
has_identifier=True,
parameters={"x": 123},
form_key="hello",
)
)
== """{
"class": "UnmaskedArray",
"content": {
"class": "EmptyArray"
},
"has_identifier": true,
"parameters": {
"x": 123
},
"form_key": "hello"
}"""
)
assert (
repr(
ak._v2.forms.unmaskedform.UnmaskedForm(
content=ak._v2.forms.emptyform.EmptyForm()
)
)
== "UnmaskedForm(EmptyForm())"
)
assert (
repr(
ak._v2.forms.unmaskedform.UnmaskedForm(
content=ak._v2.forms.emptyform.EmptyForm(),
has_identifier=True,
parameters={"x": 123},
form_key="hello",
)
)
== "UnmaskedForm(EmptyForm(), has_identifier=True, parameters={'x': 123}, form_key='hello')"
)
assert ak._v2.forms.unmaskedform.UnmaskedForm(
ak._v2.forms.emptyform.EmptyForm()
).tolist(verbose=False) == {
"class": "UnmaskedArray",
"content": {"class": "EmptyArray"},
}
assert ak._v2.forms.unmaskedform.UnmaskedForm(
ak._v2.forms.emptyform.EmptyForm()
).tolist() == {
"class": "UnmaskedArray",
"content": {
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.unmaskedform.UnmaskedForm(
content=ak._v2.forms.emptyform.EmptyForm(),
has_identifier=True,
parameters={"x": 123},
form_key="hello",
).tolist(verbose=False) == {
"class": "UnmaskedArray",
"content": {"class": "EmptyArray"},
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
assert ak._v2.forms.from_iter(
{"class": "UnmaskedArray", "content": {"class": "EmptyArray"}}
).tolist() == {
"class": "UnmaskedArray",
"content": {
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.from_iter(
{
"class": "UnmaskedArray",
"content": {"class": "EmptyArray"},
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
).tolist(verbose=False) == {
"class": "UnmaskedArray",
"content": {"class": "EmptyArray"},
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
@pytest.mark.skipif(
ak._util.py27 or ak._util.py35, reason="Python 2.7, 3.5 have unstable dict order."
)
def test_UnionForm():
assert (
str(
ak._v2.forms.unionform.UnionForm(
"i8",
"i32",
[
ak._v2.forms.emptyform.EmptyForm(),
ak._v2.forms.numpyform.NumpyForm("bool"),
],
)
)
== """{
"class": "UnionArray",
"tags": "i8",
"index": "i32",
"contents": [
{
"class": "EmptyArray"
},
"bool"
]
}"""
)
assert (
str(
ak._v2.forms.unionform.UnionForm(
"i8",
"u32",
[
ak._v2.forms.emptyform.EmptyForm(),
ak._v2.forms.numpyform.NumpyForm("bool"),
],
)
)
== """{
"class": "UnionArray",
"tags": "i8",
"index": "u32",
"contents": [
{
"class": "EmptyArray"
},
"bool"
]
}"""
)
assert (
str(
ak._v2.forms.unionform.UnionForm(
"i8",
"i64",
[
ak._v2.forms.emptyform.EmptyForm(),
ak._v2.forms.numpyform.NumpyForm("bool"),
],
)
)
== """{
"class": "UnionArray",
"tags": "i8",
"index": "i64",
"contents": [
{
"class": "EmptyArray"
},
"bool"
]
}"""
)
assert (
str(
ak._v2.forms.unionform.UnionForm(
"i8",
"i32",
[
ak._v2.forms.emptyform.EmptyForm(),
ak._v2.forms.numpyform.NumpyForm("bool"),
],
has_identifier=True,
parameters={"x": 123},
form_key="hello",
)
)
== """{
"class": "UnionArray",
"tags": "i8",
"index": "i32",
"contents": [
{
"class": "EmptyArray"
},
"bool"
],
"has_identifier": true,
"parameters": {
"x": 123
},
"form_key": "hello"
}"""
)
assert (
repr(
ak._v2.forms.unionform.UnionForm(
"i8",
"i32",
[
ak._v2.forms.emptyform.EmptyForm(),
ak._v2.forms.numpyform.NumpyForm("bool"),
],
)
)
== "UnionForm('i8', 'i32', [EmptyForm(), NumpyForm('bool')])"
)
assert (
repr(
ak._v2.forms.unionform.UnionForm(
tags="i8",
index="i32",
contents=[
ak._v2.forms.emptyform.EmptyForm(),
ak._v2.forms.numpyform.NumpyForm("bool"),
],
has_identifier=True,
parameters={"x": 123},
form_key="hello",
)
)
== "UnionForm('i8', 'i32', [EmptyForm(), NumpyForm('bool')], has_identifier=True, parameters={'x': 123}, form_key='hello')"
)
assert ak._v2.forms.unionform.UnionForm(
"i8",
"i32",
[ak._v2.forms.emptyform.EmptyForm(), ak._v2.forms.numpyform.NumpyForm("bool")],
).tolist(verbose=False) == {
"class": "UnionArray",
"tags": "i8",
"index": "i32",
"contents": [
{"class": "EmptyArray"},
"bool",
],
}
assert ak._v2.forms.unionform.UnionForm(
"i8",
"i32",
[ak._v2.forms.emptyform.EmptyForm(), ak._v2.forms.numpyform.NumpyForm("bool")],
).tolist() == {
"class": "UnionArray",
"tags": "i8",
"index": "i32",
"contents": [
{
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
{
"class": "NumpyArray",
"primitive": "bool",
"inner_shape": [],
"has_identifier": False,
"parameters": {},
"form_key": None,
},
],
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.unionform.UnionForm(
tags="i8",
index="i32",
contents=[
ak._v2.forms.emptyform.EmptyForm(),
ak._v2.forms.numpyform.NumpyForm("bool"),
],
has_identifier=True,
parameters={"x": 123},
form_key="hello",
).tolist(verbose=False) == {
"class": "UnionArray",
"tags": "i8",
"index": "i32",
"contents": [
{"class": "EmptyArray"},
"bool",
],
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
assert ak._v2.forms.from_iter(
{
"class": "UnionArray",
"tags": "i8",
"index": "i32",
"contents": [
{"class": "EmptyArray"},
"bool",
],
}
).tolist() == {
"class": "UnionArray",
"tags": "i8",
"index": "i32",
"contents": [
{
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
{
"class": "NumpyArray",
"primitive": "bool",
"inner_shape": [],
"has_identifier": False,
"parameters": {},
"form_key": None,
},
],
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.from_iter(
{
"class": "UnionArray",
"tags": "i8",
"index": "u32",
"contents": [
{"class": "EmptyArray"},
"bool",
],
}
).tolist() == {
"class": "UnionArray",
"tags": "i8",
"index": "u32",
"contents": [
{
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
{
"class": "NumpyArray",
"primitive": "bool",
"inner_shape": [],
"has_identifier": False,
"parameters": {},
"form_key": None,
},
],
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.from_iter(
{
"class": "UnionArray",
"tags": "i8",
"index": "i64",
"contents": [
{"class": "EmptyArray"},
"bool",
],
}
).tolist() == {
"class": "UnionArray",
"tags": "i8",
"index": "i64",
"contents": [
{
"class": "EmptyArray",
"has_identifier": False,
"parameters": {},
"form_key": None,
},
{
"class": "NumpyArray",
"primitive": "bool",
"inner_shape": [],
"has_identifier": False,
"parameters": {},
"form_key": None,
},
],
"has_identifier": False,
"parameters": {},
"form_key": None,
}
assert ak._v2.forms.from_iter(
{
"class": "UnionArray",
"tags": "i8",
"index": "i32",
"contents": [
{"class": "EmptyArray"},
"bool",
],
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
).tolist(verbose=False) == {
"class": "UnionArray",
"tags": "i8",
"index": "i32",
"contents": [
{"class": "EmptyArray"},
"bool",
],
"has_identifier": True,
"parameters": {"x": 123},
"form_key": "hello",
}
| 68,799 |
1,338 | /*
* Copyright (c) 2015 <NAME> <<EMAIL>>
* Copyright (c) 2002, 2003 <NAME> <<EMAIL>>
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files or portions
* thereof (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:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright notice
* in the binary, as well as this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with
* the distribution.
*
* 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 <MediaEventLooper.h>
#include <TimeSource.h>
#include <scheduler.h>
#include <Buffer.h>
#include <ServerInterface.h>
#include "MediaDebug.h"
/*************************************************************
* protected BMediaEventLooper
*************************************************************/
/* virtual */
BMediaEventLooper::~BMediaEventLooper()
{
CALLED();
// don't call Quit(); here, except if the user was stupid
if (fControlThread != -1) {
printf("You MUST call BMediaEventLooper::Quit() in your destructor!\n");
Quit();
}
}
/* explicit */
BMediaEventLooper::BMediaEventLooper(uint32 apiVersion) :
BMediaNode("called by BMediaEventLooper"),
fControlThread(-1),
fCurrentPriority(B_URGENT_PRIORITY),
fSetPriority(B_URGENT_PRIORITY),
fRunState(B_UNREGISTERED),
fEventLatency(0),
fSchedulingLatency(0),
fBufferDuration(0),
fOfflineTime(0),
fApiVersion(apiVersion)
{
CALLED();
fEventQueue.SetCleanupHook(BMediaEventLooper::_CleanUpEntry, this);
fRealTimeQueue.SetCleanupHook(BMediaEventLooper::_CleanUpEntry, this);
}
/* virtual */ void
BMediaEventLooper::NodeRegistered()
{
CALLED();
// Calling Run() should be done by the derived class,
// at least that's how it is documented by the BeBook.
// It appears that BeOS R5 called it here. Calling Run()
// twice doesn't hurt, and some nodes need it to be called here.
Run();
}
/* virtual */ void
BMediaEventLooper::Start(bigtime_t performance_time)
{
CALLED();
// This hook function is called when a node is started
// by a call to the BMediaRoster. The specified
// performanceTime, the time at which the node
// should start running, may be in the future.
fEventQueue.AddEvent(media_timed_event(performance_time, BTimedEventQueue::B_START));
}
/* virtual */ void
BMediaEventLooper::Stop(bigtime_t performance_time,
bool immediate)
{
CALLED();
// This hook function is called when a node is stopped
// by a call to the BMediaRoster. The specified performanceTime,
// the time at which the node should stop, may be in the future.
// If immediate is true, your node should ignore the performanceTime
// value and synchronously stop performance. When Stop() returns,
// you're promising not to write into any BBuffers you may have
// received from your downstream consumers, and you promise not
// to send any more buffers until Start() is called again.
if (immediate) {
// always be sure to add to the front of the queue so we can make sure it is
// handled before any buffers are sent!
performance_time = 0;
}
fEventQueue.AddEvent(media_timed_event(performance_time, BTimedEventQueue::B_STOP));
}
/* virtual */ void
BMediaEventLooper::Seek(bigtime_t media_time,
bigtime_t performance_time)
{
CALLED();
// This hook function is called when a node is asked to seek to
// the specified mediaTime by a call to the BMediaRoster.
// The specified performanceTime, the time at which the node
// should begin the seek operation, may be in the future.
fEventQueue.AddEvent(media_timed_event(performance_time, BTimedEventQueue::B_SEEK, NULL,
BTimedEventQueue::B_NO_CLEANUP, 0, media_time, NULL));
}
/* virtual */ void
BMediaEventLooper::TimeWarp(bigtime_t at_real_time,
bigtime_t to_performance_time)
{
CALLED();
// This hook function is called when the time source to which the
// node is slaved is repositioned (via a seek operation) such that
// there will be a sudden jump in the performance time progression
// as seen by the node. The to_performance_time argument indicates
// the new performance time; the change should occur at the real
// time specified by the at_real_time argument.
// place in the realtime queue
fRealTimeQueue.AddEvent(media_timed_event(at_real_time, BTimedEventQueue::B_WARP,
NULL, BTimedEventQueue::B_NO_CLEANUP, 0, to_performance_time, NULL));
// BeBook: Your implementation of TimeWarp() should call through to BMediaNode::TimeWarp()
// BeBook: as well as all other inherited forms of TimeWarp()
// XXX should we do this here?
BMediaNode::TimeWarp(at_real_time, to_performance_time);
}
/* virtual */ status_t
BMediaEventLooper::AddTimer(bigtime_t at_performance_time,
int32 cookie)
{
CALLED();
media_timed_event event(at_performance_time,
BTimedEventQueue::B_TIMER, NULL,
BTimedEventQueue::B_EXPIRE_TIMER);
event.data = cookie;
return EventQueue()->AddEvent(event);
}
/* virtual */ void
BMediaEventLooper::SetRunMode(run_mode mode)
{
CALLED();
// The SetRunMode() hook function is called when someone requests that your node's run mode be changed.
// bump or reduce priority when switching from/to offline run mode
int32 priority;
priority = (mode == B_OFFLINE) ? min_c(B_NORMAL_PRIORITY, fSetPriority) : fSetPriority;
if (priority != fCurrentPriority) {
fCurrentPriority = priority;
if (fControlThread > 0) {
set_thread_priority(fControlThread, fCurrentPriority);
fSchedulingLatency = estimate_max_scheduling_latency(fControlThread);
printf("BMediaEventLooper: SchedulingLatency is %" B_PRId64 "\n",
fSchedulingLatency);
}
}
BMediaNode::SetRunMode(mode);
}
/* virtual */ void
BMediaEventLooper::CleanUpEvent(const media_timed_event *event)
{
CALLED();
// Implement this function to clean up after custom events you've created
// and added to your queue. It's called when a custom event is removed from
// the queue, to let you handle any special tidying-up that the event might require.
}
/* virtual */ bigtime_t
BMediaEventLooper::OfflineTime()
{
CALLED();
return fOfflineTime;
}
/* virtual */ void
BMediaEventLooper::ControlLoop()
{
CALLED();
status_t err = B_OK;
bigtime_t waitUntil = B_INFINITE_TIMEOUT;
bool hasRealtime = false;
bool hasEvent = false;
// While there are no events or it is not time for the earliest event,
// process messages using WaitForMessages. Whenever this funtion times out,
// we need to handle the next event
fSchedulingLatency = estimate_max_scheduling_latency(fControlThread);
while (RunState() != B_QUITTING) {
if (err == B_TIMED_OUT
|| err == B_WOULD_BLOCK) {
// NOTE: The reference for doing the lateness calculus this way can
// be found in the BeBook article "A BMediaEventLooper Example".
// The value which we are going to calculate, is referred there as
// 'lateness'.
media_timed_event event;
if (hasEvent)
err = fEventQueue.RemoveFirstEvent(&event);
else if (hasRealtime)
err = fRealTimeQueue.RemoveFirstEvent(&event);
if (err == B_OK) {
// The general idea of lateness is to allow
// the client code to detect when the buffer
// is handled late or early.
bigtime_t lateness = TimeSource()->RealTime() - waitUntil;
DispatchEvent(&event, lateness, hasRealtime);
}
} else if (err != B_OK)
return;
// BMediaEventLooper compensates your performance time by adding
// the event latency (see SetEventLatency()) and the scheduling
// latency (or, for real-time events, only the scheduling latency).
hasRealtime = fRealTimeQueue.HasEvents();
hasEvent = fEventQueue.HasEvents();
if (hasEvent) {
waitUntil = TimeSource()->RealTimeFor(
fEventQueue.FirstEventTime(),
fEventLatency + fSchedulingLatency);
} else if (!hasRealtime)
waitUntil = B_INFINITE_TIMEOUT;
if (hasRealtime) {
bigtime_t realtimeWait = fRealTimeQueue.FirstEventTime()
- fSchedulingLatency;
if (!hasEvent || realtimeWait <= waitUntil) {
waitUntil = realtimeWait;
hasEvent = false;
} else
hasRealtime = false;
}
if (waitUntil != B_INFINITE_TIMEOUT
&& TimeSource()->RealTime() >= waitUntil) {
err = WaitForMessage(0);
} else
err = WaitForMessage(waitUntil);
}
}
thread_id
BMediaEventLooper::ControlThread()
{
CALLED();
return fControlThread;
}
/*************************************************************
* protected BMediaEventLooper
*************************************************************/
BTimedEventQueue *
BMediaEventLooper::EventQueue()
{
CALLED();
return &fEventQueue;
}
BTimedEventQueue *
BMediaEventLooper::RealTimeQueue()
{
CALLED();
return &fRealTimeQueue;
}
int32
BMediaEventLooper::Priority() const
{
CALLED();
return fCurrentPriority;
}
int32
BMediaEventLooper::RunState() const
{
PRINT(6, "CALLED BMediaEventLooper::RunState()\n");
return fRunState;
}
bigtime_t
BMediaEventLooper::EventLatency() const
{
CALLED();
return fEventLatency;
}
bigtime_t
BMediaEventLooper::BufferDuration() const
{
CALLED();
return fBufferDuration;
}
bigtime_t
BMediaEventLooper::SchedulingLatency() const
{
CALLED();
return fSchedulingLatency;
}
status_t
BMediaEventLooper::SetPriority(int32 priority)
{
CALLED();
// clamp to a valid value
if (priority < 5)
priority = 5;
if (priority > 120)
priority = 120;
fSetPriority = priority;
fCurrentPriority = (RunMode() == B_OFFLINE) ? min_c(B_NORMAL_PRIORITY, fSetPriority) : fSetPriority;
if (fControlThread > 0) {
set_thread_priority(fControlThread, fCurrentPriority);
fSchedulingLatency = estimate_max_scheduling_latency(fControlThread);
printf("BMediaEventLooper: SchedulingLatency is %" B_PRId64 "\n",
fSchedulingLatency);
}
return B_OK;
}
void
BMediaEventLooper::SetRunState(run_state state)
{
CALLED();
// don't allow run state changes while quitting,
// also needed for correct terminating of the ControlLoop()
if (fRunState == B_QUITTING && state != B_TERMINATED)
return;
fRunState = state;
}
void
BMediaEventLooper::SetEventLatency(bigtime_t latency)
{
CALLED();
// clamp to a valid value
if (latency < 0)
latency = 0;
fEventLatency = latency;
write_port_etc(ControlPort(), GENERAL_PURPOSE_WAKEUP, 0, 0, B_TIMEOUT, 0);
}
void
BMediaEventLooper::SetBufferDuration(bigtime_t duration)
{
CALLED();
if (duration < 0)
duration = 0;
fBufferDuration = duration;
}
void
BMediaEventLooper::SetOfflineTime(bigtime_t offTime)
{
CALLED();
fOfflineTime = offTime;
}
void
BMediaEventLooper::Run()
{
CALLED();
if (fControlThread != -1)
return; // thread already running
// until now, the run state is B_UNREGISTERED, but we need to start in B_STOPPED state.
SetRunState(B_STOPPED);
char threadName[32];
sprintf(threadName, "%.20s control", Name());
fControlThread = spawn_thread(_ControlThreadStart, threadName, fCurrentPriority, this);
resume_thread(fControlThread);
// get latency information
fSchedulingLatency = estimate_max_scheduling_latency(fControlThread);
}
void
BMediaEventLooper::Quit()
{
CALLED();
if (fRunState == B_TERMINATED)
return;
SetRunState(B_QUITTING);
close_port(ControlPort());
if (fControlThread != -1) {
status_t err;
wait_for_thread(fControlThread, &err);
fControlThread = -1;
}
SetRunState(B_TERMINATED);
}
void
BMediaEventLooper::DispatchEvent(const media_timed_event *event,
bigtime_t lateness,
bool realTimeEvent)
{
PRINT(6, "CALLED BMediaEventLooper::DispatchEvent()\n");
HandleEvent(event, lateness, realTimeEvent);
switch (event->type) {
case BTimedEventQueue::B_START:
SetRunState(B_STARTED);
break;
case BTimedEventQueue::B_STOP:
SetRunState(B_STOPPED);
break;
case BTimedEventQueue::B_SEEK:
/* nothing */
break;
case BTimedEventQueue::B_WARP:
/* nothing */
break;
case BTimedEventQueue::B_TIMER:
TimerExpired(event->event_time, event->data);
break;
default:
break;
}
_DispatchCleanUp(event);
}
/*************************************************************
* private BMediaEventLooper
*************************************************************/
/* static */ int32
BMediaEventLooper::_ControlThreadStart(void *arg)
{
CALLED();
((BMediaEventLooper *)arg)->SetRunState(B_STOPPED);
((BMediaEventLooper *)arg)->ControlLoop();
((BMediaEventLooper *)arg)->SetRunState(B_QUITTING);
return 0;
}
/* static */ void
BMediaEventLooper::_CleanUpEntry(const media_timed_event *event,
void *context)
{
PRINT(6, "CALLED BMediaEventLooper::_CleanUpEntry()\n");
((BMediaEventLooper *)context)->_DispatchCleanUp(event);
}
void
BMediaEventLooper::_DispatchCleanUp(const media_timed_event *event)
{
PRINT(6, "CALLED BMediaEventLooper::_DispatchCleanUp()\n");
// this function to clean up after custom events you've created
if (event->cleanup >= BTimedEventQueue::B_USER_CLEANUP)
CleanUpEvent(event);
}
/*
// unimplemented
BMediaEventLooper::BMediaEventLooper(const BMediaEventLooper &)
BMediaEventLooper &BMediaEventLooper::operator=(const BMediaEventLooper &)
*/
/*************************************************************
* protected BMediaEventLooper
*************************************************************/
status_t
BMediaEventLooper::DeleteHook(BMediaNode *node)
{
CALLED();
// this is the DeleteHook that gets called by the media server
// before the media node is deleted
Quit();
return BMediaNode::DeleteHook(node);
}
/*************************************************************
* private BMediaEventLooper
*************************************************************/
status_t BMediaEventLooper::_Reserved_BMediaEventLooper_0(int32 arg,...) { return B_ERROR; }
status_t BMediaEventLooper::_Reserved_BMediaEventLooper_1(int32 arg,...) { return B_ERROR; }
status_t BMediaEventLooper::_Reserved_BMediaEventLooper_2(int32 arg,...) { return B_ERROR; }
status_t BMediaEventLooper::_Reserved_BMediaEventLooper_3(int32 arg,...) { return B_ERROR; }
status_t BMediaEventLooper::_Reserved_BMediaEventLooper_4(int32 arg,...) { return B_ERROR; }
status_t BMediaEventLooper::_Reserved_BMediaEventLooper_5(int32 arg,...) { return B_ERROR; }
status_t BMediaEventLooper::_Reserved_BMediaEventLooper_6(int32 arg,...) { return B_ERROR; }
status_t BMediaEventLooper::_Reserved_BMediaEventLooper_7(int32 arg,...) { return B_ERROR; }
status_t BMediaEventLooper::_Reserved_BMediaEventLooper_8(int32 arg,...) { return B_ERROR; }
status_t BMediaEventLooper::_Reserved_BMediaEventLooper_9(int32 arg,...) { return B_ERROR; }
status_t BMediaEventLooper::_Reserved_BMediaEventLooper_10(int32 arg,...) { return B_ERROR; }
status_t BMediaEventLooper::_Reserved_BMediaEventLooper_11(int32 arg,...) { return B_ERROR; }
status_t BMediaEventLooper::_Reserved_BMediaEventLooper_12(int32 arg,...) { return B_ERROR; }
status_t BMediaEventLooper::_Reserved_BMediaEventLooper_13(int32 arg,...) { return B_ERROR; }
status_t BMediaEventLooper::_Reserved_BMediaEventLooper_14(int32 arg,...) { return B_ERROR; }
status_t BMediaEventLooper::_Reserved_BMediaEventLooper_15(int32 arg,...) { return B_ERROR; }
status_t BMediaEventLooper::_Reserved_BMediaEventLooper_16(int32 arg,...) { return B_ERROR; }
status_t BMediaEventLooper::_Reserved_BMediaEventLooper_17(int32 arg,...) { return B_ERROR; }
status_t BMediaEventLooper::_Reserved_BMediaEventLooper_18(int32 arg,...) { return B_ERROR; }
status_t BMediaEventLooper::_Reserved_BMediaEventLooper_19(int32 arg,...) { return B_ERROR; }
status_t BMediaEventLooper::_Reserved_BMediaEventLooper_20(int32 arg,...) { return B_ERROR; }
status_t BMediaEventLooper::_Reserved_BMediaEventLooper_21(int32 arg,...) { return B_ERROR; }
status_t BMediaEventLooper::_Reserved_BMediaEventLooper_22(int32 arg,...) { return B_ERROR; }
status_t BMediaEventLooper::_Reserved_BMediaEventLooper_23(int32 arg,...) { return B_ERROR; }
| 5,657 |
692 | <reponame>lygttpod/RxHttpUtils
package com.allen.rxhttputils.url;
import java.util.HashMap;
import java.util.Map;
/**
* <pre>
* @author : Allen
* e-mail : <EMAIL>
* date : 2019/03/23
* desc :
* </pre>
*/
public class AppUrlConfig {
public static String DOUBAN_KEY = "douban_api";
public static String OTHER_OPEN_KEY = "other_open_api";
public static String WANANDROID_KET = "wanandroid_api";
public static String DOUBAN_URL = "https://api.douban.com/";
public static String OTHER_OPEN_URL = "http://www.mxnzp.com/api/";
public static String WANANDROID_URL = "https://www.wanandroid.com/";
public static Map<String, String> getAllUrl() {
Map<String, String> map = new HashMap<>();
map.put(DOUBAN_KEY, DOUBAN_URL);
map.put(OTHER_OPEN_KEY, OTHER_OPEN_URL);
map.put(WANANDROID_KET, WANANDROID_URL);
return map;
}
}
| 409 |
1,227 | <filename>alibi_detect/utils/tensorflow/tests/test_data_tf.py<gh_stars>1000+
from itertools import product
import numpy as np
import pytest
from alibi_detect.utils.tensorflow.data import TFDataset
# test on numpy array and list
n, f = 100, 5
shape = (n, f)
xtype = [list, np.ndarray]
shuffle = [True, False]
batch_size = [2, 10]
tests_ds = list(product(xtype, batch_size, shuffle))
n_tests_ds = len(tests_ds)
@pytest.fixture
def ds_params(request):
return tests_ds[request.param]
@pytest.mark.parametrize('ds_params', list(range(n_tests_ds)), indirect=True)
def test_torchdataset(ds_params):
xtype, batch_size, shuffle = ds_params
x = np.random.randn(*shape)
y = np.random.randn(*(n,))
if xtype == list:
x = list(x)
ds = TFDataset(x, y, batch_size=batch_size, shuffle=shuffle)
for step, data in enumerate(ds):
pass
if xtype == list:
assert len(data[0]) == batch_size and data[0][0].shape == (f,)
else:
assert data[0].shape == (batch_size, f)
assert data[1].shape == (batch_size,)
assert step == len(ds) - 1
if not shuffle:
assert (data[0][-1] == x[-1 - (n % batch_size)]).all()
| 499 |
359 | <filename>test_case/models/url.py<gh_stars>100-1000
# -*-coding:utf-8-*-
"""
存储项目测试网站的地址
"""
class Url:
baseUrl = 'https://www.baidu.com' | 86 |
8,805 | <filename>ios/Pods/boost-for-react-native/boost/log/detail/trivial_keyword.hpp
/*
* Copyright <NAME> 2007 - 2015.
* 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)
*/
/*!
* \file trivial_keyword.hpp
* \author <NAME>
* \date 02.12.2012
*
* \brief This header is the Boost.Log library implementation, see the library documentation
* at http://www.boost.org/doc/libs/release/libs/log/doc/html/index.html.
*/
#ifndef BOOST_LOG_DETAIL_TRIVIAL_KEYWORD_HPP_INCLUDED_
#define BOOST_LOG_DETAIL_TRIVIAL_KEYWORD_HPP_INCLUDED_
#include <boost/log/detail/config.hpp>
#include <boost/log/detail/header.hpp>
#ifdef BOOST_HAS_PRAGMA_ONCE
#pragma once
#endif
namespace boost {
BOOST_LOG_OPEN_NAMESPACE
namespace trivial {
//! Trivial severity keyword
BOOST_LOG_ATTRIBUTE_KEYWORD(severity, "Severity", severity_level)
} // namespace trivial
BOOST_LOG_CLOSE_NAMESPACE // namespace log
} // namespace boost
#include <boost/log/detail/footer.hpp>
#endif // BOOST_LOG_DETAIL_TRIVIAL_KEYWORD_HPP_INCLUDED_
| 516 |
1,738 | /*
* 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_EDITOR_BSTEDITOR_SELECTIONTREEEDITOR_H
#define CRYINCLUDE_EDITOR_BSTEDITOR_SELECTIONTREEEDITOR_H
#pragma once
//#define USING_SELECTION_TREE_EDITOR
#include "Dialogs/BaseFrameWnd.h"
#include "Views/SelectionTreeGraphView.h"
#include "Views/SelectionTreeVariablesView.h"
#include "Views/SelectionTreeSignalsView.h"
#include "Views/SelectionTreeListView.h"
#include "Views/SelectionTreePropertiesView.h"
#include "Views/SelectionTreeHistoryView.h"
class CSelectionTreeEditor
: public CBaseFrameWnd
{
DECLARE_DYNCREATE( CSelectionTreeEditor )
public:
CSelectionTreeEditor();
virtual ~CSelectionTreeEditor();
void SetTreeName(const char* name);
void SetVariablesName(const char* name);
void SetSignalsName(const char* name);
void SetTimestampsName(const char* name);
static CSelectionTreeEditor* GetInstance();
protected:
virtual BOOL OnInitDialog();
void AttachDockingWnd( UINT wndId, CWnd* pWnd, const CString& dockingPaneTitle, XTPDockingPaneDirection direction = xtpPaneDockLeft, CXTPDockingPaneBase* pNeighbour = NULL );
DECLARE_MESSAGE_MAP()
afx_msg void OnBtnClickedReload();
afx_msg void OnBtnClickedSaveAll();
afx_msg void OnBtnClickedNewTree();
afx_msg void OnBtnClickedClearHistory();
afx_msg void OnBtnDisplayWarnings();
private:
CSelectionTreeGraphView m_graphView;
CSelectionTreeTimestampsView m_timestampView;
CSelectionTreePropertiesView m_propertiesView;
CSelectionTreeVariablesView m_variablesView;
CSelectionTreeSignalsView m_signalsView;
CSelectionTreeListView m_treeListView;
CSelectionTreeHistoryView m_historyView;
CXTPDockingPane* m_pGraphViewDockingPane;
CXTPDockingPane* m_pTreeListDockingPane;
CXTPDockingPane* m_pVariablesDockingPane;
CXTPDockingPane* m_pSignalsDockingPane;
CXTPDockingPane* m_pPropertiesDockingPane;
CXTPDockingPane* m_pTimestampsDockingPane;
CXTPDockingPane* m_pHistoryDockingPane;
static CryCriticalSection m_sLock;
};
#endif // CRYINCLUDE_EDITOR_BSTEDITOR_SELECTIONTREEEDITOR_H
| 904 |
9,782 | /*
* 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.facebook.presto.type;
import com.facebook.presto.common.block.Block;
import com.facebook.presto.common.block.BlockBuilder;
import com.facebook.presto.common.block.LongArrayBlockBuilder;
import org.testng.annotations.Test;
import static com.facebook.presto.common.type.DoubleType.DOUBLE;
import static java.lang.Double.doubleToLongBits;
import static java.lang.Double.doubleToRawLongBits;
import static org.testng.Assert.assertEquals;
public class TestDoubleType
extends AbstractTestType
{
public TestDoubleType()
{
super(DOUBLE, Double.class, createTestBlock());
}
public static Block createTestBlock()
{
BlockBuilder blockBuilder = DOUBLE.createBlockBuilder(null, 15);
DOUBLE.writeDouble(blockBuilder, 11.11);
DOUBLE.writeDouble(blockBuilder, 11.11);
DOUBLE.writeDouble(blockBuilder, 11.11);
DOUBLE.writeDouble(blockBuilder, 22.22);
DOUBLE.writeDouble(blockBuilder, 22.22);
DOUBLE.writeDouble(blockBuilder, 22.22);
DOUBLE.writeDouble(blockBuilder, 22.22);
DOUBLE.writeDouble(blockBuilder, 22.22);
DOUBLE.writeDouble(blockBuilder, 33.33);
DOUBLE.writeDouble(blockBuilder, 33.33);
DOUBLE.writeDouble(blockBuilder, 44.44);
return blockBuilder.build();
}
@Override
protected Object getGreaterValue(Object value)
{
return ((Double) value) + 0.1;
}
@Test
public void testNaNHash()
{
BlockBuilder blockBuilder = new LongArrayBlockBuilder(null, 4);
blockBuilder.writeLong(doubleToLongBits(Double.NaN));
blockBuilder.writeLong(doubleToRawLongBits(Double.NaN));
// the following two are the long values of a double NaN
blockBuilder.writeLong(-0x000fffffffffffffL);
blockBuilder.writeLong(0x7ff8000000000000L);
assertEquals(DOUBLE.hash(blockBuilder, 0), DOUBLE.hash(blockBuilder, 1));
assertEquals(DOUBLE.hash(blockBuilder, 0), DOUBLE.hash(blockBuilder, 2));
assertEquals(DOUBLE.hash(blockBuilder, 0), DOUBLE.hash(blockBuilder, 3));
}
}
| 975 |
679 | /**************************************************************
*
* 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.
*
*************************************************************/
#ifndef SCRIPTING_DLGPROV_HXX
#define SCRIPTING_DLGPROV_HXX
#ifndef _COM_SUN_STAR_AWT_XSTRINGRESOURCEWITHSTORAGE_HPP_
#include <com/sun/star/resource/XStringResourceWithStorage.hpp>
#endif
#ifndef _COM_SUN_STAR_AWT_XSTRINGRESOURCEWITHSTORAGE_HPP_
#include <com/sun/star/resource/XStringResourceWithLocation.hpp>
#endif
#include <com/sun/star/lang/XServiceInfo.hpp>
#include <com/sun/star/lang/XInitialization.hpp>
#include <com/sun/star/uno/XComponentContext.hpp>
#include <com/sun/star/ucb/XSimpleFileAccess.hpp>
#include <com/sun/star/io/XInputStream.hpp>
#include <com/sun/star/io/XOutputStream.hpp>
#include <cppuhelper/implbase1.hxx>
#include <cppuhelper/implbase2.hxx>
#include <cppuhelper/interfacecontainer.hxx>
#include <osl/mutex.hxx>
#include <vector>
#include <hash_map>
//.........................................................................
namespace stringresource
{
//.........................................................................
// =============================================================================
// mutex
// =============================================================================
::osl::Mutex& getMutex();
// =============================================================================
// class stringresourceImpl
// =============================================================================
// Hashtable to map string ids to string
struct hashName_Impl
{
size_t operator()(const ::rtl::OUString Str) const
{
return (size_t)Str.hashCode();
}
};
struct eqName_Impl
{
sal_Bool operator()(const ::rtl::OUString Str1, const ::rtl::OUString Str2) const
{
return ( Str1 == Str2 );
}
};
typedef std::hash_map
<
::rtl::OUString,
::rtl::OUString,
hashName_Impl,
eqName_Impl
>
IdToStringMap;
typedef std::hash_map
<
::rtl::OUString,
sal_Int32,
hashName_Impl,
eqName_Impl
>
IdToIndexMap;
struct LocaleItem
{
::com::sun::star::lang::Locale m_locale;
IdToStringMap m_aIdToStringMap;
IdToIndexMap m_aIdToIndexMap;
sal_Int32 m_nNextIndex;
bool m_bLoaded;
bool m_bModified;
LocaleItem( ::com::sun::star::lang::Locale locale, bool bLoaded=true )
: m_locale( locale )
, m_nNextIndex( 0 )
, m_bLoaded( bLoaded )
, m_bModified( false )
{}
};
typedef std::vector< LocaleItem* > LocaleItemVector;
typedef std::vector< LocaleItem* >::iterator LocaleItemVectorIt;
typedef std::vector< LocaleItem* >::const_iterator LocaleItemVectorConstIt;
typedef ::cppu::WeakImplHelper2<
::com::sun::star::lang::XServiceInfo,
::com::sun::star::resource::XStringResourceManager > StringResourceImpl_BASE;
class StringResourceImpl : public StringResourceImpl_BASE
{
protected:
::com::sun::star::uno::Reference< ::com::sun::star::uno::XComponentContext > m_xContext;
::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiComponentFactory > m_xMCF;
LocaleItem* m_pCurrentLocaleItem;
LocaleItem* m_pDefaultLocaleItem;
bool m_bDefaultModified;
::cppu::OInterfaceContainerHelper m_aListenerContainer;
LocaleItemVector m_aLocaleItemVector;
LocaleItemVector m_aDeletedLocaleItemVector;
LocaleItemVector m_aChangedDefaultLocaleVector;
bool m_bModified;
bool m_bReadOnly;
sal_Int32 m_nNextUniqueNumericId;
// Scans ResourceID to start with number and adapt m_nNextUniqueNumericId
void implScanIdForNumber( const ::rtl::OUString& ResourceID );
const static sal_Int32 UNIQUE_NUMBER_NEEDS_INITIALISATION = -1;
// Checks read only status and throws exception if it's true
void implCheckReadOnly( const sal_Char* pExceptionMsg )
throw (::com::sun::star::lang::NoSupportException);
// Return the context's MultiComponentFactory
::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiComponentFactory >
getMultiComponentFactory( void );
// Returns the LocalItem for a given locale, if it exists, otherwise NULL
// This method compares the locales exactly, no closest match search is performed
LocaleItem* getItemForLocale( const ::com::sun::star::lang::Locale& locale, sal_Bool bException )
throw (::com::sun::star::lang::IllegalArgumentException);
// Returns the LocalItem for a given locale, if it exists, otherwise NULL
// This method performs a closest match search, at least the language must match
LocaleItem* getClosestMatchItemForLocale( const ::com::sun::star::lang::Locale& locale );
void implSetCurrentLocale( const ::com::sun::star::lang::Locale& locale,
sal_Bool FindClosestMatch, sal_Bool bUseDefaultIfNoMatch )
throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException);
void implModified( void );
void implNotifyListeners( void );
//=== Impl methods for ...ForLocale methods ===
::rtl::OUString SAL_CALL implResolveString( const ::rtl::OUString& ResourceID, LocaleItem* pLocaleItem )
throw (::com::sun::star::resource::MissingResourceException);
::sal_Bool implHasEntryForId( const ::rtl::OUString& ResourceID, LocaleItem* pLocaleItem );
::com::sun::star::uno::Sequence< ::rtl::OUString > implGetResourceIDs( LocaleItem* pLocaleItem );
void implSetString( const ::rtl::OUString& ResourceID,
const ::rtl::OUString& Str, LocaleItem* pLocaleItem );
void implRemoveId( const ::rtl::OUString& ResourceID, LocaleItem* pLocaleItem )
throw (::com::sun::star::resource::MissingResourceException);
// Method to load a locale if necessary, returns true if loading was
// successful. Default implementation in base class just returns true.
virtual bool loadLocale( LocaleItem* pLocaleItem );
virtual void implLoadAllLocales( void );
public:
StringResourceImpl(
const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XComponentContext >& rxContext );
virtual ~StringResourceImpl();
// XServiceInfo
virtual ::rtl::OUString SAL_CALL getImplementationName( )
throw (::com::sun::star::uno::RuntimeException);
virtual sal_Bool SAL_CALL supportsService( const ::rtl::OUString& ServiceName )
throw (::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL getSupportedServiceNames( )
throw (::com::sun::star::uno::RuntimeException);
// XModifyBroadcaster
virtual void SAL_CALL addModifyListener( const ::com::sun::star::uno::Reference< ::com::sun::star::util::XModifyListener >& aListener )
throw (::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL removeModifyListener( const ::com::sun::star::uno::Reference< ::com::sun::star::util::XModifyListener >& aListener )
throw (::com::sun::star::uno::RuntimeException);
// XStringResourceResolver
virtual ::rtl::OUString SAL_CALL resolveString( const ::rtl::OUString& ResourceID )
throw (::com::sun::star::resource::MissingResourceException, ::com::sun::star::uno::RuntimeException);
virtual ::rtl::OUString SAL_CALL resolveStringForLocale( const ::rtl::OUString& ResourceID,
const ::com::sun::star::lang::Locale& locale )
throw ( ::com::sun::star::resource::MissingResourceException,
::com::sun::star::uno::RuntimeException);
virtual ::sal_Bool SAL_CALL hasEntryForId( const ::rtl::OUString& ResourceID )
throw (::com::sun::star::uno::RuntimeException);
virtual ::sal_Bool SAL_CALL hasEntryForIdAndLocale( const ::rtl::OUString& ResourceID,
const ::com::sun::star::lang::Locale& locale )
throw (::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL getResourceIDs( )
throw (::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL getResourceIDsForLocale
( const ::com::sun::star::lang::Locale& locale )
throw (::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::lang::Locale SAL_CALL getCurrentLocale( )
throw (::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::lang::Locale SAL_CALL getDefaultLocale( )
throw (::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::uno::Sequence< ::com::sun::star::lang::Locale > SAL_CALL getLocales( )
throw (::com::sun::star::uno::RuntimeException);
// XStringResourceManager
virtual ::sal_Bool SAL_CALL isReadOnly()
throw (::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL setCurrentLocale( const ::com::sun::star::lang::Locale& locale, ::sal_Bool FindClosestMatch )
throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL setDefaultLocale( const ::com::sun::star::lang::Locale& locale )
throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException,
::com::sun::star::lang::NoSupportException);
virtual void SAL_CALL setString( const ::rtl::OUString& ResourceID, const ::rtl::OUString& Str )
throw (::com::sun::star::lang::NoSupportException, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL setStringForLocale( const ::rtl::OUString& ResourceID, const ::rtl::OUString& Str,
const ::com::sun::star::lang::Locale& locale )
throw (::com::sun::star::lang::NoSupportException, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL removeId( const ::rtl::OUString& ResourceID )
throw (::com::sun::star::resource::MissingResourceException, ::com::sun::star::uno::RuntimeException,
::com::sun::star::lang::NoSupportException);
virtual void SAL_CALL removeIdForLocale( const ::rtl::OUString& ResourceID,
const ::com::sun::star::lang::Locale& locale )
throw (::com::sun::star::resource::MissingResourceException, ::com::sun::star::uno::RuntimeException,
::com::sun::star::lang::NoSupportException);
virtual void SAL_CALL newLocale( const ::com::sun::star::lang::Locale& locale )
throw (::com::sun::star::container::ElementExistException, ::com::sun::star::lang::IllegalArgumentException,
::com::sun::star::lang::NoSupportException, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL removeLocale( const ::com::sun::star::lang::Locale& locale )
throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException,
::com::sun::star::lang::NoSupportException);
virtual ::sal_Int32 SAL_CALL getUniqueNumericId( )
throw (::com::sun::star::lang::NoSupportException,
::com::sun::star::uno::RuntimeException);
};
typedef ::cppu::ImplInheritanceHelper1<
StringResourceImpl,
::com::sun::star::resource::XStringResourcePersistence > StringResourcePersistenceImpl_BASE;
class BinaryOutput;
class BinaryInput;
class StringResourcePersistenceImpl : public StringResourcePersistenceImpl_BASE
{
protected:
::rtl::OUString m_aNameBase;
::rtl::OUString m_aComment;
void SAL_CALL implInitializeCommonParameters
( const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any >& aArguments )
throw (::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException);
// Scan locale properties files
virtual void implScanLocales( void );
// Method to load a locale if necessary, returns true if loading was successful
virtual bool loadLocale( LocaleItem* pLocaleItem );
// does the actual loading
virtual bool implLoadLocale( LocaleItem* pLocaleItem );
virtual void implLoadAllLocales( void );
void implScanLocaleNames( const ::com::sun::star::uno::Sequence< ::rtl::OUString >& aContentSeq );
::rtl::OUString implGetFileNameForLocaleItem( LocaleItem* pLocaleItem, const ::rtl::OUString& aNameBase );
::rtl::OUString implGetPathForLocaleItem( LocaleItem* pLocaleItem, const ::rtl::OUString& aNameBase,
const ::rtl::OUString& aLocation, bool bDefaultFile=false );
bool implReadPropertiesFile( LocaleItem* pLocaleItem,
const ::com::sun::star::uno::Reference< ::com::sun::star::io::XInputStream >& xInput );
bool implWritePropertiesFile( LocaleItem* pLocaleItem, const ::com::sun::star::uno::Reference
< ::com::sun::star::io::XOutputStream >& xOutputStream, const ::rtl::OUString& aComment );
void implWriteLocaleBinary( LocaleItem* pLocaleItem, BinaryOutput& rOut );
void implStoreAtStorage
(
const ::rtl::OUString& aNameBase,
const ::rtl::OUString& aComment,
const ::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage >& Storage,
bool bUsedForStore,
bool bStoreAll
)
throw (::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException);
void implKillRemovedLocaleFiles
(
const ::rtl::OUString& Location,
const ::rtl::OUString& aNameBase,
const ::com::sun::star::uno::Reference< ::com::sun::star::ucb::XSimpleFileAccess >& xFileAccess
)
throw (::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException);
void implKillChangedDefaultFiles
(
const ::rtl::OUString& Location,
const ::rtl::OUString& aNameBase,
const ::com::sun::star::uno::Reference< ::com::sun::star::ucb::XSimpleFileAccess >& xFileAccess
)
throw (::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException);
void implStoreAtLocation
(
const ::rtl::OUString& Location,
const ::rtl::OUString& aNameBase,
const ::rtl::OUString& aComment,
const ::com::sun::star::uno::Reference< ::com::sun::star::ucb::XSimpleFileAccess >& xFileAccess,
bool bUsedForStore,
bool bStoreAll,
bool bKillAll = false
)
throw (::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException);
public:
StringResourcePersistenceImpl(
const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XComponentContext >& rxContext );
virtual ~StringResourcePersistenceImpl();
// XServiceInfo
virtual ::rtl::OUString SAL_CALL getImplementationName( )
throw (::com::sun::star::uno::RuntimeException);
virtual sal_Bool SAL_CALL supportsService( const ::rtl::OUString& ServiceName )
throw (::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL getSupportedServiceNames( )
throw (::com::sun::star::uno::RuntimeException);
// XModifyBroadcaster
virtual void SAL_CALL addModifyListener( const ::com::sun::star::uno::Reference< ::com::sun::star::util::XModifyListener >& aListener )
throw (::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL removeModifyListener( const ::com::sun::star::uno::Reference< ::com::sun::star::util::XModifyListener >& aListener )
throw (::com::sun::star::uno::RuntimeException);
// XStringResourceResolver
virtual ::rtl::OUString SAL_CALL resolveString( const ::rtl::OUString& ResourceID )
throw (::com::sun::star::resource::MissingResourceException, ::com::sun::star::uno::RuntimeException);
virtual ::rtl::OUString SAL_CALL resolveStringForLocale( const ::rtl::OUString& ResourceID,
const ::com::sun::star::lang::Locale& locale )
throw ( ::com::sun::star::resource::MissingResourceException,
::com::sun::star::uno::RuntimeException);
virtual ::sal_Bool SAL_CALL hasEntryForId( const ::rtl::OUString& ResourceID )
throw (::com::sun::star::uno::RuntimeException);
virtual ::sal_Bool SAL_CALL hasEntryForIdAndLocale( const ::rtl::OUString& ResourceID,
const ::com::sun::star::lang::Locale& locale )
throw (::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL getResourceIDs( )
throw (::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL getResourceIDsForLocale
( const ::com::sun::star::lang::Locale& locale )
throw (::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::lang::Locale SAL_CALL getCurrentLocale( )
throw (::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::lang::Locale SAL_CALL getDefaultLocale( )
throw (::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::uno::Sequence< ::com::sun::star::lang::Locale > SAL_CALL getLocales( )
throw (::com::sun::star::uno::RuntimeException);
// XStringResourceManager
virtual ::sal_Bool SAL_CALL isReadOnly()
throw (::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL setCurrentLocale( const ::com::sun::star::lang::Locale& locale, ::sal_Bool FindClosestMatch )
throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL setDefaultLocale( const ::com::sun::star::lang::Locale& locale )
throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException,
::com::sun::star::lang::NoSupportException);
virtual void SAL_CALL setString( const ::rtl::OUString& ResourceID, const ::rtl::OUString& Str )
throw (::com::sun::star::lang::NoSupportException, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL setStringForLocale( const ::rtl::OUString& ResourceID, const ::rtl::OUString& Str,
const ::com::sun::star::lang::Locale& locale )
throw (::com::sun::star::lang::NoSupportException, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL removeId( const ::rtl::OUString& ResourceID )
throw (::com::sun::star::resource::MissingResourceException, ::com::sun::star::uno::RuntimeException,
::com::sun::star::lang::NoSupportException);
virtual void SAL_CALL removeIdForLocale( const ::rtl::OUString& ResourceID,
const ::com::sun::star::lang::Locale& locale )
throw (::com::sun::star::resource::MissingResourceException, ::com::sun::star::uno::RuntimeException,
::com::sun::star::lang::NoSupportException);
virtual void SAL_CALL newLocale( const ::com::sun::star::lang::Locale& locale )
throw (::com::sun::star::container::ElementExistException, ::com::sun::star::lang::IllegalArgumentException,
::com::sun::star::lang::NoSupportException, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL removeLocale( const ::com::sun::star::lang::Locale& locale )
throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException,
::com::sun::star::lang::NoSupportException);
virtual ::sal_Int32 SAL_CALL getUniqueNumericId( )
throw (::com::sun::star::lang::NoSupportException,
::com::sun::star::uno::RuntimeException);
// XStringResourcePersistence
virtual void SAL_CALL store( )
throw (::com::sun::star::lang::NoSupportException,
::com::sun::star::uno::Exception,
::com::sun::star::uno::RuntimeException);
virtual ::sal_Bool SAL_CALL isModified( )
throw (::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL setComment( const ::rtl::OUString& Comment )
throw (::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL storeToStorage
( const ::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage >& Storage,
const ::rtl::OUString& NameBase, const ::rtl::OUString& Comment )
throw (::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL storeToURL( const ::rtl::OUString& URL, const ::rtl::OUString& NameBase,
const ::rtl::OUString& Comment, const ::com::sun::star::uno::Reference
< ::com::sun::star::task::XInteractionHandler >& Handler )
throw (::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::uno::Sequence< ::sal_Int8 > SAL_CALL exportBinary( )
throw (::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL importBinary( const ::com::sun::star::uno::Sequence< ::sal_Int8 >& Data )
throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException);
};
typedef ::cppu::ImplInheritanceHelper2<
StringResourcePersistenceImpl,
::com::sun::star::lang::XInitialization,
::com::sun::star::resource::XStringResourceWithStorage > StringResourceWithStorageImpl_BASE;
class StringResourceWithStorageImpl : public StringResourceWithStorageImpl_BASE
{
::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage > m_xStorage;
bool m_bStorageChanged;
virtual void implScanLocales( void );
virtual bool implLoadLocale( LocaleItem* pLocaleItem );
public:
StringResourceWithStorageImpl(
const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XComponentContext >& rxContext );
virtual ~StringResourceWithStorageImpl();
// XServiceInfo
virtual ::rtl::OUString SAL_CALL getImplementationName( )
throw (::com::sun::star::uno::RuntimeException);
virtual sal_Bool SAL_CALL supportsService( const ::rtl::OUString& ServiceName )
throw (::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL getSupportedServiceNames( )
throw (::com::sun::star::uno::RuntimeException);
// XInitialization
virtual void SAL_CALL initialize( const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any >& aArguments )
throw (::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException);
// XModifyBroadcaster
virtual void SAL_CALL addModifyListener( const ::com::sun::star::uno::Reference< ::com::sun::star::util::XModifyListener >& aListener )
throw (::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL removeModifyListener( const ::com::sun::star::uno::Reference< ::com::sun::star::util::XModifyListener >& aListener )
throw (::com::sun::star::uno::RuntimeException);
// XStringResourceResolver
virtual ::rtl::OUString SAL_CALL resolveString( const ::rtl::OUString& ResourceID )
throw (::com::sun::star::resource::MissingResourceException, ::com::sun::star::uno::RuntimeException);
virtual ::rtl::OUString SAL_CALL resolveStringForLocale( const ::rtl::OUString& ResourceID,
const ::com::sun::star::lang::Locale& locale )
throw ( ::com::sun::star::resource::MissingResourceException,
::com::sun::star::uno::RuntimeException);
virtual ::sal_Bool SAL_CALL hasEntryForId( const ::rtl::OUString& ResourceID )
throw (::com::sun::star::uno::RuntimeException);
virtual ::sal_Bool SAL_CALL hasEntryForIdAndLocale( const ::rtl::OUString& ResourceID,
const ::com::sun::star::lang::Locale& locale )
throw (::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL getResourceIDs( )
throw (::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL getResourceIDsForLocale
( const ::com::sun::star::lang::Locale& locale )
throw (::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::lang::Locale SAL_CALL getCurrentLocale( )
throw (::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::lang::Locale SAL_CALL getDefaultLocale( )
throw (::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::uno::Sequence< ::com::sun::star::lang::Locale > SAL_CALL getLocales( )
throw (::com::sun::star::uno::RuntimeException);
// XStringResourceManager
virtual ::sal_Bool SAL_CALL isReadOnly()
throw (::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL setCurrentLocale( const ::com::sun::star::lang::Locale& locale, ::sal_Bool FindClosestMatch )
throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL setDefaultLocale( const ::com::sun::star::lang::Locale& locale )
throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException,
::com::sun::star::lang::NoSupportException);
virtual void SAL_CALL setString( const ::rtl::OUString& ResourceID, const ::rtl::OUString& Str )
throw (::com::sun::star::lang::NoSupportException, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL setStringForLocale( const ::rtl::OUString& ResourceID, const ::rtl::OUString& Str,
const ::com::sun::star::lang::Locale& locale )
throw (::com::sun::star::lang::NoSupportException, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL removeId( const ::rtl::OUString& ResourceID )
throw (::com::sun::star::resource::MissingResourceException, ::com::sun::star::uno::RuntimeException,
::com::sun::star::lang::NoSupportException);
virtual void SAL_CALL removeIdForLocale( const ::rtl::OUString& ResourceID,
const ::com::sun::star::lang::Locale& locale )
throw (::com::sun::star::resource::MissingResourceException, ::com::sun::star::uno::RuntimeException,
::com::sun::star::lang::NoSupportException);
virtual void SAL_CALL newLocale( const ::com::sun::star::lang::Locale& locale )
throw (::com::sun::star::container::ElementExistException, ::com::sun::star::lang::IllegalArgumentException,
::com::sun::star::lang::NoSupportException, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL removeLocale( const ::com::sun::star::lang::Locale& locale )
throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException,
::com::sun::star::lang::NoSupportException);
virtual ::sal_Int32 SAL_CALL getUniqueNumericId( )
throw (::com::sun::star::lang::NoSupportException,
::com::sun::star::uno::RuntimeException);
// XStringResourcePersistence
virtual void SAL_CALL store( )
throw (::com::sun::star::lang::NoSupportException,
::com::sun::star::uno::Exception,
::com::sun::star::uno::RuntimeException);
virtual ::sal_Bool SAL_CALL isModified( )
throw (::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL setComment( const ::rtl::OUString& Comment )
throw (::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL storeToStorage
( const ::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage >& Storage,
const ::rtl::OUString& NameBase, const ::rtl::OUString& Comment )
throw (::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL storeToURL( const ::rtl::OUString& URL, const ::rtl::OUString& NameBase,
const ::rtl::OUString& Comment, const ::com::sun::star::uno::Reference
< ::com::sun::star::task::XInteractionHandler >& Handler )
throw (::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::uno::Sequence< ::sal_Int8 > SAL_CALL exportBinary( )
throw (::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL importBinary( const ::com::sun::star::uno::Sequence< ::sal_Int8 >& Data )
throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException);
// XStringResourceWithStorage
virtual void SAL_CALL storeAsStorage
( const ::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage >& Storage )
throw (::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL setStorage
( const ::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage >& Storage )
throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException);
};
typedef ::cppu::ImplInheritanceHelper2<
StringResourcePersistenceImpl,
::com::sun::star::lang::XInitialization,
::com::sun::star::resource::XStringResourceWithLocation > StringResourceWithLocationImpl_BASE;
class StringResourceWithLocationImpl : public StringResourceWithLocationImpl_BASE
{
::rtl::OUString m_aLocation;
bool m_bLocationChanged;
com::sun::star::uno::Reference< com::sun::star::ucb::XSimpleFileAccess > m_xSFI;
com::sun::star::uno::Reference< com::sun::star::task::XInteractionHandler > m_xInteractionHandler;
const ::com::sun::star::uno::Reference< ::com::sun::star::ucb::XSimpleFileAccess > getFileAccess( void );
virtual void implScanLocales( void );
virtual bool implLoadLocale( LocaleItem* pLocaleItem );
public:
StringResourceWithLocationImpl(
const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XComponentContext >& rxContext );
virtual ~StringResourceWithLocationImpl();
// XServiceInfo
virtual ::rtl::OUString SAL_CALL getImplementationName( )
throw (::com::sun::star::uno::RuntimeException);
virtual sal_Bool SAL_CALL supportsService( const ::rtl::OUString& ServiceName )
throw (::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL getSupportedServiceNames( )
throw (::com::sun::star::uno::RuntimeException);
// XInitialization
virtual void SAL_CALL initialize( const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any >& aArguments )
throw (::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException);
// XModifyBroadcaster
virtual void SAL_CALL addModifyListener( const ::com::sun::star::uno::Reference< ::com::sun::star::util::XModifyListener >& aListener )
throw (::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL removeModifyListener( const ::com::sun::star::uno::Reference< ::com::sun::star::util::XModifyListener >& aListener )
throw (::com::sun::star::uno::RuntimeException);
// XStringResourceResolver
virtual ::rtl::OUString SAL_CALL resolveString( const ::rtl::OUString& ResourceID )
throw (::com::sun::star::resource::MissingResourceException, ::com::sun::star::uno::RuntimeException);
virtual ::rtl::OUString SAL_CALL resolveStringForLocale( const ::rtl::OUString& ResourceID,
const ::com::sun::star::lang::Locale& locale )
throw ( ::com::sun::star::resource::MissingResourceException,
::com::sun::star::uno::RuntimeException);
virtual ::sal_Bool SAL_CALL hasEntryForId( const ::rtl::OUString& ResourceID )
throw (::com::sun::star::uno::RuntimeException);
virtual ::sal_Bool SAL_CALL hasEntryForIdAndLocale( const ::rtl::OUString& ResourceID,
const ::com::sun::star::lang::Locale& locale )
throw (::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL getResourceIDs( )
throw (::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::uno::Sequence< ::rtl::OUString > SAL_CALL getResourceIDsForLocale
( const ::com::sun::star::lang::Locale& locale )
throw (::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::lang::Locale SAL_CALL getCurrentLocale( )
throw (::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::lang::Locale SAL_CALL getDefaultLocale( )
throw (::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::uno::Sequence< ::com::sun::star::lang::Locale > SAL_CALL getLocales( )
throw (::com::sun::star::uno::RuntimeException);
// XStringResourceManager
virtual ::sal_Bool SAL_CALL isReadOnly()
throw (::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL setCurrentLocale( const ::com::sun::star::lang::Locale& locale, ::sal_Bool FindClosestMatch )
throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL setDefaultLocale( const ::com::sun::star::lang::Locale& locale )
throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException,
::com::sun::star::lang::NoSupportException);
virtual void SAL_CALL setString( const ::rtl::OUString& ResourceID, const ::rtl::OUString& Str )
throw (::com::sun::star::lang::NoSupportException, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL setStringForLocale( const ::rtl::OUString& ResourceID, const ::rtl::OUString& Str,
const ::com::sun::star::lang::Locale& locale )
throw (::com::sun::star::lang::NoSupportException, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL removeId( const ::rtl::OUString& ResourceID )
throw (::com::sun::star::resource::MissingResourceException, ::com::sun::star::uno::RuntimeException,
::com::sun::star::lang::NoSupportException);
virtual void SAL_CALL removeIdForLocale( const ::rtl::OUString& ResourceID,
const ::com::sun::star::lang::Locale& locale )
throw (::com::sun::star::resource::MissingResourceException, ::com::sun::star::uno::RuntimeException,
::com::sun::star::lang::NoSupportException);
virtual void SAL_CALL newLocale( const ::com::sun::star::lang::Locale& locale )
throw (::com::sun::star::container::ElementExistException, ::com::sun::star::lang::IllegalArgumentException,
::com::sun::star::lang::NoSupportException, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL removeLocale( const ::com::sun::star::lang::Locale& locale )
throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException,
::com::sun::star::lang::NoSupportException);
virtual ::sal_Int32 SAL_CALL getUniqueNumericId( )
throw (::com::sun::star::lang::NoSupportException,
::com::sun::star::uno::RuntimeException);
// XStringResourcePersistence
virtual void SAL_CALL store( )
throw (::com::sun::star::lang::NoSupportException,
::com::sun::star::uno::Exception,
::com::sun::star::uno::RuntimeException);
virtual ::sal_Bool SAL_CALL isModified( )
throw (::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL setComment( const ::rtl::OUString& Comment )
throw (::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL storeToStorage
( const ::com::sun::star::uno::Reference< ::com::sun::star::embed::XStorage >& Storage,
const ::rtl::OUString& NameBase, const ::rtl::OUString& Comment )
throw (::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL storeToURL( const ::rtl::OUString& URL, const ::rtl::OUString& NameBase,
const ::rtl::OUString& Comment, const ::com::sun::star::uno::Reference
< ::com::sun::star::task::XInteractionHandler >& Handler )
throw (::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException);
virtual ::com::sun::star::uno::Sequence< ::sal_Int8 > SAL_CALL exportBinary( )
throw (::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL importBinary( const ::com::sun::star::uno::Sequence< ::sal_Int8 >& Data )
throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException);
// XStringResourceWithLocation
virtual void SAL_CALL storeAsURL( const ::rtl::OUString& URL )
throw (::com::sun::star::uno::Exception, ::com::sun::star::uno::RuntimeException);
virtual void SAL_CALL setURL( const ::rtl::OUString& URL )
throw (::com::sun::star::lang::IllegalArgumentException, ::com::sun::star::uno::RuntimeException);
};
//.........................................................................
} // namespace stringtable
//.........................................................................
#endif // SCRIPTING_DLGPROV_HXX
| 12,195 |
1,155 | /*
* Orika - simpler, better and faster Java bean mapping
*
* Copyright (C) 2011-2013 Orika 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 ma.glasnost.orika.test.fieldmap;
import org.junit.Assert;
import org.junit.Test;
import ma.glasnost.orika.MapperFactory;
import ma.glasnost.orika.test.MappingUtil;
public class NestedExpressionTestCase {
@Test
public void testNestedProperty() {
MapperFactory factory = MappingUtil.getMapperFactory();
factory.registerClassMap(factory.classMap(Order.class, OrderDTO.class).field("product.state.type.label", "stateLabel")
.field("product.name", "productName").toClassMap());
StateType type = new StateType();
type.setLabel("Open");
State state = new State();
state.setType(type);
Product product = new Product();
product.setState(state);
product.setName("Glasnost Platform");
Order order = new Order();
order.setProduct(product);
OrderDTO dto = factory.getMapperFacade().map(order, OrderDTO.class);
Assert.assertEquals("Open", dto.getStateLabel());
Order object = factory.getMapperFacade().map(dto, Order.class);
Assert.assertEquals("Open", object.getProduct().getState().getType().getLabel());
}
public static class StateType {
private String label;
public String getLabel() {
return label;
}
public void setLabel(String label) {
this.label = label;
}
}
public static class State {
private StateType type;
public StateType getType() {
return type;
}
public void setType(StateType type) {
this.type = type;
}
}
public static class Product {
private State state;
private String name;
public State getState() {
return state;
}
public void setState(State state) {
this.state = state;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
public static class Order {
private Product product;
public Product getProduct() {
return product;
}
public void setProduct(Product product) {
this.product = product;
}
}
public static class OrderDTO {
private String stateLabel;
private String productName;
public String getStateLabel() {
return stateLabel;
}
public void setStateLabel(String stateLabel) {
this.stateLabel = stateLabel;
}
public String getProductName() {
return productName;
}
public void setProductName(String productName) {
this.productName = productName;
}
}
}
| 1,666 |
3,125 | <reponame>lllrrr2/jd-3
#!/bin/env python3
# -*- coding: utf-8 -*
'''
cron: 0 59 23 * * 0 jd_15.py
new Env('Faker群友家电15周年助力');
'''
# cron
#不做浏览，只做助力 建议先运行jd_appliances.js 在运行此脚本
# export jd15_pins=["pt_pin1","pt_pin2"]
from urllib.parse import unquote, quote
import time, datetime, os, sys
import requests, json, re, random
import threading
UserAgent = ''
script_name = '家电15周年助力'
def printT(msg):
print("[{}]: {}".format(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"), msg))
sys.stdout.flush()
def delEnvs(label):
try:
if label == 'True' or label == 'yes' or label == 'true' or label == 'Yes':
return True
elif label == 'False' or label == 'no' or label == 'false' or label == 'No':
return False
except:
pass
try:
if '.' in label:
return float(label)
elif '&' in label:
return label.split('&')
elif '@' in label:
return label.split('@')
else:
return int(label)
except:
return label
class getJDCookie():
# 适配青龙平台环境ck
def getckfile(self):
ql_new = '/ql/config/env.sh'
ql_old = '/ql/config/cookie.sh'
if os.path.exists(ql_new):
printT("当前环境青龙面板新版")
return ql_new
elif os.path.exists(ql_old):
printT("当前环境青龙面板旧版")
return ql_old
# 获取cookie
def getallCookie(self):
cookies = ''
ckfile = self.getckfile()
try:
if os.path.exists(ckfile):
with open(ckfile, "r", encoding="utf-8") as f:
cks_text = f.read()
if 'pt_key=' in cks_text and 'pt_pin=' in cks_text:
r = re.compile(r"pt_key=.*?pt_pin=.*?;", re.M | re.S | re.I)
cks_list = r.findall(cks_text)
if len(cks_list) > 0:
for ck in cks_list:
cookies += ck
return cookies
except Exception as e:
printT(f"【getCookie Error】{e}")
# 检测cookie格式是否正确
def getUserInfo(self, ck, user_order, pinName):
url = 'https://me-api.jd.com/user_new/info/GetJDUserInfoUnion?orgFlag=JD_PinGou_New&callSource=mainorder&channel=4&isHomewhite=0&sceneval=2&sceneval=2&callback='
headers = {
'Cookie': ck,
'Accept': '*/*',
'Connection': 'close',
'Referer': 'https://home.m.jd.com/myJd/home.action',
'Accept-Encoding': 'gzip, deflate, br',
'Host': 'me-api.jd.com',
'User-Agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 14_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.0.2 Mobile/15E148 Safari/604.1',
'Accept-Language': 'zh-cn'
}
try:
resp = requests.get(url=url, headers=headers, timeout=60).json()
if resp['retcode'] == "0":
nickname = resp['data']['userInfo']['baseInfo']['nickname']
return ck, nickname
else:
context = f"账号{user_order}【{pinName}】Cookie 已失效！请重新获取。"
print(context)
return ck, False
except Exception:
context = f"账号{user_order}【{pinName}】Cookie 已失效！请重新获取。"
print(context)
return ck, False
def getcookies(self):
"""
:return: cookiesList,userNameList,pinNameList
"""
cookiesList = []
pinNameList = []
nickNameList = []
cookies = self.getallCookie()
if 'pt_key=' in cookies and 'pt_pin=' in cookies:
r = re.compile(r"pt_key=.*?pt_pin=.*?;", re.M | re.S | re.I)
result = r.findall(cookies)
if len(result) >= 1:
printT("您已配置{}个账号".format(len(result)))
user_order = 1
for ck in result:
r = re.compile(r"pt_pin=(.*?);")
pinName = r.findall(ck)
pinName = unquote(pinName[0])
# 获取账号名
ck, nickname = self.getUserInfo(ck, user_order, pinName)
if nickname != False:
cookiesList.append(ck)
pinNameList.append(pinName)
nickNameList.append(nickname)
user_order += 1
else:
user_order += 1
continue
if len(cookiesList) > 0:
return cookiesList, pinNameList, nickNameList
else:
printT("没有可用Cookie，已退出")
exit(4)
else:
printT("没有可用Cookie，已退出")
exit(4)
def getPinEnvs():
if "jd15_pins" in os.environ:
if len(os.environ["jd15_pins"]) != 0:
jd15_pins = os.environ["jd15_pins"]
jd15_pins = jd15_pins.replace('[', '').replace(']', '').replace('\'', '').replace(' ', '').split(',')
printT(f"已获取并使用Env环境 jd15_pins:{jd15_pins}")
return jd15_pins
else:
printT('请先配置export jd15_pins=["pt_pin1","pt_pin2"]')
exit(4)
printT('请先配置export jd15_pins=["pt_pin1","pt_pin2"]')
exit(4)
def res_post(cookie, body):
url = "https://api.m.jd.com/api"
headers = {
"Host": "api.m.jd.com",
"content-length": "146",
"accept": "application/json, text/plain, */*",
"origin": "https://welfare.m.jd.com",
"user-agent": "jdapp;android;10.1.0;10;4636532323835366-1683336356836626;network/UNKNOWN;model/MI 8;addressid/4608453733;aid/dc52285fa836e8fb;oaid/a28cc4ac8bda0bf6;osVer/29;appBuild/89568;partner/xiaomi001;eufv/1;jdSupportDarkMode/0;Mozilla/5.0 (Linux; Android 10; MI 8 Build/QKQ1.190828.002; wv) AppleWebKit/537.36 (KHTML, like Gecko) Version/4.0 Chrome/77.0.3865.120 MQQBrowser/6.2 TBS/045715 Mobile Safari/537.36",
"sec-fetch-mode": "cors",
"content-type": "application/x-www-form-urlencoded",
"x-requested-with": "com.jingdong.app.mall",
"sec-fetch-site": "same-site",
"referer": "https://welfare.m.jd.com/",
"accept-encoding": "gzip, deflate, br",
"accept-language": "zh-CN,zh;q\u003d0.9,en-US;q\u003d0.8,en;q\u003d0.7",
"cookie": cookie
}
body = json.dumps(body)
t = str(int(time.time() * 1000))
data = {
'appid': 'anniversary-celebra',
'functionId': 'jd_interaction_prod',
'body': body,
't': t,
'loginType': 2
}
res = requests.post(url=url, headers=headers, data=data).json()
return res
def get_share5(cookie):
body = {"type": "99", "apiMapping": "/api/supportTask/getShareId"}
res = res_post(cookie, body)
# print(res)
if '成功' in res['msg']:
return res['data']
def get_share50(cookie):
body = {"type": "100", "apiMapping": "/api/supportTask/getShareId"}
res = res_post(cookie, body)
# print(res)
if '成功' in res['msg']:
return res['data']
def getprize1(cookie,nickname):
body = {"apiMapping": "/api/prize/getCoupon"}
res = res_post(cookie, body)
# print(res)
if res['code'] == 200:
print('------【账号：' + nickname + '】------' + res['data']['name'])
else:
print('------【账号：' + nickname + '】------优惠券领过了')
def getprize2(cookie,nickname):
body = {"apiMapping": "/api/prize/doLottery"}
res = res_post(cookie, body)
# print(res)
if res['code'] == 5011:
print('------【账号：' + nickname + '】------未中奖e卡')
else:
print('------【账号：' + nickname + '】------不确定，手动确认')
def help(mycookie, nickname, cookiesList, nickNameList):
shareId5 = get_share5(mycookie)
if shareId5 != None:
# print('获取5助力码成功：', shareId5)
# print('--------------------------------------开始5个助力-------------')
body1 = {"shareId": shareId5, "apiMapping": "/api/supportTask/doSupport"}
for i in range(len(cookiesList)):
res = res_post(cookiesList[i], body1)
# print(res)
try:
if res['code'] == 200 and res['data']['status'] == 7:
print(nickNameList[i] + '助力' + nickname + '：' + '5助力成功')
elif res['code'] == 200 and res['data']['status'] == 4:
print(nickNameList[i]+'助力'+nickname+'：'+'5个助力完成啦----')
getprize1(mycookie,nickname)
getprize2(mycookie,nickname)
break
elif res['code'] == 200 and res['data']['status'] == 3:
print(nickNameList[i]+'助力'+nickname+'：'+'5已经助力过了')
except:
pass
else:
print('【账号：' + nickname + '】请先手动执行下浏览任务')
shareId50 = get_share50(mycookie)
if shareId50 != None:
# print('获取50助力码成功：', shareId50)
# print('-------------------------------开始50个助力-------------')
body2 = {"shareId": shareId50, "apiMapping": "/api/supportTask/doSupport"}
for ck in mycookie:
res = res_post(ck, body2)
# print(res)
try:
if res['code'] == 200 and res['data']['status'] == 7:
print(nickNameList[i] + '助力' + nickname + '：' + '50助力成功')
elif res['code'] == 200 and res['data']['status'] == 4:
print(nickNameList[i] + '助力' + nickname + '：' + '50个助力完成啦----')
getprize1(mycookie, nickname)
getprize2(mycookie, nickname)
break
elif res['code'] == 200 and res['data']['status'] == 3:
print(nickNameList[i] + '助力' + nickname + '：' + '50已经助力过了')
except:
pass
else:
print('【账号' + nickname + '】请先手动执行下浏览任务')
def use_thread(jd15_cookies, nicks, cookiesList, nickNameList):
threads = []
for i in range(len(jd15_cookies)):
threads.append(
threading.Thread(target=help, args=(jd15_cookies[i], nicks[i], cookiesList, nickNameList))
)
for t in threads:
t.start()
for t in threads:
t.join()
def start():
printT("############{}##########".format(script_name))
jd15_pins = getPinEnvs()
get_jd_cookie = getJDCookie()
cookiesList, pinNameList, nickNameList = get_jd_cookie.getcookies()
jd15_cookies = []
nicks = []
for ckname in jd15_pins:
try:
ckNum = pinNameList.index(ckname)
jd15_cookies.append(cookiesList[ckNum])
nicks.append(nickNameList[ckNum])
except Exception as e:
try:
ckNum = pinNameList.index(unquote(ckname))
jd15_cookies.append(cookiesList[ckNum])
nicks.append(nickNameList[ckNum])
except:
print(f"请检查被助力账号【{ckname}】名称是否正确？ck是否存在？提示：助力名字可填pt_pin的值、也可以填账号名。")
continue
if len(jd15_cookies) == 0:
exit(4)
use_thread(jd15_cookies, nicks, cookiesList, nickNameList)
if __name__ == '__main__':
start()
| 6,374 |
2,298 | <reponame>ryanrussell/pandas-ta
# -*- coding: utf-8 -*-
from .atr import atr
from pandas_ta import Imports
from pandas_ta.utils import get_drift, get_offset, verify_series
def natr(high, low, close, length=None, scalar=None, mamode=None, talib=None, drift=None, offset=None, **kwargs):
"""Indicator: Normalized Average True Range (NATR)"""
# Validate arguments
length = int(length) if length and length > 0 else 14
mamode = mamode if isinstance(mamode, str) else "ema"
scalar = float(scalar) if scalar else 100
high = verify_series(high, length)
low = verify_series(low, length)
close = verify_series(close, length)
drift = get_drift(drift)
offset = get_offset(offset)
mode_tal = bool(talib) if isinstance(talib, bool) else True
if high is None or low is None or close is None: return
# Calculate Result
if Imports["talib"] and mode_tal:
from talib import NATR
natr = NATR(high, low, close, length)
else:
natr = scalar / close
natr *= atr(high=high, low=low, close=close, length=length, mamode=mamode, drift=drift, offset=offset, **kwargs)
# Offset
if offset != 0:
natr = natr.shift(offset)
# Handle fills
if "fillna" in kwargs:
natr.fillna(kwargs["fillna"], inplace=True)
if "fill_method" in kwargs:
natr.fillna(method=kwargs["fill_method"], inplace=True)
# Name and Categorize it
natr.name = f"NATR_{length}"
natr.category = "volatility"
return natr
natr.__doc__ = \
"""Normalized Average True Range (NATR)
Normalized Average True Range attempt to normalize the average true range.
Sources:
https://www.tradingtechnologies.com/help/x-study/technical-indicator-definitions/normalized-average-true-range-natr/
Calculation:
Default Inputs:
length=20
ATR = Average True Range
NATR = (100 / close) * ATR(high, low, close)
Args:
high (pd.Series): Series of 'high's
low (pd.Series): Series of 'low's
close (pd.Series): Series of 'close's
length (int): The short period. Default: 20
scalar (float): How much to magnify. Default: 100
mamode (str): See ```help(ta.ma)```. Default: 'ema'
talib (bool): If TA Lib is installed and talib is True, Returns the TA Lib
version. Default: True
offset (int): How many periods to offset the result. Default: 0
Kwargs:
fillna (value, optional): pd.DataFrame.fillna(value)
fill_method (value, optional): Type of fill method
Returns:
pd.Series: New feature
"""
| 974 |
4,124 | <reponame>chenqixu/jstorm
/**
* 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 com.alibaba.jstorm.message.netty;
import java.net.ConnectException;
import java.util.concurrent.atomic.AtomicBoolean;
import org.jboss.netty.channel.Channel;
import org.jboss.netty.channel.ChannelHandlerContext;
import org.jboss.netty.channel.ChannelStateEvent;
import org.jboss.netty.channel.ExceptionEvent;
import org.jboss.netty.channel.MessageEvent;
import org.jboss.netty.channel.SimpleChannelUpstreamHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class StormClientHandler extends SimpleChannelUpstreamHandler {
private static final Logger LOG = LoggerFactory.getLogger(StormClientHandler.class);
private NettyClient client;
private AtomicBoolean being_closed;
StormClientHandler(NettyClient client) {
this.client = client;
being_closed = client.getBeing_closed();
}
/**
* Don't call from underlying netty layer, which will try to obtain the lock of jstorm netty layer
* which may lead to deadlock
*/
// @Override
// public void channelInterestChanged(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
// client.notifyInterestChanged(e.getChannel());
// }
/**
* Sometime when connecting to a bad channel which isn't writable, this method will be called
*/
@Override
public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent event) {
// register the newly established channel
Channel channel = event.getChannel();
LOG.info("connection established to :{}, local port:{}", client.getRemoteAddr(), channel.getLocalAddress());
client.connectChannel(ctx.getChannel());
client.handleResponse(ctx.getChannel(), null);
}
@Override
public void messageReceived(ChannelHandlerContext ctx, MessageEvent event) {
client.handleResponse(ctx.getChannel(), event.getMessage());
}
/**
* @see org.jboss.netty.channel.SimpleChannelUpstreamHandler#exceptionCaught(org.jboss.netty.channel.ChannelHandlerContext,
* org.jboss.netty.channel.ExceptionEvent)
*/
@Override
public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent event) {
Throwable cause = event.getCause();
if (!being_closed.get()) {
if (!(cause instanceof ConnectException)) {
LOG.info("Connection failed:" + client.getRemoteAddr(), cause);
}
client.exceptionChannel(event.getChannel());
client.reconnect();
}
}
/**
* @see org.jboss.netty.channel.SimpleChannelUpstreamHandler#channelDisconnected(org.jboss.netty.channel.ChannelHandlerContext,
* org.jboss.netty.channel.ChannelStateEvent)
*/
@Override
public void channelDisconnected(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
LOG.info("Receive channelDisconnected to {}, channel = {}", client.getRemoteAddr(), e.getChannel());
// ctx.sendUpstream(e);
super.channelDisconnected(ctx, e);
client.disconnectChannel(e.getChannel());
}
@Override
public void channelClosed(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
LOG.info("Connection to {} has been closed, channel = {}", client.getRemoteAddr(), e.getChannel());
super.channelClosed(ctx, e);
}
@Override
public void channelInterestChanged(ChannelHandlerContext ctx, ChannelStateEvent e) throws Exception {
client.notifyInterestChanged(e.getChannel());
}
}
| 1,413 |
348 | <filename>docs/data/leg-t2/054/05401186.json
{"nom":"Eulmont","circ":"1ère circonscription","dpt":"Meurthe-et-Moselle","inscrits":828,"abs":387,"votants":441,"blancs":28,"nuls":14,"exp":399,"res":[{"nuance":"SOC","nom":"Mme <NAME>","voix":203},{"nuance":"REM","nom":"Mme <NAME>","voix":196}]} | 122 |
372 | /*
* 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.
*/
/*
* This code was generated by https://github.com/googleapis/google-api-java-client-services/
* Modify at your own risk.
*/
package com.google.api.services.youtube.model;
/**
* Model definition for MembershipsDetails.
*
* <p> This is the Java data model class that specifies how to parse/serialize into the JSON that is
* transmitted over HTTP when working with the YouTube Data API. For a detailed explanation see:
* <a href="https://developers.google.com/api-client-library/java/google-http-java-client/json">https://developers.google.com/api-client-library/java/google-http-java-client/json</a>
* </p>
*
* @author Google, Inc.
*/
@SuppressWarnings("javadoc")
public final class MembershipsDetails extends com.google.api.client.json.GenericJson {
/**
* All levels that the user has access to. This includes the currently active level and all other
* levels that are included because of a higher purchase.
* The value may be {@code null}.
*/
@com.google.api.client.util.Key
private java.util.List<java.lang.String> accessibleLevels;
/**
* The highest level that the user has access to at the moment.
* The value may be {@code null}.
*/
@com.google.api.client.util.Key
private java.lang.String highestAccessibleLevel;
/**
* Display name for the highest level that the user has access to at the moment.
* The value may be {@code null}.
*/
@com.google.api.client.util.Key
private java.lang.String highestAccessibleLevelDisplayName;
/**
* The date and time when the user became a continuous member across all levels.
* The value may be {@code null}.
*/
@com.google.api.client.util.Key
private java.lang.String memberSince;
/**
* The date and time when the user started to continuously have access to the currently highest
* level.
* The value may be {@code null}.
*/
@com.google.api.client.util.Key
private java.lang.String memberSinceCurrentLevel;
/**
* The cumulative time the user has been a member across all levels in complete months (the time
* is rounded down to the nearest integer).
* The value may be {@code null}.
*/
@com.google.api.client.util.Key
private java.lang.Integer memberTotalDuration;
/**
* The cumulative time the user has had access to the currently highest level in complete months
* (the time is rounded down to the nearest integer).
* The value may be {@code null}.
*/
@com.google.api.client.util.Key
private java.lang.Integer memberTotalDurationCurrentLevel;
/**
* The highest level that the user has access to at the moment. DEPRECATED -
* highest_accessible_level should be used instead. This will be removed after we make sure there
* are no 3rd parties relying on it.
* The value may be {@code null}.
*/
@com.google.api.client.util.Key
private java.lang.String purchasedLevel;
/**
* All levels that the user has access to. This includes the currently active level and all other
* levels that are included because of a higher purchase.
* @return value or {@code null} for none
*/
public java.util.List<java.lang.String> getAccessibleLevels() {
return accessibleLevels;
}
/**
* All levels that the user has access to. This includes the currently active level and all other
* levels that are included because of a higher purchase.
* @param accessibleLevels accessibleLevels or {@code null} for none
*/
public MembershipsDetails setAccessibleLevels(java.util.List<java.lang.String> accessibleLevels) {
this.accessibleLevels = accessibleLevels;
return this;
}
/**
* The highest level that the user has access to at the moment.
* @return value or {@code null} for none
*/
public java.lang.String getHighestAccessibleLevel() {
return highestAccessibleLevel;
}
/**
* The highest level that the user has access to at the moment.
* @param highestAccessibleLevel highestAccessibleLevel or {@code null} for none
*/
public MembershipsDetails setHighestAccessibleLevel(java.lang.String highestAccessibleLevel) {
this.highestAccessibleLevel = highestAccessibleLevel;
return this;
}
/**
* Display name for the highest level that the user has access to at the moment.
* @return value or {@code null} for none
*/
public java.lang.String getHighestAccessibleLevelDisplayName() {
return highestAccessibleLevelDisplayName;
}
/**
* Display name for the highest level that the user has access to at the moment.
* @param highestAccessibleLevelDisplayName highestAccessibleLevelDisplayName or {@code null} for none
*/
public MembershipsDetails setHighestAccessibleLevelDisplayName(java.lang.String highestAccessibleLevelDisplayName) {
this.highestAccessibleLevelDisplayName = highestAccessibleLevelDisplayName;
return this;
}
/**
* The date and time when the user became a continuous member across all levels.
* @return value or {@code null} for none
*/
public java.lang.String getMemberSince() {
return memberSince;
}
/**
* The date and time when the user became a continuous member across all levels.
* @param memberSince memberSince or {@code null} for none
*/
public MembershipsDetails setMemberSince(java.lang.String memberSince) {
this.memberSince = memberSince;
return this;
}
/**
* The date and time when the user started to continuously have access to the currently highest
* level.
* @return value or {@code null} for none
*/
public java.lang.String getMemberSinceCurrentLevel() {
return memberSinceCurrentLevel;
}
/**
* The date and time when the user started to continuously have access to the currently highest
* level.
* @param memberSinceCurrentLevel memberSinceCurrentLevel or {@code null} for none
*/
public MembershipsDetails setMemberSinceCurrentLevel(java.lang.String memberSinceCurrentLevel) {
this.memberSinceCurrentLevel = memberSinceCurrentLevel;
return this;
}
/**
* The cumulative time the user has been a member across all levels in complete months (the time
* is rounded down to the nearest integer).
* @return value or {@code null} for none
*/
public java.lang.Integer getMemberTotalDuration() {
return memberTotalDuration;
}
/**
* The cumulative time the user has been a member across all levels in complete months (the time
* is rounded down to the nearest integer).
* @param memberTotalDuration memberTotalDuration or {@code null} for none
*/
public MembershipsDetails setMemberTotalDuration(java.lang.Integer memberTotalDuration) {
this.memberTotalDuration = memberTotalDuration;
return this;
}
/**
* The cumulative time the user has had access to the currently highest level in complete months
* (the time is rounded down to the nearest integer).
* @return value or {@code null} for none
*/
public java.lang.Integer getMemberTotalDurationCurrentLevel() {
return memberTotalDurationCurrentLevel;
}
/**
* The cumulative time the user has had access to the currently highest level in complete months
* (the time is rounded down to the nearest integer).
* @param memberTotalDurationCurrentLevel memberTotalDurationCurrentLevel or {@code null} for none
*/
public MembershipsDetails setMemberTotalDurationCurrentLevel(java.lang.Integer memberTotalDurationCurrentLevel) {
this.memberTotalDurationCurrentLevel = memberTotalDurationCurrentLevel;
return this;
}
/**
* The highest level that the user has access to at the moment. DEPRECATED -
* highest_accessible_level should be used instead. This will be removed after we make sure there
* are no 3rd parties relying on it.
* @return value or {@code null} for none
*/
public java.lang.String getPurchasedLevel() {
return purchasedLevel;
}
/**
* The highest level that the user has access to at the moment. DEPRECATED -
* highest_accessible_level should be used instead. This will be removed after we make sure there
* are no 3rd parties relying on it.
* @param purchasedLevel purchasedLevel or {@code null} for none
*/
public MembershipsDetails setPurchasedLevel(java.lang.String purchasedLevel) {
this.purchasedLevel = purchasedLevel;
return this;
}
@Override
public MembershipsDetails set(String fieldName, Object value) {
return (MembershipsDetails) super.set(fieldName, value);
}
@Override
public MembershipsDetails clone() {
return (MembershipsDetails) super.clone();
}
}
| 2,579 |
892 | {
"schema_version": "1.2.0",
"id": "GHSA-26gq-p245-cq98",
"modified": "2021-12-16T00:02:49Z",
"published": "2021-12-14T00:00:45Z",
"aliases": [
"CVE-2021-39933"
],
"details": "An issue has been discovered in GitLab CE/EE affecting all versions starting from 12.10 before 14.3.6, all versions starting from 14.4 before 14.4.4, all versions starting from 14.5 before 14.5.2. A regular expression used for handling user input (notes, comments, etc) was susceptible to catastrophic backtracking that could cause a DOS attack.",
"severity": [
],
"affected": [
],
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2021-39933"
},
{
"type": "WEB",
"url": "https://hackerone.com/reports/1320077"
},
{
"type": "WEB",
"url": "https://gitlab.com/gitlab-org/cves/-/blob/master/2021/CVE-2021-39933.json"
},
{
"type": "WEB",
"url": "https://gitlab.com/gitlab-org/gitlab/-/issues/340449"
}
],
"database_specific": {
"cwe_ids": [
],
"severity": "MODERATE",
"github_reviewed": false
}
} | 494 |
1,738 | /*
* 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.
*
*/
#include "EditorHelpers.h"
#include <AzFramework/Entity/EntityDebugDisplayBus.h>
#include <AzFramework/Viewport/CameraState.h>
#include <AzToolsFramework/ToolsComponents/EditorEntityIconComponentBus.h>
#include <AzToolsFramework/Viewport/ViewportMessages.h>
#include <AzToolsFramework/Viewport/ViewportTypes.h>
#include <AzToolsFramework/ViewportSelection/EditorVisibleEntityDataCache.h>
#include <AzToolsFramework/ViewportSelection/EditorSelectionUtil.h>
namespace AzToolsFramework
{
AZ_CLASS_ALLOCATOR_IMPL(EditorHelpers, AZ::SystemAllocator, 0)
static const int s_iconSize = 36; // icon display size (in pixels)
static const float s_iconMinScale = 0.1f; // minimum scale for icons in the distance
static const float s_iconMaxScale = 1.0f; // maximum scale for icons near the camera
static const float s_iconCloseDist = 3.f; // distance at which icons are at maximum scale
static const float s_iconFarDist = 40.f; // distance at which icons are at minimum scale
// helper function to wrap EBus call to check if helpers are being displayed
// note: the ['?'] icon in the top right of the editor
static bool HelpersVisible()
{
bool helpersVisible = false;
EditorRequestBus::BroadcastResult(
helpersVisible, &EditorRequests::DisplayHelpersVisible);
return helpersVisible;
}
// calculate the icon scale based on how far away it is (distanceSq) from a given point
// note: this is mostly likely distance from the camera
static float GetIconScale(const float distSq)
{
AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
return s_iconMinScale + (s_iconMaxScale - s_iconMinScale) *
(1.0f - AZ::GetClamp(AZ::GetMax(0.0f, sqrtf(distSq) - s_iconCloseDist) / s_iconFarDist, 0.0f, 1.0f));
}
static void DisplayComponents(
const AZ::EntityId entityId, const AzFramework::ViewportInfo& viewportInfo,
AzFramework::DebugDisplayRequests& debugDisplay)
{
AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
// preferred DisplayEntity call - DisplayEntityViewport
AzFramework::EntityDebugDisplayEventBus::Event(
entityId, &AzFramework::EntityDebugDisplayEvents::DisplayEntityViewport,
viewportInfo, debugDisplay);
}
static AZ::Aabb CalculateComponentAabbs(const int viewportId, const AZ::EntityId entityId)
{
AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
AZ::EBusReduceResult<AZ::Aabb, AabbAggregator> aabbResult(AZ::Aabb::CreateNull());
EditorComponentSelectionRequestsBus::EventResult(
aabbResult, entityId, &EditorComponentSelectionRequests::GetEditorSelectionBoundsViewport,
AzFramework::ViewportInfo{ viewportId });
return aabbResult.value;
}
AZ::EntityId EditorHelpers::HandleMouseInteraction(
const AzFramework::CameraState& cameraState,
const ViewportInteraction::MouseInteractionEvent& mouseInteraction)
{
AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
const int viewportId = mouseInteraction.m_mouseInteraction.m_interactionId.m_viewportId;
// set the widget context before calls to ViewportWorldToScreen so we are not
// going to constantly be pushing/popping the widget context
ViewportInteraction::WidgetContextGuard widgetContextGuard(viewportId);
const bool helpersVisible = HelpersVisible();
// selecting new entities
AZ::EntityId entityIdUnderCursor;
AZ::VectorFloat closestDistance = AZ::g_fltMax;
for (size_t entityCacheIndex = 0; entityCacheIndex < m_entityDataCache->VisibleEntityDataCount(); ++entityCacheIndex)
{
const AZ::EntityId entityId = m_entityDataCache->GetVisibleEntityId(entityCacheIndex);
if ( m_entityDataCache->IsVisibleEntityLocked(entityCacheIndex)
|| !m_entityDataCache->IsVisibleEntityVisible(entityCacheIndex))
{
continue;
}
// 2d screen space selection - did we click an icon
if (helpersVisible)
{
// some components choose to hide their icons (e.g. meshes)
if (!m_entityDataCache->IsVisibleEntityIconHidden(entityCacheIndex))
{
const AZ::Vector3& entityPosition = m_entityDataCache->GetVisibleEntityPosition(entityCacheIndex);
// selecting based on 2d icon - should only do it when visible and not selected
const QPoint screenPosition = GetScreenPosition(viewportId, entityPosition);
const AZ::VectorFloat distSqFromCamera = cameraState.m_position.GetDistanceSq(entityPosition);
const auto iconRange = static_cast<float>(GetIconScale(distSqFromCamera) * s_iconSize * 0.5f);
const auto screenCoords = mouseInteraction.m_mouseInteraction.m_mousePick.m_screenCoordinates;
if ( screenCoords.m_x >= screenPosition.x() - iconRange
&& screenCoords.m_x <= screenPosition.x() + iconRange
&& screenCoords.m_y >= screenPosition.y() - iconRange
&& screenCoords.m_y <= screenPosition.y() + iconRange)
{
entityIdUnderCursor = entityId;
break;
}
}
}
// check if components provide an aabb
const AZ::Aabb aabb = CalculateComponentAabbs(viewportId, entityId);
if (aabb.IsValid())
{
// coarse grain check
if (AabbIntersectMouseRay(mouseInteraction.m_mouseInteraction, aabb))
{
// if success, pick against specific component
if (PickEntity(
entityId, mouseInteraction.m_mouseInteraction,
closestDistance, viewportId))
{
entityIdUnderCursor = entityId;
}
}
}
}
return entityIdUnderCursor;
}
void EditorHelpers::DisplayHelpers(
const AzFramework::ViewportInfo& viewportInfo, const AzFramework::CameraState& cameraState,
AzFramework::DebugDisplayRequests& debugDisplay,
const AZStd::function<bool(AZ::EntityId)>& showIconCheck)
{
AZ_PROFILE_FUNCTION(AZ::Debug::ProfileCategory::AzToolsFramework);
if (HelpersVisible())
{
for (size_t entityCacheIndex = 0; entityCacheIndex < m_entityDataCache->VisibleEntityDataCount(); ++entityCacheIndex)
{
const AZ::EntityId entityId = m_entityDataCache->GetVisibleEntityId(entityCacheIndex);
if (!m_entityDataCache->IsVisibleEntityVisible(entityCacheIndex))
{
continue;
}
// notify components to display
DisplayComponents(entityId, viewportInfo, debugDisplay);
if ( m_entityDataCache->IsVisibleEntityIconHidden(entityCacheIndex)
|| (m_entityDataCache->IsVisibleEntitySelected(entityCacheIndex) && !showIconCheck(entityId)))
{
continue;
}
int iconTextureId = 0;
EditorEntityIconComponentRequestBus::EventResult(
iconTextureId, entityId, &EditorEntityIconComponentRequests::GetEntityIconTextureId);
const AZ::Vector3& entityPosition = m_entityDataCache->GetVisibleEntityPosition(entityCacheIndex);
const AZ::VectorFloat distSqFromCamera = cameraState.m_position.GetDistanceSq(entityPosition);
const float iconScale = GetIconScale(distSqFromCamera);
const float iconSize = s_iconSize * iconScale;
using ComponentEntityAccentType = Components::EditorSelectionAccentSystemComponent::ComponentEntityAccentType;
const AZ::Color iconHighlight = [this, entityCacheIndex]() {
if (m_entityDataCache->IsVisibleEntityLocked(entityCacheIndex))
{
return AZ::Color(AZ::u8(100), AZ::u8(100), AZ::u8(100), AZ::u8(255));
}
if (m_entityDataCache->GetVisibleEntityAccent(entityCacheIndex) == ComponentEntityAccentType::Hover)
{
return AZ::Color(AZ::u8(255), AZ::u8(120), AZ::u8(0), AZ::u8(204));
}
return AZ::Color(1.0f, 1.0f, 1.0f, 1.0f);
}();
debugDisplay.SetColor(iconHighlight);
debugDisplay.DrawTextureLabel(
iconTextureId, entityPosition, iconSize, iconSize,
/*DisplayContext::ETextureIconFlags::TEXICON_ON_TOP=*/ 0x0008);
}
}
}
} // namespace AzToolsFramework
| 4,089 |
892 | {
"schema_version": "1.2.0",
"id": "GHSA-fxg9-9cmj-2228",
"modified": "2022-05-05T00:29:24Z",
"published": "2022-05-05T00:29:24Z",
"aliases": [
"CVE-2013-4863"
],
"details": "The HomeAutomationGateway service in MiCasaVerde VeraLite with firmware 1.5.408 allows (1) remote attackers to execute arbitrary Lua code via a RunLua action in a request to upnp/control/hag on port 49451 or (2) remote authenticated users to execute arbitrary Lua code via a RunLua action in a request to port_49451/upnp/control/hag.",
"severity": [
],
"affected": [
],
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2013-4863"
},
{
"type": "WEB",
"url": "https://www3.trustwave.com/spiderlabs/advisories/TWSL2013-019.txt"
},
{
"type": "WEB",
"url": "http://packetstormsecurity.com/files/122654/MiCasaVerde-VeraLite-1.5.408-Traversal-Authorization-CSRF-Disclosure.html"
},
{
"type": "WEB",
"url": "http://www.exploit-db.com/exploits/27286"
}
],
"database_specific": {
"cwe_ids": [
],
"severity": "HIGH",
"github_reviewed": false
}
} | 520 |
3,227 | <reponame>ffteja/cgal<gh_stars>1000+
//=============================================================================
#ifndef SURFACE_MESH_TYPES_H
#define SURFACE_MESH_TYPES_H
//== INCLUDES =================================================================
#include "Vector.h"
//== CLASS DEFINITION =========================================================
/// Scalar type
typedef double Scalar;
/// Point type
typedef Vector<Scalar,3> Point;
/// Normal type
typedef Vector<Scalar,3> Normal;
/// Color type
typedef Vector<Scalar,3> Color;
/// Texture coordinate type
typedef Vector<Scalar,3> Texture_coordinate;
//============================================================================
#endif
//============================================================================
| 208 |
348 | {"nom":"Novillers","circ":"2ème circonscription","dpt":"Oise","inscrits":294,"abs":182,"votants":112,"blancs":13,"nuls":2,"exp":97,"res":[{"nuance":"REM","nom":"<NAME>","voix":53},{"nuance":"FN","nom":"<NAME>","voix":44}]} | 88 |
3,428 | <filename>lib/node_modules/@stdlib/datasets/spam-assassin/data/spam-2/00694.3aca5f2a3d0d2ccbc47ef868eb051abd.json
{"id":"00694","group":"spam-2","checksum":{"type":"MD5","value":"3aca5f2a3d0d2ccbc47ef868eb051abd"},"text":"From <EMAIL> Mon Jun 24 17:49:41 2002\nReturn-Path: [email protected]\nDelivery-Date: Mon Jun 10 22:19:35 2002\nReceived: from mandark.labs.netnoteinc.com ([213.105.180.140]) by\n dogma.slashnull.org (8.11.6/8.11.6) with ESMTP id g5ALJTG31426 for\n <<EMAIL>>; Mon, 10 Jun 2002 22:19:30 +0100\nReceived: from ipce2000.ipce.com.br (200-207-190-221.dsl.telesp.net.br\n [200.207.190.221]) by mandark.labs.netnoteinc.com (8.11.6/8.11.2) with\n ESMTP id g5ALJ7m32216 for <<EMAIL>>; Mon, 10 Jun 2002 22:19:18\n +0100\nReceived: from mx14.hotmail.com\n (tamqfl1-ar1-243-254.tamqfl1.dsl-verizon.net [4.34.243.254]) by\n ipce2000.ipce.com.br with SMTP (Microsoft Exchange Internet Mail Service\n Version 5.5.2653.13) id M4779FSR; Mon, 10 Jun 2002 15:41:00 -0300\nMessage-Id: <<EMAIL>>\nTo: <<EMAIL>>\nFrom: <EMAIL>\nSubject: No more need for a lift or support bra!1903\nDate: Mon, 10 Jun 2002 12:46:31 -1700\nMIME-Version: 1.0\nContent-Type: text/plain; charset=\"Windows-1252\"\nReply-To: <EMAIL>\nX-Keywords: \nContent-Transfer-Encoding: 7bit\n\n\nGuaranteed to increase, lift and firm your\nbreasts in 60 days or your money back!!\n\n100% herbal and natural. Proven formula since 1996. \nIncrease your bust by 1 to 3 sizes within 30-60 days \nand be all natural. \n\nClick here:\nhttp://www.freehostchina.com/ultrabust/cablebox2002/\n\nAbsolutely no side effects!\nBe more self confident!\nBe more comfortable in bed!\nNo more need for a lift or support bra!\n\n100% GUARANTEED AND FROM A NAME YOU KNOW AND TRUST!\n\n\n***********************************************************\n\nYou are receiving this email as a double opt-in \nsubscriber to the Standard Affiliates Mailing List. \nTo remove yourself from all related email lists,\njust click here:\nmailto:<EMAIL>?Subject=REMOVE\n"} | 811 |
459 | #include "vvc.h"
#include <fs/systemlog.h>
#include <math.h>
#include <algorithm>
#include "tsMuxer.h"
#include "vodCoreException.h"
#include "vod_common.h"
using namespace std;
static const int EXTENDED_SAR = 255;
// ------------------------- VvcUnit -------------------
unsigned VvcUnit::extractUEGolombCode()
{
int cnt = 0;
for (; m_reader.getBits(1) == 0; cnt++)
;
if (cnt > INT_BIT)
THROW_BITSTREAM_ERR;
return (1 << cnt) - 1 + m_reader.getBits(cnt);
}
int VvcUnit::extractSEGolombCode()
{
unsigned rez = extractUEGolombCode();
if (rez % 2 == 0)
return -(int)(rez / 2);
else
return (int)((rez + 1) / 2);
}
void VvcUnit::decodeBuffer(const uint8_t* buffer, const uint8_t* end)
{
delete[] m_nalBuffer;
m_nalBuffer = new uint8_t[end - buffer];
m_nalBufferLen = NALUnit::decodeNAL(buffer, end, m_nalBuffer, end - buffer);
}
int VvcUnit::deserialize()
{
m_reader.setBuffer(m_nalBuffer, m_nalBuffer + m_nalBufferLen);
try
{
m_reader.skipBits(2); // forbidden_zero_bit, nuh_reserved_zero_bit
nuh_layer_id = m_reader.getBits(6);
nal_unit_type = m_reader.getBits(5);
nuh_temporal_id_plus1 = m_reader.getBits(3);
if (nuh_temporal_id_plus1 == 0 || (nuh_temporal_id_plus1 != 1 && ((nal_unit_type >= 7 && nal_unit_type <= 15) ||
nal_unit_type == 21 || nal_unit_type == 22)))
return 1;
return 0;
}
catch (BitStreamException& e)
{
return NOT_ENOUGH_BUFFER;
}
}
void VvcUnit::updateBits(int bitOffset, int bitLen, int value)
{
uint8_t* ptr = (uint8_t*)m_reader.getBuffer() + bitOffset / 8;
BitStreamWriter bitWriter;
int byteOffset = bitOffset % 8;
bitWriter.setBuffer(ptr, ptr + (bitLen / 8 + 5));
uint8_t* ptr_end = (uint8_t*)m_reader.getBuffer() + (bitOffset + bitLen) / 8;
int endBitsPostfix = 8 - ((bitOffset + bitLen) % 8);
if (byteOffset > 0)
{
int prefix = *ptr >> (8 - byteOffset);
bitWriter.putBits(byteOffset, prefix);
}
bitWriter.putBits(bitLen, value);
if (endBitsPostfix < 8)
{
int postfix = *ptr_end & (1 << endBitsPostfix) - 1;
bitWriter.putBits(endBitsPostfix, postfix);
}
bitWriter.flushBits();
}
int VvcUnit::serializeBuffer(uint8_t* dstBuffer, uint8_t* dstEnd) const
{
if (m_nalBufferLen == 0)
return 0;
int encodeRez = NALUnit::encodeNAL(m_nalBuffer, m_nalBuffer + m_nalBufferLen, dstBuffer, dstEnd - dstBuffer);
if (encodeRez == -1)
return -1;
else
return encodeRez;
}
bool VvcUnit::dpb_parameters(int MaxSubLayersMinus1, bool subLayerInfoFlag)
{
for (int i = (subLayerInfoFlag ? 0 : MaxSubLayersMinus1); i <= MaxSubLayersMinus1; i++)
{
unsigned dpb_max_dec_pic_buffering_minus1 = extractUEGolombCode();
unsigned dpb_max_num_reorder_pics = extractUEGolombCode();
if (dpb_max_num_reorder_pics > dpb_max_dec_pic_buffering_minus1)
return 1;
unsigned dpb_max_latency_increase_plus1 = extractUEGolombCode();
if (dpb_max_latency_increase_plus1 == 0xffffffff)
return 1;
}
return 0;
}
// ------------------------- VvcUnitWithProfile -------------------
VvcUnitWithProfile::VvcUnitWithProfile() : profile_idc(0), level_idc(0) {}
void VvcUnitWithProfile::profile_tier_level(bool profileTierPresentFlag, int MaxNumSubLayersMinus1)
{
if (profileTierPresentFlag)
{
profile_idc = m_reader.getBits(7);
bool tier_flag = m_reader.getBit();
}
level_idc = m_reader.getBits(8);
m_reader.skipBits(2); // ptl_frame_only_constraint_flag, ptl_multilayer_enabled_flag
if (profileTierPresentFlag)
{ // general_constraints_info()
if (m_reader.getBit()) // gci_present_flag
{
m_reader.skipBits(32);
m_reader.skipBits(32);
m_reader.skipBits(7);
int gci_num_reserved_bits = m_reader.getBits(8);
for (int i = 0; i < gci_num_reserved_bits; i++) m_reader.skipBit(); // gci_reserved_zero_bit[i]
}
m_reader.skipBits(m_reader.getBitsLeft() % 8); // gci_alignment_zero_bit
}
std::vector<int> ptl_sublayer_level_present_flag;
ptl_sublayer_level_present_flag.resize(MaxNumSubLayersMinus1);
for (int i = MaxNumSubLayersMinus1 - 1; i >= 0; i--) ptl_sublayer_level_present_flag[i] = m_reader.getBit();
m_reader.skipBits(m_reader.getBitsLeft() % 8); // ptl_reserved_zero_bit
for (int i = MaxNumSubLayersMinus1 - 1; i >= 0; i--)
if (ptl_sublayer_level_present_flag[i])
m_reader.skipBits(8); // sublayer_level_idc[i]
if (profileTierPresentFlag)
{
int ptl_num_sub_profiles = m_reader.getBits(8);
for (int i = 0; i < ptl_num_sub_profiles; i++) m_reader.skipBits(32); // general_sub_profile_idc[i]
}
}
std::string VvcUnitWithProfile::getProfileString() const
{
string rez("Profile: ");
if (profile_idc == 1)
rez += string("Main10");
else if (profile_idc == 65)
rez += string("Main10StillPicture");
else if (profile_idc == 33)
rez += string("Main10_4:4:4");
else if (profile_idc == 97)
rez += string("Main10_4:4:4_StillPicture");
else if (profile_idc == 17)
rez += string("Main10_Multilayer");
else if (profile_idc == 49)
rez += string("Main10_Multilayer_4:4:4");
else if (profile_idc == 0)
rez += string("Not defined");
else
rez += "Unknown";
if (level_idc)
{
rez += string("@");
rez += int32ToStr(level_idc / 16);
rez += string(".");
rez += int32ToStr((level_idc % 16) / 3);
}
return rez;
}
// ------------------------- VvcVpsUnit -------------------
VvcVpsUnit::VvcVpsUnit()
: VvcUnitWithProfile(),
vps_id(0),
vps_max_layers(0),
vps_max_sublayers(0),
num_units_in_tick(0),
time_scale(0),
num_units_in_tick_bit_pos(-1)
{
}
int VvcVpsUnit::deserialize()
{
int rez = VvcUnit::deserialize();
if (rez)
return rez;
try
{
vps_id = m_reader.getBits(4);
vps_max_layers = m_reader.getBits(6) + 1;
vps_max_sublayers = m_reader.getBits(3) + 1;
bool vps_default_ptl_dpb_hrd_max_tid_flag =
(vps_max_layers > 1 && vps_max_sublayers > 1) ? m_reader.getBit() : 1;
int vps_all_independent_layers_flag = (vps_max_layers > 1) ? m_reader.getBit() : 1;
for (int i = 0; i < vps_max_layers; i++)
{
m_reader.skipBits(6); // vps_layer_id[i]
if (i > 0 && !vps_all_independent_layers_flag)
{
if (!m_reader.getBit()) // vps_independent_layer_flag[i]
{
bool vps_max_tid_ref_present_flag = m_reader.getBit();
for (int j = 0; j < i; j++)
{
bool vps_direct_ref_layer_flag = m_reader.getBit();
if (vps_max_tid_ref_present_flag && vps_direct_ref_layer_flag)
m_reader.skipBits(3); // vps_max_tid_il_ref_pics_plus1[i][j]
}
}
}
}
bool vps_each_layer_is_an_ols_flag = 1;
int vps_num_ptls = 1;
int vps_ols_mode_idc = 2;
int olsModeIdc = 4;
int TotalNumOlss = vps_max_layers;
if (vps_max_layers > 1)
{
vps_each_layer_is_an_ols_flag = 0;
if (vps_all_independent_layers_flag)
vps_each_layer_is_an_ols_flag = m_reader.getBit();
if (!vps_each_layer_is_an_ols_flag)
{
if (!vps_all_independent_layers_flag)
{
vps_ols_mode_idc = m_reader.getBits(2);
olsModeIdc = vps_ols_mode_idc;
}
if (vps_ols_mode_idc == 2)
{
int vps_num_output_layer_sets_minus2 = m_reader.getBits(8);
TotalNumOlss = vps_num_output_layer_sets_minus2 + 2;
for (int i = 1; i <= vps_num_output_layer_sets_minus2 + 1; i++)
for (int j = 0; j < vps_max_layers; j++) m_reader.skipBit(); // vps_ols_output_layer_flag[i][j]
}
}
vps_num_ptls = m_reader.getBits(8) + 1;
}
std::vector<bool> vps_pt_present_flag;
std::vector<int> vps_ptl_max_tid;
vps_pt_present_flag.resize(vps_num_ptls);
vps_ptl_max_tid.resize(vps_num_ptls);
for (int i = 0; i < vps_num_ptls; i++)
{
if (i > 0)
vps_pt_present_flag[i] = m_reader.getBit();
if (!vps_default_ptl_dpb_hrd_max_tid_flag)
vps_ptl_max_tid[i] = m_reader.getBits(3);
}
m_reader.skipBits(m_reader.getBitsLeft() % 8); // vps_ptl_alignment_zero_bit
for (int i = 0; i < vps_num_ptls; i++) profile_tier_level(vps_pt_present_flag[i], vps_ptl_max_tid[i]);
for (int i = 0; i < TotalNumOlss; i++)
if (vps_num_ptls > 1 && vps_num_ptls != TotalNumOlss)
m_reader.skipBits(8); // vps_ols_ptl_idx[i]
if (!vps_each_layer_is_an_ols_flag)
{
unsigned NumMultiLayerOlss = 0;
int NumLayersInOls = 0;
for (int i = 1; i < TotalNumOlss; i++)
{
if (vps_each_layer_is_an_ols_flag)
NumLayersInOls = 1;
else if (vps_ols_mode_idc == 0 || vps_ols_mode_idc == 1)
NumLayersInOls = i + 1;
else if (vps_ols_mode_idc == 2)
{
int j = 0;
for (int k = 0; k < vps_max_layers; k++) NumLayersInOls = j;
}
if (NumLayersInOls > 1)
NumMultiLayerOlss++;
}
unsigned vps_num_dpb_params = extractUEGolombCode() + 1;
if (vps_num_dpb_params >= NumMultiLayerOlss)
return 1;
unsigned VpsNumDpbParams;
if (vps_each_layer_is_an_ols_flag)
VpsNumDpbParams = 0;
else
VpsNumDpbParams = vps_num_dpb_params;
bool vps_sublayer_dpb_params_present_flag =
(vps_max_sublayers > 1) ? vps_sublayer_dpb_params_present_flag = m_reader.getBit() : 0;
for (size_t i = 0; i < VpsNumDpbParams; i++)
{
int vps_dpb_max_tid = vps_max_sublayers - 1;
if (!vps_default_ptl_dpb_hrd_max_tid_flag)
vps_dpb_max_tid = m_reader.getBits(3);
if (dpb_parameters(vps_dpb_max_tid, vps_sublayer_dpb_params_present_flag))
return 1;
}
for (size_t i = 0; i < NumMultiLayerOlss; i++)
{
extractUEGolombCode(); // vps_ols_dpb_pic_width
extractUEGolombCode(); // vps_ols_dpb_pic_height
m_reader.skipBits(2); // vps_ols_dpb_chroma_format
unsigned vps_ols_dpb_bitdepth_minus8 = extractUEGolombCode();
if (vps_ols_dpb_bitdepth_minus8 > 2)
return 1;
if (VpsNumDpbParams > 1 && VpsNumDpbParams != NumMultiLayerOlss)
{
unsigned vps_ols_dpb_params_idx = extractUEGolombCode();
if (vps_ols_dpb_params_idx >= VpsNumDpbParams)
return 1;
}
}
bool vps_timing_hrd_params_present_flag = m_reader.getBit();
if (vps_timing_hrd_params_present_flag)
{
if (m_vps_hrd.general_timing_hrd_parameters())
return 1;
bool vps_sublayer_cpb_params_present_flag = (vps_max_sublayers > 1) ? m_reader.getBit() : 0;
unsigned vps_num_ols_timing_hrd_params = extractUEGolombCode() + 1;
if (vps_num_ols_timing_hrd_params > NumMultiLayerOlss)
return 1;
for (size_t i = 0; i <= vps_num_ols_timing_hrd_params; i++)
{
int vps_hrd_max_tid = 1;
if (!vps_default_ptl_dpb_hrd_max_tid_flag)
vps_hrd_max_tid = m_reader.getBits(3);
int firstSubLayer = vps_sublayer_cpb_params_present_flag ? 0 : vps_hrd_max_tid;
m_vps_hrd.ols_timing_hrd_parameters(firstSubLayer, vps_hrd_max_tid);
}
if (vps_num_ols_timing_hrd_params > 1 && vps_num_ols_timing_hrd_params != NumMultiLayerOlss)
{
for (size_t i = 0; i < NumMultiLayerOlss; i++)
{
unsigned vps_ols_timing_hrd_idx = extractUEGolombCode();
if (vps_ols_timing_hrd_idx >= vps_num_ols_timing_hrd_params)
return 1;
}
}
}
}
return rez;
}
catch (VodCoreException& e)
{
return NOT_ENOUGH_BUFFER;
}
}
void VvcVpsUnit::setFPS(double fps)
{
time_scale = (uint32_t)(fps + 0.5) * 1000000;
num_units_in_tick = time_scale / fps + 0.5;
// num_units_in_tick = time_scale/2 / fps;
assert(num_units_in_tick_bit_pos > 0);
updateBits(num_units_in_tick_bit_pos, 32, num_units_in_tick);
updateBits(num_units_in_tick_bit_pos + 32, 32, time_scale);
}
double VvcVpsUnit::getFPS() const { return num_units_in_tick ? time_scale / (float)num_units_in_tick : 0; }
string VvcVpsUnit::getDescription() const
{
string rez("Frame rate: ");
double fps = getFPS();
if (fps != 0)
rez += doubleToStr(fps);
else
rez += string("not found");
return rez;
}
// ------------------------- VvcSpsUnit ------------------------------
VvcSpsUnit::VvcSpsUnit()
: VvcUnitWithProfile(),
sps_id(0),
vps_id(0),
max_sublayers_minus1(0),
chroma_format_idc(0),
pic_width_max_in_luma_samples(0),
pic_height_max_in_luma_samples(0),
bitdepth_minus8(0),
log2_max_pic_order_cnt_lsb(0),
colour_primaries(2),
transfer_characteristics(2),
matrix_coeffs(2), // 2 = unspecified
full_range_flag(0),
chroma_sample_loc_type_frame(0),
chroma_sample_loc_type_top_field(0),
chroma_sample_loc_type_bottom_field(0),
num_units_in_tick(0),
time_scale(0),
inter_layer_prediction_enabled_flag(0),
long_term_ref_pics_flag(0),
sps_num_ref_pic_lists(0),
weighted_pred_flag(0),
weighted_bipred_flag(0)
{
}
int VvcSpsUnit::deserialize()
{
int rez = VvcUnit::deserialize();
if (rez)
return rez;
try
{
sps_id = m_reader.getBits(4);
vps_id = m_reader.getBits(4);
max_sublayers_minus1 = m_reader.getBits(3);
if (max_sublayers_minus1 == 7)
return 1;
chroma_format_idc = m_reader.getBits(2);
unsigned sps_log2_ctu_size_minus5 = m_reader.getBits(2);
if (sps_log2_ctu_size_minus5 > 2)
return 1;
int CtbLog2SizeY = sps_log2_ctu_size_minus5 + 5;
unsigned CtbSizeY = 1 << CtbLog2SizeY;
bool sps_ptl_dpb_hrd_params_present_flag = m_reader.getBit();
if (sps_id == 0 && !sps_ptl_dpb_hrd_params_present_flag)
return 1;
if (sps_ptl_dpb_hrd_params_present_flag)
profile_tier_level(1, max_sublayers_minus1);
m_reader.skipBit(); // sps_gdr_enabled_flag
if (m_reader.getBit()) // sps_ref_pic_resampling_enabled_flag
m_reader.skipBit(); // sps_res_change_in_clvs_allowed_flag
pic_width_max_in_luma_samples = extractUEGolombCode();
pic_height_max_in_luma_samples = extractUEGolombCode();
unsigned tmpWidthVal = (pic_width_max_in_luma_samples + CtbSizeY - 1) / CtbSizeY;
unsigned tmpHeightVal = (pic_height_max_in_luma_samples + CtbSizeY - 1) / CtbSizeY;
unsigned sps_conf_win_left_offset = 0;
unsigned sps_conf_win_right_offset = 0;
unsigned sps_conf_win_top_offset = 0;
unsigned sps_conf_win_bottom_offset = 0;
if (m_reader.getBit()) // sps_conformance_window_flag
{
sps_conf_win_left_offset = extractUEGolombCode();
sps_conf_win_right_offset = extractUEGolombCode();
sps_conf_win_top_offset = extractUEGolombCode();
sps_conf_win_bottom_offset = extractUEGolombCode();
}
if (m_reader.getBit()) // sps_subpic_info_present_flag
{
unsigned sps_num_subpics_minus1 = extractUEGolombCode();
if (sps_num_subpics_minus1 > 600)
return 1;
if (sps_num_subpics_minus1 > 0)
{
bool sps_independent_subpics_flag = m_reader.getBit();
bool sps_subpic_same_size_flag = m_reader.getBit();
for (size_t i = 0; i <= sps_num_subpics_minus1; i++)
{
if (!sps_subpic_same_size_flag || i == 0)
{
if (i != 0 && pic_width_max_in_luma_samples > CtbSizeY)
m_reader.skipBits(ceil(log2(tmpWidthVal))); // sps_subpic_ctu_top_left_x[i]
if (i != 0 && pic_height_max_in_luma_samples > CtbSizeY)
m_reader.skipBits(ceil(log2(tmpHeightVal))); // sps_subpic_ctu_top_left_y[i]
if (i < sps_num_subpics_minus1 && pic_width_max_in_luma_samples > CtbSizeY)
m_reader.skipBits(ceil(log2(tmpWidthVal))); // sps_subpic_width_minus1[i]
if (i < sps_num_subpics_minus1 && pic_height_max_in_luma_samples > CtbSizeY)
m_reader.skipBits(ceil(log2(tmpHeightVal))); // sps_subpic_height_minus1[i]
}
if (!sps_independent_subpics_flag)
{
m_reader.skipBit(); // sps_subpic_treated_as_pic_flag
m_reader.skipBit(); // sps_loop_filter_across_subpic_enabled_flag
}
}
}
unsigned sps_subpic_id_len = extractUEGolombCode() + 1;
if (sps_subpic_id_len > 16 || (unsigned)(1 << sps_subpic_id_len) < (sps_num_subpics_minus1 + 1))
return 1;
if (m_reader.getBit()) // sps_subpic_id_mapping_explicitly_signalled_flag
{
if (m_reader.getBit()) // sps_subpic_id_mapping_present_flag
for (size_t i = 0; i <= sps_num_subpics_minus1; i++)
m_reader.skipBits(sps_subpic_id_len); // sps_subpic_id[i]
}
}
bitdepth_minus8 = extractUEGolombCode();
if (bitdepth_minus8 > 2)
return 1;
int QpBdOffset = 6 * bitdepth_minus8;
m_reader.skipBit(); // sps_entropy_coding_sync_enabled_flag
m_reader.skipBit(); // vsps_entry_point_offsets_present_flag
log2_max_pic_order_cnt_lsb = m_reader.getBits(4) + 4;
if (log2_max_pic_order_cnt_lsb > 16)
return 1;
if (m_reader.getBit()) // sps_poc_msb_cycle_flag
{
if (extractUEGolombCode() /* sps_poc_msb_cycle_len_minus1 */ > 23 - log2_max_pic_order_cnt_lsb)
return 1;
}
int sps_num_extra_ph_bytes = m_reader.getBits(2);
for (size_t i = 0; i < sps_num_extra_ph_bytes; i++) m_reader.skipBits(8); // sps_extra_ph_bit_present_flag[i]
int sps_num_extra_sh_bytes = m_reader.getBits(2);
for (size_t i = 0; i < sps_num_extra_sh_bytes; i++) m_reader.skipBits(8); // sps_extra_sh_bit_present_flag[i]
if (sps_ptl_dpb_hrd_params_present_flag)
{
bool sps_sublayer_dpb_params_flag = (max_sublayers_minus1 > 0) ? m_reader.getBit() : 0;
if (dpb_parameters(max_sublayers_minus1, sps_sublayer_dpb_params_flag))
return 1;
}
unsigned sps_log2_min_luma_coding_block_size_minus2 = extractUEGolombCode();
if (sps_log2_min_luma_coding_block_size_minus2 > (unsigned)min(4, (int)sps_log2_ctu_size_minus5 + 3))
return 1;
unsigned MinCbLog2SizeY = sps_log2_min_luma_coding_block_size_minus2 + 2;
unsigned MinCbSizeY = 1 << MinCbLog2SizeY;
m_reader.skipBit(); // sps_partition_constraints_override_enabled_flag
unsigned sps_log2_diff_min_qt_min_cb_intra_slice_luma = extractUEGolombCode();
if (sps_log2_diff_min_qt_min_cb_intra_slice_luma > min(6, CtbLog2SizeY) - MinCbLog2SizeY)
return 1;
unsigned MinQtLog2SizeIntraY = sps_log2_diff_min_qt_min_cb_intra_slice_luma + MinCbLog2SizeY;
unsigned sps_max_mtt_hierarchy_depth_intra_slice_luma = extractUEGolombCode();
if (sps_max_mtt_hierarchy_depth_intra_slice_luma > 2 * (CtbLog2SizeY - MinCbLog2SizeY))
return 1;
if (sps_max_mtt_hierarchy_depth_intra_slice_luma != 0)
{
if (extractUEGolombCode() >
CtbLog2SizeY - MinQtLog2SizeIntraY) // sps_log2_diff_max_bt_min_qt_intra_slice_luma
return 1;
if (extractUEGolombCode() >
min(6, CtbLog2SizeY) - MinQtLog2SizeIntraY) // sps_log2_diff_max_tt_min_qt_intra_slice_luma
return 1;
}
bool sps_qtbtt_dual_tree_intra_flag = (chroma_format_idc != 0 ? m_reader.getBit() : 0);
if (sps_qtbtt_dual_tree_intra_flag)
{
unsigned sps_log2_diff_min_qt_min_cb_intra_slice_chroma = extractUEGolombCode();
if (sps_log2_diff_min_qt_min_cb_intra_slice_chroma > min(6, CtbLog2SizeY) - MinCbLog2SizeY) //
return 1;
unsigned MinQtLog2SizeIntraC = sps_log2_diff_min_qt_min_cb_intra_slice_chroma + MinCbLog2SizeY;
unsigned sps_max_mtt_hierarchy_depth_intra_slice_chroma = extractUEGolombCode();
if (sps_max_mtt_hierarchy_depth_intra_slice_chroma > 2 * (CtbLog2SizeY - MinCbLog2SizeY))
return 1;
if (sps_max_mtt_hierarchy_depth_intra_slice_chroma != 0)
{
if (extractUEGolombCode() >
min(6, CtbLog2SizeY) - MinQtLog2SizeIntraC) // sps_log2_diff_max_bt_min_qt_intra_slice_chroma
return 1;
if (extractUEGolombCode() >
min(6, CtbLog2SizeY) - MinQtLog2SizeIntraC) // sps_log2_diff_max_tt_min_qt_intra_slice_chroma
return 1;
}
}
unsigned sps_log2_diff_min_qt_min_cb_inter_slice = extractUEGolombCode();
if (sps_log2_diff_min_qt_min_cb_inter_slice > min(6, CtbLog2SizeY) - MinCbLog2SizeY)
return 1;
unsigned MinQtLog2SizeInterY = sps_log2_diff_min_qt_min_cb_inter_slice + MinCbLog2SizeY;
unsigned sps_max_mtt_hierarchy_depth_inter_slice = extractUEGolombCode();
if (sps_max_mtt_hierarchy_depth_inter_slice > 2 * (CtbLog2SizeY - MinCbLog2SizeY))
return 1;
if (sps_max_mtt_hierarchy_depth_inter_slice != 0)
{
if (extractUEGolombCode() > CtbLog2SizeY - MinQtLog2SizeInterY) // sps_log2_diff_max_bt_min_qt_inter_slice
return 1;
if (extractUEGolombCode() >
min(6, CtbLog2SizeY) - MinQtLog2SizeInterY) // sps_log2_diff_max_tt_min_qt_inter_slice
return 1;
}
bool sps_max_luma_transform_size_64_flag = (CtbSizeY > 32 ? m_reader.getBit() : 0);
bool sps_transform_skip_enabled_flag = m_reader.getBit();
if (sps_transform_skip_enabled_flag)
{
if (extractUEGolombCode() > 3) // sps_log2_transform_skip_max_size_minus2
return 1;
m_reader.skipBit(); // sps_bdpcm_enabled_flag
}
if (m_reader.getBit()) // sps_mts_enabled_flag
{
m_reader.skipBit(); // sps_explicit_mts_intra_enabled_flag
m_reader.skipBit(); // sps_explicit_mts_inter_enabled_flag
}
bool sps_lfnst_enabled_flag = m_reader.getBit();
if (chroma_format_idc != 0)
{
bool sps_joint_cbcr_enabled_flag = m_reader.getBit();
int numQpTables =
m_reader.getBit() /* sps_same_qp_table_for_chroma_flag */ ? 1 : (sps_joint_cbcr_enabled_flag ? 3 : 2);
for (int i = 0; i < numQpTables; i++)
{
int sps_qp_table_start_minus26 = extractSEGolombCode();
if (sps_qp_table_start_minus26 < (-26 - QpBdOffset) || sps_qp_table_start_minus26 > 36)
return 1;
unsigned sps_num_points_in_qp_table_minus1 = extractUEGolombCode();
if (sps_num_points_in_qp_table_minus1 > (unsigned)(36 - sps_qp_table_start_minus26))
return 1;
for (size_t j = 0; j <= sps_num_points_in_qp_table_minus1; j++)
{
extractUEGolombCode(); // sps_delta_qp_in_val_minus1
extractUEGolombCode(); // sps_delta_qp_diff_val
}
}
}
m_reader.skipBit(); // sps_sao_enabled_flag
if (m_reader.getBit() /* sps_alf_enabled_flag */ && chroma_format_idc != 0)
m_reader.skipBit(); // sps_ccalf_enabled_flag
m_reader.skipBit(); // sps_lmcs_enabled_flag
weighted_pred_flag = m_reader.getBit();
weighted_bipred_flag = m_reader.getBit();
long_term_ref_pics_flag = m_reader.getBit();
inter_layer_prediction_enabled_flag = (sps_id != 0) ? m_reader.getBit() : 0;
m_reader.skipBit(); // sps_idr_rpl_present_flag
bool sps_rpl1_same_as_rpl0_flag = m_reader.getBit();
for (size_t i = 0; i < (sps_rpl1_same_as_rpl0_flag ? 1 : 2); i++)
{
sps_num_ref_pic_lists = extractUEGolombCode();
if (sps_num_ref_pic_lists > 64)
return 1;
for (size_t j = 0; j < sps_num_ref_pic_lists; j++) ref_pic_list_struct(i, j);
}
m_reader.skipBit(); // sps_ref_wraparound_enabled_flag
bool sps_sbtmvp_enabled_flag = (m_reader.getBit()) /* sps_temporal_mvp_enabled_flag */ ? m_reader.getBit() : 0;
bool sps_amvr_enabled_flag = m_reader.getBit();
if (m_reader.getBit()) // sps_bdof_enabled_flag
m_reader.skipBit(); // sps_bdof_control_present_in_ph_flag
m_reader.skipBit(); // sps_smvd_enabled_flag
if (m_reader.getBit()) // sps_dmvr_enabled_flag
m_reader.skipBit(); // sps_dmvr_control_present_in_ph_flag
if (m_reader.getBit()) // sps_mmvd_enabled_flag
m_reader.skipBit(); // sps_mmvd_fullpel_only_enabled_flag
unsigned sps_six_minus_max_num_merge_cand = extractUEGolombCode();
if (sps_six_minus_max_num_merge_cand > 5)
return 1;
unsigned MaxNumMergeCand = 6 - sps_six_minus_max_num_merge_cand;
m_reader.skipBit(); // sps_sbt_enabled_flag
if (m_reader.getBit()) // sps_affine_enabled_flag
{
unsigned sps_five_minus_max_num_subblock_merge_cand = extractUEGolombCode();
if (sps_five_minus_max_num_subblock_merge_cand + sps_sbtmvp_enabled_flag > 5)
return 1;
m_reader.skipBit(); // sps_6param_affine_enabled_flag
if (sps_amvr_enabled_flag)
m_reader.skipBit(); // sps_affine_amvr_enabled_flag
if (m_reader.getBit()) // sps_affine_prof_enabled_flag
m_reader.skipBit(); // sps_prof_control_present_in_ph_flag
}
m_reader.skipBit(); // sps_bcw_enabled_flag
m_reader.skipBit(); // sps_ciip_enabled_flag
if (MaxNumMergeCand >= 2)
{
if (m_reader.getBit() /* sps_gpm_enabled_flag */ && MaxNumMergeCand >= 3)
{
unsigned sps_max_num_merge_cand_minus_max_num_gpm_cand = extractUEGolombCode();
if (sps_max_num_merge_cand_minus_max_num_gpm_cand + 2 > MaxNumMergeCand)
return 1;
}
}
unsigned sps_log2_parallel_merge_level_minus2 = extractUEGolombCode();
if (sps_log2_parallel_merge_level_minus2 > CtbLog2SizeY - 2)
return 1;
bool sps_isp_enabled_flag = m_reader.getBit();
bool sps_mrl_enabled_flag = m_reader.getBit();
bool sps_mip_enabled_flag = m_reader.getBit();
if (chroma_format_idc != 0)
bool sps_cclm_enabled_flag = m_reader.getBit();
if (chroma_format_idc == 1)
{
bool sps_chroma_horizontal_collocated_flag = m_reader.getBit();
bool sps_chroma_vertical_collocated_flag = m_reader.getBit();
}
bool sps_palette_enabled_flag = m_reader.getBit();
bool sps_act_enabled_flag =
(chroma_format_idc == 3 && !sps_max_luma_transform_size_64_flag) ? m_reader.getBit() : 0;
if (sps_transform_skip_enabled_flag || sps_palette_enabled_flag)
{
unsigned sps_min_qp_prime_ts = extractUEGolombCode();
if (sps_min_qp_prime_ts > 8)
return 1;
}
if (m_reader.getBit()) // sps_ibc_enabled_flag
{
unsigned sps_six_minus_max_num_ibc_merge_cand = extractUEGolombCode();
if (sps_six_minus_max_num_ibc_merge_cand > 5)
return 1;
}
if (m_reader.getBit()) // sps_ladf_enabled_flag
{
int sps_num_ladf_intervals_minus2 = m_reader.getBits(2);
int sps_ladf_lowest_interval_qp_offset = extractSEGolombCode();
for (int i = 0; i < sps_num_ladf_intervals_minus2 + 1; i++)
{
int sps_ladf_qp_offset = extractSEGolombCode();
unsigned sps_ladf_delta_threshold_minus1 = extractUEGolombCode();
}
}
bool sps_explicit_scaling_list_enabled_flag = m_reader.getBit();
if (sps_lfnst_enabled_flag && sps_explicit_scaling_list_enabled_flag)
bool sps_scaling_matrix_for_lfnst_disabled_flag = m_reader.getBit();
bool sps_scaling_matrix_for_alternative_colour_space_disabled_flag =
(sps_act_enabled_flag && sps_explicit_scaling_list_enabled_flag) ? m_reader.getBit() : 0;
if (sps_scaling_matrix_for_alternative_colour_space_disabled_flag)
bool sps_scaling_matrix_designated_colour_space_flag = m_reader.getBit();
bool sps_dep_quant_enabled_flag = m_reader.getBit();
bool sps_sign_data_hiding_enabled_flag = m_reader.getBit();
if (m_reader.getBit()) // sps_virtual_boundaries_enabled_flag
{
if (m_reader.getBit()) // sps_virtual_boundaries_present_flag
{
unsigned sps_num_ver_virtual_boundaries = extractUEGolombCode();
if (sps_num_ver_virtual_boundaries > (pic_width_max_in_luma_samples <= 8 ? 0 : 3))
return 1;
for (size_t i = 0; i < sps_num_ver_virtual_boundaries; i++)
{
unsigned sps_virtual_boundary_pos_x_minus1 = extractUEGolombCode();
if (sps_virtual_boundary_pos_x_minus1 > ceil(pic_width_max_in_luma_samples / 8) - 2)
return 1;
}
unsigned sps_num_hor_virtual_boundaries = extractUEGolombCode();
if (sps_num_hor_virtual_boundaries > (pic_height_max_in_luma_samples <= 8 ? 0 : 3))
return 1;
for (size_t i = 0; i < sps_num_hor_virtual_boundaries; i++)
{
unsigned sps_virtual_boundary_pos_y_minus1 = extractUEGolombCode();
if (sps_virtual_boundary_pos_y_minus1 > ceil(pic_height_max_in_luma_samples / 8) - 2)
return 1;
}
}
}
if (sps_ptl_dpb_hrd_params_present_flag)
{
if (m_reader.getBit()) // sps_timing_hrd_params_present_flag
{
if (m_sps_hrd.general_timing_hrd_parameters())
return 1;
int sps_sublayer_cpb_params_present_flag = (max_sublayers_minus1 > 0) ? m_reader.getBit() : 0;
int firstSubLayer = sps_sublayer_cpb_params_present_flag ? 0 : max_sublayers_minus1;
m_sps_hrd.ols_timing_hrd_parameters(firstSubLayer, max_sublayers_minus1);
}
}
bool sps_field_seq_flag = m_reader.getBit();
if (m_reader.getBit()) // sps_vui_parameters_present_flag
{
unsigned sps_vui_payload_size_minus1 = extractUEGolombCode();
if (sps_vui_payload_size_minus1 > 1023)
return 1;
m_reader.skipBits(m_reader.getBitsLeft() % 8); // sps_vui_alignment_zero_bit
vui_parameters();
}
bool sps_extension_flag = m_reader.getBit();
return 0;
}
catch (VodCoreException& e)
{
return NOT_ENOUGH_BUFFER;
}
}
int VvcSpsUnit::ref_pic_list_struct(int listIdx, int rplsIdx)
{
unsigned num_ref_entries = extractUEGolombCode();
bool ltrp_in_header_flag = 1;
if (long_term_ref_pics_flag && rplsIdx < sps_num_ref_pic_lists && num_ref_entries > 0)
ltrp_in_header_flag = m_reader.getBit();
for (size_t i = 0; i < num_ref_entries; i++)
{
bool inter_layer_ref_pic_flag = (inter_layer_prediction_enabled_flag) ? m_reader.getBit() : 0;
if (!inter_layer_ref_pic_flag)
{
bool st_ref_pic_flag = (long_term_ref_pics_flag) ? m_reader.getBit() : 1;
if (st_ref_pic_flag)
{
unsigned abs_delta_poc_st = extractUEGolombCode();
if (abs_delta_poc_st > (2 << 14) - 1)
return 1;
unsigned AbsDeltaPocSt = abs_delta_poc_st + 1;
if ((weighted_pred_flag || weighted_bipred_flag) && i != 0)
AbsDeltaPocSt -= 1;
if (AbsDeltaPocSt > 0)
bool strp_entry_sign_flag = m_reader.getBit();
}
else if (!ltrp_in_header_flag)
int rpls_poc_lsb_lt = m_reader.getBits(log2_max_pic_order_cnt_lsb);
}
else
unsigned ilrp_idx = extractUEGolombCode();
}
return 0;
}
double VvcSpsUnit::getFPS() const { return num_units_in_tick ? time_scale / (float)num_units_in_tick : 0; }
string VvcSpsUnit::getDescription() const
{
string result = getProfileString();
result += string(" Resolution: ") + int32ToStr(pic_width_max_in_luma_samples) + string(":") +
int32ToStr(pic_height_max_in_luma_samples) + string("p");
double fps = getFPS();
result += " Frame rate: ";
result += (fps ? doubleToStr(fps) : string("not found"));
return result;
}
int VvcSpsUnit::vui_parameters()
{
bool progressive_source_flag = m_reader.getBit();
bool interlaced_source_flag = m_reader.getBit();
m_reader.skipBit(); // non_packed_constraint_flag
m_reader.skipBit(); // non_projected_constraint_flag
if (m_reader.getBit()) // aspect_ratio_info_present_flag
{
if (m_reader.getBits(8) == EXTENDED_SAR) // aspect_ratio_idc
m_reader.skipBits(32); // sar_width, sar_height
}
if (m_reader.getBit()) // overscan_info_present_flag
m_reader.skipBit(); // overscan_appropriate_flag
if (m_reader.getBit()) // colour_description_present_flag
{
colour_primaries = m_reader.getBits(8);
transfer_characteristics = m_reader.getBits(8);
matrix_coeffs = m_reader.getBits(8);
full_range_flag = m_reader.getBit();
}
if (m_reader.getBit()) // chroma_loc_info_present_flag
{
if (progressive_source_flag && !interlaced_source_flag)
chroma_sample_loc_type_frame = extractUEGolombCode();
else
{
chroma_sample_loc_type_top_field = extractUEGolombCode();
if (chroma_sample_loc_type_top_field > 5)
return 1;
chroma_sample_loc_type_bottom_field = extractUEGolombCode();
if (chroma_sample_loc_type_bottom_field > 5)
return 1;
}
}
return 0;
}
// ----------------------- VvcPpsUnit ------------------------
VvcPpsUnit::VvcPpsUnit() : pps_id(-1), sps_id(-1) {}
int VvcPpsUnit::deserialize()
{
int rez = VvcUnit::deserialize();
if (rez)
return rez;
try
{
pps_id = m_reader.getBits(6);
sps_id = m_reader.getBits(4);
// bool pps_mixed_nalu_types_in_pic_flag= m_reader.getBit();
// int pps_pic_width_in_luma_samples = extractUEGolombCode();
// int pps_pic_height_in_luma_samples = extractUEGolombCode();
return 0;
}
catch (VodCoreException& e)
{
return NOT_ENOUGH_BUFFER;
}
}
// ----------------------- VvcHrdUnit ------------------------
VvcHrdUnit::VvcHrdUnit()
: general_nal_hrd_params_present_flag(0),
general_du_hrd_params_present_flag(0),
general_vcl_hrd_params_present_flag(0),
hrd_cpb_cnt_minus1(0),
num_units_in_tick(0),
time_scale(0)
{
}
bool VvcHrdUnit::general_timing_hrd_parameters()
{
num_units_in_tick = m_reader.getBits(32);
time_scale = m_reader.getBits(32);
general_nal_hrd_params_present_flag = m_reader.getBit();
general_vcl_hrd_params_present_flag = m_reader.getBit();
if (general_nal_hrd_params_present_flag || general_vcl_hrd_params_present_flag)
{
m_reader.skipBit(); // general_same_pic_timing_in_all_ols_flag
general_du_hrd_params_present_flag = m_reader.getBit();
if (general_du_hrd_params_present_flag)
int tick_divisor_minus2 = m_reader.getBits(8);
m_reader.skipBits(4); // bit_rate_scale
m_reader.skipBits(4); // cpb_size_scale
if (general_du_hrd_params_present_flag)
m_reader.skipBits(4); // cpb_size_du_scale
hrd_cpb_cnt_minus1 = extractUEGolombCode();
if (hrd_cpb_cnt_minus1 > 31)
return 1;
}
return 0;
}
bool VvcHrdUnit::ols_timing_hrd_parameters(int firstSubLayer, int MaxSubLayersVal)
{
for (int i = firstSubLayer; i <= MaxSubLayersVal; i++)
{
bool fixed_pic_rate_within_cvs_flag =
m_reader.getBit() /* fixed_pic_rate_general_flag) */ ? 1 : m_reader.getBit();
if (fixed_pic_rate_within_cvs_flag)
{
if (extractUEGolombCode() > 2047) // elemental_duration_in_tc_minus1
return 1;
}
else if ((general_nal_hrd_params_present_flag || general_vcl_hrd_params_present_flag) &&
hrd_cpb_cnt_minus1 == 0)
m_reader.skipBit(); // low_delay_hrd_flag
if (general_nal_hrd_params_present_flag)
sublayer_hrd_parameters(i);
if (general_vcl_hrd_params_present_flag)
sublayer_hrd_parameters(i);
}
return 0;
}
bool VvcHrdUnit::sublayer_hrd_parameters(int subLayerId)
{
for (int j = 0; j <= hrd_cpb_cnt_minus1; j++)
{
unsigned bit_rate_value_minus1 = extractUEGolombCode();
if (bit_rate_value_minus1 == 0xffffffff)
return 1;
unsigned cpb_size_value_minus1 = extractUEGolombCode();
if (cpb_size_value_minus1 == 0xffffffff)
return 1;
if (general_du_hrd_params_present_flag)
{
unsigned cpb_size_du_value_minus1 = extractUEGolombCode();
if (cpb_size_du_value_minus1 == 0xffffffff)
return 1;
unsigned bit_rate_du_value_minus1 = extractUEGolombCode();
if (bit_rate_du_value_minus1 == 0xffffffff)
return 1;
}
m_reader.skipBit(); // cbr_flag
}
return 0;
}
// ----------------------- VvcSliceHeader() -------------------------------------
VvcSliceHeader::VvcSliceHeader() : VvcUnit(), ph_pps_id(-1), pic_order_cnt_lsb(0) {}
int VvcSliceHeader::deserialize(const VvcSpsUnit* sps, const VvcPpsUnit* pps)
{
int rez = VvcUnit::deserialize();
if (rez)
return rez;
try
{
if (m_reader.getBit()) // sh_picture_header_in_slice_header_flag
{
bool ph_gdr_or_irap_pic_flag = m_reader.getBit();
m_reader.skipBit(); // ph_non_ref_pic_flag
if (ph_gdr_or_irap_pic_flag)
m_reader.skipBit(); // ph_gdr_pic_flag
if (m_reader.getBit()) // ph_inter_slice_allowed_flag
m_reader.skipBit(); // ph_intra_slice_allowed_flag
unsigned ph_pps_id = extractUEGolombCode();
if (ph_pps_id > 63)
return 1;
pic_order_cnt_lsb = m_reader.getBits(sps->log2_max_pic_order_cnt_lsb);
;
}
return 0;
}
catch (VodCoreException& e)
{
return NOT_ENOUGH_BUFFER;
}
}
bool VvcSliceHeader::isIDR() const { return nal_unit_type == V_IDR_W_RADL || nal_unit_type == V_IDR_N_LP; }
vector<vector<uint8_t>> vvc_extract_priv_data(const uint8_t* buff, int size, int* nal_size)
{
*nal_size = 4;
vector<vector<uint8_t>> spsPps;
if (size < 23)
return spsPps;
*nal_size = (buff[21] & 3) + 1;
int num_arrays = buff[22];
const uint8_t* src = buff + 23;
const uint8_t* end = buff + size;
for (int i = 0; i < num_arrays; ++i)
{
if (src + 3 > end)
THROW(ERR_MOV_PARSE, "Invalid VVC extra data format");
int type = *src++;
int cnt = AV_RB16(src);
src += 2;
for (int j = 0; j < cnt; ++j)
{
if (src + 2 > end)
THROW(ERR_MOV_PARSE, "Invalid VVC extra data format");
int nalSize = (src[0] << 8) + src[1];
src += 2;
if (src + nalSize > end)
THROW(ERR_MOV_PARSE, "Invalid VVC extra data format");
if (nalSize > 0)
{
spsPps.push_back(vector<uint8_t>());
for (int i = 0; i < nalSize; ++i, ++src) spsPps.rbegin()->push_back(*src);
}
}
}
return spsPps;
}
| 22,567 |
887 | <gh_stars>100-1000
# coding=utf-8
import re
import pytest
xfail = pytest.mark.xfail
def test_unicode_roundtrip(protocol_real):
shell_id = protocol_real.open_shell(codepage=65001)
command_id = protocol_real.run_command(
shell_id, u'PowerShell', arguments=['-Command', 'Write-Host', u'こんにちは'])
try:
std_out, std_err, status_code = protocol_real.get_command_output(
shell_id, command_id)
assert status_code == 0
assert len(std_err) == 0
# std_out will be returned as UTF-8, but PEP8 won't let us store a
# UTF-8 string literal, so we'll convert it on the fly
assert std_out == (u'こんにちは\n'.encode('utf-8'))
finally:
protocol_real.cleanup_command(shell_id, command_id)
protocol_real.close_shell(shell_id)
def test_open_shell_and_close_shell(protocol_real):
shell_id = protocol_real.open_shell()
assert re.match(r'^\w{8}-\w{4}-\w{4}-\w{4}-\w{12}$', shell_id)
protocol_real.close_shell(shell_id)
def test_run_command_with_arguments_and_cleanup_command(protocol_real):
shell_id = protocol_real.open_shell()
command_id = protocol_real.run_command(shell_id, 'ipconfig', ['/all'])
assert re.match(r'^\w{8}-\w{4}-\w{4}-\w{4}-\w{12}$', command_id)
protocol_real.cleanup_command(shell_id, command_id)
protocol_real.close_shell(shell_id)
def test_run_command_without_arguments_and_cleanup_command(protocol_real):
shell_id = protocol_real.open_shell()
command_id = protocol_real.run_command(shell_id, 'hostname')
assert re.match(r'^\w{8}-\w{4}-\w{4}-\w{4}-\w{12}$', command_id)
protocol_real.cleanup_command(shell_id, command_id)
protocol_real.close_shell(shell_id)
def test_run_command_with_env(protocol_real):
shell_id = protocol_real.open_shell(env_vars=dict(TESTENV1='hi mom', TESTENV2='another var'))
command_id = protocol_real.run_command(shell_id, 'echo', ['%TESTENV1%', '%TESTENV2%'])
std_out, std_err, status_code = protocol_real.get_command_output(shell_id, command_id)
assert re.search(b'hi mom another var', std_out)
protocol_real.cleanup_command(shell_id, command_id)
protocol_real.close_shell(shell_id)
def test_get_command_output(protocol_real):
shell_id = protocol_real.open_shell()
command_id = protocol_real.run_command(shell_id, 'ipconfig', ['/all'])
std_out, std_err, status_code = protocol_real.get_command_output(
shell_id, command_id)
assert status_code == 0
assert b'Windows IP Configuration' in std_out
assert len(std_err) == 0
protocol_real.cleanup_command(shell_id, command_id)
protocol_real.close_shell(shell_id)
def test_run_command_taking_more_than_operation_timeout_sec(protocol_real):
shell_id = protocol_real.open_shell()
command_id = protocol_real.run_command(
shell_id, 'PowerShell -Command Start-Sleep -s {0}'.format(protocol_real.operation_timeout_sec * 2))
assert re.match(r'^\w{8}-\w{4}-\w{4}-\w{4}-\w{12}$', command_id)
std_out, std_err, status_code = protocol_real.get_command_output(
shell_id, command_id)
assert status_code == 0
assert len(std_err) == 0
protocol_real.cleanup_command(shell_id, command_id)
protocol_real.close_shell(shell_id)
@xfail()
def test_set_timeout(protocol_real):
raise NotImplementedError()
@xfail()
def test_set_max_env_size(protocol_real):
raise NotImplementedError()
@xfail()
def test_set_locale(protocol_real):
raise NotImplementedError()
| 1,468 |
348 | <reponame>chamberone/Leaflet.PixiOverlay
{"nom":"Crannes-en-Champagne","circ":"4ème circonscription","dpt":"Sarthe","inscrits":270,"abs":150,"votants":120,"blancs":5,"nuls":3,"exp":112,"res":[{"nuance":"SOC","nom":"M. <NAME>","voix":61},{"nuance":"LR","nom":"<NAME>","voix":51}]} | 116 |
412 | /*******************************************************************\
Module: Builtin functions for string concatenations
Author: <NAME>, <NAME>
\*******************************************************************/
/// \file
/// Builtin functions for string concatenations
#ifndef CPROVER_SOLVERS_STRINGS_STRING_CONCATENATION_BUILTIN_FUNCTION_H
#define CPROVER_SOLVERS_STRINGS_STRING_CONCATENATION_BUILTIN_FUNCTION_H
#include "string_insertion_builtin_function.h"
class string_concatenation_builtin_functiont final
: public string_insertion_builtin_functiont
{
public:
/// Constructor from arguments of a function application.
/// The arguments in `fun_args` should be in order:
/// an integer `result.length`, a character pointer `&result[0]`,
/// a string `arg1` of type refined_string_typet,
/// a string `arg2` of type refined_string_typet,
/// optionally followed by an integer `start` and an integer `end`.
string_concatenation_builtin_functiont(
const exprt &return_code,
const std::vector<exprt> &fun_args,
array_poolt &array_pool);
std::vector<mp_integer> eval(
const std::vector<mp_integer> &input1_value,
const std::vector<mp_integer> &input2_value,
const std::vector<mp_integer> &args_value) const override;
std::string name() const override
{
return "concat";
}
string_constraintst
constraints(string_constraint_generatort &generator) const override;
exprt length_constraint() const override;
};
#endif // CPROVER_SOLVERS_STRINGS_STRING_CONCATENATION_BUILTIN_FUNCTION_H
| 502 |
1,025 | //==================================================================================
// Copyright (c) 2016 , Advanced Micro Devices, Inc. All rights reserved.
//
/// \author AMD Developer Tools Team
/// \file gdGlobalDebugSettingsPage.cpp
///
//==================================================================================
//------------------------------ gdGlobalDebugSettingsPage.cpp ------------------------------
#include <memory>
// Qt:
#include <QtWidgets>
// TinyXml:
#include <tinyxml.h>
// Infra:
#include <AMDTBaseTools/Include/gtAssert.h>
#include <AMDTAPIClasses/Include/apBasicParameters.h>
#include <AMDTApiFunctions/Include/gaGRApiFunctions.h>
#include <AMDTApplicationComponents/Include/acDefinitions.h>
#include <AMDTApplicationComponents/Include/acDisplay.h>
#include <AMDTApplicationComponents/Include/acMessageBox.h>
// AMDTApplicationFramework:
#include <AMDTApplicationFramework/Include/afApplicationCommands.h>
#include <AMDTApplicationFramework/Include/afGlobalVariablesManager.h>
#include <AMDTApplicationFramework/src/afUtils.h>
// Local:
#include <AMDTGpuDebuggingComponents/Include/gdGDebuggerGlobalVariablesManager.h>
#include <AMDTGpuDebuggingComponents/Include/gdGlobalDebugSettingsPage.h>
#include <AMDTGpuDebuggingComponents/Include/gdStringConstants.h>
// Constants for the page:
// Minimums and Maximums for the spin controls:
#define GD_OPTIONS_OPENGL_CALLS_MIN_AMOUNT 1
#define GD_OPTIONS_OPENGL_CALLS_MAX_AMOUNT 100000000
#define GD_OPTIONS_OPENGL_CALLS_INIT_AMOUNT AP_DEFAULT_OPENGL_CONTEXT_CALLS_LOG_MAX_SIZE
#define GD_OPTIONS_OPENGL_CALLS_AMOUNT_STEP 10000
#define GD_OPTIONS_OPENCL_CALLS_MIN_AMOUNT 1
#define GD_OPTIONS_OPENCL_CALLS_MAX_AMOUNT 100000
#define GD_OPTIONS_OPENCL_CALLS_INIT_AMOUNT AP_DEFAULT_OPENCL_CONTEXT_CALLS_LOG_MAX_SIZE
#define GD_OPTIONS_OPENCL_CALLS_AMOUNT_STEP 1000
#define GD_OPTIONS_OPENCL_QUEUE_COMMANDS_MIN_AMOUNT 1
#define GD_OPTIONS_OPENCL_QUEUE_COMMANDS_MAX_AMOUNT 100000
#define GD_OPTIONS_OPENCL_QUEUE_COMMANDS_INIT_AMOUNT AP_DEFAULT_OPENCL_QUEUE_COMMANDS_LOG_MAX_SIZE
#define GD_OPTIONS_OPENCL_QUEUE_COMMANDS_AMOUNT_STEP 50
#define GD_OPTIONS_DEBUG_OBJECTS_TREE_ITEMS_PER_TYPE_MIN 1
#define GD_OPTIONS_DEBUG_OBJECTS_TREE_ITEMS_PER_TYPE_MAX 0x7FFFFFFF
#define GD_OPTIONS_DEBUG_OBJECTS_TREE_ITEMS_PER_TYPE_INIT GD_DEFAULT_DEBUG_OBJECTS_TREE_MAX_ITEMS_PER_TYPE
#define GD_OPTIONS_DEBUG_OBJECTS_TREE_ITEMS_PER_TYPE_STEP 10
#define GD_OPTIONS_DEBUG_SPIN_BOXES_WIDTH_HINT (AC_DEFAULT_TEXT_AVERAGE_CHAR_WIDTH * 14)
// This must match the apFileType enum:
const char* gwTextureFormatStrings[4] =
{
GD_STR_globalSettingsTextureFileFormatBmp,
GD_STR_globalSettingsTextureFileFormatTiff,
GD_STR_globalSettingsTextureFileFormatJpg,
GD_STR_globalSettingsTextureFileFormatPng,
};
// ---------------------------------------------------------------------------
// Name: gdGlobalDebugSettingsPage::gdGlobalDebugSettingsPage
// Description: Constructor
// Author: <NAME>
// Date: 22/5/2012
// ---------------------------------------------------------------------------
gdGlobalDebugSettingsPage::gdGlobalDebugSettingsPage()
: m_pCollectAllocatedObjectsCreationCallStacks(NULL), m_pSaveTexturesToLogFileCheckBox(NULL), m_pLogFileTextureFileFormatComboBox(NULL),
m_pOpenGLLoggedCallsMaxSpinBox(NULL), m_pOpenCLLoggedCallsMaxSpinBox(NULL), m_pMaxTreeItemsPerTypeSpinBox(NULL), m_pFlushLogAfterEachFunctionCheckBox(NULL)
{
}
// ---------------------------------------------------------------------------
// Name: gdGlobalDebugSettingsPage::~gdGlobalDebugSettingsPage
// Description: Destructor
// Author: <NAME>
// Date: 22/5/2012
// ---------------------------------------------------------------------------
gdGlobalDebugSettingsPage::~gdGlobalDebugSettingsPage()
{
}
// ---------------------------------------------------------------------------
// Name: gdGlobalDebugSettingsPage::initialize
// Description: Initializes the page and all its sub items
// Return Val: void
// Author: <NAME>
// Date: 24/4/2012
// ---------------------------------------------------------------------------
void gdGlobalDebugSettingsPage::initialize()
{
// The main page layout:
QVBoxLayout* pPageLayout = new QVBoxLayout;
// Group 1: Call stack
QGroupBox* pCallStackGroupBox = new QGroupBox(GD_STR_globalSettingsCallStackGroupTitle);
QVBoxLayout* pCallStackGroupLayout = new QVBoxLayout;
m_pCollectAllocatedObjectsCreationCallStacks = new QCheckBox(GD_STR_globalSettingsCollectObjectCreationStacks);
pCallStackGroupLayout->addWidget(m_pCollectAllocatedObjectsCreationCallStacks);
pCallStackGroupBox->setLayout(pCallStackGroupLayout);
pPageLayout->addWidget(pCallStackGroupBox);
// Group 2: HTML Log file:
QGroupBox* pLogFileGroupBox = new QGroupBox(GD_STR_globalSettingsHTMLLogGroupTitle);
QVBoxLayout* pLogFileGroupLayout = new QVBoxLayout;
m_pSaveTexturesToLogFileCheckBox = new QCheckBox(GD_STR_globalSettingsSaveTexturesToLogFile);
QHBoxLayout* pLogFileTextureFormatLayout = new QHBoxLayout;
QLabel* pLogFileTextureFormatLabel = new QLabel(GD_STR_globalSettingsTextureFileFormat);
m_pLogFileTextureFileFormatComboBox = new QComboBox;
QStringList textureFileFormats;
for (int i = 0; i < 4; i++)
{
textureFileFormats.append(gwTextureFormatStrings[i]);
}
m_pLogFileTextureFileFormatComboBox->addItems(textureFileFormats);
QLabel* pLogFileTextureFileFormatNote1 = new QLabel(GD_STR_globalSettingsTextureFileFormatTiffNote);
QLabel* pLogFileTextureFileFormatNote2 = new QLabel(GD_STR_globalSettingsTextureFileFormatAlphaNote);
pLogFileTextureFormatLayout->addWidget(pLogFileTextureFormatLabel, 1);
pLogFileTextureFormatLayout->addWidget(m_pLogFileTextureFileFormatComboBox);
pLogFileGroupLayout->addWidget(m_pSaveTexturesToLogFileCheckBox);
pLogFileGroupLayout->addLayout(pLogFileTextureFormatLayout);
pLogFileGroupLayout->addWidget(pLogFileTextureFileFormatNote1);
pLogFileGroupLayout->addWidget(pLogFileTextureFileFormatNote2);
pLogFileGroupBox->setLayout(pLogFileGroupLayout);
pPageLayout->addWidget(pLogFileGroupBox);
// Group 3: Calls logging:
unsigned int spinBoxWidth = acScalePixelSizeToDisplayDPI(GD_OPTIONS_DEBUG_SPIN_BOXES_WIDTH_HINT);
QGroupBox* pCallsLoggingGroupBox = new QGroupBox(GD_STR_globalSettingsCallsLoggingGroupTitle);
QVBoxLayout* pCallsLoggingGroupLayout = new QVBoxLayout;
QLabel* pCallsLoggingTitle = new QLabel(GD_STR_globalSettingsAPILoggingTitle);
QHBoxLayout* pOpenGLCallsLoggingLayout = new QHBoxLayout;
QLabel* pOpenGLCallsLoggingLabel = new QLabel(GD_STR_globalSettingsOpenGLLogging);
m_pOpenGLLoggedCallsMaxSpinBox = new QSpinBox;
m_pOpenGLLoggedCallsMaxSpinBox->setRange(GD_OPTIONS_OPENGL_CALLS_MIN_AMOUNT, GD_OPTIONS_OPENGL_CALLS_MAX_AMOUNT);
connect(m_pOpenGLLoggedCallsMaxSpinBox, SIGNAL(valueChanged(int)), this, SLOT(handleValueChanged(int)));
m_pOpenGLLoggedCallsMaxSpinBox->setSingleStep(GD_OPTIONS_OPENGL_CALLS_AMOUNT_STEP);
m_pOpenGLLoggedCallsMaxSpinBox->setMinimumWidth(spinBoxWidth);
m_pOpenGLLoggedCallsMaxSpinBox->setMaximumWidth(spinBoxWidth);
m_pOpenGLLoggedCallsMaxSpinBox->setAlignment(Qt::AlignRight);
QHBoxLayout* pOpenCLCallsLoggingLayout = new QHBoxLayout;
QLabel* pOpenCLCallsLoggingLabel = new QLabel(GD_STR_globalSettingsOpenCLLogging);
m_pOpenCLLoggedCallsMaxSpinBox = new QSpinBox;
m_pOpenCLLoggedCallsMaxSpinBox->setRange(GD_OPTIONS_OPENCL_CALLS_MIN_AMOUNT, GD_OPTIONS_OPENCL_CALLS_MAX_AMOUNT);
connect(m_pOpenCLLoggedCallsMaxSpinBox, SIGNAL(valueChanged(int)), this, SLOT(handleValueChanged(int)));
m_pOpenCLLoggedCallsMaxSpinBox->setSingleStep(GD_OPTIONS_OPENCL_CALLS_AMOUNT_STEP);
m_pOpenCLLoggedCallsMaxSpinBox->setMinimumWidth(spinBoxWidth);
m_pOpenCLLoggedCallsMaxSpinBox->setMaximumWidth(spinBoxWidth);
m_pOpenCLLoggedCallsMaxSpinBox->setAlignment(Qt::AlignRight);
QLabel* pCallsLoggingExceedWarning = new QLabel(GD_STR_globalSettingsOpenCLLoggingWillBeClearedWarning);
QLabel* pCallsLoggingBeginEndBlockWarning = new QLabel(GD_STR_globalSettingsOpenGLBeginEndBlockWarning);
pOpenGLCallsLoggingLayout->addWidget(pOpenGLCallsLoggingLabel, 1);
pOpenGLCallsLoggingLayout->addWidget(m_pOpenGLLoggedCallsMaxSpinBox);
pOpenCLCallsLoggingLayout->addWidget(pOpenCLCallsLoggingLabel, 1);
pOpenCLCallsLoggingLayout->addWidget(m_pOpenCLLoggedCallsMaxSpinBox);
pCallsLoggingGroupLayout->addWidget(pCallsLoggingTitle);
pCallsLoggingGroupLayout->addLayout(pOpenGLCallsLoggingLayout);
pCallsLoggingGroupLayout->addLayout(pOpenCLCallsLoggingLayout);
pCallsLoggingGroupLayout->addWidget(pCallsLoggingExceedWarning);
pCallsLoggingGroupLayout->addWidget(pCallsLoggingBeginEndBlockWarning);
pCallsLoggingGroupBox->setLayout(pCallsLoggingGroupLayout);
pPageLayout->addWidget(pCallsLoggingGroupBox);
// Group 4: Advanced:
QGroupBox* pAdvancedGroupBox = new QGroupBox(AF_STR_globalSettingsAdvancedGroupTitle);
QVBoxLayout* pAdvancedGroupLayout = new QVBoxLayout;
QHBoxLayout* pMaxTreeItemsLayout = new QHBoxLayout;
QLabel* pMaxTreeItemsLabel = new QLabel(GD_STR_globalSettingsMaxTreeItems);
m_pMaxTreeItemsPerTypeSpinBox = new QSpinBox;
m_pMaxTreeItemsPerTypeSpinBox->setRange(GD_OPTIONS_DEBUG_OBJECTS_TREE_ITEMS_PER_TYPE_MIN, GD_OPTIONS_DEBUG_OBJECTS_TREE_ITEMS_PER_TYPE_MAX);
connect(m_pMaxTreeItemsPerTypeSpinBox, SIGNAL(valueChanged(int)), this, SLOT(handleValueChanged(int)));
m_pMaxTreeItemsPerTypeSpinBox->setSingleStep(GD_OPTIONS_DEBUG_OBJECTS_TREE_ITEMS_PER_TYPE_STEP);
m_pMaxTreeItemsPerTypeSpinBox->setMinimumWidth(spinBoxWidth);
m_pMaxTreeItemsPerTypeSpinBox->setMaximumWidth(spinBoxWidth);
m_pMaxTreeItemsPerTypeSpinBox->setAlignment(Qt::AlignRight);
m_pFlushLogAfterEachFunctionCheckBox = new QCheckBox(GD_STR_globalSettingsFlushLogFile);
pMaxTreeItemsLayout->addWidget(pMaxTreeItemsLabel, 1);
pMaxTreeItemsLayout->addWidget(m_pMaxTreeItemsPerTypeSpinBox);
pAdvancedGroupLayout->addLayout(pMaxTreeItemsLayout);
pAdvancedGroupLayout->addWidget(m_pFlushLogAfterEachFunctionCheckBox);
pAdvancedGroupBox->setLayout(pAdvancedGroupLayout);
pPageLayout->addWidget(pAdvancedGroupBox);
// Set the layout:
pPageLayout->addStretch(1);
setLayout(pPageLayout);
}
// ---------------------------------------------------------------------------
// Name: gdGlobalDebugSettingsPage::pageTitle
// Description: Returns the title for the page's tab in the global settings dialog
// Author: <NAME>
// Date: 24/4/2012
// ---------------------------------------------------------------------------
gtString gdGlobalDebugSettingsPage::pageTitle()
{
return GD_STR_globalSettingsDebugPageTitle;
}
// ---------------------------------------------------------------------------
// Name: gdGlobalDebugSettingsPage::xmlSectionTitle
// Description: Returns the section title for this page in the global settings file
// Author: <NAME>
// Date: 24/4/2012
// ---------------------------------------------------------------------------
gtString gdGlobalDebugSettingsPage::xmlSectionTitle()
{
return GD_STR_globalSettingsDebugXMLSectionPageTitle;
}
// ---------------------------------------------------------------------------
// Name: gdGlobalDebugSettingsPage::getXMLSettingsString
// Description: Gets the XML representing the Debug settings
// Return Val: bool - Success / failure.
// Author: <NAME>
// Date: 22/5/2012
// ---------------------------------------------------------------------------
bool gdGlobalDebugSettingsPage::getXMLSettingsString(gtString& projectAsXMLString)
{
bool retVal = false;
GT_IF_WITH_ASSERT((NULL != m_pCollectAllocatedObjectsCreationCallStacks) &&
(NULL != m_pSaveTexturesToLogFileCheckBox) &&
(NULL != m_pLogFileTextureFileFormatComboBox) &&
(NULL != m_pOpenGLLoggedCallsMaxSpinBox) &&
(NULL != m_pOpenCLLoggedCallsMaxSpinBox) &&
(NULL != m_pMaxTreeItemsPerTypeSpinBox) &&
(NULL != m_pFlushLogAfterEachFunctionCheckBox))
{
retVal = true;
bool collectObjectCreationStacks = m_pCollectAllocatedObjectsCreationCallStacks->isChecked();
bool saveTexturesToLogFile = m_pSaveTexturesToLogFileCheckBox->isChecked();
int textureFormatIndex = m_pLogFileTextureFileFormatComboBox->currentIndex();
int maxLoggedGLCalls = m_pOpenGLLoggedCallsMaxSpinBox->value();
int maxLoggedCLCalls = m_pOpenCLLoggedCallsMaxSpinBox->value();
int maxTreeItems = m_pMaxTreeItemsPerTypeSpinBox->value();
bool flushLogFile = m_pFlushLogAfterEachFunctionCheckBox->isChecked();
projectAsXMLString.appendFormattedString(L"<%ls>", xmlSectionTitle().asCharArray());
afUtils::addFieldToXML(projectAsXMLString, GD_STR_ToolsOptionsCollectAllocatedObjectsCreationCallsStacksNode, collectObjectCreationStacks);
afUtils::addFieldToXML(projectAsXMLString, GD_STR_ToolsOptionsEnableTexturesLoggingNode, saveTexturesToLogFile);
afUtils::addFieldToXML(projectAsXMLString, GD_STR_ToolsOptionsTexturesFileFormatNode, textureFormatIndex);
afUtils::addFieldToXML(projectAsXMLString, GD_STR_ToolsOptionsMaxOpenGLCallsPerContextNode, maxLoggedGLCalls);
afUtils::addFieldToXML(projectAsXMLString, GD_STR_ToolsOptionsMaxOpenCLCallsPerContextNode, maxLoggedCLCalls);
afUtils::addFieldToXML(projectAsXMLString, GD_STR_ToolsOptionsMaxDebugTreeItemsPerTypeNode, maxTreeItems);
afUtils::addFieldToXML(projectAsXMLString, GD_STR_ToolsOptionsFlushLogFileAfterEveryFunctionNode, flushLogFile);
projectAsXMLString.appendFormattedString(L"</%ls>", xmlSectionTitle().asCharArray());
}
return retVal;
}
// ---------------------------------------------------------------------------
// Name: gdGlobalDebugSettingsPage::setSettingsFromXMLString
// Description: Reads the settings from an XML string
// Return Val: bool - Success / failure.
// Author: <NAME>
// Date: 23/5/2012
// ---------------------------------------------------------------------------
bool gdGlobalDebugSettingsPage::setSettingsFromXMLString(const gtString& projectAsXMLString)
{
bool retVal = false;
gtString additionalSourceDirPaths;
gtString sourceCodeRootPath;
bool collectObjectCreationStacks = true;
bool saveTexturesToLogFile = true;
int textureFormatIndex = (int)AP_PNG_FILE;
int maxLoggedGLCalls = GD_OPTIONS_OPENGL_CALLS_INIT_AMOUNT;
int maxLoggedCLCalls = GD_OPTIONS_OPENCL_CALLS_INIT_AMOUNT;
int maxTreeItems = GD_OPTIONS_DEBUG_OBJECTS_TREE_ITEMS_PER_TYPE_INIT;
bool flushLogFile = false;
std::unique_ptr<TiXmlNode> pDebugNode(new TiXmlElement(xmlSectionTitle().asASCIICharArray()));
// TinyXML does not support wide strings but it does supports UTF8 so we convert the strings to UTF8
std::string utf8XMLString;
projectAsXMLString.asUtf8(utf8XMLString);
pDebugNode->Parse(utf8XMLString.c_str(), 0, TIXML_ENCODING_UTF8);
gtString debugNodeTitle;
debugNodeTitle.fromASCIIString(pDebugNode->Value());
if (xmlSectionTitle() == debugNodeTitle)
{
retVal = true;
afUtils::getFieldFromXML(*pDebugNode, GD_STR_ToolsOptionsCollectAllocatedObjectsCreationCallsStacksNode, collectObjectCreationStacks);
afUtils::getFieldFromXML(*pDebugNode, GD_STR_ToolsOptionsEnableTexturesLoggingNode, saveTexturesToLogFile);
afUtils::getFieldFromXML(*pDebugNode, GD_STR_ToolsOptionsTexturesFileFormatNode, textureFormatIndex);
afUtils::getFieldFromXML(*pDebugNode, GD_STR_ToolsOptionsMaxOpenGLCallsPerContextNode, maxLoggedGLCalls);
afUtils::getFieldFromXML(*pDebugNode, GD_STR_ToolsOptionsMaxOpenCLCallsPerContextNode, maxLoggedCLCalls);
afUtils::getFieldFromXML(*pDebugNode, GD_STR_ToolsOptionsMaxDebugTreeItemsPerTypeNode, maxTreeItems);
afUtils::getFieldFromXML(*pDebugNode, GD_STR_ToolsOptionsFlushLogFileAfterEveryFunctionNode, flushLogFile);
}
m_pCollectAllocatedObjectsCreationCallStacks->setChecked(collectObjectCreationStacks);
m_pSaveTexturesToLogFileCheckBox->setChecked(saveTexturesToLogFile);
m_pLogFileTextureFileFormatComboBox->setCurrentIndex(textureFormatIndex);
m_pOpenGLLoggedCallsMaxSpinBox->setValue(maxLoggedGLCalls);
m_pOpenCLLoggedCallsMaxSpinBox->setValue(maxLoggedCLCalls);
m_pMaxTreeItemsPerTypeSpinBox->setValue(maxTreeItems);
m_pFlushLogAfterEachFunctionCheckBox->setChecked(flushLogFile);
return retVal;
}
// ---------------------------------------------------------------------------
// Name: gdGlobalDebugSettingsPage::loadCurrentSettings
// Description: Loads the current values into the settings page
// Author: <NAME>
// Date: 24/4/2012
// ---------------------------------------------------------------------------
void gdGlobalDebugSettingsPage::loadCurrentSettings()
{
GT_IF_WITH_ASSERT((NULL != m_pCollectAllocatedObjectsCreationCallStacks) &&
(NULL != m_pSaveTexturesToLogFileCheckBox) &&
(NULL != m_pLogFileTextureFileFormatComboBox) &&
(NULL != m_pOpenGLLoggedCallsMaxSpinBox) &&
(NULL != m_pOpenCLLoggedCallsMaxSpinBox) &&
(NULL != m_pMaxTreeItemsPerTypeSpinBox) &&
(NULL != m_pFlushLogAfterEachFunctionCheckBox))
{
gdGDebuggerGlobalVariablesManager& theGDGlobalVariablesManager = gdGDebuggerGlobalVariablesManager::instance();
bool isCollectingStacks = true;
bool rcStk = gaGetCollectAllocatedObjectCreationCallsStacks(isCollectingStacks);
GT_ASSERT(rcStk);
m_pCollectAllocatedObjectsCreationCallStacks->setChecked(isCollectingStacks);
bool areImagesLogged = true;
bool rcImg = gaIsImagesDataLogged(areImagesLogged);
GT_ASSERT(rcImg);
m_pSaveTexturesToLogFileCheckBox->setChecked(areImagesLogged);
m_pLogFileTextureFileFormatComboBox->setCurrentIndex((int)theGDGlobalVariablesManager.imagesFileFormat());
unsigned int loggedGLCalls = GD_OPTIONS_OPENGL_CALLS_INIT_AMOUNT;
unsigned int loggedCLCalls = GD_OPTIONS_OPENCL_CALLS_INIT_AMOUNT;
unsigned int loggedQueueCommands = GD_OPTIONS_OPENCL_QUEUE_COMMANDS_INIT_AMOUNT;
theGDGlobalVariablesManager.getLoggingLimits(loggedGLCalls, loggedCLCalls, loggedQueueCommands);
m_pOpenGLLoggedCallsMaxSpinBox->setValue((int)loggedGLCalls);
m_pOpenCLLoggedCallsMaxSpinBox->setValue((int)loggedCLCalls);
unsigned int shownTreeItems = GD_OPTIONS_DEBUG_OBJECTS_TREE_ITEMS_PER_TYPE_INIT;
shownTreeItems = theGDGlobalVariablesManager.maxTreeItemsPerType();
m_pMaxTreeItemsPerTypeSpinBox->setValue((int)shownTreeItems);
bool isLogFlushed = false;
bool rcLog = gaIsLogFileFlushedAfterEachFunctionCall(isLogFlushed);
GT_ASSERT(rcLog);
m_pFlushLogAfterEachFunctionCheckBox->setChecked(isLogFlushed);
}
}
// ---------------------------------------------------------------------------
// Name: gdGlobalDebugSettingsPage::restoreDefaultSettings
// Description: Restores the default values into all the views.
// Author: <NAME>
// Date: 24/4/2012
// ---------------------------------------------------------------------------
void gdGlobalDebugSettingsPage::restoreDefaultSettings()
{
GT_IF_WITH_ASSERT((NULL != m_pCollectAllocatedObjectsCreationCallStacks) &&
(NULL != m_pSaveTexturesToLogFileCheckBox) &&
(NULL != m_pLogFileTextureFileFormatComboBox) &&
(NULL != m_pOpenGLLoggedCallsMaxSpinBox) &&
(NULL != m_pOpenCLLoggedCallsMaxSpinBox) &&
(NULL != m_pMaxTreeItemsPerTypeSpinBox) &&
(NULL != m_pFlushLogAfterEachFunctionCheckBox))
{
m_pCollectAllocatedObjectsCreationCallStacks->setChecked(true);
m_pSaveTexturesToLogFileCheckBox->setChecked(true);
m_pLogFileTextureFileFormatComboBox->setCurrentIndex((int)AP_PNG_FILE);
m_pOpenGLLoggedCallsMaxSpinBox->setValue(GD_OPTIONS_OPENGL_CALLS_INIT_AMOUNT);
m_pOpenCLLoggedCallsMaxSpinBox->setValue(GD_OPTIONS_OPENCL_CALLS_INIT_AMOUNT);
m_pMaxTreeItemsPerTypeSpinBox->setValue(GD_OPTIONS_DEBUG_OBJECTS_TREE_ITEMS_PER_TYPE_INIT);
m_pFlushLogAfterEachFunctionCheckBox->setChecked(false);
}
}
// ---------------------------------------------------------------------------
// Name: gdGlobalDebugSettingsPage::saveCurrentSettings
// Description: Applies the current settings to the data structures
// Return Val: bool - Success / failure.
// Author: <NAME>
// Date: 24/4/2012
// ---------------------------------------------------------------------------
bool gdGlobalDebugSettingsPage::saveCurrentSettings()
{
bool retVal = false;
GT_IF_WITH_ASSERT((NULL != m_pCollectAllocatedObjectsCreationCallStacks) &&
(NULL != m_pSaveTexturesToLogFileCheckBox) &&
(NULL != m_pLogFileTextureFileFormatComboBox) &&
(NULL != m_pOpenGLLoggedCallsMaxSpinBox) &&
(NULL != m_pOpenCLLoggedCallsMaxSpinBox) &&
(NULL != m_pMaxTreeItemsPerTypeSpinBox) &&
(NULL != m_pFlushLogAfterEachFunctionCheckBox))
{
gdGDebuggerGlobalVariablesManager& theGDGlobalVariablesManager = gdGDebuggerGlobalVariablesManager::instance();
bool rcStk = gaCollectAllocatedObjectsCreationCallsStacks(m_pCollectAllocatedObjectsCreationCallStacks->isChecked());
GT_ASSERT(rcStk);
gaEnableImagesDataLogging(m_pSaveTexturesToLogFileCheckBox->isChecked());
theGDGlobalVariablesManager.setImagesFileFormat((apFileType)m_pLogFileTextureFileFormatComboBox->currentIndex());
theGDGlobalVariablesManager.setLoggingLimits(m_pOpenGLLoggedCallsMaxSpinBox->value(), m_pOpenCLLoggedCallsMaxSpinBox->value(), GD_OPTIONS_OPENCL_QUEUE_COMMANDS_INIT_AMOUNT);
theGDGlobalVariablesManager.setMaxTreeItemsPerType(m_pMaxTreeItemsPerTypeSpinBox->value());
gaFlushLogFileAfterEachFunctionCall(m_pFlushLogAfterEachFunctionCheckBox->isChecked());
retVal = true;
}
return retVal;
}
// ---------------------------------------------------------------------------
// Name: gdGlobalDebugSettingsPage::handleValueChanged
// Description: Handles a change to one of the spin boxes' values.
// Author: <NAME>
// Date: 9/8/2012
// ---------------------------------------------------------------------------
void gdGlobalDebugSettingsPage::handleValueChanged(int value)
{
int minValue = 0;
int maxValue = INT_MAX;
if (sender() == m_pOpenCLLoggedCallsMaxSpinBox)
{
minValue = GD_OPTIONS_OPENCL_CALLS_MIN_AMOUNT;
maxValue = GD_OPTIONS_OPENCL_CALLS_MAX_AMOUNT;
}
else if (sender() == m_pOpenGLLoggedCallsMaxSpinBox)
{
minValue = GD_OPTIONS_OPENGL_CALLS_MIN_AMOUNT;
maxValue = GD_OPTIONS_OPENGL_CALLS_MAX_AMOUNT;
}
else if (sender() == m_pMaxTreeItemsPerTypeSpinBox)
{
minValue = GD_OPTIONS_DEBUG_OBJECTS_TREE_ITEMS_PER_TYPE_MIN;
maxValue = GD_OPTIONS_DEBUG_OBJECTS_TREE_ITEMS_PER_TYPE_MAX;
}
else
{
GT_ASSERT_EX(false, L"minValue / maxValue are undefined.")
}
QSpinBox* pSpinBox = qobject_cast<QSpinBox*>(sender());
if (NULL != pSpinBox)
{
QString strMessage;
int newValue = value;
if (minValue > value)
{
strMessage = QString(AF_STR_globalSettingsMinBoundErrorMsg).arg(minValue);
newValue = minValue;
}
else if (maxValue < value)
{
strMessage = QString(AF_STR_globalSettingsMaxBoundErrorMsg).arg(minValue);
newValue = maxValue;
}
if (newValue != value)
{
acMessageBox::instance().warning(afGlobalVariablesManager::ProductNameA(), strMessage, QMessageBox::Ok);
pSpinBox->setValue(newValue);
}
}
}
| 9,053 |
3,428 | <gh_stars>1000+
{"id":"00143","group":"easy-ham-1","checksum":{"type":"MD5","value":"4cae4623140fc349a57dac7ffd863227"},"text":"From <EMAIL> Tue Oct 8 10:55:45 2002\nReturn-Path: <<EMAIL>>\nDelivered-To: [email protected]\nReceived: from localhost (jalapeno [127.0.0.1])\n\tby spamassassin.taint.org (Postfix) with ESMTP id B1EF716F17\n\tfor <zzzz@localhost>; Tue, 8 Oct 2002 10:55:43 +0100 (IST)\nReceived: from jalapeno [127.0.0.1]\n\tby localhost with IMAP (fetchmail-5.9.0)\n\tfor zzzz@localhost (single-drop); Tue, 08 Oct 2002 10:55:43 +0100 (IST)\nReceived: from dogma.slashnull.org (localhost [127.0.0.1]) by\n dogma.slashnull.org (8.11.6/8.11.6) with ESMTP id g98814K06118 for\n <<EMAIL>>; Tue, 8 Oct 2002 09:01:04 +0100\nMessage-Id: <<EMAIL>>\nTo: zzzz@<EMAIL>int.org\nFrom: guardian <<EMAIL>>\nSubject: Police pay damages to journalist\nDate: Tue, 08 Oct 2002 08:01:04 -0000\nContent-Type: text/plain; encoding=utf-8\n\nURL: http://www.newsisfree.com/click/-2,8655706,215/\nDate: 2002-10-08T03:31:00+01:00\n\nBBC reporter <NAME> wins high profile libel case against police.\n\n\n"} | 472 |
14,668 | // 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.
#ifndef FUCHSIA_ENGINE_BROWSER_WEB_ENGINE_MEDIA_RESOURCE_PROVIDER_IMPL_H_
#define FUCHSIA_ENGINE_BROWSER_WEB_ENGINE_MEDIA_RESOURCE_PROVIDER_IMPL_H_
#include <lib/fidl/cpp/interface_handle.h>
#include "content/public/browser/document_service.h"
#include "fuchsia/engine/mojom/web_engine_media_resource_provider.mojom.h"
namespace content {
class RenderFrameHost;
} // namespace content
class WebEngineMediaResourceProviderImpl final
: public content::DocumentService<mojom::WebEngineMediaResourceProvider> {
public:
~WebEngineMediaResourceProviderImpl() override;
WebEngineMediaResourceProviderImpl(
const WebEngineMediaResourceProviderImpl&) = delete;
WebEngineMediaResourceProviderImpl& operator=(
const WebEngineMediaResourceProviderImpl&) = delete;
WebEngineMediaResourceProviderImpl(
const WebEngineMediaResourceProviderImpl&&) = delete;
WebEngineMediaResourceProviderImpl& operator=(
const WebEngineMediaResourceProviderImpl&&) = delete;
static void Bind(
content::RenderFrameHost* frame_host,
mojo::PendingReceiver<mojom::WebEngineMediaResourceProvider> receiver);
private:
WebEngineMediaResourceProviderImpl(
content::RenderFrameHost* render_frame_host,
mojo::PendingReceiver<mojom::WebEngineMediaResourceProvider> receiver);
// mojom::WebEngineMediaResourceProvider:
void ShouldUseAudioConsumer(ShouldUseAudioConsumerCallback callback) override;
void CreateAudioConsumer(
fidl::InterfaceRequest<fuchsia::media::AudioConsumer> request) override;
void CreateAudioCapturer(
fidl::InterfaceRequest<fuchsia::media::AudioCapturer> request) override;
};
#endif // FUCHSIA_ENGINE_BROWSER_WEB_ENGINE_MEDIA_RESOURCE_PROVIDER_IMPL_H_
| 601 |
601 | <reponame>zaitanzaibao/austin
package com.java3y.austin.support.pipeline;
import com.java3y.austin.common.vo.BasicResultVO;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import lombok.experimental.Accessors;
/**
* 责任链上下文
*
* @author 3y
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
@Builder
@Accessors(chain = true)
public class ProcessContext<T extends ProcessModel> {
/**
* 标识责任链的code
*/
private String code;
/**
* 存储责任链上下文数据的模型
*/
private T processModel;
/**
* 责任链中断的标识
*/
private Boolean needBreak;
/**
* 流程处理的结果
*/
BasicResultVO response;
}
| 355 |
5,169 | <filename>Specs/SwiftBitmask/0.0.4/SwiftBitmask.podspec.json<gh_stars>1000+
{
"name": "SwiftBitmask",
"version": "0.0.4",
"license": {
"type": "WTFPL",
"file": "LICENSE.md"
},
"summary": "Generic Bitmask utility type, written in Swift.",
"authors": {
"<NAME>": "<EMAIL>"
},
"homepage": "https://github.com/brynbellomy/SwiftBitmask",
"platforms": {
"ios": "8.0",
"osx": "10.10"
},
"source_files": "Classes/*.swift",
"requires_arc": true,
"source": {
"git": "https://github.com/brynbellomy/SwiftBitmask.git",
"tag": "0.0.4"
}
}
| 264 |
1,292 | switchApp("System Preferences.app")
m = find("1257868050242.png").top().right().find("1257868062020.png")
if m: click(m)
| 45 |
463 | from typing import List, Union, Tuple, Optional
from labml.internal.util.colors import StyleCode
class Destination:
def log(self, parts: List[Union[str, Tuple[str, Optional[StyleCode]]]], *,
is_new_line: bool,
is_reset: bool):
raise NotImplementedError()
| 116 |
309 | /**
This file is part of Deformable Shape Tracking (DEST).
Copyright(C) 2015/2016 <NAME>
All rights reserved.
This software may be modified and distributed under the terms
of the BSD license.See the LICENSE file for details.
*/
#include <dest/dest.h>
#include <opencv2/opencv.hpp>
#include <tclap/CmdLine.h>
#include <dest/face/face_detector.h>
#include <dest/util/draw.h>
#include <dest/util/convert.h>
/**
Transfer expressions from one face to another.
*/
int main(int argc, char **argv)
{
struct {
std::string tracker;
std::string detector;
std::string device;
float imageScale;
} opts;
try {
TCLAP::CmdLine cmd("Track on video stream.", ' ', "0.9");
TCLAP::ValueArg<std::string> detectorArg("d", "detector", "Detector to provide initial bounds.", true, "classifier.xml", "XML file", cmd);
TCLAP::ValueArg<std::string> trackerArg("t", "tracker", "Tracker to align landmarks based initial bounds", true, "dest.bin", "Tracker file", cmd);
TCLAP::ValueArg<float> imageScaleArg("", "image-scale", "Scale factor to be applied to input image.", false, 1.f, "float", cmd);
TCLAP::UnlabeledValueArg<std::string> deviceArg("device", "Device to be opened. Either filename of video or camera device id.", true, "0", "string", cmd);
cmd.parse(argc, argv);
opts.tracker = trackerArg.getValue();
opts.detector = detectorArg.getValue();
opts.device = deviceArg.getValue();
opts.imageScale = imageScaleArg.getValue();
}
catch (TCLAP::ArgException &e) {
std::cerr << "Error: " << e.error() << " for arg " << e.argId() << std::endl;
return -1;
}
dest::core::Tracker t;
if (!t.load(opts.tracker)) {
std::cerr << "Failed to load tracker." << std::endl;
return -1;
}
dest::face::FaceDetector fd;
if (!fd.loadClassifiers(opts.detector)) {
std::cerr << "Failed to load classifiers." << std::endl;
return -1;
}
cv::VideoCapture cap;
if (opts.device.size() == 1 && isdigit(opts.device[0])) {
// Open capture device by index
cap.open(atoi(opts.device.c_str()));
cap.set(CV_CAP_PROP_SETTINGS, 1);
} else {
// Open video video
cap.open(opts.device.c_str());
}
if (!cap.isOpened()) {
std::cerr << "Failed to open capture device." << std::endl;
return -1;
}
bool done = false;
// Capture the target face, the one expressions get applied to.
cv::Mat tmp;
cv::Mat targetRef, targetRefGray, targetRefCopy;
dest::core::Shape targetShapeRef;
while (!done) {
cap >> tmp;
if (tmp.empty())
break;
cv::resize(tmp, targetRef, cv::Size(), opts.imageScale, opts.imageScale);
cv::cvtColor(targetRef, targetRefGray, CV_BGR2GRAY);
dest::core::MappedImage img = dest::util::toDestHeaderOnly(targetRefGray);
dest::core::Rect r;
if (!fd.detectSingleFace(img, r)) {
continue;
}
dest::core::ShapeTransform shapeToImage = dest::core::estimateSimilarityTransform(dest::core::unitRectangle(), r);
targetShapeRef = t.predict(img, shapeToImage);
targetRef.copyTo(targetRefCopy);
dest::util::drawShape(targetRefCopy, targetShapeRef, cv::Scalar(0,255,0));
cv::imshow("Input", targetRefCopy);
int key = cv::waitKey(1);
if (key != -1)
done = true;
}
const int landmarkIdsNormalize[] = {27, 31}; // eyes
const float unnormalizeTarget = (targetShapeRef.col(landmarkIdsNormalize[0]) - targetShapeRef.col(landmarkIdsNormalize[1])).norm();
std::vector<dest::core::Shape::Index> tris = dest::util::triangulateShape(targetShapeRef);
cv::Mat target = targetRef.clone();
cv::Mat source, sourceGray, sourceCopy;
dest::core::Shape sourceShape, sourceShapeRef;
done = false;
bool hasSourceRef = false;
float normalizeSource = 1.f;
while (!done) {
cap >> tmp;
if (tmp.empty())
break;
cv::resize(tmp, source, cv::Size(), opts.imageScale, opts.imageScale);
cv::cvtColor(source, sourceGray, CV_BGR2GRAY);
dest::core::MappedImage img = dest::util::toDestHeaderOnly(sourceGray);
dest::core::Rect r;
if (!fd.detectSingleFace(img, r)) {
continue;
}
dest::core::ShapeTransform shapeToImage = dest::core::estimateSimilarityTransform(dest::core::unitRectangle(), r);
sourceShape = t.predict(img, shapeToImage);
if (hasSourceRef) {
dest::core::Shape r = targetShapeRef + (sourceShape - sourceShapeRef) * normalizeSource * unnormalizeTarget;
target.setTo(0);
dest::util::pawShapeTexture(targetRef, target, targetShapeRef, r, tris);
cv::imshow("Target", target);
}
source.copyTo(sourceCopy);
dest::util::drawShape(sourceCopy, sourceShape, cv::Scalar(0,255,0));
cv::imshow("Input", sourceCopy);
int key = cv::waitKey(1);
if (key == 'x') {
done = true;
} else if (key != -1) {
sourceShapeRef = sourceShape;
normalizeSource = 1.f / (sourceShapeRef.col(landmarkIdsNormalize[0]) - sourceShapeRef.col(landmarkIdsNormalize[1])).norm();
hasSourceRef = true;
}
}
return 0;
}
| 2,504 |
5,411 | // 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.
#include "base/profiler/chrome_unwinder_android.h"
#include "base/android/library_loader/anchor_functions.h"
#include "base/debug/elf_reader.h"
#include "base/debug/proc_maps_linux.h"
#include "base/no_destructor.h"
#include "base/numerics/checked_math.h"
#include "base/profiler/native_unwinder.h"
#include "base/profiler/profile_builder.h"
#include "base/sampling_heap_profiler/module_cache.h"
#include "build/build_config.h"
extern "C" {
// The address of |__executable_start| gives the start address of the
// executable or shared library. This value is used to find the offset address
// of the instruction in binary from PC.
extern char __executable_start;
}
namespace base {
namespace {
const std::string& GetChromeModuleId() {
static const base::NoDestructor<std::string> build_id([] {
#if defined(OFFICIAL_BUILD)
base::debug::ElfBuildIdBuffer build_id;
size_t build_id_length =
base::debug::ReadElfBuildId(&__executable_start, true, build_id);
DCHECK_GT(build_id_length, 0u);
// Append 0 for the age value.
return std::string(build_id, build_id_length) + "0";
#else
// Local chromium builds don't have an ELF build-id note. A synthetic
// build id is provided. https://crbug.com/870919
return std::string("CCCCCCCCDB511330464892F0B600B4D60");
#endif
}());
return *build_id;
}
StringPiece GetChromeLibraryName() {
static const StringPiece library_name([] {
Optional<StringPiece> library_name =
base::debug::ReadElfLibraryName(&__executable_start);
DCHECK(library_name);
return *library_name;
}());
return library_name;
}
class ChromeModule : public ModuleCache::Module {
public:
ChromeModule() : build_id_(GetChromeModuleId()) {}
~ChromeModule() override = default;
uintptr_t GetBaseAddress() const override {
return reinterpret_cast<uintptr_t>(&__executable_start);
}
std::string GetId() const override { return build_id_; }
FilePath GetDebugBasename() const override {
return FilePath(GetChromeLibraryName());
}
// Gets the size of the module.
size_t GetSize() const override {
return base::android::kEndOfText - GetBaseAddress();
}
// True if this is a native module.
bool IsNative() const override { return false; }
std::string build_id_;
};
} // namespace
ChromeUnwinderAndroid::ChromeUnwinderAndroid(const ArmCFITable* cfi_table)
: cfi_table_(cfi_table) {
DCHECK(cfi_table_);
}
ChromeUnwinderAndroid::~ChromeUnwinderAndroid() = default;
void ChromeUnwinderAndroid::AddNonNativeModules(ModuleCache* module_cache) {
auto chrome_module = std::make_unique<ChromeModule>();
chrome_module_id_ = chrome_module->GetId();
module_cache->AddNonNativeModule(std::move(chrome_module));
}
bool ChromeUnwinderAndroid::CanUnwindFrom(const Frame* current_frame) const {
// AddNonNativeModules() should be called first.
DCHECK(!chrome_module_id_.empty());
return current_frame->module &&
current_frame->module->GetId() == chrome_module_id_;
}
UnwindResult ChromeUnwinderAndroid::TryUnwind(RegisterContext* thread_context,
uintptr_t stack_top,
ModuleCache* module_cache,
std::vector<Frame>* stack) const {
DCHECK(CanUnwindFrom(&stack->back()));
do {
const ModuleCache::Module* module = stack->back().module;
uintptr_t pc = RegisterContextInstructionPointer(thread_context);
DCHECK_GE(pc, module->GetBaseAddress());
uintptr_t func_addr = pc - module->GetBaseAddress();
auto entry = cfi_table_->FindEntryForAddress(func_addr);
if (!entry)
return UnwindResult::ABORTED;
if (!Step(thread_context, stack_top, *entry))
return UnwindResult::ABORTED;
stack->emplace_back(RegisterContextInstructionPointer(thread_context),
module_cache->GetModuleForAddress(
RegisterContextInstructionPointer(thread_context)));
} while (CanUnwindFrom(&stack->back()));
return UnwindResult::UNRECOGNIZED_FRAME;
}
void ChromeUnwinderAndroid::SetExpectedChromeModuleIdForTesting(
const std::string& chrome_module_id) {
chrome_module_id_ = chrome_module_id;
}
// static
bool ChromeUnwinderAndroid::Step(RegisterContext* thread_context,
uintptr_t stack_top,
const ArmCFITable::FrameEntry& entry) {
CHECK_NE(RegisterContextStackPointer(thread_context), 0U);
CHECK_LE(RegisterContextStackPointer(thread_context), stack_top);
if (entry.cfa_offset == 0) {
uintptr_t pc = RegisterContextInstructionPointer(thread_context);
uintptr_t return_address = static_cast<uintptr_t>(thread_context->arm_lr);
if (pc == return_address)
return false;
RegisterContextInstructionPointer(thread_context) = return_address;
} else {
// The rules for unwinding using the CFI information are:
// SP_prev = SP_cur + cfa_offset and
// PC_prev = * (SP_prev - ra_offset).
auto new_sp =
CheckedNumeric<uintptr_t>(RegisterContextStackPointer(thread_context)) +
CheckedNumeric<uint16_t>(entry.cfa_offset);
if (!new_sp.AssignIfValid(&RegisterContextStackPointer(thread_context)) ||
RegisterContextStackPointer(thread_context) >= stack_top) {
return false;
}
if (entry.ra_offset > entry.cfa_offset)
return false;
// Underflow is prevented because |ra_offset| <= |cfa_offset|.
uintptr_t ip_address = (new_sp - CheckedNumeric<uint16_t>(entry.ra_offset))
.ValueOrDie<uintptr_t>();
RegisterContextInstructionPointer(thread_context) =
*reinterpret_cast<uintptr_t*>(ip_address);
}
return true;
}
} // namespace base
| 2,244 |
1,903 | <reponame>FMichelD/nodeeditor<filename>include/nodes/internal/QUuidStdHash.hpp
#pragma once
#include <functional>
#include <QtCore/QUuid>
#include <QtCore/QVariant>
namespace std
{
template<>
struct hash<QUuid>
{
inline
std::size_t
operator()(QUuid const& uid) const
{
return qHash(uid);
}
};
}
| 131 |
522 | <filename>src/python/cupoch_pybind/visualization/utility.cpp
/**
* Copyright (c) 2020 Neka-Nat
* 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 "cupoch/geometry/pointcloud.h"
#include "cupoch/geometry/trianglemesh.h"
#include "cupoch/io/class_io/ijson_convertible_io.h"
#include "cupoch/utility/filesystem.h"
#include "cupoch/visualization/utility/draw_geometry.h"
#include "cupoch/visualization/visualizer/visualizer.h"
#include "cupoch_pybind/docstring.h"
#include "cupoch_pybind/visualization/visualization.h"
using namespace cupoch;
// Visualization util functions have similar arguments, sharing arg docstrings
static const std::unordered_map<std::string, std::string>
map_shared_argument_docstrings = {
{"callback_function",
"Call back function to be triggered at a key press event."},
{"filename", "The file path."},
{"geometry_list", "List of geometries to be visualized."},
{"height", "The height of the visualization window."},
{"key_to_callback", "Map of key to call back functions."},
{"left", "The left margin of the visualization window."},
{"optional_view_trajectory_json_file",
"Camera trajectory json file path for custom animation."},
{"top", "The top margin of the visualization window."},
{"width", "The width of the visualization window."},
{"window_name",
"The displayed title of the visualization window."}};
void pybind_visualization_utility_methods(py::module &m) {
m.def(
"draw_geometries",
[](const std::vector<std::shared_ptr<const geometry::Geometry>>
&geometry_ptrs,
const std::string &window_name, int width, int height, int left,
int top, bool point_show_normal, bool mesh_show_wireframe,
bool mesh_show_back_face) {
std::string current_dir =
utility::filesystem::GetWorkingDirectory();
visualization::DrawGeometries(
geometry_ptrs, window_name, width, height, left, top,
point_show_normal, mesh_show_wireframe,
mesh_show_back_face);
utility::filesystem::ChangeWorkingDirectory(current_dir);
},
"Function to draw a list of geometry::Geometry objects",
"geometry_list"_a, "window_name"_a = "cupoch", "width"_a = 1920,
"height"_a = 1080, "left"_a = 50, "top"_a = 50,
"point_show_normal"_a = false, "mesh_show_wireframe"_a = false,
"mesh_show_back_face"_a = false);
docstring::FunctionDocInject(m, "draw_geometries",
map_shared_argument_docstrings);
} | 1,536 |
12,008 | {
"method": "GET",
"httpVersion": "HTTP/1.1",
"url": "https://insomnia.rest/foo/bar",
"comment": "My Request"
}
| 51 |
521 | <reponame>zai1208/fbc
/* tiny LZW codec
* Based on code by <NAME>, Dr. Dobb's Journal October, 1989
*/
#include "fb_gfx.h"
#include "fb_gfx_lzw.h"
LZW_ENTRY fb_lzw_entry[TABLE_SIZE];
static unsigned char *decode_string(unsigned char *buffer, int code)
{
int index = 0;
while (code > 255) {
*buffer++ = fb_lzw_entry[code].value;
code = fb_lzw_entry[code].prefix;
if (index++ >= MAX_CODE - 1)
return NULL;
}
*buffer = code;
return buffer;
}
FBCALL int fb_hDecode
(
const unsigned char *in_buffer,
ssize_t in_size,
unsigned char *out_buffer,
ssize_t *out_size
)
{
unsigned short new_code, old_code, next_code = 256;
unsigned char *limit, decode_stack[MAX_CODE], *string, byte, bit = 0;
/* Protecting the access to fb_lzw_entry */
FB_LOCK( );
INPUT_CODE(old_code);
byte = old_code;
*out_buffer++ = old_code;
limit = out_buffer + *out_size;
*out_size = 1;
while (in_size > 0) {
INPUT_CODE(new_code);
if (new_code == MAX_CODE) {
FB_UNLOCK( );
return 0;
}
if (new_code >= next_code) {
*decode_stack = byte;
string = decode_string(decode_stack + 1, old_code);
} else {
string = decode_string(decode_stack, new_code);
}
if (!string) {
FB_UNLOCK( );
return -1;
}
byte = *string;
while (string >= decode_stack) {
if (out_buffer >= limit) {
FB_UNLOCK( );
return -1;
}
*out_buffer++ = *string--;
(*out_size)++;
}
if (next_code < MAX_CODE) {
fb_lzw_entry[next_code].prefix = old_code;
fb_lzw_entry[next_code].value = byte;
next_code++;
}
old_code = new_code;
}
FB_UNLOCK( );
return -1;
}
| 736 |
1,104 | <reponame>fly803/BaseProject
package com.cg.baseproject.view;
import android.animation.ValueAnimator;
import android.content.Context;
import android.graphics.Paint;
import android.graphics.Rect;
import android.util.AttributeSet;
import android.view.animation.LinearInterpolator;
import androidx.annotation.Nullable;
import androidx.appcompat.widget.AppCompatTextView;
/**
* <pre>
* 作者 : 肖坤
* 时间 : 2018/01/04
* 描述 : Created by allen on 2017/6/5
* 字符串逐字显示的view
* fadeInTextView
* .setTextString("自己的字符串")
* .startFadeInAnimation()
* .setTextAnimationListener(new FadeInTextView.TextAnimationListener()
* {
* @Override
* public void animationFinish() {
*
* }
* });
* 版本 : 1.0
* </pre>
*/
public class FadeInTextView extends AppCompatTextView
{
private Rect textRect = new Rect();
private StringBuffer stringBuffer = new StringBuffer();
private String[] arr;
private int textCount;
private int currentIndex = -1;
/**
* 每个字出现的时间
*/
private long duration = 700;
private ValueAnimator textAnimation;
private String contentStr;
private TextAnimationListener textAnimationListener;
public FadeInTextView setTextAnimationListener(TextAnimationListener textAnimationListener)
{
this.textAnimationListener = textAnimationListener;
return this;
}
public FadeInTextView(Context context)
{
this(context, null);
}
public FadeInTextView(Context context, @Nullable AttributeSet attrs)
{
super(context, attrs);
init();
}
private Paint mPaint;
private void init()
{
mPaint = new Paint(Paint.ANTI_ALIAS_FLAG);
mPaint.setStyle(Paint.Style.FILL);
}
@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec)
{
super.onMeasure(widthMeasureSpec, heightMeasureSpec);
float width = mPaint.measureText(contentStr + "...");
setWidth((int) width);
}
/**
* 文字逐个显示动画 通过插值的方式改变数据源
*/
private void initAnimation()
{
if (textAnimation != null)
{
return;
}
//从0到textCount - 1 是设置从第一个字到最后一个字的变化因子
textAnimation = ValueAnimator.ofInt(0, textCount);
//执行总时间就是每个字的时间乘以字数
textAnimation.setDuration((textCount - 1) * duration);
//匀速显示文字
textAnimation.setInterpolator(new LinearInterpolator());
textAnimation.setRepeatCount(ValueAnimator.INFINITE);
textAnimation.addUpdateListener(new ValueAnimator.AnimatorUpdateListener()
{
@Override
public void onAnimationUpdate(ValueAnimator valueAnimator)
{
int index = (int) valueAnimator.getAnimatedValue();
//过滤去重，保证每个字只重绘一次
if (currentIndex != index)
{
stringBuffer.append(arr[index]);
//重复动画使用append会造成内存泄漏
// append(arr[index]);
currentIndex = index;
//所有文字都显示完成之后进度回调结束动画
if (currentIndex == (textCount - 1))
{
stringBuffer.setLength(0);
if (textAnimationListener != null)
{
textAnimationListener.animationFinish();
}
}
setText(contentStr + stringBuffer.toString());
}
}
});
}
/**
* 设置逐渐显示的字符串
*
* @param textString 主体文字
* @param flickerStr 动画的字体,一般设置为...
* @return
*/
public FadeInTextView setTextString(String textString, String flickerStr)
{
if (textString != null && flickerStr != null)
{
mPaint.setTextSize(getTextSize());
contentStr = textString;
setText(contentStr);
//总字数
textCount = flickerStr.length();
//存放单个字的数组
arr = new String[textCount];
for (int i = 0; i < textCount; i++)
{
arr[i] = flickerStr.substring(i, i + 1);
}
initAnimation();
}
return this;
}
public FadeInTextView setDuration(long duration)
{
this.duration = duration;
return this;
}
private boolean isLoading = false;
/**
* 开启动画
*
* @return
*/
public FadeInTextView startFadeInAnimation()
{
if (textAnimation != null)
{
isLoading = true;
stringBuffer.setLength(0);
currentIndex = -1;
textAnimation.start();
}
return this;
}
public boolean isLoading()
{
return isLoading;
}
/**
* 停止动画
*
* @return
*/
public FadeInTextView stopFadeInAnimation()
{
if (textAnimation != null)
{
isLoading = false;
stringBuffer.setLength(0);
textAnimation.cancel();
}
return this;
}
/**
* 回调接口
*/
public interface TextAnimationListener
{
void animationFinish();
}
}
| 2,915 |
1,749 | //
// AEBlockChannel.h
// TheAmazingAudioEngine
//
// Created by <NAME> on 20/12/2012.
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented; you must not
// claim that you wrote the original software. If you use this software
// in a product, an acknowledgment in the product documentation would be
// appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such, and must not be
// misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source distribution.
//
#ifdef __cplusplus
extern "C" {
#endif
#import <Foundation/Foundation.h>
#import "TheAmazingAudioEngine.h"
typedef void (^AEBlockChannelBlock)(const AudioTimeStamp *time,
UInt32 frames,
AudioBufferList *audio);
/*!
* Block channel: Utility class to allow use of a block to generate audio
*/
@interface AEBlockChannel : NSObject <AEAudioPlayable>
/*!
* Create a new channel with a given block
*
* @param block Block to use for audio generation
*/
+ (AEBlockChannel*)channelWithBlock:(AEBlockChannelBlock)block;
/*!
* Track volume
*
* Range: 0.0 to 1.0
*/
@property (nonatomic, assign) float volume;
/*!
* Track pan
*
* Range: -1.0 (left) to 1.0 (right)
*/
@property (nonatomic, assign) float pan;
/*
* Whether channel is currently playing
*
* If this is NO, then the track will be silenced and no further render callbacks
* will be performed until set to YES again.
*/
@property (nonatomic, assign) BOOL channelIsPlaying;
/*
* Whether channel is muted
*
* If YES, track will be silenced, but render callbacks will continue to be performed.
*/
@property (nonatomic, assign) BOOL channelIsMuted;
/*
* The audio format for this channel
*/
@property (nonatomic, assign) AudioStreamBasicDescription audioDescription;
@end
#ifdef __cplusplus
}
#endif | 749 |
324 | <reponame>tormath1/jclouds
/*
* 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.jclouds.glesys.features;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertNull;
import static org.testng.Assert.assertTrue;
import java.util.Set;
import javax.ws.rs.core.MediaType;
import org.jclouds.glesys.domain.Domain;
import org.jclouds.glesys.domain.DomainRecord;
import org.jclouds.glesys.internal.BaseGleSYSApiExpectTest;
import org.jclouds.glesys.options.AddDomainOptions;
import org.jclouds.glesys.options.DomainOptions;
import org.jclouds.glesys.options.UpdateRecordOptions;
import org.jclouds.http.HttpRequest;
import org.jclouds.http.HttpResponse;
import org.jclouds.rest.ResourceNotFoundException;
import org.testng.annotations.Test;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
/**
* Tests annotation parsing of {@code DomainApi}
*/
@Test(groups = "unit", testName = "DomainApiExpectTest")
public class DomainApiExpectTest extends BaseGleSYSApiExpectTest {
public void testListDomainsWhenResponseIs2xx() throws Exception {
DomainApi api = requestSendsResponse(
HttpRequest.builder().method("POST").endpoint("https://api.glesys.com/domain/list/format/json")
.addHeader("Accept", "application/json")
.addHeader("Authorization", "Basic aWRlbnRpdHk6Y3JlZGVudGlhbA==").build(),
HttpResponse.builder().statusCode(200).payload(payloadFromResource("/domain_list.json")).build()).getDomainApi();
Domain expected =
Domain.builder().domainName("testglesys.jclouds.org").createTime(dateService.iso8601SecondsDateParse("2012-01-31T12:19:03+01:00")).build();
Domain actual = Iterables.getOnlyElement(api.list());
assertEquals(expected.getName(), actual.getName());
assertEquals(expected.getCreateTime(), actual.getCreateTime());
}
public void testListDomainsWhenResponseIs4xxReturnsEmpty() throws Exception {
DomainApi api = requestSendsResponse(
HttpRequest.builder().method("POST").endpoint("https://api.glesys.com/domain/list/format/json")
.addHeader("Accept", "application/json")
.addHeader("Authorization", "Basic aWRlbnRpdHk6Y3JlZGVudGlhbA==").build(),
HttpResponse.builder().statusCode(404).build()).getDomainApi();
assertTrue(api.list().isEmpty());
}
public void testListDomainRecordsWhenResponseIs2xx() throws Exception {
DomainApi api = requestSendsResponse(
HttpRequest.builder().method("POST").endpoint("https://api.glesys.com/domain/listrecords/format/json")
.addHeader("Accept", "application/json")
.addHeader("Authorization", "Basic aWRlbnRpdHk6Y3JlZGVudGlhbA==")
.addFormParam("domainname", "testglesys.jclouds.org").build(),
HttpResponse.builder().statusCode(200).payload(payloadFromResource("/domain_list_records.json")).build()).getDomainApi();
Set<DomainRecord> expected = ImmutableSet.of(
DomainRecord.builder().id("224538").domainname("testglesys.jclouds.org").host("@").type("NS").data("ns1.namesystem.se.").ttl(3600).build(),
DomainRecord.builder().id("224539").domainname("testglesys.jclouds.org").host("@").type("NS").data("ns2.namesystem.se.").ttl(3600).build(),
DomainRecord.builder().id("224540").domainname("testglesys.jclouds.org").host("@").type("NS").data("ns3.namesystem.se.").ttl(3600).build(),
DomainRecord.builder().id("224541").domainname("testglesys.jclouds.org").host("@").type("A").data("127.0.0.1").ttl(3600).build(),
DomainRecord.builder().id("224542").domainname("testglesys.jclouds.org").host("www").type("A").data("127.0.0.1").ttl(3600).build(),
DomainRecord.builder().id("224543").domainname("testglesys.jclouds.org").host("mail").type("A").data("192.168.127.12").ttl(3600).build(),
DomainRecord.builder().id("224544").domainname("testglesys.jclouds.org").host("@").type("MX").data("10 mx01.glesys.se.").ttl(3600).build(),
DomainRecord.builder().id("224545").domainname("testglesys.jclouds.org").host("@").type("MX").data("20 mx02.glesys.se.").ttl(3600).build(),
DomainRecord.builder().id("224546").domainname("testglesys.jclouds.org").host("@").type("TXT").data("v=spf1 include:spf.glesys.se -all").ttl(3600).build()
);
Set<DomainRecord> actual = api.listRecords("testglesys.jclouds.org");
assertEquals(actual, expected);
for (DomainRecord result : actual) {
for (DomainRecord expect : expected) {
if (result.equals(expect)) {
assertEquals(result.toString(), expect.toString(), "Deep comparison using toString() failed!");
}
}
}
}
public void testListDomainRecordsWhenResponseIs4xxReturnsEmpty() throws Exception {
DomainApi api = requestSendsResponse(
HttpRequest.builder().method("POST").endpoint("https://api.glesys.com/domain/list/format/json")
.addHeader("Accept", "application/json")
.addHeader("Authorization", "Basic aWRlbnRpdHk6Y3JlZGVudGlhbA==").build(),
HttpResponse.builder().statusCode(404).build()).getDomainApi();
assertTrue(api.list().isEmpty());
}
public void testAddDomainRecordsWhenResponseIs2xx() throws Exception {
DomainApi api = requestSendsResponse(
HttpRequest.builder().method("POST").endpoint("https://api.glesys.com/domain/addrecord/format/json")
.addHeader("Accept", "application/json")
.addHeader("Authorization", "Basic aWRlbnRpdHk6Y3JlZGVudGlhbA==")
.addFormParam("domainname", "jclouds.org")
.addFormParam("host", "jclouds.org")
.addFormParam("type", "A")
.addFormParam("data", "").build(),
HttpResponse.builder().statusCode(200)
.payload(payloadFromResourceWithContentType("/domain_record.json", MediaType.APPLICATION_JSON)).build())
.getDomainApi();
assertEquals(api.createRecord("jclouds.org", "jclouds.org", "A", ""), recordInDomainRecord());
}
protected DomainRecord recordInDomainRecord() {
return DomainRecord.builder().id("256151").domainname("cl13016-domain.jclouds.org").host("test").type("A").data("127.0.0.1").ttl(3600).build();
}
@Test(expectedExceptions = ResourceNotFoundException.class)
public void testAddDomainRecordsWhenResponseIs4xx() throws Exception {
DomainApi api = requestSendsResponse(
HttpRequest.builder().method("POST").endpoint("https://api.glesys.com/domain/addrecord/format/json")
.addHeader("Accept", "application/json")
.addHeader("Authorization", "Basic aWRlbnRpdHk6Y3JlZGVudGlhbA==")
.addFormParam("domainname", "jclouds.org")
.addFormParam("host", "jclouds.org")
.addFormParam("type", "A")
.addFormParam("data", "").build(),
HttpResponse.builder().statusCode(404).build()).getDomainApi();
api.createRecord("jclouds.org", "jclouds.org", "A", "");
}
public void testUpdateDomainRecordsWhenResponseIs2xx() throws Exception {
DomainApi api = requestSendsResponse(
HttpRequest.builder().method("POST").endpoint("https://api.glesys.com/domain/updaterecord/format/json")
.addHeader("Accept", "application/json")
.addHeader("Authorization", "Basic aWRlbnRpdHk6Y3JlZGVudGlhbA==")
.addFormParam("recordid", "256151")
.addFormParam("host", "somehost")
.addFormParam("ttl", "1800").build(),
HttpResponse.builder().statusCode(200)
.payload(payloadFromResourceWithContentType("/domain_record.json", MediaType.APPLICATION_JSON)).build())
.getDomainApi();
assertEquals(api.updateRecord("256151", UpdateRecordOptions.Builder.host("somehost").ttl(1800)), recordInDomainRecord());
}
@Test(expectedExceptions = ResourceNotFoundException.class)
public void testUpdateDomainRecordsWhenResponseIs4xx() throws Exception {
DomainApi api = requestSendsResponse(
HttpRequest.builder().method("POST").endpoint("https://api.glesys.com/domain/updaterecord/format/json")
.addHeader("Accept", "application/json")
.addHeader("Authorization", "Basic aWRlbnRpdHk6Y3JlZGVudGlhbA==")
.addFormParam("recordid", "256151")
.addFormParam("host", "somehost")
.addFormParam("ttl", "1800").build(),
HttpResponse.builder().statusCode(404).build()).getDomainApi();
api.updateRecord("256151", UpdateRecordOptions.Builder.host("somehost").ttl(1800));
}
public void testDeleteDomainRecordsWhenResponseIs2xx() throws Exception {
DomainApi api = requestSendsResponse(
HttpRequest.builder().method("POST").endpoint("https://api.glesys.com/domain/deleterecord/format/json")
.addHeader("Authorization", "Basic aWRlbnRpdHk6Y3JlZGVudGlhbA==")
.addFormParam("recordid", "256151").build(),
HttpResponse.builder().statusCode(200)
.payload(payloadFromResourceWithContentType("/domain_record.json", MediaType.APPLICATION_JSON)).build())
.getDomainApi();
api.deleteRecord("256151");
}
@Test(expectedExceptions = ResourceNotFoundException.class)
public void testDeleteDomainRecordsWhenResponseIs4xx() throws Exception {
DomainApi api = requestSendsResponse(
HttpRequest.builder().method("POST").endpoint("https://api.glesys.com/domain/deleterecord/format/json")
.addHeader("Authorization", "Basic aWRlbnRpdHk6Y3JlZGVudGlhbA==")
.addFormParam("recordid", "256151").build(),
HttpResponse.builder().statusCode(404).build()).getDomainApi();
api.deleteRecord("256151");
}
public void testGetDomainWhenResponseIs2xx() throws Exception {
DomainApi api = requestSendsResponse(
HttpRequest.builder().method("POST").endpoint("https://api.glesys.com/domain/details/format/json")
.addHeader("Accept", "application/json")
.addHeader("Authorization", "Basic aWRlbnRpdHk6Y3JlZGVudGlhbA==")
.addFormParam("domainname", "cl66666_x").build(),
HttpResponse.builder().statusCode(200)
.payload(payloadFromResourceWithContentType("/domain_details.json", MediaType.APPLICATION_JSON)).build())
.getDomainApi();
assertEquals(api.get("cl66666_x"), domainInDomainDetails());
}
public void testGetDomainWhenResponseIs4xx() throws Exception {
DomainApi api = requestSendsResponse(
HttpRequest.builder().method("POST").endpoint("https://api.glesys.com/domain/details/format/json")
.addHeader("Accept", "application/json")
.addHeader("Authorization", "Basic aWRlbnRpdHk6Y3JlZGVudGlhbA==")
.addFormParam("domainname", "cl66666_x").build(),
HttpResponse.builder().statusCode(404).build())
.getDomainApi();
assertNull(api.get("cl66666_x"));
}
protected Domain domainInDomainDetails() {
return Domain.builder().domainName("cl13016-domain.jclouds.org").createTime(dateService.iso8601SecondsDateParse("2012-06-24T11:52:49+02:00")).recordCount(9).build();
}
public void testAddDomainWhenResponseIs2xx() throws Exception {
DomainApi api = requestSendsResponse(
HttpRequest.builder().method("POST").endpoint("https://api.glesys.com/domain/add/format/json")
.addHeader("Accept", "application/json")
.addHeader("Authorization", "Basic aWRlbnRpdHk6Y3JlZGVudGlhbA==")
.addFormParam("domainname", "cl66666_x").build(),
HttpResponse.builder().statusCode(200)
.payload(payloadFromResourceWithContentType("/domain_details.json", MediaType.APPLICATION_JSON)).build())
.getDomainApi();
assertEquals(api.create("cl66666_x"), domainInDomainDetails());
}
public void testAddDomainWithOptsWhenResponseIs2xx() throws Exception {
DomainApi api = requestSendsResponse(
HttpRequest.builder().method("POST").endpoint("https://api.glesys.com/domain/add/format/json")
.addHeader("Accept", "application/json")
.addHeader("Authorization", "Basic <KEY>6Y3JlZGVudGlhbA==")
.addFormParam("domainname", "cl66666_x")
.addFormParam("primarynameserver", "ns1.somewhere.x")
.addFormParam("expire", "1")
.addFormParam("minimum", "1")
.addFormParam("refresh", "1")
.addFormParam("responsibleperson", "Tester.")
.addFormParam("retry", "1")
.addFormParam("ttl", "1").build(),
HttpResponse.builder().statusCode(200)
.payload(payloadFromResourceWithContentType("/domain_details.json", MediaType.APPLICATION_JSON)).build())
.getDomainApi();
AddDomainOptions options = (AddDomainOptions) AddDomainOptions.Builder.primaryNameServer("ns1.somewhere.x")
.expire(1).minimum(1).refresh(1).responsiblePerson("Tester").retry(1).ttl(1);
assertEquals(api.create("cl66666_x", options), domainInDomainDetails());
}
public void testUpdateDomainWhenResponseIs2xx() throws Exception {
DomainApi api = requestSendsResponse(
HttpRequest.builder().method("POST").endpoint("https://api.glesys.com/domain/edit/format/json")
.addHeader("Accept", "application/json")
.addHeader("Authorization", "Basic aWRlbnRpdHk6Y3JlZGVudGlhbA==")
.addFormParam("domainname", "x")
.addFormParam("expire", "1").build(),
HttpResponse.builder().statusCode(200)
.payload(payloadFromResourceWithContentType("/domain_details.json", MediaType.APPLICATION_JSON)).build())
.getDomainApi();
assertEquals(api.update("x", DomainOptions.Builder.expire(1)), domainInDomainDetails());
}
@Test(expectedExceptions = {ResourceNotFoundException.class})
public void testUpdateDomainWhenResponseIs4xxThrows() throws Exception {
DomainApi api = requestSendsResponse(
HttpRequest.builder().method("POST").endpoint("https://api.glesys.com/domain/edit/format/json")
.addHeader("Accept", "application/json")
.addHeader("Authorization", "Basic aWRlbnRpdHk6Y3JlZGVudGlhbA==")
.addFormParam("domainname", "x")
.addFormParam("expire", "1").build(),
HttpResponse.builder().statusCode(404).build()).getDomainApi();
api.update("x", DomainOptions.Builder.expire(1));
}
public void testDeleteDomainWhenResponseIs2xx() throws Exception {
DomainApi api = requestSendsResponse(
HttpRequest.builder().method("POST").endpoint("https://api.glesys.com/domain/delete/format/json")
.addHeader("Authorization", "Basic aWRlbnRpdHk6Y3JlZGVudGlhbA==")
.addFormParam("domainname", "x").build(),
HttpResponse.builder().statusCode(200).build()).getDomainApi();
api.delete("x");
}
@Test(expectedExceptions = {ResourceNotFoundException.class})
public void testDeleteDomainWhenResponseIs4xxThrows() throws Exception {
DomainApi api = requestSendsResponse(
HttpRequest.builder().method("POST").endpoint("https://api.glesys.com/domain/delete/format/json")
.addHeader("Authorization", "Basic aWRlbnRpdHk6Y3JlZGVudGlhbA==")
.addFormParam("domainname", "x").build(),
HttpResponse.builder().statusCode(404).build()).getDomainApi();
api.delete("x");
}
}
| 7,346 |
2,293 | # -*- coding: utf-8 -*-
from os.path import expanduser
from os.path import exists
import json
def get_storm_config():
config_file = expanduser("~/.stormssh/config")
if exists(config_file):
try:
config_data = json.loads(open(config_file).read())
return config_data
except Exception as error:
pass
return {}
| 158 |
407 | <reponame>iuskye/SREWorks
package com.alibaba.tesla.authproxy.model.vo;
import com.alibaba.tesla.authproxy.Constants;
import lombok.AllArgsConstructor;
import lombok.Builder;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.List;
/**
* 导入权限列表 VO
*
* @author <EMAIL>
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ImportPermissionsVO {
/**
* 角色列表
*/
private List<Role> roles;
/**
* OAM 中的角色前缀
*/
private String prefix = Constants.PERMISSION_PREFIX_API;
/**
* 是否忽略 permissions 导入
*/
private Boolean ignorePermissions = false;
/**
* 权限详情
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public static class Permission {
/**
* 权限路径
*/
private String path;
}
/**
* 角色详情
*/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public static class Role {
/**
* 角色名称
*/
private String roleName;
/**
* 描述
*/
private String description;
/**
* 角色拥有权限列表
*/
private List<Permission> permissions;
}
}
| 649 |
471 | <reponame>madanagopaltcomcast/pxCore
/////////////////////////////////////////////////////////////////////////////
// Name: wx/osx/carbon/private/mactext.h
// Purpose: private wxMacTextControl base class
// Author: <NAME>
// Modified by:
// Created: 03/02/99
// Copyright: (c) <NAME>
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MAC_PRIVATE_MACTEXT_H_
#define _WX_MAC_PRIVATE_MACTEXT_H_
#include "wx/osx/private.h"
// implementation exposed, so that search control can pull it
class wxMacUnicodeTextControl : public wxMacControl, public wxTextWidgetImpl
{
public :
wxMacUnicodeTextControl( wxTextCtrl *wxPeer ) ;
wxMacUnicodeTextControl( wxTextCtrl *wxPeer,
const wxString& str,
const wxPoint& pos,
const wxSize& size, long style ) ;
virtual ~wxMacUnicodeTextControl();
virtual bool CanFocus() const
{ return true; }
virtual void VisibilityChanged(bool shown);
virtual wxString GetStringValue() const ;
virtual void SetStringValue( const wxString &str) ;
virtual void Copy();
virtual void Cut();
virtual void Paste();
virtual bool CanPaste() const;
virtual void SetEditable(bool editable) ;
virtual void GetSelection( long* from, long* to) const ;
virtual void SetSelection( long from , long to ) ;
virtual void WriteText(const wxString& str) ;
protected :
void InstallEventHandlers();
// contains the tag for the content (is different for password and non-password controls)
OSType m_valueTag ;
WXEVENTHANDLERREF m_macTextCtrlEventHandler ;
public :
ControlEditTextSelectionRec m_selection ;
};
#endif // _WX_MAC_PRIVATE_MACTEXT_H_
| 690 |
543 | <filename>excel/annotations/src/main/java/com/riiablo/excel/annotation/Schema.java
package com.riiablo.excel.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
* Indicates that the specified type is a record schema.
*/
@Documented
@Retention(RetentionPolicy.SOURCE)
@Target(ElementType.TYPE)
public @interface Schema {
/**
* Offset of the first record.
*/
int offset() default 0;
/**
* Whether or not records are indexed in their natural ordering. Setting this
* will override any set {@link PrimaryKey primary key}.
*/
boolean indexed() default false;
}
| 232 |
1,104 | package com.cg.baseproject.encryption;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;
import java.security.NoSuchAlgorithmException;
/**
* @Description:主要功能:3DES对称加密（Triple DES、DESede，进行了三重DES加密的算法，对称加密算法）
* @Prject: CommonUtilLibrary
* @Package: com.jingewenku.abrahamcaijin.commonutil.encryption
* @author: AbrahamCaiJin
* @date: 2017年05月16日 15:58
* @Copyright: 个人版权所有
* @Company:
* @version: 1.0.0
*/
public class TripleDESUtils {
private TripleDESUtils() {
throw new UnsupportedOperationException("cannot be instantiated");
}
/*
* 生成密钥
*/
public static byte[] initKey() throws NoSuchAlgorithmException {
KeyGenerator keyGen = KeyGenerator.getInstance("DESede");
keyGen.init(168); //112 168
SecretKey secretKey = keyGen.generateKey();
return secretKey.getEncoded();
}
/*
* 3DES 加密
*/
public static byte[] encrypt(byte[] data, byte[] key) throws Exception {
SecretKey secretKey = new SecretKeySpec(key, "DESede");
Cipher cipher = Cipher.getInstance("DESede/ECB/PKCS5Padding");
cipher.init(Cipher.ENCRYPT_MODE, secretKey);
byte[] cipherBytes = cipher.doFinal(data);
return cipherBytes;
}
/*
* 3DES 解密
*/
public static byte[] decrypt(byte[] data, byte[] key) throws Exception {
SecretKey secretKey = new SecretKeySpec(key, "DESede");
Cipher cipher = Cipher.getInstance("DESede/ECB/PKCS5Padding");
cipher.init(Cipher.DECRYPT_MODE, secretKey);
byte[] plainBytes = cipher.doFinal(data);
return plainBytes;
}
}
| 748 |
763 | <reponame>zabrewer/batfish<gh_stars>100-1000
package org.batfish.common;
import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;
import com.google.common.base.MoreObjects;
import java.nio.file.Path;
import java.util.Objects;
import java.util.SortedSet;
public final class Container {
private static final String PROP_NAME = "name";
private static final String PROP_TESTRIGS = "testrigs";
private static final String PROP_ANALYSIS = "analysis";
private String _name;
private SortedSet<String> _testrigs;
private Path _analysis;
@JsonCreator
public static Container of(
@JsonProperty(PROP_NAME) String name,
@JsonProperty(PROP_TESTRIGS) SortedSet<String> testrigs) {
return new Container(name, testrigs);
}
private Container(String name, SortedSet<String> testrigs) {
_name = name;
_testrigs = testrigs;
}
@JsonProperty(PROP_NAME)
public String getName() {
return _name;
}
@JsonProperty(PROP_TESTRIGS)
public SortedSet<String> getTestrigs() {
return _testrigs;
}
@JsonProperty(PROP_ANALYSIS)
public Path getAnalysis() {
return _analysis;
}
@JsonProperty(PROP_NAME)
public void setName(String name) {
_name = name;
}
@JsonProperty(PROP_TESTRIGS)
public void setTestrigs(SortedSet<String> testrigs) {
_testrigs = testrigs;
}
@JsonProperty(PROP_ANALYSIS)
public void setAnalysis(Path analysis) {
_analysis = analysis;
}
@Override
public String toString() {
return MoreObjects.toStringHelper(Container.class)
.add(PROP_NAME, _name)
.add(PROP_TESTRIGS, _testrigs)
.toString();
}
@Override
public boolean equals(Object o) {
if (!(o instanceof Container)) {
return false;
}
Container other = (Container) o;
return Objects.equals(_name, other._name) && Objects.equals(_testrigs, other._testrigs);
}
@Override
public int hashCode() {
return Objects.hash(_name, _testrigs);
}
}
| 766 |
327 | <filename>cola-cloud-services/cola-cloud-dict/cola-cloud-dict-client/src/main/java/com/honvay/cola/cloud/dict/client/jackson/JacksonDictConfiguration.java
package com.honvay.cola.cloud.dict.client.jackson;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.module.SimpleModule;
import com.honvay.cola.cloud.dict.client.DictClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import java.util.List;
/**
* 数据字典转换配置
* @author LIQIU
* @date 2018-4-9
**/
@Configuration
public class JacksonDictConfiguration extends WebMvcConfigurerAdapter {
@Autowired(required = false)
private MappingJackson2HttpMessageConverter mappingJackson2HttpMessageConverter;
@Autowired
private DictClient dictClient;
@Override
public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
if(mappingJackson2HttpMessageConverter != null){
ObjectMapper objectMapper = mappingJackson2HttpMessageConverter.getObjectMapper();
SimpleModule module = new SimpleModule("JacksonDictModule");
JacksonDictJsonModifier jacksonDictJsonModifier = new JacksonDictJsonModifier();
jacksonDictJsonModifier.setDictClient(dictClient);
module.setSerializerModifier(jacksonDictJsonModifier);
objectMapper.registerModule(module);
}
}
}
| 610 |
3,058 | ///////////////////////////////////////////////////////////////////////////////
// Copyright (c) Electronic Arts Inc. All rights reserved.
///////////////////////////////////////////////////////////////////////////////
#ifndef EASTL_STRING_MAP_H
#define EASTL_STRING_MAP_H
#if defined(EA_PRAGMA_ONCE_SUPPORTED)
#pragma once
#endif
#include "map.h"
#include "string.h"
namespace eastl
{
template<typename T, typename Predicate = str_less<const char*>, typename Allocator = EASTLAllocatorType>
class string_map : public eastl::map<const char*, T, Predicate, Allocator>
{
public:
typedef eastl::map<const char*, T, Predicate, Allocator> base;
typedef string_map<T, Predicate, Allocator> this_type;
typedef typename base::base_type::allocator_type allocator_type;
typedef typename base::base_type::insert_return_type insert_return_type;
typedef typename base::base_type::iterator iterator;
typedef typename base::base_type::reverse_iterator reverse_iterator;
typedef typename base::base_type::const_iterator const_iterator;
typedef typename base::base_type::size_type size_type;
typedef typename base::base_type::key_type key_type;
typedef typename base::base_type::value_type value_type;
typedef typename base::mapped_type mapped_type;
string_map(const allocator_type& allocator = allocator_type()) : base(allocator) {}
string_map(const string_map& src, const allocator_type& allocator = allocator_type());
~string_map();
void clear();
this_type& operator=(const this_type& x);
insert_return_type insert(const char* key, const T& value);
insert_return_type insert(const char* key);
iterator erase(iterator position);
size_type erase(const char* key);
mapped_type& operator[](const char* key);
private:
char* strduplicate(const char* str);
// Not implemented right now
// insert_return_type insert(const value_type& value);
// iterator insert(iterator position, const value_type& value);
// reverse_iterator erase(reverse_iterator position);
// reverse_iterator erase(reverse_iterator first, reverse_iterator last);
// void erase(const key_type* first, const key_type* last);
};
template<typename T, typename Predicate, typename Allocator>
string_map<T, Predicate, Allocator>::string_map(const string_map& src, const allocator_type& allocator) : base(allocator)
{
for (const_iterator i=src.begin(), e=src.end(); i!=e; ++i)
base::base_type::insert(eastl::make_pair(strduplicate(i->first), i->second));
}
template<typename T, typename Predicate, typename Allocator>
string_map<T, Predicate, Allocator>::~string_map()
{
clear();
}
template<typename T, typename Predicate, typename Allocator>
void
string_map<T, Predicate, Allocator>::clear()
{
allocator_type& allocator = base::base_type::get_allocator();
for (const_iterator i=base::base_type::begin(), e=base::base_type::end(); i!=e; ++i)
allocator.deallocate((void*)i->first, 0);
base::base_type::clear();
}
template<typename T, typename Predicate, typename Allocator>
typename string_map<T, Predicate, Allocator>::this_type&
string_map<T, Predicate, Allocator>::operator=(const this_type& x)
{
allocator_type allocator = base::base_type::get_allocator();
this->~this_type();
new (this) this_type(x, allocator);
return *this;
}
template<typename T, typename Predicate, typename Allocator>
typename string_map<T, Predicate, Allocator>::insert_return_type
string_map<T, Predicate, Allocator>::insert(const char* key)
{
return insert(key, mapped_type());
}
template<typename T, typename Predicate, typename Allocator>
typename string_map<T, Predicate, Allocator>::insert_return_type
string_map<T, Predicate, Allocator>::insert(const char* key, const T& value)
{
EASTL_ASSERT(key);
iterator i = base::base_type::find(key);
if (i != base::base_type::end())
{
insert_return_type ret;
ret.first = i;
ret.second = false;
return ret;
}
return base::base_type::insert(eastl::make_pair(strduplicate(key), value));
}
template<typename T, typename Predicate, typename Allocator>
typename string_map<T, Predicate, Allocator>::iterator
string_map<T, Predicate, Allocator>::erase(iterator position)
{
const char* key = position->first;
iterator result = base::base_type::erase(position);
base::base_type::get_allocator().deallocate((void*)key, 0);
return result;
}
template<typename T, typename Predicate, typename Allocator>
typename string_map<T, Predicate, Allocator>::size_type
string_map<T, Predicate, Allocator>::erase(const char* key)
{
const iterator it(base::base_type::find(key));
if(it != base::base_type::end())
{
erase(it);
return 1;
}
return 0;
}
template<typename T, typename Predicate, typename Allocator>
typename string_map<T, Predicate, Allocator>::mapped_type&
string_map<T, Predicate, Allocator>::operator[](const char* key)
{
using base_value_type = typename base::base_type::value_type;
EASTL_ASSERT(key);
iterator i = base::base_type::find(key);
if (i != base::base_type::end())
return i->second;
return base::base_type::insert(base_value_type(pair_first_construct, strduplicate(key))).first->second;
}
template<typename T, typename Predicate, typename Allocator>
char*
string_map<T, Predicate, Allocator>::strduplicate(const char* str)
{
size_t len = strlen(str);
char* result = (char*)base::base_type::get_allocator().allocate(len + 1);
memcpy(result, str, len+1);
return result;
}
}
#endif
| 2,083 |
437 | from .common import DtoObject
class CurrentGameInfoDto(DtoObject):
pass
class FeaturedGamesDto(DtoObject):
pass
| 43 |
786 | package redis.embedded.ports;
import redis.embedded.PortProvider;
import redis.embedded.exceptions.RedisBuildingException;
import java.util.Collection;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
public class PredefinedPortProvider implements PortProvider {
private final List<Integer> ports = new LinkedList<Integer>();
private final Iterator<Integer> current;
public PredefinedPortProvider(Collection<Integer> ports) {
this.ports.addAll(ports);
this.current = this.ports.iterator();
}
@Override
public synchronized int next() {
if (!current.hasNext()) {
throw new RedisBuildingException("Run out of Redis ports!");
}
return current.next();
}
}
| 263 |
2,830 | // Copyright 2018 Twitter, Inc.
// Licensed under the Apache License, Version 2.0
// http://www.apache.org/licenses/LICENSE-2.0
package com.twitter.twittertext;
import junit.framework.TestCase;
public class TwitterTextParserTest extends TestCase {
public void testparseTweetWithoutUrlExtraction() {
assertEquals("Handle null input", 0,
TwitterTextParser.parseTweetWithoutUrlExtraction(null).weightedLength);
assertEquals("Handle empty input", 0,
TwitterTextParser.parseTweetWithoutUrlExtraction("").weightedLength);
assertEquals("Count Latin chars normally", 11,
TwitterTextParser.parseTweetWithoutUrlExtraction("Normal Text").weightedLength);
assertEquals("Count hashtags, @mentions and cashtags normally", 38,
TwitterTextParser.parseTweetWithoutUrlExtraction("Text with #hashtag, @mention and $CASH")
.weightedLength);
assertEquals("Count CJK chars with their appropriate weights", 94,
TwitterTextParser.parseTweetWithoutUrlExtraction("CJK Weighted chars: " +
"あいうえおかきくけこあいうえおかきくけこあいうえおかきくけこあいうえおかき").weightedLength);
assertEquals("URLs should be counted without transformation", 69,
TwitterTextParser.parseTweetWithoutUrlExtraction("Text with url: " +
"a.com http://abc.com https://longurllongurllongurl.com").weightedLength);
assertEquals("t.co URLs should be counted without transformation", 39,
TwitterTextParser.parseTweetWithoutUrlExtraction("Text with t.co url: https://t.co/foobar")
.weightedLength);
}
}
| 547 |
313 | /*******************************************************************************
Copyright (c) 2017, The OpenBLAS Project
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.
3. Neither the name of the OpenBLAS project 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 OPENBLAS PROJECT 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.
*******************************************************************************/
#include "common.h"
#include "macros_msa.h"
int CNAME(BLASLONG n, BLASLONG dummy0, BLASLONG dummy1, FLOAT da, FLOAT *x,
BLASLONG inc_x, FLOAT *y, BLASLONG inc_y, FLOAT *dummy,
BLASLONG dummy2)
{
BLASLONG i;
FLOAT *px;
FLOAT f0, f1, f2, f3, f4, f5, f6, f7, f8, f9, f10, f11, f12, f13, f14, f15;
v4f32 x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12, x13, x14, x15;
v4f32 da_vec;
px = x;
if (1 == inc_x)
{
if (0.0 == da)
{
v4f32 zero_v = __msa_cast_to_vector_float(0);
zero_v = (v4f32) __msa_insert_w((v4i32) zero_v, 0, 0.0);
zero_v = (v4f32) __msa_insert_w((v4i32) zero_v, 1, 0.0);
zero_v = (v4f32) __msa_insert_w((v4i32) zero_v, 2, 0.0);
zero_v = (v4f32) __msa_insert_w((v4i32) zero_v, 3, 0.0);
for (i = (n >> 6); i--;)
{
ST_SP8_INC(zero_v, zero_v, zero_v, zero_v, zero_v, zero_v,
zero_v, zero_v, x, 4);
ST_SP8_INC(zero_v, zero_v, zero_v, zero_v, zero_v, zero_v,
zero_v, zero_v, x, 4);
}
if (n & 63)
{
if (n & 32)
{
ST_SP8_INC(zero_v, zero_v, zero_v, zero_v, zero_v, zero_v,
zero_v, zero_v, x, 4);
}
if (n & 16)
{
ST_SP4_INC(zero_v, zero_v, zero_v, zero_v, x, 4);
}
if (n & 8)
{
ST_SP2_INC(zero_v, zero_v, x, 4);
}
if (n & 4)
{
*x = 0; x += 1;
*x = 0; x += 1;
*x = 0; x += 1;
*x = 0; x += 1;
}
if (n & 2)
{
*x = 0; x += 1;
*x = 0; x += 1;
}
if (n & 1)
{
*x = 0;
}
}
}
else
{
da_vec = COPY_FLOAT_TO_VECTOR(da);
if (n > 63)
{
FLOAT *x_pref;
BLASLONG pref_offset;
pref_offset = (BLASLONG)x & (L1_DATA_LINESIZE - 1);
if (pref_offset > 0)
{
pref_offset = L1_DATA_LINESIZE - pref_offset;
pref_offset = pref_offset / sizeof(FLOAT);
}
x_pref = x + pref_offset + 64 + 32;
LD_SP8_INC(px, 4, x0, x1, x2, x3, x4, x5, x6, x7);
for (i = 0; i < (n >> 6) - 1; i++)
{
PREF_OFFSET(x_pref, 0);
PREF_OFFSET(x_pref, 32);
PREF_OFFSET(x_pref, 64);
PREF_OFFSET(x_pref, 96);
PREF_OFFSET(x_pref, 128);
PREF_OFFSET(x_pref, 160);
PREF_OFFSET(x_pref, 192);
PREF_OFFSET(x_pref, 224);
x_pref += 64;
x8 = LD_SP(px); px += 4;
x0 *= da_vec;
x9 = LD_SP(px); px += 4;
x1 *= da_vec;
x10 = LD_SP(px); px += 4;
x2 *= da_vec;
x11 = LD_SP(px); px += 4;
x3 *= da_vec;
x12 = LD_SP(px); px += 4;
x4 *= da_vec;
x13 = LD_SP(px); px += 4;
x5 *= da_vec;
x14 = LD_SP(px); px += 4;
x6 *= da_vec;
x15 = LD_SP(px); px += 4;
x7 *= da_vec;
x8 *= da_vec;
ST_SP(x0, x); x += 4;
x9 *= da_vec;
ST_SP(x1, x); x += 4;
x10 *= da_vec;
ST_SP(x2, x); x += 4;
x11 *= da_vec;
ST_SP(x3, x); x += 4;
x12 *= da_vec;
ST_SP(x4, x); x += 4;
x13 *= da_vec;
ST_SP(x5, x); x += 4;
x14 *= da_vec;
ST_SP(x6, x); x += 4;
x15 *= da_vec;
ST_SP(x7, x); x += 4;
ST_SP(x8, x); x += 4;
x0 = LD_SP(px); px += 4;
ST_SP(x9, x); x += 4;
x1 = LD_SP(px); px += 4;
ST_SP(x10, x); x += 4;
x2 = LD_SP(px); px += 4;
ST_SP(x11, x); x += 4;
x3 = LD_SP(px); px += 4;
ST_SP(x12, x); x += 4;
x4 = LD_SP(px); px += 4;
ST_SP(x13, x); x += 4;
x5 = LD_SP(px); px += 4;
ST_SP(x14, x); x += 4;
x6 = LD_SP(px); px += 4;
ST_SP(x15, x); x += 4;
x7 = LD_SP(px); px += 4;
}
x8 = LD_SP(px); px += 4;
x0 *= da_vec;
x9 = LD_SP(px); px += 4;
x1 *= da_vec;
x10 = LD_SP(px); px += 4;
x2 *= da_vec;
x11 = LD_SP(px); px += 4;
x3 *= da_vec;
x12 = LD_SP(px); px += 4;
x4 *= da_vec;
x13 = LD_SP(px); px += 4;
x5 *= da_vec;
x14 = LD_SP(px); px += 4;
x6 *= da_vec;
x15 = LD_SP(px); px += 4;
x7 *= da_vec;
x8 *= da_vec;
ST_SP(x0, x); x += 4;
x9 *= da_vec;
ST_SP(x1, x); x += 4;
x10 *= da_vec;
ST_SP(x2, x); x += 4;
x11 *= da_vec;
ST_SP(x3, x); x += 4;
x12 *= da_vec;
ST_SP(x4, x); x += 4;
x13 *= da_vec;
ST_SP(x5, x); x += 4;
x15 *= da_vec;
ST_SP(x6, x); x += 4;
x14 *= da_vec;
ST_SP(x7, x); x += 4;
ST_SP8_INC(x8, x9, x10, x11, x12, x13, x14, x15, x, 4);
}
if (n & 63)
{
if (n & 32)
{
LD_SP8_INC(px, 4, x0, x1, x2, x3, x4, x5, x6, x7);
MUL4(x0, da_vec, x1, da_vec, x2, da_vec, x3, da_vec, x0, x1, x2, x3);
MUL4(x4, da_vec, x5, da_vec, x6, da_vec, x7, da_vec, x4, x5, x6, x7);
ST_SP8_INC(x0, x1, x2, x3, x4, x5, x6, x7, x, 4);
}
if (n & 16)
{
LD_SP4_INC(px, 4, x0, x1, x2, x3);
MUL4(x0, da_vec, x1, da_vec, x2, da_vec, x3, da_vec, x0, x1, x2, x3);
ST_SP4_INC(x0, x1, x2, x3, x, 4);
}
if (n & 8)
{
LD_SP2_INC(px, 4, x0, x1);
MUL2(x0, da_vec, x1, da_vec, x0, x1);
ST_SP2_INC(x0, x1, x, 4);
}
if (n & 4)
{
LD_GP4_INC(px, 1, f0, f1, f2, f3);
MUL4(f0, da, f1, da, f2, da, f3, da, f0, f1, f2, f3);
ST_GP4_INC(f0, f1, f2, f3, x, 1);
}
if (n & 2)
{
LD_GP2_INC(px, 1, f0, f1);
MUL2(f0, da, f1, da, f0, f1);
ST_GP2_INC(f0, f1, x, 1);
}
if (n & 1)
{
*x *= da;
}
}
}
}
else
{
if (0.0 == da)
{
for (i = n; i--;)
{
*x = 0;
x += inc_x;
}
}
else
{
if (n > 15)
{
LD_GP8_INC(px, inc_x, f0, f1, f2, f3, f4, f5, f6, f7);
for (i = 0; i < (n >> 4) - 1; i++)
{
LD_GP8_INC(px, inc_x, f8, f9, f10, f11, f12, f13, f14, f15);
MUL4(f0, da, f1, da, f2, da, f3, da, f0, f1, f2, f3);
f4 *= da;
f5 *= da;
*x = f0; x += inc_x;
f6 *= da;
*x = f1; x += inc_x;
f7 *= da;
*x = f2; x += inc_x;
f8 *= da;
*x = f3; x += inc_x;
f9 *= da;
*x = f4; x += inc_x;
f10 *= da;
*x = f5; x += inc_x;
f11 *= da;
*x = f6; x += inc_x;
f12 *= da;
*x = f7; x += inc_x;
f13 *= da;
*x = f8; x += inc_x;
f14 *= da;
*x = f9; x += inc_x;
f15 *= da;
*x = f10; x += inc_x;
*x = f11; x += inc_x;
f0 = *px; px += inc_x;
*x = f12; x += inc_x;
f1 = *px; px += inc_x;
*x = f13; x += inc_x;
f2 = *px; px += inc_x;
*x = f14; x += inc_x;
f3 = *px; px += inc_x;
*x = f15; x += inc_x;
f4 = *px; px += inc_x;
f5 = *px; px += inc_x;
f6 = *px; px += inc_x;
f7 = *px; px += inc_x;
}
LD_GP8_INC(px, inc_x, f8, f9, f10, f11, f12, f13, f14, f15);
MUL4(f0, da, f1, da, f2, da, f3, da, f0, f1, f2, f3);
f4 *= da;
f5 *= da;
*x = f0; x += inc_x;
f6 *= da;
*x = f1; x += inc_x;
f7 *= da;
*x = f2; x += inc_x;
f8 *= da;
*x = f3; x += inc_x;
f9 *= da;
*x = f4; x += inc_x;
f10 *= da;
*x = f5; x += inc_x;
f11 *= da;
*x = f6; x += inc_x;
f12 *= da;
*x = f7; x += inc_x;
f13 *= da;
*x = f8; x += inc_x;
f14 *= da;
*x = f9; x += inc_x;
f15 *= da;
*x = f10; x += inc_x;
*x = f11; x += inc_x;
*x = f12; x += inc_x;
*x = f13; x += inc_x;
*x = f14; x += inc_x;
*x = f15; x += inc_x;
}
if (n & 15)
{
if (n & 8)
{
LD_GP8_INC(px, inc_x, f0, f1, f2, f3, f4, f5, f6, f7);
MUL4(f0, da, f1, da, f2, da, f3, da, f0, f1, f2, f3);
MUL4(f4, da, f5, da, f6, da, f7, da, f4, f5, f6, f7);
ST_GP8_INC(f0, f1, f2, f3, f4, f5, f6, f7, x, inc_x);
}
if (n & 4)
{
LD_GP4_INC(px, inc_x, f0, f1, f2, f3);
MUL4(f0, da, f1, da, f2, da, f3, da, f0, f1, f2, f3);
ST_GP4_INC(f0, f1, f2, f3, x, inc_x);
}
if (n & 2)
{
LD_GP2_INC(px, inc_x, f0, f1);
MUL2(f0, da, f1, da, f0, f1);
ST_GP2_INC(f0, f1, x, inc_x);
}
if (n & 1)
{
*x *= da;
}
}
}
}
return 0;
}
| 9,429 |
320 | <filename>test/testcases/execute/0002-operators.c<gh_stars>100-1000
int x;
// TODO:
// Should we generate test cases for these?
// Should we do table based testing?
// Test prec.
// Test all types.
// Test short circuits.
int main() {
x = 0;
x = x + 2; // 2
x = x - 1; // 1
x = x * 6; // 6
x = x / 2; // 3
x = x % 2; // 1
x = x << 2; // 4
x = x >> 1; // 2
x = x | 255; // 255
x = x & 3; // 3
x = x ^ 1; // 2
x = -x; // -2
x = x + !!x; // -1
x = x + (x > 2); // -1
x = x + (x < 2); // 0
// XXX <= >= != ==
return x;
}
| 334 |
643 | <filename>src/gorilla.h
/*
* Copyright 2018-2019 Redis Labs Ltd. and Contributors
*
* This file is available under the Redis Labs Source Available License Agreement
*/
#ifndef GORILLA_H
#define GORILLA_H
#include "consts.h"
#include "generic_chunk.h"
#include <stdbool.h> // bool
#include <sys/types.h> // u_int_t
typedef u_int64_t timestamp_t;
typedef u_int64_t binary_t;
typedef u_int64_t globalbit_t;
typedef u_int8_t localbit_t;
typedef union
{
double d;
int64_t i;
u_int64_t u;
} union64bits;
typedef struct CompressedChunk
{
u_int64_t size;
u_int64_t count;
u_int64_t idx;
union64bits baseValue;
u_int64_t baseTimestamp;
u_int64_t *data;
u_int64_t prevTimestamp;
int64_t prevTimestampDelta;
union64bits prevValue;
u_int8_t prevLeading;
u_int8_t prevTrailing;
} CompressedChunk;
typedef struct Compressed_Iterator
{
CompressedChunk *chunk;
u_int64_t idx;
u_int64_t count;
// timestamp vars
u_int64_t prevTS;
int64_t prevDelta;
// value vars
union64bits prevValue;
u_int8_t leading;
u_int8_t trailing;
u_int8_t blocksize;
} Compressed_Iterator;
ChunkResult Compressed_Append(CompressedChunk *chunk, u_int64_t timestamp, double value);
ChunkResult Compressed_ChunkIteratorGetNext(ChunkIter_t *iter, Sample *sample);
#endif
| 580 |
Subsets and Splits