max_stars_count
int64 301
224k
| text
stringlengths 6
1.05M
| token_count
int64 3
727k
|
|---|---|---|
4,013 | import unittest
from checkov.terraform.context_parsers.registry import parser_registry
from tests.terraform.context_parsers.mock_context_parser import MockContextParser
import os
mock_definition = (os.path.dirname(os.path.realpath(__file__)) + '/mock_tf_files/mock.tf', {'mock': [
{
'mock_type': {
'mock_name': {
'value': [
'mock_value']}}}
]})
class TestScannerRegistry(unittest.TestCase):
def test_enrich_definition_block(self):
mock_parser = MockContextParser()
parser_registry.register(mock_parser)
definition_context = parser_registry.enrich_definitions_context(mock_definition)
self.assertIsNotNone(definition_context[mock_definition[0]]['mock']['mock_type']['mock_name'])
if __name__ == '__main__':
unittest.main()
| 356 |
392 | <reponame>Da-Krause/settlers-remake
/*******************************************************************************
* Copyright (c) 2015
*
* 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.
*******************************************************************************/
package jsettlers.mapcreator.mapview;
import jsettlers.common.landscape.EResourceType;
import jsettlers.common.mapobject.EMapObjectType;
import jsettlers.common.mapobject.IMapObject;
/**
* Helper class to display resources on the Map
*
* @author <NAME>
*
*/
public class ResourceMapObject implements IMapObject {
/**
* Amount of the resources
*/
private final byte resourceAmount;
/**
* Type of the resource
*/
private final EResourceType resourceType;
/**
* Constructor
*
* @param resourceType
* Type of the resource
* @param resourceAmount
* Amount of the resources
*/
public ResourceMapObject(EResourceType resourceType, byte resourceAmount) {
this.resourceType = resourceType;
this.resourceAmount = resourceAmount;
}
/**
* Gets the resource object
*
* @param resourceType
* Type of the resource
* @param resourceAmount
* Amount of the resources
* @return IMapObject
*/
public static IMapObject get(EResourceType resourceType, byte resourceAmount) {
return new ResourceMapObject(resourceType, resourceAmount);
}
@Override
public EMapObjectType getObjectType() {
switch (resourceType) {
case COAL:
return EMapObjectType.FOUND_COAL;
case GOLDORE:
return EMapObjectType.FOUND_GOLD;
case IRONORE:
return EMapObjectType.FOUND_IRON;
case FISH:
return EMapObjectType.FISH_DECORATION;
case NOTHING:
return EMapObjectType.FOUND_NOTHING;
case GEMSTONE:
return EMapObjectType.FOUND_GEMSTONE;
case BRIMSTONE:
return EMapObjectType.FOUND_BRIMSTONE;
default:
return EMapObjectType.FOUND_NOTHING;
}
}
@Override
public float getStateProgress() {
return (float) resourceAmount / Byte.MAX_VALUE;
}
@Override
public IMapObject getNextObject() {
return null;
}
@Override
public IMapObject getMapObject(EMapObjectType type) {
return type == getObjectType() ? this : null;
}
}
| 984 |
5,169 | <filename>Specs/2/c/c/AXASDK/19.12/AXASDK.podspec.json
{
"name": "AXASDK",
"version": "19.12",
"summary": "A short description of AXASDK.",
"description": "TODO: Add long description of the pod here.",
"homepage": "https://github.com/Aruna-Sree/AXASDK.git",
"license": {
"type": "MIT",
"file": "LICENSE"
},
"authors": {
"<EMAIL>": "<EMAIL>"
},
"source": {
"git": "https://github.com/Aruna-Sree/AXASDK.git",
"tag": "19.12"
},
"platforms": {
"ios": "8.0"
},
"requires_arc": true,
"resources": [
"CaMDOIntegration.js",
"CaMDOInterceptor.js"
],
"source_files": "CAMDOReporter.h",
"public_header_files": "CAMDOReporter.h",
"vendored_libraries": [
"libCAMobileAppAnalytics.a",
"libCAMobileAppAnalytics-simulator.a"
],
"xcconfig": {
"OTHER_LDFLAGS": "$(inherited) -lc++ -lz -lsqlite3 -framework CoreLocation -framework SystemConfiguration -framework Foundation -framework UIKit -framework CoreGraphics -framework Security -framework CoreTelephony -framework WebKit -framework WatchConnectivity"
},
"pod_target_xcconfig": {
"VALID_ARCHS": "arm64,armv7,armv7s",
"ENABLE_BITCODE": "NO"
}
}
| 489 |
546 | #include "Msnhnet/hardware/MsnhSerialPort.h"
namespace Msnhnet
{
std::vector<Msnhnet::PortInfo> SerialPort::searchPorts()
{
return Msnhnet::list_ports();
}
SerialPort::SerialPort(const std::string &port, uint32_t baudrate, Timeout timeout, bytesize_t bytesize, parity_t parity, stopbits_t stopbits, flowcontrol_t flowcontrol)
:Serial(port, baudrate, timeout, bytesize, parity, stopbits, flowcontrol)
{
}
}
| 155 |
965 | <gh_stars>100-1000
// Create "Customize" page
// CMFCRibbonBar m_wndRibbonBar
CMFCRibbonCustomizePropertyPage pageCustomize(&m_wndRibbonBar);
// Create a list of popular items:
CList<UINT, UINT> lstPopular;
lstPopular.AddTail(ID_FILE_NEW);
lstPopular.AddTail(ID_FILE_OPEN);
// add a custom category
pageCustomize.AddCustomCategory(_T("Popular Commands"), lstPopular); | 140 |
14,668 | <gh_stars>1000+
/* Copyright (c) 2012 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.
*/
/* From pp_input_event.idl modified Thu Mar 28 10:52:59 2013. */
#ifndef PPAPI_C_PP_INPUT_EVENT_H_
#define PPAPI_C_PP_INPUT_EVENT_H_
#include "ppapi/c/pp_bool.h"
#include "ppapi/c/pp_macros.h"
#include "ppapi/c/pp_stdint.h"
#include "ppapi/c/ppb_input_event.h"
/**
* @file
* This file defines the API used to handle mouse and keyboard input events.
*/
/**
* @addtogroup Structs
* @{
*/
/**
* The <code>PP_InputEvent_Key</code> struct represents a key up or key down
* event.
*
* Key up and key down events correspond to physical keys on the keyboard. The
* actual character that the user typed (if any) will be delivered in a
* "character" event.
*
* If the user loses focus on the module while a key is down, a key up
* event might not occur. For example, if the module has focus and the user
* presses and holds the shift key, the module will see a "shift down" message.
* Then if the user clicks elsewhere on the web page, the module's focus will
* be lost and no more input events will be delivered.
*
* If your module depends on receiving key up events, it should also handle
* "lost focus" as the equivalent of "all keys up."
*/
struct PP_InputEvent_Key {
/** This value is a bit field combination of the EVENT_MODIFIER flags. */
uint32_t modifier;
/**
* This value reflects the DOM KeyboardEvent <code>keyCode</code> field.
* Chrome populates this with the Windows-style Virtual Key code of the key.
*/
uint32_t key_code;
};
PP_COMPILE_ASSERT_STRUCT_SIZE_IN_BYTES(PP_InputEvent_Key, 8);
/**
* The <code>PP_InputEvent_Character</code> struct represents a typed character
* event.
*
* Normally, the program will receive a key down event, followed by a character
* event, followed by a key up event. The character event will have any
* modifier keys applied. Obvious examples are symbols, where Shift-5 gives you
* a '%'. The key down and up events will give you the scan code for the "5"
* key, and the character event will give you the '%' character.
*
* You may not get a character event for all key down events if the key doesn't
* generate a character. Likewise, you may actually get multiple character
* events in a row. For example, some locales have an accent key that modifies
* the next character typed. You might get this stream of events: accent down,
* accent up (it didn't generate a character), letter key down, letter with
* accent character event (it was modified by the previous accent key), letter
* key up. If the letter can't be combined with the accent, like an umlaut and
* an 'R', the system might send umlaut down, umlaut up, 'R' key down, umlaut
* character (can't combine it with 'R', so just send the raw umlaut so it
* isn't lost"), 'R' character event, 'R' key up.
*/
struct PP_InputEvent_Character {
/** A combination of the <code>PP_InputEvent_Modifier</code> flags. */
uint32_t modifier;
/**
* This value represents the typed character as a single null-terminated UTF-8
* character. Any unused bytes will be filled with null bytes. Since the
* maximum UTF-8 character is 4 bytes, there will always be at least one null
* at the end so you can treat this as a null-terminated UTF-8 string.
*/
int8_t text[5];
};
PP_COMPILE_ASSERT_STRUCT_SIZE_IN_BYTES(PP_InputEvent_Character, 12);
/**
* The <code>PP_InputEvent_Mouse</code> struct represents all mouse events
* except mouse wheel events.
*/
struct PP_InputEvent_Mouse {
/**
* This value is a bit field combination of the
* <code>PP_InputEvent_Modifier</code> flags.
*/
uint32_t modifier;
/**
* This value represents the button that changed for mouse down or up events.
* This value will be <code>PP_EVENT_MOUSEBUTTON_NONE</code> for mouse move,
* enter, and leave events.
*/
PP_InputEvent_MouseButton button;
/**
* This values represents the x coordinate of the mouse when the event
* occurred.
*
* In most, but not all, cases these coordinates will just be integers.
* For example, the plugin element might be arbitrarily scaled or transformed
* in the DOM, and translating a mouse event into the coordinate space of the
* plugin will give non-integer values.
*/
float x;
/**
* This values represents the y coordinate of the mouse when the event
* occurred.
*
* In most, but not all, cases these coordinates will just be integers.
* For example, the plugin element might be arbitrarily scaled or transformed
* in the DOM, and translating a mouse event into the coordinate space of the
* plugin will give non-integer values.
*/
float y;
int32_t click_count;
};
PP_COMPILE_ASSERT_STRUCT_SIZE_IN_BYTES(PP_InputEvent_Mouse, 20);
/**
* The <code>PP_InputEvent_Wheel</code> struct represents all mouse wheel
* events.
*/
struct PP_InputEvent_Wheel {
/**
* This value represents a combination of the <code>EVENT_MODIFIER</code>
* flags.
*/
uint32_t modifier;
/**
* The mouse wheel's horizontal scroll amount. A scroll to the right
* (where the content moves left) is represented as positive values,
* and a scroll to the left (where the content moves right) is
* represented as negative values.
*
* The units are either in pixels (when scroll_by_page is false) or pages
* (when scroll_by_page is true). For example, delta_y = -3 means scroll up 3
* pixels when scroll_by_page is false, and scroll up 3 pages when
* scroll_by_page is true.
*
* This amount is system dependent and will take into account the user's
* preferred scroll sensitivity and potentially also nonlinear acceleration
* based on the speed of the scrolling.
*
* Devices will be of varying resolution. Some mice with large detents will
* only generate integer scroll amounts. But fractional values are also
* possible, for example, on some trackpads and newer mice that don't have
* "clicks".
*/
float delta_x;
/**
* The mouse wheel's vertical scroll amount. A scroll down (where the
* content moves up) is represented as positive values, and a scroll up
* (where the content moves down) is represented as negative values.
*
* The units are either in pixels (when scroll_by_page is false) or pages
* (when scroll_by_page is true). For example, delta_y = -3 means scroll up 3
* pixels when scroll_by_page is false, and scroll up 3 pages when
* scroll_by_page is true.
*
* This amount is system dependent and will take into account the user's
* preferred scroll sensitivity and potentially also nonlinear acceleration
* based on the speed of the scrolling.
*
* Devices will be of varying resolution. Some mice with large detents will
* only generate integer scroll amounts. But fractional values are also
* possible, for example, on some trackpads and newer mice that don't have
* "clicks".
*/
float delta_y;
/**
* The number of "clicks" of the scroll wheel that have produced the
* event. The value may have system-specific acceleration applied to it,
* depending on the device. The positive and negative meanings are the same
* as for <code>delta_x</code> and <code>delta_y</code>.
*
* If you are scrolling, you probably want to use the delta values above.
* These tick events can be useful if you aren't doing actual scrolling and
* don't want or pixel values. An example may be cycling between different
* items in a game.
*
* You may receive fractional values for the wheel ticks if the mouse wheel
* is high resolution or doesn't have "clicks". If your program wants
* discrete events (as in the "picking items" example) you should accumulate
* fractional click values from multiple messages until the total value
* reaches positive or negative one. This should represent a similar amount
* of scrolling as for a mouse that has a discrete mouse wheel.
*/
float wheel_ticks_x;
/** This value represents */
float wheel_ticks_y;
/**
* Indicates if the scroll <code>delta_x</code>/<code>delta_y</code>
* indicates pages or lines to scroll by. When true, the user is requesting
* to scroll by pages.
*/
PP_Bool scroll_by_page;
};
PP_COMPILE_ASSERT_STRUCT_SIZE_IN_BYTES(PP_InputEvent_Wheel, 24);
/**
* @}
*/
#endif /* PPAPI_C_PP_INPUT_EVENT_H_ */
| 2,504 |
30,023 | """Provides the Canary DataUpdateCoordinator."""
from __future__ import annotations
from collections.abc import ValuesView
from datetime import timedelta
import logging
from async_timeout import timeout
from canary.api import Api, Location
from requests.exceptions import ConnectTimeout, HTTPError
from homeassistant.core import HomeAssistant
from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
from .const import DOMAIN
from .model import CanaryData
_LOGGER = logging.getLogger(__name__)
class CanaryDataUpdateCoordinator(DataUpdateCoordinator):
"""Class to manage fetching Canary data."""
def __init__(self, hass: HomeAssistant, *, api: Api) -> None:
"""Initialize global Canary data updater."""
self.canary = api
update_interval = timedelta(seconds=30)
super().__init__(
hass,
_LOGGER,
name=DOMAIN,
update_interval=update_interval,
)
def _update_data(self) -> CanaryData:
"""Fetch data from Canary via sync functions."""
locations_by_id: dict[str, Location] = {}
readings_by_device_id: dict[str, ValuesView] = {}
for location in self.canary.get_locations():
location_id = location.location_id
locations_by_id[location_id] = location
for device in location.devices:
if device.is_online:
readings_by_device_id[
device.device_id
] = self.canary.get_latest_readings(device.device_id)
return {
"locations": locations_by_id,
"readings": readings_by_device_id,
}
async def _async_update_data(self) -> CanaryData:
"""Fetch data from Canary."""
try:
async with timeout(15):
return await self.hass.async_add_executor_job(self._update_data)
except (ConnectTimeout, HTTPError) as error:
raise UpdateFailed(f"Invalid response from API: {error}") from error
| 841 |
3,702 | <gh_stars>1000+
// Copyright (c) YugaByte, Inc.
package com.yugabyte.yw.forms;
import play.data.validation.Constraints;
public class PagedRequestFormData<F, S> {
@Constraints.Required() public F filter;
@Constraints.Required() public S sortBy;
@Constraints.Required() public int offset;
@Constraints.Required() public int limit;
}
| 118 |
746 | # Copyright 2019 The Texar Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Example for building the Variational Auto-Encoder.
This is an implementation of Variational Auto-Encoder for text generation
To run:
$ python vae_train.py
Hyperparameters and data path may be specified in config_trans.py
"""
import argparse
import importlib
import math
import os
import sys
import time
from typing import Any, Dict, Optional, Tuple, Union
import torch
import torch.nn as nn
from torch import Tensor
from torch.optim.lr_scheduler import ExponentialLR
import texar.torch as tx
from texar.torch.custom import MultivariateNormalDiag
parser = argparse.ArgumentParser()
parser.add_argument(
'--config', type=str, default=None,
help="The config to use.")
parser.add_argument(
'--mode', type=str, default='train',
help="Train or predict.")
parser.add_argument(
'--model', type=str, default=None,
help="Model path for generating sentences.")
parser.add_argument(
'--out', type=str, default=None,
help="Generation output path.")
args = parser.parse_args()
def kl_divergence(means: Tensor, logvars: Tensor) -> Tensor:
"""Compute the KL divergence between Gaussian distribution
"""
kl_cost = -0.5 * (logvars - means ** 2 -
torch.exp(logvars) + 1.0)
kl_cost = torch.mean(kl_cost, 0)
return torch.sum(kl_cost)
class VAE(nn.Module):
_latent_z: Tensor
def __init__(self, vocab_size: int, config_model):
super().__init__()
# Model architecture
self._config = config_model
self.encoder_w_embedder = tx.modules.WordEmbedder(
vocab_size=vocab_size, hparams=config_model.enc_emb_hparams)
self.encoder = tx.modules.UnidirectionalRNNEncoder[tx.core.LSTMState](
input_size=self.encoder_w_embedder.dim,
hparams={
"rnn_cell": config_model.enc_cell_hparams,
})
self.decoder_w_embedder = tx.modules.WordEmbedder(
vocab_size=vocab_size, hparams=config_model.dec_emb_hparams)
if config_model.decoder_type == "lstm":
self.lstm_decoder = tx.modules.BasicRNNDecoder(
input_size=(self.decoder_w_embedder.dim +
config_model.latent_dims),
vocab_size=vocab_size,
token_embedder=self._embed_fn_rnn,
hparams={"rnn_cell": config_model.dec_cell_hparams})
sum_state_size = self.lstm_decoder.cell.hidden_size * 2
elif config_model.decoder_type == 'transformer':
# position embedding
self.decoder_p_embedder = tx.modules.SinusoidsPositionEmbedder(
position_size=config_model.max_pos,
hparams=config_model.dec_pos_emb_hparams)
# decoder
self.transformer_decoder = tx.modules.TransformerDecoder(
# tie word embedding with output layer
output_layer=self.decoder_w_embedder.embedding,
token_pos_embedder=self._embed_fn_transformer,
hparams=config_model.trans_hparams)
sum_state_size = self._config.dec_emb_hparams["dim"]
else:
raise ValueError("Decoder type must be 'lstm' or 'transformer'")
self.connector_mlp = tx.modules.MLPTransformConnector(
config_model.latent_dims * 2,
linear_layer_dim=self.encoder.cell.hidden_size * 2)
self.mlp_linear_layer = nn.Linear(
config_model.latent_dims, sum_state_size)
def forward(self, # type: ignore
data_batch: tx.data.Batch,
kl_weight: float, start_tokens: torch.LongTensor,
end_token: int) -> Dict[str, Tensor]:
# encoder -> connector -> decoder
text_ids = data_batch["text_ids"]
input_embed = self.encoder_w_embedder(text_ids)
_, encoder_states = self.encoder(
input_embed,
sequence_length=data_batch["length"])
mean_logvar = self.connector_mlp(encoder_states)
mean, logvar = torch.chunk(mean_logvar, 2, 1)
kl_loss = kl_divergence(mean, logvar)
dst = MultivariateNormalDiag(
loc=mean, scale_diag=torch.exp(0.5 * logvar))
latent_z = dst.rsample()
helper = None
if self._config.decoder_type == "lstm":
helper = self.lstm_decoder.create_helper(
decoding_strategy="train_greedy",
start_tokens=start_tokens,
end_token=end_token)
# decode
seq_lengths = data_batch["length"] - 1
outputs = self.decode(
helper=helper, latent_z=latent_z,
text_ids=text_ids[:, :-1], seq_lengths=seq_lengths)
logits = outputs.logits
# Losses & train ops
rc_loss = tx.losses.sequence_sparse_softmax_cross_entropy(
labels=text_ids[:, 1:], logits=logits,
sequence_length=seq_lengths)
nll = rc_loss + kl_weight * kl_loss
ret = {
"nll": nll,
"kl_loss": kl_loss,
"rc_loss": rc_loss,
"lengths": seq_lengths,
}
return ret
def _embed_fn_rnn(self, tokens: torch.LongTensor) -> Tensor:
r"""Generates word embeddings
"""
embedding = self.decoder_w_embedder(tokens)
latent_z = self._latent_z
if len(embedding.size()) > 2:
latent_z = latent_z.unsqueeze(0).repeat(tokens.size(0), 1, 1)
return torch.cat([embedding, latent_z], dim=-1)
def _embed_fn_transformer(self,
tokens: torch.LongTensor,
positions: torch.LongTensor) -> Tensor:
r"""Generates word embeddings combined with positional embeddings
"""
output_p_embed = self.decoder_p_embedder(positions)
output_w_embed = self.decoder_w_embedder(tokens)
output_w_embed = output_w_embed * self._config.hidden_size ** 0.5
output_embed = output_w_embed + output_p_embed
return output_embed
@property
def decoder(self) -> tx.modules.DecoderBase:
if self._config.decoder_type == "lstm":
return self.lstm_decoder
else:
return self.transformer_decoder
def decode(self,
helper: Optional[tx.modules.Helper],
latent_z: Tensor,
text_ids: Optional[torch.LongTensor] = None,
seq_lengths: Optional[Tensor] = None,
max_decoding_length: Optional[int] = None) \
-> Union[tx.modules.BasicRNNDecoderOutput,
tx.modules.TransformerDecoderOutput]:
self._latent_z = latent_z
fc_output = self.mlp_linear_layer(latent_z)
if self._config.decoder_type == "lstm":
lstm_states = torch.chunk(fc_output, 2, dim=1)
outputs, _, _ = self.lstm_decoder(
initial_state=lstm_states,
inputs=text_ids,
helper=helper,
sequence_length=seq_lengths,
max_decoding_length=max_decoding_length)
else:
transformer_states = fc_output.unsqueeze(1)
outputs = self.transformer_decoder(
inputs=text_ids,
memory=transformer_states,
memory_sequence_length=torch.ones(transformer_states.size(0)),
helper=helper,
max_decoding_length=max_decoding_length)
return outputs
def main() -> None:
"""Entrypoint.
"""
config: Any = importlib.import_module(args.config)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
train_data = tx.data.MonoTextData(config.train_data_hparams, device=device)
val_data = tx.data.MonoTextData(config.val_data_hparams, device=device)
test_data = tx.data.MonoTextData(config.test_data_hparams, device=device)
iterator = tx.data.DataIterator(
{"train": train_data, "valid": val_data, "test": test_data})
opt_vars = {
'learning_rate': config.lr_decay_hparams["init_lr"],
'best_valid_nll': 1e100,
'steps_not_improved': 0,
'kl_weight': config.kl_anneal_hparams["start"]
}
decay_cnt = 0
max_decay = config.lr_decay_hparams["max_decay"]
decay_factor = config.lr_decay_hparams["decay_factor"]
decay_ts = config.lr_decay_hparams["threshold"]
save_dir = f"./models/{config.dataset}"
if not os.path.exists(save_dir):
os.makedirs(save_dir)
suffix = f"{config.dataset}_{config.decoder_type}Decoder.ckpt"
save_path = os.path.join(save_dir, suffix)
# KL term annealing rate
anneal_r = 1.0 / (config.kl_anneal_hparams["warm_up"] *
(len(train_data) / config.batch_size))
vocab = train_data.vocab
model = VAE(train_data.vocab.size, config)
model.to(device)
start_tokens = torch.full(
(config.batch_size,),
vocab.bos_token_id,
dtype=torch.long).to(device)
end_token = vocab.eos_token_id
optimizer = tx.core.get_optimizer(
params=model.parameters(),
hparams=config.opt_hparams)
scheduler = ExponentialLR(optimizer, decay_factor)
def _run_epoch(epoch: int, mode: str, display: int = 10) \
-> Tuple[Tensor, float]:
iterator.switch_to_dataset(mode)
if mode == 'train':
model.train()
opt_vars["kl_weight"] = min(
1.0, opt_vars["kl_weight"] + anneal_r)
kl_weight = opt_vars["kl_weight"]
else:
model.eval()
kl_weight = 1.0
step = 0
start_time = time.time()
num_words = 0
nll_total = 0.
avg_rec = tx.utils.AverageRecorder()
for batch in iterator:
ret = model(batch, kl_weight, start_tokens, end_token)
if mode == "train":
opt_vars["kl_weight"] = min(
1.0, opt_vars["kl_weight"] + anneal_r)
kl_weight = opt_vars["kl_weight"]
ret["nll"].backward()
optimizer.step()
optimizer.zero_grad()
batch_size = len(ret["lengths"])
num_words += torch.sum(ret["lengths"]).item()
nll_total += ret["nll"].item() * batch_size
avg_rec.add(
[ret["nll"].item(),
ret["kl_loss"].item(),
ret["rc_loss"].item()],
batch_size)
if step % display == 0 and mode == 'train':
nll = avg_rec.avg(0)
klw = opt_vars["kl_weight"]
KL = avg_rec.avg(1)
rc = avg_rec.avg(2)
log_ppl = nll_total / num_words
ppl = math.exp(log_ppl)
time_cost = time.time() - start_time
print(f"{mode}: epoch {epoch}, step {step}, nll {nll:.4f}, "
f"klw {klw:.4f}, KL {KL:.4f}, rc {rc:.4f}, "
f"log_ppl {log_ppl:.4f}, ppl {ppl:.4f}, "
f"time_cost {time_cost:.1f}", flush=True)
step += 1
nll = avg_rec.avg(0)
KL = avg_rec.avg(1)
rc = avg_rec.avg(2)
log_ppl = nll_total / num_words
ppl = math.exp(log_ppl)
print(f"\n{mode}: epoch {epoch}, nll {nll:.4f}, KL {KL:.4f}, "
f"rc {rc:.4f}, log_ppl {log_ppl:.4f}, ppl {ppl:.4f}")
return nll, ppl # type: ignore
@torch.no_grad()
def _generate(start_tokens: torch.LongTensor,
end_token: int,
filename: Optional[str] = None):
ckpt = torch.load(args.model)
model.load_state_dict(ckpt['model'])
model.eval()
batch_size = train_data.batch_size
dst = MultivariateNormalDiag(
loc=torch.zeros(batch_size, config.latent_dims),
scale_diag=torch.ones(batch_size, config.latent_dims))
latent_z = dst.rsample().to(device)
helper = model.decoder.create_helper(
decoding_strategy='infer_sample',
start_tokens=start_tokens,
end_token=end_token)
outputs = model.decode(
helper=helper,
latent_z=latent_z,
max_decoding_length=100)
if config.decoder_type == "transformer":
outputs = outputs[0]
sample_tokens = vocab.map_ids_to_tokens_py(outputs.sample_id.cpu())
if filename is None:
fh = sys.stdout
else:
fh = open(filename, 'w', encoding='utf-8')
for sent in sample_tokens:
sent = tx.utils.compat_as_text(list(sent))
end_id = len(sent)
if vocab.eos_token in sent:
end_id = sent.index(vocab.eos_token)
fh.write(' '.join(sent[:end_id + 1]) + '\n')
print('Output done')
fh.close()
if args.mode == "predict":
_generate(start_tokens, end_token, args.out)
return
# Counts trainable parameters
total_parameters = sum(param.numel() for param in model.parameters())
print(f"{total_parameters} total parameters")
best_nll = best_ppl = 0.
for epoch in range(config.num_epochs):
_, _ = _run_epoch(epoch, 'train', display=200)
val_nll, _ = _run_epoch(epoch, 'valid')
test_nll, test_ppl = _run_epoch(epoch, 'test')
if val_nll < opt_vars['best_valid_nll']:
opt_vars['best_valid_nll'] = val_nll
opt_vars['steps_not_improved'] = 0
best_nll = test_nll
best_ppl = test_ppl
states = {
"model": model.state_dict(),
"optimizer": optimizer.state_dict(),
"scheduler": scheduler.state_dict()
}
torch.save(states, save_path)
else:
opt_vars['steps_not_improved'] += 1
if opt_vars['steps_not_improved'] == decay_ts:
old_lr = opt_vars['learning_rate']
opt_vars['learning_rate'] *= decay_factor
opt_vars['steps_not_improved'] = 0
new_lr = opt_vars['learning_rate']
ckpt = torch.load(save_path)
model.load_state_dict(ckpt['model'])
optimizer.load_state_dict(ckpt['optimizer'])
scheduler.load_state_dict(ckpt['scheduler'])
scheduler.step()
print(f"-----\nchange lr, old lr: {old_lr}, "
f"new lr: {new_lr}\n-----")
decay_cnt += 1
if decay_cnt == max_decay:
break
print(f"\nbest testing nll: {best_nll:.4f},"
f"best testing ppl {best_ppl:.4f}\n")
if __name__ == '__main__':
main()
| 7,613 |
793 | <filename>clang/test/Refactor/Extract/extract-reference-of-captured-variable.cpp
void takesPtr(int *x) { }
typedef struct {
int width, height;
} Rectangle;
void takesStructPtr(Rectangle *sp) { }
void variableTakesRef(int x, Rectangle r) {
int &y = x;
takesPtr(&y);
// CHECK1: (int &x) {\nint &y = x;\n takesPtr(&y);\n}
Rectangle p = r;
Rectangle &rp = p;
takesStructPtr(&rp);
// CHECK1: (const Rectangle &r) {\nRectangle p = r;\n Rectangle &rp = p;\n takesStructPtr(&rp);\n}
// CHECK1: (Rectangle &p) {\nRectangle &rp = p;\n takesStructPtr(&rp);\n}
int &member = ((r).width);
int z = member;
// CHECK1: (Rectangle &r) {\nint &member = ((r).width);\n int z = member;\n}
// Even though y takes a reference to x, we still want to pass it by value here.
int a = x;
// CHECK1: (int x) {\nint a = x;\n}
}
// RUN: clang-refactor-test perform -action extract -selected=%s:11:3-12:15 -selected=%s:14:3-16:22 -selected=%s:15:3-16:22 -selected=%s:19:3-20:17 -selected=%s:24:3-24:12 %s | FileCheck --check-prefix=CHECK1 %s
class PrivateInstanceVariables {
int x;
Rectangle r;
void method() {
int &y = x;
// CHECK2: extracted(int &x) {\nint &y = x;\n}
Rectangle &rr = r;
// CHECK2: extracted(Rectangle &r) {\nRectangle &rr = r;\n}
int &z = ((r).width);
// CHECK2: extracted(Rectangle &r) {\nint &z = ((r).width);\n}
}
};
// RUN: clang-refactor-test perform -action extract -selected=%s:35:5-35:15 -selected=%s:37:5-37:22 -selected=%s:39:5-39:25 %s | FileCheck --check-prefix=CHECK2 %s
#ifdef USECONST
#define CONST const
#else
#define CONST
#endif
void takesRef(CONST int &x) { }
void takesStructRef(CONST Rectangle &r) { }
void takesValue(int x) { }
struct ConsTakesRef {
ConsTakesRef(CONST int &x) { }
void takesRef(CONST int &x) const { }
void takesValue(int x) const { }
};
int operator << (CONST Rectangle &r, CONST int &x) { return 0; }
void callTakesRef(int x, Rectangle r) {
takesRef(x);
// CHECK3: extracted(int &x) {\ntakesRef(x);\n}
// CHECK4: extracted(int x) {\ntakesRef(x);\n}
takesValue(x);
// CHECK3: extracted(int x) {\ntakesValue(x);\n}
// CHECK4: extracted(int x) {\ntakesValue(x);\n}
auto k = ConsTakesRef(x); auto y = ConsTakesRef(x);
// CHECK3: extracted(int &x) {\nauto k = ConsTakesRef(x);\n}
// CHECK4: extracted(int x) {\nauto k = ConsTakesRef(x);\n}
y.takesRef((x));
// CHECK3: extracted(int &x, const ConsTakesRef &y) {\ny.takesRef((x));\n}
// CHECK4: extracted(int x, const ConsTakesRef &y) {\ny.takesRef((x));\n}
y.takesValue(x);
// CHECK3: extracted(int x, const ConsTakesRef &y) {\ny.takesValue(x);\n}
// CHECK4: extracted(int x, const ConsTakesRef &y) {\ny.takesValue(x);\n}
takesStructRef((r));
// CHECK3: extracted(Rectangle &r) {\ntakesStructRef((r));\n}
// CHECK4: extracted(const Rectangle &r) {\ntakesStructRef((r));\n}
takesRef((r).height);
// CHECK3: extracted(Rectangle &r) {\ntakesRef((r).height);\n}
// CHECK4: extracted(const Rectangle &r) {\ntakesRef((r).height);\n}
y.takesRef(r.width);
// CHECK3: extracted(Rectangle &r, const ConsTakesRef &y) {\ny.takesRef(r.width);\n}
// CHECK4: extracted(const Rectangle &r, const ConsTakesRef &y) {\ny.takesRef(r.width);\n}
takesValue(r.width);
// CHECK3: extracted(const Rectangle &r) {\ntakesValue(r.width);\n}
// CHECK4: extracted(const Rectangle &r) {\ntakesValue(r.width);\n}
r << x;
// CHECK3: extracted(Rectangle &r, int &x) {\nreturn r << x;\n}
// CHECK4: extracted(const Rectangle &r, int x) {\nreturn r << x;\n}
int &r1 = x;
takesRef(x);
// CHECK3: extracted(int &x) {\nint &r1 = x;\n takesRef(x);\n}
// CHECK4: extracted(int &x) {\nint &r1 = x;\n takesRef(x);\n}
}
// RUN: clang-refactor-test perform -action extract -selected=%s:68:3-68:14 -selected=%s:71:3-71:16 -selected=%s:74:3-74:27 -selected=%s:77:3-77:18 -selected=%s:80:3-80:18 -selected=%s:83:3-83:22 -selected=%s:86:3-86:23 -selected=%s:89:3-89:22 -selected=%s:92:3-92:22 -selected=%s:95:3-95:9 -selected=%s:99:3-100:14 %s | FileCheck --check-prefix=CHECK3 %s
// RUN: clang-refactor-test perform -action extract -selected=%s:68:3-68:14 -selected=%s:71:3-71:16 -selected=%s:74:3-74:27 -selected=%s:77:3-77:18 -selected=%s:80:3-80:18 -selected=%s:83:3-83:22 -selected=%s:86:3-86:23 -selected=%s:89:3-89:22 -selected=%s:92:3-92:22 -selected=%s:95:3-95:9 -selected=%s:99:3-100:14 %s -DUSECONST | FileCheck --check-prefix=CHECK4 %s
void takesConstRef(const int &x) { }
void callTakeRefAndConstRef(int x) {
takesRef(x);
takesConstRef(x);
// CHECK5: extracted(int &x) {\ntakesRef(x);\n takesConstRef(x);\n}
}
// RUN: clang-refactor-test perform -action extract -selected=%s:111:3-112:19 %s | FileCheck --check-prefix=CHECK5 %s
class PrivateInstanceVariablesCallRefs {
int x;
Rectangle r;
void callsTakeRef() {
takesRef(x);
// CHECK6: extracted(int &x) {\ntakesRef(x);\n}
// CHECK7: extracted(int x) {\ntakesRef(x);\n}
takesStructRef(r);
// CHECK6: extracted(Rectangle &r) {\ntakesStructRef(r);\n}
// CHECK7: extracted(const Rectangle &r) {\ntakesStructRef(r);\n}
takesRef(r.width);
// CHECK6: extracted(Rectangle &r) {\ntakesRef(r.width);\n}
// CHECK7: extracted(const Rectangle &r) {\ntakesRef(r.width);\n}
}
};
// RUN: clang-refactor-test perform -action extract -selected=%s:123:5-123:16 -selected=%s:126:5-126:22 -selected=%s:129:5-129:22 %s | FileCheck --check-prefix=CHECK6 %s
// RUN: clang-refactor-test perform -action extract -selected=%s:123:5-123:16 -selected=%s:126:5-126:22 -selected=%s:129:5-129:22 %s -DUSECONST | FileCheck --check-prefix=CHECK7 %s
void variableTakesConstRef(int x, Rectangle r) {
const int &y = x;
// CHECK8: extracted(int x) {\nconst int &y = x;\n}
const Rectangle &p = r;
// CHECK8: extracted(const Rectangle &r) {\nconst Rectangle &p = r;\n}
const int &z = r.width;
// CHECK8: extracted(const Rectangle &r) {\nconst int &z = r.width;\n}
}
// RUN: clang-refactor-test perform -action extract -selected=%s:139:3-139:19 -selected=%s:141:3-141:25 -selected=%s:143:3-143:25 %s | FileCheck --check-prefix=CHECK8 %s
class ClassWithMethod {
public:
int method() CONST { return 0; }
int operator + (int x) CONST { return x; }
};
void nonConstMethodCallImpliesNonConstReceiver(ClassWithMethod x) {
x.method();
// CHECK10: extracted(ClassWithMethod &x) {\nreturn x.method();\n}
// CHECK11: extracted(const ClassWithMethod &x) {\nreturn x.method();\n}
x.operator +(2);
// CHECK10: extracted(ClassWithMethod &x) {\nreturn x.operator +(2);\n}
// CHECK11: extracted(const ClassWithMethod &x) {\nreturn x.operator +(2);\n}
}
// RUN: clang-refactor-test perform -action extract -selected=%s:156:3-156:14 -selected=%s:159:3-159:18 %s | FileCheck --check-prefix=CHECK10 %s
// RUN: clang-refactor-test perform -action extract -selected=%s:156:3-156:14 -selected=%s:159:3-159:18 %s -DUSECONST | FileCheck --check-prefix=CHECK11 %s
void ignoreMethodCallsOnPointer(ClassWithMethod *x) {
x->method();
// CHECK12: extracted(ClassWithMethod *x) {\nreturn x->method();\n}
x->operator +(2);
// CHECK12: extracted(ClassWithMethod *x) {\nreturn x->operator +(2);\n}
}
// RUN: clang-refactor-test perform -action extract -selected=%s:168:3-168:13 -selected=%s:170:3-170:19 %s | FileCheck --check-prefix=CHECK12 %s
void takesRValueRef(int &&x) { }
void takesRValueStructRef(Rectangle &&r) { }
void callTakesRValueRef(int x) {
takesRValueRef(static_cast<int&&>(x));
// CHECK13: extracted(int &x) {\ntakesRValueRef(static_cast<int&&>(x));\n}
Rectangle r;
takesRValueStructRef((static_cast<Rectangle&&>(r)));
// CHECK13: extracted(Rectangle &r) {\ntakesRValueStructRef((static_cast<Rectangle&&>(r)));\n}
int &&y = static_cast<int&&>(r.height);
// CHECK13: extracted(Rectangle &r) {\nint &&y = static_cast<int&&>(r.height);\n}
}
// RUN: clang-refactor-test perform -action extract -selected=%s:180:3-180:20 -selected=%s:183:3-183:54 -selected=%s:185:3-185:41 %s | FileCheck --check-prefix=CHECK13 %s
void referencesInConditionalOperator(int x, int y) {
takesRef(x == 0 ? x : y);
// CHECK14: (int &x, int &y) {\ntakesRef(x == 0 ? x : y);\n}
// CHECK15: (int x, int y) {\ntakesRef(x == 0 ? x : y);\n}
Rectangle a, b;
takesStructRef(y == 0 ? (a) : b);
// CHECK14: (Rectangle &a, Rectangle &b, int y) {\ntakesStructRef(y == 0 ? (a) : b);\n}
// CHECK15: (const Rectangle &a, const Rectangle &b, int y) {\ntakesStructRef(y == 0 ? (a) : b);\n}
takesRef(x == 0 ? (a).width : (y == 0 ? y : b.height));
// CHECK14: (Rectangle &a, Rectangle &b, int x, int &y) {\ntakesRef(x == 0 ? (a).width : (y == 0 ? y : b.height));\n}
// CHECK15: (const Rectangle &a, const Rectangle &b, int x, int y) {\ntakesRef(x == 0 ? (a).width : (y == 0 ? y : b.height));\n}
takesRef((x == 0 ? a : (b)).width);
// CHECK14: (Rectangle &a, Rectangle &b, int x) {\ntakesRef((x == 0 ? a : (b)).width);\n}
// CHECK15: (const Rectangle &a, const Rectangle &b, int x) {\ntakesRef((x == 0 ? a : (b)).width);\n}
takesRef(x == 0 ? y : y);
// CHECK14: (int x, int &y) {\ntakesRef(x == 0 ? y : y);\n}
// CHECK15: (int x, int y) {\ntakesRef(x == 0 ? y : y);\n}
ClassWithMethod caller1, caller2;
(x == 0 ? caller1 : caller2).method();
// CHECK14: (ClassWithMethod &caller1, ClassWithMethod &caller2, int x) {\nreturn (x == 0 ? caller1 : caller2).method();\n}
// CHECK15: (const ClassWithMethod &caller1, const ClassWithMethod &caller2, int x) {\nreturn (x == 0 ? caller1 : caller2).method();\n}
}
// RUN: clang-refactor-test perform -action extract -selected=%s:192:3-192:27 -selected=%s:196:3-196:35 -selected=%s:199:3-199:57 -selected=%s:202:3-202:37 -selected=%s:205:3-205:27 -selected=%s:209:3-209:40 %s | FileCheck --check-prefix=CHECK14 %s
// RUN: clang-refactor-test perform -action extract -selected=%s:192:3-192:27 -selected=%s:196:3-196:35 -selected=%s:199:3-199:57 -selected=%s:202:3-202:37 -selected=%s:205:3-205:27 -selected=%s:209:3-209:40 %s -DUSECONST | FileCheck --check-prefix=CHECK15 %s
class PrivateInstanceVariablesConditionalOperatorRefs {
int x;
Rectangle r;
void callsTakeRef(int y) {
takesRef(y == 0 ? x : r.width);
}
};
// CHECK16: (Rectangle &r, int &x, int y) {\ntakesRef(y == 0 ? x : r.width);\n}
// RUN: clang-refactor-test perform -action extract -selected=%s:222:5-222:35 %s | FileCheck --check-prefix=CHECK16 %s
class ReferencesInCommaOperator {
int x;
void callsTakeRef(int y, Rectangle r) {
takesRef((x, y));
// CHECK17: (int x, int &y) {\ntakesRef((x, y));\n}
takesRef((y, x));
// CHECK17: (int &x, int y) {\ntakesRef((y, x));\n}
takesStructRef((takesValue(x), r));
// CHECK17: (Rectangle &r, int x) {\ntakesStructRef((takesValue(x), r));\n}
}
};
// RUN: clang-refactor-test perform -action extract -selected=%s:232:5-232:21 -selected=%s:234:5-234:21 -selected=%s:236:5-236:39 %s | FileCheck --check-prefix=CHECK17 %s
struct StaticMember {
static int staticMember;
};
void memberMustBeNonStaticField(StaticMember s) {
takesRef(s.staticMember);
// CHECK18: (const StaticMember &s) {\ntakesRef(s.staticMember);\n}
}
// RUN: clang-refactor-test perform -action extract -selected=%s:248:3-248:27 %s | FileCheck --check-prefix=CHECK18 %s
class ClassWithMethod2 {
public:
ClassWithMethod member;
};
class ClassWithMethod;
void nonConstMethodCallImpliesNonConstReceiver2(ClassWithMethod2 x) {
x.member.method();
// CHECK19: (ClassWithMethod2 &x) {\nreturn x.member.method();\n}
// CHECK20: (const ClassWithMethod2 &x) {\nreturn x.member.method();\n}
}
// RUN: clang-refactor-test perform -action extract -selected=%s:261:3-261:20 %s | FileCheck --check-prefix=CHECK19 %s
// RUN: clang-refactor-test perform -action extract -selected=%s:261:3-261:20 %s -DUSECONST | FileCheck --check-prefix=CHECK20 %s
class PrivateInstaceVariablesCallRefsBase {
int x;
};
class PrivateInstanceVariablesCallRefs2: public PrivateInstaceVariablesCallRefsBase {
int y;
Rectangle r;
void callsTakeRef() {
takesRef(this->x);
takesRef((this)->y);
takesRef(static_cast<PrivateInstaceVariablesCallRefsBase *>(this)->x);
takesRef((0, ((const_cast<PrivateInstanceVariablesCallRefs2 *>(this)->r.width))));
}
// CHECK21: (PrivateInstanceVariablesCallRefs2 &object) {\ntakesRef(object.x);\n}
// CHECK21: (PrivateInstanceVariablesCallRefs2 &object) {\ntakesRef((object).y);\n}
// CHECK21: (PrivateInstanceVariablesCallRefs2 &object) {\ntakesRef(static_cast<PrivateInstaceVariablesCallRefsBase *>(&object)->x);\n}
// CHECK21: (PrivateInstanceVariablesCallRefs2 &object) {\ntakesRef((0, ((const_cast<PrivateInstanceVariablesCallRefs2 *>(&object)->r.width))));\n}
};
// RUN: clang-refactor-test perform -action extract -selected=%s:277:5-277:22 -selected=%s:278:5-278:24 -selected=%s:279:5-279:74 -selected=%s:280:5-280:86 %s | FileCheck --check-prefix=CHECK21 %s
| 5,153 |
535 | # coding: utf-8
def controller(func):
def _controller(
query_arguments,
body_arguments,
get_query_argument,
get_body_argument
):
result = func(
query_arguments,
body_arguments,
get_query_argument,
get_body_argument
)
return result
return _controller
def controller_post(func):
def _controller(
query_arguments,
body_arguments,
get_query_argument,
get_body_argument
):
result = func(
query_arguments,
body_arguments,
get_query_argument,
get_body_argument
)
return result
return _controller
def controller_get(func):
def _controller(
query_arguments,
get_query_argument,
):
result = func(
query_arguments,
get_query_argument,
)
return result
return _controller | 531 |
892 | <gh_stars>100-1000
#!/usr/bin/python2.7
# xdelta3 - delta compression tools and library -*- Mode: C++ -*-
# Copyright 2016 <NAME>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import xdelta3
# the test data section is expected to be len('target')
source = 'source source input0 source source'
target = 'source source target source source'
#
#
print 'encode: basic ...'
result, patch = xdelta3.xd3_encode_memory(target, source, 50)
assert result == 0
assert len(patch) < len(source)
print 'encode: adler32 ...'
result, patch_adler32 = xdelta3.xd3_encode_memory(target, source, 50,
xdelta3.XD3_ADLER32)
assert result == 0
assert len(patch_adler32) < len(source)
assert len(patch_adler32) > len(patch)
print 'encode: secondary ...'
result, patch_djw = xdelta3.xd3_encode_memory(target, source, 50,
xdelta3.XD3_SEC_DJW)
assert result == 0
# secondary compression doesn't help
assert len(patch_djw) > len(patch)
print 'encode: exact ...'
result, ignore = xdelta3.xd3_encode_memory(target, source, len(patch))
assert result == 0
assert len(ignore) < len(source)
print 'encode: out of space ...'
result, ignore = xdelta3.xd3_encode_memory(target, source, len(patch) - 1)
assert result == 28
assert ignore == None
print 'encode: zero space ...'
result, ignore = xdelta3.xd3_encode_memory(target, source, 0)
assert result == 28
assert ignore == None
print 'encode: no source ...'
result, zdata = xdelta3.xd3_encode_memory(target, None, 50)
assert result == 0
assert len(zdata) > len(patch)
print 'encode: no input ...'
result, ignore = xdelta3.xd3_encode_memory(None, None, 50)
assert result != 0
print 'decode: basic ...'
result, target1 = xdelta3.xd3_decode_memory(patch, source, len(target))
assert result == 0
assert len(target1) == len(target)
assert target1 == target
print 'decode: out of space ...'
result, ignore = xdelta3.xd3_decode_memory(patch, source, len(target) - 1)
assert result == 28
assert ignore == None
print 'decode: zero space ...'
result, ignore = xdelta3.xd3_decode_memory(patch, source, 0)
assert result == 28
assert ignore == None
print 'decode: single byte error ...'
# a few expected single-byte errors, e.g., unused address cache bits, see
# xdelta3-test.h's single-bit error tests
extra_count = 4
noverify_count = 0
for corrupt_pos in range(len(patch_adler32)):
input = ''.join([j == corrupt_pos and '\xff' or patch_adler32[j]
for j in range(len(patch_adler32))])
result, ignore = xdelta3.xd3_decode_memory(input, source, len(target), 0)
assert result == -17712
assert ignore == None
# without adler32 verification, the error may be in the data section which
# in this case is 6 bytes 'target'
result, corrupt = xdelta3.xd3_decode_memory(input, source, len(target),
xdelta3.XD3_ADLER32_NOVER)
if result == 0:
noverify_count = noverify_count + 1
#print "got %s" % corrupt
#end
#end
assert noverify_count == len('target') + extra_count
print 'decode: no source ...'
result, target2 = xdelta3.xd3_decode_memory(zdata, None, len(target))
assert result == 0
assert target == target2
# Test compression level setting via flags. assumes a 9 byte checksum
# and that level 9 steps 2, level 1 steps 15:
# 01234567890123456789012345678901
# level 1 only indexes 2 checksums "abcdefghi" and "ABCDEFGHI"
# outputs 43 vs. 23 bytes
print 'encode: compression level ...'
source = '_la_la_abcdefghi_la_la_ABCDEFGHI'
target = 'la_la_ABCDEFGH__la_la_abcdefgh__'
result1, level1 = xdelta3.xd3_encode_memory(target, source, 50, xdelta3.XD3_COMPLEVEL_1)
result9, level9 = xdelta3.xd3_encode_memory(target, source, 50, xdelta3.XD3_COMPLEVEL_9)
assert result1 == 0 and result9 == 0
assert len(level1) > len(level9)
#
# Issue 65
print 'encode: 65 ...'
source = 'Hello World'
target = 'Hello everyone'
result, patch = xdelta3.xd3_encode_memory(target, source, len(target))
assert result != 0
result, patch = xdelta3.xd3_encode_memory(target, source, 2 * len(target))
assert result == 0
print 'PASS'
| 1,747 |
807 | {
"ConnectionStrings": {
"Default": "Server=(LocalDb)\\MSSQLLocalDB;Database=BookStore;Trusted_Connection=True",
"AbpPermissionManagement": "Server=(LocalDb)\\MSSQLLocalDB;Database=BookStore_SecondDb;Trusted_Connection=True",
"AbpSettingManagement": "Server=(LocalDb)\\MSSQLLocalDB;Database=BookStore_SecondDb;Trusted_Connection=True",
"AbpAuditLogging": "Server=(LocalDb)\\MSSQLLocalDB;Database=BookStore_SecondDb;Trusted_Connection=True"
},
"IdentityServer": {
"Clients": {
"BookStore_Web": {
"ClientId": "BookStore_Web",
"ClientSecret": "<KEY>
"RootUrl": "https://localhost:44332"
},
"BookStore_App": {
"ClientId": "BookStore_App",
"ClientSecret": "<KEY>
"RootUrl": "http://localhost:4200"
},
"BookStore_BlazorServerTiered": {
"ClientId": "BookStore_BlazorServerTiered",
"ClientSecret": "<KEY>
"RootUrl": "https://localhost:44314"
},
"BookStore_Swagger": {
"ClientId": "BookStore_Swagger",
"ClientSecret": "<KEY>
"RootUrl": "https://localhost:44399"
}
}
}
} | 496 |
398 | <filename>joyrpc-extension/joyrpc-extension-core/src/main/java/io/joyrpc/extension/AbstractParametric.java
/**
*
*/
package io.joyrpc.extension;
/*-
* #%L
* joyrpc
* %%
* Copyright (C) 2019 joyrpc.io
* %%
* 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.
* #L%
*/
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* 抽象参数
*/
public abstract class AbstractParametric implements Parametric {
@Override
public String getString(final String key) {
Object target = getObject(key);
return target == null ? null : target.toString();
}
@Override
public String getString(final String key, final String def) {
String value = getString(key);
if (value == null || value.isEmpty()) {
return def;
}
return value;
}
@Override
public String getString(final String key, final String candidate, final String def) {
String value = getString(key);
if (value == null || value.isEmpty()) {
value = getString(candidate, def);
}
return value;
}
@Override
public String getString(final URLOption<String> option) {
return option == null ? null : getString(option.getName(), option.getValue());
}
@Override
public String getString(final URLBiOption<String> option) {
return option == null ? null : getString(option.getName(), option.getCandidate(), option.getValue());
}
@Override
public Date getDate(final String key, final Date def) {
return Converts.getDate(getString(key), def);
}
@Override
public Date getDate(final String key, final SimpleDateFormat format) {
return Converts.getDate(getString(key), format, null);
}
@Override
public Date getDate(final String key, final SimpleDateFormat format, final Date def) {
return Converts.getDate(getString(key), format, def);
}
@Override
public Date getDate(final String key, final DateParser parser, final Date def) {
return Converts.getDate(getObject(key), parser, def);
}
@Override
public Float getFloat(final String key) {
return Converts.getFloat(getString(key), null);
}
@Override
public Float getFloat(final String key, final Float def) {
return Converts.getFloat(getString(key), def);
}
@Override
public Float getFloat(final String key, final String candidate, final Float def) {
Float result = getFloat(key);
return result != null ? result : getFloat(candidate, def);
}
@Override
public Float getFloat(final URLOption<Float> option) {
return option == null ? null : getFloat(option.getName(), option.getValue());
}
@Override
public Float getFloat(final URLBiOption<Float> option) {
return option == null ? null : getFloat(option.getName(), option.getCandidate(), option.getValue());
}
@Override
public Double getDouble(final String key) {
return Converts.getDouble(getString(key), null);
}
@Override
public Double getDouble(final String key, final String candidate, final Double def) {
Double result = getDouble(key);
return result != null ? result : getDouble(candidate, def);
}
@Override
public Double getDouble(final String key, final Double def) {
return Converts.getDouble(getString(key), def);
}
@Override
public Double getDouble(final URLOption<Double> option) {
return option == null ? null : getDouble(option.getName(), option.getValue());
}
@Override
public Double getDouble(final URLBiOption<Double> option) {
if (option == null) {
return null;
}
Double result = getDouble(option.getName());
if (result == null) {
result = getDouble(option.getCandidate(), option.getValue());
}
return result;
}
@Override
public Long getLong(final String key) {
return Converts.getLong(getString(key), null);
}
@Override
public Long getLong(final String key, final String candidate, final Long def) {
Long result = getLong(key);
return result != null ? result : getLong(candidate, def);
}
@Override
public Long getLong(final String key, final Long def) {
return Converts.getLong(getString(key), def);
}
@Override
public Long getLong(final URLOption<Long> option) {
return option == null ? null : getLong(option.getName(), option.getValue());
}
@Override
public Long getLong(final URLBiOption<Long> option) {
return option == null ? null : getLong(option.getName(), option.getCandidate(), option.getValue());
}
@Override
public Integer getInteger(final String key) {
return Converts.getInteger(getString(key), null);
}
@Override
public Integer getInteger(final String key, final Integer def) {
return Converts.getInteger(getString(key), def);
}
@Override
public Integer getInteger(final String key, final String candidate, final Integer def) {
Integer result = getInteger(key);
return result != null ? result : getInteger(candidate, def);
}
@Override
public Integer getInteger(final URLOption<Integer> option) {
return option == null ? null : getInteger(option.getName(), option.getValue());
}
@Override
public Integer getInteger(final URLBiOption<Integer> option) {
return option == null ? null : getInteger(option.getName(), option.getCandidate(), option.getValue());
}
@Override
public Short getShort(final String key) {
return Converts.getShort(getString(key), null);
}
@Override
public Short getShort(final String key, final Short def) {
return Converts.getShort(getString(key), def);
}
@Override
public Short getShort(final String key, final String candidate, final Short def) {
Short result = getShort(key);
return result != null ? result : getShort(candidate, def);
}
@Override
public Short getShort(final URLOption<Short> option) {
return option == null ? null : getShort(option.getName(), option.getValue());
}
@Override
public Short getShort(final URLBiOption<Short> option) {
return option == null ? null : getShort(option.getName(), option.getCandidate(), option.getValue());
}
@Override
public Byte getByte(final String key) {
return Converts.getByte(getString(key), null);
}
@Override
public Byte getByte(final String key, final Byte def) {
return Converts.getByte(getString(key), def);
}
@Override
public Byte getByte(final String key, final String candidate, final Byte def) {
Byte result = getByte(key);
return result != null ? result : getByte(candidate, def);
}
@Override
public Byte getByte(final URLOption<Byte> option) {
return option == null ? null : getByte(option.getName(), option.getValue());
}
@Override
public Byte getByte(final URLBiOption<Byte> option) {
return option == null ? null : getByte(option.getName(), option.getCandidate(), option.getValue());
}
@Override
public Boolean getBoolean(final String key) {
return Converts.getBoolean(getString(key), null);
}
@Override
public Boolean getBoolean(final String key, final Boolean def) {
return Converts.getBoolean(getString(key), def);
}
@Override
public Boolean getBoolean(final String key, final String candidate, final Boolean def) {
Boolean result = getBoolean(key);
return result != null ? result : getBoolean(candidate, def);
}
@Override
public Boolean getBoolean(final URLOption<Boolean> option) {
return option == null ? null : getBoolean(option.getName(), option.getValue());
}
@Override
public Boolean getBoolean(final URLBiOption<Boolean> option) {
return option == null ? null : getBoolean(option.getName(), option.getCandidate(), option.getValue());
}
@Override
public Long getNatural(final String key, final Long def) {
return Converts.getNatural(getString(key), def);
}
@Override
public Long getNatural(final String key, final String candidate, final Long def) {
Long result = getNatural(key, (Long) null);
return result != null ? result : getNatural(candidate, def);
}
@Override
public Long getNaturalLong(final URLOption<Long> option) {
return option == null ? null : getNatural(option.getName(), option.getValue());
}
@Override
public Long getNaturalLong(final URLBiOption<Long> option) {
return option == null ? null : getNatural(option.getName(), option.getCandidate(), option.getValue());
}
@Override
public Integer getNatural(final String key, final Integer def) {
return Converts.getNatural(getString(key), def);
}
@Override
public Integer getNatural(final String key, final String candidate, final Integer def) {
Integer result = getNatural(key, (Integer) null);
return result != null ? result : getNatural(candidate, def);
}
@Override
public Integer getNaturalInt(final URLOption<Integer> option) {
return option == null ? null : getNatural(option.getName(), option.getValue());
}
@Override
public Integer getNaturalInt(final URLBiOption<Integer> option) {
return option == null ? null : getNatural(option.getName(), option.getCandidate(), option.getValue());
}
@Override
public Short getNatural(final String key, final Short def) {
return Converts.getNatural(getString(key), def);
}
@Override
public Short getNatural(final String key, final String candidate, final Short def) {
Short result = getNatural(key, (Short) null);
return result != null ? result : getNatural(key, def);
}
@Override
public Short getNaturalShort(final URLOption<Short> option) {
return option == null ? null : getNatural(option.getName(), option.getValue());
}
@Override
public Short getNaturalShort(final URLBiOption<Short> option) {
return option == null ? null : getNatural(option.getName(), option.getCandidate(), option.getValue());
}
@Override
public Byte getNatural(final String key, final Byte def) {
return Converts.getNatural(getString(key), def);
}
@Override
public Byte getNatural(final String key, final String candidate, final Byte def) {
Byte result = getNatural(key, (Byte) null);
return result != null ? result : getNatural(candidate, def);
}
@Override
public Byte getNaturalByte(final URLOption<Byte> option) {
return option == null ? null : getNatural(option.getName(), option.getValue());
}
@Override
public Byte getNaturalByte(final URLBiOption<Byte> option) {
return option == null ? null : getNatural(option.getName(), option.getCandidate(), option.getValue());
}
@Override
public Long getPositive(final String key, final Long def) {
return Converts.getPositive(getString(key), def);
}
@Override
public Long getPositive(final String key, final String candidate, final Long def) {
Long result = getPositive(key, (Long) null);
return result != null ? result : getPositive(candidate, def);
}
@Override
public Long getPositiveLong(final URLOption<Long> option) {
return option == null ? null : getPositive(option.getName(), option.getValue());
}
@Override
public Long getPositiveLong(final URLBiOption<Long> option) {
return option == null ? null : getPositive(option.getName(), option.getCandidate(), option.getValue());
}
@Override
public Integer getPositive(final String key, final Integer def) {
return Converts.getPositive(getString(key), def);
}
@Override
public Integer getPositive(final String key, final String candidate, final Integer def) {
Integer result = getPositive(key, (Integer) null);
return result != null ? result : getPositive(candidate, def);
}
@Override
public Integer getPositiveInt(final URLOption<Integer> option) {
return option == null ? null : getPositive(option.getName(), option.getValue());
}
@Override
public Integer getPositiveInt(final URLBiOption<Integer> option) {
return option == null ? null : getPositive(option.getName(), option.getCandidate(), option.getValue());
}
@Override
public Short getPositive(final String key, final Short def) {
return Converts.getPositive(getString(key), def);
}
@Override
public Short getPositive(final String key, final String candidate, final Short def) {
Short result = getPositive(key, (Short) null);
return result != null ? result : getPositive(candidate, def);
}
@Override
public Short getPositiveShort(final URLOption<Short> option) {
return option == null ? null : getPositive(option.getName(), option.getValue());
}
@Override
public Short getPositiveShort(final URLBiOption<Short> option) {
return option == null ? null : getPositive(option.getName(), option.getCandidate(), option.getValue());
}
@Override
public Byte getPositive(final String key, final Byte def) {
return Converts.getPositive(getString(key), def);
}
@Override
public Byte getPositive(final String key, final String candidate, final Byte def) {
Byte result = getPositive(key, (Byte) null);
return result != null ? result : getPositive(candidate, def);
}
@Override
public Byte getPositiveByte(final URLOption<Byte> option) {
return option == null ? null : getPositive(option.getName(), option.getValue());
}
@Override
public Byte getPositiveByte(final URLBiOption<Byte> option) {
return option == null ? null : getPositive(option.getName(), option.getCandidate(), option.getValue());
}
}
| 5,082 |
905 | import binascii
from malwareconfig import crypto
from malwareconfig.common import Decoder
from malwareconfig.common import string_printable
class BlueBanana(Decoder):
decoder_name = "BlueBanana"
decoder__version = 1
decoder_author = "@kevthehermit"
decoder_description = "Decoder for Blue Banana"
def __init__(self):
self.config = {}
def get_config(self):
'''
This is the main entry
:return:
'''
key1 = '<KEY>'
key2 = '<KEY>'
crypted_config = self.file_info.file_from_zip('config.txt')
first_round = crypto.decrypt_aes(key1, binascii.unhexlify(crypted_config))
clear_config = crypto.decrypt_aes(key2, binascii.unhexlify(first_round[:-16]))
fields = clear_config.decode('utf-8').split("<separator>")
config_dict = {'Domain': fields[0],
'Password': fields[1],
'Port1': fields[2],
'Port2': fields[3]
}
if len(fields) > 4:
config_dict['InstallName'] = fields[4]
config_dict['JarName'] = fields[5]
# Set the config to the class for use
self.config = config_dict
| 577 |
20,453 | <gh_stars>1000+
import os
ref_dir = os.path.join(os.path.dirname(__file__))
__all__ = sorted(f[:-3] for f in os.listdir(ref_dir) if f.endswith('.py') and
not f.startswith('__'))
for f in __all__:
__import__(__name__ + '.' + f)
del f, ref_dir
__doc__ = """\
Topical documentation
=====================
The following topics are available:
%s
You can view them by
>>> help(np.doc.TOPIC) #doctest: +SKIP
""" % '\n- '.join([''] + __all__)
__all__.extend(['__doc__'])
| 249 |
1,507 | <reponame>abitrolly/hashids.js<filename>package.json
{
"author": "hashids.org <<EMAIL>> (https://github.com/hashids)",
"name": "hashids",
"description": "Generate YouTube-like ids from numbers. Use Hashids when you do not want to expose your database ids to the user.",
"contributors": [
{
"name": "<NAME>",
"email": "<EMAIL>",
"url": "https://twitter.com/IvanAkimov"
},
{
"name": "<NAME>",
"email": "<EMAIL>",
"url": "https://twitter.com/niieani"
}
],
"version": "0.0.0-development",
"homepage": "http://hashids.org/javascript",
"repository": {
"type": "git",
"url": "https://github.com/niieani/hashids.js.git"
},
"bugs": {
"url": "https://github.com/niieani/hashids.js/issues"
},
"files": [
"cjs",
"esm",
"dist",
"lib"
],
"main": "cjs/index.js",
"module": "esm/index.js",
"exports": {
".": {
"import": "./esm/index.js",
"require": "./cjs/index.js"
},
"./cjs": {
"require": "./cjs/index.js"
},
"./cjs/": {
"require": "./cjs/"
},
"./esm/": {
"import": "./esm/"
},
"./package.json": "./package.json"
},
"scripts": {
"lint": "eslint lib/* tests/*",
"prettier:check": "prettier --check lib/* tests*/*",
"prettier:write": "prettier --write lib/* tests*/*",
"test": "yarn prettier:check && yarn lint && yarn jest",
"coverage": "jest --coverage && cat coverage/lcov.info | coveralls",
"build:umd": "babel lib/hashids.ts --source-maps -o dist/hashids.js && replace-in-files --string='global.Hashids = mod.exports;' --replacement='global.Hashids = mod.exports.default;' dist/hashids.js",
"build:esm": "BABEL_MODULES=1 babel lib/hashids.ts --source-maps -o esm/index.js",
"minify": "cd dist && terser hashids.js -o hashids.min.js --source-map \"url=hashids.min.js.map\" --compress --mangle",
"build": "yarn run build:umd && yarn run build:esm && yarn run minify",
"clean": "rm -rf coverage yarn-debug.log",
"all": "yarn run lint && yarn run coverage && yarn run build && yarn run clean",
"release": "./release.sh",
"semantic-release": "semantic-release",
"benchmark": "yarn ts-node -O '{\"module\": \"commonjs\"}' -T tests/benchmark"
},
"husky": {
"hooks": {
"pre-commit": "yarn run lint && yarn run test"
}
},
"browserslist": [
"last 2 version",
"> 0.5%",
"maintained node versions",
"not dead"
],
"devDependencies": {
"@babel/cli": "^7.13.10",
"@babel/core": "^7.13.10",
"@babel/helper-plugin-utils": "^7.13.0",
"@babel/plugin-syntax-bigint": "^7.8.3",
"@babel/plugin-transform-destructuring": "^7.13.0",
"@babel/plugin-transform-modules-umd": "^7.13.0",
"@babel/plugin-transform-spread": "^7.13.0",
"@babel/preset-env": "^7.13.10",
"@babel/preset-typescript": "^7.13.0",
"@babel/register": "^7.13.8",
"@types/jest": "^26.0.21",
"@types/node": "^14.14.35",
"@typescript-eslint/eslint-plugin": "^4.18.0",
"@typescript-eslint/parser": "^4.18.0",
"@yarnpkg/pnpify": "^2.4.0",
"coveralls": "^3.1.0",
"eslint": "^7.22.0",
"eslint-config-prettier": "^8.1.0",
"eslint-import-resolver-node": "^0.3.4",
"eslint-plugin-eslint-comments": "^3.2.0",
"eslint-plugin-import": "^2.22.1",
"eslint-plugin-jest": "^24.3.2",
"husky": "^5.1.3",
"jest": "^26.6.3",
"nodemark": "^0.3.0",
"prettier": "^2.2.1",
"replace-in-files-cli": "^1.0.0",
"require-from-web": "^1.2.0",
"semantic-release": "^17.4.2",
"terser": "^5.6.1",
"ts-node": "^9.1.1",
"typescript": "^4.2.3"
},
"license": "MIT",
"keywords": [
"hashids",
"hashid",
"hash",
"ids",
"youtube",
"bitly",
"obfuscate",
"encode",
"decode",
"encrypt",
"decrypt"
],
"prettier": {
"semi": false,
"tabWidth": 2,
"singleQuote": true,
"trailingComma": "all",
"arrowParens": "always",
"bracketSpacing": false
},
"jest": {
"collectCoverageFrom": [
"lib/**/*.ts"
]
}
}
| 1,948 |
344 | <reponame>ilya-fedin/tg_owt
/*
* Copyright (c) 2020 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "modules/video_coding/svc/scalability_structure_full_svc.h"
#include <vector>
#include "modules/video_coding/svc/scalability_structure_test_helpers.h"
#include "test/gmock.h"
#include "test/gtest.h"
namespace webrtc {
namespace {
using ::testing::IsEmpty;
using ::testing::SizeIs;
TEST(ScalabilityStructureL3T3Test, SkipS1T1FrameKeepsStructureValid) {
ScalabilityStructureL3T3 structure;
ScalabilityStructureWrapper wrapper(structure);
structure.OnRatesUpdated(EnableTemporalLayers(/*s0=*/3, /*s1=*/3));
auto frames = wrapper.GenerateFrames(/*num_temporal_units=*/1);
EXPECT_THAT(frames, SizeIs(2));
EXPECT_EQ(frames[0].temporal_id, 0);
frames = wrapper.GenerateFrames(/*num_temporal_units=*/1);
EXPECT_THAT(frames, SizeIs(2));
EXPECT_EQ(frames[0].temporal_id, 2);
structure.OnRatesUpdated(EnableTemporalLayers(/*s0=*/3, /*s1=*/0));
frames = wrapper.GenerateFrames(/*num_temporal_units=*/1);
EXPECT_THAT(frames, SizeIs(1));
EXPECT_EQ(frames[0].temporal_id, 1);
structure.OnRatesUpdated(EnableTemporalLayers(/*s0=*/3, /*s1=*/3));
// Rely on checks inside GenerateFrames frame references are valid.
frames = wrapper.GenerateFrames(/*num_temporal_units=*/1);
EXPECT_THAT(frames, SizeIs(2));
EXPECT_EQ(frames[0].temporal_id, 2);
}
TEST(ScalabilityStructureL3T3Test, SkipT1FrameByEncoderKeepsReferencesValid) {
std::vector<GenericFrameInfo> frames;
ScalabilityStructureL3T3 structure;
ScalabilityStructureWrapper wrapper(structure);
// 1st 2 temporal units (T0 and T2)
wrapper.GenerateFrames(/*num_temporal_units=*/2, frames);
// Simulate T1 frame dropped by the encoder,
// i.e. retrieve config, but skip calling OnEncodeDone.
structure.NextFrameConfig(/*restart=*/false);
// one more temporal units (T2)
wrapper.GenerateFrames(/*num_temporal_units=*/1, frames);
EXPECT_TRUE(wrapper.FrameReferencesAreValid(frames));
}
TEST(ScalabilityStructureL3T3Test,
SkippingFrameReusePreviousFrameConfiguration) {
std::vector<GenericFrameInfo> frames;
ScalabilityStructureL3T3 structure;
ScalabilityStructureWrapper wrapper(structure);
// 1st 2 temporal units (T0 and T2)
wrapper.GenerateFrames(/*num_temporal_units=*/2, frames);
ASSERT_THAT(frames, SizeIs(6));
ASSERT_EQ(frames[0].temporal_id, 0);
ASSERT_EQ(frames[3].temporal_id, 2);
// Simulate a frame dropped by the encoder,
// i.e. retrieve config, but skip calling OnEncodeDone.
structure.NextFrameConfig(/*restart=*/false);
// two more temporal unit, expect temporal pattern continues
wrapper.GenerateFrames(/*num_temporal_units=*/2, frames);
ASSERT_THAT(frames, SizeIs(12));
// Expect temporal pattern continues as if there were no dropped frames.
EXPECT_EQ(frames[6].temporal_id, 1);
EXPECT_EQ(frames[9].temporal_id, 2);
}
TEST(ScalabilityStructureL3T3Test, SwitchSpatialLayerBeforeT1Frame) {
ScalabilityStructureL3T3 structure;
ScalabilityStructureWrapper wrapper(structure);
structure.OnRatesUpdated(EnableTemporalLayers(/*s0=*/2, /*s1=*/0));
EXPECT_THAT(wrapper.GenerateFrames(1), SizeIs(1));
structure.OnRatesUpdated(EnableTemporalLayers(/*s0=*/0, /*s1=*/2));
auto frames = wrapper.GenerateFrames(1);
ASSERT_THAT(frames, SizeIs(1));
EXPECT_THAT(frames[0].frame_diffs, IsEmpty());
EXPECT_EQ(frames[0].temporal_id, 0);
}
} // namespace
} // namespace webrtc
| 1,337 |
1,291 | <gh_stars>1000+
# 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.
"""Givens rotations routines."""
import numpy
from openfermion.config import EQ_TOLERANCE
def givens_matrix_elements(a, b, which='left'):
"""Compute the matrix elements of the Givens rotation that zeroes out one
of two row entries.
If `which='left'` then returns a matrix G such that
G * [a b]^T= [0 r]^T
otherwise, returns a matrix G such that
G * [a b]^T= [r 0]^T
where r is a complex number.
Args:
a(complex or float): A complex number representing the upper row entry
b(complex or float): A complex number representing the lower row entry
which(string): Either 'left' or 'right', indicating whether to
zero out the left element (first argument) or right element
(second argument). Default is `left`.
Returns:
G(ndarray): A 2 x 2 numpy array representing the matrix G.
The numbers in the first column of G are real.
"""
# Handle case that a is zero
if abs(a) < EQ_TOLERANCE:
cosine = 1.
sine = 0.
phase = 1.
# Handle case that b is zero and a is nonzero
elif abs(b) < EQ_TOLERANCE:
cosine = 0.
sine = 1.
phase = 1.
# Handle case that a and b are both nonzero
else:
denominator = numpy.sqrt(abs(a)**2 + abs(b)**2)
cosine = abs(b) / denominator
sine = abs(a) / denominator
sign_b = b / abs(b)
sign_a = a / abs(a)
phase = sign_a * sign_b.conjugate()
# If phase is a real number, convert it to a float
if numpy.isreal(phase):
phase = numpy.real(phase)
# Construct matrix and return
if which == 'left':
# We want to zero out a
if (abs(numpy.imag(a)) < EQ_TOLERANCE and
abs(numpy.imag(b)) < EQ_TOLERANCE):
# a and b are real, so return a standard rotation matrix
givens_rotation = numpy.array([[cosine, -phase * sine],
[phase * sine, cosine]])
else:
givens_rotation = numpy.array([[cosine, -phase * sine],
[sine, phase * cosine]])
elif which == 'right':
# We want to zero out b
if (abs(numpy.imag(a)) < EQ_TOLERANCE and
abs(numpy.imag(b)) < EQ_TOLERANCE):
# a and b are real, so return a standard rotation matrix
givens_rotation = numpy.array([[sine, phase * cosine],
[-phase * cosine, sine]])
else:
givens_rotation = numpy.array([[sine, phase * cosine],
[cosine, -phase * sine]])
else:
raise ValueError('"which" must be equal to "left" or "right".')
return givens_rotation
def givens_rotate(operator, givens_rotation, i, j, which='row'):
"""Apply a Givens rotation to coordinates i and j of an operator."""
if which == 'row':
# Rotate rows i and j
row_i = operator[i].copy()
row_j = operator[j].copy()
operator[i] = (givens_rotation[0, 0] * row_i +
givens_rotation[0, 1] * row_j)
operator[j] = (givens_rotation[1, 0] * row_i +
givens_rotation[1, 1] * row_j)
elif which == 'col':
# Rotate columns i and j
col_i = operator[:, i].copy()
col_j = operator[:, j].copy()
operator[:, i] = (givens_rotation[0, 0] * col_i +
givens_rotation[0, 1].conj() * col_j)
operator[:, j] = (givens_rotation[1, 0] * col_i +
givens_rotation[1, 1].conj() * col_j)
else:
raise ValueError('"which" must be equal to "row" or "col".')
def double_givens_rotate(operator, givens_rotation, i, j, which='row'):
"""Apply a double Givens rotation.
Applies a Givens rotation to coordinates i and j and the the conjugate
Givens rotation to coordinates n + i and n + j, where
n = dim(operator) / 2. dim(operator) must be even.
"""
m, p = operator.shape
if which == 'row':
if m % 2 != 0:
raise ValueError('To apply a double Givens rotation on rows, '
'the number of rows must be even.')
n = m // 2
# Rotate rows i and j
givens_rotate(operator[:n], givens_rotation, i, j, which='row')
# Rotate rows n + i and n + j
givens_rotate(operator[n:], givens_rotation.conj(), i, j, which='row')
elif which == 'col':
if p % 2 != 0:
raise ValueError('To apply a double Givens rotation on columns, '
'the number of columns must be even.')
n = p // 2
# Rotate columns i and j
givens_rotate(operator[:, :n], givens_rotation, i, j, which='col')
# Rotate cols n + i and n + j
givens_rotate(operator[:, n:],
givens_rotation.conj(),
i,
j,
which='col')
else:
raise ValueError('"which" must be equal to "row" or "col".')
def givens_decomposition_square(unitary_matrix, always_insert=False):
r"""Decompose a square matrix into a sequence of Givens rotations.
The input is a square $n \times n$ matrix $Q$.
$Q$ can be decomposed as follows:
$$
Q = DU
$$
where $U$ is unitary and $D$ is diagonal.
Furthermore, we can decompose $U$ as
$$
U = G_k ... G_1
$$
where $G_1, \ldots, G_k$ are complex Givens rotations.
A Givens rotation is a rotation within the two-dimensional subspace
spanned by two coordinate axes. Within the two relevant coordinate
axes, a Givens rotation has the form
$$
\begin{pmatrix}
\cos(\theta) & -e^{i \varphi} \sin(\theta) \\
\sin(\theta) & e^{i \varphi} \cos(\theta)
\end{pmatrix}.
$$
Args:
unitary_matrix: A numpy array with orthonormal rows,
representing the matrix Q.
Returns
-------
decomposition (list[tuple]):
A list of tuples of objects describing Givens
rotations. The list looks like [(G_1, ), (G_2, G_3), ... ].
The Givens rotations within a tuple can be implemented in parallel.
The description of a Givens rotation is itself a tuple of the
form $(i, j, \theta, \varphi)$, which represents a
Givens rotation of coordinates
$i$ and $j$ by angles $\theta$ and
$\varphi$.
diagonal (ndarray):
A list of the nonzero entries of $D$.
"""
current_matrix = numpy.copy(unitary_matrix)
n = current_matrix.shape[0]
decomposition = []
for k in range(2 * (n - 1) - 1):
# Initialize the list of parallel operations to perform
# in this iteration
parallel_ops = []
# Get the (row, column) indices of elements to zero out in parallel.
if k < n - 1:
start_row = 0
start_column = n - 1 - k
else:
start_row = k - (n - 2)
start_column = k - (n - 3)
column_indices = range(start_column, n, 2)
row_indices = range(start_row, start_row + len(column_indices))
indices_to_zero_out = zip(row_indices, column_indices)
for i, j in indices_to_zero_out:
# Compute the Givens rotation to zero out the (i, j) element,
# if needed
right_element = current_matrix[i, j].conj()
if always_insert or abs(right_element) > EQ_TOLERANCE:
# We actually need to perform a Givens rotation
left_element = current_matrix[i, j - 1].conj()
givens_rotation = givens_matrix_elements(left_element,
right_element,
which='right')
# Add the parameters to the list
theta = numpy.arcsin(numpy.real(givens_rotation[1, 0]))
phi = numpy.angle(givens_rotation[1, 1])
parallel_ops.append((j - 1, j, theta, phi))
# Update the matrix
givens_rotate(current_matrix,
givens_rotation,
j - 1,
j,
which='col')
# If the current list of parallel operations is not empty,
# append it to the list,
if parallel_ops:
decomposition.append(tuple(parallel_ops))
# Get the diagonal entries
diagonal = current_matrix[range(n), range(n)]
return decomposition, diagonal
def givens_decomposition(unitary_rows, always_insert=False):
r"""Decompose a matrix into a sequence of Givens rotations.
The input is an $m \times n$ matrix $Q$ with $m \leq n$.
The rows of $Q$ are orthonormal.
$Q$ can be decomposed as follows:
$$
V Q U^\dagger = D
$$
where $V$ and $U$ are unitary matrices, and $D$
is an $m \times n$ matrix with the
first $m$ columns forming a diagonal matrix and the rest of the
columns being zero. Furthermore, we can decompose $U$ as
$$
U = G_k ... G_1
$$
where $G_1, \ldots, G_k$ are complex Givens rotations.
A Givens rotation is a rotation within the two-dimensional subspace
spanned by two coordinate axes. Within the two relevant coordinate
axes, a Givens rotation has the form
$$
\begin{pmatrix}
\cos(\theta) & -e^{i \varphi} \sin(\theta) \\
\sin(\theta) & e^{i \varphi} \cos(\theta)
\end{pmatrix}.
$$
Args:
unitary_rows: A numpy array or matrix with orthonormal rows,
representing the matrix Q.
Returns
-------
givens_rotations (list[tuple]):
A list of tuples of objects describing Givens
rotations. The list looks like [(G_1, ), (G_2, G_3), ... ].
The Givens rotations within a tuple can be implemented in parallel.
The description of a Givens rotation is itself a tuple of the
form $(i, j, \theta, \varphi)$, which represents a
Givens rotation of coordinates
$i$ and $j$ by angles $\theta$ and
$\varphi$.
left_unitary (ndarray):
An $m \times m$ numpy array representing the matrix
$V$.
diagonal (ndarray):
A list of the nonzero entries of $D$.
"""
current_matrix = numpy.copy(unitary_rows)
m, n = current_matrix.shape
# Check that m <= n
if m > n:
raise ValueError('The input m x n matrix must have m <= n')
# Compute left_unitary using Givens rotations
left_unitary = numpy.eye(m, dtype=complex)
for k in reversed(range(n - m + 1, n)):
# Zero out entries in column k
for l in range(m - n + k):
# Zero out entry in row l if needed
if abs(current_matrix[l, k]) > EQ_TOLERANCE:
givens_rotation = givens_matrix_elements(
current_matrix[l, k], current_matrix[l + 1, k])
# Apply Givens rotation
givens_rotate(current_matrix, givens_rotation, l, l + 1)
givens_rotate(left_unitary, givens_rotation, l, l + 1)
# Compute the decomposition of current_matrix into Givens rotations
givens_rotations = []
# If m = n (the matrix is square) then we don't need to perform any
# Givens rotations!
if m != n:
# Get the maximum number of simultaneous rotations that
# will be performed
max_simul_rotations = min(m, n - m)
# There are n - 1 iterations (the circuit depth is n - 1)
for k in range(n - 1):
# Get the (row, column) indices of elements to zero out in
# parallel.
if k < max_simul_rotations - 1:
# There are k + 1 elements to zero out
start_row = 0
end_row = k + 1
start_column = n - m - k
end_column = start_column + 2 * (k + 1)
elif k > n - 1 - max_simul_rotations:
# There are n - 1 - k elements to zero out
start_row = m - (n - 1 - k)
end_row = m
start_column = m - (n - 1 - k) + 1
end_column = start_column + 2 * (n - 1 - k)
else:
# There are max_simul_rotations elements to zero out
if max_simul_rotations == m:
start_row = 0
end_row = m
start_column = n - m - k
end_column = start_column + 2 * m
else:
start_row = k + 1 - max_simul_rotations
end_row = k + 1
start_column = k + 1 - max_simul_rotations + 1
end_column = start_column + 2 * max_simul_rotations
row_indices = range(start_row, end_row)
column_indices = range(start_column, end_column, 2)
indices_to_zero_out = zip(row_indices, column_indices)
parallel_rotations = []
for i, j in indices_to_zero_out:
# Compute the Givens rotation to zero out the (i, j) element,
# if needed
right_element = current_matrix[i, j].conj()
if always_insert or abs(right_element) > EQ_TOLERANCE:
# We actually need to perform a Givens rotation
left_element = current_matrix[i, j - 1].conj()
givens_rotation = givens_matrix_elements(left_element,
right_element,
which='right')
# Add the parameters to the list
theta = numpy.arcsin(numpy.real(givens_rotation[1, 0]))
phi = numpy.angle(givens_rotation[1, 1])
parallel_rotations.append((j - 1, j, theta, phi))
# Update the matrix
givens_rotate(current_matrix,
givens_rotation,
j - 1,
j,
which='col')
# If the current list of parallel operations is not empty,
# append it to the list,
if parallel_rotations:
givens_rotations.append(tuple(parallel_rotations))
# Get the diagonal entries
diagonal = current_matrix.diagonal()
return givens_rotations, left_unitary, diagonal
def fermionic_gaussian_decomposition(unitary_rows):
r"""Decompose a matrix into a sequence of Givens rotations and
particle-hole transformations on the last fermionic mode.
The input is an $N \times 2N$ matrix $W$ with orthonormal
rows. Furthermore, $W$ must have the block form
$$
W = ( W_1 \hspace{4pt} W_2 )
$$
where $W_1$ and $W_2$ satisfy
$$
W_1 W_1^\dagger + W_2 W_2^\dagger &= I
$$
W_1 W_2^T + W_2 W_1^T &= 0.
Then $W$ can be decomposed as
$$
V W U^\dagger = ( 0 \hspace{6pt} D )
$$
where $V$ and $U$ are unitary matrices and $D$
is a diagonal unitary matrix. Furthermore, $U$ can be decomposed
as follows:
$$
U = B G_{k} \cdots B G_3 G_2 B G_1 B,
$$
where each $G_i$ is a Givens rotation, and $B$ represents
swapping the $N$-th column with the $2N$-th column,
which corresponds to a particle-hole transformation
on the last fermionic mode. This particle-hole transformation maps
$a^\dagger_N$ to $a_N$ and vice versa, while leaving the
other fermionic ladder operators invariant.
The decomposition of $U$ is returned as a list of tuples of objects
describing rotations and particle-hole transformations. The list looks
something like [('pht', ), (G_1, ), ('pht', G_2), ... ].
The objects within a tuple are either the string 'pht', which indicates
a particle-hole transformation on the last fermionic mode, or a tuple
of the form $(i, j, \theta, \varphi)$, which indicates a
Givens rotation of rows $i$ and $j$ by angles
$\theta$ and $\varphi$.
The matrix $V^T D^*$ can also be decomposed as a sequence of
Givens rotations. This decomposition is needed for a circuit that
prepares an excited state.
Args:
unitary_rows(ndarray): A matrix with orthonormal rows and
additional structure described above.
Returns
-------
decomposition (list[tuple]):
The decomposition of $U$.
left_decomposition (list[tuple]):
The decomposition of $V^T D^*$.
diagonal (ndarray):
A list of the nonzero entries of $D$.
left_diagonal (ndarray):
A list of the nonzero entries left from the decomposition
of $V^T D^*$.
"""
current_matrix = numpy.copy(unitary_rows)
n, p = current_matrix.shape
# Check that p = 2 * n
if p != 2 * n:
raise ValueError('The input matrix must have twice as many columns '
'as rows.')
# Check that left and right parts of unitary_rows satisfy the constraints
# necessary for the transformed fermionic operators to satisfy
# the fermionic anticommutation relations
left_part = unitary_rows[:, :n]
right_part = unitary_rows[:, n:]
constraint_matrix_1 = (left_part.dot(left_part.T.conj()) +
right_part.dot(right_part.T.conj()))
constraint_matrix_2 = (left_part.dot(right_part.T) +
right_part.dot(left_part.T))
discrepancy_1 = numpy.amax(abs(constraint_matrix_1 - numpy.eye(n)))
discrepancy_2 = numpy.amax(abs(constraint_matrix_2))
if discrepancy_1 > EQ_TOLERANCE or discrepancy_2 > EQ_TOLERANCE:
raise ValueError('The input matrix does not satisfy the constraints '
'necessary for a proper transformation of the '
'fermionic ladder operators.')
# Compute left_unitary using Givens rotations
left_unitary = numpy.eye(n, dtype=complex)
for k in range(n - 1):
# Zero out entries in column k
for l in range(n - 1 - k):
# Zero out entry in row l if needed
if abs(current_matrix[l, k]) > EQ_TOLERANCE:
givens_rotation = givens_matrix_elements(
current_matrix[l, k], current_matrix[l + 1, k])
# Apply Givens rotation
givens_rotate(current_matrix, givens_rotation, l, l + 1)
givens_rotate(left_unitary, givens_rotation, l, l + 1)
# Initialize list to store decomposition of current_matrix
decomposition = []
# There are 2 * n - 1 iterations (that is the circuit depth)
for k in range(2 * n - 1):
# Initialize the list of parallel operations to perform
# in this iteration
parallel_ops = []
# Perform a particle-hole transformation if necessary
if k % 2 == 0 and abs(current_matrix[k // 2, n - 1]) > EQ_TOLERANCE:
parallel_ops.append('pht')
swap_columns(current_matrix, n - 1, 2 * n - 1)
# Get the (row, column) indices of elements to zero out in parallel.
if k < n:
end_row = k
end_column = n - 1 - k
else:
end_row = n - 1
end_column = k - (n - 1)
column_indices = range(end_column, n - 1, 2)
row_indices = range(end_row, end_row - len(column_indices), -1)
indices_to_zero_out = zip(row_indices, column_indices)
for i, j in indices_to_zero_out:
# Compute the Givens rotation to zero out the (i, j) element,
# if needed
left_element = current_matrix[i, j].conj()
if abs(left_element) > EQ_TOLERANCE:
# We actually need to perform a Givens rotation
right_element = current_matrix[i, j + 1].conj()
givens_rotation = givens_matrix_elements(
left_element, right_element)
# Add the parameters to the list
theta = numpy.arcsin(numpy.real(givens_rotation[1, 0]))
phi = numpy.angle(givens_rotation[1, 1])
parallel_ops.append((j, j + 1, theta, phi))
# Update the matrix
double_givens_rotate(current_matrix,
givens_rotation,
j,
j + 1,
which='col')
# If the current list of parallel operations is not empty,
# append it to the list,
if parallel_ops:
decomposition.append(tuple(parallel_ops))
# Get the diagonal entries
diagonal = current_matrix[range(n), range(n, 2 * n)]
# Compute the decomposition of left_unitary^T * diagonal^*
current_matrix = left_unitary.T
for k in range(n):
current_matrix[:, k] *= diagonal[k].conj()
left_decomposition, left_diagonal = givens_decomposition_square(
current_matrix)
return decomposition, left_decomposition, diagonal, left_diagonal
def swap_rows(M, i, j):
"""Swap rows i and j of matrix M."""
if len(M.shape) == 1:
M[i], M[j] = M[j], M[i]
else:
row_i = M[i, :].copy()
row_j = M[j, :].copy()
M[i, :], M[j, :] = row_j, row_i
def swap_columns(M, i, j):
"""Swap columns i and j of matrix M."""
if len(M.shape) == 1:
M[i], M[j] = M[j], M[i]
else:
column_i = M[:, i].copy()
column_j = M[:, j].copy()
M[:, i], M[:, j] = column_j, column_i
| 10,743 |
14,668 | <gh_stars>1000+
// Copyright 2017 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.
package org.chromium.base;
import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.robolectric.annotation.Config;
import org.chromium.base.DiscardableReferencePool.DiscardableReference;
import org.chromium.base.test.BaseRobolectricTestRunner;
import java.lang.ref.WeakReference;
/**
* Tests for {@link DiscardableReferencePool}.
*/
@RunWith(BaseRobolectricTestRunner.class)
@Config(manifest = Config.NONE)
public class DiscardableReferencePoolTest {
/**
* Tests that draining the pool clears references and allows objects to be garbage collected.
*/
@Test
public void testDrain() {
DiscardableReferencePool pool = new DiscardableReferencePool();
Object object = new Object();
WeakReference<Object> weakReference = new WeakReference<>(object);
DiscardableReference<Object> discardableReference = pool.put(object);
Assert.assertEquals(object, discardableReference.get());
// Drop reference to the object itself, to allow it to be garbage-collected.
object = null;
pool.drain();
// The discardable reference should be null now.
Assert.assertNull(discardableReference.get());
// The object is not (strongly) reachable anymore, so the weak reference may or may not be
// null (it could be if a GC has happened since the pool was drained). It should be
// eligible for garbage collection.
Assert.assertTrue(GarbageCollectionTestUtils.canBeGarbageCollected(weakReference));
}
@Test
public void testRemoveAfterDrainDoesNotThrow() {
DiscardableReferencePool pool = new DiscardableReferencePool();
Object object = new Object();
WeakReference<Object> weakReference = new WeakReference<>(object);
DiscardableReference<Object> discardableReference = pool.put(object);
Assert.assertEquals(object, discardableReference.get());
// Release the strong reference.
object = null;
pool.drain();
// Shouldn't throw any exception.
pool.remove(discardableReference);
// The discardable reference should be null now.
Assert.assertNull(discardableReference.get());
// The object is not (strongly) reachable anymore, so the weak reference may or may not be
// null (it could be if a GC has happened since the pool was drained). It should be
// eligible for garbage collection.
Assert.assertTrue(GarbageCollectionTestUtils.canBeGarbageCollected(weakReference));
}
@Test
public void testDrainAfterRemoveDoesNotThrow() {
DiscardableReferencePool pool = new DiscardableReferencePool();
Object object = new Object();
WeakReference<Object> weakReference = new WeakReference<>(object);
DiscardableReference<Object> discardableReference = pool.put(object);
Assert.assertEquals(object, discardableReference.get());
// Release the strong reference.
object = null;
pool.remove(discardableReference);
// Shouldn't throw any exception.
pool.drain();
// The discardable reference should be null now.
Assert.assertNull(discardableReference.get());
// The object is not (strongly) reachable anymore, so the weak reference may or may not be
// null (it could be if a GC has happened since the pool was drained). It should be
// eligible for garbage collection.
Assert.assertTrue(GarbageCollectionTestUtils.canBeGarbageCollected(weakReference));
}
/**
* Tests that dropping the (last) discardable reference to an object allows it to be regularly
* garbage collected.
*/
@Test
public void testReferenceGCd() {
DiscardableReferencePool pool = new DiscardableReferencePool();
Object object = new Object();
WeakReference<Object> weakReference = new WeakReference<>(object);
DiscardableReference<Object> discardableReference = pool.put(object);
Assert.assertEquals(object, discardableReference.get());
// Drop reference to the object itself and to the discardable reference, allowing the object
// to be garbage-collected.
object = null;
discardableReference = null;
// The object is not (strongly) reachable anymore, so the weak reference may or may not be
// null (it could be if a GC has happened since the pool was drained). It should be
// eligible for garbage collection.
Assert.assertTrue(GarbageCollectionTestUtils.canBeGarbageCollected(weakReference));
}
}
| 1,608 |
3,562 | // Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements. See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership. The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
package org.apache.doris.alter;
import org.apache.doris.analysis.ColumnPosition;
import org.apache.doris.catalog.Column;
import org.apache.doris.catalog.KeysType;
import org.apache.doris.catalog.OlapTable;
import org.apache.doris.common.jmockit.Deencapsulation;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import org.junit.Assert;
import org.junit.Test;
import mockit.Expectations;
import mockit.Injectable;
public class SchemaChangeHandlerTest {
@Test
public void testAddValueColumnOnAggMV(@Injectable OlapTable olapTable, @Injectable Column newColumn,
@Injectable ColumnPosition columnPosition) {
SchemaChangeHandler schemaChangeHandler = new SchemaChangeHandler();
new Expectations() {
{
olapTable.getKeysType();
result = KeysType.DUP_KEYS;
newColumn.getAggregationType();
result = null;
olapTable.getIndexMetaByIndexId(2).getKeysType();
result = KeysType.AGG_KEYS;
newColumn.isKey();
result = false;
}
};
try {
Deencapsulation.invoke(schemaChangeHandler, "addColumnInternal", olapTable, newColumn, columnPosition,
new Long(2), new Long(1),
Maps.newHashMap(), Sets.newHashSet());
Assert.fail();
} catch (Exception e) {
System.out.println(e.getMessage());
}
}
}
| 931 |
575 | // Copyright 2013 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 CHROME_BROWSER_PRINTING_CLOUD_PRINT_PRIVET_HTTP_ASYNCHRONOUS_FACTORY_H_
#define CHROME_BROWSER_PRINTING_CLOUD_PRINT_PRIVET_HTTP_ASYNCHRONOUS_FACTORY_H_
#include <memory>
#include <string>
#include "base/callback.h"
#include "base/memory/ref_counted.h"
namespace net {
class HostPortPair;
}
namespace network {
class SharedURLLoaderFactory;
}
namespace cloud_print {
class PrivetHTTPClient;
class PrivetHTTPResolution {
public:
using ResultCallback =
base::OnceCallback<void(std::unique_ptr<PrivetHTTPClient>)>;
virtual ~PrivetHTTPResolution() {}
virtual void Start(const net::HostPortPair& address,
ResultCallback callback) = 0;
};
class PrivetHTTPAsynchronousFactory {
public:
using ResultCallback = PrivetHTTPResolution::ResultCallback;
virtual ~PrivetHTTPAsynchronousFactory() {}
static std::unique_ptr<PrivetHTTPAsynchronousFactory> CreateInstance(
scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory);
virtual std::unique_ptr<PrivetHTTPResolution> CreatePrivetHTTP(
const std::string& service_name) = 0;
};
} // namespace cloud_print
#endif // CHROME_BROWSER_PRINTING_CLOUD_PRINT_PRIVET_HTTP_ASYNCHRONOUS_FACTORY_H_
| 503 |
1,916 | #ifndef SimTK_SIMBODY_RIGID_BODY_NODE_SPEC_CUSTOM_H_
#define SimTK_SIMBODY_RIGID_BODY_NODE_SPEC_CUSTOM_H_
/* -------------------------------------------------------------------------- *
* Simbody(tm) *
* -------------------------------------------------------------------------- *
* This is part of the SimTK biosimulation toolkit originating from *
* Simbios, the NIH National Center for Physics-Based Simulation of *
* Biological Structures at Stanford, funded under the NIH Roadmap for *
* Medical Research, grant U54 GM072970. See https://simtk.org/home/simbody. *
* *
* Portions copyright (c) 2008-12 Stanford University and the Authors. *
* Authors: <NAME> *
* Contributors: <NAME> *
* *
* Licensed under the Apache License, Version 2.0 (the "License"); you may *
* not use this file except in compliance with the License. You may obtain a *
* copy of the License at http://www.apache.org/licenses/LICENSE-2.0. *
* *
* Unless required by applicable law or agreed to in writing, software *
* distributed under the License is distributed on an "AS IS" BASIS, *
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
* See the License for the specific language governing permissions and *
* limitations under the License. *
* -------------------------------------------------------------------------- */
/**@file
* Define the RigidBodyNode that implements Custom mobilizers.
*/
#include "SimbodyMatterSubsystemRep.h"
#include "RigidBodyNode.h"
#include "RigidBodyNodeSpec.h"
#include "MobilizedBodyImpl.h" // need Custom::ImplementationImpl
/**
* RigidBodyNodeSpec for Custom Mobilizers. This is still templatized
* by the number of u's (mobilities) in the user-defined Mobilizer.
*/
template <int nu, bool noX_MB, bool noR_PF>
class RBNodeCustom : public RigidBodyNodeSpec<nu, false, noX_MB, noR_PF> {
typedef typename RigidBodyNodeSpec<nu, false, noX_MB, noR_PF>::HType HType;
public:
RBNodeCustom(const MobilizedBody::Custom::Implementation& impl,
const MassProperties& mProps_B,
const Transform& X_PF,
const Transform& X_BM,
bool isReversed,
UIndex& nextUSlot,
USquaredIndex& nextUSqSlot,
QIndex& nextQSlot)
: RigidBodyNodeSpec<nu, false, noX_MB, noR_PF>(mProps_B, X_PF, X_BM, nextUSlot, nextUSqSlot, nextQSlot,
RigidBodyNode::QDotMayDifferFromU,
impl.getImpl().getNumAngles() == 4 ? RigidBodyNode::QuaternionMayBeUsed
: RigidBodyNode::QuaternionIsNeverUsed,
isReversed),
impl(impl), nq(impl.getImpl().getNQ()), nAngles(impl.getImpl().getNumAngles())
{
this->updateSlots(nextUSlot,nextUSqSlot,nextQSlot);
}
const char* type() const {
return "custom";
}
int getMaxNQ() const {
return nq;
}
int getNQInUse(const SBModelVars& mv) const {
return (nAngles == 4 && this->getUseEulerAngles(mv) ? nq-1 : nq);
}
virtual int getNUInUse(const SBModelVars& mv) const {
return nu;
}
bool isUsingQuaternion(const SBStateDigest& sbs, MobilizerQIndex& startOfQuaternion) const {
if (nAngles < 4 || this->getUseEulerAngles(sbs.getModelVars())) {
startOfQuaternion.invalidate();
return false;
}
startOfQuaternion = MobilizerQIndex(0); // quaternion comes first
return true;
}
void calcQDot(const SBStateDigest& sbs,
const Real* u, Real* qdot) const
{
const int nqInUse = getNQInUse(sbs.getModelVars());
impl.multiplyByN(sbs.getState(), false, nu, u, getNQInUse(sbs.getModelVars()), qdot);
for (int i = nqInUse; i < nq; ++i)
qdot[i] = 0.0;
}
void calcQDotDot(const SBStateDigest& sbs,
const Real* udot, Real* qdotdot) const
{
const SBModelVars& mv = sbs.getModelVars();
const SBTreePositionCache& pc = sbs.getTreePositionCache();
const int nqInUse = getNQInUse(sbs.getModelVars());
const Real* u = &sbs.getU()[this->getUIndex()];
impl.multiplyByN(sbs.getState(), false, nu, udot, nqInUse, qdotdot);
Real temp[7];
impl.multiplyByNDot(sbs.getState(), false, nu, u, nqInUse, temp);
for (int i = 0; i < nqInUse; ++i)
qdotdot[i] += temp[i];
for (int i = nqInUse; i < nq; ++i)
qdotdot[i] = 0.0;
}
void multiplyByN(const SBStateDigest& sbs, bool matrixOnRight,
const Real* in, Real* out) const
{
const SBModelVars& mv = sbs.getModelVars();
int nIn, nOut;
if (matrixOnRight) {
nIn = getNQInUse(mv);
nOut = getNUInUse(mv);
}
else {
nIn = getNUInUse(mv);
nOut = getNQInUse(mv);
}
impl.multiplyByN(sbs.getState(), matrixOnRight, nIn, in, nOut, out);
}
void multiplyByNInv(const SBStateDigest& sbs, bool matrixOnRight,
const Real* in, Real* out) const
{
const SBModelVars& mv = sbs.getModelVars();
int nIn, nOut;
if (matrixOnRight) {
nIn = getNUInUse(mv);
nOut = getNQInUse(mv);
}
else {
nIn = getNQInUse(mv);
nOut = getNUInUse(mv);
}
impl.multiplyByNInv(sbs.getState(), matrixOnRight, nIn, in, nOut, out);
}
void multiplyByNDot(const SBStateDigest& sbs, bool matrixOnRight,
const Real* in, Real* out) const
{
const SBModelVars& mv = sbs.getModelVars();
int nIn, nOut;
if (matrixOnRight) {
nIn = getNQInUse(mv);
nOut = getNUInUse(mv);
}
else {
nIn = getNUInUse(mv);
nOut = getNQInUse(mv);
}
impl.multiplyByNDot(sbs.getState(), matrixOnRight, nIn, in, nOut, out);
}
bool enforceQuaternionConstraints(const SBStateDigest& sbs, Vector& q, Vector& qErrest) const {
if (nAngles != 4 || this->getUseEulerAngles(sbs.getModelVars()))
return false;
Vec4& quat = this->toQuat(q);
quat = quat / quat.norm();
if (qErrest.size()) {
Vec4& qerr = this->toQuat(qErrest);
qerr -= dot(qerr,quat) * quat;
}
return true;
}
// Convert from quaternion to Euler angle representations.
void convertToEulerAngles(const Vector& inputQ, Vector& outputQ) const {
int indexBase = this->getQIndex();
if (nAngles != 4) {
for (int i = 0; i < nq; ++i)
outputQ[indexBase+i] = inputQ[indexBase+i];
}
else {
this->toQVec3(outputQ, 0) = Rotation(Quaternion(this->fromQuat(inputQ))).convertRotationToBodyFixedXYZ();
for (int i = 3; i < nq-1; ++i)
outputQ[indexBase+i] = inputQ[indexBase+i+1];
outputQ[indexBase+nq-1] = 0.0;
}
}
// Convert from Euler angle to quaternion representations.
void convertToQuaternions(const Vector& inputQ, Vector& outputQ) const {
int indexBase = this->getQIndex();
if (nAngles != 4) {
for (int i = 0; i < nq; ++i)
outputQ[indexBase+i] = inputQ[indexBase+i];
}
else {
Rotation rot;
rot.setRotationToBodyFixedXYZ(Vec3(inputQ[indexBase], inputQ[indexBase+1], inputQ[indexBase+2]));
this->toQuat(outputQ) = rot.convertRotationToQuaternion().asVec4();
for (int i = 4; i < nq; ++i)
outputQ[indexBase+i] = inputQ[indexBase+i-1];
}
};
void setQToFitTransformImpl(const SBStateDigest& sbs, const Transform& X_FM, Vector& q) const {
impl.setQToFitTransform(sbs.getState(), X_FM, this->getNQInUse(sbs.getModelVars()), &q[this->getQIndex()]);
}
void setQToFitRotationImpl(const SBStateDigest& sbs, const Rotation& R_FM, Vector& q) const {
setQToFitTransformImpl(sbs, Transform(R_FM), q);
}
void setQToFitTranslationImpl(const SBStateDigest& sbs, const Vec3& p_FM, Vector& q) const {
setQToFitTransformImpl(sbs, Transform(p_FM), q);
}
void setUToFitVelocityImpl(const SBStateDigest& sbs, const Vector& q, const SpatialVec& V_FM, Vector& u) const {
impl.setUToFitVelocity(sbs.getState(), V_FM, nu, &u[this->getUIndex()]);
}
void setUToFitAngularVelocityImpl(const SBStateDigest& sbs, const Vector& q, const Vec3& w_FM, Vector& u) const {
setUToFitVelocityImpl(sbs, q, SpatialVec(w_FM, Vec3(0)), u);
}
void setUToFitLinearVelocityImpl(const SBStateDigest& sbs, const Vector& q, const Vec3& v_FM, Vector& u) const {
setUToFitVelocityImpl(sbs, q, SpatialVec(Vec3(0), v_FM), u);
}
// VIRTUAL METHODS FOR SINGLE-NODE OPERATOR CONTRIBUTIONS //
// We're not going to attempt to cache any q precalculations.
int calcQPoolSize(const SBModelVars&) const {return 0;}
void performQPrecalculations(const SBStateDigest& sbs,
const Real* q, int nq,
Real* qCache, int nQCache,
Real* qErr, int nQErr) const
{
assert(nq==getNQInUse(sbs.getModelVars()) && nQCache==0);
if (nAngles == 4 && !this->getUseEulerAngles(sbs.getModelVars())) {
// Need to calculate qerr
assert(nQErr==1);
const Real quatLen = Vec4::getAs(&q[0]).norm();
qErr[0] = quatLen - Real(1); // normalization error
}
}
void calcX_FM(const SBStateDigest& sbs,
const Real* q, int nq,
const Real* qCache, int nQCache,
Transform& X_F0M0) const
{
assert(nq==getNQInUse(sbs.getModelVars()) && nQCache==0);
// Note: quaternion will be unnormalized.
X_F0M0 = impl.calcMobilizerTransformFromQ(sbs.getState(), nq, q);
}
void calcAcrossJointVelocityJacobian(
const SBStateDigest& sbs,
HType& H_F0M0) const {
for (int i = 0; i < nu; ++i) {
Vec<nu> u(0);
u[i] = 1;
H_F0M0(i) = impl.multiplyByHMatrix(sbs.getState(), nu, &u[0]);
}
}
void calcAcrossJointVelocityJacobianDot(
const SBStateDigest& sbs,
HType& HDot_F0M0) const {
for (int i = 0; i < nu; ++i) {
Vec<nu> u(0);
u[i] = 1;
HDot_F0M0(i) = impl.multiplyByHDotMatrix(sbs.getState(), nu, &u[0]);
}
}
private:
const MobilizedBody::Custom::Implementation& impl;
const int nq, nAngles;
};
#endif // SimTK_SIMBODY_RIGID_BODY_NODE_SPEC_CUSTOM_H_
| 5,835 |
1,056 | package org.netbeans.test.java.hints;
public abstract class AbstractMethod {
public abstract void method(int i) ;
// System.out.println(i);
// }
public void test() {
method(3, "Hello World!");
method("Hello World!", 3);
method("Hello World!", 3, "");
method(3, 3, 4);
}
} | 144 |
386 | //////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2012, J3P LLC. 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 Image Engine Design 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 IECORENUKE_DISPLAYIOP_H
#define IECORENUKE_DISPLAYIOP_H
#include "IECoreNuke/Export.h"
#include "IECoreImage/DisplayDriverServer.h"
#include "DDImage/Iop.h"
namespace IECoreNuke
{
IE_CORE_FORWARDDECLARE( NukeDisplayDriver );
class IECORENUKE_API DisplayIop : public DD::Image::Iop
{
public :
DisplayIop( Node *node );
virtual ~DisplayIop();
virtual const char *Class() const;
virtual const char *node_help() const;
virtual void knobs( DD::Image::Knob_Callback f );
virtual int knob_changed( DD::Image::Knob *knob );
virtual void append( DD::Image::Hash &hash );
virtual void _validate( bool forReal );
virtual void engine( int y, int x, int r, const DD::Image::ChannelSet &channels, DD::Image::Row &row );
private :
static const Description g_description;
static DD::Image::Op *build( Node *node );
DisplayIop *firstDisplayIop();
void driverCreated( NukeDisplayDriver *driver );
void connectToDriver( NukeDisplayDriver *driver );
void driverDataReceived( NukeDisplayDriver *driver, const Imath::Box2i &box );
int m_portNumber;
DD::Image::Format m_format;
DD::Image::Format m_fullSizeFormat;
IECoreImage::DisplayDriverServerPtr m_server;
// we only bother updating these for firstDisplayIop(),
// and then refer to them from all other instances. this
// avoids problems where nuke might make new ops mid render
// and those ops would have missed the display driver creation.
unsigned int m_updateCount;
IECoreNuke::NukeDisplayDriverPtr m_driver;
};
} // namespace IECoreNuke
#endif // IECORENUKE_DISPLAYIOP_H
| 1,048 |
892 | {
"schema_version": "1.2.0",
"id": "GHSA-2xrc-mfj2-6vg5",
"modified": "2022-05-01T07:22:34Z",
"published": "2022-05-01T07:22:34Z",
"aliases": [
"CVE-2006-4863"
],
"details": "** DISPUTED ** Multiple PHP remote file inclusion vulnerabilities in Marc Cagninacci mcLinksCounter 1.1 allow remote attackers to execute arbitrary PHP code via a URL in the langfile parameter in (1) login.php, (2) stats.php, (3) detail.php, or (4) erase.php. NOTE: CVE and a third party dispute this vulnerability, because the langfile parameter is set to english.php in each file. NOTE: CVE also disputes a later report of this vulnerability in 1.2, because the langfile parameter is set to french.php in 1.2.",
"severity": [
],
"affected": [
],
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2006-4863"
},
{
"type": "WEB",
"url": "http://marc.info/?l=bugtraq&m=115860241806867&w=2"
},
{
"type": "WEB",
"url": "http://securityvulns.com/Rdocument844.html"
},
{
"type": "WEB",
"url": "http://securityvulns.com/source26994.html"
},
{
"type": "WEB",
"url": "http://www.securityfocus.com/archive/1/446062/100/0/threaded"
},
{
"type": "WEB",
"url": "http://www.securityfocus.com/archive/1/477253/100/0/threaded"
},
{
"type": "WEB",
"url": "http://www.securityfocus.com/archive/1/477363/100/0/threaded"
},
{
"type": "WEB",
"url": "http://www.securityfocus.com/archive/1/482006/100/0/threaded"
}
],
"database_specific": {
"cwe_ids": [
"CWE-94"
],
"severity": "HIGH",
"github_reviewed": false
}
} | 767 |
5,169 | {
"name": "ARActivityIndicator",
"version": "1.0.1",
"summary": "ARActivityIndicator allow you to show indicator for a process",
"description": "\"ARActivityIndicator allow you to show indicator for a process. You can easily show and hide with a single line of code.\"",
"homepage": "https://github.com/AbdulRehmanWarraich/ARActivityIndicator.git",
"license": {
"type": "MIT",
"file": "LICENSE"
},
"authors": {
"<NAME>": "<EMAIL>"
},
"source": {
"git": "https://github.com/AbdulRehmanWarraich/ARActivityIndicator.git",
"tag": "1.0.1"
},
"platforms": {
"ios": "9.0"
},
"source_files": "ARActivityIndicator/Classes/**/*",
"swift_versions": "5",
"swift_version": "5"
}
| 279 |
11,750 | from plotly.basedatatypes import BaseTraceHierarchyType as _BaseTraceHierarchyType
import copy as _copy
class Cumulative(_BaseTraceHierarchyType):
# class properties
# --------------------
_parent_path_str = "histogram"
_path_str = "histogram.cumulative"
_valid_props = {"currentbin", "direction", "enabled"}
# currentbin
# ----------
@property
def currentbin(self):
"""
Only applies if cumulative is enabled. Sets whether the current
bin is included, excluded, or has half of its value included in
the current cumulative value. "include" is the default for
compatibility with various other tools, however it introduces a
half-bin bias to the results. "exclude" makes the opposite
half-bin bias, and "half" removes it.
The 'currentbin' property is an enumeration that may be specified as:
- One of the following enumeration values:
['include', 'exclude', 'half']
Returns
-------
Any
"""
return self["currentbin"]
@currentbin.setter
def currentbin(self, val):
self["currentbin"] = val
# direction
# ---------
@property
def direction(self):
"""
Only applies if cumulative is enabled. If "increasing"
(default) we sum all prior bins, so the result increases from
left to right. If "decreasing" we sum later bins so the result
decreases from left to right.
The 'direction' property is an enumeration that may be specified as:
- One of the following enumeration values:
['increasing', 'decreasing']
Returns
-------
Any
"""
return self["direction"]
@direction.setter
def direction(self, val):
self["direction"] = val
# enabled
# -------
@property
def enabled(self):
"""
If true, display the cumulative distribution by summing the
binned values. Use the `direction` and `centralbin` attributes
to tune the accumulation method. Note: in this mode, the
"density" `histnorm` settings behave the same as their
equivalents without "density": "" and "density" both rise to
the number of data points, and "probability" and *probability
density* both rise to the number of sample points.
The 'enabled' property must be specified as a bool
(either True, or False)
Returns
-------
bool
"""
return self["enabled"]
@enabled.setter
def enabled(self, val):
self["enabled"] = val
# Self properties description
# ---------------------------
@property
def _prop_descriptions(self):
return """\
currentbin
Only applies if cumulative is enabled. Sets whether the
current bin is included, excluded, or has half of its
value included in the current cumulative value.
"include" is the default for compatibility with various
other tools, however it introduces a half-bin bias to
the results. "exclude" makes the opposite half-bin
bias, and "half" removes it.
direction
Only applies if cumulative is enabled. If "increasing"
(default) we sum all prior bins, so the result
increases from left to right. If "decreasing" we sum
later bins so the result decreases from left to right.
enabled
If true, display the cumulative distribution by summing
the binned values. Use the `direction` and `centralbin`
attributes to tune the accumulation method. Note: in
this mode, the "density" `histnorm` settings behave the
same as their equivalents without "density": "" and
"density" both rise to the number of data points, and
"probability" and *probability density* both rise to
the number of sample points.
"""
def __init__(
self, arg=None, currentbin=None, direction=None, enabled=None, **kwargs
):
"""
Construct a new Cumulative object
Parameters
----------
arg
dict of properties compatible with this constructor or
an instance of
:class:`plotly.graph_objs.histogram.Cumulative`
currentbin
Only applies if cumulative is enabled. Sets whether the
current bin is included, excluded, or has half of its
value included in the current cumulative value.
"include" is the default for compatibility with various
other tools, however it introduces a half-bin bias to
the results. "exclude" makes the opposite half-bin
bias, and "half" removes it.
direction
Only applies if cumulative is enabled. If "increasing"
(default) we sum all prior bins, so the result
increases from left to right. If "decreasing" we sum
later bins so the result decreases from left to right.
enabled
If true, display the cumulative distribution by summing
the binned values. Use the `direction` and `centralbin`
attributes to tune the accumulation method. Note: in
this mode, the "density" `histnorm` settings behave the
same as their equivalents without "density": "" and
"density" both rise to the number of data points, and
"probability" and *probability density* both rise to
the number of sample points.
Returns
-------
Cumulative
"""
super(Cumulative, self).__init__("cumulative")
if "_parent" in kwargs:
self._parent = kwargs["_parent"]
return
# Validate arg
# ------------
if arg is None:
arg = {}
elif isinstance(arg, self.__class__):
arg = arg.to_plotly_json()
elif isinstance(arg, dict):
arg = _copy.copy(arg)
else:
raise ValueError(
"""\
The first argument to the plotly.graph_objs.histogram.Cumulative
constructor must be a dict or
an instance of :class:`plotly.graph_objs.histogram.Cumulative`"""
)
# Handle skip_invalid
# -------------------
self._skip_invalid = kwargs.pop("skip_invalid", False)
self._validate = kwargs.pop("_validate", True)
# Populate data dict with properties
# ----------------------------------
_v = arg.pop("currentbin", None)
_v = currentbin if currentbin is not None else _v
if _v is not None:
self["currentbin"] = _v
_v = arg.pop("direction", None)
_v = direction if direction is not None else _v
if _v is not None:
self["direction"] = _v
_v = arg.pop("enabled", None)
_v = enabled if enabled is not None else _v
if _v is not None:
self["enabled"] = _v
# Process unknown kwargs
# ----------------------
self._process_kwargs(**dict(arg, **kwargs))
# Reset skip_invalid
# ------------------
self._skip_invalid = False
| 2,951 |
348 | <gh_stars>100-1000
{"nom":"Kédange-sur-Canner","circ":"9ème circonscription","dpt":"Moselle","inscrits":834,"abs":489,"votants":345,"blancs":32,"nuls":1,"exp":312,"res":[{"nuance":"REM","nom":"Mme <NAME>","voix":177},{"nuance":"FN","nom":"Mme <NAME>","voix":135}]} | 110 |
1,100 | /*********************************************************************************
* (Use radio buttons) Write a GUI program as shown in Figure 16.36a. You can use *
* buttons to move the message to the left and right and use the radio buttons to *
* change the color for the message displayed. *
*********************************************************************************/
import javafx.application.Application;
import javafx.stage.Stage;
import javafx.scene.Scene;
import javafx.geometry.Pos;
import javafx.scene.control.Button;
import javafx.scene.layout.HBox;
import javafx.scene.layout.Pane;
import javafx.scene.layout.BorderPane;
import javafx.scene.text.Text;
import javafx.scene.control.RadioButton;
import javafx.scene.control.ToggleGroup;
import javafx.scene.paint.Color;
public class Exercise_16_01 extends Application {
protected Text text = new Text(50, 50, "Programming is fun");
@Override // Override the stage method in the Application class
public void start(Stage primaryStage) {
HBox paneForButtons = new HBox(20);
Button btLeft = new Button("<=");
Button btRight = new Button("=>");
paneForButtons.getChildren().addAll(btLeft, btRight);
paneForButtons.setAlignment(Pos.CENTER);
BorderPane pane = new BorderPane();
pane.setBottom(paneForButtons);
HBox paneForRadioButtons = new HBox(20);
RadioButton rbRed = new RadioButton("Red");
RadioButton rbYellow = new RadioButton("Yellow");
RadioButton rbBlack = new RadioButton("Black");
RadioButton rbOrange = new RadioButton("Orange");
RadioButton rbGreen = new RadioButton("Green");
paneForRadioButtons.getChildren().addAll(rbRed, rbYellow,
rbBlack, rbOrange, rbGreen);
ToggleGroup group = new ToggleGroup();
rbRed.setToggleGroup(group);
rbYellow.setToggleGroup(group);
rbBlack.setToggleGroup(group);
rbOrange.setToggleGroup(group);
rbGreen.setToggleGroup(group);
Pane paneForText = new Pane();
paneForText.setStyle("-fx-border-color: black");
paneForText.getChildren().add(text);
pane.setCenter(paneForText);
pane.setTop(paneForRadioButtons);
btLeft.setOnAction(e -> text.setX(text.getX() - 10));
btRight.setOnAction(e -> text.setX(text.getX() + 10));
rbRed.setOnAction(e -> {
if (rbRed.isSelected()) {
text.setFill(Color.RED);
}
});
rbYellow.setOnAction(e -> {
if (rbYellow.isSelected()) {
text.setFill(Color.YELLOW);
}
});
rbBlack.setOnAction(e -> {
if (rbBlack.isSelected()) {
text.setFill(Color.BLACK);
}
});
rbOrange.setOnAction(e -> {
if (rbOrange.isSelected()) {
text.setFill(Color.ORANGE);
}
});
rbGreen.setOnAction(e -> {
if (rbGreen.isSelected()) {
text.setFill(Color.GREEN);
}
});
// Create a scene and place it in the stage
Scene scene = new Scene(pane, 450, 150);
primaryStage.setTitle("Exercise_16_01"); // Set the stage title
primaryStage.setScene(scene); // Place the scene in the stage
primaryStage.show(); // Display the stage
}
} | 1,098 |
14,668 | <filename>media/filters/fuchsia/fuchsia_video_decoder.cc
// Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "media/filters/fuchsia/fuchsia_video_decoder.h"
#include <fuchsia/mediacodec/cpp/fidl.h>
#include <lib/sys/cpp/component_context.h>
#include <vulkan/vulkan.h>
#include "base/bind.h"
#include "base/bits.h"
#include "base/callback_helpers.h"
#include "base/command_line.h"
#include "base/fuchsia/fuchsia_logging.h"
#include "base/fuchsia/process_context.h"
#include "base/location.h"
#include "base/logging.h"
#include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h"
#include "base/process/process_metrics.h"
#include "base/threading/sequenced_task_runner_handle.h"
#include "components/viz/common/gpu/raster_context_provider.h"
#include "gpu/command_buffer/client/context_support.h"
#include "gpu/command_buffer/client/shared_image_interface.h"
#include "gpu/command_buffer/common/shared_image_usage.h"
#include "gpu/ipc/common/gpu_memory_buffer_impl_native_pixmap.h"
#include "media/base/bind_to_current_loop.h"
#include "media/base/cdm_context.h"
#include "media/base/media_switches.h"
#include "media/base/video_aspect_ratio.h"
#include "media/base/video_frame.h"
#include "media/base/video_util.h"
#include "media/fuchsia/cdm/fuchsia_cdm_context.h"
#include "media/fuchsia/cdm/fuchsia_decryptor.h"
#include "media/fuchsia/cdm/fuchsia_stream_decryptor.h"
#include "media/fuchsia/common/decrypting_sysmem_buffer_stream.h"
#include "media/fuchsia/common/passthrough_sysmem_buffer_stream.h"
#include "media/fuchsia/common/stream_processor_helper.h"
#include "third_party/libyuv/include/libyuv/video_common.h"
#include "ui/gfx/buffer_types.h"
#include "ui/gfx/client_native_pixmap_factory.h"
#include "ui/ozone/public/client_native_pixmap_factory_ozone.h"
namespace media {
namespace {
// Number of output buffers allocated "for camping". This value is passed to
// sysmem to ensure that we get one output buffer for the frame currently
// displayed on the screen.
constexpr uint32_t kOutputBuffersForCamping = 1;
// Maximum number of frames we expect to have queued up while playing video.
// Higher values require more memory for output buffers. Lower values make it
// more likely that renderer will stall because decoded frames are not available
// on time.
constexpr uint32_t kMaxUsedOutputBuffers = 5;
// Use 2 buffers for decoder input. Allocating more than one buffers ensures
// that when the decoder is done working on one packet it will have another one
// waiting in the queue. Limiting number of buffers to 2 allows to minimize
// required memory, without significant effect on performance.
constexpr size_t kNumInputBuffers = 2;
// Some codecs do not support splitting video frames across multiple input
// buffers, so the buffers need to be large enough to fit all video frames. The
// buffer size is calculated to fit 1080p I420 frame with MinCR=2 (per H264
// spec), plus 128KiB for SEI/SPS/PPS. (note that the same size is used for all
// codecs, not just H264).
constexpr size_t kInputBufferSize = 1920 * 1080 * 3 / 2 / 2 + 128 * 1024;
} // namespace
// Helper used to hold mailboxes for the output textures. OutputMailbox may
// outlive FuchsiaVideoDecoder if is referenced by a VideoFrame.
class FuchsiaVideoDecoder::OutputMailbox {
public:
OutputMailbox(
scoped_refptr<viz::RasterContextProvider> raster_context_provider,
std::unique_ptr<gfx::GpuMemoryBuffer> gmb)
: raster_context_provider_(raster_context_provider), weak_factory_(this) {
uint32_t usage = gpu::SHARED_IMAGE_USAGE_DISPLAY |
gpu::SHARED_IMAGE_USAGE_SCANOUT |
gpu::SHARED_IMAGE_USAGE_VIDEO_DECODE;
mailbox_ =
raster_context_provider_->SharedImageInterface()->CreateSharedImage(
gmb.get(), nullptr, gfx::ColorSpace(), kTopLeft_GrSurfaceOrigin,
kPremul_SkAlphaType, usage);
}
OutputMailbox(const OutputMailbox&) = delete;
OutputMailbox& operator=(const OutputMailbox&) = delete;
~OutputMailbox() {
raster_context_provider_->SharedImageInterface()->DestroySharedImage(
sync_token_, mailbox_);
}
const gpu::Mailbox& mailbox() { return mailbox_; }
// Create a new video frame that wraps the mailbox. |reuse_callback| will be
// called when the mailbox can be reused.
scoped_refptr<VideoFrame> CreateFrame(VideoPixelFormat pixel_format,
const gfx::Size& coded_size,
const gfx::Rect& visible_rect,
const gfx::Size& natural_size,
base::TimeDelta timestamp,
base::OnceClosure reuse_callback) {
DCHECK(!is_used_);
is_used_ = true;
reuse_callback_ = std::move(reuse_callback);
gpu::MailboxHolder mailboxes[VideoFrame::kMaxPlanes];
mailboxes[0].mailbox = mailbox_;
mailboxes[0].sync_token = raster_context_provider_->SharedImageInterface()
->GenUnverifiedSyncToken();
auto frame = VideoFrame::WrapNativeTextures(
pixel_format, mailboxes,
BindToCurrentLoop(base::BindOnce(&OutputMailbox::OnFrameDestroyed,
base::Unretained(this))),
coded_size, visible_rect, natural_size, timestamp);
// Request a fence we'll wait on before reusing the buffer.
frame->metadata().read_lock_fences_enabled = true;
return frame;
}
// Called by FuchsiaVideoDecoder when it no longer needs this mailbox.
void Release() {
if (is_used_) {
// The mailbox is referenced by a VideoFrame. It will be deleted as soon
// as the frame is destroyed.
DCHECK(reuse_callback_);
reuse_callback_ = base::OnceClosure();
} else {
delete this;
}
}
private:
void OnFrameDestroyed(const gpu::SyncToken& sync_token) {
DCHECK(is_used_);
is_used_ = false;
sync_token_ = sync_token;
if (!reuse_callback_) {
// If the mailbox cannot be reused then we can just delete it.
delete this;
return;
}
raster_context_provider_->ContextSupport()->SignalSyncToken(
sync_token_,
BindToCurrentLoop(base::BindOnce(&OutputMailbox::OnSyncTokenSignaled,
weak_factory_.GetWeakPtr())));
}
void OnSyncTokenSignaled() {
sync_token_.Clear();
std::move(reuse_callback_).Run();
}
const scoped_refptr<viz::RasterContextProvider> raster_context_provider_;
gpu::Mailbox mailbox_;
gpu::SyncToken sync_token_;
// Set to true when the mailbox is referenced by a video frame.
bool is_used_ = false;
base::OnceClosure reuse_callback_;
base::WeakPtrFactory<OutputMailbox> weak_factory_;
};
// static
std::unique_ptr<VideoDecoder> FuchsiaVideoDecoder::Create(
scoped_refptr<viz::RasterContextProvider> raster_context_provider) {
return std::make_unique<FuchsiaVideoDecoder>(
std::move(raster_context_provider),
/*enable_sw_decoding=*/false);
}
// static
std::unique_ptr<VideoDecoder> FuchsiaVideoDecoder::CreateForTests(
scoped_refptr<viz::RasterContextProvider> raster_context_provider,
bool enable_sw_decoding) {
return std::make_unique<FuchsiaVideoDecoder>(
std::move(raster_context_provider), enable_sw_decoding);
}
FuchsiaVideoDecoder::FuchsiaVideoDecoder(
scoped_refptr<viz::RasterContextProvider> raster_context_provider,
bool enable_sw_decoding)
: raster_context_provider_(raster_context_provider),
enable_sw_decoding_(enable_sw_decoding),
use_overlays_for_video_(base::CommandLine::ForCurrentProcess()->HasSwitch(
switches::kUseOverlaysForVideo)),
sysmem_allocator_("CrFuchsiaVideoDecoder"),
client_native_pixmap_factory_(
ui::CreateClientNativePixmapFactoryOzone()) {
DCHECK(raster_context_provider_);
weak_this_ = weak_factory_.GetWeakPtr();
}
FuchsiaVideoDecoder::~FuchsiaVideoDecoder() {
// Reset SysmemBufferStream to ensure it doesn't try to send new packets when
// the |decoder_| is destroyed.
sysmem_buffer_stream_.reset();
decoder_.reset();
// Release mailboxes used for output frames.
ReleaseOutputBuffers();
}
bool FuchsiaVideoDecoder::IsPlatformDecoder() const {
return true;
}
bool FuchsiaVideoDecoder::SupportsDecryption() const {
return true;
}
VideoDecoderType FuchsiaVideoDecoder::GetDecoderType() const {
return VideoDecoderType::kFuchsia;
}
void FuchsiaVideoDecoder::Initialize(const VideoDecoderConfig& config,
bool low_delay,
CdmContext* cdm_context,
InitCB init_cb,
const OutputCB& output_cb,
const WaitingCB& waiting_cb) {
DCHECK(output_cb);
DCHECK(waiting_cb);
DCHECK(decode_callbacks_.empty());
auto done_callback = BindToCurrentLoop(std::move(init_cb));
// There should be no pending decode request, so DropInputQueue() is not
// expected to fail.
bool result = DropInputQueue(DecodeStatus::ABORTED);
DCHECK(result);
output_cb_ = output_cb;
waiting_cb_ = waiting_cb;
container_aspect_ratio_ = config.aspect_ratio();
// Keep decoder and decryptor if the configuration hasn't changed.
if (decoder_ && current_config_.codec() == config.codec() &&
current_config_.is_encrypted() == config.is_encrypted()) {
std::move(done_callback).Run(OkStatus());
return;
}
sysmem_buffer_stream_.reset();
decoder_.reset();
// Initialize the stream.
bool secure_mode = false;
StatusCode status = InitializeSysmemBufferStream(config.is_encrypted(),
cdm_context, &secure_mode);
if (status != StatusCode::kOk) {
std::move(done_callback).Run(StatusCode::kOk);
return;
}
// Reset output buffers since we won't be able to re-use them.
ReleaseOutputBuffers();
fuchsia::mediacodec::CreateDecoder_Params decoder_params;
decoder_params.mutable_input_details()->set_format_details_version_ordinal(0);
switch (config.codec()) {
case VideoCodec::kH264:
decoder_params.mutable_input_details()->set_mime_type("video/h264");
break;
case VideoCodec::kVP8:
decoder_params.mutable_input_details()->set_mime_type("video/vp8");
break;
case VideoCodec::kVP9:
decoder_params.mutable_input_details()->set_mime_type("video/vp9");
break;
case VideoCodec::kHEVC:
decoder_params.mutable_input_details()->set_mime_type("video/hevc");
break;
case VideoCodec::kAV1:
decoder_params.mutable_input_details()->set_mime_type("video/av1");
break;
default:
std::move(done_callback).Run(StatusCode::kDecoderUnsupportedCodec);
return;
}
if (secure_mode) {
decoder_params.set_secure_input_mode(
fuchsia::mediacodec::SecureMemoryMode::ON);
}
if (secure_mode || base::CommandLine::ForCurrentProcess()->HasSwitch(
switches::kForceProtectedVideoOutputBuffers)) {
decoder_params.set_secure_output_mode(
fuchsia::mediacodec::SecureMemoryMode::ON);
}
decoder_params.set_promise_separate_access_units_on_input(true);
decoder_params.set_require_hw(!enable_sw_decoding_);
auto decoder_factory = base::ComponentContextForProcess()
->svc()
->Connect<fuchsia::mediacodec::CodecFactory>();
fuchsia::media::StreamProcessorPtr decoder;
decoder_factory->CreateDecoder(std::move(decoder_params),
decoder.NewRequest());
decoder_ = std::make_unique<StreamProcessorHelper>(std::move(decoder), this);
current_config_ = config;
std::move(done_callback).Run(OkStatus());
}
void FuchsiaVideoDecoder::Decode(scoped_refptr<DecoderBuffer> buffer,
DecodeCB decode_cb) {
if (!decoder_) {
// Post the callback to the current sequence as DecoderStream doesn't expect
// Decode() to complete synchronously.
base::SequencedTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
base::BindOnce(std::move(decode_cb), DecodeStatus::DECODE_ERROR));
return;
}
decode_callbacks_.push_back(std::move(decode_cb));
sysmem_buffer_stream_->EnqueueBuffer(std::move(buffer));
}
void FuchsiaVideoDecoder::Reset(base::OnceClosure closure) {
DropInputQueue(DecodeStatus::ABORTED);
base::SequencedTaskRunnerHandle::Get()->PostTask(FROM_HERE,
std::move(closure));
}
bool FuchsiaVideoDecoder::NeedsBitstreamConversion() const {
return true;
}
bool FuchsiaVideoDecoder::CanReadWithoutStalling() const {
return num_used_output_buffers_ < kMaxUsedOutputBuffers;
}
int FuchsiaVideoDecoder::GetMaxDecodeRequests() const {
return max_decoder_requests_;
}
StatusCode FuchsiaVideoDecoder::InitializeSysmemBufferStream(
bool is_encrypted,
CdmContext* cdm_context,
bool* out_secure_mode) {
DCHECK(!sysmem_buffer_stream_);
*out_secure_mode = false;
// By default queue as many decode requests as the input buffers available
// with one extra request to be able to send a new InputBuffer immediately.
max_decoder_requests_ = kNumInputBuffers + 1;
if (is_encrypted) {
// Caller makes sure |cdm_context| is available if the stream is encrypted.
if (!cdm_context) {
DLOG(ERROR) << "No cdm context for encrypted stream.";
return StatusCode::kDecoderMissingCdmForEncryptedContent;
}
// Use FuchsiaStreamDecryptor with FuchsiaCdm (it doesn't support
// media::Decryptor interface). Otherwise (e.g. for ClearKey CDM) use
// DecryptingSysmemBufferStream.
FuchsiaCdmContext* fuchsia_cdm = cdm_context->GetFuchsiaCdmContext();
if (fuchsia_cdm) {
*out_secure_mode = base::CommandLine::ForCurrentProcess()->HasSwitch(
switches::kEnableProtectedVideoBuffers);
sysmem_buffer_stream_ =
fuchsia_cdm->CreateStreamDecryptor(*out_secure_mode);
// For optimal performance allow more requests to fill the decryptor
// queue.
max_decoder_requests_ += FuchsiaStreamDecryptor::kInputBufferCount;
} else {
sysmem_buffer_stream_ = std::make_unique<DecryptingSysmemBufferStream>(
&sysmem_allocator_, cdm_context, Decryptor::kVideo);
}
} else {
sysmem_buffer_stream_ =
std::make_unique<PassthroughSysmemBufferStream>(&sysmem_allocator_);
}
sysmem_buffer_stream_->Initialize(this, kInputBufferSize, kNumInputBuffers);
return StatusCode::kOk;
}
void FuchsiaVideoDecoder::OnSysmemBufferStreamBufferCollectionToken(
fuchsia::sysmem::BufferCollectionTokenPtr token) {
DCHECK(decoder_);
decoder_->SetInputBufferCollectionToken(std::move(token));
}
void FuchsiaVideoDecoder::OnSysmemBufferStreamOutputPacket(
StreamProcessorHelper::IoPacket packet) {
packet.AddOnDestroyClosure(
base::BindOnce(&FuchsiaVideoDecoder::CallNextDecodeCallback,
decode_callbacks_weak_factory_.GetWeakPtr()));
decoder_->Process(std::move(packet));
}
void FuchsiaVideoDecoder::OnSysmemBufferStreamEndOfStream() {
decoder_->ProcessEos();
}
void FuchsiaVideoDecoder::OnSysmemBufferStreamError() {
OnError();
}
void FuchsiaVideoDecoder::OnSysmemBufferStreamNoKey() {
waiting_cb_.Run(WaitingReason::kNoDecryptionKey);
}
void FuchsiaVideoDecoder::OnStreamProcessorAllocateOutputBuffers(
const fuchsia::media::StreamBufferConstraints& output_constraints) {
ReleaseOutputBuffers();
output_buffer_collection_ = sysmem_allocator_.AllocateNewCollection();
output_buffer_collection_->CreateSharedToken(
base::BindOnce(&StreamProcessorHelper::CompleteOutputBuffersAllocation,
base::Unretained(decoder_.get())),
"codec");
output_buffer_collection_->CreateSharedToken(
base::BindOnce(&FuchsiaVideoDecoder::SetBufferCollectionTokenForGpu,
base::Unretained(this)),
"gpu");
fuchsia::sysmem::BufferCollectionConstraints buffer_constraints;
buffer_constraints.usage.none = fuchsia::sysmem::noneUsage;
buffer_constraints.min_buffer_count_for_camping = kOutputBuffersForCamping;
buffer_constraints.min_buffer_count_for_shared_slack =
kMaxUsedOutputBuffers - kOutputBuffersForCamping;
output_buffer_collection_->Initialize(std::move(buffer_constraints),
"ChromiumVideoDecoderOutput");
}
void FuchsiaVideoDecoder::OnStreamProcessorEndOfStream() {
// Decode() is not supposed to be called again after EOF.
DCHECK_EQ(decode_callbacks_.size(), 1U);
CallNextDecodeCallback();
}
void FuchsiaVideoDecoder::OnStreamProcessorOutputFormat(
fuchsia::media::StreamOutputFormat output_format) {
auto* format = output_format.mutable_format_details();
if (!format->has_domain() || !format->domain().is_video() ||
!format->domain().video().is_uncompressed()) {
DLOG(ERROR) << "Received OnOutputFormat() with invalid format.";
OnError();
return;
}
output_format_ = std::move(format->mutable_domain()->video().uncompressed());
}
void FuchsiaVideoDecoder::OnStreamProcessorOutputPacket(
StreamProcessorHelper::IoPacket output_packet) {
fuchsia::sysmem::PixelFormatType sysmem_pixel_format =
output_format_.image_format.pixel_format.type;
VideoPixelFormat pixel_format;
gfx::BufferFormat buffer_format;
VkFormat vk_format;
switch (sysmem_pixel_format) {
case fuchsia::sysmem::PixelFormatType::NV12:
pixel_format = PIXEL_FORMAT_NV12;
buffer_format = gfx::BufferFormat::YUV_420_BIPLANAR;
vk_format = VK_FORMAT_G8_B8R8_2PLANE_420_UNORM;
break;
case fuchsia::sysmem::PixelFormatType::I420:
case fuchsia::sysmem::PixelFormatType::YV12:
pixel_format = PIXEL_FORMAT_I420;
buffer_format = gfx::BufferFormat::YVU_420;
vk_format = VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM;
break;
default:
DLOG(ERROR) << "Unsupported pixel format: "
<< static_cast<int>(sysmem_pixel_format);
OnError();
return;
}
size_t buffer_index = output_packet.buffer_index();
if (buffer_index >= output_mailboxes_.size())
output_mailboxes_.resize(buffer_index + 1, nullptr);
auto coded_size = gfx::Size(output_format_.primary_width_pixels,
output_format_.primary_height_pixels);
if (!output_mailboxes_[buffer_index]) {
gfx::GpuMemoryBufferHandle gmb_handle;
gmb_handle.type = gfx::NATIVE_PIXMAP;
gmb_handle.native_pixmap_handle.buffer_collection_id =
output_buffer_collection_id_;
gmb_handle.native_pixmap_handle.buffer_index = buffer_index;
auto gmb = gpu::GpuMemoryBufferImplNativePixmap::CreateFromHandle(
client_native_pixmap_factory_.get(), std::move(gmb_handle), coded_size,
buffer_format, gfx::BufferUsage::GPU_READ,
gpu::GpuMemoryBufferImpl::DestructionCallback());
output_mailboxes_[buffer_index] =
new OutputMailbox(raster_context_provider_, std::move(gmb));
} else {
raster_context_provider_->SharedImageInterface()->UpdateSharedImage(
gpu::SyncToken(), output_mailboxes_[buffer_index]->mailbox());
}
auto display_rect = gfx::Rect(output_format_.primary_display_width_pixels,
output_format_.primary_display_height_pixels);
VideoAspectRatio aspect_ratio = container_aspect_ratio_;
if (!aspect_ratio.IsValid() && output_format_.has_pixel_aspect_ratio) {
aspect_ratio =
VideoAspectRatio::PAR(output_format_.pixel_aspect_ratio_width,
output_format_.pixel_aspect_ratio_height);
}
auto timestamp = output_packet.timestamp();
// SendInputPacket() sets timestamp for all packets sent to the decoder, so we
// expect to receive timestamp for all decoded frames. Missing timestamp
// indicates a bug in the decoder implementation.
if (timestamp == kNoTimestamp) {
LOG(ERROR) << "Received frame without timestamp.";
OnError();
return;
}
num_used_output_buffers_++;
auto frame = output_mailboxes_[buffer_index]->CreateFrame(
pixel_format, coded_size, display_rect,
aspect_ratio.GetNaturalSize(display_rect), timestamp,
base::BindOnce(&FuchsiaVideoDecoder::ReleaseOutputPacket,
base::Unretained(this), std::move(output_packet)));
// Currently sysmem doesn't specify location of chroma samples relative to
// luma (see fxb/13677). Assume they are cosited with luma. YCbCr info here
// must match the values passed for the same buffer in
// ui::SysmemBufferCollection::CreateVkImage() (see
// ui/ozone/platform/scenic/sysmem_buffer_collection.cc). |format_features|
// are resolved later in the GPU process before this info is passed to Skia.
frame->set_ycbcr_info(gpu::VulkanYCbCrInfo(
vk_format, /*external_format=*/0,
VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709,
VK_SAMPLER_YCBCR_RANGE_ITU_NARROW, VK_CHROMA_LOCATION_COSITED_EVEN,
VK_CHROMA_LOCATION_COSITED_EVEN, /*format_features=*/0));
// Mark the frame as power-efficient when software decoders are disabled. The
// codec may still decode on hardware even when |enable_sw_decoding_| is set
// (i.e. power_efficient flag would not be set correctly in that case). It
// doesn't matter because software decoders can be enabled only for tests.
frame->metadata().power_efficient = !enable_sw_decoding_;
// Allow this video frame to be promoted as an overlay, because it was
// registered with an ImagePipe.
frame->metadata().allow_overlay = use_overlays_for_video_;
output_cb_.Run(std::move(frame));
}
void FuchsiaVideoDecoder::OnStreamProcessorNoKey() {
// Decoder is not expected to produce NoKey() error.
DLOG(ERROR) << "Video decoder failed with DECRYPTOR_NO_KEY expectedly";
OnError();
}
void FuchsiaVideoDecoder::OnStreamProcessorError() {
OnError();
}
void FuchsiaVideoDecoder::CallNextDecodeCallback() {
DCHECK(!decode_callbacks_.empty());
auto cb = std::move(decode_callbacks_.front());
decode_callbacks_.pop_front();
std::move(cb).Run(DecodeStatus::OK);
}
bool FuchsiaVideoDecoder::DropInputQueue(DecodeStatus status) {
// Invalidate callbacks for CallNextDecodeCallback(), so the callbacks are not
// called when the |decoder_| is dropped below. The callbacks are called
// explicitly later.
decode_callbacks_weak_factory_.InvalidateWeakPtrs();
if (decoder_) {
decoder_->Reset();
}
if (sysmem_buffer_stream_) {
sysmem_buffer_stream_->Reset();
}
auto weak_this = weak_this_;
for (auto& cb : decode_callbacks_) {
std::move(cb).Run(status);
// DecodeCB may destroy |this|.
if (!weak_this)
return false;
}
decode_callbacks_.clear();
return true;
}
void FuchsiaVideoDecoder::OnError() {
sysmem_buffer_stream_.reset();
decoder_.reset();
ReleaseOutputBuffers();
DropInputQueue(DecodeStatus::DECODE_ERROR);
}
void FuchsiaVideoDecoder::SetBufferCollectionTokenForGpu(
fuchsia::sysmem::BufferCollectionTokenPtr token) {
// Register the new collection with the GPU process.
DCHECK(!output_buffer_collection_id_);
output_buffer_collection_id_ = gfx::SysmemBufferCollectionId::Create();
raster_context_provider_->SharedImageInterface()
->RegisterSysmemBufferCollection(
output_buffer_collection_id_, token.Unbind().TakeChannel(),
gfx::BufferFormat::YUV_420_BIPLANAR, gfx::BufferUsage::GPU_READ,
use_overlays_for_video_ /*register_with_image_pipe*/);
// Exact number of buffers sysmem will allocate is unknown here.
// |output_mailboxes_| is resized when we start receiving output frames.
DCHECK(output_mailboxes_.empty());
}
void FuchsiaVideoDecoder::ReleaseOutputBuffers() {
// Release the buffer collection.
num_used_output_buffers_ = 0;
if (output_buffer_collection_) {
output_buffer_collection_.reset();
}
// Release all output mailboxes.
for (OutputMailbox* mailbox : output_mailboxes_) {
if (mailbox)
mailbox->Release();
}
output_mailboxes_.clear();
// Tell the GPU process to drop the buffer collection.
if (output_buffer_collection_id_) {
raster_context_provider_->SharedImageInterface()
->ReleaseSysmemBufferCollection(output_buffer_collection_id_);
output_buffer_collection_id_ = {};
}
}
void FuchsiaVideoDecoder::ReleaseOutputPacket(
StreamProcessorHelper::IoPacket output_packet) {
DCHECK_GT(num_used_output_buffers_, 0U);
num_used_output_buffers_--;
}
} // namespace media
| 9,442 |
6,728 | <filename>csrc/includes/softmax.h
#pragma once
#include <cuda.h>
#include <cuda_fp16.h>
#include <stdio.h>
#include "custom_cuda_layers.h"
#include <fstream>
using namespace std;
template <typename T>
class Softmax {
public:
struct Config {
size_t batchSize;
size_t heads;
size_t seq_length;
size_t prob_depth;
float temperature;
bool mem_alloc;
Config(size_t batch, size_t h, size_t seq, int prob_size = 0, bool mem_alloc = false)
: batchSize(batch),
heads(h),
seq_length(seq),
prob_depth(prob_size),
temperature(1.0),
mem_alloc(mem_alloc)
{
}
};
Softmax(Config config) : config_(config) {}
~Softmax() {}
void Forward(int bsz, T* vals, const T* attn_mask, cudaStream_t& stream)
{
launch_attn_softmax<T>(vals, attn_mask, bsz, config_.heads, config_.seq_length, stream);
}
void Backward(int bsz, T* out_grad, const T* soft_out, cudaStream_t stream)
{
launch_attn_softmax_backward_v2<T>(
out_grad, soft_out, bsz, config_.heads, config_.seq_length, stream);
}
inline size_t GetProbDepth() const { return config_.prob_depth; }
inline size_t GetBatchSize() const { return config_.batchSize; }
inline size_t GetNumHeads() const { return config_.heads; }
inline size_t GetSeqLength() const { return config_.seq_length; }
inline void SetSeqLength(size_t seq_len) { config_.seq_length = seq_len; }
private:
Config config_;
};
| 781 |
5,169 | <reponame>Gantios/Specs
{
"name": "UPPaymentControl",
"version": "3.3.14",
"summary": "Unionpay SDK",
"description": "A unoffical unionpay SDK pod",
"homepage": "https://github.com/letspod/UPPaymentControl",
"license": {
"type": "MIT"
},
"authors": {
"TBXark": "<EMAIL>"
},
"source": {
"git": "https://github.com/letspod/UPPaymentControl.git",
"tag": "3.3.14"
},
"platforms": {
"ios": "8.0"
},
"source_files": "UPPaymentControl.h",
"vendored_libraries": "libPaymentControl.a"
}
| 228 |
5,169 | <gh_stars>1000+
{
"name": "UserKit",
"version": "0.0.5",
"summary": "UserKit tracking library for iOS (Swift)",
"homepage": "http://www.mstage.io/",
"license": {
"type": "Apache License, Version 2.0",
"file": "LICENSE"
},
"authors": {
"mStage": "<EMAIL>"
},
"platforms": {
"ios": "8.0"
},
"source": {
"http": "https://raw.githubusercontent.com/T-Pham/UserKitSDK/0.0.5/UserKit.zip"
},
"vendored_frameworks": "UserKit.framework",
"dependencies": {
"JSQMessagesViewController": [
],
"JSQSystemSoundPlayer": [
"~> 2.0.1"
]
}
}
| 270 |
1,350 | // Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
// Code generated by Microsoft (R) AutoRest Code Generator.
package com.azure.resourcemanager.automation.implementation;
import com.azure.core.util.Context;
import com.azure.resourcemanager.automation.fluent.models.SourceControlInner;
import com.azure.resourcemanager.automation.models.SourceControl;
import com.azure.resourcemanager.automation.models.SourceControlCreateOrUpdateParameters;
import com.azure.resourcemanager.automation.models.SourceControlSecurityTokenProperties;
import com.azure.resourcemanager.automation.models.SourceControlUpdateParameters;
import com.azure.resourcemanager.automation.models.SourceType;
import java.time.OffsetDateTime;
public final class SourceControlImpl implements SourceControl, SourceControl.Definition, SourceControl.Update {
private SourceControlInner innerObject;
private final com.azure.resourcemanager.automation.AutomationManager serviceManager;
public String id() {
return this.innerModel().id();
}
public String name() {
return this.innerModel().name();
}
public String type() {
return this.innerModel().type();
}
public String repoUrl() {
return this.innerModel().repoUrl();
}
public String branch() {
return this.innerModel().branch();
}
public String folderPath() {
return this.innerModel().folderPath();
}
public Boolean autoSync() {
return this.innerModel().autoSync();
}
public Boolean publishRunbook() {
return this.innerModel().publishRunbook();
}
public SourceType sourceType() {
return this.innerModel().sourceType();
}
public String description() {
return this.innerModel().description();
}
public OffsetDateTime creationTime() {
return this.innerModel().creationTime();
}
public OffsetDateTime lastModifiedTime() {
return this.innerModel().lastModifiedTime();
}
public SourceControlInner innerModel() {
return this.innerObject;
}
private com.azure.resourcemanager.automation.AutomationManager manager() {
return this.serviceManager;
}
private String resourceGroupName;
private String automationAccountName;
private String sourceControlName;
private SourceControlCreateOrUpdateParameters createParameters;
private SourceControlUpdateParameters updateParameters;
public SourceControlImpl withExistingAutomationAccount(String resourceGroupName, String automationAccountName) {
this.resourceGroupName = resourceGroupName;
this.automationAccountName = automationAccountName;
return this;
}
public SourceControl create() {
this.innerObject =
serviceManager
.serviceClient()
.getSourceControls()
.createOrUpdateWithResponse(
resourceGroupName, automationAccountName, sourceControlName, createParameters, Context.NONE)
.getValue();
return this;
}
public SourceControl create(Context context) {
this.innerObject =
serviceManager
.serviceClient()
.getSourceControls()
.createOrUpdateWithResponse(
resourceGroupName, automationAccountName, sourceControlName, createParameters, context)
.getValue();
return this;
}
SourceControlImpl(String name, com.azure.resourcemanager.automation.AutomationManager serviceManager) {
this.innerObject = new SourceControlInner();
this.serviceManager = serviceManager;
this.sourceControlName = name;
this.createParameters = new SourceControlCreateOrUpdateParameters();
}
public SourceControlImpl update() {
this.updateParameters = new SourceControlUpdateParameters();
return this;
}
public SourceControl apply() {
this.innerObject =
serviceManager
.serviceClient()
.getSourceControls()
.updateWithResponse(
resourceGroupName, automationAccountName, sourceControlName, updateParameters, Context.NONE)
.getValue();
return this;
}
public SourceControl apply(Context context) {
this.innerObject =
serviceManager
.serviceClient()
.getSourceControls()
.updateWithResponse(
resourceGroupName, automationAccountName, sourceControlName, updateParameters, context)
.getValue();
return this;
}
SourceControlImpl(
SourceControlInner innerObject, com.azure.resourcemanager.automation.AutomationManager serviceManager) {
this.innerObject = innerObject;
this.serviceManager = serviceManager;
this.resourceGroupName = Utils.getValueFromIdByName(innerObject.id(), "resourceGroups");
this.automationAccountName = Utils.getValueFromIdByName(innerObject.id(), "automationAccounts");
this.sourceControlName = Utils.getValueFromIdByName(innerObject.id(), "sourceControls");
}
public SourceControl refresh() {
this.innerObject =
serviceManager
.serviceClient()
.getSourceControls()
.getWithResponse(resourceGroupName, automationAccountName, sourceControlName, Context.NONE)
.getValue();
return this;
}
public SourceControl refresh(Context context) {
this.innerObject =
serviceManager
.serviceClient()
.getSourceControls()
.getWithResponse(resourceGroupName, automationAccountName, sourceControlName, context)
.getValue();
return this;
}
public SourceControlImpl withRepoUrl(String repoUrl) {
this.createParameters.withRepoUrl(repoUrl);
return this;
}
public SourceControlImpl withBranch(String branch) {
if (isInCreateMode()) {
this.createParameters.withBranch(branch);
return this;
} else {
this.updateParameters.withBranch(branch);
return this;
}
}
public SourceControlImpl withFolderPath(String folderPath) {
if (isInCreateMode()) {
this.createParameters.withFolderPath(folderPath);
return this;
} else {
this.updateParameters.withFolderPath(folderPath);
return this;
}
}
public SourceControlImpl withAutoSync(Boolean autoSync) {
if (isInCreateMode()) {
this.createParameters.withAutoSync(autoSync);
return this;
} else {
this.updateParameters.withAutoSync(autoSync);
return this;
}
}
public SourceControlImpl withPublishRunbook(Boolean publishRunbook) {
if (isInCreateMode()) {
this.createParameters.withPublishRunbook(publishRunbook);
return this;
} else {
this.updateParameters.withPublishRunbook(publishRunbook);
return this;
}
}
public SourceControlImpl withSourceType(SourceType sourceType) {
this.createParameters.withSourceType(sourceType);
return this;
}
public SourceControlImpl withSecurityToken(SourceControlSecurityTokenProperties securityToken) {
if (isInCreateMode()) {
this.createParameters.withSecurityToken(securityToken);
return this;
} else {
this.updateParameters.withSecurityToken(securityToken);
return this;
}
}
public SourceControlImpl withDescription(String description) {
if (isInCreateMode()) {
this.createParameters.withDescription(description);
return this;
} else {
this.updateParameters.withDescription(description);
return this;
}
}
private boolean isInCreateMode() {
return this.innerModel().id() == null;
}
}
| 3,191 |
348 | {"nom":"Condamine","circ":"5ème circonscription","dpt":"Ain","inscrits":268,"abs":132,"votants":136,"blancs":8,"nuls":3,"exp":125,"res":[{"nuance":"LR","nom":"<NAME>","voix":90},{"nuance":"REM","nom":"<NAME>","voix":35}]} | 87 |
348 | {"nom":"Bonneville","circ":"1ère circonscription","dpt":"Somme","inscrits":254,"abs":132,"votants":122,"blancs":7,"nuls":3,"exp":112,"res":[{"nuance":"FI","nom":"<NAME>","voix":67},{"nuance":"REM","nom":"M. <NAME>","voix":45}]} | 90 |
1,718 | <filename>passes/opt/opt_mem_widen.cc
/*
* yosys -- Yosys Open SYnthesis Suite
*
* Copyright (C) 2021 <NAME> <<EMAIL>>
*
* 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.
*
* THE 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 "kernel/yosys.h"
#include "kernel/mem.h"
USING_YOSYS_NAMESPACE
PRIVATE_NAMESPACE_BEGIN
struct OptMemWidenPass : public Pass {
OptMemWidenPass() : Pass("opt_mem_widen", "optimize memories where all ports are wide") { }
void help() override
{
// |---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|
log("\n");
log(" opt_mem_widen [options] [selection]\n");
log("\n");
log("This pass looks for memories where all ports are wide and adjusts the base\n");
log("memory width up until that stops being the case.\n");
log("\n");
}
void execute(std::vector<std::string> args, RTLIL::Design *design) override
{
log_header(design, "Executing OPT_MEM_WIDEN pass (optimize memories where all ports are wide).\n");
size_t argidx;
for (argidx = 1; argidx < args.size(); argidx++) {
// if (args[argidx] == "-nomux") {
// mode_nomux = true;
// continue;
// }
break;
}
extra_args(args, argidx, design);
int total_count = 0;
for (auto module : design->selected_modules()) {
for (auto &mem : Mem::get_selected_memories(module)) {
// If the memory has no read ports, opt_clean will remove it
// instead.
if (mem.rd_ports.empty())
continue;
int factor_log2 = mem.rd_ports[0].wide_log2;
for (auto &port : mem.rd_ports)
if (port.wide_log2 < factor_log2)
factor_log2 = port.wide_log2;
for (auto &port : mem.wr_ports)
if (port.wide_log2 < factor_log2)
factor_log2 = port.wide_log2;
if (factor_log2 == 0)
continue;
log("Widening base width of memory %s in module %s by factor %d.\n", log_id(mem.memid), log_id(module->name), 1 << factor_log2);
total_count++;
// The inits are too messy to expand one-by-one, for they may
// collide with one another after expansion. Just hit it with
// a hammer.
bool has_init = !mem.inits.empty();
Const init_data;
if (has_init) {
init_data = mem.get_init_data();
mem.clear_inits();
}
mem.width <<= factor_log2;
mem.size >>= factor_log2;
mem.start_offset >>= factor_log2;
if (has_init) {
MemInit new_init;
new_init.addr = mem.start_offset;
new_init.data = init_data;
new_init.en = Const(State::S1, mem.width);
mem.inits.push_back(new_init);
}
for (auto &port : mem.rd_ports) {
port.wide_log2 -= factor_log2;
port.addr = port.addr.extract_end(factor_log2);
}
for (auto &port : mem.wr_ports) {
port.wide_log2 -= factor_log2;
port.addr = port.addr.extract_end(factor_log2);
}
mem.emit();
}
}
if (total_count)
design->scratchpad_set_bool("opt.did_something", true);
log("Performed a total of %d transformations.\n", total_count);
}
} OptMemWidenPass;
PRIVATE_NAMESPACE_END
| 1,495 |
1,350 | // Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
// Code generated by Microsoft (R) AutoRest Code Generator.
package com.azure.resourcemanager.datalakeanalytics.models;
import com.azure.resourcemanager.datalakeanalytics.fluent.models.CapabilityInformationInner;
import java.util.UUID;
/** An immutable client-side representation of CapabilityInformation. */
public interface CapabilityInformation {
/**
* Gets the subscriptionId property: The subscription credentials that uniquely identifies the subscription.
*
* @return the subscriptionId value.
*/
UUID subscriptionId();
/**
* Gets the state property: The subscription state.
*
* @return the state value.
*/
SubscriptionState state();
/**
* Gets the maxAccountCount property: The maximum supported number of accounts under this subscription.
*
* @return the maxAccountCount value.
*/
Integer maxAccountCount();
/**
* Gets the accountCount property: The current number of accounts under this subscription.
*
* @return the accountCount value.
*/
Integer accountCount();
/**
* Gets the migrationState property: The Boolean value of true or false to indicate the maintenance state.
*
* @return the migrationState value.
*/
Boolean migrationState();
/**
* Gets the inner com.azure.resourcemanager.datalakeanalytics.fluent.models.CapabilityInformationInner object.
*
* @return the inner object.
*/
CapabilityInformationInner innerModel();
}
| 489 |
348 | {"nom":"Sainte-Mondane","circ":"4ème circonscription","dpt":"Dordogne","inscrits":222,"abs":108,"votants":114,"blancs":7,"nuls":3,"exp":104,"res":[{"nuance":"FI","nom":"<NAME>","voix":62},{"nuance":"REM","nom":"Mme <NAME>","voix":42}]} | 96 |
2,542 | <filename>src/prod/src/Lease/api/stdafx.h
// ------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License (MIT). See License.txt in the repo root for license information.
// ------------------------------------------------------------
// stdafx.h : include file for standard system include files,
// or project specific include files that are used frequently, but
// are changed infrequently
//
#pragma once
#include "targetver.h"
#include "Common\Common.h"
#include "ServiceModel\Transport\SecurityProvider.h"
#pragma warning(disable:4201) // Nameless struct/union
#include <winioctl.h>
| 178 |
1,174 | <gh_stars>1000+
package com.github.devnied.emvpcsccard;
import java.util.List;
import javax.smartcardio.Card;
import javax.smartcardio.CardException;
import javax.smartcardio.CardTerminal;
import javax.smartcardio.TerminalFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.github.devnied.emvnfccard.exception.CommunicationException;
import com.github.devnied.emvnfccard.model.EmvCard;
import com.github.devnied.emvnfccard.parser.EmvTemplate;
import com.github.devnied.emvnfccard.parser.EmvTemplate.Config;
@SuppressWarnings("restriction")
public class Main {
/**
* Class logger
*/
private static final Logger LOGGER = LoggerFactory.getLogger(Main.class);
public static void main(final String[] args) throws CardException, CommunicationException {
TerminalFactory factory = TerminalFactory.getDefault();
List<CardTerminal> terminals = factory.terminals().list();
if (terminals.isEmpty()) {
throw new CardException("No card terminals available");
}
LOGGER.info("Terminals: " + terminals);
if (terminals != null && !terminals.isEmpty()) {
// Use the first terminal
CardTerminal terminal = terminals.get(0);
if (terminal.waitForCardPresent(0)) {
// Connect with the card
Card card = terminal.connect("*");
LOGGER.info("card: " + card);
// Create provider
PcscProvider provider = new PcscProvider(card.getBasicChannel());
// Define config
Config config = EmvTemplate.Config()
.setContactLess(false) // Enable contact less reading
.setReadAllAids(true) // Read all aids in card
.setReadTransactions(true) // Read all transactions
.setRemoveDefaultParsers(false) // Remove default parsers (GeldKarte and Emv)
.setReadAt(true)
.setReadCplc(true);
// Create Parser
EmvTemplate parser = EmvTemplate.Builder() //
.setProvider(provider) // Define provider
.setConfig(config) // Define config
//.setTerminal(terminal) (optional) you can define a custom terminal implementation to create APDU
.build();
// Read card
EmvCard emvCard = parser.readEmvCard();
LOGGER.info(emvCard.toString());
// Disconnect the card
card.disconnect(false);
}
} else {
LOGGER.error("No pcsc terminal found");
}
}
}
| 853 |
337 | <gh_stars>100-1000
package c;
import a.MainKt;
class J {
void bar() {
MainKt.test();
}
}
| 56 |
3,436 | <reponame>theodelrieu/range-v3
/// \file
// Range v3 library
//
// Copyright <NAME> 2021-present
//
// Use, modification and distribution is subject to 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)
//
// Project home: https://github.com/ericniebler/range-v3
#ifndef RANGES_V3_ALGORITHM_FOLDR_HPP
#define RANGES_V3_ALGORITHM_FOLDR_HPP
#include <meta/meta.hpp>
#include <range/v3/algorithm/foldl.hpp>
#include <range/v3/functional/identity.hpp>
#include <range/v3/functional/invoke.hpp>
#include <range/v3/iterator/operations.hpp>
#include <range/v3/range/access.hpp>
#include <range/v3/range/concepts.hpp>
#include <range/v3/utility/optional.hpp>
#include <range/v3/detail/prologue.hpp>
namespace ranges
{
namespace detail
{
template<typename F>
struct flipped
{
F f;
template(class T, class U)(requires invocable<F &, U, T>) //
invoke_result_t<F &, U, T>
operator()(T &&, U &&);
};
} // namespace detail
// clang-format off
template <class F, class T, class I>
CPP_concept indirectly_binary_right_foldable =
indirectly_binary_left_foldable<detail::flipped<F>, T, I>;
// clang-format on
/// \addtogroup group-algorithms
/// @{
struct foldr_fn
{
template(typename I, typename S, typename T, typename Op, typename P = identity)(
/// \pre
requires sentinel_for<S, I> AND bidirectional_iterator<I> AND
indirectly_binary_right_foldable<Op, T, projected<I, P>>) //
constexpr auto
operator()(I first, S last, T init, Op op, P proj = P{}) const
{
using U = std::decay_t<invoke_result_t<Op &, indirect_result_t<P &, I>, T>>;
if(first == last)
{
return U(std::move(init));
}
I tail = next(first, last);
U accum = invoke(op, invoke(proj, *--tail), std::move(init));
while(first != tail)
{
accum = invoke(op, invoke(proj, *--tail), std::move(accum));
}
return accum;
}
template(typename Rng, typename T, typename Op, typename P = identity)(
/// \pre
requires bidirectional_range<Rng> AND
indirectly_binary_right_foldable<Op, T, projected<iterator_t<Rng>, P>>) //
constexpr auto
operator()(Rng && rng, T init, Op op, P proj = P{}) const
{
return (*this)(begin(rng),
end(rng),
std::move(init),
std::move(op),
std::move(proj));
}
};
struct foldr1_fn
{
template(typename I, typename S, typename Op, typename P = identity)(
/// \pre
requires sentinel_for<S, I> AND bidirectional_iterator<I> AND
indirectly_binary_right_foldable<Op, iter_value_t<I>, projected<I, P>>
AND constructible_from<iter_value_t<I>, iter_reference_t<I>>) //
constexpr auto
operator()(I first, S last, Op op, P proj = P{}) const
{
using U = invoke_result_t<foldr_fn, I, S, iter_value_t<I>, Op, P>;
if(first == last)
{
return optional<U>();
}
I tail = prev(next(first, std::move(last)));
return optional<U>(in_place,
foldr_fn{}(std::move(first),
tail,
iter_value_t<I>(*tail),
std::move(op),
std::move(proj)));
}
template(typename R, typename Op, typename P = identity)(
/// \pre
requires bidirectional_range<R> AND indirectly_binary_right_foldable<
Op, range_value_t<R>, projected<iterator_t<R>, P>>
AND constructible_from<range_value_t<R>, range_reference_t<R>>) //
constexpr auto
operator()(R && rng, Op op, P proj = P{}) const
{
return (*this)(begin(rng), end(rng), std::move(op), std::move(proj));
}
};
RANGES_INLINE_VARIABLE(foldr_fn, foldr)
RANGES_INLINE_VARIABLE(foldr1_fn, foldr1)
/// @}
} // namespace ranges
#include <range/v3/detail/epilogue.hpp>
#endif
| 2,374 |
311 | #ifndef I2C_BUS_READBYTE_H_
#define I2C_BUS_READBYTE_H_
NAN_METHOD(ReadByteAsync);
NAN_METHOD(ReadByteSync);
#endif // I2C_BUS_READBYTE_H_
| 68 |
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.
#include "components/autofill/core/browser/webdata/autofill_wallet_metadata_sync_bridge.h"
#include <stddef.h>
#include <algorithm>
#include <memory>
#include <sstream>
#include <utility>
#include "base/base64.h"
#include "base/bind.h"
#include "base/callback_helpers.h"
#include "base/files/scoped_temp_dir.h"
#include "base/run_loop.h"
#include "base/test/bind.h"
#include "base/test/task_environment.h"
#include "base/time/time.h"
#include "components/autofill/core/browser/data_model/autofill_metadata.h"
#include "components/autofill/core/browser/data_model/autofill_profile.h"
#include "components/autofill/core/browser/data_model/credit_card.h"
#include "components/autofill/core/browser/geo/country_names.h"
#include "components/autofill/core/browser/test_autofill_clock.h"
#include "components/autofill/core/browser/webdata/autofill_sync_bridge_test_util.h"
#include "components/autofill/core/browser/webdata/autofill_sync_bridge_util.h"
#include "components/autofill/core/browser/webdata/autofill_table.h"
#include "components/autofill/core/browser/webdata/mock_autofill_webdata_backend.h"
#include "components/autofill/core/common/autofill_constants.h"
#include "components/os_crypt/os_crypt_mocker.h"
#include "components/sync/base/client_tag_hash.h"
#include "components/sync/engine/data_type_activation_response.h"
#include "components/sync/engine/entity_data.h"
#include "components/sync/model/client_tag_based_model_type_processor.h"
#include "components/sync/model/data_batch.h"
#include "components/sync/protocol/autofill_specifics.pb.h"
#include "components/sync/protocol/entity_metadata.pb.h"
#include "components/sync/protocol/entity_specifics.pb.h"
#include "components/sync/protocol/model_type_state.pb.h"
#include "components/sync/test/model/mock_model_type_change_processor.h"
#include "components/webdata/common/web_database.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace autofill {
namespace {
using base::ScopedTempDir;
using sync_pb::WalletMetadataSpecifics;
using syncer::DataBatch;
using syncer::EntityData;
using syncer::KeyAndData;
using syncer::MockModelTypeChangeProcessor;
using syncer::ModelType;
using testing::_;
using testing::ElementsAre;
using testing::ElementsAreArray;
using testing::IsEmpty;
using testing::Return;
using testing::UnorderedElementsAre;
// Non-UTF8 server IDs.
const char kAddr1ServerId[] = "addr1\xEF\xBF\xBE";
const char kAddr2ServerId[] = "addr2\xEF\xBF\xBE";
const char kCard1ServerId[] = "card1\xEF\xBF\xBE";
const char kCard2ServerId[] = "card2\xEF\xBF\xBE";
// Base64 encodings of the server IDs, used as ids in WalletMetadataSpecifics
// (these are suitable for syncing, because they are valid UTF-8).
const char kAddr1SpecificsId[] = "YWRkcjHvv74=";
const char kAddr2SpecificsId[] = "YWRkcjLvv74=";
const char kCard1SpecificsId[] = "Y2FyZDHvv74=";
const char kCard2SpecificsId[] = "Y2FyZDLvv74=";
const std::string kAddr1StorageKey =
GetStorageKeyForWalletMetadataTypeAndSpecificsId(
WalletMetadataSpecifics::ADDRESS,
kAddr1SpecificsId);
const std::string kCard1StorageKey =
GetStorageKeyForWalletMetadataTypeAndSpecificsId(
WalletMetadataSpecifics::CARD,
kCard1SpecificsId);
// Unique sync tags for the server IDs.
const char kAddr1SyncTag[] = "address-YWRkcjHvv74=";
const char kCard1SyncTag[] = "card-Y2FyZDHvv74=";
const char kLocalAddr1ServerId[] = "e171e3ed-858a-4dd5-9bf3-8517f14ba5fc";
const char kLocalAddr2ServerId[] = "fa232b9a-f248-4e5a-8d76-d46f821c0c5f";
const char kLocaleString[] = "en-US";
const char kDefaultCacheGuid[] = "CacheGuid";
base::Time UseDateFromProtoValue(int64_t use_date_proto_value) {
return base::Time::FromDeltaSinceWindowsEpoch(
base::Microseconds(use_date_proto_value));
}
const base::Time kDefaultTime = UseDateFromProtoValue(100);
int64_t UseDateToProtoValue(base::Time use_date) {
return use_date.ToDeltaSinceWindowsEpoch().InMicroseconds();
}
std::string GetAddressStorageKey(const std::string& specifics_id) {
return GetStorageKeyForWalletMetadataTypeAndSpecificsId(
WalletMetadataSpecifics::ADDRESS, specifics_id);
}
std::string GetCardStorageKey(const std::string& specifics_id) {
return GetStorageKeyForWalletMetadataTypeAndSpecificsId(
WalletMetadataSpecifics::CARD, specifics_id);
}
WalletMetadataSpecifics CreateWalletMetadataSpecificsForAddressWithDetails(
const std::string& specifics_id,
size_t use_count,
int64_t use_date,
bool has_converted = false) {
WalletMetadataSpecifics specifics;
specifics.set_id(specifics_id);
specifics.set_type(WalletMetadataSpecifics::ADDRESS);
specifics.set_use_count(use_count);
specifics.set_use_date(use_date);
// False is the default value according to the constructor of AutofillProfile.
specifics.set_address_has_converted(has_converted);
return specifics;
}
WalletMetadataSpecifics CreateWalletMetadataSpecificsForAddress(
const std::string& specifics_id) {
// Set default values according to the constructor of AutofillProfile (the
// clock value is overrided by TestAutofillClock in the test fixture).
return CreateWalletMetadataSpecificsForAddressWithDetails(
specifics_id, /*use_count=*/1,
/*use_date=*/UseDateToProtoValue(kDefaultTime));
}
WalletMetadataSpecifics CreateWalletMetadataSpecificsForCardWithDetails(
const std::string& specifics_id,
size_t use_count,
int64_t use_date,
const std::string& billing_address_id = "") {
WalletMetadataSpecifics specifics;
specifics.set_id(specifics_id);
specifics.set_type(WalletMetadataSpecifics::CARD);
specifics.set_use_count(use_count);
specifics.set_use_date(use_date);
// "" is the default value according to the constructor of AutofillProfile;
// this field is Base64 encoded in the protobuf.
specifics.set_card_billing_address_id(GetBase64EncodedId(billing_address_id));
return specifics;
}
WalletMetadataSpecifics CreateWalletMetadataSpecificsForCard(
const std::string& specifics_id) {
// Set default values according to the constructor of AutofillProfile (the
// clock value is overrided by TestAutofillClock in the test fixture).
return CreateWalletMetadataSpecificsForCardWithDetails(
specifics_id, /*use_count=*/1,
/*use_date=*/UseDateToProtoValue(kDefaultTime));
}
AutofillProfile CreateServerProfileWithDetails(const std::string& server_id,
size_t use_count,
int64_t use_date,
bool has_converted = false) {
AutofillProfile profile = CreateServerProfile(server_id);
profile.set_use_count(use_count);
profile.set_use_date(UseDateFromProtoValue(use_date));
profile.set_has_converted(has_converted);
return profile;
}
CreditCard CreateServerCreditCardWithDetails(
const std::string& server_id,
size_t use_count,
int64_t use_date,
const std::string& billing_address_id = "") {
CreditCard card = CreateServerCreditCard(server_id);
card.set_use_count(use_count);
card.set_use_date(UseDateFromProtoValue(use_date));
card.set_billing_address_id(billing_address_id);
return card;
}
AutofillProfile CreateLocalProfileWithDetails(size_t use_count,
int64_t use_date) {
AutofillProfile profile;
DCHECK_EQ(profile.record_type(), AutofillProfile::LOCAL_PROFILE);
profile.set_use_count(use_count);
profile.set_use_date(UseDateFromProtoValue(use_date));
return profile;
}
CreditCard CreateLocalCreditCardWithDetails(size_t use_count,
int64_t use_date) {
CreditCard card;
DCHECK_EQ(card.record_type(), CreditCard::LOCAL_CARD);
card.set_use_count(use_count);
card.set_use_date(UseDateFromProtoValue(use_date));
return card;
}
AutofillProfile CreateServerProfileFromSpecifics(
const WalletMetadataSpecifics& specifics) {
return CreateServerProfileWithDetails(
GetBase64DecodedId(specifics.id()), specifics.use_count(),
specifics.use_date(), specifics.address_has_converted());
}
CreditCard CreateServerCreditCardFromSpecifics(
const WalletMetadataSpecifics& specifics) {
return CreateServerCreditCardWithDetails(
GetBase64DecodedId(specifics.id()), specifics.use_count(),
specifics.use_date(),
GetBase64DecodedId(specifics.card_billing_address_id()));
}
void ExtractWalletMetadataSpecificsFromDataBatch(
std::unique_ptr<DataBatch> batch,
std::vector<WalletMetadataSpecifics>* output) {
while (batch->HasNext()) {
const KeyAndData& data_pair = batch->Next();
output->push_back(data_pair.second->specifics.wallet_metadata());
}
}
std::string WalletMetadataSpecificsAsDebugString(
const WalletMetadataSpecifics& specifics) {
std::ostringstream output;
output << "[id: " << specifics.id()
<< ", type: " << static_cast<int>(specifics.type())
<< ", use_count: " << specifics.use_count()
<< ", use_date: " << specifics.use_date()
<< ", card_billing_address_id: "
<< (specifics.has_card_billing_address_id()
? specifics.card_billing_address_id()
: "not_set")
<< ", address_has_converted: "
<< (specifics.has_address_has_converted()
? (specifics.address_has_converted() ? "true" : "false")
: "not_set")
<< "]";
return output.str();
}
std::vector<std::string> GetSortedSerializedSpecifics(
const std::vector<WalletMetadataSpecifics>& specifics) {
std::vector<std::string> serialized;
for (const WalletMetadataSpecifics& entry : specifics) {
serialized.push_back(entry.SerializeAsString());
}
std::sort(serialized.begin(), serialized.end());
return serialized;
}
MATCHER_P(EqualsSpecifics, expected, "") {
if (arg.SerializeAsString() != expected.SerializeAsString()) {
*result_listener << "entry\n"
<< WalletMetadataSpecificsAsDebugString(arg) << "\n"
<< "did not match expected\n"
<< WalletMetadataSpecificsAsDebugString(expected);
return false;
}
return true;
}
MATCHER_P(HasSpecifics, expected, "") {
const WalletMetadataSpecifics& arg_specifics =
arg->specifics.wallet_metadata();
if (arg_specifics.SerializeAsString() != expected.SerializeAsString()) {
*result_listener << "entry\n"
<< WalletMetadataSpecificsAsDebugString(arg_specifics)
<< "\ndid not match expected\n"
<< WalletMetadataSpecificsAsDebugString(expected);
return false;
}
return true;
}
} // namespace
class AutofillWalletMetadataSyncBridgeTest : public testing::Test {
public:
AutofillWalletMetadataSyncBridgeTest() {}
AutofillWalletMetadataSyncBridgeTest(
const AutofillWalletMetadataSyncBridgeTest&) = delete;
AutofillWalletMetadataSyncBridgeTest& operator=(
const AutofillWalletMetadataSyncBridgeTest&) = delete;
~AutofillWalletMetadataSyncBridgeTest() override {}
void SetUp() override {
// Fix a time for implicitly constructed use_dates in AutofillProfile.
test_clock_.SetNow(kDefaultTime);
CountryNames::SetLocaleString(kLocaleString);
ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
db_.AddTable(&table_);
db_.Init(temp_dir_.GetPath().AppendASCII("SyncTestWebDatabase"));
ON_CALL(*backend(), GetDatabase()).WillByDefault(Return(&db_));
ResetProcessor();
}
void ResetProcessor() {
real_processor_ =
std::make_unique<syncer::ClientTagBasedModelTypeProcessor>(
syncer::AUTOFILL_WALLET_METADATA, /*dump_stack=*/base::DoNothing());
mock_processor_.DelegateCallsByDefaultTo(real_processor_.get());
}
void ResetBridge(bool initial_sync_done = true) {
sync_pb::ModelTypeState model_type_state;
model_type_state.set_initial_sync_done(initial_sync_done);
model_type_state.mutable_progress_marker()->set_data_type_id(
GetSpecificsFieldNumberFromModelType(syncer::AUTOFILL_WALLET_METADATA));
model_type_state.set_cache_guid(kDefaultCacheGuid);
EXPECT_TRUE(table()->UpdateModelTypeState(syncer::AUTOFILL_WALLET_METADATA,
model_type_state));
bridge_ = std::make_unique<AutofillWalletMetadataSyncBridge>(
mock_processor_.CreateForwardingProcessor(), &backend_);
}
void StopSyncing() {
real_processor_->OnSyncStopping(syncer::CLEAR_METADATA);
}
void Shutdown() { real_processor_->OnSyncStopping(syncer::KEEP_METADATA); }
void StartSyncing(
const std::vector<WalletMetadataSpecifics>& remote_data = {}) {
base::RunLoop loop;
syncer::DataTypeActivationRequest request;
request.error_handler = base::DoNothing();
request.cache_guid = kDefaultCacheGuid;
real_processor_->OnSyncStarting(
request,
base::BindLambdaForTesting(
[&loop](std::unique_ptr<syncer::DataTypeActivationResponse>) {
loop.Quit();
}));
loop.Run();
ReceiveUpdates(remote_data);
}
void ReceiveUpdates(const std::vector<WalletMetadataSpecifics>& remote_data) {
// Make sure each update has an updated response version so that it does not
// get filtered out as reflection by the processor.
++response_version;
// After this update initial sync is for sure done.
sync_pb::ModelTypeState state;
state.set_initial_sync_done(true);
syncer::UpdateResponseDataList updates;
for (const WalletMetadataSpecifics& specifics : remote_data) {
updates.push_back(SpecificsToUpdateResponse(specifics));
}
real_processor_->OnUpdateReceived(state, std::move(updates));
}
void ReceiveTombstones(
const std::vector<WalletMetadataSpecifics>& remote_tombstones) {
// Make sure each update has an updated response version so that it does not
// get filtered out as reflection by the processor.
++response_version;
// After this update initial sync is for sure done.
sync_pb::ModelTypeState state;
state.set_initial_sync_done(true);
syncer::UpdateResponseDataList updates;
for (const WalletMetadataSpecifics& specifics : remote_tombstones) {
updates.push_back(
SpecificsToUpdateResponse(specifics, /*is_deleted=*/true));
}
real_processor_->OnUpdateReceived(state, std::move(updates));
}
EntityData SpecificsToEntity(const WalletMetadataSpecifics& specifics,
bool is_deleted = false) {
EntityData data;
*data.specifics.mutable_wallet_metadata() = specifics;
data.client_tag_hash = syncer::ClientTagHash::FromUnhashed(
syncer::AUTOFILL_WALLET_METADATA, bridge()->GetClientTag(data));
if (is_deleted) {
// Specifics had to be set in order to generate the client tag. Since
// deleted entity is defined by specifics being empty, we need to clear
// them now.
data.specifics = sync_pb::EntitySpecifics();
}
return data;
}
syncer::UpdateResponseData SpecificsToUpdateResponse(
const WalletMetadataSpecifics& specifics,
bool is_deleted = false) {
syncer::UpdateResponseData data;
data.entity = SpecificsToEntity(specifics, is_deleted);
data.response_version = response_version;
return data;
}
std::vector<WalletMetadataSpecifics> GetAllLocalData() {
std::vector<WalletMetadataSpecifics> data;
// Perform an async call synchronously for testing.
base::RunLoop loop;
bridge()->GetAllDataForDebugging(base::BindLambdaForTesting(
[&loop, &data](std::unique_ptr<DataBatch> batch) {
ExtractWalletMetadataSpecificsFromDataBatch(std::move(batch), &data);
loop.Quit();
}));
loop.Run();
return data;
}
// Like GetAllData() but it also checks that cache is consistent with the disk
// content.
std::vector<WalletMetadataSpecifics> GetAllLocalDataInclRestart() {
std::vector<WalletMetadataSpecifics> data_before = GetAllLocalData();
ResetProcessor();
ResetBridge();
std::vector<WalletMetadataSpecifics> data_after = GetAllLocalData();
EXPECT_THAT(GetSortedSerializedSpecifics(data_before),
ElementsAreArray(GetSortedSerializedSpecifics(data_after)));
return data_after;
}
std::vector<WalletMetadataSpecifics> GetLocalData(
AutofillWalletMetadataSyncBridge::StorageKeyList storage_keys) {
std::vector<WalletMetadataSpecifics> data;
// Perform an async call synchronously for testing.
base::RunLoop loop;
bridge()->GetData(storage_keys,
base::BindLambdaForTesting(
[&loop, &data](std::unique_ptr<DataBatch> batch) {
ExtractWalletMetadataSpecificsFromDataBatch(
std::move(batch), &data);
loop.Quit();
}));
loop.Run();
return data;
}
std::vector<std::string> GetLocalSyncMetadataStorageKeys() {
std::vector<std::string> storage_keys;
AutofillTable* table = AutofillTable::FromWebDatabase(&db_);
syncer::MetadataBatch batch;
if (table->GetAllSyncMetadata(syncer::AUTOFILL_WALLET_METADATA, &batch)) {
for (const std::pair<const std::string,
std::unique_ptr<sync_pb::EntityMetadata>>& entry :
batch.GetAllMetadata()) {
storage_keys.push_back(entry.first);
}
}
return storage_keys;
}
void AdvanceTestClockByTwoYears() {
test_clock_.Advance(base::Days(365 * 2));
}
AutofillWalletMetadataSyncBridge* bridge() { return bridge_.get(); }
syncer::MockModelTypeChangeProcessor& mock_processor() {
return mock_processor_;
}
syncer::ClientTagBasedModelTypeProcessor* real_processor() {
return real_processor_.get();
}
AutofillTable* table() { return &table_; }
MockAutofillWebDataBackend* backend() { return &backend_; }
private:
int response_version = 0;
autofill::TestAutofillClock test_clock_;
ScopedTempDir temp_dir_;
base::test::SingleThreadTaskEnvironment task_environment_;
testing::NiceMock<MockAutofillWebDataBackend> backend_;
AutofillTable table_;
WebDatabase db_;
testing::NiceMock<MockModelTypeChangeProcessor> mock_processor_;
std::unique_ptr<syncer::ClientTagBasedModelTypeProcessor> real_processor_;
std::unique_ptr<AutofillWalletMetadataSyncBridge> bridge_;
};
// The following 2 tests make sure client tags stay stable.
TEST_F(AutofillWalletMetadataSyncBridgeTest, GetClientTagForAddress) {
ResetBridge();
WalletMetadataSpecifics specifics =
CreateWalletMetadataSpecificsForAddress(kAddr1SpecificsId);
EXPECT_EQ(bridge()->GetClientTag(SpecificsToEntity(specifics)),
kAddr1SyncTag);
}
TEST_F(AutofillWalletMetadataSyncBridgeTest, GetClientTagForCard) {
ResetBridge();
WalletMetadataSpecifics specifics =
CreateWalletMetadataSpecificsForCard(kCard1SpecificsId);
EXPECT_EQ(bridge()->GetClientTag(SpecificsToEntity(specifics)),
kCard1SyncTag);
}
// The following 2 tests make sure storage keys stay stable.
TEST_F(AutofillWalletMetadataSyncBridgeTest, GetStorageKeyForAddress) {
ResetBridge();
WalletMetadataSpecifics specifics =
CreateWalletMetadataSpecificsForAddress(kAddr1SpecificsId);
EXPECT_EQ(bridge()->GetStorageKey(SpecificsToEntity(specifics)),
GetAddressStorageKey(kAddr1SpecificsId));
}
TEST_F(AutofillWalletMetadataSyncBridgeTest, GetStorageKeyForCard) {
ResetBridge();
WalletMetadataSpecifics specifics =
CreateWalletMetadataSpecificsForCard(kCard1SpecificsId);
EXPECT_EQ(bridge()->GetStorageKey(SpecificsToEntity(specifics)),
GetCardStorageKey(kCard1SpecificsId));
}
TEST_F(AutofillWalletMetadataSyncBridgeTest,
GetAllDataForDebugging_ShouldReturnAllData) {
table()->SetServerProfiles({CreateServerProfile(kAddr1ServerId),
CreateServerProfile(kAddr2ServerId)});
table()->SetServerCreditCards({CreateServerCreditCard(kCard1ServerId),
CreateServerCreditCard(kCard2ServerId)});
ResetBridge();
EXPECT_THAT(
GetAllLocalData(),
UnorderedElementsAre(
EqualsSpecifics(
CreateWalletMetadataSpecificsForAddress(kAddr1SpecificsId)),
EqualsSpecifics(
CreateWalletMetadataSpecificsForAddress(kAddr2SpecificsId)),
EqualsSpecifics(
CreateWalletMetadataSpecificsForCard(kCard1SpecificsId)),
EqualsSpecifics(
CreateWalletMetadataSpecificsForCard(kCard2SpecificsId))));
}
TEST_F(AutofillWalletMetadataSyncBridgeTest,
GetData_ShouldNotReturnNonexistentData) {
ResetBridge();
EXPECT_THAT(GetLocalData({GetAddressStorageKey(kAddr1SpecificsId)}),
IsEmpty());
}
TEST_F(AutofillWalletMetadataSyncBridgeTest, GetData_ShouldReturnSelectedData) {
table()->SetServerProfiles({CreateServerProfile(kAddr1ServerId),
CreateServerProfile(kAddr2ServerId)});
table()->SetServerCreditCards({CreateServerCreditCard(kCard1ServerId),
CreateServerCreditCard(kCard2ServerId)});
ResetBridge();
EXPECT_THAT(GetLocalData({GetAddressStorageKey(kAddr1SpecificsId),
GetCardStorageKey(kCard1SpecificsId)}),
UnorderedElementsAre(
EqualsSpecifics(CreateWalletMetadataSpecificsForAddress(
kAddr1SpecificsId)),
EqualsSpecifics(CreateWalletMetadataSpecificsForCard(
kCard1SpecificsId))));
}
TEST_F(AutofillWalletMetadataSyncBridgeTest, GetData_ShouldReturnCompleteData) {
AutofillProfile profile = CreateServerProfile(kAddr1ServerId);
profile.set_use_count(5);
profile.set_use_date(UseDateFromProtoValue(2));
profile.set_has_converted(true);
table()->SetServerProfiles({profile});
CreditCard card = CreateServerCreditCard(kCard1ServerId);
card.set_use_count(6);
card.set_use_date(UseDateFromProtoValue(3));
card.set_billing_address_id(kAddr1ServerId);
table()->SetServerCreditCards({card});
ResetBridge();
// Expect to retrieve following specifics:
WalletMetadataSpecifics profile_specifics =
CreateWalletMetadataSpecificsForAddress(kAddr1SpecificsId);
profile_specifics.set_use_count(5);
profile_specifics.set_use_date(2);
profile_specifics.set_address_has_converted(true);
WalletMetadataSpecifics card_specifics =
CreateWalletMetadataSpecificsForCard(kCard1SpecificsId);
card_specifics.set_use_count(6);
card_specifics.set_use_date(3);
card_specifics.set_card_billing_address_id(kAddr1SpecificsId);
EXPECT_THAT(GetLocalData({GetAddressStorageKey(kAddr1SpecificsId),
GetCardStorageKey(kCard1SpecificsId)}),
UnorderedElementsAre(EqualsSpecifics(profile_specifics),
EqualsSpecifics(card_specifics)));
}
TEST_F(AutofillWalletMetadataSyncBridgeTest,
ApplyStopSyncChanges_ShouldWipeLocalDataWhenSyncStopped) {
// Perform initial sync to create sync data & metadata.
ResetBridge(/*initial_sync_done=*/false);
WalletMetadataSpecifics profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/10, /*use_date=*/20);
WalletMetadataSpecifics card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/30, /*use_date=*/40);
StartSyncing({profile, card});
// Now stop sync. This should wipe the data but not notify the backend (as the
// data bridge will do that).
EXPECT_CALL(*backend(), CommitChanges());
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges()).Times(0);
StopSyncing();
EXPECT_THAT(GetAllLocalDataInclRestart(), IsEmpty());
}
TEST_F(AutofillWalletMetadataSyncBridgeTest,
ApplyStopSyncChanges_ShouldKeepLocalDataOnShutdown) {
// Perform initial sync to create sync data & metadata.
ResetBridge(/*initial_sync_done=*/false);
WalletMetadataSpecifics profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/10, /*use_date=*/20);
WalletMetadataSpecifics card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/30, /*use_date=*/40);
StartSyncing({profile, card});
// Now simulate shutting down the browser. This should not touch any of the
// data and thus also not notify the backend.
EXPECT_CALL(*backend(), CommitChanges()).Times(0);
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges()).Times(0);
Shutdown();
EXPECT_THAT(
GetAllLocalDataInclRestart(),
UnorderedElementsAre(EqualsSpecifics(profile), EqualsSpecifics(card)));
}
// Verify that lower values of metadata are not sent to the sync server when
// local metadata is updated.
TEST_F(AutofillWalletMetadataSyncBridgeTest,
DontSendLowerValueToServerOnUpdate) {
table()->SetServerProfiles({CreateServerProfileWithDetails(
kAddr1ServerId, /*use_count=*/2, /*use_date=*/5)});
table()->SetServerCreditCards({CreateServerCreditCardWithDetails(
kCard1ServerId, /*use_count=*/3, /*use_date=*/6)});
ResetBridge();
AutofillProfile updated_profile = CreateServerProfileWithDetails(
kAddr1ServerId, /*use_count=*/1, /*use_date=*/4);
CreditCard updated_card = CreateServerCreditCardWithDetails(
kCard1ServerId, /*use_count=*/2, /*use_date=*/5);
EXPECT_CALL(mock_processor(), Put(_, _, _)).Times(0);
// Local changes should not cause local DB writes.
EXPECT_CALL(*backend(), CommitChanges()).Times(0);
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges()).Times(0);
bridge()->AutofillProfileChanged(
AutofillProfileChange(AutofillProfileChange::UPDATE,
updated_profile.server_id(), &updated_profile));
bridge()->CreditCardChanged(CreditCardChange(
CreditCardChange::UPDATE, updated_card.server_id(), &updated_card));
// Check that also the local metadata did not get updated.
EXPECT_THAT(
GetAllLocalDataInclRestart(),
UnorderedElementsAre(
EqualsSpecifics(CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/2, /*use_date=*/5)),
EqualsSpecifics(CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/3, /*use_date=*/6))));
}
// Verify that lower values of metadata are not sent to the sync server when
// local metadata is created (tests the case when metadata with higher use
// counts arrive before the data, the data bridge later notifies about creation
// for data that is already there).
TEST_F(AutofillWalletMetadataSyncBridgeTest,
DontSendLowerValueToServerOnCreation) {
table()->SetServerProfiles({CreateServerProfileWithDetails(
kAddr1ServerId, /*use_count=*/2, /*use_date=*/5)});
table()->SetServerCreditCards({CreateServerCreditCardWithDetails(
kCard1ServerId, /*use_count=*/3, /*use_date=*/6)});
ResetBridge();
AutofillProfile updated_profile = CreateServerProfileWithDetails(
kAddr1ServerId, /*use_count=*/1, /*use_date=*/4);
CreditCard updated_card = CreateServerCreditCardWithDetails(
kCard1ServerId, /*use_count=*/2, /*use_date=*/5);
EXPECT_CALL(mock_processor(), Put(_, _, _)).Times(0);
// Local changes should not cause local DB writes.
EXPECT_CALL(*backend(), CommitChanges()).Times(0);
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges()).Times(0);
bridge()->AutofillProfileChanged(
AutofillProfileChange(AutofillProfileChange::ADD,
updated_profile.server_id(), &updated_profile));
bridge()->CreditCardChanged(CreditCardChange(
CreditCardChange::ADD, updated_card.server_id(), &updated_card));
// Check that also the local metadata did not get updated.
EXPECT_THAT(
GetAllLocalDataInclRestart(),
UnorderedElementsAre(
EqualsSpecifics(CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/2, /*use_date=*/5)),
EqualsSpecifics(CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/3, /*use_date=*/6))));
}
// Verify that higher values of metadata are sent to the sync server when local
// metadata is updated.
TEST_F(AutofillWalletMetadataSyncBridgeTest,
SendHigherValuesToServerOnLocalUpdate) {
table()->SetServerProfiles({CreateServerProfileWithDetails(
kAddr1ServerId, /*use_count=*/1, /*use_date=*/2)});
table()->SetServerCreditCards({CreateServerCreditCardWithDetails(
kCard1ServerId, /*use_count=*/3, /*use_date=*/4)});
ResetBridge();
AutofillProfile updated_profile = CreateServerProfileWithDetails(
kAddr1ServerId, /*use_count=*/10, /*use_date=*/20);
CreditCard updated_card = CreateServerCreditCardWithDetails(
kCard1ServerId, /*use_count=*/30, /*use_date=*/40);
WalletMetadataSpecifics expected_profile_specifics =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/10, /*use_date=*/20);
WalletMetadataSpecifics expected_card_specifics =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/30, /*use_date=*/40);
EXPECT_CALL(
mock_processor(),
Put(kAddr1StorageKey, HasSpecifics(expected_profile_specifics), _));
EXPECT_CALL(mock_processor(),
Put(kCard1StorageKey, HasSpecifics(expected_card_specifics), _));
// Local changes should not cause local DB writes.
EXPECT_CALL(*backend(), CommitChanges()).Times(0);
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges()).Times(0);
bridge()->AutofillProfileChanged(
AutofillProfileChange(AutofillProfileChange::UPDATE,
updated_profile.server_id(), &updated_profile));
bridge()->CreditCardChanged(CreditCardChange(
CreditCardChange::UPDATE, updated_card.server_id(), &updated_card));
// Check that the local metadata got update as well.
EXPECT_THAT(GetAllLocalDataInclRestart(),
UnorderedElementsAre(EqualsSpecifics(expected_profile_specifics),
EqualsSpecifics(expected_card_specifics)));
}
// Verify that one-off addition of metadata is sent to the sync server.
TEST_F(AutofillWalletMetadataSyncBridgeTest,
SendNewDataToServerOnLocalAddition) {
ResetBridge();
AutofillProfile new_profile = CreateServerProfileWithDetails(
kAddr1ServerId, /*use_count=*/10, /*use_date=*/20);
CreditCard new_card = CreateServerCreditCardWithDetails(
kCard1ServerId, /*use_count=*/30, /*use_date=*/40);
WalletMetadataSpecifics expected_profile_specifics =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/10, /*use_date=*/20);
WalletMetadataSpecifics expected_card_specifics =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/30, /*use_date=*/40);
EXPECT_CALL(
mock_processor(),
Put(kAddr1StorageKey, HasSpecifics(expected_profile_specifics), _));
EXPECT_CALL(mock_processor(),
Put(kCard1StorageKey, HasSpecifics(expected_card_specifics), _));
// Local changes should not cause local DB writes.
EXPECT_CALL(*backend(), CommitChanges()).Times(0);
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges()).Times(0);
bridge()->AutofillProfileChanged(AutofillProfileChange(
AutofillProfileChange::ADD, new_profile.server_id(), &new_profile));
bridge()->CreditCardChanged(
CreditCardChange(CreditCardChange::ADD, new_card.server_id(), &new_card));
// Check that the new metadata got created as well.
EXPECT_THAT(GetAllLocalDataInclRestart(),
UnorderedElementsAre(EqualsSpecifics(expected_profile_specifics),
EqualsSpecifics(expected_card_specifics)));
}
// Verify that one-off addition of metadata is sent to the sync server (even
// though it is notified as an update). This tests that the bridge is robust and
// recreates metadata that may get deleted in the mean-time).
TEST_F(AutofillWalletMetadataSyncBridgeTest, SendNewDataToServerOnLocalUpdate) {
ResetBridge();
AutofillProfile new_profile = CreateServerProfileWithDetails(
kAddr1ServerId, /*use_count=*/10, /*use_date=*/20);
CreditCard new_card = CreateServerCreditCardWithDetails(
kCard1ServerId, /*use_count=*/30, /*use_date=*/40);
WalletMetadataSpecifics expected_profile_specifics =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/10, /*use_date=*/20);
WalletMetadataSpecifics expected_card_specifics =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/30, /*use_date=*/40);
EXPECT_CALL(
mock_processor(),
Put(kAddr1StorageKey, HasSpecifics(expected_profile_specifics), _));
EXPECT_CALL(mock_processor(),
Put(kCard1StorageKey, HasSpecifics(expected_card_specifics), _));
// Local changes should not cause local DB writes.
EXPECT_CALL(*backend(), CommitChanges()).Times(0);
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges()).Times(0);
bridge()->AutofillProfileChanged(AutofillProfileChange(
AutofillProfileChange::UPDATE, new_profile.server_id(), &new_profile));
bridge()->CreditCardChanged(CreditCardChange(
CreditCardChange::UPDATE, new_card.server_id(), &new_card));
// Check that the new metadata got created as well.
EXPECT_THAT(GetAllLocalDataInclRestart(),
UnorderedElementsAre(EqualsSpecifics(expected_profile_specifics),
EqualsSpecifics(expected_card_specifics)));
}
// Verify that one-off deletion of existing metadata is sent to the sync server.
TEST_F(AutofillWalletMetadataSyncBridgeTest,
DeleteExistingDataFromServerOnLocalDeletion) {
AutofillProfile existing_profile = CreateServerProfileWithDetails(
kAddr1ServerId, /*use_count=*/10, /*use_date=*/20);
CreditCard existing_card = CreateServerCreditCardWithDetails(
kCard1ServerId, /*use_count=*/30, /*use_date=*/40);
table()->SetServerProfiles({existing_profile});
table()->SetServerCreditCards({existing_card});
ResetBridge();
EXPECT_CALL(mock_processor(), Delete(kAddr1StorageKey, _));
EXPECT_CALL(mock_processor(), Delete(kCard1StorageKey, _));
// Local changes should not cause local DB writes.
EXPECT_CALL(*backend(), CommitChanges()).Times(0);
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges()).Times(0);
bridge()->AutofillProfileChanged(
AutofillProfileChange(AutofillProfileChange::REMOVE,
existing_profile.server_id(), &existing_profile));
bridge()->CreditCardChanged(CreditCardChange(
CreditCardChange::REMOVE, existing_card.server_id(), &existing_card));
// Check that there is no metadata anymore.
EXPECT_THAT(GetAllLocalDataInclRestart(), IsEmpty());
}
// Verify that deletion of non-existing metadata is not sent to the sync server.
TEST_F(AutofillWalletMetadataSyncBridgeTest,
DoNotDeleteNonExistingDataFromServerOnLocalDeletion) {
AutofillProfile existing_profile = CreateServerProfileWithDetails(
kAddr1ServerId, /*use_count=*/10, /*use_date=*/20);
CreditCard existing_card = CreateServerCreditCardWithDetails(
kCard1ServerId, /*use_count=*/30, /*use_date=*/40);
// Save only data and not metadata.
table()->SetServerAddressesData({existing_profile});
table()->SetServerCardsData({existing_card});
ResetBridge();
// Check that there is no metadata, from start on.
ASSERT_THAT(GetAllLocalDataInclRestart(), IsEmpty());
EXPECT_CALL(mock_processor(), Delete(_, _)).Times(0);
// Local changes should not cause local DB writes.
EXPECT_CALL(*backend(), CommitChanges()).Times(0);
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges()).Times(0);
bridge()->AutofillProfileChanged(
AutofillProfileChange(AutofillProfileChange::REMOVE,
existing_profile.server_id(), &existing_profile));
bridge()->CreditCardChanged(CreditCardChange(
CreditCardChange::REMOVE, existing_card.server_id(), &existing_card));
// Check that there is also no metadata at the end.
EXPECT_THAT(GetAllLocalDataInclRestart(), IsEmpty());
}
// Verify that updates of local (non-sync) addresses are ignored.
TEST_F(AutofillWalletMetadataSyncBridgeTest, DoNotPropagateNonSyncAddresses) {
// Add local data.
AutofillProfile existing_profile =
CreateLocalProfileWithDetails(/*use_count=*/10, /*use_date=*/20);
table()->AddAutofillProfile(existing_profile);
ResetBridge();
// Check that there is no metadata, from start on.
ASSERT_THAT(GetAllLocalDataInclRestart(), IsEmpty());
EXPECT_CALL(mock_processor(), Put).Times(0);
// Local changes should not cause local DB writes.
EXPECT_CALL(*backend(), CommitChanges()).Times(0);
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges()).Times(0);
existing_profile.set_use_count(11);
existing_profile.set_use_date(UseDateFromProtoValue(21));
bridge()->AutofillProfileChanged(
AutofillProfileChange(AutofillProfileChange::UPDATE,
existing_profile.guid(), &existing_profile));
// Check that there is also no metadata at the end.
EXPECT_THAT(GetAllLocalDataInclRestart(), IsEmpty());
}
// Verify that updates of local (non-sync) credit cards are ignored.
// Regression test for crbug.com/1206306.
TEST_F(AutofillWalletMetadataSyncBridgeTest, DoNotPropagateNonSyncCards) {
// Local credit cards need crypto for storage.
OSCryptMocker::SetUp();
// Add local data.
CreditCard existing_card =
CreateLocalCreditCardWithDetails(/*use_count=*/30, /*use_date=*/40);
table()->AddCreditCard(existing_card);
ResetBridge();
// Check that there is no metadata, from start on.
ASSERT_THAT(GetAllLocalDataInclRestart(), IsEmpty());
EXPECT_CALL(mock_processor(), Put).Times(0);
// Local changes should not cause local DB writes.
EXPECT_CALL(*backend(), CommitChanges()).Times(0);
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges()).Times(0);
existing_card.set_use_count(31);
existing_card.set_use_date(UseDateFromProtoValue(41));
bridge()->CreditCardChanged(CreditCardChange(
AutofillProfileChange::UPDATE, existing_card.guid(), &existing_card));
// Check that there is also no metadata at the end.
EXPECT_THAT(GetAllLocalDataInclRestart(), IsEmpty());
OSCryptMocker::TearDown();
}
// Verify that old orphan metadata gets deleted on startup.
TEST_F(AutofillWalletMetadataSyncBridgeTest, DeleteOldOrphanMetadataOnStartup) {
WalletMetadataSpecifics profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/10, /*use_date=*/20);
WalletMetadataSpecifics card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/30, /*use_date=*/40);
// Save only metadata and not data - simulate an orphan.
table()->AddServerAddressMetadata(
CreateServerProfileFromSpecifics(profile).GetMetadata());
table()->AddServerCardMetadata(
CreateServerCreditCardFromSpecifics(card).GetMetadata());
// Make the orphans old by advancing time.
AdvanceTestClockByTwoYears();
EXPECT_CALL(mock_processor(), Delete(kAddr1StorageKey, _));
EXPECT_CALL(mock_processor(), Delete(kCard1StorageKey, _));
EXPECT_CALL(*backend(), CommitChanges());
ResetBridge();
ASSERT_THAT(GetAllLocalDataInclRestart(), IsEmpty());
}
// Verify that recent orphan metadata does not get deleted on startup.
TEST_F(AutofillWalletMetadataSyncBridgeTest,
DoNotDeleteOldNonOrphanMetadataOnStartup) {
WalletMetadataSpecifics profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/10, /*use_date=*/20);
WalletMetadataSpecifics card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/30, /*use_date=*/40);
// Save both data and metadata - these are not orphans.
table()->SetServerProfiles({CreateServerProfileFromSpecifics(profile)});
table()->SetServerCreditCards({CreateServerCreditCardFromSpecifics(card)});
// Make the entities old by advancing time.
AdvanceTestClockByTwoYears();
// Since the entities are non-oprhans, they should not get deleted.
EXPECT_CALL(mock_processor(), Delete(_, _)).Times(0);
EXPECT_CALL(*backend(), CommitChanges()).Times(0);
ResetBridge();
EXPECT_THAT(
GetAllLocalDataInclRestart(),
UnorderedElementsAre(EqualsSpecifics(profile), EqualsSpecifics(card)));
}
// Verify that recent orphan metadata does not get deleted on startup.
TEST_F(AutofillWalletMetadataSyncBridgeTest,
DoNotDeleteRecentOrphanMetadataOnStartup) {
WalletMetadataSpecifics profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/10, /*use_date=*/20);
WalletMetadataSpecifics card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/30, /*use_date=*/40);
// Save only metadata and not data - simulate an orphan.
table()->AddServerAddressMetadata(
CreateServerProfileFromSpecifics(profile).GetMetadata());
table()->AddServerCardMetadata(
CreateServerCreditCardFromSpecifics(card).GetMetadata());
// We do not advance time so the orphans are recent, should not get deleted.
EXPECT_CALL(mock_processor(), Delete(_, _)).Times(0);
EXPECT_CALL(*backend(), CommitChanges()).Times(0);
ResetBridge();
EXPECT_THAT(
GetAllLocalDataInclRestart(),
UnorderedElementsAre(EqualsSpecifics(profile), EqualsSpecifics(card)));
}
// Test that both local cards and local profiles that are not in the remote data
// set are uploaded during initial sync. This should rarely happen in practice
// because we wipe local data when disabling sync. Still there are corner cases
// such as when PDM manages to change metadata before the metadata bridge
// performs initial sync.
TEST_F(AutofillWalletMetadataSyncBridgeTest,
InitialSync_UploadUniqueLocalData) {
WalletMetadataSpecifics preexisting_profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/10, /*use_date=*/20);
WalletMetadataSpecifics preexisting_card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/30, /*use_date=*/40);
table()->SetServerProfiles(
{CreateServerProfileFromSpecifics(preexisting_profile)});
table()->SetServerCreditCards(
{CreateServerCreditCardFromSpecifics(preexisting_card)});
// Have different entities on the server.
WalletMetadataSpecifics remote_profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr2SpecificsId, /*use_count=*/10, /*use_date=*/20);
WalletMetadataSpecifics remote_card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard2SpecificsId, /*use_count=*/30, /*use_date=*/40);
// The bridge should upload the unique local entities and store the remote
// ones locally.
EXPECT_CALL(mock_processor(),
Put(kAddr1StorageKey, HasSpecifics(preexisting_profile), _));
EXPECT_CALL(mock_processor(),
Put(kCard1StorageKey, HasSpecifics(preexisting_card), _));
EXPECT_CALL(mock_processor(), Delete(_, _)).Times(0);
EXPECT_CALL(*backend(), CommitChanges());
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges());
ResetBridge(/*initial_sync_done=*/false);
StartSyncing({remote_profile, remote_card});
EXPECT_THAT(GetAllLocalDataInclRestart(),
UnorderedElementsAre(EqualsSpecifics(preexisting_profile),
EqualsSpecifics(preexisting_card),
EqualsSpecifics(remote_profile),
EqualsSpecifics(remote_card)));
}
// Test that the initial sync correctly distinguishes data that is unique in the
// local data set from data that is both in the local data and in the remote
// data. We should only upload the local data. This should rarely happen in
// practice because we wipe local data when disabling sync. Still there are
// corner cases such as when PDM manages to change metadata before the metadata
// bridge performs initial sync.
TEST_F(AutofillWalletMetadataSyncBridgeTest,
InitialSync_UploadOnlyUniqueLocalData) {
WalletMetadataSpecifics preexisting_profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/10, /*use_date=*/20);
WalletMetadataSpecifics preexisting_card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/30, /*use_date=*/40);
table()->SetServerProfiles(
{CreateServerProfileFromSpecifics(preexisting_profile)});
table()->SetServerCreditCards(
{CreateServerCreditCardFromSpecifics(preexisting_card)});
// The remote profile has the same id as local profile, only is newer.
WalletMetadataSpecifics remote_profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/15, /*use_date=*/25);
WalletMetadataSpecifics remote_card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard2SpecificsId, /*use_count=*/30, /*use_date=*/40);
// Upload _only_ the unique local data, only the card.
EXPECT_CALL(mock_processor(),
Put(kCard1StorageKey, HasSpecifics(preexisting_card), _));
EXPECT_CALL(mock_processor(), Delete(_, _)).Times(0);
EXPECT_CALL(*backend(), CommitChanges());
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges());
ResetBridge(/*initial_sync_done=*/false);
StartSyncing({remote_profile, remote_card});
EXPECT_THAT(GetAllLocalDataInclRestart(),
UnorderedElementsAre(EqualsSpecifics(preexisting_card),
EqualsSpecifics(remote_profile),
EqualsSpecifics(remote_card)));
}
// Test that remote deletions are ignored.
TEST_F(AutofillWalletMetadataSyncBridgeTest,
RemoteDeletion_ShouldNotDeleteExistingLocalData) {
// Perform initial sync to create sync data & metadata.
ResetBridge(/*initial_sync_done=*/false);
WalletMetadataSpecifics profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/10, /*use_date=*/20);
WalletMetadataSpecifics card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/30, /*use_date=*/40);
StartSyncing({profile, card});
// Verify that both the processor and the local DB contain sync metadata.
ASSERT_TRUE(real_processor()->IsTrackingEntityForTest(kAddr1StorageKey));
ASSERT_TRUE(real_processor()->IsTrackingEntityForTest(kCard1StorageKey));
ASSERT_THAT(GetLocalSyncMetadataStorageKeys(),
UnorderedElementsAre(kAddr1StorageKey, kCard1StorageKey));
// Now delete the profile.
// We still need to commit the updated progress marker and sync metadata.
EXPECT_CALL(*backend(), CommitChanges());
// Changes should _not_ happen in the local autofill database.
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges()).Times(0);
ReceiveTombstones({profile, card});
// Verify that even though the processor does not track these entities any
// more and the sync metadata is gone, the actual data entities still exist in
// the local DB.
EXPECT_FALSE(real_processor()->IsTrackingEntityForTest(kAddr1StorageKey));
EXPECT_FALSE(real_processor()->IsTrackingEntityForTest(kCard1StorageKey));
EXPECT_THAT(GetLocalSyncMetadataStorageKeys(), IsEmpty());
EXPECT_THAT(
GetAllLocalDataInclRestart(),
UnorderedElementsAre(EqualsSpecifics(profile), EqualsSpecifics(card)));
}
enum RemoteChangesMode {
INITIAL_SYNC_ADD, // Initial sync -> ADD changes.
LATER_SYNC_ADD, // Later sync; the client receives the data for the first
// time -> ADD changes.
LATER_SYNC_UPDATE // Later sync; the client has received the data before ->
// UPDATE changes.
};
// Parametrized fixture for tests that apply in the same way for all
// RemoteChangesModes.
class AutofillWalletMetadataSyncBridgeRemoteChangesTest
: public testing::WithParamInterface<RemoteChangesMode>,
public AutofillWalletMetadataSyncBridgeTest {
public:
AutofillWalletMetadataSyncBridgeRemoteChangesTest() {}
AutofillWalletMetadataSyncBridgeRemoteChangesTest(
const AutofillWalletMetadataSyncBridgeRemoteChangesTest&) = delete;
AutofillWalletMetadataSyncBridgeRemoteChangesTest& operator=(
const AutofillWalletMetadataSyncBridgeRemoteChangesTest&) = delete;
~AutofillWalletMetadataSyncBridgeRemoteChangesTest() override {}
void ResetBridgeWithPotentialInitialSync(
const std::vector<WalletMetadataSpecifics>& remote_data) {
ResetBridge(/*initial_sync_done=*/GetParam() != INITIAL_SYNC_ADD);
if (GetParam() == LATER_SYNC_UPDATE) {
StartSyncing(remote_data);
}
}
void ReceivePotentiallyInitialUpdates(
const std::vector<WalletMetadataSpecifics>& remote_data) {
if (GetParam() != LATER_SYNC_UPDATE) {
StartSyncing(remote_data);
} else {
ReceiveUpdates(remote_data);
}
}
};
// No upstream communication or local DB change happens if the server sends an
// empty update.
TEST_P(AutofillWalletMetadataSyncBridgeRemoteChangesTest, EmptyUpdateIgnored) {
ResetBridgeWithPotentialInitialSync({});
EXPECT_CALL(mock_processor(), Delete(_, _)).Times(0);
EXPECT_CALL(mock_processor(), Put(_, _, _)).Times(0);
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges()).Times(0);
// We still need to commit the updated progress marker.
EXPECT_CALL(*backend(), CommitChanges());
ReceivePotentiallyInitialUpdates({});
EXPECT_THAT(GetAllLocalDataInclRestart(), IsEmpty());
}
// No upstream communication or local DB change happens if the server sends the
// same data as we have locally.
TEST_P(AutofillWalletMetadataSyncBridgeRemoteChangesTest, SameDataIgnored) {
WalletMetadataSpecifics profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/2, /*use_date=*/5);
WalletMetadataSpecifics card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/3, /*use_date=*/6);
table()->SetServerProfiles({CreateServerProfileFromSpecifics(profile)});
table()->SetServerCreditCards({CreateServerCreditCardFromSpecifics(card)});
ResetBridgeWithPotentialInitialSync({profile, card});
EXPECT_CALL(mock_processor(), Delete(_, _)).Times(0);
EXPECT_CALL(mock_processor(), Put(_, _, _)).Times(0);
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges()).Times(0);
// We still need to commit the updated progress marker.
EXPECT_CALL(*backend(), CommitChanges());
ReceivePotentiallyInitialUpdates({profile, card});
EXPECT_THAT(
GetAllLocalDataInclRestart(),
UnorderedElementsAre(EqualsSpecifics(profile), EqualsSpecifics(card)));
}
// Tests that if the remote use stats are higher / newer, they should win over
// local stats.
TEST_P(AutofillWalletMetadataSyncBridgeRemoteChangesTest,
Conflict_PreferHigherValues_RemoteWins) {
WalletMetadataSpecifics profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/2, /*use_date=*/5);
WalletMetadataSpecifics card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/3, /*use_date=*/6);
table()->SetServerProfiles({CreateServerProfileFromSpecifics(profile)});
table()->SetServerCreditCards({CreateServerCreditCardFromSpecifics(card)});
ResetBridgeWithPotentialInitialSync({profile, card});
WalletMetadataSpecifics updated_remote_profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/20, /*use_date=*/50);
WalletMetadataSpecifics updated_remote_card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/30, /*use_date=*/60);
EXPECT_CALL(mock_processor(), Delete(_, _)).Times(0);
EXPECT_CALL(mock_processor(), Put(_, _, _)).Times(0);
EXPECT_CALL(*backend(), CommitChanges());
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges());
ReceivePotentiallyInitialUpdates(
{updated_remote_profile, updated_remote_card});
EXPECT_THAT(GetAllLocalDataInclRestart(),
UnorderedElementsAre(EqualsSpecifics(updated_remote_profile),
EqualsSpecifics(updated_remote_card)));
}
// Tests that if the local use stats are higher / newer, they should win over
// remote stats.
TEST_P(AutofillWalletMetadataSyncBridgeRemoteChangesTest,
Conflict_PreferHigherValues_LocalWins) {
WalletMetadataSpecifics profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/20, /*use_date=*/50);
WalletMetadataSpecifics card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/30, /*use_date=*/60);
table()->SetServerProfiles({CreateServerProfileFromSpecifics(profile)});
table()->SetServerCreditCards({CreateServerCreditCardFromSpecifics(card)});
ResetBridgeWithPotentialInitialSync({profile, card});
WalletMetadataSpecifics updated_remote_profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/2, /*use_date=*/5);
WalletMetadataSpecifics updated_remote_card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/3, /*use_date=*/6);
EXPECT_CALL(mock_processor(), Delete(_, _)).Times(0);
EXPECT_CALL(mock_processor(),
Put(kAddr1StorageKey, HasSpecifics(profile), _));
EXPECT_CALL(mock_processor(), Put(kCard1StorageKey, HasSpecifics(card), _));
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges()).Times(0);
// We still need to commit the updated progress marker.
EXPECT_CALL(*backend(), CommitChanges());
ReceivePotentiallyInitialUpdates(
{updated_remote_profile, updated_remote_card});
EXPECT_THAT(
GetAllLocalDataInclRestart(),
UnorderedElementsAre(EqualsSpecifics(profile), EqualsSpecifics(card)));
}
// Tests that the conflicts are resolved component-wise (a higher use_count is
// taken from local data, a newer use_data is taken from remote data).
TEST_P(AutofillWalletMetadataSyncBridgeRemoteChangesTest,
Conflict_PreferHigherValues_BothWin1) {
WalletMetadataSpecifics profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/20, /*use_date=*/5);
WalletMetadataSpecifics card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/30, /*use_date=*/6);
table()->SetServerProfiles({CreateServerProfileFromSpecifics(profile)});
table()->SetServerCreditCards({CreateServerCreditCardFromSpecifics(card)});
ResetBridgeWithPotentialInitialSync({profile, card});
WalletMetadataSpecifics updated_remote_profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/2, /*use_date=*/50);
WalletMetadataSpecifics updated_remote_card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/3, /*use_date=*/60);
WalletMetadataSpecifics merged_profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/20, /*use_date=*/50);
WalletMetadataSpecifics merged_card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/30, /*use_date=*/60);
EXPECT_CALL(mock_processor(), Delete(_, _)).Times(0);
EXPECT_CALL(mock_processor(),
Put(kAddr1StorageKey, HasSpecifics(merged_profile), _));
EXPECT_CALL(mock_processor(),
Put(kCard1StorageKey, HasSpecifics(merged_card), _));
EXPECT_CALL(*backend(), CommitChanges());
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges());
ReceivePotentiallyInitialUpdates(
{updated_remote_profile, updated_remote_card});
EXPECT_THAT(GetAllLocalDataInclRestart(),
UnorderedElementsAre(EqualsSpecifics(merged_profile),
EqualsSpecifics(merged_card)));
}
// Tests that the conflicts are resolved component-wise, like the previous test,
// only the other way around (a higher use_count is taken from remote data, a
// newer use_data is taken from local data).
TEST_P(AutofillWalletMetadataSyncBridgeRemoteChangesTest,
Conflict_PreferHigherValues_BothWin2) {
WalletMetadataSpecifics profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/2, /*use_date=*/50);
WalletMetadataSpecifics card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/3, /*use_date=*/60);
table()->SetServerProfiles({CreateServerProfileFromSpecifics(profile)});
table()->SetServerCreditCards({CreateServerCreditCardFromSpecifics(card)});
ResetBridgeWithPotentialInitialSync({profile, card});
WalletMetadataSpecifics updated_remote_profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/20, /*use_date=*/5);
WalletMetadataSpecifics updated_remote_card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/30, /*use_date=*/6);
WalletMetadataSpecifics merged_profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/20, /*use_date=*/50);
WalletMetadataSpecifics merged_card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/30, /*use_date=*/60);
EXPECT_CALL(mock_processor(), Delete(_, _)).Times(0);
EXPECT_CALL(mock_processor(),
Put(kAddr1StorageKey, HasSpecifics(merged_profile), _));
EXPECT_CALL(mock_processor(),
Put(kCard1StorageKey, HasSpecifics(merged_card), _));
EXPECT_CALL(*backend(), CommitChanges());
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges());
ReceivePotentiallyInitialUpdates(
{updated_remote_profile, updated_remote_card});
EXPECT_THAT(GetAllLocalDataInclRestart(),
UnorderedElementsAre(EqualsSpecifics(merged_profile),
EqualsSpecifics(merged_card)));
}
// No merge logic is applied if local data has initial use_count (=1). In this
// situation, we just take over the remote entity completely.
TEST_P(AutofillWalletMetadataSyncBridgeRemoteChangesTest,
Conflict_PreferRemoteIfLocalHasInitialUseCount) {
WalletMetadataSpecifics profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/1, /*use_date=*/50);
WalletMetadataSpecifics card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/1, /*use_date=*/60);
table()->SetServerProfiles({CreateServerProfileFromSpecifics(profile)});
table()->SetServerCreditCards({CreateServerCreditCardFromSpecifics(card)});
ResetBridgeWithPotentialInitialSync({profile, card});
WalletMetadataSpecifics updated_remote_profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/20, /*use_date=*/5);
WalletMetadataSpecifics updated_remote_card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/30, /*use_date=*/6);
EXPECT_CALL(mock_processor(), Delete(_, _)).Times(0);
EXPECT_CALL(mock_processor(), Put(_, _, _)).Times(0);
EXPECT_CALL(*backend(), CommitChanges());
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges());
ReceivePotentiallyInitialUpdates(
{updated_remote_profile, updated_remote_card});
EXPECT_THAT(GetAllLocalDataInclRestart(),
UnorderedElementsAre(EqualsSpecifics(updated_remote_profile),
EqualsSpecifics(updated_remote_card)));
}
// Tests that with a conflict in billing_address_id, we prefer an ID of a local
// profile over an ID of a server profile. In this test, the preferred ID is in
// the remote update that we need to store locally.
TEST_P(AutofillWalletMetadataSyncBridgeRemoteChangesTest,
Conflict_Card_PreferLocalBillingAddressId_RemoteWins) {
WalletMetadataSpecifics card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/3, /*use_date=*/6,
/*billing_address_id=*/kAddr1ServerId);
table()->SetServerCreditCards({CreateServerCreditCardFromSpecifics(card)});
ResetBridgeWithPotentialInitialSync({card});
WalletMetadataSpecifics updated_remote_card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/3, /*use_date=*/6,
/*billing_address_id=*/kLocalAddr1ServerId);
EXPECT_CALL(mock_processor(), Delete(_, _)).Times(0);
EXPECT_CALL(mock_processor(), Put(_, _, _)).Times(0);
EXPECT_CALL(*backend(), CommitChanges());
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges());
ReceivePotentiallyInitialUpdates({updated_remote_card});
EXPECT_THAT(GetAllLocalDataInclRestart(),
UnorderedElementsAre(EqualsSpecifics(updated_remote_card)));
}
// Tests that with a conflict in billing_address_id, we prefer an ID of a local
// profile over an ID of a server profile. In this test, the preferred ID is in
// the local data that we need to upstream.
TEST_P(AutofillWalletMetadataSyncBridgeRemoteChangesTest,
Conflict_Card_PreferLocalBillingAddressId_LocalWins) {
WalletMetadataSpecifics card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/3, /*use_date=*/6,
/*billing_address_id=*/kLocalAddr1ServerId);
table()->SetServerCreditCards({CreateServerCreditCardFromSpecifics(card)});
ResetBridgeWithPotentialInitialSync({card});
WalletMetadataSpecifics updated_remote_card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/3, /*use_date=*/6,
/*billing_address_id=*/kAddr1ServerId);
EXPECT_CALL(mock_processor(), Delete(_, _)).Times(0);
EXPECT_CALL(mock_processor(), Put(kCard1StorageKey, HasSpecifics(card), _));
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges()).Times(0);
// We still need to commit the updated progress marker.
EXPECT_CALL(*backend(), CommitChanges());
ReceivePotentiallyInitialUpdates({updated_remote_card});
EXPECT_THAT(GetAllLocalDataInclRestart(),
UnorderedElementsAre(EqualsSpecifics(card)));
}
// Tests that if both addresses have billing address ids of local profiles, we
// prefer the one from the most recently used entity. In this test, it is the
// remote entity.
TEST_P(AutofillWalletMetadataSyncBridgeRemoteChangesTest,
Conflict_Card_PreferNewerBillingAddressOutOfLocalIds_RemoteWins) {
WalletMetadataSpecifics card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/3, /*use_date=*/6,
/*billing_address_id=*/kLocalAddr1ServerId);
table()->SetServerCreditCards({CreateServerCreditCardFromSpecifics(card)});
ResetBridgeWithPotentialInitialSync({card});
WalletMetadataSpecifics updated_remote_card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/3, /*use_date=*/60,
/*billing_address_id=*/kLocalAddr2ServerId);
EXPECT_CALL(mock_processor(), Delete(_, _)).Times(0);
EXPECT_CALL(mock_processor(), Put(_, _, _)).Times(0);
EXPECT_CALL(*backend(), CommitChanges());
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges());
ReceivePotentiallyInitialUpdates({updated_remote_card});
EXPECT_THAT(GetAllLocalDataInclRestart(),
UnorderedElementsAre(EqualsSpecifics(updated_remote_card)));
}
// Tests that if both addresses have billing address ids of local profiles, we
// prefer the one from the most recently used entity. In this test, it is the
// local entity.
TEST_P(AutofillWalletMetadataSyncBridgeRemoteChangesTest,
Conflict_Card_PreferNewerBillingAddressOutOfLocalIds_LocalWins) {
WalletMetadataSpecifics card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/3, /*use_date=*/60,
/*billing_address_id=*/kLocalAddr1ServerId);
table()->SetServerCreditCards({CreateServerCreditCardFromSpecifics(card)});
ResetBridgeWithPotentialInitialSync({card});
WalletMetadataSpecifics updated_remote_card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/3, /*use_date=*/6,
/*billing_address_id=*/kLocalAddr2ServerId);
EXPECT_CALL(mock_processor(), Delete(_, _)).Times(0);
EXPECT_CALL(mock_processor(), Put(kCard1StorageKey, HasSpecifics(card), _));
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges()).Times(0);
// We still need to commit the updated progress marker.
EXPECT_CALL(*backend(), CommitChanges());
ReceivePotentiallyInitialUpdates({updated_remote_card});
EXPECT_THAT(GetAllLocalDataInclRestart(),
UnorderedElementsAre(EqualsSpecifics(card)));
}
// Tests that if both addresses have billing address ids of server profiles, we
// prefer the one from the most recently used entity. In this test, it is the
// remote entity.
TEST_P(AutofillWalletMetadataSyncBridgeRemoteChangesTest,
Conflict_Card_PreferNewerBillingAddressOutOfServerIds_RemoteWins) {
WalletMetadataSpecifics card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/3, /*use_date=*/6,
/*billing_address_id=*/kAddr1ServerId);
table()->SetServerCreditCards({CreateServerCreditCardFromSpecifics(card)});
ResetBridgeWithPotentialInitialSync({card});
WalletMetadataSpecifics updated_remote_card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/3, /*use_date=*/60,
/*billing_address_id=*/kAddr2ServerId);
EXPECT_CALL(mock_processor(), Delete(_, _)).Times(0);
EXPECT_CALL(mock_processor(), Put(_, _, _)).Times(0);
EXPECT_CALL(*backend(), CommitChanges());
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges());
ReceivePotentiallyInitialUpdates({updated_remote_card});
EXPECT_THAT(GetAllLocalDataInclRestart(),
UnorderedElementsAre(EqualsSpecifics(updated_remote_card)));
}
// Tests that if both addresses have billing address ids of server profiles, we
// prefer the one from the most recently used entity. In this test, it is the
// local entity.
TEST_P(AutofillWalletMetadataSyncBridgeRemoteChangesTest,
Conflict_Card_PreferNewerBillingAddressOutOfServerIds_LocalWins) {
WalletMetadataSpecifics card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/3, /*use_date=*/60,
/*billing_address_id=*/kAddr1ServerId);
table()->SetServerCreditCards({CreateServerCreditCardFromSpecifics(card)});
ResetBridgeWithPotentialInitialSync({card});
WalletMetadataSpecifics updated_remote_card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/3, /*use_date=*/6,
/*billing_address_id=*/kAddr2ServerId);
EXPECT_CALL(mock_processor(), Delete(_, _)).Times(0);
EXPECT_CALL(mock_processor(), Put(kCard1StorageKey, HasSpecifics(card), _));
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges()).Times(0);
// We still need to commit the updated progress marker.
EXPECT_CALL(*backend(), CommitChanges());
ReceivePotentiallyInitialUpdates({updated_remote_card});
EXPECT_THAT(GetAllLocalDataInclRestart(),
UnorderedElementsAre(EqualsSpecifics(card)));
}
// Tests that the conflict resolution happens component-wise. To avoid
// combinatorial explosion, this only tests when both have billing address ids
// of server profiles, one entity is more recently used but the other entity has
// a higher use_count. We should pick the billing_address_id of the newer one
// but have the use_count updated to the maximum as well. In this test, the
// remote entity is the more recently used.
TEST_P(AutofillWalletMetadataSyncBridgeRemoteChangesTest,
Conflict_Card_PreferNewerBillingAddressOutOfServerIds_BothWin1) {
WalletMetadataSpecifics card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/30, /*use_date=*/6,
/*billing_address_id=*/kAddr1ServerId);
table()->SetServerCreditCards({CreateServerCreditCardFromSpecifics(card)});
ResetBridgeWithPotentialInitialSync({card});
WalletMetadataSpecifics updated_remote_card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/3, /*use_date=*/60,
/*billing_address_id=*/kAddr2ServerId);
WalletMetadataSpecifics merged_card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/30, /*use_date=*/60,
/*billing_address_id=*/kAddr2ServerId);
EXPECT_CALL(mock_processor(), Delete(_, _)).Times(0);
EXPECT_CALL(mock_processor(),
Put(kCard1StorageKey, HasSpecifics(merged_card), _));
EXPECT_CALL(*backend(), CommitChanges());
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges());
ReceivePotentiallyInitialUpdates({updated_remote_card});
EXPECT_THAT(GetAllLocalDataInclRestart(),
UnorderedElementsAre(EqualsSpecifics(merged_card)));
}
// Tests that the conflict resolution happens component-wise. To avoid
// combinatorial explosion, this only tests when both have billing address ids
// of server profiles, one entity is more recently used but the other entity has
// a higher use_count. We should pick the billing_address_id of the newer one
// but have the use_count updated to the maximum as well. In this test, the
// local entity is the more recently used.
TEST_P(AutofillWalletMetadataSyncBridgeRemoteChangesTest,
Conflict_Card_PreferNewerBillingAddressOutOfServerIds_BothWin2) {
WalletMetadataSpecifics card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/3, /*use_date=*/60,
/*billing_address_id=*/kAddr1ServerId);
table()->SetServerCreditCards({CreateServerCreditCardFromSpecifics(card)});
ResetBridgeWithPotentialInitialSync({card});
WalletMetadataSpecifics updated_remote_card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/30, /*use_date=*/6,
/*billing_address_id=*/kAddr2ServerId);
WalletMetadataSpecifics merged_card =
CreateWalletMetadataSpecificsForCardWithDetails(
kCard1SpecificsId, /*use_count=*/30, /*use_date=*/60,
/*billing_address_id=*/kAddr1ServerId);
EXPECT_CALL(mock_processor(), Delete(_, _)).Times(0);
EXPECT_CALL(mock_processor(),
Put(kCard1StorageKey, HasSpecifics(merged_card), _));
EXPECT_CALL(*backend(), CommitChanges());
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges());
ReceivePotentiallyInitialUpdates({updated_remote_card});
EXPECT_THAT(GetAllLocalDataInclRestart(),
UnorderedElementsAre(EqualsSpecifics(merged_card)));
}
// Tests that if the has_converted bit differs, we always end up with the true
// value. This test has the remote entity converted which should get updated in
// the local DB.
TEST_P(AutofillWalletMetadataSyncBridgeRemoteChangesTest,
Conflict_Address_HasConverted_RemoteWins) {
WalletMetadataSpecifics profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/1, /*use_date=*/50,
/*has_converted=*/false);
table()->SetServerProfiles({CreateServerProfileFromSpecifics(profile)});
ResetBridgeWithPotentialInitialSync({profile});
WalletMetadataSpecifics updated_remote_profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/1, /*use_date=*/50,
/*has_converted=*/true);
EXPECT_CALL(mock_processor(), Delete(_, _)).Times(0);
EXPECT_CALL(mock_processor(), Put(_, _, _)).Times(0);
EXPECT_CALL(*backend(), CommitChanges());
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges());
ReceivePotentiallyInitialUpdates({updated_remote_profile});
EXPECT_THAT(GetAllLocalDataInclRestart(),
UnorderedElementsAre(EqualsSpecifics(updated_remote_profile)));
}
// Tests that if the has_converted bit differs, we always end up with the true
// value. This test has the local entity converted which should get upstreamed.
TEST_P(AutofillWalletMetadataSyncBridgeRemoteChangesTest,
Conflict_Address_HasConverted_LocalWins) {
WalletMetadataSpecifics profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/1, /*use_date=*/50,
/*has_converted=*/true);
table()->SetServerProfiles({CreateServerProfileFromSpecifics(profile)});
ResetBridgeWithPotentialInitialSync({profile});
WalletMetadataSpecifics updated_remote_profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/1, /*use_date=*/50,
/*has_converted=*/false);
EXPECT_CALL(mock_processor(), Delete(_, _)).Times(0);
EXPECT_CALL(mock_processor(),
Put(kAddr1StorageKey, HasSpecifics(profile), _));
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges()).Times(0);
// We still need to commit the updated progress marker.
EXPECT_CALL(*backend(), CommitChanges());
ReceivePotentiallyInitialUpdates({updated_remote_profile});
EXPECT_THAT(GetAllLocalDataInclRestart(),
UnorderedElementsAre(EqualsSpecifics(profile)));
}
// Tests that the conflict resolution happens component-wise. If one entity
// has_converted but the other entity has higher use_count, we should end up
// with an entity that has_converted and has the higher use_count. This test has
// the remote entity converted.
TEST_P(AutofillWalletMetadataSyncBridgeRemoteChangesTest,
Conflict_Address_HasConverted_BothWin1) {
WalletMetadataSpecifics profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/10, /*use_date=*/50,
/*has_converted=*/false);
table()->SetServerProfiles({CreateServerProfileFromSpecifics(profile)});
ResetBridgeWithPotentialInitialSync({profile});
WalletMetadataSpecifics updated_remote_profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/1, /*use_date=*/50,
/*has_converted=*/true);
WalletMetadataSpecifics merged_profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/10, /*use_date=*/50,
/*has_converted=*/true);
EXPECT_CALL(mock_processor(), Delete(_, _)).Times(0);
EXPECT_CALL(mock_processor(),
Put(kAddr1StorageKey, HasSpecifics(merged_profile), _));
EXPECT_CALL(*backend(), CommitChanges());
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges());
ReceivePotentiallyInitialUpdates({updated_remote_profile});
EXPECT_THAT(GetAllLocalDataInclRestart(),
UnorderedElementsAre(EqualsSpecifics(merged_profile)));
}
// Tests that the conflict resolution happens component-wise. If one entity
// has_converted but the other entity has higher use_count, we should end up
// with an entity that has_converted and has the higher use_count. This test has
// the local entity converted.
TEST_P(AutofillWalletMetadataSyncBridgeRemoteChangesTest,
Conflict_Address_HasConverted_BothWin2) {
WalletMetadataSpecifics profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/1, /*use_date=*/50,
/*has_converted=*/true);
table()->SetServerProfiles({CreateServerProfileFromSpecifics(profile)});
ResetBridgeWithPotentialInitialSync({profile});
WalletMetadataSpecifics updated_remote_profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/10, /*use_date=*/50,
/*has_converted=*/false);
WalletMetadataSpecifics merged_profile =
CreateWalletMetadataSpecificsForAddressWithDetails(
kAddr1SpecificsId, /*use_count=*/10, /*use_date=*/50,
/*has_converted=*/true);
EXPECT_CALL(mock_processor(), Delete(_, _)).Times(0);
EXPECT_CALL(mock_processor(),
Put(kAddr1StorageKey, HasSpecifics(merged_profile), _));
EXPECT_CALL(*backend(), CommitChanges());
EXPECT_CALL(*backend(), NotifyOfMultipleAutofillChanges());
ReceivePotentiallyInitialUpdates({updated_remote_profile});
EXPECT_THAT(GetAllLocalDataInclRestart(),
UnorderedElementsAre(EqualsSpecifics(merged_profile)));
}
INSTANTIATE_TEST_SUITE_P(All,
AutofillWalletMetadataSyncBridgeRemoteChangesTest,
::testing::Values(INITIAL_SYNC_ADD,
LATER_SYNC_ADD,
LATER_SYNC_UPDATE));
} // namespace autofill
namespace sync_pb {
// Makes the GMock matchers print out a readable version of the protobuf.
void PrintTo(const WalletMetadataSpecifics& specifics, std::ostream* os) {
*os << autofill::WalletMetadataSpecificsAsDebugString(specifics);
}
} // namespace sync_pb
| 28,121 |
1,998 | <reponame>Aliacf21/BotBuilder-Samples
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License.
from .slot_filling_dialog import SlotFillingDialog
from .root_dialog import RootDialog
__all__ = ["RootDialog", "SlotFillingDialog"]
| 79 |
679 | <filename>main/dbaccess/source/core/dataaccess/documentdefinition.cxx
/**************************************************************
*
* 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.
*
*************************************************************/
// MARKER(update_precomp.py): autogen include statement, do not remove
#include "precompiled_dbaccess.hxx"
#ifndef _DBA_COREDATAACCESS_DOCUMENTDEFINITION_HXX_
#include "documentdefinition.hxx"
#endif
#ifndef DBACCESS_SHARED_DBASTRINGS_HRC
#include "dbastrings.hrc"
#endif
#ifndef DBACORE_SDBCORETOOLS_HXX
#include "sdbcoretools.hxx"
#endif
#ifndef _TOOLS_DEBUG_HXX
#include <tools/debug.hxx>
#endif
#ifndef TOOLS_DIAGNOSE_EX_H
#include <tools/diagnose_ex.h>
#endif
#ifndef _COMPHELPER_PROPERTY_HXX_
#include <comphelper/property.hxx>
#endif
#ifndef _COMPHELPER_SEQUENCE_HXX_
#include <comphelper/sequence.hxx>
#endif
#ifndef _COMPHELPER_MEDIADESCRIPTOR_HXX_
#include <comphelper/mediadescriptor.hxx>
#endif
#ifndef COMPHELPER_NAMEDVALUECOLLECTION_HXX
#include <comphelper/namedvaluecollection.hxx>
#endif
#ifndef _COMPHELPER_CLASSIDS_HXX
#include <comphelper/classids.hxx>
#endif
#include <com/sun/star/frame/XUntitledNumbers.hpp>
#ifndef _COM_SUN_STAR_AWT_XTOPWINDOW_HPP_
#include <com/sun/star/awt/XTopWindow.hpp>
#endif
#ifndef _COM_SUN_STAR_AWT_SIZE_HPP_
#include <com/sun/star/awt/Size.hpp>
#endif
#ifndef _COM_SUN_STAR_LANG_DISPOSEDEXCEPTION_HPP_
#include <com/sun/star/lang/DisposedException.hpp>
#endif
#ifndef _COM_SUN_STAR_BEANS_PROPERTYATTRIBUTE_HPP_
#include <com/sun/star/beans/PropertyAttribute.hpp>
#endif
#ifndef _COM_SUN_STAR_FRAME_XMODEL_HPP_
#include <com/sun/star/frame/XModel.hpp>
#endif
#include <com/sun/star/frame/XTitle.hpp>
#ifndef _COM_SUN_STAR_FRAME_XCONTROLLER_HPP_
#include <com/sun/star/frame/XController.hpp>
#endif
#ifndef _COM_SUN_STAR_TASK_XJOBEXECUTOR_HPP_
#include <com/sun/star/task/XJobExecutor.hpp>
#endif
#ifndef _COM_SUN_STAR_FRAME_XDISPATCHPROVIDERINTERCEPTION_HPP_
#include <com/sun/star/frame/XDispatchProviderInterception.hpp>
#endif
#ifndef _COM_SUN_STAR_FRAME_XFRAMESSUPPLIER_HPP_
#include <com/sun/star/frame/XFramesSupplier.hpp>
#endif
#ifndef _COM_SUN_STAR_UCB_INSERTCOMMANDARGUMENT_HPP_
#include <com/sun/star/ucb/InsertCommandArgument.hpp>
#endif
#include <com/sun/star/report/XReportDefinition.hpp>
#include <com/sun/star/report/XReportEngine.hpp>
#ifndef _COM_SUN_STAR_UCB_OPENMODE_HPP_
#include <com/sun/star/ucb/OpenMode.hpp>
#endif
#ifndef _COM_SUN_STAR_XEMBEDOBJECTFACTORY_HPP_
#include <com/sun/star/embed/XEmbedObjectFactory.hpp>
#endif
#ifndef _COM_SUN_STAR_XEMBEDOBJECTCREATOR_HPP_
#include <com/sun/star/embed/XEmbedObjectCreator.hpp>
#endif
#ifndef _COM_SUN_STAR_EMBED_ASPECTS_HPP_
#include <com/sun/star/embed/Aspects.hpp>
#endif
#ifndef _UCBHELPER_CANCELCOMMANDEXECUTION_HXX_
#include <ucbhelper/cancelcommandexecution.hxx>
#endif
#ifndef _COM_SUN_STAR_UCB_UNSUPPORTEDDATASINKEXCEPTION_HPP_
#include <com/sun/star/ucb/UnsupportedDataSinkException.hpp>
#endif
#ifndef _COM_SUN_STAR_UCB_UNSUPPORTEDOPENMODEEXCEPTION_HPP_
#include <com/sun/star/ucb/UnsupportedOpenModeException.hpp>
#endif
#ifndef _COM_SUN_STAR_ELEMENTMODES_HPP_
#include <com/sun/star/embed/ElementModes.hpp>
#endif
#ifndef _COM_SUN_STAR_XEMBEDPERSIST_HPP_
#include <com/sun/star/embed/XEmbedPersist.hpp>
#endif
#ifndef _COM_SUN_STAR_EMBEDSTATES_HPP_
#include <com/sun/star/embed/EmbedStates.hpp>
#endif
#ifndef _COM_SUN_STAR_XCOMPONENTSUPPLIER_HPP_
#include <com/sun/star/embed/XComponentSupplier.hpp>
#endif
#ifndef _COM_SUN_STAR_ENTRYINITMODES_HPP_
#include <com/sun/star/embed/EntryInitModes.hpp>
#endif
#ifndef _COM_SUN_STAR_UCB_MISSINGPROPERTIESEXCEPTION_HPP_
#include <com/sun/star/ucb/MissingPropertiesException.hpp>
#endif
#ifndef _COM_SUN_STAR_UCB_MISSINGINPUTSTREAMEXCEPTION_HPP_
#include <com/sun/star/ucb/MissingInputStreamException.hpp>
#endif
#ifndef _COM_SUN_STAR_UCB_OPENCOMMANDARGUMENT2_HPP_
#include <com/sun/star/ucb/OpenCommandArgument2.hpp>
#endif
#ifndef _COM_SUN_STAR_UTIL_XCLOSEBROADCASTER_HPP_
#include <com/sun/star/util/XCloseBroadcaster.hpp>
#endif
#ifndef _COM_SUN_STAR_FRAME_XMODULE_HPP_
#include <com/sun/star/frame/XModule.hpp>
#endif
#ifndef _COM_SUN_STAR_DATATRANSFER_DATAFLAVOR_HPP_
#include <com/sun/star/datatransfer/DataFlavor.hpp>
#endif
#ifndef _COM_SUN_STAR_DATATRANSFER_XTRANSFERABLE_HPP_
#include <com/sun/star/datatransfer/XTransferable.hpp>
#endif
#ifndef _COM_SUN_STAR_CONTAINER_XNAMECONTAINER_HPP_
#include <com/sun/star/container/XNameContainer.hpp>
#endif
#ifndef _COM_SUN_STAR_XTRANSACTEDOBJECT_HPP_
#include <com/sun/star/embed/XTransactedObject.hpp>
#endif
#ifndef _COM_SUN_STAR_EMBED_XCOMMONEMBEDPERSIST_HPP_
#include <com/sun/star/embed/XCommonEmbedPersist.hpp>
#endif
#ifndef DBA_INTERCEPT_HXX
#include "intercept.hxx"
#endif
#ifndef _COM_SUN_STAR_SDB_ERRORCONDITION_HPP_
#include <com/sun/star/sdb/ErrorCondition.hpp>
#endif
#ifndef _COM_SUN_STAR_SDB_XINTERACTIONDOCUMENTSAVE_HPP_
#include <com/sun/star/sdb/XInteractionDocumentSave.hpp>
#endif
#ifndef _COM_SUN_STAR_TASK_XINTERACTIONHANDLER_HPP_
#include <com/sun/star/task/XInteractionHandler.hpp>
#endif
#ifndef _COM_SUN_STAR_SDB_DOCUMENTSAVEREQUEST_HPP_
#include <com/sun/star/sdb/DocumentSaveRequest.hpp>
#endif
#ifndef _COM_SUN_STAR_DOCUMENT_XDOCUMENTPROPERTIESSUPPLIER_HPP_
#include <com/sun/star/document/XDocumentPropertiesSupplier.hpp>
#endif
#ifndef _COM_SUN_STAR_DOCUMENT_MACROEXECMODE_HPP_
#include <com/sun/star/document/MacroExecMode.hpp>
#endif
#ifndef _COM_SUN_STAR_DRAWING_XDRAWPAGESUPPLIER_HPP_
#include <com/sun/star/drawing/XDrawPageSupplier.hpp>
#endif
#ifndef _COM_SUN_STAR_CONTAINER_XINDEXCONTAINER_HPP_
#include <com/sun/star/container/XIndexContainer.hpp>
#endif
#ifndef _COM_SUN_STAR_FORM_XFORMSSUPPLIER_HPP_
#include <com/sun/star/form/XFormsSupplier.hpp>
#endif
#ifndef _COM_SUN_STAR_FORM_XFORM_HPP_
#include <com/sun/star/form/XForm.hpp>
#endif
#ifndef _COMPHELPER_INTERACTION_HXX_
#include <comphelper/interaction.hxx>
#endif
#ifndef _CONNECTIVITY_DBTOOLS_HXX_
#include <connectivity/dbtools.hxx>
#endif
#ifndef _SV_SVAPP_HXX
#include <vcl/svapp.hxx>
#endif
#ifndef _VOS_MUTEX_HXX_
#include <vos/mutex.hxx>
#endif
#ifndef _COM_SUN_STAR_VIEW_XVIEWSETTINGSSUPPLIER_HPP_
#include <com/sun/star/view/XViewSettingsSupplier.hpp>
#endif
#ifndef _DBA_CORE_RESOURCE_HXX_
#include "core_resource.hxx"
#endif
#ifndef _DBA_CORE_RESOURCE_HRC_
#include "core_resource.hrc"
#endif
#ifndef _DBA_COREDATAACCESS_DATASOURCE_HXX_
#include "datasource.hxx"
#endif
#ifndef _COM_SUN_STAR_EMBED_XSTATECHANGEBROADCASTER_HPP_
#include <com/sun/star/embed/XStateChangeBroadcaster.hpp>
#endif
#ifndef _COM_SUN_STAR_TASK_XINTERACTIONAPPROVE_HPP_
#include <com/sun/star/task/XInteractionApprove.hpp>
#endif
#ifndef _COM_SUN_STAR_TASK_XINTERACTIONDISAPPROVE_HPP_
#include <com/sun/star/task/XInteractionDisapprove.hpp>
#endif
#ifndef _COM_SUN_STAR_FRAME_XLAYOUTMANAGER_HPP_
#include <com/sun/star/frame/XLayoutManager.hpp>
#endif
#ifndef _CPPUHELPER_COMPBASE1_HXX_
#include <cppuhelper/compbase1.hxx>
#endif
#include <cppuhelper/exc_hlp.hxx>
#ifndef _COM_SUN_STAR_FRAME_FRAMESEARCHFLAG_HPP_
#include <com/sun/star/frame/FrameSearchFlag.hpp>
#endif
#ifndef _COMPHELPER_SEQUENCEASHASHMAP_HXX_
#include <comphelper/sequenceashashmap.hxx>
#endif
#ifndef _COMPHELPER_MIMECONFIGHELPER_HXX_
#include <comphelper/mimeconfighelper.hxx>
#endif
#ifndef _COMPHELPER_STORAGEHELPER_HXX
#include <comphelper/storagehelper.hxx>
#endif
#ifndef _COM_SUN_STAR_CONTAINER_XCONTENTENUMERATIONACCESS_HPP_
#include <com/sun/star/container/XContentEnumerationAccess.hpp>
#endif
#include <com/sun/star/io/WrongFormatException.hpp>
#include <com/sun/star/sdb/application/XDatabaseDocumentUI.hpp>
#include <com/sun/star/sdb/application/DatabaseObject.hpp>
#include <com/sun/star/util/XModifiable2.hpp>
using namespace ::com::sun::star;
using namespace view;
using namespace uno;
using namespace util;
using namespace ucb;
using namespace beans;
using namespace lang;
using namespace awt;
using namespace embed;
using namespace frame;
using namespace document;
using namespace sdbc;
using namespace sdb;
using namespace io;
using namespace container;
using namespace datatransfer;
using namespace task;
using namespace form;
using namespace drawing;
using namespace ::osl;
using namespace ::comphelper;
using namespace ::cppu;
namespace css = ::com::sun::star;
using sdb::application::XDatabaseDocumentUI;
namespace DatabaseObject = sdb::application::DatabaseObject;
#define DEFAULT_WIDTH 10000
#define DEFAULT_HEIGHT 7500
//.............................................................................
namespace dbaccess
{
//.............................................................................
typedef ::boost::optional< bool > optional_bool;
//=========================================================================
//= helper
//=========================================================================
namespace
{
// --------------------------------------------------------------------
::rtl::OUString lcl_determineContentType_nothrow( const Reference< XStorage >& _rxContainerStorage,
const ::rtl::OUString& _rEntityName )
{
::rtl::OUString sContentType;
try
{
Reference< XStorage > xContainerStorage( _rxContainerStorage, UNO_QUERY_THROW );
::utl::SharedUNOComponent< XPropertySet > xStorageProps(
xContainerStorage->openStorageElement( _rEntityName, ElementModes::READ ), UNO_QUERY_THROW );
OSL_VERIFY( xStorageProps->getPropertyValue( INFO_MEDIATYPE ) >>= sContentType );
}
catch( const Exception& )
{
DBG_UNHANDLED_EXCEPTION();
}
return sContentType;
}
}
//==================================================================
// OEmbedObjectHolder
//==================================================================
typedef ::cppu::WeakComponentImplHelper1< embed::XStateChangeListener > TEmbedObjectHolder;
class OEmbedObjectHolder : public ::comphelper::OBaseMutex
,public TEmbedObjectHolder
{
Reference< XEmbeddedObject > m_xBroadCaster;
ODocumentDefinition* m_pDefinition;
bool m_bInStateChange;
bool m_bInChangingState;
protected:
virtual void SAL_CALL disposing();
public:
OEmbedObjectHolder(const Reference< XEmbeddedObject >& _xBroadCaster,ODocumentDefinition* _pDefinition)
: TEmbedObjectHolder(m_aMutex)
,m_xBroadCaster(_xBroadCaster)
,m_pDefinition(_pDefinition)
,m_bInStateChange(false)
,m_bInChangingState(false)
{
osl_incrementInterlockedCount( &m_refCount );
{
if ( m_xBroadCaster.is() )
m_xBroadCaster->addStateChangeListener(this);
}
osl_decrementInterlockedCount( &m_refCount );
}
virtual void SAL_CALL changingState( const lang::EventObject& aEvent, ::sal_Int32 nOldState, ::sal_Int32 nNewState ) throw (embed::WrongStateException, uno::RuntimeException);
virtual void SAL_CALL stateChanged( const lang::EventObject& aEvent, ::sal_Int32 nOldState, ::sal_Int32 nNewState ) throw (uno::RuntimeException);
virtual void SAL_CALL disposing( const lang::EventObject& Source ) throw (uno::RuntimeException);
};
//------------------------------------------------------------------
void SAL_CALL OEmbedObjectHolder::disposing()
{
if ( m_xBroadCaster.is() )
m_xBroadCaster->removeStateChangeListener(this);
m_xBroadCaster = NULL;
m_pDefinition = NULL;
}
//------------------------------------------------------------------
void SAL_CALL OEmbedObjectHolder::changingState( const lang::EventObject& /*aEvent*/, ::sal_Int32 nOldState, ::sal_Int32 nNewState ) throw (embed::WrongStateException, uno::RuntimeException)
{
if ( !m_bInChangingState && nNewState == EmbedStates::RUNNING && nOldState == EmbedStates::ACTIVE && m_pDefinition )
{
m_bInChangingState = true;
//m_pDefinition->save(sal_False);
m_bInChangingState = false;
}
}
//------------------------------------------------------------------
void SAL_CALL OEmbedObjectHolder::stateChanged( const lang::EventObject& aEvent, ::sal_Int32 nOldState, ::sal_Int32 nNewState ) throw (uno::RuntimeException)
{
if ( !m_bInStateChange && nNewState == EmbedStates::RUNNING && nOldState == EmbedStates::ACTIVE && m_pDefinition )
{
m_bInStateChange = true;
Reference<XInterface> xInt(static_cast< ::cppu::OWeakObject* >(m_pDefinition),UNO_QUERY);
{
Reference<XEmbeddedObject> xEmbeddedObject(aEvent.Source,UNO_QUERY);
if ( xEmbeddedObject.is() )
xEmbeddedObject->changeState(EmbedStates::LOADED);
}
m_bInStateChange = false;
}
}
//------------------------------------------------------------------
void SAL_CALL OEmbedObjectHolder::disposing( const lang::EventObject& /*Source*/ ) throw (uno::RuntimeException)
{
m_xBroadCaster = NULL;
}
//==================================================================
// OEmbeddedClientHelper
//==================================================================
typedef ::cppu::WeakImplHelper1 < XEmbeddedClient
> EmbeddedClientHelper_BASE;
class OEmbeddedClientHelper : public EmbeddedClientHelper_BASE
{
ODocumentDefinition* m_pClient;
public:
OEmbeddedClientHelper(ODocumentDefinition* _pClient) :m_pClient(_pClient) {}
virtual void SAL_CALL saveObject( ) throw (ObjectSaveVetoException, Exception, RuntimeException)
{
}
virtual void SAL_CALL onShowWindow( sal_Bool /*bVisible*/ ) throw (RuntimeException)
{
}
// XComponentSupplier
virtual Reference< util::XCloseable > SAL_CALL getComponent( ) throw (RuntimeException)
{
return Reference< css::util::XCloseable >();
}
// XEmbeddedClient
virtual void SAL_CALL visibilityChanged( ::sal_Bool /*bVisible*/ ) throw (WrongStateException, RuntimeException)
{
}
inline void resetClient(ODocumentDefinition* _pClient) { m_pClient = _pClient; }
};
//==================================================================
// LockModifiable
//==================================================================
class LockModifiable
{
public:
LockModifiable( const Reference< XInterface >& i_rModifiable )
:m_xModifiable( i_rModifiable, UNO_QUERY )
{
OSL_ENSURE( m_xModifiable.is(), "LockModifiable::LockModifiable: invalid component!" );
if ( m_xModifiable.is() )
{
if ( !m_xModifiable->isSetModifiedEnabled() )
{
// somebody already locked that, no need to lock it, again, and no need to unlock it later
m_xModifiable.clear();
}
else
{
m_xModifiable->disableSetModified();
}
}
}
~LockModifiable()
{
if ( m_xModifiable.is() )
m_xModifiable->enableSetModified();
}
private:
Reference< XModifiable2 > m_xModifiable;
};
//==================================================================
// LifetimeCoupler
//==================================================================
typedef ::cppu::WeakImplHelper1 < css::lang::XEventListener
> LifetimeCoupler_Base;
/** helper class which couples the lifetime of a component to the lifetime
of another component
Instances of this class are constructed with two components. The first is
simply held by reference, and thus kept alive. The second one is observed
for <code>disposing</code> calls - if they occur, i.e. if the component dies,
the reference to the first component is cleared.
This way, you can ensure that a certain component is kept alive as long
as a second component is not disposed.
*/
class LifetimeCoupler : public LifetimeCoupler_Base
{
private:
Reference< XInterface > m_xClient;
public:
inline static void couple( const Reference< XInterface >& _rxClient, const Reference< XComponent >& _rxActor )
{
Reference< css::lang::XEventListener > xEnsureDelete( new LifetimeCoupler( _rxClient, _rxActor ) );
}
private:
inline LifetimeCoupler( const Reference< XInterface >& _rxClient, const Reference< XComponent >& _rxActor )
:m_xClient( _rxClient )
{
DBG_ASSERT( _rxActor.is(), "LifetimeCoupler::LifetimeCoupler: this will crash!" );
osl_incrementInterlockedCount( &m_refCount );
{
_rxActor->addEventListener( this );
}
osl_decrementInterlockedCount( &m_refCount );
DBG_ASSERT( m_refCount, "LifetimeCoupler::LifetimeCoupler: the actor is not holding us by hard ref - this won't work!" );
}
virtual void SAL_CALL disposing( const css::lang::EventObject& Source ) throw (RuntimeException);
protected:
};
//------------------------------------------------------------------
void SAL_CALL LifetimeCoupler::disposing( const css::lang::EventObject& /*Source*/ ) throw (RuntimeException)
{
m_xClient.clear();
}
//==================================================================
// ODocumentSaveContinuation
//==================================================================
class ODocumentSaveContinuation : public OInteraction< XInteractionDocumentSave >
{
::rtl::OUString m_sName;
Reference<XContent> m_xParentContainer;
public:
ODocumentSaveContinuation() { }
inline Reference<XContent> getContent() const { return m_xParentContainer; }
inline ::rtl::OUString getName() const { return m_sName; }
// XInteractionDocumentSave
virtual void SAL_CALL setName( const ::rtl::OUString& _sName,const Reference<XContent>& _xParent) throw(RuntimeException);
};
//------------------------------------------------------------------
void SAL_CALL ODocumentSaveContinuation::setName( const ::rtl::OUString& _sName,const Reference<XContent>& _xParent) throw(RuntimeException)
{
m_sName = _sName;
m_xParentContainer = _xParent;
}
// -----------------------------------------------------------------------------
::rtl::OUString ODocumentDefinition::GetDocumentServiceFromMediaType( const Reference< XStorage >& _rxContainerStorage,
const ::rtl::OUString& _rEntityName, const ::comphelper::ComponentContext& _rContext,
Sequence< sal_Int8 >& _rClassId )
{
return GetDocumentServiceFromMediaType(
lcl_determineContentType_nothrow( _rxContainerStorage, _rEntityName ),
_rContext, _rClassId );
}
// -----------------------------------------------------------------------------
::rtl::OUString ODocumentDefinition::GetDocumentServiceFromMediaType( const ::rtl::OUString& _rMediaType,
const ::comphelper::ComponentContext& _rContext, Sequence< sal_Int8 >& _rClassId )
{
::rtl::OUString sResult;
try
{
::comphelper::MimeConfigurationHelper aConfigHelper( _rContext.getLegacyServiceFactory() );
sResult = aConfigHelper.GetDocServiceNameFromMediaType( _rMediaType );
_rClassId = aConfigHelper.GetSequenceClassIDRepresentation(aConfigHelper.GetExplicitlyRegisteredObjClassID( _rMediaType ));
if ( !_rClassId.getLength() && sResult.getLength() )
{
Reference< XNameAccess > xObjConfig = aConfigHelper.GetObjConfiguration();
if ( xObjConfig.is() )
{
Sequence< ::rtl::OUString > aClassIDs = xObjConfig->getElementNames();
for ( sal_Int32 nInd = 0; nInd < aClassIDs.getLength(); nInd++ )
{
Reference< XNameAccess > xObjectProps;
::rtl::OUString aEntryDocName;
if ( ( xObjConfig->getByName( aClassIDs[nInd] ) >>= xObjectProps ) && xObjectProps.is()
&& ( xObjectProps->getByName(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ObjectDocumentServiceName"))
) >>= aEntryDocName )
&& aEntryDocName.equals( sResult ) )
{
_rClassId = aConfigHelper.GetSequenceClassIDRepresentation(aClassIDs[nInd]);
break;
}
}
}
}
#if OSL_DEBUG_LEVEL > 0
// alternative, shorter approach
const Sequence< NamedValue > aProps( aConfigHelper.GetObjectPropsByMediaType( _rMediaType ) );
const ::comphelper::NamedValueCollection aMediaTypeProps( aProps );
const ::rtl::OUString sAlternativeResult = aMediaTypeProps.getOrDefault( "ObjectDocumentServiceName", ::rtl::OUString() );
OSL_ENSURE( sAlternativeResult == sResult, "ODocumentDefinition::GetDocumentServiceFromMediaType: failed, this approach is *not* equivalent (1)!" );
const Sequence< sal_Int8 > aAlternativeClassID = aMediaTypeProps.getOrDefault( "ClassID", Sequence< sal_Int8 >() );
OSL_ENSURE( aAlternativeClassID == _rClassId, "ODocumentDefinition::GetDocumentServiceFromMediaType: failed, this approach is *not* equivalent (2)!" );
#endif
}
catch ( Exception& )
{
DBG_UNHANDLED_EXCEPTION();
}
return sResult;
}
// -----------------------------------------------------------------------------
//==========================================================================
//= ODocumentDefinition
//==========================================================================
DBG_NAME(ODocumentDefinition)
//--------------------------------------------------------------------------
ODocumentDefinition::ODocumentDefinition( const Reference< XInterface >& _rxContainer, const Reference< XMultiServiceFactory >& _xORB,
const TContentPtr& _pImpl, sal_Bool _bForm )
:OContentHelper(_xORB,_rxContainer,_pImpl)
,OPropertyStateContainer(OContentHelper::rBHelper)
,m_pInterceptor(NULL)
,m_bForm(_bForm)
,m_bOpenInDesign(sal_False)
,m_bInExecute(sal_False)
,m_bRemoveListener(sal_False)
,m_pClientHelper(NULL)
{
DBG_CTOR(ODocumentDefinition, NULL);
registerProperties();
}
//--------------------------------------------------------------------------
void ODocumentDefinition::initialLoad( const Sequence< sal_Int8 >& i_rClassID, const Sequence< PropertyValue >& i_rCreationArgs,
const Reference< XConnection >& i_rConnection )
{
OSL_ENSURE( i_rClassID.getLength(), "ODocumentDefinition::initialLoad: illegal class ID!" );
if ( !i_rClassID.getLength() )
return;
loadEmbeddedObject( i_rConnection, i_rClassID, i_rCreationArgs, false, false );
}
//--------------------------------------------------------------------------
ODocumentDefinition::~ODocumentDefinition()
{
DBG_DTOR(ODocumentDefinition, NULL);
if ( !OContentHelper::rBHelper.bInDispose && !OContentHelper::rBHelper.bDisposed )
{
acquire();
dispose();
}
if ( m_pInterceptor )
{
m_pInterceptor->dispose();
m_pInterceptor->release();
m_pInterceptor = NULL;
}
}
// -----------------------------------------------------------------------------
void ODocumentDefinition::closeObject()
{
::osl::MutexGuard aGuard(m_aMutex);
if ( m_xEmbeddedObject.is() )
{
try
{
Reference< com::sun::star::util::XCloseable> xCloseable(m_xEmbeddedObject,UNO_QUERY);
if ( xCloseable.is() )
xCloseable->close(sal_True);
}
catch(Exception)
{
}
m_xEmbeddedObject = NULL;
if ( m_pClientHelper )
{
m_pClientHelper->resetClient(NULL);
m_pClientHelper->release();
m_pClientHelper = NULL;
}
}
}
// -----------------------------------------------------------------------------
void SAL_CALL ODocumentDefinition::disposing()
{
OContentHelper::disposing();
::osl::MutexGuard aGuard(m_aMutex);
closeObject();
::comphelper::disposeComponent(m_xListener);
if ( m_bRemoveListener )
{
Reference<util::XCloseable> xCloseable(m_pImpl->m_pDataSource->getModel_noCreate(),UNO_QUERY);
if ( xCloseable.is() )
xCloseable->removeCloseListener(this);
}
}
// -----------------------------------------------------------------------------
IMPLEMENT_TYPEPROVIDER3(ODocumentDefinition,OContentHelper,OPropertyStateContainer,ODocumentDefinition_Base);
IMPLEMENT_FORWARD_XINTERFACE3( ODocumentDefinition,OContentHelper,OPropertyStateContainer,ODocumentDefinition_Base)
IMPLEMENT_SERVICE_INFO1(ODocumentDefinition,"com.sun.star.comp.dba.ODocumentDefinition",SERVICE_SDB_DOCUMENTDEFINITION)
//--------------------------------------------------------------------------
void ODocumentDefinition::registerProperties()
{
#define REGISTER_PROPERTY( name, location ) \
registerProperty( PROPERTY_##name, PROPERTY_ID_##name, PropertyAttribute::READONLY, &location, ::getCppuType( &location ) );
#define REGISTER_PROPERTY_BV( name, location ) \
registerProperty( PROPERTY_##name, PROPERTY_ID_##name, PropertyAttribute::CONSTRAINED | PropertyAttribute::BOUND | PropertyAttribute::READONLY, &location, ::getCppuType( &location ) );
REGISTER_PROPERTY_BV( NAME, m_pImpl->m_aProps.aTitle );
REGISTER_PROPERTY ( AS_TEMPLATE, m_pImpl->m_aProps.bAsTemplate );
REGISTER_PROPERTY ( PERSISTENT_NAME, m_pImpl->m_aProps.sPersistentName );
REGISTER_PROPERTY ( IS_FORM, m_bForm );
}
// -----------------------------------------------------------------------------
void SAL_CALL ODocumentDefinition::getFastPropertyValue( Any& o_rValue, sal_Int32 i_nHandle ) const
{
if ( i_nHandle == PROPERTY_ID_PERSISTENT_PATH )
{
::rtl::OUString sPersistentPath;
if ( m_pImpl->m_aProps.sPersistentName.getLength() )
{
::rtl::OUStringBuffer aBuffer;
aBuffer.append( ODatabaseModelImpl::getObjectContainerStorageName( m_bForm ? ODatabaseModelImpl::E_FORM : ODatabaseModelImpl::E_REPORT ) );
aBuffer.append( sal_Unicode( '/' ) );
aBuffer.append( m_pImpl->m_aProps.sPersistentName );
sPersistentPath = aBuffer.makeStringAndClear();
}
o_rValue <<= sPersistentPath;
return;
}
OPropertyStateContainer::getFastPropertyValue( o_rValue, i_nHandle );
}
// -----------------------------------------------------------------------------
Reference< XPropertySetInfo > SAL_CALL ODocumentDefinition::getPropertySetInfo( ) throw(RuntimeException)
{
Reference<XPropertySetInfo> xInfo( createPropertySetInfo( getInfoHelper() ) );
return xInfo;
}
//--------------------------------------------------------------------------
IPropertyArrayHelper& ODocumentDefinition::getInfoHelper()
{
return *getArrayHelper();
}
//--------------------------------------------------------------------------
IPropertyArrayHelper* ODocumentDefinition::createArrayHelper( ) const
{
// properties maintained by our base class (see registerProperties)
Sequence< Property > aProps;
describeProperties( aProps );
// properties not maintained by our base class
Sequence< Property > aManualProps( 1 );
aManualProps[0].Name = PROPERTY_PERSISTENT_PATH;
aManualProps[0].Handle = PROPERTY_ID_PERSISTENT_PATH;
aManualProps[0].Type = ::getCppuType( static_cast< const ::rtl::OUString* >( NULL ) );
aManualProps[0].Attributes = PropertyAttribute::READONLY;
return new OPropertyArrayHelper( ::comphelper::concatSequences( aProps, aManualProps ) );
}
// -----------------------------------------------------------------------------
class OExecuteImpl
{
sal_Bool& m_rbSet;
public:
OExecuteImpl(sal_Bool& _rbSet) : m_rbSet(_rbSet){ m_rbSet=sal_True; }
~OExecuteImpl(){ m_rbSet = sal_False; }
};
// -----------------------------------------------------------------------------
namespace
{
bool lcl_extractOpenMode( const Any& _rValue, sal_Int32& _out_rMode )
{
OpenCommandArgument aOpenCommand;
if ( _rValue >>= aOpenCommand )
_out_rMode = aOpenCommand.Mode;
else
{
OpenCommandArgument2 aOpenCommand2;
if ( _rValue >>= aOpenCommand2 )
_out_rMode = aOpenCommand2.Mode;
else
return false;
}
return true;
}
}
// -----------------------------------------------------------------------------
void ODocumentDefinition::impl_removeFrameFromDesktop_throw( const ::comphelper::ComponentContext& _rContxt, const Reference< XFrame >& _rxFrame )
{
Reference< XFramesSupplier > xDesktop( _rContxt.createComponent( (::rtl::OUString)SERVICE_FRAME_DESKTOP ), UNO_QUERY_THROW );
Reference< XFrames > xFrames( xDesktop->getFrames(), UNO_QUERY_THROW );
xFrames->remove( _rxFrame );
}
// -----------------------------------------------------------------------------
void ODocumentDefinition::impl_onActivateEmbeddedObject_nothrow( const bool i_bReactivated )
{
try
{
Reference< XModel > xModel( getComponent(), UNO_QUERY );
Reference< XController > xController( xModel.is() ? xModel->getCurrentController() : Reference< XController >() );
if ( !xController.is() )
return;
if ( !m_xListener.is() )
// it's the first time the embedded object has been activated
// create an OEmbedObjectHolder
m_xListener = new OEmbedObjectHolder( m_xEmbeddedObject, this );
// raise the window to top (especially necessary if this is not the first activation)
Reference< XFrame > xFrame( xController->getFrame(), UNO_SET_THROW );
Reference< XTopWindow > xTopWindow( xFrame->getContainerWindow(), UNO_QUERY_THROW );
xTopWindow->toFront();
// remove the frame from the desktop's frame collection because we need full control of it.
impl_removeFrameFromDesktop_throw( m_aContext, xFrame );
// ensure that we ourself are kept alive as long as the embedded object's frame is
// opened
LifetimeCoupler::couple( *this, xFrame.get() );
// init the edit view
if ( m_bForm && m_bOpenInDesign && !i_bReactivated )
impl_initFormEditView( xController );
}
catch( const RuntimeException& )
{
DBG_UNHANDLED_EXCEPTION();
}
}
// -----------------------------------------------------------------------------
namespace
{
// =========================================================================
// = PreserveVisualAreaSize
// =========================================================================
/** stack-guard for preserving the size of the VisArea of an XModel
*/
class PreserveVisualAreaSize
{
private:
Reference< XVisualObject > m_xVisObject;
awt::Size m_aOriginalSize;
public:
inline PreserveVisualAreaSize( const Reference< XModel >& _rxModel )
:m_xVisObject( _rxModel, UNO_QUERY )
{
if ( m_xVisObject.is() )
{
try
{
m_aOriginalSize = m_xVisObject->getVisualAreaSize( Aspects::MSOLE_CONTENT );
}
catch ( Exception& )
{
DBG_ERROR( "PreserveVisualAreaSize::PreserveVisualAreaSize: caught an exception!" );
}
}
}
inline ~PreserveVisualAreaSize()
{
if ( m_xVisObject.is() && m_aOriginalSize.Width && m_aOriginalSize.Height )
{
try
{
m_xVisObject->setVisualAreaSize( Aspects::MSOLE_CONTENT, m_aOriginalSize );
}
catch ( Exception& )
{
DBG_ERROR( "PreserveVisualAreaSize::~PreserveVisualAreaSize: caught an exception!" );
}
}
}
};
// =========================================================================
// = LayoutManagerLock
// =========================================================================
/** helper class for stack-usage which during its lifetime locks a layout manager
*/
class LayoutManagerLock
{
private:
Reference< XLayoutManager > m_xLayoutManager;
public:
inline LayoutManagerLock( const Reference< XController >& _rxController )
{
DBG_ASSERT( _rxController.is(), "LayoutManagerLock::LayoutManagerLock: this will crash!" );
Reference< XFrame > xFrame( _rxController->getFrame() );
try
{
Reference< XPropertySet > xPropSet( xFrame, UNO_QUERY_THROW );
m_xLayoutManager.set(
xPropSet->getPropertyValue( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "LayoutManager" ) ) ),
UNO_QUERY_THROW );
m_xLayoutManager->lock();
}
catch( Exception& )
{
DBG_ERROR( "LayoutManagerLock::LayoutManagerLock: caught an exception!" );
}
}
inline ~LayoutManagerLock()
{
try
{
// unlock the layout manager
if ( m_xLayoutManager.is() )
m_xLayoutManager->unlock();
}
catch( Exception& )
{
DBG_ERROR( "LayoutManagerLock::~LayoutManagerLock: caught an exception!" );
}
}
};
}
// -----------------------------------------------------------------------------
void ODocumentDefinition::impl_initFormEditView( const Reference< XController >& _rxController )
{
try
{
Reference< XViewSettingsSupplier > xSettingsSupplier( _rxController, UNO_QUERY_THROW );
Reference< XPropertySet > xViewSettings( xSettingsSupplier->getViewSettings(), UNO_QUERY_THROW );
// the below code could indirectly tamper with the "modified" flag of the model, temporarily disable this
LockModifiable aLockModify( _rxController->getModel() );
// The visual area size can be changed by the setting of the following properties
// so it should be restored later
PreserveVisualAreaSize aPreserveVisAreaSize( _rxController->getModel() );
// Layout manager should not layout while the size is still not restored
// so it will stay locked for this time
LayoutManagerLock aLockLayout( _rxController );
// setting of the visual properties
xViewSettings->setPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShowRulers")),makeAny(sal_True));
xViewSettings->setPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShowVertRuler")),makeAny(sal_True));
xViewSettings->setPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShowHoriRuler")),makeAny(sal_True));
xViewSettings->setPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("IsRasterVisible")),makeAny(sal_True));
xViewSettings->setPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("IsSnapToRaster")),makeAny(sal_True));
xViewSettings->setPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("ShowOnlineLayout")),makeAny(sal_True));
xViewSettings->setPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("RasterSubdivisionX")),makeAny(sal_Int32(5)));
xViewSettings->setPropertyValue(::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("RasterSubdivisionY")),makeAny(sal_Int32(5)));
}
catch( const Exception& )
{
DBG_UNHANDLED_EXCEPTION();
}
}
// -----------------------------------------------------------------------------
void ODocumentDefinition::impl_showOrHideComponent_throw( const bool i_bShow )
{
const sal_Int32 nCurrentState = m_xEmbeddedObject.is() ? m_xEmbeddedObject->getCurrentState() : EmbedStates::LOADED;
switch ( nCurrentState )
{
default:
case EmbedStates::LOADED:
throw embed::WrongStateException( ::rtl::OUString(), *this );
case EmbedStates::RUNNING:
if ( !i_bShow )
// fine, a running (and not yet active) object is never visible
return;
{
LockModifiable aLockModify( impl_getComponent_throw() );
m_xEmbeddedObject->changeState( EmbedStates::ACTIVE );
impl_onActivateEmbeddedObject_nothrow( false );
}
break;
case EmbedStates::ACTIVE:
{
Reference< XModel > xEmbeddedDoc( impl_getComponent_throw( true ), UNO_QUERY_THROW );
Reference< XController > xEmbeddedController( xEmbeddedDoc->getCurrentController(), UNO_SET_THROW );
Reference< XFrame > xEmbeddedFrame( xEmbeddedController->getFrame(), UNO_SET_THROW );
Reference< XWindow > xEmbeddedWindow( xEmbeddedFrame->getContainerWindow(), UNO_SET_THROW );
xEmbeddedWindow->setVisible( i_bShow );
}
break;
}
}
// -----------------------------------------------------------------------------
Any ODocumentDefinition::onCommandOpenSomething( const Any& _rOpenArgument, const bool _bActivate,
const Reference< XCommandEnvironment >& _rxEnvironment )
{
OExecuteImpl aExecuteGuard( m_bInExecute );
Reference< XConnection > xConnection;
sal_Int32 nOpenMode = OpenMode::DOCUMENT;
::comphelper::NamedValueCollection aDocumentArgs;
// for the document, default to the interaction handler as used for loading the DB doc
// This might be overwritten below, when examining _rOpenArgument.
const ::comphelper::NamedValueCollection& aDBDocArgs( m_pImpl->m_pDataSource->getMediaDescriptor() );
Reference< XInteractionHandler > xHandler( aDBDocArgs.getOrDefault( "InteractionHandler", Reference< XInteractionHandler >() ) );
if ( xHandler.is() )
aDocumentArgs.put( "InteractionHandler", xHandler );
::boost::optional< sal_Int16 > aDocumentMacroMode;
if ( !lcl_extractOpenMode( _rOpenArgument, nOpenMode ) )
{
Sequence< PropertyValue > aArguments;
if ( _rOpenArgument >>= aArguments )
{
const PropertyValue* pIter = aArguments.getConstArray();
const PropertyValue* pEnd = pIter + aArguments.getLength();
for ( ;pIter != pEnd; ++pIter )
{
if ( pIter->Name == PROPERTY_ACTIVE_CONNECTION )
{
xConnection.set( pIter->Value, UNO_QUERY );
continue;
}
if ( lcl_extractOpenMode( pIter->Value, nOpenMode ) )
continue;
if ( pIter->Name.equalsAscii( "MacroExecutionMode" ) )
{
sal_Int16 nMacroExecMode( !aDocumentMacroMode ? MacroExecMode::USE_CONFIG : *aDocumentMacroMode );
OSL_VERIFY( pIter->Value >>= nMacroExecMode );
aDocumentMacroMode.reset( nMacroExecMode );
continue;
}
// unknown argument -> pass to the loaded document
aDocumentArgs.put( pIter->Name, pIter->Value );
}
}
}
bool bExecuteDBDocMacros = m_pImpl->m_pDataSource->checkMacrosOnLoading();
// Note that this call implies the user might be asked for the macro execution mode.
// Normally, this would happen when the database document is loaded, and subsequent calls
// will simply use the user's decision from this point in time.
// However, it is possible to programmatically load forms/reports, without actually
// loading the database document into a frame. In this case, the user will be asked
// here and now.
// #i87741# / 2008-05-05 / <EMAIL>
// allow the command arguments to downgrade the macro execution mode, but not to upgrade
// it
if ( ( m_pImpl->m_pDataSource->getImposedMacroExecMode() == MacroExecMode::USE_CONFIG )
&& bExecuteDBDocMacros
)
{
// while loading the whole database document, USE_CONFIG, was passed.
// Additionally, *by now* executing macros from the DB doc is allowed (this is what bExecuteDBDocMacros
// indicates). This means either one of:
// 1. The DB doc or one of the sub docs contained macros and
// 1a. the user explicitly allowed executing them
// 1b. the configuration allows executing them without asking the user
// 2. Neither the DB doc nor the sub docs contained macros, thus macro
// execution was silently enabled, assuming that any macro will be a
// user-created macro
//
// The problem with this: If the to-be-opened sub document has macros embedded in
// the content.xml (which is valid ODF, but normally not produced by OOo itself),
// then this has not been detected while loading the database document - it would
// be too expensive, as it effectively would require loading all forms/reports.
//
// So, in such a case, and with 2. above, we would silently execute those macros,
// regardless of the global security settings - which would be a security issue, of
// course.
if ( m_pImpl->m_pDataSource->determineEmbeddedMacros() == ODatabaseModelImpl::eNoMacros )
{
// this is case 2. from above
// So, pass a USE_CONFIG to the to-be-loaded document. This means that
// the user will be prompted with a security message upon opening this
// sub document, in case the settings require this, *and* the document
// contains scripts in the content.xml. But this is better than the security
// issue we had before ...
aDocumentMacroMode.reset( MacroExecMode::USE_CONFIG );
}
}
if ( !aDocumentMacroMode )
{
// nobody so far felt responsible for setting it
// => use the DBDoc-wide macro exec mode for the document, too
aDocumentMacroMode.reset( bExecuteDBDocMacros ? MacroExecMode::ALWAYS_EXECUTE_NO_WARN : MacroExecMode::NEVER_EXECUTE );
}
aDocumentArgs.put( "MacroExecutionMode", *aDocumentMacroMode );
if ( ( nOpenMode == OpenMode::ALL )
|| ( nOpenMode == OpenMode::FOLDERS )
|| ( nOpenMode == OpenMode::DOCUMENTS )
|| ( nOpenMode == OpenMode::DOCUMENT_SHARE_DENY_NONE )
|| ( nOpenMode == OpenMode::DOCUMENT_SHARE_DENY_WRITE )
)
{
// not supported
ucbhelper::cancelCommandExecution(
makeAny( UnsupportedOpenModeException(
rtl::OUString(),
static_cast< cppu::OWeakObject * >( this ),
sal_Int16( nOpenMode ) ) ),
_rxEnvironment );
// Unreachable
DBG_ERROR( "unreachable" );
}
OSL_ENSURE( m_pImpl->m_aProps.sPersistentName.getLength(),
"ODocumentDefinition::onCommandOpenSomething: no persistent name - cannot load!" );
if ( !m_pImpl->m_aProps.sPersistentName.getLength() )
return Any();
// embedded objects themself do not support the hidden flag. We implement support for
// it by changing the STATE to RUNNING only, instead of ACTIVE.
bool bOpenHidden = aDocumentArgs.getOrDefault( "Hidden", false );
aDocumentArgs.remove( "Hidden" );
loadEmbeddedObject( xConnection, Sequence< sal_Int8 >(), aDocumentArgs.getPropertyValues(), false, !m_bOpenInDesign );
OSL_ENSURE( m_xEmbeddedObject.is(), "ODocumentDefinition::onCommandOpenSomething: what's this?" );
if ( !m_xEmbeddedObject.is() )
return Any();
Reference< XModel > xModel( getComponent(), UNO_QUERY );
Reference< report::XReportDefinition > xReportDefinition(xModel,UNO_QUERY);
Reference< XModule > xModule( xModel, UNO_QUERY );
if ( xModule.is() )
{
if ( m_bForm )
xModule->setIdentifier( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.sdb.FormDesign" ) ) );
else if ( !xReportDefinition.is() )
xModule->setIdentifier( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.sdb.TextReportDesign" ) ) );
updateDocumentTitle();
}
bool bIsAliveNewStyleReport = ( !m_bOpenInDesign && xReportDefinition.is() );
if ( bIsAliveNewStyleReport )
{
// we are in ReadOnly mode
// we would like to open the Writer or Calc with the report direct, without design it.
Reference< report::XReportEngine > xReportEngine( m_aContext.createComponent( "com.sun.star.comp.report.OReportEngineJFree" ), UNO_QUERY_THROW );
xReportEngine->setReportDefinition(xReportDefinition);
xReportEngine->setActiveConnection(m_xLastKnownConnection);
if ( bOpenHidden )
return makeAny( xReportEngine->createDocumentModel() );
return makeAny( xReportEngine->createDocumentAlive( NULL ) );
}
if ( _bActivate && !bOpenHidden )
{
LockModifiable aLockModify( impl_getComponent_throw() );
m_xEmbeddedObject->changeState( EmbedStates::ACTIVE );
impl_onActivateEmbeddedObject_nothrow( false );
}
else
{
// ensure that we ourself are kept alive as long as the document is open
LifetimeCoupler::couple( *this, xModel.get() );
}
if ( !m_bForm && m_pImpl->m_aProps.bAsTemplate && !m_bOpenInDesign )
ODocumentDefinition::fillReportData( m_aContext, getComponent(), xConnection );
return makeAny( xModel );
}
// -----------------------------------------------------------------------------
Any SAL_CALL ODocumentDefinition::execute( const Command& aCommand, sal_Int32 CommandId, const Reference< XCommandEnvironment >& Environment ) throw (Exception, CommandAbortedException, RuntimeException)
{
Any aRet;
sal_Bool bOpen = aCommand.Name.equalsAscii( "open" );
sal_Bool bOpenInDesign = aCommand.Name.equalsAscii( "openDesign" );
sal_Bool bOpenForMail = aCommand.Name.equalsAscii( "openForMail" );
if ( bOpen || bOpenInDesign || bOpenForMail )
{
// opening the document involves a lot of VCL code, which is not thread-safe, but needs the SolarMutex locked.
// Unfortunately, the DocumentDefinition, as well as the EmbeddedObject implementation, calls into VCL-dependent
// components *without* releasing the own mutex, which is a guaranteed recipe for deadlocks.
// We have control over this implementation here, and in modifying it to release the own mutex before calling into
// the VCL-dependent components is not too difficult (was there, seen it).
// However, we do /not/ have control over the EmbeddedObject implementation, and from a first look, it seems as
// making it release the own mutex before calling SolarMutex-code is ... difficult, at least.
// So, to be on the same side, we lock the SolarMutex here. Yes, it sucks.
::vos::OGuard aSolarGuard( Application::GetSolarMutex() );
::osl::ClearableMutexGuard aGuard(m_aMutex);
if ( m_bInExecute )
return aRet;
bool bActivateObject = true;
if ( bOpenForMail )
{
OSL_ENSURE( false, "ODocumentDefinition::execute: 'openForMail' should not be used anymore - use the 'Hidden' parameter instead!" );
bActivateObject = false;
}
// if the object is already opened, do nothing
// #i89509# / 2008-05-22 / <EMAIL>
if ( m_xEmbeddedObject.is() )
{
sal_Int32 nCurrentState = m_xEmbeddedObject->getCurrentState();
bool bIsActive = ( nCurrentState == EmbedStates::ACTIVE );
if ( bIsActive )
{
// exception: new-style reports always create a new document when "open" is executed
Reference< report::XReportDefinition > xReportDefinition( impl_getComponent_throw( false ), UNO_QUERY );
bool bIsAliveNewStyleReport = ( xReportDefinition.is() && ( bOpen || bOpenForMail ) );
if ( !bIsAliveNewStyleReport )
{
impl_onActivateEmbeddedObject_nothrow( true );
return makeAny( getComponent() );
}
}
}
m_bOpenInDesign = bOpenInDesign || bOpenForMail;
return onCommandOpenSomething( aCommand.Argument, bActivateObject, Environment );
}
::osl::ClearableMutexGuard aGuard(m_aMutex);
if ( m_bInExecute )
return aRet;
if ( aCommand.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "copyTo" ) ) )
{
Sequence<Any> aIni;
aCommand.Argument >>= aIni;
if ( aIni.getLength() != 2 )
{
OSL_ENSURE( sal_False, "Wrong argument type!" );
ucbhelper::cancelCommandExecution(
makeAny( IllegalArgumentException(
rtl::OUString(),
static_cast< cppu::OWeakObject * >( this ),
-1 ) ),
Environment );
// Unreachable
}
Reference< XStorage> xDest(aIni[0],UNO_QUERY);
::rtl::OUString sPersistentName;
aIni[1] >>= sPersistentName;
Reference< XStorage> xStorage = getContainerStorage();
// -----------------------------------------------------------------------------
xStorage->copyElementTo(m_pImpl->m_aProps.sPersistentName,xDest,sPersistentName);
}
else if ( aCommand.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "preview" ) ) )
{
onCommandPreview(aRet);
}
else if ( aCommand.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "insert" ) ) )
{
Sequence<Any> aIni;
aCommand.Argument >>= aIni;
if ( !aIni.getLength() )
{
OSL_ENSURE( sal_False, "Wrong argument count!" );
ucbhelper::cancelCommandExecution(
makeAny( IllegalArgumentException(
rtl::OUString(),
static_cast< cppu::OWeakObject * >( this ),
-1 ) ),
Environment );
// Unreachable
}
::rtl::OUString sURL;
aIni[0] >>= sURL;
onCommandInsert( sURL, Environment );
}
else if ( aCommand.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "getdocumentinfo" ) ) // compatibility
|| aCommand.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "getDocumentInfo" ) )
)
{
onCommandGetDocumentProperties( aRet );
}
else if ( aCommand.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "delete" ) ) )
{
//////////////////////////////////////////////////////////////////
// delete
//////////////////////////////////////////////////////////////////
closeObject();
Reference< XStorage> xStorage = getContainerStorage();
if ( xStorage.is() )
xStorage->removeElement(m_pImpl->m_aProps.sPersistentName);
dispose();
}
else if ( ( aCommand.Name.compareToAscii( "storeOwn" ) == 0 ) // compatibility
|| ( aCommand.Name.compareToAscii( "store" ) == 0 )
)
{
impl_store_throw();
}
else if ( ( aCommand.Name.compareToAscii( "shutdown" ) == 0 ) // compatibility
|| ( aCommand.Name.compareToAscii( "close" ) == 0 )
)
{
aRet <<= impl_close_throw();
}
else if ( aCommand.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "show" ) ) )
{
impl_showOrHideComponent_throw( true );
}
else if ( aCommand.Name.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM( "hide" ) ) )
{
impl_showOrHideComponent_throw( false );
}
else
{
aRet = OContentHelper::execute(aCommand,CommandId,Environment);
}
return aRet;
}
// -----------------------------------------------------------------------------
namespace
{
void lcl_resetChildFormsToEmptyDataSource( const Reference< XIndexAccess>& _rxFormsContainer )
{
OSL_PRECOND( _rxFormsContainer.is(), "lcl_resetChildFormsToEmptyDataSource: illegal call!" );
sal_Int32 count = _rxFormsContainer->getCount();
for ( sal_Int32 i = 0; i < count; ++i )
{
Reference< XForm > xForm( _rxFormsContainer->getByIndex( i ), UNO_QUERY );
if ( !xForm.is() )
continue;
// if the element is a form, reset its DataSourceName property to an empty string
try
{
Reference< XPropertySet > xFormProps( xForm, UNO_QUERY_THROW );
xFormProps->setPropertyValue( PROPERTY_DATASOURCENAME, makeAny( ::rtl::OUString() ) );
}
catch( const Exception& )
{
DBG_UNHANDLED_EXCEPTION();
}
// if the element is a container itself, step down the component hierarchy
Reference< XIndexAccess > xContainer( xForm, UNO_QUERY );
if ( xContainer.is() )
lcl_resetChildFormsToEmptyDataSource( xContainer );
}
}
void lcl_resetFormsToEmptyDataSource( const Reference< XEmbeddedObject>& _rxEmbeddedObject )
{
try
{
Reference< XComponentSupplier > xCompProv( _rxEmbeddedObject, UNO_QUERY_THROW );
Reference< XDrawPageSupplier > xSuppPage( xCompProv->getComponent(), UNO_QUERY_THROW );
// if this interface does not exist, then either getComponent returned NULL,
// or the document is a multi-page document. The latter is allowed, but currently
// simply not handled by this code, as it would not normally happen.
Reference< XFormsSupplier > xSuppForms( xSuppPage->getDrawPage(), UNO_QUERY_THROW );
Reference< XIndexAccess > xForms( xSuppForms->getForms(), UNO_QUERY_THROW );
lcl_resetChildFormsToEmptyDataSource( xForms );
}
catch( const Exception& )
{
DBG_UNHANDLED_EXCEPTION();
}
}
}
// -----------------------------------------------------------------------------
void ODocumentDefinition::onCommandInsert( const ::rtl::OUString& _sURL, const Reference< XCommandEnvironment >& Environment )
throw( Exception )
{
osl::ClearableGuard< osl::Mutex > aGuard( m_aMutex );
// Check, if all required properties were set.
if ( !_sURL.getLength() || m_xEmbeddedObject.is() )
{
OSL_ENSURE( sal_False, "Content::onCommandInsert - property value missing!" );
Sequence< rtl::OUString > aProps( 1 );
aProps[ 0 ] = PROPERTY_URL;
ucbhelper::cancelCommandExecution(
makeAny( MissingPropertiesException(
rtl::OUString(),
static_cast< cppu::OWeakObject * >( this ),
aProps ) ),
Environment );
// Unreachable
}
if ( !m_xEmbeddedObject.is() )
{
Reference< XStorage> xStorage = getContainerStorage();
if ( xStorage.is() )
{
Reference< XEmbedObjectCreator> xEmbedFactory( m_aContext.createComponent( "com.sun.star.embed.EmbeddedObjectCreator" ), UNO_QUERY );
if ( xEmbedFactory.is() )
{
Sequence<PropertyValue> aEmpty,aMediaDesc(1);
aMediaDesc[0].Name = PROPERTY_URL;
aMediaDesc[0].Value <<= _sURL;
m_xEmbeddedObject.set(xEmbedFactory->createInstanceInitFromMediaDescriptor( xStorage
,m_pImpl->m_aProps.sPersistentName
,aMediaDesc
,aEmpty),UNO_QUERY);
lcl_resetFormsToEmptyDataSource( m_xEmbeddedObject );
// #i57669# / 2005-12-01 / <EMAIL>
Reference<XEmbedPersist> xPersist(m_xEmbeddedObject,UNO_QUERY);
if ( xPersist.is() )
{
xPersist->storeOwn();
}
try
{
Reference< com::sun::star::util::XCloseable> xCloseable(m_xEmbeddedObject,UNO_QUERY);
if ( xCloseable.is() )
xCloseable->close(sal_True);
}
catch(Exception)
{
}
m_xEmbeddedObject = NULL;
}
}
}
// @@@
// storeData();
aGuard.clear();
// inserted();
}
// -----------------------------------------------------------------------------
sal_Bool ODocumentDefinition::save(sal_Bool _bApprove)
{
// default handling: instantiate an interaction handler and let it handle the parameter request
if ( !m_bOpenInDesign )
return sal_False;
try
{
{
::vos::OGuard aSolarGuard(Application::GetSolarMutex());
// the request
Reference<XNameAccess> xName(m_xParentContainer,UNO_QUERY);
DocumentSaveRequest aRequest;
aRequest.Name = m_pImpl->m_aProps.aTitle;
if ( !aRequest.Name.getLength() )
{
if ( m_bForm )
aRequest.Name = DBACORE_RESSTRING( RID_STR_FORM );
else
aRequest.Name = DBACORE_RESSTRING( RID_STR_REPORT );
aRequest.Name = ::dbtools::createUniqueName(xName,aRequest.Name);
}
aRequest.Content.set(m_xParentContainer,UNO_QUERY);
OInteractionRequest* pRequest = new OInteractionRequest(makeAny(aRequest));
Reference< XInteractionRequest > xRequest(pRequest);
// some knittings
// two continuations allowed: OK and Cancel
ODocumentSaveContinuation* pDocuSave = NULL;
if ( !m_pImpl->m_aProps.aTitle.getLength() )
{
pDocuSave = new ODocumentSaveContinuation;
pRequest->addContinuation(pDocuSave);
}
OInteraction< XInteractionApprove >* pApprove = NULL;
if ( _bApprove )
{
pApprove = new OInteraction< XInteractionApprove >;
pRequest->addContinuation(pApprove);
}
OInteraction< XInteractionDisapprove >* pDisApprove = new OInteraction< XInteractionDisapprove >;
pRequest->addContinuation(pDisApprove);
OInteractionAbort* pAbort = new OInteractionAbort;
pRequest->addContinuation(pAbort);
// create the handler, let it handle the request
Reference< XInteractionHandler > xHandler( m_aContext.createComponent( (::rtl::OUString)SERVICE_TASK_INTERACTION_HANDLER ), UNO_QUERY );
if ( xHandler.is() )
xHandler->handle(xRequest);
if ( pAbort->wasSelected() )
return sal_False;
if ( pDisApprove->wasSelected() )
return sal_True;
if ( pDocuSave && pDocuSave->wasSelected() )
{
Reference<XNameContainer> xNC( pDocuSave->getContent(), UNO_QUERY_THROW );
::osl::ResettableMutexGuard aGuard( m_aMutex );
NameChangeNotifier aNameChangeAndNotify( *this, pDocuSave->getName(), aGuard );
m_pImpl->m_aProps.aTitle = pDocuSave->getName();
Reference< XContent> xContent = this;
xNC->insertByName(pDocuSave->getName(),makeAny(xContent));
updateDocumentTitle();
}
}
::osl::MutexGuard aGuard(m_aMutex);
Reference<XEmbedPersist> xPersist(m_xEmbeddedObject,UNO_QUERY);
if ( xPersist.is() )
{
xPersist->storeOwn();
notifyDataSourceModified();
}
}
catch(Exception&)
{
OSL_ENSURE(0,"ODocumentDefinition::save: caught an Exception (tried to let the InteractionHandler handle it)!");
}
return sal_True;
}
// -----------------------------------------------------------------------------
sal_Bool ODocumentDefinition::saveAs()
{
// default handling: instantiate an interaction handler and let it handle the parameter request
if ( !m_bOpenInDesign )
return sal_False;
{
osl::ClearableGuard< osl::Mutex > aGuard( m_aMutex );
if ( !m_pImpl->m_aProps.aTitle.getLength() )
{
aGuard.clear();
return save(sal_False); // (sal_False) : we don't want an approve dialog
}
}
try
{
{
::vos::OGuard aSolarGuard(Application::GetSolarMutex());
// the request
Reference<XNameAccess> xName(m_xParentContainer,UNO_QUERY);
DocumentSaveRequest aRequest;
aRequest.Name = m_pImpl->m_aProps.aTitle;
aRequest.Content.set(m_xParentContainer,UNO_QUERY);
OInteractionRequest* pRequest = new OInteractionRequest(makeAny(aRequest));
Reference< XInteractionRequest > xRequest(pRequest);
// some knittings
// two continuations allowed: OK and Cancel
ODocumentSaveContinuation* pDocuSave = new ODocumentSaveContinuation;
pRequest->addContinuation(pDocuSave);
OInteraction< XInteractionDisapprove >* pDisApprove = new OInteraction< XInteractionDisapprove >;
pRequest->addContinuation(pDisApprove);
OInteractionAbort* pAbort = new OInteractionAbort;
pRequest->addContinuation(pAbort);
// create the handler, let it handle the request
Reference< XInteractionHandler > xHandler(m_aContext.createComponent(::rtl::OUString(SERVICE_TASK_INTERACTION_HANDLER)), UNO_QUERY);
if ( xHandler.is() )
xHandler->handle(xRequest);
if ( pAbort->wasSelected() )
return sal_False;
if ( pDisApprove->wasSelected() )
return sal_True;
if ( pDocuSave->wasSelected() )
{
::osl::MutexGuard aGuard(m_aMutex);
Reference<XNameContainer> xNC(pDocuSave->getContent(),UNO_QUERY);
if ( xNC.is() )
{
if ( m_pImpl->m_aProps.aTitle != pDocuSave->getName() )
{
try
{
Reference< XStorage> xStorage = getContainerStorage();
const static ::rtl::OUString sBaseName(RTL_CONSTASCII_USTRINGPARAM("Obj"));
// -----------------------------------------------------------------------------
Reference<XNameAccess> xElements(xStorage,UNO_QUERY_THROW);
::rtl::OUString sPersistentName = ::dbtools::createUniqueName(xElements,sBaseName);
xStorage->copyElementTo(m_pImpl->m_aProps.sPersistentName,xStorage,sPersistentName);
::rtl::OUString sOldName = m_pImpl->m_aProps.aTitle;
rename(pDocuSave->getName());
updateDocumentTitle();
Sequence< Any > aArguments(3);
PropertyValue aValue;
// set as folder
aValue.Name = PROPERTY_NAME;
aValue.Value <<= sOldName;
aArguments[0] <<= aValue;
aValue.Name = PROPERTY_PERSISTENT_NAME;
aValue.Value <<= sPersistentName;
aArguments[1] <<= aValue;
aValue.Name = PROPERTY_AS_TEMPLATE;
aValue.Value <<= m_pImpl->m_aProps.bAsTemplate;
aArguments[2] <<= aValue;
Reference< XMultiServiceFactory > xORB( m_xParentContainer, UNO_QUERY_THROW );
Reference< XInterface > xComponent( xORB->createInstanceWithArguments( SERVICE_SDB_DOCUMENTDEFINITION, aArguments ) );
Reference< XNameContainer > xNameContainer( m_xParentContainer, UNO_QUERY_THROW );
xNameContainer->insertByName( sOldName, makeAny( xComponent ) );
}
catch(Exception&)
{
DBG_UNHANDLED_EXCEPTION();
}
}
Reference<XEmbedPersist> xPersist(m_xEmbeddedObject,UNO_QUERY);
if ( xPersist.is() )
{
xPersist->storeOwn();
notifyDataSourceModified();
}
}
}
}
}
catch(Exception&)
{
OSL_ENSURE(0,"ODocumentDefinition::save: caught an Exception (tried to let the InteractionHandler handle it)!");
}
return sal_True;
}
namespace
{
// .........................................................................
void lcl_putLoadArgs( ::comphelper::NamedValueCollection& _io_rArgs, const optional_bool _bSuppressMacros, const optional_bool _bReadOnly )
{
if ( !!_bSuppressMacros )
{
if ( *_bSuppressMacros )
{
// if we're to suppress macros, do exactly this
_io_rArgs.put( "MacroExecutionMode", MacroExecMode::NEVER_EXECUTE );
}
else
{
// otherwise, put the setting only if not already present
if ( !_io_rArgs.has( "MacroExecutionMode" ) )
{
_io_rArgs.put( "MacroExecutionMode", MacroExecMode::USE_CONFIG );
}
}
}
if ( !!_bReadOnly )
_io_rArgs.put( "ReadOnly", *_bReadOnly );
}
}
// -----------------------------------------------------------------------------
namespace
{
Reference< XFrame > lcl_getDatabaseDocumentFrame( ODatabaseModelImpl& _rImpl )
{
Reference< XModel > xDatabaseDocumentModel( _rImpl.getModel_noCreate() );
Reference< XController > xDatabaseDocumentController;
if ( xDatabaseDocumentModel.is() )
xDatabaseDocumentController = xDatabaseDocumentModel->getCurrentController();
Reference< XFrame > xFrame;
if ( xDatabaseDocumentController.is() )
xFrame = xDatabaseDocumentController->getFrame();
return xFrame;
}
}
// -----------------------------------------------------------------------------
sal_Bool ODocumentDefinition::objectSupportsEmbeddedScripts() const
{
bool bAllowDocumentMacros = !m_pImpl->m_pDataSource
|| ( m_pImpl->m_pDataSource->determineEmbeddedMacros() == ODatabaseModelImpl::eSubDocumentMacros );
// if *any* of the objects of the database document already has macros, we continue to allow it
// to have them, until the user did a migration.
// If there are no macros, yet, we don't allow to create them
return bAllowDocumentMacros;
}
// -----------------------------------------------------------------------------
::rtl::OUString ODocumentDefinition::determineContentType() const
{
return lcl_determineContentType_nothrow( getContainerStorage(), m_pImpl->m_aProps.sPersistentName );
}
// -----------------------------------------------------------------------------
void ODocumentDefinition::separateOpenCommandArguments( const Sequence< PropertyValue >& i_rOpenCommandArguments,
::comphelper::NamedValueCollection& o_rDocumentLoadArgs, ::comphelper::NamedValueCollection& o_rEmbeddedObjectDescriptor )
{
::comphelper::NamedValueCollection aOpenCommandArguments( i_rOpenCommandArguments );
const sal_Char* pObjectDescriptorArgs[] =
{
"RecoveryStorage"
};
for ( size_t i=0; i < sizeof( pObjectDescriptorArgs ) / sizeof( pObjectDescriptorArgs[0] ); ++i )
{
if ( aOpenCommandArguments.has( pObjectDescriptorArgs[i] ) )
{
o_rEmbeddedObjectDescriptor.put( pObjectDescriptorArgs[i], aOpenCommandArguments.get( pObjectDescriptorArgs[i] ) );
aOpenCommandArguments.remove( pObjectDescriptorArgs[i] );
}
}
o_rDocumentLoadArgs.merge( aOpenCommandArguments, false );
}
// -----------------------------------------------------------------------------
Sequence< PropertyValue > ODocumentDefinition::fillLoadArgs( const Reference< XConnection>& _xConnection, const bool _bSuppressMacros, const bool _bReadOnly,
const Sequence< PropertyValue >& i_rOpenCommandArguments, Sequence< PropertyValue >& _out_rEmbeddedObjectDescriptor )
{
// .........................................................................
// (re-)create interceptor, and put it into the descriptor of the embedded object
if ( m_pInterceptor )
{
m_pInterceptor->dispose();
m_pInterceptor->release();
m_pInterceptor = NULL;
}
m_pInterceptor = new OInterceptor( this ,_bReadOnly);
m_pInterceptor->acquire();
Reference<XDispatchProviderInterceptor> xInterceptor = m_pInterceptor;
::comphelper::NamedValueCollection aEmbeddedDescriptor;
aEmbeddedDescriptor.put( "OutplaceDispatchInterceptor", xInterceptor );
// .........................................................................
::comphelper::NamedValueCollection aMediaDesc;
separateOpenCommandArguments( i_rOpenCommandArguments, aMediaDesc, aEmbeddedDescriptor );
// .........................................................................
// create the OutplaceFrameProperties, and put them into the descriptor of the embedded object
::comphelper::NamedValueCollection OutplaceFrameProperties;
OutplaceFrameProperties.put( "TopWindow", (sal_Bool)sal_True );
Reference< XFrame > xParentFrame;
if ( m_pImpl->m_pDataSource )
xParentFrame = lcl_getDatabaseDocumentFrame( *m_pImpl->m_pDataSource );
if ( !xParentFrame.is() )
{ // i87957 we need a parent frame
Reference< XComponentLoader > xDesktop( m_aContext.createComponent( (::rtl::OUString)SERVICE_FRAME_DESKTOP ), UNO_QUERY_THROW );
xParentFrame.set( xDesktop, UNO_QUERY );
if ( xParentFrame.is() )
{
Reference<util::XCloseable> xCloseable(m_pImpl->m_pDataSource->getModel_noCreate(),UNO_QUERY);
if ( xCloseable.is() )
{
xCloseable->addCloseListener(this);
m_bRemoveListener = sal_True;
}
}
}
OSL_ENSURE( xParentFrame.is(), "ODocumentDefinition::fillLoadArgs: no parent frame!" );
if ( xParentFrame.is() )
OutplaceFrameProperties.put( "ParentFrame", xParentFrame );
aEmbeddedDescriptor.put( "OutplaceFrameProperties", OutplaceFrameProperties.getNamedValues() );
// .........................................................................
// tell the embedded object to have (or not have) script support
aEmbeddedDescriptor.put( "EmbeddedScriptSupport", (sal_Bool)objectSupportsEmbeddedScripts() );
// .........................................................................
// tell the embedded object to not participate in the document recovery game - the DB doc will handle it
aEmbeddedDescriptor.put( "DocumentRecoverySupport", (sal_Bool)sal_False );
// .........................................................................
// pass the descriptor of the embedded object to the caller
aEmbeddedDescriptor >>= _out_rEmbeddedObjectDescriptor;
// .........................................................................
// create the ComponentData, and put it into the document's media descriptor
{
::comphelper::NamedValueCollection aComponentData;
aComponentData.put( "ActiveConnection", _xConnection );
aComponentData.put( "ApplyFormDesignMode", !_bReadOnly );
aMediaDesc.put( "ComponentData", aComponentData.getPropertyValues() );
}
if ( m_pImpl->m_aProps.aTitle.getLength() )
aMediaDesc.put( "DocumentTitle", m_pImpl->m_aProps.aTitle );
aMediaDesc.put( "DocumentBaseURL", m_pImpl->m_pDataSource->getURL() );
// .........................................................................
// put the common load arguments into the document's media descriptor
lcl_putLoadArgs( aMediaDesc, optional_bool( _bSuppressMacros ), optional_bool( _bReadOnly ) );
return aMediaDesc.getPropertyValues();
}
// -----------------------------------------------------------------------------
void ODocumentDefinition::loadEmbeddedObject( const Reference< XConnection >& i_rConnection, const Sequence< sal_Int8 >& _aClassID,
const Sequence< PropertyValue >& i_rOpenCommandArguments, const bool _bSuppressMacros, const bool _bReadOnly )
{
if ( !m_xEmbeddedObject.is() )
{
Reference< XStorage> xStorage = getContainerStorage();
if ( xStorage.is() )
{
Reference< XEmbedObjectFactory> xEmbedFactory( m_aContext.createComponent( "com.sun.star.embed.OOoEmbeddedObjectFactory" ), UNO_QUERY );
if ( xEmbedFactory.is() )
{
::rtl::OUString sDocumentService;
sal_Bool bSetSize = sal_False;
sal_Int32 nEntryConnectionMode = EntryInitModes::DEFAULT_INIT;
Sequence< sal_Int8 > aClassID = _aClassID;
if ( aClassID.getLength() )
{
nEntryConnectionMode = EntryInitModes::TRUNCATE_INIT;
bSetSize = sal_True;
}
else
{
sDocumentService = GetDocumentServiceFromMediaType( getContentType(), m_aContext, aClassID );
// check if we are not a form and
// the com.sun.star.report.pentaho.SOReportJobFactory is not present.
if ( !m_bForm && !sDocumentService.equalsAscii("com.sun.star.text.TextDocument"))
{
// we seem to be a "new style" report, check if report extension is present.
Reference< XContentEnumerationAccess > xEnumAccess( m_aContext.getLegacyServiceFactory(), UNO_QUERY );
const ::rtl::OUString sReportEngineServiceName = ::dbtools::getDefaultReportEngineServiceName(m_aContext.getLegacyServiceFactory());
Reference< XEnumeration > xEnumDrivers = xEnumAccess->createContentEnumeration(sReportEngineServiceName);
if ( !xEnumDrivers.is() || !xEnumDrivers->hasMoreElements() )
{
com::sun::star::io::WrongFormatException aWFE;
aWFE.Message = DBACORE_RESSTRING( RID_STR_MISSING_EXTENSION );
throw aWFE;
}
}
if ( !aClassID.getLength() )
{
if ( m_bForm )
aClassID = MimeConfigurationHelper::GetSequenceClassID(SO3_SW_CLASSID);
else
{
aClassID = MimeConfigurationHelper::GetSequenceClassID(SO3_RPT_CLASSID_90);
}
}
}
OSL_ENSURE( aClassID.getLength(),"No Class ID" );
Sequence< PropertyValue > aEmbeddedObjectDescriptor;
Sequence< PropertyValue > aLoadArgs( fillLoadArgs(
i_rConnection, _bSuppressMacros, _bReadOnly, i_rOpenCommandArguments, aEmbeddedObjectDescriptor ) );
m_xEmbeddedObject.set(xEmbedFactory->createInstanceUserInit(aClassID
,sDocumentService
,xStorage
,m_pImpl->m_aProps.sPersistentName
,nEntryConnectionMode
,aLoadArgs
,aEmbeddedObjectDescriptor
),UNO_QUERY);
if ( m_xEmbeddedObject.is() )
{
if ( !m_pClientHelper )
{
m_pClientHelper = new OEmbeddedClientHelper(this);
m_pClientHelper->acquire();
}
Reference<XEmbeddedClient> xClient = m_pClientHelper;
m_xEmbeddedObject->setClientSite(xClient);
m_xEmbeddedObject->changeState(EmbedStates::RUNNING);
if ( bSetSize )
{
LockModifiable aLockModify( impl_getComponent_throw( false ) );
awt::Size aSize( DEFAULT_WIDTH, DEFAULT_HEIGHT );
m_xEmbeddedObject->setVisualAreaSize(Aspects::MSOLE_CONTENT,aSize);
}
}
}
}
}
else
{
sal_Int32 nCurrentState = m_xEmbeddedObject->getCurrentState();
if ( nCurrentState == EmbedStates::LOADED )
{
if ( !m_pClientHelper )
{
m_pClientHelper = new OEmbeddedClientHelper(this);
m_pClientHelper->acquire();
}
Reference<XEmbeddedClient> xClient = m_pClientHelper;
m_xEmbeddedObject->setClientSite(xClient);
Sequence< PropertyValue > aEmbeddedObjectDescriptor;
Sequence< PropertyValue > aLoadArgs( fillLoadArgs(
i_rConnection, _bSuppressMacros, _bReadOnly, i_rOpenCommandArguments, aEmbeddedObjectDescriptor ) );
Reference<XCommonEmbedPersist> xCommon(m_xEmbeddedObject,UNO_QUERY);
OSL_ENSURE(xCommon.is(),"unsupported interface!");
if ( xCommon.is() )
xCommon->reload( aLoadArgs, aEmbeddedObjectDescriptor );
m_xEmbeddedObject->changeState(EmbedStates::RUNNING);
}
else
{
OSL_ENSURE( ( nCurrentState == EmbedStates::RUNNING ) || ( nCurrentState == EmbedStates::ACTIVE ),
"ODocumentDefinition::loadEmbeddedObject: unexpected state!" );
// if the document was already loaded (which means the embedded object is in state RUNNING or ACTIVE),
// then just re-set some model parameters
try
{
// ensure the media descriptor doesn't contain any values which are intended for the
// EmbeddedObjectDescriptor only
::comphelper::NamedValueCollection aEmbeddedObjectDescriptor;
::comphelper::NamedValueCollection aNewMediaDesc;
separateOpenCommandArguments( i_rOpenCommandArguments, aNewMediaDesc, aEmbeddedObjectDescriptor );
// merge the new media descriptor into the existing media descriptor
const Reference< XModel > xModel( getComponent(), UNO_QUERY_THROW );
const Sequence< PropertyValue > aArgs = xModel->getArgs();
::comphelper::NamedValueCollection aExistentMediaDesc( aArgs );
aExistentMediaDesc.merge( aNewMediaDesc, sal_False );
lcl_putLoadArgs( aExistentMediaDesc, optional_bool(), optional_bool() );
// don't put _bSuppressMacros and _bReadOnly here - if the document was already
// loaded, we should not tamper with its settings.
// #i88977# / 2008-05-05 / <EMAIL>
// #i86872# / 2008-03-13 / <EMAIL>
xModel->attachResource( xModel->getURL(), aExistentMediaDesc.getPropertyValues() );
}
catch( const Exception& )
{
DBG_UNHANDLED_EXCEPTION();
}
}
}
// set the OfficeDatabaseDocument instance as parent of the embedded document
// #i40358# / 2005-01-19 / <EMAIL>
Reference< XChild > xDepdendDocAsChild( getComponent(), UNO_QUERY );
if ( xDepdendDocAsChild.is() )
{
try
{
if ( !xDepdendDocAsChild->getParent().is() )
{ // first encounter
xDepdendDocAsChild->setParent( getDataSource( m_xParentContainer ) );
}
}
catch( const Exception& )
{
DBG_UNHANDLED_EXCEPTION();
}
}
if ( i_rConnection.is() )
m_xLastKnownConnection = i_rConnection;
}
// -----------------------------------------------------------------------------
void ODocumentDefinition::onCommandPreview(Any& _rImage)
{
loadEmbeddedObjectForPreview();
if ( m_xEmbeddedObject.is() )
{
try
{
Reference<XTransferable> xTransfer(getComponent(),UNO_QUERY);
if ( xTransfer.is() )
{
DataFlavor aFlavor;
aFlavor.MimeType = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("image/png"));
aFlavor.HumanPresentableName = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("Portable Network Graphics"));
aFlavor.DataType = ::getCppuType(static_cast< const Sequence < sal_Int8 >* >(NULL));
_rImage = xTransfer->getTransferData( aFlavor );
}
}
catch( Exception )
{
}
}
}
// -----------------------------------------------------------------------------
void ODocumentDefinition::getPropertyDefaultByHandle( sal_Int32 /*_nHandle*/, Any& _rDefault ) const
{
_rDefault.clear();
}
// -----------------------------------------------------------------------------
void ODocumentDefinition::onCommandGetDocumentProperties( Any& _rProps )
{
loadEmbeddedObjectForPreview();
if ( m_xEmbeddedObject.is() )
{
try
{
Reference<XDocumentPropertiesSupplier> xDocSup(
getComponent(), UNO_QUERY );
if ( xDocSup.is() )
_rProps <<= xDocSup->getDocumentProperties();
}
catch( const Exception& )
{
DBG_UNHANDLED_EXCEPTION();
}
}
}
// -----------------------------------------------------------------------------
Reference< util::XCloseable > ODocumentDefinition::impl_getComponent_throw( const bool i_ForceCreate )
{
OSL_ENSURE(m_xEmbeddedObject.is(),"Illegal call for embeddedObject");
Reference< util::XCloseable > xComp;
if ( m_xEmbeddedObject.is() )
{
int nState = m_xEmbeddedObject->getCurrentState();
if ( ( nState == EmbedStates::LOADED ) && i_ForceCreate )
{
m_xEmbeddedObject->changeState( EmbedStates::RUNNING );
nState = m_xEmbeddedObject->getCurrentState();
OSL_ENSURE( nState == EmbedStates::RUNNING, "ODocumentDefinition::impl_getComponent_throw: could not switch to RUNNING!" );
}
if ( nState == EmbedStates::ACTIVE || nState == EmbedStates::RUNNING )
{
Reference<XComponentSupplier> xCompProv(m_xEmbeddedObject,UNO_QUERY);
if ( xCompProv.is() )
{
xComp = xCompProv->getComponent();
OSL_ENSURE(xComp.is(),"No valid component");
}
}
}
return xComp;
}
// -----------------------------------------------------------------------------
Reference< util::XCloseable > ODocumentDefinition::getComponent() throw (RuntimeException)
{
::osl::MutexGuard aGuard( m_aMutex );
return impl_getComponent_throw( true );
}
// -----------------------------------------------------------------------------
namespace
{
Reference< XDatabaseDocumentUI > lcl_getDatabaseDocumentUI( ODatabaseModelImpl& _rModelImpl )
{
Reference< XDatabaseDocumentUI > xUI;
Reference< XModel > xModel( _rModelImpl.getModel_noCreate() );
if ( xModel.is() )
xUI.set( xModel->getCurrentController(), UNO_QUERY );
return xUI;
}
}
// -----------------------------------------------------------------------------
Reference< XComponent > ODocumentDefinition::impl_openUI_nolck_throw( bool _bForEditing )
{
::osl::ClearableMutexGuard aGuard( m_aMutex );
if ( !m_pImpl || !m_pImpl->m_pDataSource )
throw DisposedException();
Reference< XDatabaseDocumentUI > xUI( lcl_getDatabaseDocumentUI( *m_pImpl->m_pDataSource ) );
if ( !xUI.is() )
{
// no XDatabaseDocumentUI -> just execute the respective command
m_bOpenInDesign = _bForEditing;
Reference< XComponent > xComponent( onCommandOpenSomething( Any(), true, NULL ), UNO_QUERY );
OSL_ENSURE( xComponent.is(), "ODocumentDefinition::impl_openUI_nolck_throw: opening the thingie failed." );
return xComponent;
}
Reference< XComponent > xComponent;
try
{
::rtl::OUString sName( impl_getHierarchicalName( false ) );
sal_Int32 nObjectType = m_bForm ? DatabaseObject::FORM : DatabaseObject::REPORT;
aGuard.clear();
xComponent = xUI->loadComponent(
nObjectType, sName, _bForEditing
);
}
catch( RuntimeException& ) { throw; }
catch( const Exception& )
{
throw WrappedTargetException(
::rtl::OUString(), *this, ::cppu::getCaughtException() );
}
return xComponent;
}
// -----------------------------------------------------------------------------
void ODocumentDefinition::impl_store_throw()
{
Reference<XEmbedPersist> xPersist( m_xEmbeddedObject, UNO_QUERY );
if ( xPersist.is() )
{
xPersist->storeOwn();
notifyDataSourceModified();
}
}
// -----------------------------------------------------------------------------
bool ODocumentDefinition::impl_close_throw()
{
bool bSuccess = prepareClose();
if ( bSuccess && m_xEmbeddedObject.is() )
{
m_xEmbeddedObject->changeState( EmbedStates::LOADED );
bSuccess = m_xEmbeddedObject->getCurrentState() == EmbedStates::LOADED;
}
return bSuccess;
}
// -----------------------------------------------------------------------------
Reference< XComponent > SAL_CALL ODocumentDefinition::open( ) throw (WrappedTargetException, RuntimeException)
{
return impl_openUI_nolck_throw( false );
}
// -----------------------------------------------------------------------------
Reference< XComponent > SAL_CALL ODocumentDefinition::openDesign( ) throw (WrappedTargetException, RuntimeException)
{
return impl_openUI_nolck_throw( true );
}
// -----------------------------------------------------------------------------
void SAL_CALL ODocumentDefinition::store( ) throw (WrappedTargetException, RuntimeException)
{
::osl::MutexGuard aGuard( m_aMutex );
try
{
impl_store_throw();
}
catch( RuntimeException& ) { throw; }
catch( const Exception& )
{
throw WrappedTargetException(
::rtl::OUString(), *this, ::cppu::getCaughtException() );
}
}
// -----------------------------------------------------------------------------
::sal_Bool SAL_CALL ODocumentDefinition::close( ) throw (WrappedTargetException, RuntimeException)
{
::osl::MutexGuard aGuard( m_aMutex );
sal_Bool bSuccess = sal_False;
try
{
bSuccess = impl_close_throw();
}
catch( RuntimeException& ) { throw; }
catch( const Exception& )
{
throw WrappedTargetException(
::rtl::OUString(), *this, ::cppu::getCaughtException() );
}
return bSuccess;
}
// -----------------------------------------------------------------------------
::rtl::OUString SAL_CALL ODocumentDefinition::getHierarchicalName() throw (RuntimeException)
{
::osl::MutexGuard aGuard( m_aMutex );
return impl_getHierarchicalName( false );
}
// -----------------------------------------------------------------------------
::rtl::OUString SAL_CALL ODocumentDefinition::composeHierarchicalName( const ::rtl::OUString& i_rRelativeName ) throw (IllegalArgumentException, NoSupportException, RuntimeException)
{
::rtl::OUStringBuffer aBuffer;
aBuffer.append( getHierarchicalName() );
aBuffer.append( sal_Unicode( '/' ) );
aBuffer.append( i_rRelativeName );
return aBuffer.makeStringAndClear();
}
// -----------------------------------------------------------------------------
void SAL_CALL ODocumentDefinition::rename( const ::rtl::OUString& _rNewName ) throw (SQLException, ElementExistException, RuntimeException)
{
try
{
::osl::ResettableMutexGuard aGuard(m_aMutex);
if ( _rNewName.equals( m_pImpl->m_aProps.aTitle ) )
return;
// document definitions are organized in a hierarchical way, so reject names
// which contain a /, as this is reserved for hierarchy level separation
if ( _rNewName.indexOf( '/' ) != -1 )
m_aErrorHelper.raiseException( ErrorCondition::DB_OBJECT_NAME_WITH_SLASHES, *this );
NameChangeNotifier aNameChangeAndNotify( *this, _rNewName, aGuard );
m_pImpl->m_aProps.aTitle = _rNewName;
if ( m_xEmbeddedObject.is() && m_xEmbeddedObject->getCurrentState() == EmbedStates::ACTIVE )
updateDocumentTitle();
}
catch(const PropertyVetoException&)
{
throw ElementExistException(_rNewName,*this);
}
}
// -----------------------------------------------------------------------------
Reference< XStorage> ODocumentDefinition::getContainerStorage() const
{
return m_pImpl->m_pDataSource
? m_pImpl->m_pDataSource->getStorage( m_bForm ? ODatabaseModelImpl::E_FORM : ODatabaseModelImpl::E_REPORT )
: Reference< XStorage>();
}
// -----------------------------------------------------------------------------
sal_Bool ODocumentDefinition::isModified()
{
osl::ClearableGuard< osl::Mutex > aGuard(m_aMutex);
sal_Bool bRet = sal_False;
if ( m_xEmbeddedObject.is() )
{
Reference<XModifiable> xModel(getComponent(),UNO_QUERY);
bRet = xModel.is() && xModel->isModified();
}
return bRet;
}
// -----------------------------------------------------------------------------
bool ODocumentDefinition::prepareClose()
{
if ( !m_xEmbeddedObject.is() )
return true;
try
{
// suspend the controller. Embedded objects are not allowed to raise
// own UI at their own discretion, instead, this has always to be triggered
// by the embedding component. Thus, we do the suspend call here.
// #i49370# / 2005-06-09 / <EMAIL>
Reference< util::XCloseable > xComponent( impl_getComponent_throw( false ) );
if ( !xComponent.is() )
return true;
Reference< XModel > xModel( xComponent, UNO_QUERY );
Reference< XController > xController;
if ( xModel.is() )
xController = xModel->getCurrentController();
OSL_ENSURE( xController.is() || ( m_xEmbeddedObject->getCurrentState() < EmbedStates::ACTIVE ),
"ODocumentDefinition::prepareClose: no controller!" );
if ( !xController.is() )
// document has not yet been activated, i.e. has no UI, yet
return true;
sal_Bool bCouldSuspend = xController->suspend( sal_True );
if ( !bCouldSuspend )
// controller vetoed the closing
return false;
if ( isModified() )
{
Reference< XFrame > xFrame( xController->getFrame() );
if ( xFrame.is() )
{
Reference< XTopWindow > xTopWindow( xFrame->getContainerWindow(), UNO_QUERY_THROW );
xTopWindow->toFront();
}
if ( !save( sal_True ) )
{
if ( bCouldSuspend )
// revert suspension
xController->suspend( sal_False );
// saving failed or was cancelled
return false;
}
}
}
catch( const Exception& )
{
DBG_UNHANDLED_EXCEPTION();
}
return true;
}
// -----------------------------------------------------------------------------
void ODocumentDefinition::fillReportData( const ::comphelper::ComponentContext& _rContext,
const Reference< util::XCloseable >& _rxComponent,
const Reference< XConnection >& _rxActiveConnection )
{
Sequence< Any > aArgs(2);
PropertyValue aValue;
aValue.Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "TextDocument" ) );
aValue.Value <<= _rxComponent;
aArgs[0] <<= aValue;
aValue.Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ActiveConnection" ) );
aValue.Value <<= _rxActiveConnection;
aArgs[1] <<= aValue;
try
{
Reference< XJobExecutor > xExecuteable(
_rContext.createComponentWithArguments( "com.sun.star.wizards.report.CallReportWizard", aArgs ), UNO_QUERY_THROW );
xExecuteable->trigger( ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "fill" ) ) );
}
catch( const Exception& )
{
DBG_UNHANDLED_EXCEPTION();
}
}
// -----------------------------------------------------------------------------
void ODocumentDefinition::updateDocumentTitle()
{
::rtl::OUString sName = m_pImpl->m_aProps.aTitle;
if ( m_pImpl->m_pDataSource )
{
if ( !sName.getLength() )
{
if ( m_bForm )
sName = DBACORE_RESSTRING( RID_STR_FORM );
else
sName = DBACORE_RESSTRING( RID_STR_REPORT );
Reference< XUntitledNumbers > xUntitledProvider(m_pImpl->m_pDataSource->getModel_noCreate(), UNO_QUERY );
if ( xUntitledProvider.is() )
sName += ::rtl::OUString::valueOf( xUntitledProvider->leaseNumber(getComponent()) );
}
Reference< XTitle > xDatabaseDocumentModel(m_pImpl->m_pDataSource->getModel_noCreate(),uno::UNO_QUERY);
if ( xDatabaseDocumentModel.is() )
sName = xDatabaseDocumentModel->getTitle() + ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(" : ")) + sName;
}
Reference< XTitle> xTitle(getComponent(),UNO_QUERY);
if ( xTitle.is() )
xTitle->setTitle(sName);
}
// -----------------------------------------------------------------------------
void SAL_CALL ODocumentDefinition::queryClosing( const lang::EventObject& Source, ::sal_Bool GetsOwnership ) throw (util::CloseVetoException, uno::RuntimeException)
{
(void) Source;
(void) GetsOwnership;
try
{
if ( !close() )
throw util::CloseVetoException();
}
catch(const lang::WrappedTargetException&)
{
throw util::CloseVetoException();
}
}
// -----------------------------------------------------------------------------
void SAL_CALL ODocumentDefinition::notifyClosing( const lang::EventObject& /*Source*/ ) throw (uno::RuntimeException)
{
}
// -----------------------------------------------------------------------------
void SAL_CALL ODocumentDefinition::disposing( const lang::EventObject& /*Source*/ ) throw (uno::RuntimeException)
{
}
// -----------------------------------------------------------------------------
void ODocumentDefinition::firePropertyChange( sal_Int32 i_nHandle, const Any& i_rNewValue, const Any& i_rOldValue,
sal_Bool i_bVetoable, const NotifierAccess )
{
fire( &i_nHandle, &i_rNewValue, &i_rOldValue, 1, i_bVetoable );
}
// =============================================================================
// NameChangeNotifier
// =============================================================================
// -----------------------------------------------------------------------------
NameChangeNotifier::NameChangeNotifier( ODocumentDefinition& i_rDocumentDefinition, const ::rtl::OUString& i_rNewName,
::osl::ResettableMutexGuard& i_rClearForNotify )
:m_rDocumentDefinition( i_rDocumentDefinition )
,m_aOldValue( makeAny( i_rDocumentDefinition.getCurrentName() ) )
,m_aNewValue( makeAny( i_rNewName ) )
,m_rClearForNotify( i_rClearForNotify )
{
impl_fireEvent_throw( sal_True );
}
// -----------------------------------------------------------------------------
NameChangeNotifier::~NameChangeNotifier()
{
impl_fireEvent_throw( sal_False );
}
// -----------------------------------------------------------------------------
void NameChangeNotifier::impl_fireEvent_throw( const sal_Bool i_bVetoable )
{
m_rClearForNotify.clear();
m_rDocumentDefinition.firePropertyChange(
PROPERTY_ID_NAME, m_aNewValue, m_aOldValue, i_bVetoable, ODocumentDefinition::NotifierAccess() );
m_rClearForNotify.reset();
}
//........................................................................
} // namespace dbaccess
//........................................................................
| 36,698 |
348 | /*
* Copyright 2010-2021 Australian Signals Directorate
*
* 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 au.gov.asd.tac.constellation.plugins.algorithms.clustering.infomap;
import au.gov.asd.tac.constellation.plugins.algorithms.clustering.infomap.util.Resizer;
import java.util.ArrayList;
/**
*
* @author algol
*/
public class PartitionQueue {
private int level;
private int numNonTrivialModules;
private double flow;
private double nonTrivialFlow;
private boolean skip;
private double indexCodelength; // Consolidated
private double leafCodelength; // Consolidated
private double moduleCodelength; // Left to improve on next level
private ArrayList<NodeBase> queue;
public PartitionQueue() {
level = 1;
numNonTrivialModules = 0;
flow = 0;
nonTrivialFlow = 0;
skip = false;
indexCodelength = 0;
leafCodelength = 0;
moduleCodelength = 0;
queue = new ArrayList<>();
}
public int getLevel() {
return level;
}
public void setLevel(final int level) {
this.level = level;
}
public int getNumNonTrivialModules() {
return numNonTrivialModules;
}
public void setNumNonTrivialModules(final int numNonTrivialModules) {
this.numNonTrivialModules = numNonTrivialModules;
}
public double getFlow() {
return flow;
}
public void setFlow(final double flow) {
this.flow = flow;
}
public double getNonTrivialFlow() {
return nonTrivialFlow;
}
public void setNonTrivialFlow(final double nonTrivialFlow) {
this.nonTrivialFlow = nonTrivialFlow;
}
public boolean isSkip() {
return skip;
}
public void setSkip(final boolean skip) {
this.skip = skip;
}
public double getIndexCodelength() {
return indexCodelength;
}
public void setIndexCodelength(final double indexCodelength) {
this.indexCodelength = indexCodelength;
}
public double getLeafCodelength() {
return leafCodelength;
}
public void setLeafCodelength(final double leafCodelength) {
this.leafCodelength = leafCodelength;
}
public double getModuleCodelength() {
return moduleCodelength;
}
public void setModuleCodelength(final double moduleCodelength) {
this.moduleCodelength = moduleCodelength;
}
public ArrayList<NodeBase> getQueue() {
return queue;
}
public void setQueue(final ArrayList<NodeBase> queue) {
this.queue = queue;
}
public void swap(final PartitionQueue other) {
int ti;
double td;
boolean tb;
ti = level;
level = other.level;
other.level = ti;
ti = numNonTrivialModules;
numNonTrivialModules = other.numNonTrivialModules;
other.numNonTrivialModules = ti;
td = flow;
flow = other.flow;
other.flow = td;
td = nonTrivialFlow;
nonTrivialFlow = other.nonTrivialFlow;
other.nonTrivialFlow = td;
tb = skip;
skip = other.skip;
other.skip = tb;
td = indexCodelength;
indexCodelength = other.indexCodelength;
other.indexCodelength = td;
td = leafCodelength;
leafCodelength = other.leafCodelength;
other.leafCodelength = td;
td = moduleCodelength;
moduleCodelength = other.moduleCodelength;
other.moduleCodelength = td;
final ArrayList<NodeBase> tmp = queue;
queue = other.queue;
other.queue = tmp;
}
public int size() {
return queue.size();
}
public void resize(final int size) {
Resizer.resizeNodeBase(queue, size);
}
public void set(final int ix, final NodeBase node) {
queue.set(ix, node);
}
public NodeBase get(final int ix) {
return queue.get(ix);
}
}
| 1,804 |
2,875 | <reponame>Anancha/OpenCV-Python-Tutorial
# -*- coding: utf-8 -*-
# @Time : 2017/7/17 下午12:03
# @Author : play4fun
# @File : 画圆圈.py
# @Software: PyCharm
"""
画圆圈.py:随机覆盖，不同颜色，
"""
from time import sleep
import cv2
import numpy as np
def click_event(event, x, y, flags, param):
'''
用左键点击屏幕，打印坐标
:param event:
:param x:
:param y:
:param flags:
:param param:
:return:
'''
if event == cv2.EVENT_LBUTTONDOWN:
print(x, y, flags, param)
cv2.namedWindow('Canvas', cv2.WINDOW_GUI_EXPANDED)
cv2.setMouseCallback("Canvas", click_event)
canvas = np.zeros((300, 300, 3), dtype="uint8")
while True:
try:
for i in range(0, 25):
radius = np.random.randint(5, high=200)
color = np.random.randint(0, high=256, size=(3,)).tolist()
pt = np.random.randint(0, high=300, size=(2,))
cv2.circle(canvas, tuple(pt), radius, color, -1)
cv2.imshow("Canvas", canvas)
key = cv2.waitKey(1000) # 等待1秒
if key == ord('q'):
break
else:
# sleep(1)
continue
except KeyboardInterrupt as e:
print('KeyboardInterrupt', e)
finally:
cv2.imwrite('random-circles2.jpg', canvas)
| 681 |
2,144 | /**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.pinot.tools.admin.command.filesystem;
import java.net.URI;
import org.apache.pinot.spi.filesystem.PinotFS;
import org.apache.pinot.spi.filesystem.PinotFSFactory;
public class Utils {
private Utils() {
}
public static String getScheme(URI uri) {
if (uri.getScheme() != null) {
return uri.getScheme();
}
return PinotFSFactory.LOCAL_PINOT_FS_SCHEME;
}
public static PinotFS getPinotFS(URI uri) {
String scheme = getScheme(uri);
if (!PinotFSFactory.isSchemeSupported(scheme)) {
System.err.println("File scheme " + scheme + " is not supported.");
throw new RuntimeException("File scheme " + scheme + " is not supported.");
}
return PinotFSFactory.create(scheme);
}
}
| 476 |
333 | <gh_stars>100-1000
package com.alipay.api.domain;
import java.util.Date;
import java.util.List;
import com.alipay.api.AlipayObject;
import com.alipay.api.internal.mapping.ApiField;
import com.alipay.api.internal.mapping.ApiListField;
/**
* 业管平台立项信息DTO
*
* @author auto create
* @since 1.0, 2021-10-14 10:49:26
*/
public class GrmProjectInfoDTO extends AlipayObject {
private static final long serialVersionUID = 1369265131413339777L;
/**
* 附件地址
*/
@ApiListField("attachments_url")
@ApiField("string")
private List<String> attachmentsUrl;
/**
* 延续项目编号
*/
@ApiField("continue_project_code")
private String continueProjectCode;
/**
* 创建人工号
*/
@ApiField("create")
private String create;
/**
* 创建人名称
*/
@ApiField("create_name")
private String createName;
/**
* 产品交付物及验收标准
*/
@ApiListField("critical_deliverable")
@ApiField("deliverable")
private List<Deliverable> criticalDeliverable;
/**
* 项目描述目的及价值
*/
@ApiField("description")
private String description;
/**
* 项目结束时间
*/
@ApiField("end_date")
private Date endDate;
/**
* 业务方代表工号
*/
@ApiField("owner")
private String owner;
/**
* 业务方代表名称
*/
@ApiField("owner_name")
private String ownerName;
/**
* 项目经理工号
*/
@ApiField("pm")
private String pm;
/**
* 项目经理名称
*/
@ApiField("pm_name")
private String pmName;
/**
* PR提交人工号
*/
@ApiField("pr_emp_id")
private String prEmpId;
/**
* pr提交人姓名
*/
@ApiField("pr_emp_name")
private String prEmpName;
/**
* 业管平台立项编码
*/
@ApiField("project_code")
private String projectCode;
/**
* 立项项目详情URL
*/
@ApiField("project_detail_url")
private String projectDetailUrl;
/**
* 业管平台立项名称
*/
@ApiField("project_name")
private String projectName;
/**
* 项目结算类型
*/
@ApiField("project_pay")
private String projectPay;
/**
* 项目时间表
*/
@ApiListField("project_time_sheet")
@ApiField("project_time_table")
private List<ProjectTimeTable> projectTimeSheet;
/**
* 业管平台立项类型大类
*/
@ApiField("project_type")
private String projectType;
/**
* 工作量
*/
@ApiListField("project_workload")
@ApiField("workload")
private List<Workload> projectWorkload;
/**
* 服务地点
*/
@ApiField("service_location")
private String serviceLocation;
/**
* 结算公式编码
*/
@ApiField("settlement_formula_code")
private String settlementFormulaCode;
/**
* 结算公式名称
*/
@ApiField("settlement_formula_name")
private String settlementFormulaName;
/**
* sla详情地址
*/
@ApiField("sla_view_info")
private String slaViewInfo;
/**
* 项目开始时间
*/
@ApiField("start_date")
private Date startDate;
/**
* 立项金额
*/
@ApiField("total_amount")
private String totalAmount;
/**
* 采购用途code
*/
@ApiField("usage_code")
private String usageCode;
public List<String> getAttachmentsUrl() {
return this.attachmentsUrl;
}
public void setAttachmentsUrl(List<String> attachmentsUrl) {
this.attachmentsUrl = attachmentsUrl;
}
public String getContinueProjectCode() {
return this.continueProjectCode;
}
public void setContinueProjectCode(String continueProjectCode) {
this.continueProjectCode = continueProjectCode;
}
public String getCreate() {
return this.create;
}
public void setCreate(String create) {
this.create = create;
}
public String getCreateName() {
return this.createName;
}
public void setCreateName(String createName) {
this.createName = createName;
}
public List<Deliverable> getCriticalDeliverable() {
return this.criticalDeliverable;
}
public void setCriticalDeliverable(List<Deliverable> criticalDeliverable) {
this.criticalDeliverable = criticalDeliverable;
}
public String getDescription() {
return this.description;
}
public void setDescription(String description) {
this.description = description;
}
public Date getEndDate() {
return this.endDate;
}
public void setEndDate(Date endDate) {
this.endDate = endDate;
}
public String getOwner() {
return this.owner;
}
public void setOwner(String owner) {
this.owner = owner;
}
public String getOwnerName() {
return this.ownerName;
}
public void setOwnerName(String ownerName) {
this.ownerName = ownerName;
}
public String getPm() {
return this.pm;
}
public void setPm(String pm) {
this.pm = pm;
}
public String getPmName() {
return this.pmName;
}
public void setPmName(String pmName) {
this.pmName = pmName;
}
public String getPrEmpId() {
return this.prEmpId;
}
public void setPrEmpId(String prEmpId) {
this.prEmpId = prEmpId;
}
public String getPrEmpName() {
return this.prEmpName;
}
public void setPrEmpName(String prEmpName) {
this.prEmpName = prEmpName;
}
public String getProjectCode() {
return this.projectCode;
}
public void setProjectCode(String projectCode) {
this.projectCode = projectCode;
}
public String getProjectDetailUrl() {
return this.projectDetailUrl;
}
public void setProjectDetailUrl(String projectDetailUrl) {
this.projectDetailUrl = projectDetailUrl;
}
public String getProjectName() {
return this.projectName;
}
public void setProjectName(String projectName) {
this.projectName = projectName;
}
public String getProjectPay() {
return this.projectPay;
}
public void setProjectPay(String projectPay) {
this.projectPay = projectPay;
}
public List<ProjectTimeTable> getProjectTimeSheet() {
return this.projectTimeSheet;
}
public void setProjectTimeSheet(List<ProjectTimeTable> projectTimeSheet) {
this.projectTimeSheet = projectTimeSheet;
}
public String getProjectType() {
return this.projectType;
}
public void setProjectType(String projectType) {
this.projectType = projectType;
}
public List<Workload> getProjectWorkload() {
return this.projectWorkload;
}
public void setProjectWorkload(List<Workload> projectWorkload) {
this.projectWorkload = projectWorkload;
}
public String getServiceLocation() {
return this.serviceLocation;
}
public void setServiceLocation(String serviceLocation) {
this.serviceLocation = serviceLocation;
}
public String getSettlementFormulaCode() {
return this.settlementFormulaCode;
}
public void setSettlementFormulaCode(String settlementFormulaCode) {
this.settlementFormulaCode = settlementFormulaCode;
}
public String getSettlementFormulaName() {
return this.settlementFormulaName;
}
public void setSettlementFormulaName(String settlementFormulaName) {
this.settlementFormulaName = settlementFormulaName;
}
public String getSlaViewInfo() {
return this.slaViewInfo;
}
public void setSlaViewInfo(String slaViewInfo) {
this.slaViewInfo = slaViewInfo;
}
public Date getStartDate() {
return this.startDate;
}
public void setStartDate(Date startDate) {
this.startDate = startDate;
}
public String getTotalAmount() {
return this.totalAmount;
}
public void setTotalAmount(String totalAmount) {
this.totalAmount = totalAmount;
}
public String getUsageCode() {
return this.usageCode;
}
public void setUsageCode(String usageCode) {
this.usageCode = usageCode;
}
}
| 3,257 |
522 | <gh_stars>100-1000
import timeit
import math
def power(n,c):
"""return pi*2**n"""
return math.pi*c
for p in range(0,256):
c = str(2**p)
cmd = 'power(' + str(p) + ',' + c + ')'
print (p, timeit.timeit(cmd, number=10000, setup="from __main__ import power"))
| 127 |
2,728 | <gh_stars>1000+
# coding=utf-8
# --------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for
# license information.
# --------------------------------------------------------------------------
{%- for mod_api_version in default_models %}
from .{{ mod_api_version }}.models import *
{%- endfor %}
| 94 |
14,668 | // Copyright (c) 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 CHROMEOS_DBUS_HERMES_HERMES_CLIENTS_H_
#define CHROMEOS_DBUS_HERMES_HERMES_CLIENTS_H_
#include "base/component_export.h"
namespace dbus {
class Bus;
}
namespace chromeos {
namespace hermes_clients {
// Initializes all Hermes dbus clients in the correct order.
COMPONENT_EXPORT(HERMES_CLIENT) void Initialize(dbus::Bus* system_bus);
// Initializes fake implementations of all Hermes dbus clients.
COMPONENT_EXPORT(HERMES_CLIENT) void InitializeFakes();
// Shutdown all Hermes dbus clients.
COMPONENT_EXPORT(HERMES_CLIENT) void Shutdown();
} // namespace hermes_clients
} // namespace chromeos
// TODO(https://crbug.com/1164001): remove when moved to ash.
namespace ash {
namespace hermes_clients {
using ::chromeos::hermes_clients::Initialize;
using ::chromeos::hermes_clients::Shutdown;
} // namespace hermes_clients
} // namespace ash
#endif // CHROMEOS_DBUS_HERMES_HERMES_CLIENTS_H_
| 376 |
852 | #ifndef RecoLocalCalo_HGCalRecProducers_ComputeClusterTime_h
#define RecoLocalCalo_HGCalRecProducers_ComputeClusterTime_h
// user include files
#include <algorithm>
#include <cmath>
#include <numeric>
#include <vector>
#include <string>
// functions to select the hits to compute the time of a given cluster
// start with the only hits with timing information
// average among the hits contained in the chosen time interval
// weighted average wrt resolution or preferred function
// N.B. time is corrected wrt vtx-calorimeter distance
// with straight line and light speed hypothesis
// for charged tracks or heavy particles (longer track length or beta < 1)
// need to correct the offset at analysis level
namespace hgcalsimclustertime {
class ComputeClusterTime {
public:
ComputeClusterTime(float Xmix, float Xmax, float Cterm, float Aterm);
ComputeClusterTime();
void setParameters(float Xmix, float Xmax, float Cterm, float Aterm);
//time resolution parametrization
float timeResolution(float xVal);
float getTimeError(std::string type, float xVal);
//time-interval based on that ~210ps wide and with the highest number of hits
//apply weights if provided => weighted mean
//return also error on the mean
//only effective with a minimum number of hits with time (3 from TDR time)
std::pair<float, float> fixSizeHighestDensity(std::vector<float>& time,
std::vector<float> weight = std::vector<float>(),
unsigned int minNhits = 3,
float deltaT = 0.210, /*time window in ns*/
float timeWidthBy = 0.5);
private:
float xMin_;
float xMax_;
float cTerm_;
float aTerm_;
};
} // namespace hgcalsimclustertime
#endif
| 723 |
2,151 | <gh_stars>1000+
// Copyright 2017 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 <linux/input.h>
#include <algorithm>
#include <bitset>
#include <cstdint>
#include <list>
#include <set>
#include <vector>
#include "base/macros.h"
#include "ui/events/ozone/evdev/event_device_info.h"
#include "ui/events/ozone/gamepad/generic_gamepad_mapping.h"
#include "ui/events/ozone/gamepad/webgamepad_constants.h"
namespace {
using ui::GamepadEventType;
class GenericGamepadMapper : public ui::GamepadMapper {
public:
GenericGamepadMapper(std::vector<ui::AbsMapEntry> axis_mapping,
std::vector<ui::KeyMapEntry> button_mapping) {
axis_mapping.swap(axis_mapping_);
button_mapping.swap(button_mapping_);
}
bool Map(uint16_t type,
uint16_t code,
ui::GamepadEventType* mapped_type,
uint16_t* mapped_code) const override {
if (type == EV_KEY) {
for (auto entry : button_mapping_) {
if (entry.evdev_code == code) {
*mapped_type = ui::GamepadEventType::BUTTON;
*mapped_code = entry.mapped_code;
return true;
}
}
return false;
}
if (type == EV_ABS) {
for (auto entry : axis_mapping_) {
if (entry.evdev_code == code) {
*mapped_type = entry.mapped_type;
*mapped_code = entry.mapped_code;
return true;
}
}
return false;
}
return false;
}
~GenericGamepadMapper() override {}
private:
std::vector<ui::AbsMapEntry> axis_mapping_;
std::vector<ui::KeyMapEntry> button_mapping_;
};
// This helper class will be used to build generic mapping.
class GamepadMapperBuilder {
public:
explicit GamepadMapperBuilder(const ui::EventDeviceInfo& devinfo)
: devinfo_(devinfo) {}
std::unique_ptr<ui::GamepadMapper> ToGamepadMapper() {
return std::make_unique<GenericGamepadMapper>(std::move(axis_mapping_),
std::move(button_mapping_));
}
void MapButton(uint16_t from_button, uint16_t mapped_button) {
if (!devinfo_.HasKeyEvent(from_button)) {
return;
}
DCHECK(!IfEvdevButtonMappedFrom(from_button));
DCHECK(!IfWebgamepadButtonMappedTo(mapped_button));
button_mapping_.push_back({from_button, mapped_button});
evdev_buttons_.set(from_button);
webgamepad_buttons_.set(mapped_button);
}
void MapAxisToButton(uint16_t from_axis, uint16_t mapped_button) {
if (!devinfo_.HasAbsEvent(from_axis)) {
return;
}
DCHECK(!IfEvdevAxisMappedFrom(from_axis));
evdev_axes_.set(from_axis);
axis_mapping_.push_back(TO_BTN(from_axis, mapped_button));
if (mapped_button == ui::kHAT_X) {
DCHECK(!IfWebgamepadButtonMappedTo(ui::WG_BUTTON_DPAD_LEFT));
DCHECK(!IfWebgamepadButtonMappedTo(ui::WG_BUTTON_DPAD_RIGHT));
webgamepad_buttons_.set(ui::WG_BUTTON_DPAD_LEFT);
webgamepad_buttons_.set(ui::WG_BUTTON_DPAD_RIGHT);
} else if (mapped_button == ui::kHAT_Y) {
DCHECK(!IfWebgamepadButtonMappedTo(ui::WG_BUTTON_DPAD_UP));
DCHECK(!IfWebgamepadButtonMappedTo(ui::WG_BUTTON_DPAD_DOWN));
webgamepad_buttons_.set(ui::WG_BUTTON_DPAD_UP);
webgamepad_buttons_.set(ui::WG_BUTTON_DPAD_DOWN);
} else {
DCHECK(!IfWebgamepadButtonMappedTo(mapped_button));
webgamepad_buttons_.set(mapped_button);
}
}
void MapAxisToAxis(uint16_t from_axis, uint16_t mapped_axis) {
if (!devinfo_.HasAbsEvent(from_axis)) {
return;
}
DCHECK(!IfEvdevAxisMappedFrom(from_axis));
DCHECK(!IfWebgamepadAxisMappedTo(mapped_axis));
axis_mapping_.push_back(TO_ABS(from_axis, mapped_axis));
evdev_axes_.set(from_axis);
webgamepad_axes_.set(mapped_axis);
}
void MapButtonLikeJoydev() {
uint16_t next_unmapped_button = 0;
// In linux kernel, joydev.c map evdev events in the same way.
for (int i = BTN_JOYSTICK - BTN_MISC; i < KEY_MAX - BTN_MISC + 1; i++) {
int code = i + BTN_MISC;
if (devinfo_.HasKeyEvent(code) && !IfEvdevButtonMappedFrom(code) &&
FindNextUnmappedCode(webgamepad_buttons_, &next_unmapped_button)) {
MapButton(code, next_unmapped_button);
}
}
for (int i = 0; i < BTN_JOYSTICK - BTN_MISC; i++) {
int code = i + BTN_MISC;
if (devinfo_.HasKeyEvent(code) && !IfEvdevButtonMappedFrom(code) &&
FindNextUnmappedCode(webgamepad_buttons_, &next_unmapped_button)) {
MapButton(code, next_unmapped_button);
}
}
}
void MapAxisLikeJoydev() {
uint16_t next_unmapped_axis = 0;
for (int code = 0; code < ABS_CNT; ++code) {
if (devinfo_.HasAbsEvent(code) && !IfEvdevAxisMappedFrom(code) &&
FindNextUnmappedCode(webgamepad_axes_, &next_unmapped_axis)) {
MapAxisToAxis(code, next_unmapped_axis);
}
}
}
private:
// This function helps to find the next unmapped button or axis. Code is the
// last unmapped code and will be the next unmapped code when the function
// returns.
template <typename T>
bool FindNextUnmappedCode(const T& bitset, uint16_t* code) {
for (uint16_t i = *code; i < bitset.size(); ++i) {
if (!bitset.test(i)) {
*code = i;
return true;
}
}
return false;
}
bool IfEvdevButtonMappedFrom(uint16_t code) {
DCHECK_LT(code, KEY_CNT);
return evdev_buttons_.test(code);
}
bool IfEvdevAxisMappedFrom(uint16_t code) {
DCHECK_LT(code, ABS_CNT);
return evdev_axes_.test(code);
}
bool IfWebgamepadButtonMappedTo(uint16_t code) {
DCHECK_LT(code, ui::WG_BUTTON_COUNT);
return webgamepad_buttons_.test(code);
}
bool IfWebgamepadAxisMappedTo(uint16_t code) {
DCHECK_LT(code, ui::WG_ABS_COUNT);
return webgamepad_axes_.test(code);
}
const ui::EventDeviceInfo& devinfo_;
// Mapped webgamepad buttons and axes will be marked as true.
std::bitset<ui::WG_BUTTON_COUNT> webgamepad_buttons_;
std::bitset<ui::WG_ABS_COUNT> webgamepad_axes_;
// Evdev buttons and axes that are already mapped will be marked as true.
std::bitset<KEY_CNT> evdev_buttons_;
std::bitset<ABS_CNT> evdev_axes_;
// Generated Mapping.
std::vector<ui::AbsMapEntry> axis_mapping_;
std::vector<ui::KeyMapEntry> button_mapping_;
};
void MapSpecialButtons(GamepadMapperBuilder* builder) {
// Map mode seperately.
builder->MapButton(BTN_MODE, ui::WG_BUTTON_MODE);
// Take care of ADT style back and start.
builder->MapButton(KEY_BACK, ui::WG_BUTTON_SELECT);
builder->MapButton(KEY_HOMEPAGE, ui::WG_BUTTON_START);
}
void MapSpecialAxes(const ui::EventDeviceInfo& devinfo,
GamepadMapperBuilder* builder) {
// HAT0X and HAT0Y always map to DPAD.
builder->MapAxisToButton(ABS_HAT0X, ui::kHAT_X);
builder->MapAxisToButton(ABS_HAT0Y, ui::kHAT_Y);
// When ABS_BRAKE and ABS_GAS supported at the same time, they are mapped to
// l-trigger and r-trigger.
// Otherwise, when x,y,z,rx,ry,rz are all supported, z and rz are mapped to
// triggers (As XInput gamepad mapper).
if (devinfo.HasAbsEvent(ABS_BRAKE) && devinfo.HasAbsEvent(ABS_GAS)) {
builder->MapAxisToButton(ABS_BRAKE, ui::WG_BUTTON_LT);
builder->MapAxisToButton(ABS_GAS, ui::WG_BUTTON_RT);
} else if (devinfo.HasAbsEvent(ABS_X) && devinfo.HasAbsEvent(ABS_Y) &&
devinfo.HasAbsEvent(ABS_Z) && devinfo.HasAbsEvent(ABS_RX) &&
devinfo.HasAbsEvent(ABS_RY) && devinfo.HasAbsEvent(ABS_RZ)) {
builder->MapAxisToButton(ABS_Z, ui::WG_BUTTON_LT);
builder->MapAxisToButton(ABS_RZ, ui::WG_BUTTON_RT);
}
}
} // namespace
namespace ui {
std::unique_ptr<GamepadMapper> BuildGenericGamepadMapper(
const EventDeviceInfo& info) {
GamepadMapperBuilder builder(info);
// Must map axes first as axis might be mapped to button and occupy some
// webgamepad button slots.
MapSpecialAxes(info, &builder);
builder.MapAxisLikeJoydev();
MapSpecialButtons(&builder);
builder.MapButtonLikeJoydev();
return builder.ToGamepadMapper();
}
} // namespace ui
| 3,512 |
1,223 | # Copyright 2016 Nidium Inc. All rights reserved.
# Use of this source code is governed by a MIT license
# that can be found in the LICENSE file.
from dokumentor import *
NamespaceDoc("DebuggerCompartment", """For debugging purpose, Nidium use the <a href="https://developer.mozilla.org/en-US/docs/Tools/Debugger-API/Debugger">Debugger of SpiderMonkey</a>.
As the Debugger is not residing in the same <a href="https://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey/Compartmentshttps://developer.mozilla.org/en-US/docs/Mozilla/Projects/SpiderMonkey/Compartments">compartment</a> you need to use a DebuggerCompartment to initialize and execute code inside the Debugger""",
[ SeeDoc( "DebuggerCompartment.run" ) ],
NO_Examples,
products=["Frontend", "Server"]
)
ConstructorDoc("DebuggerCompartment", "Create a new instance of a <a href=\"https://developer.mozilla.org/en-US/docs/Tools/Debugger-API/Debugger\">Debugger</a> inside a new compartment",
sees=[ SeeDoc( "DebuggerCompartment.run" ) ],
returns=ReturnDoc( "Return a DebuggerCompartment", "DebuggerCompartment" )
)
FunctionDoc("DebuggerCompartment.run", """Run a function inside the Debugger compartment.
Important note : You cannot share variables between compartments as you usually do in JS. Each compartment is like a sandbox. If you want to have access to variables from the main compartment, you can pass them as an arguments to the run() method. Nidium will wrap your variables to make them accessible inside the Debugger compartment.
The compartment of the debugger only expose the console API. None of Nidium APIs will be available.""",
NO_Sees,
[ExampleDoc( """var dbg = new DebuggerCompartment();
dbg.run(function(dbg) {
// dbg is the Debugger instance
dbg.onEnterFrame = function(frame) {
console.log("Entering inside function " + (frame.callee && frame.callee.displayName ? frame.callee.displayName : "anonymous"));
}
});
// The main compartment is not shared with the Debugger.
// You cannot use variables from the parent scope.
var foo = "bar";
dbg.run(function(dbg) {
try {
console.log(foo); // undefined
} catch ( e ) {
console.log("as expected, 'foo' is undefined");
}
});
// However you can explicitly pass a variable into the Debugger compartment
var foo = "bar";
var obj = {"foo": "bar"};
dbg.run(function(dbg, wrappedFoo, wrappedObj) {
console.log(wrappedFoo); // bar
console.log(JSON.stringify(wrappedObj)); // {"foo": "bar"}
}, foo, obj);""" )],
IS_Static, IS_Public, IS_Fast,
[ ParamDoc("context", "Debugger compartment context", "DebuggerCompartment", NO_Default, IS_Obligated ),
CallbackDoc( 'callback', 'function to be executed in the Debugger compartment',
[ParamDoc("debugger", "Debugger instance", "DebuggerCompartment", NO_Default, IS_Obligated),
ParamDoc("params", "arguments", "[any]", NO_Default, IS_Optional)]),
ParamDoc( 'arg', 'Optional variable to wrap into the Debugger compartment. The wrapped variable is passed as an argument of the callback', 'any', 0, IS_Optional )
],
ReturnDoc( "The value returned from the callback function", "any" )
)
| 1,011 |
4,047 | <reponame>kira78/meson
int rOne(void); | 18 |
2,661 | #ifndef SPACER_H
#define SPACER_H
#include <Qt/qlayoutitem.h>
class spacer : public QSpacerItem
{
public:
spacer() = default;
void setObjectName(const QString& oName) {}
void setOrientation(const Qt::Orientation& orient) {}
void setSizeType(const QSizePolicy& policy) {}
void setSizeHint(const QSize& sizeHint) {}
};
#endif // SPACER_H
| 143 |
560 | #!/usr/bin/env python
"""Tests for `pytorch_tabular` package."""
import pytest
import math
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import QuantileTransformer, PowerTransformer
import numpy as np
from pytorch_tabular.config import DataConfig, OptimizerConfig, TrainerConfig
from pytorch_tabular.models import CategoryEmbeddingModelConfig
from pytorch_tabular import TabularModel
from pytorch_tabular.tabular_datamodule import TabularDatamodule
@pytest.mark.parametrize("multi_target", [True, False])
@pytest.mark.parametrize(
"continuous_cols",
[
[
"AveRooms",
"AveBedrms",
"Population",
"AveOccup",
"Latitude",
"Longitude",
],
[],
],
)
@pytest.mark.parametrize("categorical_cols", [["HouseAgeBin"], []])
@pytest.mark.parametrize("continuous_feature_transform", [None, "yeo-johnson"])
@pytest.mark.parametrize("normalize_continuous_features", [True, False])
@pytest.mark.parametrize(
"target_transform",
[
None,
PowerTransformer(method="yeo-johnson"),
(lambda x: x ** 2, lambda x: np.sqrt(x)),
],
)
@pytest.mark.parametrize("validation_split", [None, 0.3])
@pytest.mark.parametrize("embedding_dims", [None, [(5, 1)]])
def test_dataloader(
regression_data,
validation_split,
multi_target,
continuous_cols,
categorical_cols,
continuous_feature_transform,
normalize_continuous_features,
target_transform,
embedding_dims,
):
(train, test, target) = regression_data
train, valid = train_test_split(train, random_state=42)
if len(continuous_cols) + len(categorical_cols) == 0:
assert True
else:
data_config = DataConfig(
target=target + ["MedInc"] if multi_target else target,
continuous_cols=continuous_cols,
categorical_cols=categorical_cols,
continuous_feature_transform=continuous_feature_transform,
normalize_continuous_features=normalize_continuous_features,
validation_split=validation_split,
)
model_config_params = dict(task="regression", embedding_dims=embedding_dims)
model_config = CategoryEmbeddingModelConfig(**model_config_params)
trainer_config = TrainerConfig(
max_epochs=1, checkpoints=None, early_stopping=None
)
optimizer_config = OptimizerConfig()
tabular_model = TabularModel(
data_config=data_config,
model_config=model_config,
optimizer_config=optimizer_config,
trainer_config=trainer_config,
)
config = tabular_model.config
datamodule = TabularDatamodule(
train=train,
validation=valid,
config=config,
test=test,
target_transform=target_transform,
)
datamodule.prepare_data()
datamodule.setup("fit")
config = datamodule.config
if len(categorical_cols) > 0:
assert config.categorical_cardinality[0] == 5
if embedding_dims is None:
assert config.embedding_dims[0][-1] == 3
else:
assert config.embedding_dims[0][-1] == embedding_dims[0][-1]
if normalize_continuous_features and len(continuous_cols) > 0:
assert round(datamodule.train[config.continuous_cols[0]].mean()) == 0
assert round(datamodule.train[config.continuous_cols[0]].std()) == 1
# assert round(datamodule.validation[config.continuous_cols[0]].mean()) == 0
# assert round(datamodule.validation[config.continuous_cols[0]].std()) == 1
val_loader = datamodule.val_dataloader()
_val_loader = datamodule.prepare_inference_dataloader(valid)
chk_1 = next(iter(val_loader))["continuous"]
chk_2 = next(iter(_val_loader))["continuous"]
assert np.not_equal(chk_1, chk_2).sum().item() == 0
@pytest.mark.parametrize(
"freq",
["H", "D", "T", "S"],
)
def test_date_encoding(timeseries_data, freq):
(train, test, target) = timeseries_data
train, valid = train_test_split(train, random_state=42)
data_config = DataConfig(
target=target + ["Occupancy"],
continuous_cols=["Temperature", "Humidity", "Light", "CO2", "HumidityRatio"],
categorical_cols=[],
date_columns=[("date", freq)],
encode_date_columns=True,
)
model_config_params = dict(task="regression")
model_config = CategoryEmbeddingModelConfig(**model_config_params)
trainer_config = TrainerConfig(max_epochs=1, checkpoints=None, early_stopping=None)
optimizer_config = OptimizerConfig()
tabular_model = TabularModel(
data_config=data_config,
model_config=model_config,
optimizer_config=optimizer_config,
trainer_config=trainer_config,
)
config = tabular_model.config
datamodule = TabularDatamodule(
train=train,
validation=valid,
config=config,
test=test,
)
datamodule.prepare_data()
if freq != "S":
datamodule.setup("fit")
config = datamodule.config
if freq == "H":
assert "_Hour" in datamodule.train.columns
elif freq == "D":
assert "_Dayofyear" in datamodule.train.columns
elif freq == "T":
assert "_Minute" in datamodule.train.columns
elif freq == "S":
try:
datamodule.setup("fit")
assert False
except RuntimeError:
assert True
# from io import BytesIO
# from urllib.request import urlopen
# from zipfile import ZipFile
# import numpy as np
# import pandas as pd
# import pytest
# from sklearn.datasets import fetch_california_housing, fetch_covtype
# def load_timeseries_data():
# url = "https://archive.ics.uci.edu/ml/machine-learning-databases/00357/occupancy_data.zip"
# resp = urlopen(url)
# zipfile = ZipFile(BytesIO(resp.read()))
# train = pd.read_csv(zipfile.open("datatraining.txt"), sep=",")
# val = pd.read_csv(zipfile.open("datatest.txt"), sep=",")
# test = pd.read_csv(zipfile.open("datatest2.txt"), sep=",")
# return (pd.concat([train, val], sort=False), test, ["Occupancy"])
# def load_regression_data():
# dataset = fetch_california_housing(data_home="data", as_frame=True)
# df = dataset.frame.sample(5000)
# df["HouseAgeBin"] = pd.qcut(df["HouseAge"], q=4)
# df["HouseAgeBin"] = "age_" + df.HouseAgeBin.cat.codes.astype(str)
# test_idx = df.sample(int(0.2 * len(df)), random_state=42).index
# test = df[df.index.isin(test_idx)]
# train = df[~df.index.isin(test_idx)]
# return (train, test, dataset.target_names)
# test_dataloader(
# load_regression_data(),
# validation_split=None,
# multi_target=False,
# continuous_cols=[
# "AveRooms",
# "AveBedrms",
# "Population",
# "AveOccup",
# "Latitude",
# "Longitude",
# ],
# categorical_cols=[],
# continuous_feature_transform="yeo-johnson",
# normalize_continuous_features=False,
# target_transform=None,
# embedding_dims=None
# )
# test_date_encoding(load_timeseries_data(), "S")
# ["H","D", "T", "S"], | 3,264 |
1,641 | <filename>eth/vm/forks/london/state.py
from typing import Type
from eth_hash.auto import keccak
from eth_utils import (
encode_hex,
)
from eth.abc import (
AccountDatabaseAPI,
ComputationAPI,
MessageAPI,
SignedTransactionAPI,
StateAPI,
TransactionContextAPI,
TransactionExecutorAPI,
)
from eth.constants import (
CREATE_CONTRACT_ADDRESS,
)
from eth.db.account import (
AccountDB
)
from eth.vm.message import (
Message,
)
from eth.vm.forks.berlin.state import (
BerlinState,
BerlinTransactionExecutor,
)
from eth._utils.address import (
generate_contract_address,
)
from .computation import LondonComputation
from .validation import validate_london_normalized_transaction
from .constants import EIP3529_MAX_REFUND_QUOTIENT
class LondonTransactionExecutor(BerlinTransactionExecutor):
def build_evm_message(self, transaction: SignedTransactionAPI) -> MessageAPI:
# Use vm_state.get_gas_price instead of transaction_context.gas_price so
# that we can run get_transaction_result (aka~ eth_call) and estimate_gas.
# Both work better if the GASPRICE opcode returns the original real price,
# but the sender's balance doesn't actually deduct the gas. This get_gas_price()
# will return 0 for eth_call, but transaction_context.gas_price will return
# the same value as the GASPRICE opcode.
gas_fee = transaction.gas * self.vm_state.get_gas_price(transaction)
# Buy Gas
self.vm_state.delta_balance(transaction.sender, -1 * gas_fee)
# Increment Nonce
self.vm_state.increment_nonce(transaction.sender)
# Setup VM Message
message_gas = transaction.gas - transaction.intrinsic_gas
if transaction.to == CREATE_CONTRACT_ADDRESS:
contract_address = generate_contract_address(
transaction.sender,
self.vm_state.get_nonce(transaction.sender) - 1,
)
data = b''
code = transaction.data
else:
contract_address = None
data = transaction.data
code = self.vm_state.get_code(transaction.to)
self.vm_state.logger.debug2(
(
"TRANSACTION: %r; sender: %s | to: %s | data-hash: %s"
),
transaction,
encode_hex(transaction.sender),
encode_hex(transaction.to),
encode_hex(keccak(transaction.data)),
)
message = Message(
gas=message_gas,
to=transaction.to,
sender=transaction.sender,
value=transaction.value,
data=data,
code=code,
create_address=contract_address,
)
return message
@classmethod
def calculate_gas_refund(cls,
computation: ComputationAPI,
gas_used: int) -> int:
# Self destruct refunds were added in Frontier
# London removes them in EIP-3529
gas_refunded = computation.get_gas_refund()
return min(gas_refunded, gas_used // EIP3529_MAX_REFUND_QUOTIENT)
class LondonState(BerlinState):
account_db_class: Type[AccountDatabaseAPI] = AccountDB
computation_class = LondonComputation
transaction_executor_class: Type[TransactionExecutorAPI] = LondonTransactionExecutor
def get_tip(self, transaction: SignedTransactionAPI) -> int:
return min(
transaction.max_fee_per_gas - self.execution_context.base_fee_per_gas,
transaction.max_priority_fee_per_gas,
)
def get_gas_price(self, transaction: SignedTransactionAPI) -> int:
return min(
transaction.max_fee_per_gas,
transaction.max_priority_fee_per_gas + self.execution_context.base_fee_per_gas,
)
def validate_transaction(
self,
transaction: SignedTransactionAPI
) -> None:
validate_london_normalized_transaction(
state=self,
transaction=transaction,
)
def get_transaction_context(self: StateAPI,
transaction: SignedTransactionAPI) -> TransactionContextAPI:
"""
London-specific transaction context creation,
where gas_price includes the block base fee
"""
effective_gas_price = min(
transaction.max_priority_fee_per_gas + self.execution_context.base_fee_per_gas,
transaction.max_fee_per_gas,
)
# See how this reduces in a pre-1559 transaction:
# 1. effective_gas_price = min(
# transaction.gas_price + self.execution_context.base_fee_per_gas,
# transaction.gas_price,
# )
# base_fee_per_gas is non-negative, so:
# 2. effective_gas_price = transaction.gas_price
return self.get_transaction_context_class()(
gas_price=effective_gas_price,
origin=transaction.sender
)
@property
def base_fee(self: StateAPI) -> int:
return self.execution_context.base_fee_per_gas
| 2,214 |
3,138 | <gh_stars>1000+
# Lint as: python3
# Copyright 2021 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
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Tests for swap module."""
from absl.testing import parameterized
import numpy as np
import tensorflow.compat.v2 as tf
import tf_quant_finance as tff
from tensorflow.python.framework import test_util # pylint: disable=g-direct-tensorflow-import
@test_util.run_all_in_graph_and_eager_modes
class SwapTest(tf.test.TestCase, parameterized.TestCase):
@parameterized.named_parameters(
{
'testcase_name': 'NoBatch',
'notional': 10000,
'forward_prices': [110, 120, 140],
'spots': 100,
'dividends': [1, 1, 1],
'expected_pv': [1000.01, 909.1, 1666.675],
}, {
'testcase_name': 'WithBatch',
'notional': 10000,
'forward_prices': [[110, 120, 140], [210, 220, 240]],
'spots': [100, 200],
'dividends': [[1, 1, 1], [2, 2, 2]],
'expected_pv': [[1000.01, 909.1, 1666.675], [500.01, 476.2, 909.1]],
})
def test_equity_leg_cashflows(
self, notional, forward_prices, spots, dividends, expected_pv):
dtype = tf.float64
actual_pv = self.evaluate(
tff.rates.analytics.swap.equity_leg_cashflows(
forward_prices=forward_prices,
spots=spots,
notional=notional,
dividends=dividends,
dtype=dtype))
np.testing.assert_allclose(expected_pv, actual_pv)
@parameterized.named_parameters(
{
'testcase_name': 'NoBatch',
'notional': 1000,
'coupon_rates': 0.1,
'daycount_fractions': [1, 1, 1],
'expected_pv': [100.0, 100.0, 100.0],
}, {
'testcase_name': 'WithBatch',
'notional': 1000,
'coupon_rates': [[0.1, 0.1, 0.1], [0.02, 0.12, 0.14]],
'daycount_fractions': [[1, 1, 1], [1, 2, 1]],
'expected_pv': [[100.0, 100.0, 100.0], [20.0, 240.0, 140.0]],
})
def test_rate_leg_cashflows(
self, notional, coupon_rates, daycount_fractions, expected_pv):
dtype = tf.float64
actual_pv = self.evaluate(
tff.rates.analytics.swap.rate_leg_cashflows(
coupon_rates=coupon_rates,
daycount_fractions=daycount_fractions,
notional=notional,
dtype=dtype))
np.testing.assert_allclose(expected_pv, actual_pv)
@parameterized.named_parameters(
{
'testcase_name': 'NoBatch',
'pay_leg_cashflows': [100, 100, 100],
'receive_leg_cashflows': [200, 250, 300, 300],
'pay_leg_discount_factors': [0.95, 0.9, 0.8],
'receive_leg_discount_factors': [0.95, 0.9, 0.8, 0.75],
'expected_pv': 615.0,
}, {
'testcase_name': 'WithBatch',
'pay_leg_cashflows': [[100, 100, 100], [200, 250, 300]],
'receive_leg_cashflows': [[200, 250, 300, 300], [100, 100, 100, 100]],
'pay_leg_discount_factors': [[0.95, 0.9, 0.8], [0.9, 0.85, 0.8]],
'receive_leg_discount_factors': [[0.95, 0.9, 0.8, 0.75],
[0.9, 0.85, 0.8, 0.75]],
'expected_pv': [615.0, -302.5],
})
def test_swap_price(
self, pay_leg_cashflows, receive_leg_cashflows,
pay_leg_discount_factors, receive_leg_discount_factors, expected_pv):
dtype = tf.float64
actual_pv = self.evaluate(
tff.rates.analytics.swap.swap_price(
pay_leg_cashflows=pay_leg_cashflows,
receive_leg_cashflows=receive_leg_cashflows,
pay_leg_discount_factors=pay_leg_discount_factors,
receive_leg_discount_factors=receive_leg_discount_factors,
dtype=dtype))
np.testing.assert_allclose(expected_pv, actual_pv)
@parameterized.named_parameters(
{
'testcase_name': 'NoBatch',
'pay_leg_coupon_rates': 0.1,
'receive_leg_coupon_rates': [0.1, 0.2, 0.05],
'notional': 1000,
'pay_leg_daycount_fractions': 0.5,
'receive_leg_daycount_fractions': 0.5,
'discount_factors': [0.95, 0.9, 0.85],
'expected_pv': 23.75,
}, {
'testcase_name': 'WithBatch',
'pay_leg_coupon_rates': [[0.1], [0.15]],
'receive_leg_coupon_rates': [[0.1, 0.2, 0.05], [0.1, 0.05, 0.2]],
'notional': 1000,
'pay_leg_daycount_fractions': 0.5,
'receive_leg_daycount_fractions': [[0.5, 0.5, 0.5], [0.4, 0.5, 0.6]],
'discount_factors': [[0.95, 0.9, 0.85], [0.98, 0.92, 0.88]],
'expected_pv': [23.75, -40.7],
})
def test_ir_swap_price(
self, pay_leg_coupon_rates, receive_leg_coupon_rates, notional,
pay_leg_daycount_fractions, receive_leg_daycount_fractions,
discount_factors, expected_pv):
dtype = tf.float64
actual_pv = self.evaluate(
tff.rates.analytics.swap.ir_swap_price(
pay_leg_coupon_rates=pay_leg_coupon_rates,
receive_leg_coupon_rates=receive_leg_coupon_rates,
pay_leg_notional=notional,
receive_leg_notional=notional,
pay_leg_daycount_fractions=pay_leg_daycount_fractions,
receive_leg_daycount_fractions=receive_leg_daycount_fractions,
pay_leg_discount_factors=discount_factors,
receive_leg_discount_factors=discount_factors,
dtype=dtype))
np.testing.assert_allclose(expected_pv, actual_pv)
@parameterized.named_parameters(
{
'testcase_name': 'NoBatch',
'floating_leg_start_times': [0.5, 1.0, 1.5],
'floating_leg_end_times': [1.0, 1.5, 2.0],
'fixed_leg_payment_times': [1.0, 1.5, 2.0],
'fixed_leg_daycount_fractions': [0.5, 0.5, 0.5],
'reference_rate_fn': lambda x: 0.01,
'expected_values': [0.010025041718802, 1.477680223329493],
}, {
'testcase_name':
'WithBatch',
'floating_leg_start_times': [[0.5, 1.0, 1.5], [0.5, 1.0, 1.5]],
'floating_leg_end_times': [[1.0, 1.5, 2.0], [1.0, 1.5, 2.0]],
'fixed_leg_payment_times': [[1.0, 1.5, 2.0], [1.0, 1.5, 2.0]],
'fixed_leg_daycount_fractions': [[0.5, 0.5, 0.5], [0.5, 0.5, 0.5]],
'reference_rate_fn':
lambda x: 0.01,
'expected_values': [[0.010025041718802, 0.010025041718802],
[1.477680223329493, 1.477680223329493]],
})
def test_ir_swap_par_rate_and_annuity(self, floating_leg_start_times,
floating_leg_end_times,
fixed_leg_payment_times,
fixed_leg_daycount_fractions,
reference_rate_fn, expected_values):
dtype = tf.float64
actual_parrate, actual_annuity = self.evaluate(
tff.rates.analytics.swap.ir_swap_par_rate_and_annuity(
floating_leg_start_times,
floating_leg_end_times,
fixed_leg_payment_times,
fixed_leg_daycount_fractions,
reference_rate_fn,
dtype=dtype))
np.testing.assert_allclose(expected_values[0], actual_parrate)
np.testing.assert_allclose(expected_values[1], actual_annuity)
@parameterized.named_parameters(
{
'testcase_name': 'NoBatch',
'rate_leg_coupon_rates': [0.1, 0.2, 0.05],
'forward_prices': [110, 120, 140, 150],
'spots': 100,
'notional': 1000,
'daycount_fractions': [0.5, 0.5, 0.5],
'rate_leg_discount_factors': [0.95, 0.9, 0.85],
'equity_leg_discount_factors': [0.95, 0.9, 0.85, 0.8],
'is_equity_receiver': None,
'expected_pv': 216.87770563,
}, {
'testcase_name': 'WithBatch',
'rate_leg_coupon_rates': [[0.1, 0.2, 0.05], [0.1, 0.05, 0.2]],
'forward_prices': [[110, 120, 140, 150], [210, 220, 240, 0]],
'spots': [100, 200],
'notional': 1000,
'daycount_fractions': [[0.5, 0.5, 0.5], [0.4, 0.5, 0.6]],
'rate_leg_discount_factors': [[0.95, 0.9, 0.85], [0.98, 0.92, 0.88]],
'equity_leg_discount_factors': [[0.95, 0.9, 0.85, 0.8],
[0.98, 0.92, 0.88, 0.0]],
'is_equity_receiver': [True, False],
'expected_pv': [216.87770563, -5.00952381],
})
def test_equity_swap_price(
self, rate_leg_coupon_rates, forward_prices, spots, notional,
daycount_fractions,
rate_leg_discount_factors, equity_leg_discount_factors,
is_equity_receiver, expected_pv):
dtype = tf.float64
actual_pv = self.evaluate(
tff.rates.analytics.swap.equity_swap_price(
rate_leg_coupon_rates=rate_leg_coupon_rates,
equity_leg_forward_prices=forward_prices,
equity_leg_spots=spots,
rate_leg_notional=notional,
equity_leg_notional=notional,
rate_leg_daycount_fractions=daycount_fractions,
rate_leg_discount_factors=rate_leg_discount_factors,
equity_leg_discount_factors=equity_leg_discount_factors,
is_equity_receiver=is_equity_receiver,
dtype=dtype))
np.testing.assert_allclose(expected_pv, actual_pv)
if __name__ == '__main__':
tf.test.main()
| 5,124 |
1,671 | <filename>documentation/manpages/tool/man-pandoc-filter.py
#!/usr/bin/env python3
#
# Copyright (c) .NET Foundation and contributors. All rights reserved.
# Licensed under the MIT license. See LICENSE file in the project root for full license information.
#
import copy
from pandocfilters import toJSONFilters, Para, Str, Header, Space
def fail_on_includes(key, value, format, meta):
if key == 'Para' and value[0]['c'] == '[!INCLUDE':
assert False, 'Found an unexpected [!INCLUDE'
def promote_and_capitalize_sections(key, value, format, meta):
if key == 'Header':
header_contents = value[2]
header_text = ' '.join([ x['c'] for x in header_contents if x['t'] == 'Str']).lower()
if header_text in ['name', 'synopsis', 'description', 'options', 'examples', 'environment variables']:
# capitalize
for element in header_contents:
if element['t'] == 'Str':
element['c'] = element['c'].upper()
# promote
value = Header(1, value[1], header_contents)
return value
return None
def demote_net_core_1_2(key, value, format, meta):
if key == 'Header':
header_id = value[1][0]
if header_id.startswith('net-core-'):
value = Header(2, value[1], value[2][0]['c'][1])
return value
return None
def main():
toJSONFilters([
fail_on_includes,
promote_and_capitalize_sections,
demote_net_core_1_2,
])
if __name__ == '__main__':
main()
| 648 |
1,998 | # Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License.
import json
import os.path
from typing import List
from botbuilder.core import MessageFactory, TurnContext
from botbuilder.schema import Attachment, ChannelAccount
from helpers import DialogHelper
from .dialog_bot import DialogBot
class DialogAndWelcomeBot(DialogBot):
async def on_members_added_activity(
self, members_added: List[ChannelAccount], turn_context: TurnContext
):
for member in members_added:
# Greet anyone that was not the target (recipient) of this message.
# To learn more about Adaptive Cards, see https://aka.ms/msbot-adaptivecards for more details.
if member.id != turn_context.activity.recipient.id:
welcome_card = self.create_adaptive_card_attachment()
response = MessageFactory.attachment(welcome_card)
await turn_context.send_activity(response)
await DialogHelper.run_dialog(
self.dialog,
turn_context,
self.conversation_state.create_property("DialogState"),
)
# Load attachment from file.
def create_adaptive_card_attachment(self):
relative_path = os.path.abspath(os.path.dirname(__file__))
path = os.path.join(relative_path, "../cards/welcomeCard.json")
with open(path) as card_file:
card = json.load(card_file)
return Attachment(
content_type="application/vnd.microsoft.card.adaptive", content=card
)
| 641 |
8,865 | <gh_stars>1000+
#define PNG_USER_PRIVATEBUILD "Skia build; no MNG features"
#define PNG_USER_DLLFNAME_POSTFIX "Sk"
#define PNG_NO_MNG_FEATURES
#define PNG_NO_READ_GAMMA
| 71 |
4,812 | //===- llvm/CodeGen/LiveRegUnits.h - Register Unit Set ----------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
/// \file
/// A set of register units. It is intended for register liveness tracking.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CODEGEN_LIVEREGUNITS_H
#define LLVM_CODEGEN_LIVEREGUNITS_H
#include "llvm/ADT/BitVector.h"
#include "llvm/CodeGen/MachineRegisterInfo.h"
#include "llvm/CodeGen/TargetRegisterInfo.h"
#include "llvm/MC/LaneBitmask.h"
#include "llvm/MC/MCRegisterInfo.h"
#include <cstdint>
namespace llvm {
class MachineInstr;
class MachineBasicBlock;
/// A set of register units used to track register liveness.
class LiveRegUnits {
const TargetRegisterInfo *TRI = nullptr;
BitVector Units;
public:
/// Constructs a new empty LiveRegUnits set.
LiveRegUnits() = default;
/// Constructs and initialize an empty LiveRegUnits set.
LiveRegUnits(const TargetRegisterInfo &TRI) {
init(TRI);
}
/// For a machine instruction \p MI, adds all register units used in
/// \p UsedRegUnits and defined or clobbered in \p ModifiedRegUnits. This is
/// useful when walking over a range of instructions to track registers
/// used or defined seperately.
static void accumulateUsedDefed(const MachineInstr &MI,
LiveRegUnits &ModifiedRegUnits,
LiveRegUnits &UsedRegUnits,
const TargetRegisterInfo *TRI) {
for (ConstMIBundleOperands O(MI); O.isValid(); ++O) {
if (O->isRegMask())
ModifiedRegUnits.addRegsInMask(O->getRegMask());
if (!O->isReg())
continue;
Register Reg = O->getReg();
if (!Reg.isPhysical())
continue;
if (O->isDef()) {
// Some architectures (e.g. AArch64 XZR/WZR) have registers that are
// constant and may be used as destinations to indicate the generated
// value is discarded. No need to track such case as a def.
if (!TRI->isConstantPhysReg(Reg))
ModifiedRegUnits.addReg(Reg);
} else {
assert(O->isUse() && "Reg operand not a def and not a use");
UsedRegUnits.addReg(Reg);
}
}
return;
}
/// Initialize and clear the set.
void init(const TargetRegisterInfo &TRI) {
this->TRI = &TRI;
Units.reset();
Units.resize(TRI.getNumRegUnits());
}
/// Clears the set.
void clear() { Units.reset(); }
/// Returns true if the set is empty.
bool empty() const { return Units.none(); }
/// Adds register units covered by physical register \p Reg.
void addReg(MCPhysReg Reg) {
for (MCRegUnitIterator Unit(Reg, TRI); Unit.isValid(); ++Unit)
Units.set(*Unit);
}
/// Adds register units covered by physical register \p Reg that are
/// part of the lanemask \p Mask.
void addRegMasked(MCPhysReg Reg, LaneBitmask Mask) {
for (MCRegUnitMaskIterator Unit(Reg, TRI); Unit.isValid(); ++Unit) {
LaneBitmask UnitMask = (*Unit).second;
if (UnitMask.none() || (UnitMask & Mask).any())
Units.set((*Unit).first);
}
}
/// Removes all register units covered by physical register \p Reg.
void removeReg(MCPhysReg Reg) {
for (MCRegUnitIterator Unit(Reg, TRI); Unit.isValid(); ++Unit)
Units.reset(*Unit);
}
/// Removes register units not preserved by the regmask \p RegMask.
/// The regmask has the same format as the one in the RegMask machine operand.
void removeRegsNotPreserved(const uint32_t *RegMask);
/// Adds register units not preserved by the regmask \p RegMask.
/// The regmask has the same format as the one in the RegMask machine operand.
void addRegsInMask(const uint32_t *RegMask);
/// Returns true if no part of physical register \p Reg is live.
bool available(MCPhysReg Reg) const {
for (MCRegUnitIterator Unit(Reg, TRI); Unit.isValid(); ++Unit) {
if (Units.test(*Unit))
return false;
}
return true;
}
/// Updates liveness when stepping backwards over the instruction \p MI.
/// This removes all register units defined or clobbered in \p MI and then
/// adds the units used (as in use operands) in \p MI.
void stepBackward(const MachineInstr &MI);
/// Adds all register units used, defined or clobbered in \p MI.
/// This is useful when walking over a range of instruction to find registers
/// unused over the whole range.
void accumulate(const MachineInstr &MI);
/// Adds registers living out of block \p MBB.
/// Live out registers are the union of the live-in registers of the successor
/// blocks and pristine registers. Live out registers of the end block are the
/// callee saved registers.
void addLiveOuts(const MachineBasicBlock &MBB);
/// Adds registers living into block \p MBB.
void addLiveIns(const MachineBasicBlock &MBB);
/// Adds all register units marked in the bitvector \p RegUnits.
void addUnits(const BitVector &RegUnits) {
Units |= RegUnits;
}
/// Removes all register units marked in the bitvector \p RegUnits.
void removeUnits(const BitVector &RegUnits) {
Units.reset(RegUnits);
}
/// Return the internal bitvector representation of the set.
const BitVector &getBitVector() const {
return Units;
}
private:
/// Adds pristine registers. Pristine registers are callee saved registers
/// that are unused in the function.
void addPristines(const MachineFunction &MF);
};
} // end namespace llvm
#endif // LLVM_CODEGEN_LIVEREGUNITS_H
| 1,957 |
312 | // Copyright <NAME> 2015
#ifndef PURINE_CONNECTABLE
#define PURINE_CONNECTABLE
#include "dispatch/graph.hpp"
namespace purine {
class Connectable : public Graph {
friend Connectable& operator >> (Connectable& graph1,
Connectable& graph2);
friend Connectable& operator >> (const vector<Blob*>& bottom,
Connectable& graph);
friend const vector<Blob*>& operator >> (Connectable& graph,
const vector<Blob*>& top);
protected:
vector<Blob*> bottom_;
vector<Blob*> top_;
bool bottom_setup_ = false;
bool top_setup_ = false;
public:
Connectable(int rank = 0, int device = 0);
virtual ~Connectable() override;
const vector<Blob*>& bottom();
const vector<Blob*>& top();
virtual void set_bottom(const vector<Blob*>& bottom);
virtual void set_top(const vector<Blob*>& top);
};
}
#endif
| 291 |
1,047 | <reponame>Mu-L/MeshSync<gh_stars>1000+
#pragma once
namespace ms {
enum class ZUpCorrectionMode {
FlipYZ,
RotateX,
};
struct SceneImportSettings {
uint32_t flags = 0; // reserved
uint32_t mesh_split_unit = 0xffffffff;
int mesh_max_bone_influence = 4; // 4 or 255 (variable up to 255)
ZUpCorrectionMode zup_correction_mode = ZUpCorrectionMode::FlipYZ;
};
} // namespace ms
| 158 |
1,162 | package io.digdag.standards.command;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.google.common.base.Optional;
import io.digdag.client.config.Config;
import io.digdag.client.config.ConfigFactory;
import io.digdag.core.archive.ProjectArchiveLoader;
import io.digdag.core.storage.StorageManager;
import io.digdag.spi.CommandContext;
import io.digdag.spi.CommandLogger;
import io.digdag.spi.CommandRequest;
import io.digdag.spi.CommandStatus;
import io.digdag.spi.TaskRequest;
import io.digdag.standards.command.kubernetes.KubernetesClient;
import io.digdag.standards.command.kubernetes.KubernetesClientConfig;
import io.digdag.standards.command.kubernetes.KubernetesClientFactory;
import io.digdag.standards.command.kubernetes.TemporalConfigStorage;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.runners.MockitoJUnitRunner;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.mockito.Mockito.any;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.when;
@RunWith(MockitoJUnitRunner.class)
public class KubernetesCommandExecutorTest
{
private final ObjectMapper om = new ObjectMapper();
private final ConfigFactory configFactory = new ConfigFactory(om);
private Config systemConfig;
@Mock private KubernetesClientFactory kubernetesClientFactory;
@Mock private DockerCommandExecutor dockerCommandExecutor;
@Mock private StorageManager storageManager;
@Mock private ProjectArchiveLoader projectArchiveLoader;
@Mock private CommandLogger commandLogger;
@Before
public void setUp()
throws Exception
{
this.systemConfig = configFactory.create();
}
@Test
public void testRun()
throws Exception
{
final KubernetesCommandExecutor executor = spy(new KubernetesCommandExecutor(
systemConfig, kubernetesClientFactory, dockerCommandExecutor,
storageManager, projectArchiveLoader, commandLogger));
final KubernetesCommandStatus commandStatus = KubernetesCommandStatus.of(false, om.createObjectNode().put("foo", "bar"));
doReturn(mock(KubernetesClientConfig.class)).when(executor).createKubernetesClientConfig(any(Optional.class), any(Config.class), any(Config.class));
doReturn(mock(TemporalConfigStorage.class)).when(executor).createTemporalConfigStorage(any(Config.class), any(String.class));
doReturn(commandStatus).when(executor).runOnKubernetes(any(CommandContext.class), any(CommandRequest.class), any(KubernetesClient.class), any(TemporalConfigStorage.class), any(TemporalConfigStorage.class));
when(kubernetesClientFactory.newClient(any(KubernetesClientConfig.class))).thenReturn(mock(KubernetesClient.class));
CommandContext commandContext = mock(CommandContext.class);
CommandRequest commandRequest = mock(CommandRequest.class);
when(commandContext.getTaskRequest()).thenReturn(mock(TaskRequest.class));
CommandStatus actual = executor.run(commandContext, commandRequest);
assertThat(actual.isFinished(), is(commandStatus.isFinished()));
assertThat(actual.toJson(), is(commandStatus.toJson()));
}
@Test
public void testPoll()
throws Exception
{
final KubernetesCommandExecutor executor = spy(new KubernetesCommandExecutor(
systemConfig, kubernetesClientFactory, dockerCommandExecutor,
storageManager, projectArchiveLoader, commandLogger));
final KubernetesCommandStatus commandStatus = KubernetesCommandStatus.of(false, om.createObjectNode().put("foo", "bar"));
doReturn(commandStatus).when(executor).getCommandStatusFromKubernetes(any(CommandContext.class), any(ObjectNode.class), any(KubernetesClient.class), any(TemporalConfigStorage.class));
doReturn(mock(KubernetesClientConfig.class)).when(executor).createKubernetesClientConfig(any(Optional.class), any(Config.class), any(Config.class));
doReturn(mock(TemporalConfigStorage.class)).when(executor).createTemporalConfigStorage(any(Config.class), any(String.class));
when(kubernetesClientFactory.newClient(any(KubernetesClientConfig.class))).thenReturn(mock(KubernetesClient.class));
CommandContext commandContext = mock(CommandContext.class);
when(commandContext.getTaskRequest()).thenReturn(mock(TaskRequest.class));
ObjectNode previousStatusJson = om.createObjectNode().put("cluster_name", "my_cluster");
CommandStatus actual = executor.poll(commandContext, previousStatusJson);
assertThat(actual.isFinished(), is(commandStatus.isFinished()));
assertThat(actual.toJson(), is(commandStatus.toJson()));
}
}
| 1,741 |
335 | <filename>F/Fit_verb.json
{
"word": "Fit",
"definitions": [
"Be of the right shape and size for.",
"Try clothing on (someone) in order to make or alter it to the correct size.",
"Be of the right size, shape, or number to occupy a particular place.",
"Install or fix (something) into place.",
"Provide (something) with a particular component or article.",
"Join or cause to join together to form a whole.",
"Be compatible or in agreement with; match.",
"Be suitable or appropriate for.",
"(of an attribute, qualification, or skill) make (someone) suitable to fulfil a particular role or undertake a particular task."
],
"parts-of-speech": "Verb"
} | 249 |
365 | /*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* The Original Code is Copyright (C) 2013 Blender Foundation.
* All rights reserved.
*/
/** \file
* \ingroup depsgraph
*
* Methods for constructing depsgraph
*/
#include "intern/builder/deg_builder_relations.h"
namespace blender::deg {
////////////////////////////////////////////////////////////////////////////////
// Time source.
TimeSourceKey::TimeSourceKey() : id(nullptr)
{
}
TimeSourceKey::TimeSourceKey(ID *id) : id(id)
{
}
string TimeSourceKey::identifier() const
{
return string("TimeSourceKey");
}
////////////////////////////////////////////////////////////////////////////////
// Component.
ComponentKey::ComponentKey() : id(nullptr), type(NodeType::UNDEFINED), name("")
{
}
ComponentKey::ComponentKey(ID *id, NodeType type, const char *name)
: id(id), type(type), name(name)
{
}
string ComponentKey::identifier() const
{
const char *idname = (id) ? id->name : "<None>";
string result = string("ComponentKey(");
result += idname;
result += ", " + string(nodeTypeAsString(type));
if (name[0] != '\0') {
result += ", '" + string(name) + "'";
}
result += ')';
return result;
}
////////////////////////////////////////////////////////////////////////////////
// Operation.
OperationKey::OperationKey()
: id(nullptr),
component_type(NodeType::UNDEFINED),
component_name(""),
opcode(OperationCode::OPERATION),
name(""),
name_tag(-1)
{
}
OperationKey::OperationKey(ID *id, NodeType component_type, const char *name, int name_tag)
: id(id),
component_type(component_type),
component_name(""),
opcode(OperationCode::OPERATION),
name(name),
name_tag(name_tag)
{
}
OperationKey::OperationKey(
ID *id, NodeType component_type, const char *component_name, const char *name, int name_tag)
: id(id),
component_type(component_type),
component_name(component_name),
opcode(OperationCode::OPERATION),
name(name),
name_tag(name_tag)
{
}
OperationKey::OperationKey(ID *id, NodeType component_type, OperationCode opcode)
: id(id),
component_type(component_type),
component_name(""),
opcode(opcode),
name(""),
name_tag(-1)
{
}
OperationKey::OperationKey(ID *id,
NodeType component_type,
const char *component_name,
OperationCode opcode)
: id(id),
component_type(component_type),
component_name(component_name),
opcode(opcode),
name(""),
name_tag(-1)
{
}
OperationKey::OperationKey(
ID *id, NodeType component_type, OperationCode opcode, const char *name, int name_tag)
: id(id),
component_type(component_type),
component_name(""),
opcode(opcode),
name(name),
name_tag(name_tag)
{
}
OperationKey::OperationKey(ID *id,
NodeType component_type,
const char *component_name,
OperationCode opcode,
const char *name,
int name_tag)
: id(id),
component_type(component_type),
component_name(component_name),
opcode(opcode),
name(name),
name_tag(name_tag)
{
}
string OperationKey::identifier() const
{
string result = string("OperationKey(");
result += "type: " + string(nodeTypeAsString(component_type));
result += ", component name: '" + string(component_name) + "'";
result += ", operation code: " + string(operationCodeAsString(opcode));
if (name[0] != '\0') {
result += ", '" + string(name) + "'";
}
result += ")";
return result;
}
////////////////////////////////////////////////////////////////////////////////
// RNA path.
RNAPathKey::RNAPathKey(ID *id, const char *path, RNAPointerSource source) : id(id), source(source)
{
/* Create ID pointer for root of path lookup. */
PointerRNA id_ptr;
RNA_id_pointer_create(id, &id_ptr);
/* Try to resolve path. */
int index;
if (!RNA_path_resolve_full(&id_ptr, path, &ptr, &prop, &index)) {
ptr = PointerRNA_NULL;
prop = nullptr;
}
}
RNAPathKey::RNAPathKey(ID *id, const PointerRNA &ptr, PropertyRNA *prop, RNAPointerSource source)
: id(id), ptr(ptr), prop(prop), source(source)
{
}
string RNAPathKey::identifier() const
{
const char *id_name = (id) ? id->name : "<No ID>";
const char *prop_name = (prop) ? RNA_property_identifier(prop) : "<No Prop>";
return string("RnaPathKey(") + "id: " + id_name + ", prop: '" + prop_name + "')";
}
} // namespace blender::deg
| 1,945 |
332 | <reponame>floschliep/ISHPermissionKit
//
// ISHPermissionRequestModernPhotoLibrary.h
// ISHPermissionKit
//
// Created by Hagi on 24/08/16.
// Copyright © 2016 iosphere GmbH. All rights reserved.
//
#import <ISHPermissionKit/ISHPermissionKit.h>
#ifdef ISHPermissionRequestPhotoLibraryEnabled
/**
* Permission request to acces the user's photo library using
* PHPhotoLibrary APIs.
*
* @sa ISHPermissionCategoryModernPhotoLibrary
*/
@interface ISHPermissionRequestModernPhotoLibrary : ISHPermissionRequest
@end
#endif
| 171 |
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.contactcenterinsights.v1.model;
/**
* A time series representing conversations over time.
*
* <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 Contact Center AI Insights 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 GoogleCloudContactcenterinsightsV1CalculateStatsResponseTimeSeries extends com.google.api.client.json.GenericJson {
/**
* The duration of each interval.
* The value may be {@code null}.
*/
@com.google.api.client.util.Key
private String intervalDuration;
/**
* An ordered list of intervals from earliest to latest, where each interval represents the number
* of conversations that transpired during the time window.
* The value may be {@code null}.
*/
@com.google.api.client.util.Key
private java.util.List<GoogleCloudContactcenterinsightsV1CalculateStatsResponseTimeSeriesInterval> points;
/**
* The duration of each interval.
* @return value or {@code null} for none
*/
public String getIntervalDuration() {
return intervalDuration;
}
/**
* The duration of each interval.
* @param intervalDuration intervalDuration or {@code null} for none
*/
public GoogleCloudContactcenterinsightsV1CalculateStatsResponseTimeSeries setIntervalDuration(String intervalDuration) {
this.intervalDuration = intervalDuration;
return this;
}
/**
* An ordered list of intervals from earliest to latest, where each interval represents the number
* of conversations that transpired during the time window.
* @return value or {@code null} for none
*/
public java.util.List<GoogleCloudContactcenterinsightsV1CalculateStatsResponseTimeSeriesInterval> getPoints() {
return points;
}
/**
* An ordered list of intervals from earliest to latest, where each interval represents the number
* of conversations that transpired during the time window.
* @param points points or {@code null} for none
*/
public GoogleCloudContactcenterinsightsV1CalculateStatsResponseTimeSeries setPoints(java.util.List<GoogleCloudContactcenterinsightsV1CalculateStatsResponseTimeSeriesInterval> points) {
this.points = points;
return this;
}
@Override
public GoogleCloudContactcenterinsightsV1CalculateStatsResponseTimeSeries set(String fieldName, Object value) {
return (GoogleCloudContactcenterinsightsV1CalculateStatsResponseTimeSeries) super.set(fieldName, value);
}
@Override
public GoogleCloudContactcenterinsightsV1CalculateStatsResponseTimeSeries clone() {
return (GoogleCloudContactcenterinsightsV1CalculateStatsResponseTimeSeries) super.clone();
}
}
| 1,016 |
936 | /*
* Copyright 2021, Yahoo Inc.
* Licensed under the Apache License, Version 2.0
* See LICENSE file in project root for terms.
*/
package com.yahoo.elide.core.datastore.inmemory;
import static com.yahoo.elide.core.dictionary.EntityDictionary.NO_VERSION;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.Assertions.assertTrue;
import com.yahoo.elide.core.RequestScope;
import com.yahoo.elide.core.TestRequestScope;
import com.yahoo.elide.core.dictionary.EntityDictionary;
import com.yahoo.elide.core.filter.dialect.RSQLFilterDialect;
import com.yahoo.elide.core.filter.expression.FilterExpression;
import com.yahoo.elide.core.type.ClassType;
import example.Book;
import org.junit.jupiter.api.Test;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
public class FilteredIteratorTest {
@Test
public void testFilteredResult() throws Exception {
EntityDictionary dictionary = EntityDictionary.builder().build();
dictionary.bindEntity(Book.class);
Book book1 = new Book();
book1.setTitle("foo");
Book book2 = new Book();
book2.setTitle("bar");
Book book3 = new Book();
book3.setTitle("foobar");
List<Book> books = List.of(book1, book2, book3);
RSQLFilterDialect filterDialect = RSQLFilterDialect.builder().dictionary(dictionary).build();
FilterExpression expression =
filterDialect.parse(ClassType.of(Book.class), new HashSet<>(), "title==*bar", NO_VERSION);
RequestScope scope = new TestRequestScope(null, null, dictionary);
Iterator<Book> bookIterator = new FilteredIterator<>(expression, scope, books.iterator());
assertTrue(bookIterator.hasNext());
assertEquals("bar", bookIterator.next().getTitle());
assertTrue(bookIterator.hasNext());
assertEquals("foobar", bookIterator.next().getTitle());
assertFalse(bookIterator.hasNext());
}
@Test
public void testEmptyResult() throws Exception {
EntityDictionary dictionary = EntityDictionary.builder().build();
dictionary.bindEntity(Book.class);
List<Book> books = List.of();
RSQLFilterDialect filterDialect = RSQLFilterDialect.builder().dictionary(dictionary).build();
FilterExpression expression =
filterDialect.parse(ClassType.of(Book.class), new HashSet<>(), "title==*bar", NO_VERSION);
RequestScope scope = new TestRequestScope(null, null, dictionary);
Iterator<Book> bookIterator = new FilteredIterator<>(expression, scope, books.iterator());
assertFalse(bookIterator.hasNext());
assertThrows(NoSuchElementException.class, () -> bookIterator.next());
}
}
| 1,029 |
310 | <reponame>dreeves/usesthis
{
"name": "Meatspace",
"description": "A web-based chat system.",
"url": "https://chat.meatspac.es"
} | 55 |
1,209 | <gh_stars>1000+
/*
u8g_com_arduino_common.c
shared procedures for the arduino communication procedures
Universal 8bit Graphics Library
Copyright (c) 2011, <EMAIL>
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
* 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.
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 HOLDER 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 "u8g.h"
#if defined(ARDUINO)
#if ARDUINO < 100
#include <WProgram.h>
#else
#include <Arduino.h>
#endif
void u8g_com_arduino_digital_write(u8g_t *u8g, uint8_t pin_index, uint8_t value)
{
uint8_t pin;
pin = u8g->pin_list[pin_index];
if ( pin != U8G_PIN_NONE )
digitalWrite(pin, value);
}
/* this procedure does not set the RW pin */
void u8g_com_arduino_assign_pin_output_high(u8g_t *u8g)
{
uint8_t i;
/* skip the RW pin, which is the last pin in the list */
for( i = 0; i < U8G_PIN_LIST_LEN-1; i++ )
{
if ( u8g->pin_list[i] != U8G_PIN_NONE )
{
pinMode(u8g->pin_list[i], OUTPUT);
digitalWrite(u8g->pin_list[i], HIGH);
}
}
}
#endif
| 802 |
5,813 | <reponame>RomaKoks/druid<gh_stars>1000+
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.druid.server.security;
import com.google.common.annotations.VisibleForTesting;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Sets;
import javax.annotation.Nonnull;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.ws.rs.HttpMethod;
import java.io.IOException;
import java.util.List;
import java.util.Set;
/**
* Filters requests based on the HTTP method.
*
* Any method that is not explicitly allowed by a Druid admin or one of the {@link #SUPPORTED_METHODS} that Druid
* requires to operate, will be rejected.
*/
public class AllowHttpMethodsResourceFilter implements Filter
{
/**
* Druid always allows GET, POST, PUT and DELETE methods.
*/
@VisibleForTesting
static final List<String> SUPPORTED_METHODS =
ImmutableList.of(HttpMethod.GET, HttpMethod.POST, HttpMethod.PUT, HttpMethod.DELETE);
private final Set<String> supportedMethods;
public AllowHttpMethodsResourceFilter(@Nonnull List<String> additionalSupportedMethods)
{
supportedMethods = Sets.newHashSetWithExpectedSize(additionalSupportedMethods.size() + SUPPORTED_METHODS.size());
supportedMethods.addAll(SUPPORTED_METHODS);
supportedMethods.addAll(additionalSupportedMethods);
}
@Override
public void init(FilterConfig filterConfig)
{
/* Do nothing. */
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws IOException, ServletException
{
HttpServletRequest httpReq = (HttpServletRequest) request;
if (!supportedMethods.contains(httpReq.getMethod())) {
((HttpServletResponse) response).sendError(HttpServletResponse.SC_METHOD_NOT_ALLOWED);
} else {
chain.doFilter(request, response);
}
}
@Override
public void destroy()
{
/* Do nothing. */
}
}
| 891 |
3,402 | /*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.kylin.metadata.model;
import java.io.Serializable;
import java.util.Comparator;
/**
* SegmentRange and TSRange seem similar but are different concepts.
*
* - SegmentRange defines the range of a segment.
* - TSRange is the time series range of the segment data.
* - When segment range is defined by time, the two can be the same, in that case TSRange is a kind of SegmentRange.
* - Duration segment creation (build/refresh/merge), a new segment is defined by either one of the two, not both.
* - And the choice must be consistent across all following segment creation.
*/
@SuppressWarnings("serial")
public class SegmentRange<T extends Comparable> implements Comparable<SegmentRange>, Serializable {
public final Endpoint<T> start;
public final Endpoint<T> end;
public SegmentRange(Endpoint start, Endpoint end) {
this.start = start;
this.end = end;
checkState();
}
public SegmentRange(T start, T end) {
if (start != null && end != null && start.getClass() != end.getClass())
throw new IllegalArgumentException();
this.start = new Endpoint(start, start == null, false);
this.end = new Endpoint(end, false, end == null);
checkState();
}
@Override
public int compareTo(SegmentRange o) {
int comp = this.start.compareTo(o.start);
if (comp != 0)
return comp;
return this.end.compareTo(o.end);
}
private void checkState() {
if (start.compareTo(end) > 0)
throw new IllegalStateException();
}
public boolean isInfinite() {
return start.isMin && end.isMax;
}
public boolean contains(SegmentRange o) {
return this.start.compareTo(o.start) <= 0 && o.end.compareTo(this.end) <= 0;
}
public boolean overlaps(SegmentRange o) {
return this.start.compareTo(o.end) < 0 && o.start.compareTo(this.end) < 0;
}
public boolean connects(SegmentRange o) {
return this.end.compareTo(o.start) == 0;
}
public boolean apartBefore(SegmentRange o) {
return this.end.compareTo(o.start) < 0;
}
@Override
public String toString() {
return this.getClass().getSimpleName() + "[" + start + "," + end + ")";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((end == null) ? 0 : end.hashCode());
result = prime * result + ((start == null) ? 0 : start.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
SegmentRange other = (SegmentRange) obj;
if (end == null) {
if (other.end != null)
return false;
} else if (!end.equals(other.end))
return false;
if (start == null) {
if (other.start != null)
return false;
} else if (!start.equals(other.start))
return false;
return true;
}
// ============================================================================
public static class TSRange extends SegmentRange<Long> {
public TSRange(Long start, Long end) {
// [0, Long.MAX_VALUE) is full build (for historic reason)
super(new Endpoint(isInfinite(start, end) ? 0 : start, isInfinite(start, end), false), //
new Endpoint(isInfinite(start, end) ? Long.MAX_VALUE : end, false, isInfinite(start, end)));
}
private static boolean isInfinite(Long start, Long end) {
return (start == null || start <= 0) && (end == null || end == Long.MAX_VALUE);
}
public long duration() {
return end.v - start.v;
}
public long startValue() {
return start.v;
}
public long endValue() {
return end.v;
}
}
// ============================================================================
// immutable
public static class Endpoint<T extends Comparable> implements Comparable<Endpoint>, Serializable {
public static final Comparator<Endpoint> comparator = getComparator(new Comparator() {
@Override
public int compare(Object o1, Object o2) {
return ((Comparable) o1).compareTo(o2);
}
});
public static Comparator<Endpoint> getComparator(final Comparator valueComparator) {
return new Comparator<Endpoint>() {
@Override
public int compare(Endpoint a, Endpoint b) {
if (a == null || b == null)
throw new IllegalStateException();
if (a.isMin) {
return b.isMin ? 0 : -1;
} else if (b.isMin) {
return a.isMin ? 0 : 1;
} else if (a.isMax) {
return b.isMax ? 0 : 1;
} else if (b.isMax) {
return a.isMax ? 0 : -1;
} else {
return valueComparator.compare(a.v, b.v);
}
}
};
}
public final T v;
public final boolean isMin;
public final boolean isMax;
private Endpoint(T v, boolean isMin, boolean isMax) {
this.v = v;
this.isMin = isMin;
this.isMax = isMax;
}
@Override
public int compareTo(Endpoint o) {
return comparator.compare(this, o);
}
@Override
public String toString() {
String s = "" + v;
if (isMin)
s += "[min]";
if (isMax)
s += "[max]";
return s;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + (isMax ? 1231 : 1237);
result = prime * result + (isMin ? 1231 : 1237);
result = prime * result + ((v == null) ? 0 : v.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Endpoint other = (Endpoint) obj;
if (isMax != other.isMax)
return false;
if (isMin != other.isMin)
return false;
return comparator.compare(this, other) == 0;
}
}
}
| 3,367 |
852 | import FWCore.ParameterSet.Config as cms
process = cms.Process("TEST")
process.PoolDBESSource = cms.ESSource("PoolDBESSource",
loadAll = cms.bool(True),
toGet = cms.VPSet(cms.PSet(
record = cms.string('CSCGainsRcd'),
tag = cms.string('CSCGains_ideal')
),
cms.PSet(
record = cms.string('CSCNoiseMatrixRcd'),
tag = cms.string('CSCNoiseMatrix_ideal')
),
cms.PSet(
record = cms.string('CSCcrosstalkRcd'),
tag = cms.string('CSCCrosstalk_ideal')
),
cms.PSet(
record = cms.string('CSCPedestalsRcd'),
tag = cms.string('CSCPedestals_ideal')
)),
DBParameters = cms.PSet(
authenticationPath = cms.untracked.string('/afs/cern.ch/cms/DB/conddb'),
authenticationMethod = cms.untracked.uint32(1)
),
catalog = cms.untracked.string('relationalcatalog_oracle://cms_orcoff_int2r/CMS_COND_GENERAL'), ##cms_orcoff_int2r/CMS_COND_GENERAL"
timetype = cms.string('runnumber'),
#read constants from DB
connect = cms.string('oracle://cms_orcoff_int2r/CMS_COND_CSC')
)
process.maxEvents = cms.untracked.PSet(
input = cms.untracked.int32(1)
)
process.source = cms.Source("EmptySource")
process.prod1 = cms.EDAnalyzer("CSCCrossTalkReadAnalyzer")
process.prod2 = cms.EDAnalyzer("CSCGainsReadAnalyzer")
process.prod3 = cms.EDAnalyzer("CSCNoiseMatrixReadAnalyzer")
process.prod4 = cms.EDAnalyzer("CSCPedestalReadAnalyzer")
process.output = cms.OutputModule("AsciiOutputModule")
process.p = cms.Path(process.prod1*process.prod2*process.prod3*process.prod4)
process.ep = cms.EndPath(process.output)
| 776 |
385 | <gh_stars>100-1000
import datetime
import uuid
import decimal
import pytest
from jupyterlab_sql.serializer import make_row_serializable
@pytest.mark.parametrize(
"test_input",
[
((1, "hello"),),
((1, {"some": "dict"}),),
((1, {"some": ["array", "in", "dict"]}),),
],
)
def test_make_row_serializable_unchanged(test_input):
assert make_row_serializable(test_input) == test_input
def test_serialize_uuid():
uuid_str = "6e1d16e3-ca00-4e96-9735-95bf92a8c46c"
row = (1, uuid.UUID(uuid_str))
assert make_row_serializable(row) == (1, uuid_str)
def test_serialize_datetime():
dt = datetime.datetime(2019, 2, 10, 11, 45, 22)
expected_str = "2019-02-10 11:45:22"
row = (1, dt)
assert make_row_serializable(row) == (1, expected_str)
def test_serialize_date():
dt = datetime.date(2019, 2, 10)
expected_str = "2019-02-10"
row = (1, dt)
assert make_row_serializable(row) == (1, expected_str)
def test_serialize_uuid_array():
uuid1_str = "1cfdc7b5-f320-4885-9b50-3cefc20a462a"
uuid2_str = "bfd96545-bd8b-41bb-b9fc-afb57f7d1328"
row = (1, [uuid.UUID(uuid1_str), uuid.UUID(uuid2_str)])
assert make_row_serializable(row) == (1, [uuid1_str, uuid2_str])
@pytest.mark.parametrize(
"test_str",
[
"3.14",
"3.141592653589793238462643383279502884197169399375105820974944592307816", # noqa
],
)
def test_serialize_decimal(test_str):
dec = decimal.Decimal(test_str)
row = (1, dec)
assert make_row_serializable(row) == (1, test_str)
| 742 |
3,102 | // use-defs-2.h
#include "defs.h"
| 19 |
2,151 | <gh_stars>1000+
// Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "components/signin/core/browser/cookie_settings_util.h"
#include "components/content_settings/core/browser/cookie_settings.h"
#include "google_apis/gaia/gaia_urls.h"
#include "url/gurl.h"
namespace signin {
bool SettingsAllowSigninCookies(
const content_settings::CookieSettings* cookie_settings) {
GURL gaia_url = GaiaUrls::GetInstance()->gaia_url();
GURL google_url = GaiaUrls::GetInstance()->google_url();
return cookie_settings &&
cookie_settings->IsCookieAccessAllowed(gaia_url, gaia_url) &&
cookie_settings->IsCookieAccessAllowed(google_url, google_url);
}
bool SettingsDeleteSigninCookiesOnExit(
const content_settings::CookieSettings* cookie_settings) {
GURL gaia_url = GaiaUrls::GetInstance()->gaia_url();
GURL google_url = GaiaUrls::GetInstance()->google_url();
ContentSettingsForOneType settings;
cookie_settings->GetCookieSettings(&settings);
return !cookie_settings ||
cookie_settings->ShouldDeleteCookieOnExit(
settings, "." + gaia_url.host(), true) ||
cookie_settings->ShouldDeleteCookieOnExit(
settings, "." + google_url.host(), true);
}
} // namespace signin
| 476 |
9,156 | /**
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.pulsar.broker.web.plugin.servlet;
import com.google.common.collect.ImmutableMap;
import java.io.IOException;
import java.util.Map;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;
import org.apache.pulsar.common.configuration.PulsarConfiguration;
import org.apache.pulsar.common.nar.NarClassLoader;
/**
* A collection of loaded additional servlets.
*/
@Slf4j
public class AdditionalServlets implements AutoCloseable {
private static final String ADDITIONAL_SERVLET_DIRECTORY = "additionalServletDirectory";
private static final String ADDITIONAL_SERVLETS = "additionalServlets";
private static final String NAR_EXTRACTION_DIRECTORY = "narExtractionDirectory";
@Deprecated
private static final String PROXY_ADDITIONAL_SERVLET_DIRECTORY = "proxyAdditionalServletDirectory";
@Deprecated
private static final String PROXY_ADDITIONAL_SERVLETS = "proxyAdditionalServlets";
@Getter
private final Map<String, AdditionalServletWithClassLoader> servlets;
public AdditionalServlets(Map<String, AdditionalServletWithClassLoader> servlets) {
this.servlets = servlets;
}
/**
* Load the additional servlet for the given <tt>servlet name</tt> list.
*
* @param conf the pulsar service configuration
* @return the collection of additional servlet
*/
public static AdditionalServlets load(PulsarConfiguration conf) throws IOException {
String additionalServletDirectory = conf.getProperties().getProperty(ADDITIONAL_SERVLET_DIRECTORY);
if (additionalServletDirectory == null) {
// Compatible with the current proxy configuration
additionalServletDirectory = conf.getProperties().getProperty(PROXY_ADDITIONAL_SERVLET_DIRECTORY);
}
String additionalServlets = conf.getProperties().getProperty(ADDITIONAL_SERVLETS);
if (additionalServlets == null) {
additionalServlets = conf.getProperties().getProperty(PROXY_ADDITIONAL_SERVLETS);
}
String narExtractionDirectory = conf.getProperties().getProperty(NAR_EXTRACTION_DIRECTORY);
if(narExtractionDirectory == null) {
narExtractionDirectory = NarClassLoader.DEFAULT_NAR_EXTRACTION_DIR;
}
if (additionalServletDirectory == null || additionalServlets == null) {
return null;
}
AdditionalServletDefinitions definitions =
AdditionalServletUtils.searchForServlets(additionalServletDirectory
, narExtractionDirectory);
ImmutableMap.Builder<String, AdditionalServletWithClassLoader> builder = ImmutableMap.builder();
String[] additionalServletsList = additionalServlets.split(",");
for (String servletName : additionalServletsList) {
AdditionalServletMetadata definition = definitions.servlets().get(servletName);
if (null == definition) {
throw new RuntimeException("No additional servlet is found for name `" + servletName
+ "`. Available additional servlet are : " + definitions.servlets());
}
AdditionalServletWithClassLoader servletWithClassLoader;
try {
servletWithClassLoader = AdditionalServletUtils.load(definition, narExtractionDirectory);
if (servletWithClassLoader != null) {
builder.put(servletName, servletWithClassLoader);
}
log.info("Successfully loaded additional servlet for name `{}`", servletName);
} catch (IOException e) {
log.error("Failed to load the additional servlet for name `" + servletName + "`", e);
throw new RuntimeException("Failed to load the additional servlet for name `" + servletName + "`");
}
}
Map<String, AdditionalServletWithClassLoader> servlets = builder.build();
if (servlets != null && !servlets.isEmpty()) {
return new AdditionalServlets(servlets);
}
return null;
}
@Override
public void close() {
servlets.values().forEach(AdditionalServletWithClassLoader::close);
}
}
| 1,764 |
5,169 | {
"name": "Overcoat",
"version": "1.2",
"license": "MIT",
"summary": "Overcoat is an AFNetworking extension that makes it extremely simple for developers to use Mantle model objects with a REST client.",
"homepage": "https://github.com/gonzalezreal/Overcoat",
"authors": {
"<NAME>": "<EMAIL>"
},
"source": {
"git": "https://github.com/gonzalezreal/Overcoat.git",
"tag": "1.2"
},
"source_files": "Overcoat",
"requires_arc": true,
"dependencies": {
"AFNetworking": [
"~> 2.0"
],
"Mantle": [
"~> 1.3"
]
},
"platforms": {
"ios": "6.0",
"osx": "10.8"
},
"ios": {
"frameworks": [
"Foundation",
"Accounts",
"Social"
]
},
"osx": {
"frameworks": [
"Foundation",
"Accounts",
"Social"
]
}
}
| 375 |
1,056 | /*
* 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.netbeans.modules.db.dataview.table;
import java.awt.datatransfer.StringSelection;
import java.awt.datatransfer.Transferable;
import java.awt.event.ActionEvent;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.MouseEvent;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.JCheckBox;
import javax.swing.JComponent;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.TransferHandler;
import javax.swing.event.TableModelEvent;
import javax.swing.event.TableModelListener;
import javax.swing.plaf.UIResource;
import javax.swing.table.*;
import org.netbeans.modules.db.dataview.meta.DBColumn;
import org.netbeans.modules.db.dataview.table.celleditor.*;
import org.netbeans.modules.db.dataview.util.BinaryToStringConverter;
import org.netbeans.modules.db.dataview.util.DataViewUtils;
import org.netbeans.modules.db.dataview.util.DateType;
import org.netbeans.modules.db.dataview.util.TimeType;
import org.netbeans.modules.db.dataview.util.TimestampType;
import org.openide.util.Exceptions;
import org.openide.util.Lookup;
import org.openide.util.datatransfer.ExClipboard;
/**
* A better-looking table than JTable, implements JXTable and a decorator to draw empty rows
*
* @author <NAME>
*/
public class ResultSetJXTable extends JXTableDecorator {
private static final String data = "WE WILL EITHER FIND A WAY, OR MAKE ONE."; // NOI18N
private static final Logger mLogger = Logger.getLogger(ResultSetJXTable.class.getName());
private static final int MAX_COLUMN_WIDTH = 25;
private static final DateFormat timeFormat = new SimpleDateFormat(TimeType.DEFAULT_FOMAT_PATTERN);
private static final DateFormat dateFormat = new SimpleDateFormat(DateType.DEFAULT_FOMAT_PATTERN);
private static final DateFormat timestampFormat = new SimpleDateFormat(TimestampType.DEFAULT_FORMAT_PATTERN);
private final int multiplier;
private final StringFallbackRowSorter sorter = new StringFallbackRowSorter(null);
private Set<Integer> visibleColumns = new HashSet<>();
// If structure changes, enforce relayout
private final TableModelListener dataExchangedListener = new TableModelListener() {
@Override
public void tableChanged(TableModelEvent e) {
if(e.getFirstRow() == TableModelEvent.HEADER_ROW) {
updateHeader();
}
}
};
@SuppressWarnings("OverridableMethodCallInConstructor")
public ResultSetJXTable() {
this.setRowSorter(sorter);
this.setAutoCreateColumnsFromModel(false);
this.setTransferHandler(new TableTransferHandler());
setShowGrid(true);
setGridColor(GRID_COLOR);
getTableHeader().setReorderingAllowed(false);
setFillsViewportHeight(true);
setDefaultCellRenderers();
setDefaultCellEditors();
multiplier = getFontMetrics(getFont()).stringWidth(data) / data.length() + 4;
putClientProperty("terminateEditOnFocusLost", Boolean.TRUE);
this.setModel(createDefaultDataModel());
getActionMap().put("selectNextColumnCell", new EditingAwareAction(getActionMap().get("selectNextColumnCell")));
getActionMap().put("selectPreviousColumnCell", new EditingAwareAction(getActionMap().get("selectPreviousColumnCell")));
getActionMap().put("selectNextRowCell", new EditingAwareAction(getActionMap().get("selectNextRowCell")));
getActionMap().put("selectNextPreviousCell", new EditingAwareAction(getActionMap().get("selectPreviousRowCell")));
setSurrendersFocusOnKeystroke(true);
setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
}
@Override
protected JTableHeader createDefaultTableHeader() {
return new JTableHeaderImpl(columnModel);
}
@Override
protected TableModel createDefaultDataModel() {
return new ResultSetTableModel(new DBColumn[0]);
}
@Override
public void setModel(TableModel dataModel) {
if(! (dataModel instanceof ResultSetTableModel)) {
throw new IllegalArgumentException(
"TableModel for ResultSetJXTable must be an " // NOI18N
+ " instance of ResultSetTableModel" // NOI18N
);
}
if(getModel() != null) {
getModel().removeTableModelListener(dataExchangedListener);
}
if(sorter != null) {
sorter.setModel((ResultSetTableModel) dataModel);
}
super.setModel(dataModel);
if(visibleColumns != null) {
visibleColumns.clear();
for(int i = 0; i < dataModel.getColumnCount(); i++) {
visibleColumns.add(i);
}
}
updateHeader();
dataModel.addTableModelListener(dataExchangedListener);
}
public Set<Integer> getVisibleColumns() {
return new HashSet<>(visibleColumns);
}
public void setVisibleColumns(Set<Integer> visibleColumns) {
this.visibleColumns.addAll(visibleColumns);
this.visibleColumns.retainAll(visibleColumns);
updateHeader();
}
@Override
public ResultSetTableModel getModel() {
return (ResultSetTableModel) super.getModel();
}
@SuppressWarnings("deprecation")
protected void setDefaultCellRenderers() {
setDefaultRenderer(Object.class, new ResultSetCellRenderer());
setDefaultRenderer(String.class, new ResultSetCellRenderer());
setDefaultRenderer(Number.class, new ResultSetCellRenderer());
setDefaultRenderer(Boolean.class, new ResultSetCellRenderer());
setDefaultRenderer(java.sql.Date.class, new ResultSetCellRenderer(ResultSetCellRenderer.Date_TO_STRING));
setDefaultRenderer(java.sql.Time.class, new ResultSetCellRenderer(ResultSetCellRenderer.TIME_TO_STRING));
setDefaultRenderer(java.sql.Timestamp.class, new ResultSetCellRenderer(ResultSetCellRenderer.DATETIME_TO_STRING));
setDefaultRenderer(java.util.Date.class, new ResultSetCellRenderer(ResultSetCellRenderer.DATETIME_TO_STRING));
}
protected void setDefaultCellEditors() {
KeyListener kl = createControKeyListener();
JTextField txtFld = new JTextField();
txtFld.addKeyListener(kl);
setDefaultEditor(Object.class, new StringTableCellEditor(txtFld));
setDefaultEditor(String.class, new StringTableCellEditor(txtFld));
setDefaultEditor(java.sql.Time.class, new StringTableCellEditor(txtFld));
setDefaultEditor(Blob.class, new BlobFieldTableCellEditor());
setDefaultEditor(Clob.class, new ClobFieldTableCellEditor());
JTextField numFld = new JTextField();
txtFld.addKeyListener(kl);
setDefaultEditor(Number.class, new NumberFieldEditor(numFld));
JCheckBox b = new JCheckBox();
b.addKeyListener(kl);
setDefaultEditor(Boolean.class, new BooleanTableCellEditor(b));
try {
DateTimePickerCellEditor dateEditor = new DateTimePickerCellEditor(new SimpleDateFormat (DateType.DEFAULT_FOMAT_PATTERN));
setDefaultEditor(java.sql.Date.class, dateEditor);
} catch (NullPointerException npe) {
mLogger.log(Level.WARNING, "While creating DatePickerCellEditor was thrown " + npe, npe);
}
try{
DateTimePickerCellEditor dateTimeEditor = new DateTimePickerCellEditor(new SimpleDateFormat (TimestampType.DEFAULT_FORMAT_PATTERN));
dateTimeEditor.addKeyListener(kl);
setDefaultEditor(Timestamp.class, dateTimeEditor);
setDefaultEditor(java.util.Date.class, dateTimeEditor);
} catch (NullPointerException npe) {
mLogger.log(Level.WARNING, "While creating DateTimePickerCellEditor was thrown " + npe, npe);
}
}
protected KeyListener createControKeyListener() {
return new KeyListener() {
@Override
public void keyTyped(KeyEvent arg0) {
}
@Override
public void keyPressed(KeyEvent arg0) {
}
@Override
public void keyReleased(KeyEvent arg0) {
}
};
}
protected void updateHeader() {
TableColumnModel dtcm = createDefaultColumnModel();
DBColumn[] columns = getModel().getColumns();
List<Integer> columnWidthList = getColumnWidthList(columns);
for (int i = 0; i < columns.length; i++) {
if(! (visibleColumns.isEmpty() || visibleColumns.contains(i))) {
continue;
}
TableColumn tc = new TableColumn(i);
tc.setPreferredWidth(columnWidthList.get(i));
DBColumn col = columns[i];
StringBuilder sb = new StringBuilder();
sb.append("<html>"); //NOI18N
if (col.getDisplayName() != null) {
sb.append(DataViewUtils.escapeHTML(col.getDisplayName()));
}
sb.append("</html>"); // NOI18N
tc.setHeaderValue(sb.toString());
tc.setIdentifier(col.getDisplayName() == null
? "COL_" + i : col.getDisplayName()); //NOI18N
dtcm.addColumn(tc);
}
setColumnModel(dtcm);
}
private List<Integer> getColumnWidthList(DBColumn[] columns) {
List<Integer> result = new ArrayList<>();
for (DBColumn col : columns) {
int fieldWidth = col.getDisplaySize();
int labelWidth = col.getDisplayName().length();
int colWidth = Math.max(fieldWidth, labelWidth) * multiplier;
if (colWidth < 5) {
colWidth = 15 * multiplier;
}
if (colWidth > MAX_COLUMN_WIDTH * multiplier) {
colWidth = MAX_COLUMN_WIDTH * multiplier;
}
result.add(colWidth);
}
return result;
}
@Override
public boolean isCellEditable(int row, int column) {
if (getCellEditor(row, column) instanceof AlwaysEnable) {
return true;
}
try {
if (getModel() != null) {
int modelRow = convertRowIndexToModel(row);
int modelColumn = convertColumnIndexToModel(column);
return getModel().isCellEditable(modelRow, modelColumn);
}
} catch (IndexOutOfBoundsException ex) {
// Swallow it silently - its unclear under which circumstances
// the problem happens, but in case an illegal row/column combination
// is requested its saver/saner to just mark cell as not editable
}
return false;
}
/**
* Quote string for use in TSV (tab-separated values file
*
* Assumptions: column separator is \t and row separator is \n
*/
protected String quoteIfNecessary(String value) {
if (value == null || value.isEmpty()) {
return "\"\""; //NOI18N
} else if (value.contains("\t") || value.contains("\n") //NOI18N
|| value.contains("\"")) { //NOI18N
return "\"" + value.replace("\"", "\"\"") + "\""; //NOI18N
} else {
return value;
}
}
/**
* Convert object to string representation
*
* @param o object to convert
* @param limitSize in case of CLOBs and BLOBs limit to limitSize
* bytes/chars
* @return string representation of o
*/
protected String convertToClipboardString(Object o, int limitSize) {
if (o instanceof Blob) {
Blob b = (Blob) o;
try {
if (b.length() <= limitSize) {
return BinaryToStringConverter.convertToString(
b.getBytes(1, (int) b.length()), 16, false);
}
} catch (SQLException ex) {
}
} else if (o instanceof Clob) {
Clob c = (Clob) o;
try {
if (c.length() <= limitSize) {
return c.getSubString(1, (int) c.length());
}
} catch (SQLException ex) {
}
} else if (o instanceof java.sql.Time) {
synchronized(timeFormat) {
return timeFormat.format((java.util.Date) o);
}
} else if (o instanceof java.sql.Date) {
synchronized(dateFormat) {
return dateFormat.format((java.util.Date) o);
}
} else if (o instanceof java.util.Date) {
synchronized(timestampFormat) {
return timestampFormat.format((java.util.Date) o);
}
} else if (o == null) {
return ""; //NOI18N
}
return o.toString();
}
/**
* Create TSV (tab-separated values) string from row data
*
* @param withHeader include column headers?
* @return Transferable for clipboard transfer
*/
private StringSelection createTransferableTSV(boolean withHeader) {
try {
int[] rows = getSelectedRows();
int[] columns;
if (getRowSelectionAllowed()) {
columns = new int[getColumnCount()];
for (int a = 0; a < columns.length; a++) {
columns[a] = a;
}
} else {
columns = getSelectedColumns();
}
if (rows != null && columns != null) {
StringBuilder output = new StringBuilder();
if (withHeader) {
for (int column = 0; column < columns.length; column++) {
if (column > 0) {
output.append('\t'); //NOI18N
}
Object o = getColumnModel().getColumn(column).
getIdentifier();
String s = o != null ? o.toString() : "";
output.append(quoteIfNecessary(s));
}
output.append('\n'); //NOI18N
}
for (int row = 0; row < rows.length; row++) {
for (int column = 0; column < columns.length; column++) {
if (column > 0) {
output.append('\t'); //NOI18N
}
Object o = getValueAt(rows[row], columns[column]);
// Limit 1 MB/1 Million Characters.
String s = convertToClipboardString(o, 1024 * 1024);
output.append(quoteIfNecessary(s));
}
output.append('\n'); //NOI18N
}
return new StringSelection(output.toString());
}
return null;
} catch (ArrayIndexOutOfBoundsException exc) {
Exceptions.printStackTrace(exc);
return null;
}
}
protected void copyRowValues(boolean withHeader) {
ExClipboard clipboard = Lookup.getDefault().lookup(ExClipboard.class);
StringSelection selection = createTransferableTSV(withHeader);
clipboard.setContents(selection, selection);
}
// This is mainly used for set Tooltip for column headers
private class JTableHeaderImpl extends JTableHeader {
public JTableHeaderImpl(TableColumnModel cm) {
super(cm);
}
@Override
public String getToolTipText(MouseEvent e) {
return getColumnToolTipText(e);
}
protected String getColumnToolTipText(MouseEvent e) {
java.awt.Point p = e.getPoint();
int index = columnModel.getColumnIndexAtX(p.x);
try {
int realIndex = columnModel.getColumn(index).getModelIndex();
ResultSetTableModel tm = getModel();
if (tm != null) {
return tm.getColumnTooltip(realIndex);
} else {
return "";
}
} catch (ArrayIndexOutOfBoundsException aio) {
return null;
}
}
}
private class TableTransferHandler extends TransferHandler
implements UIResource {
/**
* Map Transferable to createTransferableTSV from ResultSetJXTable
*
* This is needed so that CTRL-C Action of JTable gets the same
* treatment as the transfer via the copy Methods of DataTableUI
*/
@Override
protected Transferable createTransferable(JComponent c) {
return createTransferableTSV(false);
}
@Override
public int getSourceActions(JComponent c) {
return COPY;
}
}
private class EditingAwareAction extends AbstractAction {
private final Action delegate;
public EditingAwareAction(Action delegate) {
this.delegate = delegate;
}
@Override
public void actionPerformed(ActionEvent e) {
boolean editing = isEditing();
delegate.actionPerformed(e);
if (editing) {
editCellAt(getSelectedRow(), getSelectedColumn());
}
}
}
}
| 8,112 |
366 | <reponame>pulkomandy/thekla_atlas<filename>src/thekla/thekla_atlas.cpp
#include "thekla_atlas.h"
#include <cfloat>
#include "nvmesh/halfedge/Edge.h"
#include "nvmesh/halfedge/Mesh.h"
#include "nvmesh/halfedge/Face.h"
#include "nvmesh/halfedge/Vertex.h"
#include "nvmesh/param/Atlas.h"
#include "nvmath/Vector.inl"
#include "nvmath/ftoi.h"
#include "nvcore/Array.inl"
using namespace Thekla;
using namespace nv;
inline Atlas_Output_Mesh * set_error(Atlas_Error * error, Atlas_Error code) {
if (error) *error = code;
return NULL;
}
static void input_to_mesh(const Atlas_Input_Mesh * input, HalfEdge::Mesh * mesh, Atlas_Error * error) {
Array<uint> canonicalMap;
canonicalMap.reserve(input->vertex_count);
for (int i = 0; i < input->vertex_count; i++) {
const Atlas_Input_Vertex & input_vertex = input->vertex_array[i];
const float * pos = input_vertex.position;
const float * nor = input_vertex.normal;
const float * tex = input_vertex.uv;
HalfEdge::Vertex * vertex = mesh->addVertex(Vector3(pos[0], pos[1], pos[2]));
vertex->nor.set(nor[0], nor[1], nor[2]);
vertex->tex.set(tex[0], tex[1]);
canonicalMap.append(input_vertex.first_colocal);
}
mesh->linkColocalsWithCanonicalMap(canonicalMap);
const int face_count = input->face_count;
int non_manifold_faces = 0;
for (int i = 0; i < face_count; i++) {
const Atlas_Input_Face & input_face = input->face_array[i];
int v0 = input_face.vertex_index[0];
int v1 = input_face.vertex_index[1];
int v2 = input_face.vertex_index[2];
HalfEdge::Face * face = mesh->addFace(v0, v1, v2);
if (face != NULL) {
face->material = input_face.material_index;
}
else {
non_manifold_faces++;
}
}
mesh->linkBoundary();
if (non_manifold_faces != 0 && error != NULL) {
*error = Atlas_Error_Invalid_Mesh_Non_Manifold;
}
}
static Atlas_Output_Mesh * mesh_atlas_to_output(const HalfEdge::Mesh * mesh, const Atlas & atlas, Atlas_Error * error) {
Atlas_Output_Mesh * output = new Atlas_Output_Mesh;
const MeshCharts * charts = atlas.meshAt(0);
// Allocate vertices.
const int vertex_count = charts->vertexCount();
output->vertex_count = vertex_count;
output->vertex_array = new Atlas_Output_Vertex[vertex_count];
int w = 0;
int h = 0;
// Output vertices.
const int chart_count = charts->chartCount();
for (int i = 0; i < chart_count; i++) {
const Chart * chart = charts->chartAt(i);
uint vertexOffset = charts->vertexCountBeforeChartAt(i);
const uint chart_vertex_count = chart->vertexCount();
for (uint v = 0; v < chart_vertex_count; v++) {
Atlas_Output_Vertex & output_vertex = output->vertex_array[vertexOffset + v];
uint original_vertex = chart->mapChartVertexToOriginalVertex(v);
output_vertex.xref = original_vertex;
Vector2 uv = chart->chartMesh()->vertexAt(v)->tex;
output_vertex.uv[0] = uv.x;
output_vertex.uv[1] = uv.y;
w = max(w, ftoi_ceil(uv.x));
h = max(h, ftoi_ceil(uv.y));
}
}
const int face_count = mesh->faceCount();
output->index_count = face_count * 3;
output->index_array = new int[face_count * 3];
// Set face indices.
for (int f = 0; f < face_count; f++) {
uint c = charts->faceChartAt(f);
uint i = charts->faceIndexWithinChartAt(f);
uint vertexOffset = charts->vertexCountBeforeChartAt(c);
const Chart * chart = charts->chartAt(c);
nvDebugCheck(chart->faceAt(i) == f);
const HalfEdge::Face * face = chart->chartMesh()->faceAt(i);
const HalfEdge::Edge * edge = face->edge;
output->index_array[3*f+0] = vertexOffset + edge->vertex->id;
output->index_array[3*f+1] = vertexOffset + edge->next->vertex->id;
output->index_array[3*f+2] = vertexOffset + edge->next->next->vertex->id;
}
*error = Atlas_Error_Success;
output->atlas_width = w;
output->atlas_height = h;
return output;
}
void Thekla::atlas_set_default_options(Atlas_Options * options) {
if (options != NULL) {
// These are the default values we use on The Witness.
options->charter = Atlas_Charter_Default;
options->charter_options.witness.proxy_fit_metric_weight = 2.0f;
options->charter_options.witness.roundness_metric_weight = 0.01f;
options->charter_options.witness.straightness_metric_weight = 6.0f;
options->charter_options.witness.normal_seam_metric_weight = 4.0f;
options->charter_options.witness.texture_seam_metric_weight = 0.5f;
options->charter_options.witness.max_chart_area = FLT_MAX;
options->charter_options.witness.max_boundary_length = FLT_MAX;
options->mapper = Atlas_Mapper_Default;
options->packer = Atlas_Packer_Default;
options->packer_options.witness.packing_quality = 0;
options->packer_options.witness.texels_per_unit = 8;
options->packer_options.witness.block_align = true;
options->packer_options.witness.conservative = false;
}
}
Atlas_Output_Mesh * Thekla::atlas_generate(const Atlas_Input_Mesh * input, const Atlas_Options * options, Atlas_Error * error) {
*error = Atlas_Error_Success;
// Validate args.
if (input == NULL || options == NULL || error == NULL) return set_error(error, Atlas_Error_Invalid_Args);
// Validate options.
if (options->charter != Atlas_Charter_Witness && options->charter != Atlas_Charter_Extract) {
return set_error(error, Atlas_Error_Invalid_Options);
}
if (options->charter == Atlas_Charter_Witness) {
// @@ Validate input options!
}
if (options->mapper != Atlas_Mapper_LSCM) {
return set_error(error, Atlas_Error_Invalid_Options);
}
if (options->mapper == Atlas_Mapper_LSCM) {
// No options.
}
if (options->packer != Atlas_Packer_Witness) {
return set_error(error, Atlas_Error_Invalid_Options);
}
if (options->packer == Atlas_Packer_Witness) {
// @@ Validate input options!
}
// Validate input mesh.
for (int i = 0; i < input->face_count; i++) {
int v0 = input->face_array[i].vertex_index[0];
int v1 = input->face_array[i].vertex_index[1];
int v2 = input->face_array[i].vertex_index[2];
if (v0 < 0 || v0 >= input->vertex_count ||
v1 < 0 || v1 >= input->vertex_count ||
v2 < 0 || v2 >= input->vertex_count)
{
return set_error(error, Atlas_Error_Invalid_Mesh);
}
}
// Build half edge mesh.
AutoPtr<HalfEdge::Mesh> mesh(new HalfEdge::Mesh);
input_to_mesh(input, mesh.ptr(), error);
if (*error != Atlas_Error_Success) {
return NULL;
}
Atlas atlas;
// Charter.
if (options->charter == Atlas_Charter_Extract) {
// Let's only care about the chart topology if we have to run the LSCM mapper from scratch
bool ensure_disk_charts = options->mapper_options.preserve_uvs == false || options->mapper_options.preserve_boundary == false;
atlas.extractCharts(mesh.ptr(), ensure_disk_charts);
}
else if (options->charter == Atlas_Charter_Witness) {
SegmentationSettings segmentation_settings;
segmentation_settings.proxyFitMetricWeight = options->charter_options.witness.proxy_fit_metric_weight;
segmentation_settings.roundnessMetricWeight = options->charter_options.witness.roundness_metric_weight;
segmentation_settings.straightnessMetricWeight = options->charter_options.witness.straightness_metric_weight;
segmentation_settings.normalSeamMetricWeight = options->charter_options.witness.normal_seam_metric_weight;
segmentation_settings.textureSeamMetricWeight = options->charter_options.witness.texture_seam_metric_weight;
segmentation_settings.maxChartArea = options->charter_options.witness.max_chart_area;
segmentation_settings.maxBoundaryLength = options->charter_options.witness.max_boundary_length;
Array<uint> uncharted_materials;
atlas.computeCharts(mesh.ptr(), segmentation_settings, uncharted_materials);
}
// Mapper.
if (options->mapper == Atlas_Mapper_LSCM) {
atlas.parameterizeCharts(options->mapper_options.preserve_uvs, options->mapper_options.preserve_boundary);
}
// Packer.
if (options->packer == Atlas_Packer_Witness) {
int packing_quality = options->packer_options.witness.packing_quality;
float texels_per_unit = options->packer_options.witness.texels_per_unit;
bool block_align = options->packer_options.witness.block_align;
bool conservative = options->packer_options.witness.conservative;
/*float utilization =*/ atlas.packCharts(packing_quality, texels_per_unit, block_align, conservative);
}
// Build output mesh.
return mesh_atlas_to_output(mesh.ptr(), atlas, error);
}
void Thekla::atlas_free(Atlas_Output_Mesh * output) {
if (output != NULL) {
delete [] output->vertex_array;
delete [] output->index_array;
delete output;
}
}
typedef void Atlas_Debug_Output(const char * output);
void Thekla::atlas_set_debug_output(Atlas_Debug_Output * output) {
// @@
}
| 3,875 |
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 CHROME_BROWSER_EXTENSIONS_API_SEARCH_SEARCH_API_H_
#define CHROME_BROWSER_EXTENSIONS_API_SEARCH_SEARCH_API_H_
#include "extensions/browser/extension_function.h"
namespace extensions {
class SearchQueryFunction : public ExtensionFunction {
public:
DECLARE_EXTENSION_FUNCTION("search.query", SEARCH_QUERY)
SearchQueryFunction() = default;
private:
~SearchQueryFunction() override = default;
ResponseAction Run() override;
};
} // namespace extensions
#endif // CHROME_BROWSER_EXTENSIONS_API_SEARCH_SEARCH_API_H_
| 226 |
994 | def answer(a, b):
a ^= b
b ^= a
a ^= b
return a, b
| 40 |
30,023 | <gh_stars>1000+
"""Utils needed for Google Hangouts."""
from hangups import CredentialsPrompt, GoogleAuthError, RefreshTokenCache
class Google2FAError(GoogleAuthError):
"""A Google authentication request failed."""
class HangoutsCredentials(CredentialsPrompt):
"""Google account credentials.
This implementation gets the user data as params.
"""
def __init__(self, email, password, pin=None, auth_code=None):
"""Google account credentials.
:param email: Google account email address.
:param password: Google account password.
:param pin: Google account verification code.
"""
self._email = email
self._password = password
self._pin = pin
self._auth_code = auth_code
def get_email(self):
"""Return email.
:return: Google account email address.
"""
return self._email
def get_password(self):
"""Return password.
:return: Google account password.
"""
return self._password
def get_verification_code(self):
"""Return the verification code.
:return: Google account verification code.
"""
if self._pin is None:
raise Google2FAError()
return self._pin
def set_verification_code(self, pin):
"""Set the verification code.
:param pin: Google account verification code.
"""
self._pin = pin
def get_authorization_code(self):
"""Return the oauth authorization code.
:return: Google oauth code.
"""
return self._auth_code
def set_authorization_code(self, code):
"""Set the google oauth authorization code.
:param code: Oauth code returned after authentication with google.
"""
self._auth_code = code
class HangoutsRefreshToken(RefreshTokenCache):
"""Memory-based cache for refresh token."""
def __init__(self, token):
"""Memory-based cache for refresh token.
:param token: Initial refresh token.
"""
super().__init__("")
self._token = token
def get(self):
"""Get cached refresh token.
:return: Cached refresh token.
"""
return self._token
def set(self, refresh_token):
"""Cache a refresh token.
:param refresh_token: Refresh token to cache.
"""
self._token = refresh_token
| 932 |
511 | // Generated by the protocol buffer compiler. DO NOT EDIT!
// source: google/protobuf/unittest_lazy_dependencies_enum.proto
#ifndef PROTOBUF_google_2fprotobuf_2funittest_5flazy_5fdependencies_5fenum_2eproto__INCLUDED
#define PROTOBUF_google_2fprotobuf_2funittest_5flazy_5fdependencies_5fenum_2eproto__INCLUDED
#include <string>
#include <google/protobuf/stubs/common.h>
#if GOOGLE_PROTOBUF_VERSION < 3005000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata.h>
#include <google/protobuf/repeated_field.h> // IWYU pragma: export
#include <google/protobuf/extension_set.h> // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
// @@protoc_insertion_point(includes)
namespace protobuf_google_2fprotobuf_2funittest_5flazy_5fdependencies_5fenum_2eproto {
// Internal implementation detail -- do not use these members.
struct TableStruct {
static const ::google::protobuf::internal::ParseTableField entries[];
static const ::google::protobuf::internal::AuxillaryParseTableField aux[];
static const ::google::protobuf::internal::ParseTable schema[1];
static const ::google::protobuf::internal::FieldMetadata field_metadata[];
static const ::google::protobuf::internal::SerializationTable serialization_table[];
static const ::google::protobuf::uint32 offsets[];
};
void AddDescriptors();
inline void InitDefaults() {
}
} // namespace protobuf_google_2fprotobuf_2funittest_5flazy_5fdependencies_5fenum_2eproto
namespace protobuf_unittest {
namespace lazy_imports {
} // namespace lazy_imports
} // namespace protobuf_unittest
namespace protobuf_unittest {
namespace lazy_imports {
enum LazyEnum {
LAZY_ENUM_0 = 0,
LAZY_ENUM_1 = 1
};
bool LazyEnum_IsValid(int value);
const LazyEnum LazyEnum_MIN = LAZY_ENUM_0;
const LazyEnum LazyEnum_MAX = LAZY_ENUM_1;
const int LazyEnum_ARRAYSIZE = LazyEnum_MAX + 1;
const ::google::protobuf::EnumDescriptor* LazyEnum_descriptor();
inline const ::std::string& LazyEnum_Name(LazyEnum value) {
return ::google::protobuf::internal::NameOfEnum(
LazyEnum_descriptor(), value);
}
inline bool LazyEnum_Parse(
const ::std::string& name, LazyEnum* value) {
return ::google::protobuf::internal::ParseNamedEnum<LazyEnum>(
LazyEnum_descriptor(), name, value);
}
// ===================================================================
// ===================================================================
// ===================================================================
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif // __GNUC__
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif // __GNUC__
// @@protoc_insertion_point(namespace_scope)
} // namespace lazy_imports
} // namespace protobuf_unittest
namespace google {
namespace protobuf {
template <> struct is_proto_enum< ::protobuf_unittest::lazy_imports::LazyEnum> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::protobuf_unittest::lazy_imports::LazyEnum>() {
return ::protobuf_unittest::lazy_imports::LazyEnum_descriptor();
}
} // namespace protobuf
} // namespace google
// @@protoc_insertion_point(global_scope)
#endif // PROTOBUF_google_2fprotobuf_2funittest_5flazy_5fdependencies_5fenum_2eproto__INCLUDED
| 1,355 |
32,544 | <gh_stars>1000+
package com.baeldung.hibernate.pojo;
import javax.persistence.*;
import java.io.Serializable;
import java.sql.Date;
import java.sql.Time;
import java.sql.Timestamp;
import java.time.*;
import java.util.Calendar;
@Entity
public class TemporalValues implements Serializable {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private long id;
@Basic
private java.sql.Date sqlDate;
@Basic
private java.sql.Time sqlTime;
@Basic
private java.sql.Timestamp sqlTimestamp;
@Basic
@Temporal(TemporalType.DATE)
private java.util.Date utilDate;
@Basic
@Temporal(TemporalType.TIME)
private java.util.Date utilTime;
@Basic
@Temporal(TemporalType.TIMESTAMP)
private java.util.Date utilTimestamp;
@Basic
@Temporal(TemporalType.DATE)
private java.util.Calendar calendarDate;
@Basic
@Temporal(TemporalType.TIMESTAMP)
private java.util.Calendar calendarTimestamp;
@Basic
private java.time.LocalDate localDate;
@Basic
private java.time.LocalTime localTime;
@Basic
private java.time.OffsetTime offsetTime;
@Basic
private java.time.Instant instant;
@Basic
private java.time.LocalDateTime localDateTime;
@Basic
private java.time.OffsetDateTime offsetDateTime;
@Basic
private java.time.ZonedDateTime zonedDateTime;
public long getId() {
return id;
}
public void setId(long id) {
this.id = id;
}
public Date getSqlDate() {
return sqlDate;
}
public void setSqlDate(Date sqlDate) {
this.sqlDate = sqlDate;
}
public Time getSqlTime() {
return sqlTime;
}
public void setSqlTime(Time sqlTime) {
this.sqlTime = sqlTime;
}
public Timestamp getSqlTimestamp() {
return sqlTimestamp;
}
public void setSqlTimestamp(Timestamp sqlTimestamp) {
this.sqlTimestamp = sqlTimestamp;
}
public java.util.Date getUtilDate() {
return utilDate;
}
public void setUtilDate(java.util.Date utilDate) {
this.utilDate = utilDate;
}
public java.util.Date getUtilTime() {
return utilTime;
}
public void setUtilTime(java.util.Date utilTime) {
this.utilTime = utilTime;
}
public java.util.Date getUtilTimestamp() {
return utilTimestamp;
}
public void setUtilTimestamp(java.util.Date utilTimestamp) {
this.utilTimestamp = utilTimestamp;
}
public Calendar getCalendarDate() {
return calendarDate;
}
public void setCalendarDate(Calendar calendarDate) {
this.calendarDate = calendarDate;
}
public Calendar getCalendarTimestamp() {
return calendarTimestamp;
}
public void setCalendarTimestamp(Calendar calendarTimestamp) {
this.calendarTimestamp = calendarTimestamp;
}
public LocalDate getLocalDate() {
return localDate;
}
public void setLocalDate(LocalDate localDate) {
this.localDate = localDate;
}
public LocalTime getLocalTime() {
return localTime;
}
public void setLocalTime(LocalTime localTime) {
this.localTime = localTime;
}
public OffsetTime getOffsetTime() {
return offsetTime;
}
public void setOffsetTime(OffsetTime offsetTime) {
this.offsetTime = offsetTime;
}
public Instant getInstant() {
return instant;
}
public void setInstant(Instant instant) {
this.instant = instant;
}
public LocalDateTime getLocalDateTime() {
return localDateTime;
}
public void setLocalDateTime(LocalDateTime localDateTime) {
this.localDateTime = localDateTime;
}
public OffsetDateTime getOffsetDateTime() {
return offsetDateTime;
}
public void setOffsetDateTime(OffsetDateTime offsetDateTime) {
this.offsetDateTime = offsetDateTime;
}
public ZonedDateTime getZonedDateTime() {
return zonedDateTime;
}
public void setZonedDateTime(ZonedDateTime zonedDateTime) {
this.zonedDateTime = zonedDateTime;
}
}
| 1,639 |
4,816 | <gh_stars>1000+
/**
* @file include/retdec/llvmir2hll/semantics/semantics/win_api_semantics/get_name_of_param/t.h
* @brief Initializes FuncParamNamesMap for WinAPI functions starting with T.
* @copyright (c) 2017 Avast Software, licensed under the MIT license
*/
#ifndef RETDEC_LLVMIR2HLL_SEMANTICS_SEMANTICS_WIN_API_SEMANTICS_GET_NAME_OF_PARAM_T_H
#define RETDEC_LLVMIR2HLL_SEMANTICS_SEMANTICS_WIN_API_SEMANTICS_GET_NAME_OF_PARAM_T_H
#include "retdec/llvmir2hll/semantics/semantics/impl_support/get_name_of_param.h"
namespace retdec {
namespace llvmir2hll {
namespace semantics {
namespace win_api {
void initFuncParamNamesMap_T(FuncParamNamesMap &funcParamNamesMap);
} // namespace win_api
} // namespace semantics
} // namespace llvmir2hll
} // namespace retdec
#endif
| 301 |
977 | package io.leangen.graphql.metadata.strategy.query;
import io.leangen.graphql.util.ClassUtils;
import io.leangen.graphql.util.Utils;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.List;
import java.util.Optional;
public class PropertyOperationInfoGenerator extends AnnotatedOperationInfoGenerator {
@Override
public String name(OperationInfoGeneratorParams params) {
List<AnnotatedElement> elements = params.getElement().getElements();
Optional<String> field = Utils.extractInstances(elements, Field.class).findFirst().map(Field::getName);
Optional<String> getter = Utils.extractInstances(elements, Method.class).findFirst().map(ClassUtils::getFieldNameFromGetter);
return Utils.coalesce(super.name(params), Utils.or(field, getter).orElse(null));
}
}
| 298 |
785 | /*
* Copyright © 2020 Apple Inc. and the ServiceTalk project authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package io.servicetalk.benchmark.concurrent;
import io.servicetalk.concurrent.PublisherSource.Subscription;
import io.servicetalk.concurrent.internal.ConcurrentSubscription;
import org.openjdk.jmh.annotations.Benchmark;
import org.openjdk.jmh.annotations.BenchmarkMode;
import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.Group;
import org.openjdk.jmh.annotations.GroupThreads;
import org.openjdk.jmh.annotations.Measurement;
import org.openjdk.jmh.annotations.Mode;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.annotations.Warmup;
@Fork(value = 1)
@State(Scope.Benchmark)
@Warmup(iterations = 5, time = 3)
@Measurement(iterations = 5, time = 3)
@BenchmarkMode(Mode.Throughput)
public class ConcurrentSubscriptionBenchmark {
private final InnerSubscription innerSubscription = new InnerSubscription();
private final Subscription subscription = ConcurrentSubscription.wrap(innerSubscription);
@Benchmark
public long singleThread() {
subscription.request(1);
return innerSubscription.requestN;
}
@Group("multiThread")
@GroupThreads(2)
@Benchmark
public long multiThread() {
subscription.request(1);
return innerSubscription.requestN;
}
private static final class InnerSubscription implements Subscription {
private long requestN;
@Override
public void request(final long n) {
requestN += n;
}
@Override
public void cancel() {
}
}
}
| 744 |
435 | <gh_stars>100-1000
{
"copyright_text": null,
"description": "In the past it was simpler and easier to think of building websites\nexclusively for desktop monitors capable of showing 1024x768 pixels,\nsitting on the desk of a non-impaired, English-speaking person. But\ntoday we need to embrace a much broader range of users. And one part of\nthis is designing sites for the visually impaired.\n\nThere are automatic checkers that you can use to assess your site\u2019s\naccessibility. It will tell you that all your images need an alt tag,\nand that the H2 should come after the H1. This is a good start, but even\nif you dot all your i\u2019s and cross all your t\u2019s and get 100% pass, your\nsite may be an unnavigable mess in practice.\n\nIn this talk we will look at and *listen to* real world examples of\nwebsites that either pass or fail the accessibility test. We will hear\nanecdotes from actual visually impaired users and discover how they\nnavigate the web. And we will see that even though frameworks like\nDjango can set us up for success, it\u2019s up to us as developers to follow\nthrough.\n",
"duration": 1472,
"language": "eng",
"recorded": "2018-10-17",
"related_urls": [
{
"label": "Conference schedule",
"url": "https://2018.djangocon.us/schedule/"
},
{
"label": "slides",
"url": "https://drive.google.com/file/d/1QhA-Yuw_ZJZEYwZayCcXa-PUQFK4oRe8/view"
}
],
"speakers": [
"<NAME>"
],
"tags": [],
"thumbnail_url": "https://i.ytimg.com/vi/urY3sBXtcP0/maxresdefault.jpg",
"title": "Real Life Accessibility: Have you HEARD your site?",
"videos": [
{
"type": "youtube",
"url": "https://www.youtube.com/watch?v=urY3sBXtcP0"
}
]
}
| 609 |
2,542 | <filename>src/prod/ktl/src/tools/tests/KAsyncContext.cpp
#include "../kasynccontext/KAsyncContextTests.cpp"
| 42 |
1,056 | /*
* 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.netbeans.modules.junit.api;
import org.netbeans.modules.java.testrunner.JavaRegexpUtils;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import junit.framework.TestCase;
/**
*
* @author <NAME>
*/
public class RegexpUtilsTest extends TestCase {
private final Field instRefField;
private final Method methodSpecialTrim;
private JavaRegexpUtils inst;
public RegexpUtilsTest(String testName) throws NoSuchFieldException,
NoSuchMethodException {
super(testName);
instRefField = JavaRegexpUtils.class.getDeclaredField("instRef");
instRefField.setAccessible(true);
methodSpecialTrim = JavaRegexpUtils.class.getDeclaredMethod(
"specialTrim",
new Class[] {String.class});
methodSpecialTrim.setAccessible(true);
}
@Override
public void setUp() throws IllegalAccessException {
instRefField.set(null, null);
inst = JavaRegexpUtils.getInstance();
}
public void testParseTimeMillis() {
assertEquals(0, inst.parseTimeMillis("0"));
assertEquals(0, inst.parseTimeMillis("00"));
assertEquals(1234000, inst.parseTimeMillis("1234"));
assertEquals(1234500, inst.parseTimeMillis("1234.5"));
assertEquals(1234560, inst.parseTimeMillis("1234.56"));
assertEquals(1234567, inst.parseTimeMillis("1234.567"));
assertEquals(1234567, inst.parseTimeMillis("1234.5670"));
assertEquals(1234567, inst.parseTimeMillis("1234.5671"));
assertEquals(1234567, inst.parseTimeMillis("1234.5674"));
assertEquals(1234568, inst.parseTimeMillis("1234.5675"));
assertEquals(1234568, inst.parseTimeMillis("1234.5676"));
assertEquals(1234568, inst.parseTimeMillis("1234.56764"));
assertEquals(1234568, inst.parseTimeMillis("1234.56766"));
assertEquals(500, inst.parseTimeMillis(".5"));
assertEquals(560, inst.parseTimeMillis(".56"));
assertEquals(567, inst.parseTimeMillis(".567"));
assertEquals(567, inst.parseTimeMillis(".5670"));
assertEquals(567, inst.parseTimeMillis(".5671"));
assertEquals(567, inst.parseTimeMillis(".5674"));
assertEquals(568, inst.parseTimeMillis(".5675"));
assertEquals(568, inst.parseTimeMillis(".5676"));
}
public void testTimeSecsRegex() throws Exception {
Pattern pattern = getPattern("SECONDS_REGEX");
final String[] matchingStrings = new String[] {
"s",
"sec",
"secs",
"sec(s)",
"second",
"seconds",
"second(s)",
};
final String[] nonMatchingStrings = new String[] {
"ss",
"s(s)",
"secss",
"secs(s)",
"secondss",
"seconds(s)"
};
for (int i = 0; i < matchingStrings.length; i++) {
String string = matchingStrings[i];
assertTrue("should match: " + string,
pattern.matcher(string).matches());
}
for (int i = 0; i < nonMatchingStrings.length; i++) {
String string = nonMatchingStrings[i];
assertFalse("should not match: " + string,
pattern.matcher(string).matches());
}
}
public void testTestcaseIssueRegex() throws Exception {
Pattern pattern = getPattern("TESTCASE_ISSUE_REGEX");
final String[] matchingStrings = new String[] {
"FAILED",
"Caused an ERROR",
"error",
" FAILED",
"\t \t FAILED",
" \t \tFAILED",
"\t \t FAILED ",
" \t \tFAILED ",
"xxxxx ErRoR yyy"
};
final String[] nonMatchingStrings = new String[] {
"failed",
"Failed",
"x FAILED",
"xFAILED",
"FAILEDx",
"mistakeerror",
"mistake errors",
};
for (int i = 0; i < matchingStrings.length; i++) {
String string = matchingStrings[i];
assertTrue("should match: " + string,
pattern.matcher(string).matches());
}
for (int i = 0; i < nonMatchingStrings.length; i++) {
String string = nonMatchingStrings[i];
assertFalse("should not match: " + string,
pattern.matcher(string).matches());
}
}
public void testTestsuiteStatsRegex() throws Exception {
Pattern pattern = getPattern("TESTSUITE_STATS_REGEX");
String[] matchingStrings = new String[] {
"Tests run: 1, Failures: 0, Errors: 0, Time elapsed: 0.066 sec",
};
String[] nonMatchingStrings = new String[] {
"Tests run: 1, Failures: 0, Errors: 0, Time elapse: 0.066 sec",
};
for (int i = 0; i < matchingStrings.length; i++) {
String string = matchingStrings[i];
Matcher matcher = pattern.matcher(string);
assertTrue("should match: " + string, matcher.matches());
assertTrue("matcher.group(4) should be durationn of test", matcher.group(4).trim().equals("0.066"));
}
for (int i = 0; i < nonMatchingStrings.length; i++) {
String string = nonMatchingStrings[i];
assertFalse("should not match: " + string,
pattern.matcher(string).matches());
}
pattern = getPattern("TESTSUITE_STATS_190_REGEX");
matchingStrings = new String[] {
"Tests run: 1, Failures: 0, Errors: 0, Skipped: 1, Time elapsed: 0.066 sec",
};
nonMatchingStrings = new String[] {
"Tests run: 1, Failures: 0, Errors: 0, Skippe: 1, Time elapsed: 0.066 sec",
};
for (int i = 0; i < matchingStrings.length; i++) {
String string = matchingStrings[i];
Matcher matcher = pattern.matcher(string);
assertTrue("should match: " + string, matcher.matches());
assertTrue("matcher.group(6) should be durationn of test", matcher.group(6).trim().equals("0.066"));
}
for (int i = 0; i < nonMatchingStrings.length; i++) {
String string = nonMatchingStrings[i];
assertFalse("should not match: " + string,
pattern.matcher(string).matches());
}
}
public void testTestcaseHeaderPlainRegex() throws Exception {
Pattern pattern = getPattern("TESTCASE_HEADER_PLAIN_REGEX");
final String[] matchingStrings = new String[] {
"testComputeSum took 0.002 sec",
"testComputeSum took 0 sec",
"testComputeSum took 0.002 s",
" testComputeSum took 0.002 sec",
" testComputeSum took 0.002 sec",
"\ttestComputeSum took 0.002 sec",
"\t\t\testComputeSum took 0.002 sec",
" \t\t testComputeSum took 0.002 sec",
"\t\t testComputeSum took 0.002 sec",
"test took 12 seconds",
"test\ttook 12 seconds",
"test\t\ttook .5 seconds",
"test\t took .5 seconds",
"test took .5 seconds",
"test12 took 12 secs"
};
final String[] nonMatchingStrings = new String[] {
"12test took 12 seconds",
"test tooks",
"test took3 seconds",
"test took 3 bflmpsvz",
};
for (int i = 0; i < matchingStrings.length; i++) {
String string = matchingStrings[i];
assertTrue("should match: " + string,
pattern.matcher(string).matches());
}
for (int i = 0; i < nonMatchingStrings.length; i++) {
String string = nonMatchingStrings[i];
assertFalse("should not match: " + string,
pattern.matcher(string).matches());
}
}
public void testTestcaseHeaderBriefRegex() throws Exception {
Pattern pattern = getPattern("TESTCASE_HEADER_BRIEF_REGEX");
final String[] matchingStrings = new String[] {
"testMain(javapplication2.MainTest): FAILED",
"testMain(javapplication2.MainTest): Caused an ERROR",
"testMain(MainTest): FAILED",
" testMain(javapplication2.MainTest): FAILED",
"testMain(javapplication2.MainTest) :FAILED",
"testMain(javapplication2.MainTest) : FAILED",
"testMain(javapplication2.MainTest): mistake error"
};
final String[] nonMatchingStrings = new String[] {
"testMain(javapplication2.MainTest)",
"(javapplication2.MainTest): FAILED",
"testMain(javapplication2.MainTest): Failed",
"testMain(javapplication2.MainTest): mistake",
"testMain(javapplication2.MainTest): errors",
"testMain(javapplication2.MainTest): mistakeerror",
"testMain(javapplication2.MainTest): mistake errors",
"testMain(javapplication2.): FAILED",
"testMain(.MainTest): FAILED",
"testMain(javapplication2..MainTest): FAILED",
"testMain(2.MainTest): FAILED",
"testMain(javapplication2.2): FAILED"
};
for (int i = 0; i < matchingStrings.length; i++) {
String string = matchingStrings[i];
assertTrue("should match: " + string,
pattern.matcher(string).matches());
}
for (int i = 0; i < nonMatchingStrings.length; i++) {
String string = nonMatchingStrings[i];
assertFalse("should not match: " + string,
pattern.matcher(string).matches());
}
}
public void testTestcaseExceptionRegex() throws Exception {
Pattern pattern = getPattern("TESTCASE_EXCEPTION_REGEX");
final String[] matchingStrings = new String[] {
"junit.framework.AssertionFailedException",
"junit.framework.AssertionFailedException: The test case is empty.",
"java.lang.NullPointerException",
"java.lang.Exception",
"java.lang.Throwable",
"MySpecialException",
"MySpecialError",
"foo.Exception",
"foo.Error",
"foo.bar.Exception",
"foo.bar.Error" };
final String[] nonMatchingStrings = new String[] {
"Exception",
"Error",
"Throwable",
"mypackage.Throwable",
"foo.bar.Throwable",
".foo",
".Exception",
".Error",
".foo.Exception",
".foo.Error",
"Exception.",
"Error.",
"foo.Exception.",
"foo.Error.",
"foo.bar.Exception.",
"foo.bar.Error.",
"foo..bar.Exception",
"foo..bar.Error",
"junit.framework.AssertionFailedException It failed" };
for (int i = 0; i < matchingStrings.length; i++) {
String string = matchingStrings[i];
assertTrue("should match: " + string,
pattern.matcher(string).matches());
}
for (int i = 0; i < nonMatchingStrings.length; i++) {
String string = nonMatchingStrings[i];
assertFalse("should not match: " + string,
pattern.matcher(string).matches());
}
Matcher matcher;
matcher = pattern.matcher("java.lang.NullPointerException");
assertTrue(matcher.matches());
assertEquals("java.lang.NullPointerException", matcher.group(1));
assertNull(matcher.group(2));
matcher = pattern.matcher("java.lang.NullPointerException:");
assertTrue(matcher.matches());
assertEquals("java.lang.NullPointerException", matcher.group(1));
assertEquals("", matcher.group(2));
matcher = pattern.matcher("java.lang.NullPointerException : Failed");
assertTrue(matcher.matches());
assertEquals("java.lang.NullPointerException", matcher.group(1));
assertEquals("Failed", matcher.group(2));
}
public void testCallstackLineRegex() throws Exception{
Pattern pattern = getPattern("CALLSTACK_LINE_REGEX");
final String[] matchingStrings = new String[] {
" at javaapplication.MainTest.test",
" at javaapplication.MainTest.test",
" at javaapplication.MainTest.test",
"\tat javaapplication.MainTest.test",
"\t\tat javaapplication.MainTest.test",
"[catch] at javaapplication.MainTest.test",
" [catch] at javaapplication.MainTest.test",
" [catch] at javaapplication.MainTest.test",
" [catch] at javaapplication.MainTest.test",
"\t[catch] at javaapplication.MainTest.test",
"\t [catch] at javaapplication.MainTest.test",
" \t[catch] at javaapplication.MainTest.test",
"\t [catch] at javaapplication.MainTest.test",
" \t [catch] at javaapplication.MainTest.test",
" \t[catch] at javaapplication.MainTest.test",
"\t [catch] at javaapplication.MainTest.test",
" \t [catch] at javaapplication.MainTest.test",
" \t [catch] at javaapplication.MainTest.test",
" \t[catch] at javaapplication.MainTest.test",
" at MainTest.test",
" at javaapplication.MainTest.test(a)",
" at javaapplication.MainTest.test (a)",
" at javaapplication.MainTest.test (Compiled)",
" at javaapplication.MainTest.test (Native method)",
" at javaapplication.MainTest.test (MainTest.java)",
" at javaapplication.MainTest.test (MainTest.java:32)",
" at javaapplication.MainTest.test(MainTest.java:32)"
};
final String[] nonMatchingStrings = new String[] {
"javaapplication.MainTest.test",
" javaapplication.MainTest.test",
"at javaapplication.MainTest.test",
" at javaapplication.MainTest.test",
" at javaapplication.MainTest.test",
"\t at javaapplication.MainTest.test",
" \tat javaapplication.MainTest.test",
"\t at javaapplication.MainTest.test",
" \t at javaapplication.MainTest.test",
" \tat javaapplication.MainTest.test",
"\t\t at javaapplication.MainTest.test",
"\t \tat javaapplication.MainTest.test",
" \t\tat javaapplication.MainTest.test",
"\t\t at javaapplication.MainTest.test",
"\t \t at javaapplication.MainTest.test",
"\t \tat javaapplication.MainTest.test",
" \t\t at javaapplication.MainTest.test",
" \t \tat javaapplication.MainTest.test",
" \t\tat javaapplication.MainTest.test",
"\t\t[catch] at javaapplication.MainTest.test",
" \t\t[catch] at javaapplication.MainTest.test",
"\t \t[catch] at javaapplication.MainTest.test",
"\t\t [catch] at javaapplication.MainTest.test",
" at test",
" at javaapplication.%dfsd",
" at 2application.MainTest",
" at javaapplication.MainTest.test()",
" at javaapplication.MainTest.test ()",
" at javaapplication.MainTest.test (a)",
" at javaapplication.MainTest.test xyz",
" at javaapplication.MainTest.test (abc) x",
" at javaapplication.MainTest.test (abc) (de)",
" at javaapplication.MainTest.test (ab(cd)",
" at javaapplication.MainTest.test (ab)cd)",
" at javaapplication.MainTest.test (ab(cd))"
};
for (int i = 0; i < matchingStrings.length; i++) {
String string = matchingStrings[i];
assertTrue("should match: " + string,
pattern.matcher(string).matches());
}
for (int i = 0; i < nonMatchingStrings.length; i++) {
String string = nonMatchingStrings[i];
assertFalse("should not match: " + string,
pattern.matcher(string).matches());
}
}
public void testXmlDeclRegex() throws Exception {
Pattern pattern = getPattern("XML_DECL_REGEX");
final String[] matchingStrings = new String[] {
"<?xml version=\"1.0\"?>",
"<?xml version=\"1.0\"?>",
"<?xml\tversion=\"1.0\"?>",
"<?xml\t\t version=\"1.0\"?>",
"<?xml version =\"1.0\"?>",
"<?xml version =\"1.0\"?>",
"<?xml version= \"1.0\"?>",
"<?xml version= \"1.0\"?>",
"<?xml version = \"1.0\"?>",
"<?xml version \t=\t \"1.0\"?>",
"<?xml version=\"1.0\" encoding=\"abc\"?>",
"<?xml version=\"1.0\" encoding=\'abc\'?>",
"<?xml version=\"1.0\"\tencoding=\"abc\"?>",
"<?xml version=\"1.0\" encoding=\"abc\"?>",
"<?xml version=\"1.0\"\t\tencoding=\"abc\"?>",
"<?xml version=\"1.0\" \tencoding=\"abc\"?>",
"<?xml version=\"1.0\"\t encoding=\"abc\"?>",
"<?xml version=\"1.0\" encoding =\"abc\"?>",
"<?xml version=\"1.0\" encoding= \"abc\"?>",
"<?xml version=\"1.0\" encoding\t=\t\"abc\"?>",
"<?xml version=\"1.0\" encoding\t = \t\"abc\"?>",
"<?xml version=\"1.0\" encoding=\"ab1c\"?>",
"<?xml version=\"1.0\" encoding=\"ab.c\"?>",
"<?xml version=\"1.0\" encoding=\"ab_c\"?>",
"<?xml version=\"1.0\" encoding=\"ab-c\"?>",
"<?xml version=\"1.0\" standalone=\"yes\"?>",
"<?xml version=\"1.0\" standalone=\'yes\'?>",
"<?xml version=\"1.0\" standalone=\"no\"?>",
"<?xml version=\"1.0\" standalone=\'no\'?>",
"<?xml version=\"1.0\"\tstandalone=\"yes\"?>",
"<?xml version=\"1.0\" standalone=\"yes\"?>",
"<?xml version=\"1.0\"\t\tstandalone=\"yes\"?>",
"<?xml version=\"1.0\" \tstandalone=\"yes\"?>",
"<?xml version=\"1.0\"\t standalone=\"yes\"?>",
"<?xml version=\"1.0\" standalone =\"yes\"?>",
"<?xml version=\"1.0\" standalone= \"yes\"?>",
"<?xml version=\"1.0\" standalone\t=\t\"yes\"?>",
"<?xml version=\"1.0\" standalone\t = \t\"yes\"?>",
"<?xml version=\"1.0\" encoding=\"abc\" standalone=\"yes\"?>",
"<?xml version=\"1.0\" encoding=\"abc\" standalone=\'yes\'?>",
"<?xml version=\"1.0\" encoding=\'abc\' standalone=\"yes\"?>",
"<?xml version=\"1.0\" encoding=\'abc\' standalone=\'yes\'?>",
"<?xml version=\"1.0\" encoding=\"abc\" standalone=\"yes\" ?>",
"<?xml version=\"1.0\" encoding=\"abc\" standalone=\"yes\"\t?>"
};
final String[] nonMatchingStrings = new String[] {
"<?xml?>",
"<?xml ?>",
"<?xml version=\"1.1\"?>",
"<?xmlversion=\"1.0\"?>",
"<Uxml version=\"1.0\"?>",
"<?xml version=\"1.0\"U>",
"<?xml version=\"1.0\"?> ",
"<?xml version=\"1.0\"?>\t",
"xml version=\"1.0\"?>",
"<?xml version=\"1.0>",
"<?xml version=\"1.0\"encoding=\"abc\"?>",
"<?xml version=\"1.0\" encoding=\"ab%\"?>",
"<?xml version=\"1.0\" encoding=\"1abc\"?>",
"<?xml version=\"1.0\" encoding=\".abc\"?>",
"<?xml version=\"1.0\" encoding=\"_abc\"?>",
"<?xml version=\"1.0\" encoding=\"-abc\"?>",
"<?xml version=\"1.0\"standalone=yes?>",
"<?xml version=\"1.0\" standalone=yes>",
"<?xml version=\"1.0\" standalone=\'yes\"?>",
"<?xml version=\"1.0\" standalone=\"yes\'?>",
"<?xml version=\"1.0\" standalone=\"yes?>",
"<?xml version=\"1.0\" standalone=yes\"?>",
"<?xml version=\"1.0\" standalone=\'yes?>",
"<?xml version=\"1.0\" standalone=yes\'?>",
"<?xml version=\"1.0\" standalone=\"maybe\"?>",
"<?xml version=\"1.0\" encoding=\"abc\" standalone=\'yes\"?>",
"<?xml version=\"1.0\" encoding=\'abc\" standalone=\"yes\"?>"
};
for (int i = 0; i < matchingStrings.length; i++) {
String string = matchingStrings[i];
assertTrue("should match: " + string,
pattern.matcher(string).matches());
}
for (int i = 0; i < nonMatchingStrings.length; i++) {
String string = nonMatchingStrings[i];
assertFalse("should not match: " + string,
pattern.matcher(string).matches());
}
}
/**
*/
public void testSpecialTrim() throws IllegalAccessException,
InvocationTargetException {
assertSame("", specialTrim(""));
assertSame("abcde", specialTrim("abcde"));
assertSame("ab\tc de", specialTrim("ab\tc de"));
assertSame("ab c\tde", specialTrim("ab c\tde"));
assertEquals("", specialTrim(" "));
assertEquals("", specialTrim("\t\t"));
assertEquals("abcde", specialTrim(" abcde"));
assertEquals("abcde", specialTrim("abcde "));
assertEquals("abcde", specialTrim(" abcde "));
assertEquals("ab\tc de", specialTrim(" ab\tc de"));
assertEquals("ab c\tde", specialTrim("\tab c\tde"));
assertEquals("ab\tc de", specialTrim("ab\tc de "));
assertEquals("ab c\tde", specialTrim("ab c\tde\t"));
}
public void testComparisonRegex() throws Exception {
Pattern pattern = getPattern("COMPARISON_REGEX");
final String[] matchingStrings = new String[] {
"expected:<Hello from hereThis is test[]> but was:<Hello from hereThis is test[2]>",
"expected:<Hello from here[ This is test]> but was:<Hello from here[This is test2]>",
"expected:<...om hereThis is test[]> but was:<...om hereThis is test[2]>",
};
final String[] nonMatchingStrings = new String[] {
"expected:<Hello from here\nThis is test[]> but was:<Hello from here\nThis is test[2]>",
"expected:<Hello from here[\nThis is test]> but was:<Hello from here[This is test2]>",
"expected:<...om here\nThis is test[]> but was:<...om here\nThis is test[2]>",
};
for (int i = 0; i < matchingStrings.length; i++) {
String string = matchingStrings[i];
assertTrue("should match: " + string,
pattern.matcher(string).matches());
}
for (int i = 0; i < nonMatchingStrings.length; i++) {
String string = nonMatchingStrings[i];
assertFalse("should not match: " + string,
pattern.matcher(string).matches());
assertTrue("should match: " + string,
pattern.matcher(string.replaceAll("\n", "")).matches());
}
}
private Pattern getPattern(String fieldName) throws Exception {
return Pattern.compile(getRegex(fieldName));
}
private String getRegex(String fieldName) throws Exception {
Field regexField = JavaRegexpUtils.class.getDeclaredField(fieldName);
regexField.setAccessible(true);
return (String) regexField.get(null);
}
/**
*/
private String specialTrim(String str) throws IllegalAccessException,
InvocationTargetException {
Object result = methodSpecialTrim.invoke(null, new Object[] {str});
return (String) result;
}
}
| 11,968 |
15,577 | <filename>src/IO/UseSSL.h
#pragma once
#include <boost/noncopyable.hpp>
namespace DB
{
// http://stackoverflow.com/questions/18315472/https-request-in-c-using-poco
struct UseSSL : private boost::noncopyable
{
UseSSL();
~UseSSL();
};
}
| 100 |
335 | {
"word": "Filmography",
"definitions": [
"A list of films by one director or actor, or on one subject."
],
"parts-of-speech": "Noun"
} | 67 |
Subsets and Splits