max_stars_count
int64 301
224k
| text
stringlengths 6
1.05M
| token_count
int64 3
727k
|
|---|---|---|
14,668 | // Copyright 2016 The Crashpad Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#ifndef CRASHPAD_MINIDUMP_MINIDUMP_UNLOADED_MODULE_WRITER_H_
#define CRASHPAD_MINIDUMP_MINIDUMP_UNLOADED_MODULE_WRITER_H_
#include <windows.h>
#include <dbghelp.h>
#include <stdint.h>
#include <memory>
#include <string>
#include <vector>
#include "minidump/minidump_stream_writer.h"
#include "minidump/minidump_string_writer.h"
#include "minidump/minidump_writable.h"
#include "snapshot/unloaded_module_snapshot.h"
namespace crashpad {
//! \brief The writer for a MINIDUMP_UNLOADED_MODULE object in a minidump file.
//!
//! Because MINIDUMP_UNLOADED_MODULE objects only appear as elements of
//! MINIDUMP_UNLOADED_MODULE_LIST objects, this class does not write any data on
//! its own. It makes its MINIDUMP_UNLOADED_MODULE data available to its
//! MinidumpUnloadedModuleListWriter parent, which writes it as part of a
//! MINIDUMP_UNLOADED_MODULE_LIST.
class MinidumpUnloadedModuleWriter final : public internal::MinidumpWritable {
public:
MinidumpUnloadedModuleWriter();
MinidumpUnloadedModuleWriter(const MinidumpUnloadedModuleWriter&) = delete;
MinidumpUnloadedModuleWriter& operator=(const MinidumpUnloadedModuleWriter&) =
delete;
~MinidumpUnloadedModuleWriter() override;
//! \brief Initializes the MINIDUMP_UNLOADED_MODULE based on \a
//! unloaded_module_snapshot.
//!
//! \param[in] unloaded_module_snapshot The unloaded module snapshot to use as
//! source data.
//!
//! \note Valid in #kStateMutable. No mutator methods may be called before
//! this method, and it is not normally necessary to call any mutator
//! methods after this method.
void InitializeFromSnapshot(
const UnloadedModuleSnapshot& unloaded_module_snapshot);
//! \brief Returns a MINIDUMP_UNLOADED_MODULE referencing this object’s data.
//!
//! This method is expected to be called by a MinidumpUnloadedModuleListWriter
//! in order to obtain a MINIDUMP_UNLOADED_MODULE to include in its list.
//!
//! \note Valid in #kStateWritable.
const MINIDUMP_UNLOADED_MODULE* MinidumpUnloadedModule() const;
//! \brief Arranges for MINIDUMP_UNLOADED_MODULE::ModuleNameRva to point to a
//! MINIDUMP_STRING containing \a name.
//!
//! \note Valid in #kStateMutable.
void SetName(const std::string& name);
//! \brief Sets MINIDUMP_UNLOADED_MODULE::BaseOfImage.
void SetImageBaseAddress(uint64_t image_base_address) {
unloaded_module_.BaseOfImage = image_base_address;
}
//! \brief Sets MINIDUMP_UNLOADED_MODULE::SizeOfImage.
void SetImageSize(uint32_t image_size) {
unloaded_module_.SizeOfImage = image_size;
}
//! \brief Sets MINIDUMP_UNLOADED_MODULE::CheckSum.
void SetChecksum(uint32_t checksum) { unloaded_module_.CheckSum = checksum; }
//! \brief Sets MINIDUMP_UNLOADED_MODULE::TimeDateStamp.
//!
//! \note Valid in #kStateMutable.
void SetTimestamp(time_t timestamp);
protected:
// MinidumpWritable:
bool Freeze() override;
size_t SizeOfObject() override;
std::vector<MinidumpWritable*> Children() override;
bool WriteObject(FileWriterInterface* file_writer) override;
private:
MINIDUMP_UNLOADED_MODULE unloaded_module_;
std::unique_ptr<internal::MinidumpUTF16StringWriter> name_;
};
//! \brief The writer for a MINIDUMP_UNLOADED_MODULE_LIST stream in a minidump
//! file, containing a list of MINIDUMP_UNLOADED_MODULE objects.
class MinidumpUnloadedModuleListWriter final
: public internal::MinidumpStreamWriter {
public:
MinidumpUnloadedModuleListWriter();
MinidumpUnloadedModuleListWriter(const MinidumpUnloadedModuleListWriter&) =
delete;
MinidumpUnloadedModuleListWriter& operator=(
const MinidumpUnloadedModuleListWriter&) = delete;
~MinidumpUnloadedModuleListWriter() override;
//! \brief Adds an initialized MINIDUMP_UNLOADED_MODULE for each unloaded
//! module in \a unloaded_module_snapshots to the
//! MINIDUMP_UNLOADED_MODULE_LIST.
//!
//! \param[in] unloaded_module_snapshots The unloaded module snapshots to use
//! as source data.
//!
//! \note Valid in #kStateMutable. AddUnloadedModule() may not be called
//! before this this method, and it is not normally necessary to call
//! AddUnloadedModule() after this method.
void InitializeFromSnapshot(
const std::vector<UnloadedModuleSnapshot>& unloaded_module_snapshots);
//! \brief Adds a MinidumpUnloadedModuleWriter to the
//! MINIDUMP_UNLOADED_MODULE_LIST.
//!
//! This object takes ownership of \a unloaded_module and becomes its parent
//! in the overall tree of internal::MinidumpWritable objects.
//!
//! \note Valid in #kStateMutable.
void AddUnloadedModule(
std::unique_ptr<MinidumpUnloadedModuleWriter> unloaded_module);
protected:
// MinidumpWritable:
bool Freeze() override;
size_t SizeOfObject() override;
std::vector<MinidumpWritable*> Children() override;
bool WriteObject(FileWriterInterface* file_writer) override;
// MinidumpStreamWriter:
MinidumpStreamType StreamType() const override;
private:
std::vector<std::unique_ptr<MinidumpUnloadedModuleWriter>> unloaded_modules_;
MINIDUMP_UNLOADED_MODULE_LIST unloaded_module_list_base_;
};
} // namespace crashpad
#endif // CRASHPAD_MINIDUMP_MINIDUMP_UNLOADED_MODULE_WRITER_H_
| 1,944 |
852 | from CalibTracker.SiStripCommon.shallowTree_test_template import *
process.TFileService.fileName = 'test_shallowTracksProducer.root'
process.load('CalibTracker.SiStripCommon.ShallowTracksProducer_cfi')
process.testTree = cms.EDAnalyzer(
"ShallowTree",
outputCommands = cms.untracked.vstring(
'drop *',
'keep *_shallowTracks_*_*',
)
)
process.p = cms.Path(process.shallowTracks*process.testTree)
| 167 |
3,269 | // Time: O(n * m), m is max x
// Space: O(m)
class Solution {
public:
int minimumOperations(vector<int>& nums, int start, int goal) {
static const int MAX_X = 1000;
vector<int> new_nums;
for (const auto& y : nums) {
if (y && ((0 <= y && y <= MAX_X) || (0 <= (goal - y) && (goal - y) <= MAX_X) || (0 <= (goal + y) && (goal + y) <= MAX_X) || (0 <= (goal ^ y) && (goal ^ y) <= MAX_X))) {
new_nums.emplace_back(y);
}
}
nums = move(new_nums);
vector<pair<int, int>> q = {{start, 0}};
unordered_set<int> lookup = {start};
while (!empty(q)) {
vector<pair<int, int>> new_q;
for (const auto& [x, steps] : q) {
for (const auto& y : nums) {
for (const auto& nx : {x + y, x - y, x ^ y}) {
if (nx == goal) {
return steps + 1;
}
if (!(0 <= nx && nx <= MAX_X) || lookup.count(nx)) {
continue;
}
lookup.emplace(nx);
new_q.emplace_back(nx, steps + 1);
}
}
}
q = move(new_q);
}
return -1;
}
};
| 806 |
507 | //
// Copyright 2018 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#ifndef PXRUSDPREVIEWSURFACE_USD_PREVIEW_SURFACE_H
#define PXRUSDPREVIEWSURFACE_USD_PREVIEW_SURFACE_H
/// \file usdPreviewSurface.h
#include "api.h"
#include <pxr/base/tf/staticTokens.h>
#include <pxr/pxr.h>
#include <maya/MDataBlock.h>
#include <maya/MObject.h>
#include <maya/MPlug.h>
#include <maya/MPxNode.h>
#include <maya/MStatus.h>
#include <maya/MString.h>
#include <maya/MTypeId.h>
PXR_NAMESPACE_OPEN_SCOPE
// clang-format off
#define PXRUSDPREVIEWSURFACE_USD_PREVIEW_SURFACE_TOKENS \
((ClearcoatAttrName, "clearcoat")) \
((ClearcoatRoughnessAttrName, "clearcoatRoughness")) \
((DiffuseColorAttrName, "diffuseColor")) \
((DisplacementAttrName, "displacement")) \
((EmissiveColorAttrName, "emissiveColor")) \
((IorAttrName, "ior")) \
((MetallicAttrName, "metallic")) \
((NormalAttrName, "normal")) \
((OcclusionAttrName, "occlusion")) \
((OpacityAttrName, "opacity")) \
((OpacityThresholdAttrName, "opacityThreshold")) \
((RoughnessAttrName, "roughness")) \
((SpecularColorAttrName, "specularColor")) \
((UseSpecularWorkflowAttrName, "useSpecularWorkflow")) \
((OutColorAttrName, "outColor")) \
((OutTransparencyAttrName, "outTransparency")) \
((OutTransparencyOnAttrName, "outTransparencyOn")) \
((niceName, "USD Preview Surface")) \
((exportDescription, "Exports the bound shader as a USD preview surface UsdShade network.")) \
((importDescription, "Search for a USD preview surface UsdShade network to import."))
// clang-format on
TF_DECLARE_PUBLIC_TOKENS(
PxrMayaUsdPreviewSurfaceTokens,
PXRUSDPREVIEWSURFACE_API,
PXRUSDPREVIEWSURFACE_USD_PREVIEW_SURFACE_TOKENS);
class PxrMayaUsdPreviewSurface : public MPxNode
{
public:
PXRUSDPREVIEWSURFACE_API
static void* creator();
PXRUSDPREVIEWSURFACE_API
static MStatus initialize();
PXRUSDPREVIEWSURFACE_API
void postConstructor() override;
PXRUSDPREVIEWSURFACE_API
MStatus compute(const MPlug& plug, MDataBlock& dataBlock) override;
private:
PxrMayaUsdPreviewSurface();
~PxrMayaUsdPreviewSurface() override;
PxrMayaUsdPreviewSurface(const PxrMayaUsdPreviewSurface&) = delete;
PxrMayaUsdPreviewSurface& operator=(const PxrMayaUsdPreviewSurface&) = delete;
};
PXR_NAMESPACE_CLOSE_SCOPE
#endif
| 2,103 |
307 | <reponame>KilianB/JImageHash<gh_stars>100-1000
package dev.brachtendorf.jimagehash.matcher.categorize.supervised.randomForest;
import java.awt.image.BufferedImage;
class TestData {
protected BufferedImage b0;
protected boolean match;
/**
* @param b0
* @param b1
* @param match
*/
public TestData(BufferedImage b0, boolean match) {
super();
this.b0 = b0;
this.match = match;
}
@Override
public String toString() {
return "TestData [b0=" + b0.hashCode() + ", match=" + match + "]";
}
} | 197 |
442 | #pragma once
#include <functional>
#include <string>
namespace obe::Animation::Easing
{
enum class EasingType
{
Linear,
InSine,
OutSine,
InOutSine,
InQuad,
OutQuad,
InOutQuad,
InCubic,
OutCubic,
InOutCubic,
InQuart,
OutQuart,
InOutQuart,
InQuint,
OutQuint,
InOutQuint,
InExpo,
OutExpo,
InOutExpo,
InCirc,
OutCirc,
InOutCirc,
InBack,
OutBack,
InOutBack,
InElastic,
OutElastic,
InOutElastic,
InBounce,
OutBounce,
InOutBounce
};
double Linear(double t);
double InSine(double t);
double OutSine(double t);
double InOutSine(double t);
double InQuad(double t);
double OutQuad(double t);
double InOutQuad(double t);
double InCubic(double t);
double OutCubic(double t);
double InOutCubic(double t);
double InQuart(double t);
double OutQuart(double t);
double InOutQuart(double t);
double InQuint(double t);
double OutQuint(double t);
double InOutQuint(double t);
double InExpo(double t);
double OutExpo(double t);
double InOutExpo(double t);
double InCirc(double t);
double OutCirc(double t);
double InOutCirc(double t);
double InBack(double t);
double OutBack(double t);
double InOutBack(double t);
double InElastic(double t);
double OutElastic(double t);
double InOutElastic(double t);
double InBounce(double t);
double OutBounce(double t);
double InOutBounce(double t);
using EasingFunction = std::function<double(double)>;
EasingFunction get(const std::string& easing);
EasingFunction get(EasingType easing);
}
| 930 |
748 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
'''
Copyright (c) 2013,掌阅科技
All rights reserved.
File Name: logger.py
Author: WangLichao
Created on: 2014-03-28
'''
import os
import os.path
import logging
import logging.handlers
LOGGER_LEVEL = {
'DEBUG': logging.DEBUG,
'INFO': logging.INFO,
'WARNING': logging.WARNING,
'ERROR': logging.ERROR,
'CRITICAL': logging.CRITICAL
}
def init_logger(log_conf_items, suffix=None, log_name=None):
"""
初始化logger.
Args:
log_conf_items: 配置项list.
"""
logger = logging.getLogger(log_name)
for log_item in log_conf_items:
path = os.path.expanduser(log_item['file'])
if suffix:
path = '%s.%s' % (path, suffix)
dir_name = os.path.dirname(path)
if dir_name and not os.path.exists(dir_name):
os.makedirs(dir_name)
handler = logging.handlers.TimedRotatingFileHandler(
path,
when=log_item['when'],
interval=int(log_item['interval']),
backupCount=int(log_item['backup_count']),
)
enable_levels = [LOGGER_LEVEL[i] for i in log_item['log_levels']]
handler.addFilter(LevelFilter(enable_levels, False))
handler.suffix = log_item['backup_suffix']
formatter = logging.Formatter(log_item['format'])
handler.setFormatter(formatter)
logger.addHandler(handler)
logger.setLevel(log_item['level'])
class LevelFilter(logging.Filter):
'''日志过滤器
'''
def __init__(self, passlevels, reject):
super(LevelFilter, self).__init__()
self.passlevels = passlevels
self.reject = reject
def filter(self, record):
if self.reject:
return record.levelno not in self.passlevels
else:
return record.levelno in self.passlevels
if __name__ == '__main__':
LOG_CONF = [{'name': 'operation', 'file': 'log/operation.log',
'level': 'DEBUG', 'format': '%(asctime)s %(levelname)s %(message)s'}]
init_logger(LOG_CONF)
| 952 |
2,151 | // 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.
#ifndef ASH_WM_TABLET_MODE_TABLET_MODE_BACKDROP_DELEGATE_IMPL_H_
#define ASH_WM_TABLET_MODE_TABLET_MODE_BACKDROP_DELEGATE_IMPL_H_
#include "ash/wm/workspace/backdrop_delegate.h"
#include "ash/ash_export.h"
#include "base/macros.h"
namespace ash {
// A backdrop delegate for MaximizedMode, which always creates a backdrop.
// This is also used in the WorkspaceLayoutManagerBackdropTest, hence
// is public.
class ASH_EXPORT TabletModeBackdropDelegateImpl : public BackdropDelegate {
public:
TabletModeBackdropDelegateImpl();
~TabletModeBackdropDelegateImpl() override;
protected:
bool HasBackdrop(aura::Window* window) override;
private:
DISALLOW_COPY_AND_ASSIGN(TabletModeBackdropDelegateImpl);
};
} // namespace ash
#endif // ASH_WM_TABLET_MODE_TABLET_MODE_BACKDROP_DELEGATE_IMPL_H_
| 334 |
453 | #ifndef ASSERT_H
#define ASSERT_H
#include <stdbool.h>
void assert(bool cond, const char* msg);
#endif | 43 |
1,738 | /*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#pragma once
#include "LastPathBus.h"
#include "Platforms.h"
#include "PlatformSettings.h"
#include "ProjectSettingsContainer.h"
#include "ProjectSettingsSerialization.h"
#include "ValidatorBus.h"
#include <QProcess>
#include <QScopedPointer>
#include <QWidget>
// Forward Declares
namespace Ui
{
class ProjectSettingsToolWidget;
}
namespace AzToolsFramework
{
class InstanceDataHierarchy;
class PropertyHandlerBase;
class ReflectedPropertyEditor;
}
namespace ProjectSettingsTool
{
//Forward Declares
class Validator;
class ValidationHandler;
class PropertyLinkedHandler;
struct Properties
{
BaseSettings base;
AndroidSettings android;
IosSettings ios;
};
// Main window for Project Settings tool
class ProjectSettingsToolWindow
: public QWidget
, public LastPathBus::Handler
, public ValidatorBus::Handler
{
Q_OBJECT
public:
static const GUID& GetClassID()
{
// {0DC1B7D9-B660-41C3-91F1-A643EE65AADF}
static const GUID guid = {
0x0dc1b7d9, 0xb660, 0x41c3, { 0x91, 0xf1, 0xa6, 0x43, 0xee, 0x65, 0xaa, 0xdf }
};
return guid;
}
ProjectSettingsToolWindow(QWidget* parent = nullptr);
~ProjectSettingsToolWindow();
// Ebuses
QString GetLastImagePath() override;
void SetLastImagePath(const QString& path) override;
FunctorValidator* GetValidator(FunctorValidator::FunctorType) override;
void TrackValidator(FunctorValidator*) override;
static void ReflectPlatformClasses();
private:
AZ_DISABLE_COPY_MOVE(ProjectSettingsToolWindow);
void closeEvent(QCloseEvent* event) override;
// Close the window now because an error occurred
void ForceClose();
// Un/Registers and dis/connect handlers and buses
void RegisterHandlersAndBusses();
void UnregisterHandlersAndBusses();
void InitializeUi();
// Used to make the serializers for settings
void MakeSerializerJson(const Platform& plat, AzToolsFramework::InstanceDataHierarchy& hierarchy, rapidjson::Document* doc);
void MakeSerializerJsonNonRoot(const Platform& plat, AzToolsFramework::InstanceDataHierarchy& hierarchy, rapidjson::Document* doc, rapidjson::Value* jsonRoot);
void MakeSerializerPlist(const Platform& plat, AzToolsFramework::InstanceDataHierarchy& hierarchy, PlistDictionary* dict);
// Shows an error dialog if an error has occurred while loading settings then exits if users chooses
// Returns true if there was an error
bool IfErrorShowThenExit();
// Loop through all errors then exit if the user chooses to abort or window is in invalid state
void ShowAllErrorsThenExitIfInvalid();
// Resizes TabWidget to size of current tab instead of largest tab
void ResizeTabs(int index);
// Add all platforms into the ui
void AddAllPlatformsToUi();
// Add given platform into the ui
void AddPlatformToUi(const Platform& plat);
// Makes all serializers
void MakeSerializers();
// Makes the serializer for specified platform
void MakePlatformSerializer(const Platform& plat);
// Replace values in ui with those read from settings
void LoadPropertiesFromSettings();
// Load properties for specified platform from file
void LoadPropertiesFromPlatformSettings(const Platform& plat);
// Checks if ui is the same as all settings
bool UiEqualToSettings();
// Checks if platform is the same as settings
bool UiEqualToPlatformSettings(const Platform& plat);
// Checks if all properties are valid, if any are not returns false, also sets warnings on those properties
bool ValidateAllProperties();
// Replace values in settings with those from ui and save to file
void SaveSettingsFromUi();
// Saves all properties for specified platform from to file
void SaveSettingsFromPlatformUi(const Platform& plat);
// Reload settings files and replace the values in ui with them
void ReloadUiFromSettings();
// returns true if the platform is enabled
bool PlatformEnabled(PlatformId platformId);
// The ui for the window
QScopedPointer<Ui::ProjectSettingsToolWidget> m_ui;
// The process used to reconfigure settings
QProcess m_reconfigureProcess;
AZStd::string m_devRoot;
AZStd::string m_projectRoot;
AZStd::string m_projectName;
// Used to initialize the settings container's pLists
ProjectSettingsContainer::PlistInitVector m_plistsInitVector;
// Container to manage settings files per platform
AZStd::unique_ptr<ProjectSettingsContainer> m_settingsContainer;
// Allows lookup and contains all allocated QValidators
AZStd::unique_ptr<Validator> m_validator;
Properties m_platformProperties;
AzToolsFramework::ReflectedPropertyEditor* m_platformPropertyEditors[static_cast<unsigned>(PlatformId::NumPlatformIds)];
AZStd::unique_ptr<Serializer> m_platformSerializers[static_cast<unsigned>(PlatformId::NumPlatformIds)];
// Pointers to all handlers to they can be unregistered and deleted
AZStd::vector<AzToolsFramework::PropertyHandlerBase*> m_propertyHandlers;
AZStd::unique_ptr<ValidationHandler> m_validationHandler;
PropertyLinkedHandler* m_linkHandler;
// Last path used when browsing for images in icons or splash
QString m_lastImagesPath;
bool m_invalidState;
};
} // namespace ProjectSettingsTool | 2,225 |
367 | <reponame>carolchenyx/mmpose<filename>mmpose/models/keypoint_heads/multilabel_classification_head.py
import torch
import torch.nn as nn
from mmcv.cnn import normal_init
from mmpose.models.builder import build_loss
from ..registry import HEADS
@HEADS.register_module()
class MultilabelClassificationHead(nn.Module):
"""Multi-label classification head. Paper ref: Gyeongsik Moon.
"InterHand2.6M: A Dataset and Baseline for 3D Interacting Hand Pose
Estimation from a Single RGB Image".
Args:
in_channels (int): Number of input channels
num_labels (int): Number of labels
hidden_dims (list|tuple): Number of hidden dimension of FC layers.
loss_classification (dict): Config for classification loss.
Default: None.
"""
def __init__(self,
in_channels=2048,
num_labels=2,
hidden_dims=(512, ),
loss_classification=None,
train_cfg=None,
test_cfg=None):
super().__init__()
self.loss = build_loss(loss_classification)
self.in_channels = in_channels
self.num_labesl = num_labels
self.train_cfg = {} if train_cfg is None else train_cfg
self.test_cfg = {} if test_cfg is None else test_cfg
feature_dims = [in_channels] + \
[dim for dim in hidden_dims] + \
[num_labels]
self.fc = self._make_linear_layers(feature_dims)
def _make_linear_layers(self, feat_dims, relu_final=True):
"""Make linear layers."""
layers = []
for i in range(len(feat_dims) - 1):
layers.append(nn.Linear(feat_dims[i], feat_dims[i + 1]))
if i < len(feat_dims) - 2 or (i == len(feat_dims) - 2
and relu_final):
layers.append(nn.ReLU(inplace=True))
return nn.Sequential(*layers)
def forward(self, x):
"""Forward function."""
labels = torch.sigmoid(self.fc(x))
return labels
def get_loss(self, output, target, target_weight):
"""Calculate regression loss of root depth.
Note:
batch_size: N
Args:
output (torch.Tensor[N, 1]): Output depth.
target (torch.Tensor[N, 1]): Target depth.
target_weight (torch.Tensor[N, 1]):
Weights across different data.
"""
losses = dict()
assert not isinstance(self.loss, nn.Sequential)
assert target.dim() == 2 and target_weight.dim() == 2
losses['classification_loss'] = self.loss(output, target,
target_weight)
return losses
def get_accuracy(self, output, target, target_weight):
"""Calculate accuracy for classification.
Note:
batch size: N
number labels: L
Args:
output (torch.Tensor[N, L]): Output hand visibility.
target (torch.Tensor[N, L]): Target hand visibility.
target_weight (torch.Tensor[N, L]):
Weights across different labels.
"""
accuracy = dict()
# only calculate accuracy on the samples with ground truth labels
valid = (target_weight > 0).min(dim=1)[0]
output, target = output[valid], target[valid]
if output.shape[0] == 0:
# when no samples with gt labels, set acc to 0.
acc = output.new_zeros(1)
else:
acc = (((output - 0.5) *
(target - 0.5)).min(dim=1)[0] > 0).float().mean()
accuracy['acc_classification'] = acc
return accuracy
def inference_model(self, x, flip_pairs=None):
"""Inference function.
Returns:
output_labels (np.ndarray): Output labels.
Args:
x (torch.Tensor[NxC]): Input features vector.
flip_pairs (None | list[tuple()]):
Pairs of labels which are mirrored.
"""
labels = self.forward(x).detach().cpu().numpy()
if flip_pairs is not None:
labels_flipped_back = labels.copy()
for left, right in flip_pairs:
labels_flipped_back[:, left, ...] = labels[:, right, ...]
labels_flipped_back[:, right, ...] = labels[:, left, ...]
return labels_flipped_back
return labels
def decode(self, img_metas, output, **kwargs):
"""Decode keypoints from heatmaps.
Args:
img_metas (list(dict)): Information about data augmentation
By default this includes:
- "image_file": path to the image file
output (np.ndarray[N, L]): model predicted labels.
"""
return dict(labels=output)
def init_weights(self):
for m in self.fc.modules():
if isinstance(m, nn.Linear):
normal_init(m, mean=0, std=0.01, bias=0)
| 2,366 |
317 | <filename>Modules/ThirdParty/6S/src/libf2c/z_log.c
/* OTB patches: replace "f2c.h" by "otb_6S_f2c.h" */
/*#include "f2c.h"*/
#include "otb_6S_f2c.h"
#ifdef KR_headers
double log(), f__cabs(), atan2();
#define ANSI(x) ()
#else
#define ANSI(x) x
#undef abs
#include "math.h"
#ifdef __cplusplus
extern "C" {
#endif
extern double f__cabs(double, double);
#endif
#ifndef NO_DOUBLE_EXTENDED
#ifndef GCC_COMPARE_BUG_FIXED
#ifndef Pre20000310
#ifdef Comment
Some versions of gcc, such as 2.95.3 and 3.0.4, are buggy under -O2 or -O3:
on IA32 (Intel 80x87) systems, they may do comparisons on values computed
in extended-precision registers. This can lead to the test "s > s0" that
was used below being carried out incorrectly. The fix below cannot be
spoiled by overzealous optimization, since the compiler cannot know
whether gcc_bug_bypass_diff_F2C will be nonzero. (We expect it always
to be zero. The weird name is unlikely to collide with anything.)
An example (provided by <NAME>) where the bug fix matters is
double complex a, b
a = (.1099557428756427618354862829619, .9857360542953131909982289471372)
b = log(a)
An alternative to the fix below would be to use 53-bit rounding precision,
but the means of specifying this 80x87 feature are highly unportable.
#endif /*Comment*/
#define BYPASS_GCC_COMPARE_BUG
double (*gcc_bug_bypass_diff_F2C) ANSI((double*,double*));
static double
#ifdef KR_headers
diff1(a,b) double *a, *b;
#else
diff1(double *a, double *b)
#endif
{ return *a - *b; }
#endif /*Pre20000310*/
#endif /*GCC_COMPARE_BUG_FIXED*/
#endif /*NO_DOUBLE_EXTENDED*/
#ifdef KR_headers
VOID z_log(r, z) doublecomplex *r, *z;
#else
void z_log(doublecomplex *r, doublecomplex *z)
#endif
{
double s, s0, t, t2, u, v;
double zi = z->i, zr = z->r;
#ifdef BYPASS_GCC_COMPARE_BUG
double (*diff) ANSI((double*,double*));
#endif
r->i = atan2(zi, zr);
#ifdef Pre20000310
r->r = log( f__cabs( zr, zi ) );
#else
if (zi < 0)
zi = -zi;
if (zr < 0)
zr = -zr;
if (zr < zi) {
t = zi;
zi = zr;
zr = t;
}
t = zi/zr;
s = zr * sqrt(1 + t*t);
/* now s = f__cabs(zi,zr), and zr = |zr| >= |zi| = zi */
if ((t = s - 1) < 0)
t = -t;
if (t > .01)
r->r = log(s);
else {
#ifdef Comment
log(1+x) = x - x^2/2 + x^3/3 - x^4/4 + - ...
= x(1 - x/2 + x^2/3 -+...)
[sqrt(y^2 + z^2) - 1] * [sqrt(y^2 + z^2) + 1] = y^2 + z^2 - 1, so
sqrt(y^2 + z^2) - 1 = (y^2 + z^2 - 1) / [sqrt(y^2 + z^2) + 1]
#endif /*Comment*/
#ifdef BYPASS_GCC_COMPARE_BUG
if (!(diff = gcc_bug_bypass_diff_F2C))
diff = diff1;
#endif
t = ((zr*zr - 1.) + zi*zi) / (s + 1);
t2 = t*t;
s = 1. - 0.5*t;
u = v = 1;
do {
s0 = s;
u *= t2;
v += 2;
s += u/v - t*u/(v+1);
}
#ifdef BYPASS_GCC_COMPARE_BUG
while(s - s0 > 1e-18 || (*diff)(&s,&s0) > 0.);
#else
while(s > s0);
#endif
r->r = s*t;
}
#endif
}
#ifdef __cplusplus
}
#endif
| 1,347 |
332 | <reponame>kuangye098/Exchangis
/*
*
* Copyright 2020 WeBank
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.webank.wedatasphere.exchangis.job.query;
import com.webank.wedatasphere.exchangis.common.util.page.PageQuery;
import java.util.Date;
import java.util.HashSet;
import java.util.Set;
/**
* Created by devendeng on 2018/8/24.
*/
public class JobLogQuery extends PageQuery {
private Integer id;
private Integer jobId;
private Long taskId;
private String createUser;
private long triggerTimeBegin;
private long triggerTimeEnd;
private String status;
private String jobName;
private String fuzzyName;
private Set<String> userDataAuth = new HashSet<>();
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getJobId() {
return jobId;
}
public void setJobId(Integer jobId) {
this.jobId = jobId;
}
public Long getTaskId() {
return taskId;
}
public void setTaskId(Long taskId) {
this.taskId = taskId;
}
public Date getTriggerTimeBegin() {
return triggerTimeBegin==0 ? null:new Date(triggerTimeBegin);
}
public void setTriggerTimeBegin(Long triggerTimeBegin) {
this.triggerTimeBegin = triggerTimeBegin;
}
public Date getTriggerTimeEnd() {
return triggerTimeEnd==0?null:new Date(triggerTimeEnd);
}
public void setTriggerTimeEnd(Long triggerTimeEnd) {
this.triggerTimeEnd = triggerTimeEnd;
}
public String getStatus() {
return status;
}
public void setStatus(String status) {
this.status = status;
}
public String getCreateUser() {
return createUser;
}
public void setCreateUser(String createUser) {
this.createUser = createUser;
}
public String getJobName() {
return jobName;
}
public void setJobName(String jobName) {
this.jobName = jobName;
}
public Set<String> getUserDataAuth() {
return userDataAuth;
}
public void setUserDataAuth(Set<String> userDataAuth) {
this.userDataAuth = userDataAuth;
}
public String getFuzzyName() {
return fuzzyName;
}
public void setFuzzyName(String fuzzyName) {
this.fuzzyName = fuzzyName;
}
}
| 1,058 |
971 | <reponame>ScottLiao920/noisepage<filename>src/network/connection_handle.cpp
#include "network/connection_handle.h"
#include "loggers/network_logger.h"
#include "network/connection_dispatcher_task.h"
#include "network/connection_handle_factory.h"
#include "network/connection_handler_task.h"
#include "network/network_io_wrapper.h"
namespace noisepage::network {
/** ConnectionHandleStateMachineTransition implements ConnectionHandle::StateMachine::Delta's transition function. */
class ConnectionHandleStateMachineTransition {
public:
// clang-format off
/** Implement transition for ConnState::READ. */
static ConnectionHandle::StateMachine::TransitionResult TransitionForRead(Transition transition) {
switch (transition) {
case Transition::NEED_READ: return {ConnState::READ, WaitForRead};
case Transition::NEED_READ_TIMEOUT: return {ConnState::READ, WaitForReadWithTimeout};
// Allegedly, the NEED_WRITE case happens only when we use SSL and are blocked on a write
// during handshake. From noisepage's perspective we are still waiting for reads.
case Transition::NEED_WRITE: return {ConnState::READ, WaitForWrite};
case Transition::PROCEED: return {ConnState::PROCESS, Process};
case Transition::TERMINATE: return {ConnState::CLOSING, TryCloseConnection};
case Transition::WAKEUP: return {ConnState::READ, TryRead};
default: throw std::runtime_error("Undefined transition!");
}
}
/** Implement transition for ConnState::PROCESS. */
static ConnectionHandle::StateMachine::TransitionResult TransitionForProcess(Transition transition) {
switch (transition) {
case Transition::NEED_READ: return {ConnState::READ, TryRead};
case Transition::NEED_READ_TIMEOUT: return {ConnState::READ, WaitForReadWithTimeout};
case Transition::NEED_RESULT: return {ConnState::PROCESS, WaitForTerrier};
case Transition::PROCEED: return {ConnState::WRITE, TryWrite};
case Transition::TERMINATE: return {ConnState::CLOSING, TryCloseConnection};
case Transition::WAKEUP: return {ConnState::PROCESS, GetResult};
default: throw std::runtime_error("Undefined transition!");
}
}
/** Implement transition for ConnState::WRITE. */
static ConnectionHandle::StateMachine::TransitionResult TransitionForWrite(Transition transition) {
switch (transition) {
// Allegedly, NEED_READ happens during ssl-rehandshake with the client.
case Transition::NEED_READ: return {ConnState::WRITE, WaitForRead};
case Transition::NEED_WRITE: return {ConnState::WRITE, WaitForWrite};
case Transition::PROCEED: return {ConnState::PROCESS, Process};
case Transition::TERMINATE: return {ConnState::CLOSING, TryCloseConnection};
case Transition::WAKEUP: return {ConnState::WRITE, TryWrite};
default: throw std::runtime_error("Undefined transition!");
}
}
/** Implement transition for ConnState::CLOSING. */
static ConnectionHandle::StateMachine::TransitionResult TransitionForClosing(Transition transition) {
switch (transition) {
case Transition::NEED_READ: return {ConnState::WRITE, WaitForRead};
case Transition::NEED_WRITE: return {ConnState::WRITE, WaitForWrite};
case Transition::TERMINATE: return {ConnState::CLOSING, TryCloseConnection};
case Transition::WAKEUP: return {ConnState::CLOSING, TryCloseConnection};
default: throw std::runtime_error("Undefined transition!");
}
}
// clang-format on
private:
/** Define a function (ManagedPointer<ConnectionHandle> -> Transition) that calls the underlying handle's function. */
#define DEF_HANDLE_WRAPPER_FN(function_name) \
static Transition function_name(const common::ManagedPointer<ConnectionHandle> handle) { \
return handle->function_name(); \
}
DEF_HANDLE_WRAPPER_FN(GetResult);
DEF_HANDLE_WRAPPER_FN(Process);
DEF_HANDLE_WRAPPER_FN(TryRead);
DEF_HANDLE_WRAPPER_FN(TryWrite);
DEF_HANDLE_WRAPPER_FN(TryCloseConnection);
#undef DEF_HANDLE_WRAPPER_FN
/** Wait for the connection to become readable. */
static Transition WaitForRead(const common::ManagedPointer<ConnectionHandle> handle) {
handle->UpdateEventFlags(EV_READ | EV_PERSIST);
return Transition::NONE;
}
/** Wait for the connection to become writable. */
static Transition WaitForWrite(const common::ManagedPointer<ConnectionHandle> handle) {
// Wait for the connection to become writable.
handle->UpdateEventFlags(EV_WRITE | EV_PERSIST);
return Transition::NONE;
}
/** Wait for the connection to become readable, or until a timeout happens. */
static Transition WaitForReadWithTimeout(const common::ManagedPointer<ConnectionHandle> handle) {
handle->UpdateEventFlags(EV_READ | EV_PERSIST | EV_TIMEOUT, READ_TIMEOUT);
return Transition::NONE;
}
/** Stop listening to network events. This is used when control is completely ceded to Terrier, hence the name. */
static Transition WaitForTerrier(const common::ManagedPointer<ConnectionHandle> handle) {
handle->StopReceivingNetworkEvent();
return Transition::NONE;
}
};
ConnectionHandle::StateMachine::TransitionResult ConnectionHandle::StateMachine::Delta(ConnState state,
Transition transition) {
// clang-format off
switch (state) {
case ConnState::READ: return ConnectionHandleStateMachineTransition::TransitionForRead(transition);
case ConnState::PROCESS: return ConnectionHandleStateMachineTransition::TransitionForProcess(transition);
case ConnState::WRITE: return ConnectionHandleStateMachineTransition::TransitionForWrite(transition);
case ConnState::CLOSING: return ConnectionHandleStateMachineTransition::TransitionForClosing(transition);
default: throw std::runtime_error("Undefined transition!");
}
// clang-format on
}
void ConnectionHandle::StateMachine::Accept(Transition action, const common::ManagedPointer<ConnectionHandle> handle) {
Transition next = action;
// Transition until there are no more transitions.
while (next != Transition::NONE) {
TransitionResult result = Delta(current_state_, next);
current_state_ = result.first;
try {
next = result.second(handle);
} catch (const NetworkProcessException &e) {
// If an error occurs, the error is logged and the connection is terminated.
NETWORK_LOG_ERROR("{0}\n", e.what());
next = Transition::TERMINATE;
}
}
}
ConnectionHandle::ConnectionHandle(int sock_fd, common::ManagedPointer<ConnectionHandlerTask> task,
common::ManagedPointer<trafficcop::TrafficCop> tcop,
std::unique_ptr<ProtocolInterpreter> interpreter)
: io_wrapper_(std::make_unique<NetworkIoWrapper>(sock_fd)),
conn_handler_task_(task),
traffic_cop_(tcop),
protocol_interpreter_(std::move(interpreter)) {
context_.SetCallback(Callback, this);
context_.SetConnectionID(static_cast<connection_id_t>(sock_fd));
}
ConnectionHandle::~ConnectionHandle() = default;
void ConnectionHandle::RegisterToReceiveEvents() {
workpool_event_ = conn_handler_task_->RegisterManualEvent(
[](int fd, int16_t flags, void *arg) { static_cast<ConnectionHandle *>(arg)->HandleEvent(fd, flags); }, this);
network_event_ = conn_handler_task_->RegisterEvent(
io_wrapper_->GetSocketFd(), EV_READ | EV_PERSIST,
[](int fd, int16_t flags, void *arg) { static_cast<ConnectionHandle *>(arg)->HandleEvent(fd, flags); }, this);
}
void ConnectionHandle::HandleEvent(int fd, int16_t flags) {
Transition t;
if ((flags & EV_TIMEOUT) != 0) {
// If the event was a timeout, this implies that the connection timed out. Terminate to disconnect.
t = Transition::TERMINATE;
} else {
// Otherwise, something happened, so the state machine should wake up.
t = Transition::WAKEUP;
}
state_machine_.Accept(t, common::ManagedPointer<ConnectionHandle>(this));
}
Transition ConnectionHandle::TryRead() { return io_wrapper_->FillReadBuffer(); }
Transition ConnectionHandle::TryWrite() {
if (io_wrapper_->ShouldFlush()) {
return io_wrapper_->FlushAllWrites();
}
return Transition::PROCEED;
}
Transition ConnectionHandle::Process() {
auto transition = protocol_interpreter_->Process(io_wrapper_->GetReadBuffer(), io_wrapper_->GetWriteQueue(),
traffic_cop_, common::ManagedPointer(&context_));
return transition;
}
Transition ConnectionHandle::GetResult() {
// Wait until a network event happens.
EventUtil::EventAdd(network_event_, EventUtil::WAIT_FOREVER);
// TODO(WAN): It is not clear to me what this function is doing. If someone figures it out, please update comment.
protocol_interpreter_->GetResult(io_wrapper_->GetWriteQueue());
return Transition::PROCEED;
}
Transition ConnectionHandle::TryCloseConnection() {
// Flush out any pending writes before closing the connection. In theory this should just be error messages and not
// partial query data, but I don't completely understand the network state machine. This is mostly to make sure we
// flush error messages on connection startup. @see PostgresProtocolInterpreter::ProcessStartup's error states
if (io_wrapper_->ShouldFlush()) TryWrite();
// Stop the protocol interpreter.
protocol_interpreter_->Teardown(io_wrapper_->GetReadBuffer(), io_wrapper_->GetWriteQueue(), traffic_cop_,
common::ManagedPointer(&context_));
// Try to close the connection. If that fails, return whatever should have been done instead.
// The connection must be closed before events are removed for safety reasons.
Transition close = io_wrapper_->Close();
if (close != Transition::PROCEED) {
return close;
}
// Remove the network and worker pool events.
conn_handler_task_->UnregisterEvent(network_event_);
conn_handler_task_->UnregisterEvent(workpool_event_);
return Transition::NONE;
}
void ConnectionHandle::UpdateEventFlags(int16_t flags, int timeout_secs) {
// This callback function just calls HandleEvent().
event_callback_fn handle_event = [](int fd, int16_t flags, void *arg) {
static_cast<ConnectionHandle *>(arg)->HandleEvent(fd, flags);
};
// Update the flags for the event, casing on whether a timeout value needs to be specified.
int conn_fd = io_wrapper_->GetSocketFd();
if ((flags & EV_TIMEOUT) == 0) {
// If there is no timeout specified, then the event will wait forever to be activated.
conn_handler_task_->UpdateEvent(network_event_, conn_fd, flags, handle_event, this, EventUtil::WAIT_FOREVER);
} else {
// Otherwise if there is a timeout specified, then the event will fire once the timeout has passed.
struct timeval timeout {
timeout_secs, 0
};
conn_handler_task_->UpdateEvent(network_event_, conn_fd, flags, handle_event, this, &timeout);
}
}
void ConnectionHandle::StopReceivingNetworkEvent() { EventUtil::EventDel(network_event_); }
void ConnectionHandle::Callback(void *callback_args) {
// TODO(WAN): this is currently unused.
auto *const handle = reinterpret_cast<ConnectionHandle *>(callback_args);
NOISEPAGE_ASSERT(handle->state_machine_.CurrentState() == ConnState::PROCESS,
"Should be waking up a ConnectionHandle that's in PROCESS state waiting on query result.");
event_active(handle->workpool_event_, EV_WRITE, 0);
}
void ConnectionHandle::ResetForReuse(connection_id_t connection_id, common::ManagedPointer<ConnectionHandlerTask> task,
std::unique_ptr<ProtocolInterpreter> interpreter) {
io_wrapper_->Restart();
conn_handler_task_ = task;
// TODO(WAN): the same traffic cop is kept because the ConnectionHandleFactory always uses the same traffic cop
// anyway, but if this ever changes then we'll need to revisit this.
protocol_interpreter_ = std::move(interpreter);
state_machine_ = ConnectionHandle::StateMachine();
network_event_ = nullptr;
workpool_event_ = nullptr;
context_.Reset();
context_.SetConnectionID(connection_id);
}
} // namespace noisepage::network
| 4,380 |
16,461 | // Copyright 2018-present 650 Industries. All rights reserved.
#import <Foundation/Foundation.h>
#import <ABI42_0_0UMTaskManagerInterface/ABI42_0_0UMTaskConsumerInterface.h>
NS_ASSUME_NONNULL_BEGIN
@interface ABI42_0_0EXBackgroundFetchTaskConsumer : NSObject <ABI42_0_0UMTaskConsumerInterface>
@property (nonatomic, strong) id<ABI42_0_0UMTaskInterface> task;
@end
NS_ASSUME_NONNULL_END
| 143 |
2,970 | <filename>pyzoo/test/zoo/models/anomalydetection/test_anomalydetector.py<gh_stars>1000+
#
# Copyright 2018 Analytics Zoo 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.
#
import pytest
import numpy as np
from zoo.models.anomalydetection import AnomalyDetector
from test.zoo.pipeline.utils.test_utils import ZooTestCase
np.random.seed(1337) # for reproducibility
class TestAnomalyDetector(ZooTestCase):
def test_forward_backward(self):
model = AnomalyDetector(feature_shape=(10, 3), hidden_layers=[8, 32, 15],
dropouts=[0.2, 0.2, 0.2])
model.summary()
input_data = np.random.rand(100, 10, 3)
self.assert_forward_backward(model, input_data)
model.set_evaluate_status()
# Forward twice will get the same output
output1 = model.forward(input_data)
output2 = model.forward(input_data)
assert np.allclose(output1, output2)
def test_save_load(self):
model = AnomalyDetector(feature_shape=(10, 3), hidden_layers=[8, 32, 15],
dropouts=[0.2, 0.2, 0.2])
input_data = np.random.rand(100, 10, 3)
self.assert_zoo_model_save_load(model, input_data)
def test_compile_fit(self):
model = AnomalyDetector(feature_shape=(5, 3), hidden_layers=[8],
dropouts=[0.2])
input_data = [[float(i), float(i + 1), float(i + 2)] for i in range(20)]
rdd = self.sc.parallelize(input_data)
unrolled = AnomalyDetector.unroll(rdd, 5, 1)
[train, validation] = AnomalyDetector.train_test_split(unrolled, 10)
model.compile(loss='mse', optimizer='rmsprop', metrics=['mae'])
model.fit(train, batch_size=4, nb_epoch=1, validation_data=validation)
if __name__ == "__main__":
pytest.main([__file__])
| 946 |
1,647 | """
YieldPoints gathers all yield points from a node
"""
from pythran.passmanager import FunctionAnalysis
class YieldPoints(FunctionAnalysis):
'''Gathers all yield points of a generator, if any.'''
def __init__(self):
self.result = list()
super(YieldPoints, self).__init__()
def visit_Yield(self, node):
self.result.append(node)
| 132 |
348 | {"nom":"Krautergersheim","circ":"6ème circonscription","dpt":"Bas-Rhin","inscrits":1384,"abs":788,"votants":596,"blancs":19,"nuls":1,"exp":576,"res":[{"nuance":"LR","nom":"<NAME>","voix":376},{"nuance":"MDM","nom":"<NAME>","voix":200}]} | 95 |
816 | # coding=utf-8
# Copyright 2019 The Google AI Language Team 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.
# Lint as: python3
import os
from absl import flags
from absl import logging
from absl.testing import absltest
from absl.testing import parameterized
from tapas.protos import interaction_pb2
from tapas.utils import sem_tab_fact_utils
from google.protobuf import text_format
FLAGS = flags.FLAGS
TEST_PATH = 'tapas/utils/testdata/'
class GetTableDimensionsTest(parameterized.TestCase):
def setUp(self):
super().setUp()
self.test_data_dir = TEST_PATH
@parameterized.parameters(
(sem_tab_fact_utils.Version.V1),
(sem_tab_fact_utils.Version.V2),
)
def test_process_doc(self, version):
interactions = list(
sem_tab_fact_utils._process_doc(
os.path.join(
self.test_data_dir,
'sem_tab_fact_20502.xml',
),
version,
))
if version == sem_tab_fact_utils.Version.V1:
name = 'sem_tab_fact_20502_interaction.txtpb'
elif version == sem_tab_fact_utils.Version.V2:
name = 'sem_tab_fact_20502_interaction_v2.txtpb'
else:
raise ValueError(f'Unsupported version: {version.name}')
interaction_file = os.path.join(self.test_data_dir, name)
with open(interaction_file) as input_file:
interaction = text_format.ParseLines(input_file,
interaction_pb2.Interaction())
self.assertLen(interactions, 4)
logging.info(interactions[0])
self.assertEqual(interactions[0], interaction)
questions = [
( # pylint: disable=g-complex-comprehension
i.questions[0].id,
i.questions[0].original_text,
i.questions[0].answer.class_index,
) for i in interactions
]
self.assertEqual(questions, [
(
'sem_tab_fact_20502_Table_2_2_0',
'At the same time, these networks often occur in tandem at the firm level.',
1,
),
(
'sem_tab_fact_20502_Table_2_3_0',
'For each network interaction, there is considerable variation both across and within countries.',
1,
),
(
'sem_tab_fact_20502_Table_2_5_0',
'The n value is same for Hong Kong and Malaysia.',
0,
),
(
'sem_tab_fact_20502_Table_2_8_0',
'There are 9 different types country in the given table.',
1,
),
])
if __name__ == '__main__':
absltest.main()
| 1,306 |
6,557 | <gh_stars>1000+
{
"actions": "Acțiuni",
"actionsAvailable": "Acțiuni disponibile.",
"clearSelection": "Goliți selecția",
"selected": "{count, plural, =0 {Niciunul selectat} other {# selectate}}",
"selectedAll": "Toate selectate"
}
| 100 |
10,225 | package io.quarkus.it.jpa.postgresql;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringReader;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.SQLXML;
import java.sql.Statement;
import java.util.List;
import java.util.UUID;
import javax.inject.Inject;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.sql.DataSource;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMResult;
import javax.xml.transform.stream.StreamSource;
/**
* First we run a smoke test for basic Hibernate ORM functionality,
* then we specifically focus on supporting the PgSQLXML mapping abilities for XML types:
* both need to work.
*/
@WebServlet(name = "JPATestBootstrapEndpoint", urlPatterns = "/jpa-withxml/testfunctionality")
public class JPAFunctionalityTestEndpoint extends HttpServlet {
@Inject
EntityManagerFactory entityManagerFactory;
@Inject
DataSource ds;
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws IOException {
try {
doStuffWithHibernate(entityManagerFactory);
doStuffWithDatasource();
} catch (Exception e) {
reportException("An error occurred while performing Hibernate operations", e, resp);
}
resp.getWriter().write("OK");
}
private void doStuffWithDatasource() throws SQLException, TransformerException {
try (final Connection con = ds.getConnection()) {
deleteXmlSchema(con);
createXmlSchema(con);
writeXmlObject(con);
checkWrittenXmlObject(con);
}
}
private void checkWrittenXmlObject(Connection con) throws SQLException {
try (Statement stmt = con.createStatement()) {
final ResultSet resultSet = stmt.executeQuery("SELECT val FROM xmltest");
final boolean next = resultSet.next();
if (!next) {
throw new IllegalStateException("Stored XML element not found!");
}
final String storedValue = resultSet.getString(1);
if (storedValue == null) {
throw new IllegalStateException("Stored XML element was loaded as null!");
}
String expectedMatch = "<?xml version=\"1.0\" standalone=\"no\"?><root><ele>1</ele><ele>2</ele></root>";
if (!expectedMatch.equals(storedValue)) {
throw new IllegalStateException("Stored XML element is not matching expected value of '" + expectedMatch
+ "', but was '" + storedValue + "'");
}
}
}
private void writeXmlObject(Connection con) throws SQLException, TransformerException {
TransformerFactory factory = TransformerFactory.newInstance();
final String _xmlDocument = "<root><ele>1</ele><ele>2</ele></root>";
Transformer identityTransformer = factory.newTransformer();
try (PreparedStatement ps = con.prepareStatement("INSERT INTO xmltest VALUES (?,?)")) {
SQLXML xml = con.createSQLXML();
Result result = xml.setResult(DOMResult.class);
Source source = new StreamSource(new StringReader(_xmlDocument));
identityTransformer.transform(source, result);
ps.setInt(1, 1);
ps.setSQLXML(2, xml);
ps.executeUpdate();
}
}
private void createXmlSchema(Connection con) throws SQLException {
Statement stmt = con.createStatement();
stmt.execute("CREATE TEMP TABLE xmltest(id int primary key, val xml)");
stmt.close();
}
private void deleteXmlSchema(Connection con) {
try {
Statement stmt = con.createStatement();
stmt.execute("DROP TABLE xmltest");
stmt.close();
} catch (SQLException throwables) {
//ignore this one
}
}
/**
* Lists the various operations we want to test for:
*/
private static void doStuffWithHibernate(EntityManagerFactory entityManagerFactory) {
//Store some well known Person instances we can then test on:
storeTestPersons(entityManagerFactory);
//Load all persons and run some checks on the query results:
verifyListOfExistingPersons(entityManagerFactory);
//Try a JPA named query:
verifyJPANamedQuery(entityManagerFactory);
}
private static void verifyJPANamedQuery(final EntityManagerFactory emf) {
EntityManager em = emf.createEntityManager();
EntityTransaction transaction = em.getTransaction();
transaction.begin();
TypedQuery<Person> typedQuery = em.createNamedQuery(
"get_person_by_name", Person.class);
typedQuery.setParameter("name", "Quarkus");
final Person singleResult = typedQuery.getSingleResult();
if (!singleResult.getName().equals("Quarkus")) {
throw new RuntimeException("Wrong result from named JPA query");
}
transaction.commit();
em.close();
}
private static void verifyListOfExistingPersons(final EntityManagerFactory emf) {
EntityManager em = emf.createEntityManager();
EntityTransaction transaction = em.getTransaction();
transaction.begin();
listExistingPersons(em);
transaction.commit();
em.close();
}
private static void storeTestPersons(final EntityManagerFactory emf) {
EntityManager em = emf.createEntityManager();
EntityTransaction transaction = em.getTransaction();
transaction.begin();
persistNewPerson(em, "Gizmo");
persistNewPerson(em, "Quarkus");
persistNewPerson(em, "Hibernate ORM");
transaction.commit();
em.close();
}
private static void listExistingPersons(EntityManager em) {
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Person> cq = cb.createQuery(Person.class);
Root<Person> from = cq.from(Person.class);
cq.select(from).orderBy(cb.asc(from.get("name")));
TypedQuery<Person> q = em.createQuery(cq);
List<Person> allpersons = q.getResultList();
if (allpersons.size() != 3) {
throw new RuntimeException("Incorrect number of results");
}
if (!allpersons.get(0).getName().equals("Gizmo")) {
throw new RuntimeException("Incorrect order of results");
}
StringBuilder sb = new StringBuilder("list of stored Person names:\n\t");
for (Person p : allpersons) {
p.describeFully(sb);
sb.append("\n\t");
if (p.getStatus() != Status.LIVING) {
throw new RuntimeException("Incorrect status " + p);
}
}
sb.append("\nList complete.\n");
System.out.print(sb);
}
private static void persistNewPerson(EntityManager entityManager, String name) {
Person person = new Person();
person.setName(name);
person.setStatus(Status.LIVING);
person.setAddress(new SequencedAddress("Street " + randomName()));
entityManager.persist(person);
}
private static String randomName() {
return UUID.randomUUID().toString();
}
private void reportException(String errorMessage, final Exception e, final HttpServletResponse resp) throws IOException {
final PrintWriter writer = resp.getWriter();
if (errorMessage != null) {
writer.write(errorMessage);
writer.write(" ");
}
writer.write(e.toString());
writer.append("\n\t");
e.printStackTrace(writer);
writer.append("\n\t");
}
}
| 3,289 |
592 | <filename>backend/posts/views.py
from rest_framework.generics import ListCreateAPIView, RetrieveUpdateDestroyAPIView
from rest_framework.generics import ListAPIView, CreateAPIView
from rest_framework.decorators import permission_classes
from rest_framework.permissions import IsAuthenticated, AllowAny
from django.views.decorators.csrf import csrf_exempt
# from rest_framework import status
# from rest_framework.views import APIView
# from rest_framework.response import Response
from .models import Post
from tags.models import Tag
from categories.models import Category
from .serializers import PostSerializer, TagSerializer
from .utils import add_tags
from .activities import submit_post
class PostList(ListAPIView):
queryset = Post.objects.all()
serializer_class = PostSerializer
def get_queryset(self):
qs = super(PostList, self).get_queryset()
# Filter by tag
tag = self.kwargs.get('tag')
if tag:
tag = Tag.objects.get(slug=tag)
return qs.filter(tags=tag)
# Filter by category
category = self.kwargs.get('category')
if category:
category = Category.objects.get(slug=category)
return qs.filter(category=category)
return qs
@permission_classes((IsAuthenticated, ))
class PostCreate(CreateAPIView):
queryset = Post.objects.all()
serializer_class = PostSerializer
def perform_create(self, serializer):
post = serializer.save()
# Set category
try:
category = str(self.request.data['category'])
except:
category = ""
if category:
category = Category.objects.get(slug=category)
post.category = category
# Add tags
try:
tag_string = self.request.data['tags']
except:
tag_string = ""
if tag_string:
post = add_tags(post, tag_string)
post.save()
# Ignore this.
# Experimenting with submitting posts using ActivityPub.
try:
submit_post(post)
except:
pass
# @permission_classes((IsAuthenticated, ))
# @permission_classes((AllowAny, ))
class PostRetrieveUpdateDestroy(RetrieveUpdateDestroyAPIView):
queryset = Post.objects.all()
serializer_class = PostSerializer
lookup_field = 'slug'
def perform_update(self, serializer):
post = serializer.save()
# Set category
try:
category = str(self.request.data['category'])
except:
category = ""
if category:
category = Category.objects.get(slug=category)
post.category = category
# Replace tags
try:
tags = str(self.request.data['tags'])
except:
tags = ""
if tags:
post = add_tags(post, tags)
post.save()
class TagListCreate(ListCreateAPIView):
queryset = Tag.objects.all()
serializer_class = TagSerializer
class TagRetrieveUpdateDestroy(RetrieveUpdateDestroyAPIView):
queryset = Tag.objects.all()
serializer_class = TagSerializer
lookup_field = 'slug'
| 1,370 |
1,352 | <filename>ruoyi-system/src/main/java/com/ruoyi/system/domain/SysDictData.java
package com.ruoyi.system.domain;
import com.ruoyi.common.annotation.Excel;
import com.ruoyi.common.base.BaseEntity;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import lombok.EqualsAndHashCode;
/**
* 字典数据表 sys_dict_data
*
* @author ruoyi
*/
@EqualsAndHashCode(callSuper = true)
@Data
@ApiModel(description="数据字典",parent=BaseEntity.class)
public class SysDictData extends BaseEntity {
private static final long serialVersionUID = 1L;
@Excel(name = "字典编码")
@ApiModelProperty(value="字典编码",name="dictCode",example="1")
private Long dictCode;
@Excel(name = "字典排序")
@ApiModelProperty(value="字典排序",name="dictSort",example="1")
private Long dictSort;
@Excel(name = "字典标签")
@ApiModelProperty(value="字典标签",name="dictLabel",example="男")
private String dictLabel;
@Excel(name = "字典键值")
@ApiModelProperty(value="字典键值",name="dictValue",example="0")
private String dictValue;
@Excel(name = "字典类型")
@ApiModelProperty(value="字典类型",name="dictType",example="sys_user_sex")
private String dictType;
@Excel(name = "字典样式")
@ApiModelProperty(value="字典样式",name="cssClass")
private String cssClass;
@ApiModelProperty(value="表格字典样式",name="listClass")
private String listClass;
@Excel(name = "是否默认", readConverterExp = "Y=是,N=否")
@ApiModelProperty(value="是否默认",name="isDefault",example="N",allowableValues = "Y,N",reference="Y=是,N=否")
private String isDefault;
@Excel(name = "状态", readConverterExp = "0=正常,1=停用")
@ApiModelProperty(value="状态",name="status",example="0",allowableValues = "0,1",reference="0=正常,1=停用")
private String status;
}
| 835 |
790 | """
The GeoDjango GEOS module. Please consult the GeoDjango documentation
for more details:
http://geodjango.org/docs/geos.html
"""
from django.contrib.gis.geos.geometry import GEOSGeometry, wkt_regex, hex_regex
from django.contrib.gis.geos.point import Point
from django.contrib.gis.geos.linestring import LineString, LinearRing
from django.contrib.gis.geos.polygon import Polygon
from django.contrib.gis.geos.collections import GeometryCollection, MultiPoint, MultiLineString, MultiPolygon
from django.contrib.gis.geos.error import GEOSException, GEOSIndexError
from django.contrib.gis.geos.io import WKTReader, WKTWriter, WKBReader, WKBWriter
from django.contrib.gis.geos.factory import fromfile, fromstr
from django.contrib.gis.geos.libgeos import geos_version, geos_version_info, GEOS_PREPARE
| 283 |
1,338 | <filename>headers/build/os/package/hpkg/PackageWriter.h
#include <../os/package/hpkg/PackageWriter.h>
| 36 |
2,268 | //========= Copyright Valve Corporation, All rights reserved. ============//
//
// Functionality to render a glowing outline around client renderable objects.
//
//===============================================================================
#include "cbase.h"
#include "glow_outline_effect.h"
#include "model_types.h"
#include "shaderapi/ishaderapi.h"
#include "materialsystem/imaterialvar.h"
#include "materialsystem/itexture.h"
#include "view_shared.h"
#include "viewpostprocess.h"
#define FULL_FRAME_TEXTURE "_rt_FullFrameFB"
#ifdef GLOWS_ENABLE
ConVar glow_outline_effect_enable( "glow_outline_effect_enable", "1", FCVAR_ARCHIVE, "Enable entity outline glow effects." );
ConVar glow_outline_effect_width( "glow_outline_width", "10.0f", FCVAR_CHEAT, "Width of glow outline effect in screen space." );
extern bool g_bDumpRenderTargets; // in viewpostprocess.cpp
CGlowObjectManager g_GlowObjectManager;
struct ShaderStencilState_t
{
bool m_bEnable;
StencilOperation_t m_FailOp;
StencilOperation_t m_ZFailOp;
StencilOperation_t m_PassOp;
StencilComparisonFunction_t m_CompareFunc;
int m_nReferenceValue;
uint32 m_nTestMask;
uint32 m_nWriteMask;
ShaderStencilState_t()
{
m_bEnable = false;
m_PassOp = m_FailOp = m_ZFailOp = STENCILOPERATION_KEEP;
m_CompareFunc = STENCILCOMPARISONFUNCTION_ALWAYS;
m_nReferenceValue = 0;
m_nTestMask = m_nWriteMask = 0xFFFFFFFF;
}
void SetStencilState( CMatRenderContextPtr &pRenderContext )
{
pRenderContext->SetStencilEnable( m_bEnable );
pRenderContext->SetStencilFailOperation( m_FailOp );
pRenderContext->SetStencilZFailOperation( m_ZFailOp );
pRenderContext->SetStencilPassOperation( m_PassOp );
pRenderContext->SetStencilCompareFunction( m_CompareFunc );
pRenderContext->SetStencilReferenceValue( m_nReferenceValue );
pRenderContext->SetStencilTestMask( m_nTestMask );
pRenderContext->SetStencilWriteMask( m_nWriteMask );
}
};
void CGlowObjectManager::RenderGlowEffects( const CViewSetup *pSetup, int nSplitScreenSlot )
{
if ( g_pMaterialSystemHardwareConfig->SupportsPixelShaders_2_0() )
{
if ( glow_outline_effect_enable.GetBool() )
{
CMatRenderContextPtr pRenderContext( materials );
int nX, nY, nWidth, nHeight;
pRenderContext->GetViewport( nX, nY, nWidth, nHeight );
PIXEvent _pixEvent( pRenderContext, "EntityGlowEffects" );
ApplyEntityGlowEffects( pSetup, nSplitScreenSlot, pRenderContext, glow_outline_effect_width.GetFloat(), nX, nY, nWidth, nHeight );
}
}
}
static void SetRenderTargetAndViewPort( ITexture *rt, int w, int h )
{
CMatRenderContextPtr pRenderContext( materials );
pRenderContext->SetRenderTarget(rt);
pRenderContext->Viewport(0,0,w,h);
}
void CGlowObjectManager::RenderGlowModels( const CViewSetup *pSetup, int nSplitScreenSlot, CMatRenderContextPtr &pRenderContext )
{
//==========================================================================================//
// This renders solid pixels with the correct coloring for each object that needs the glow. //
// After this function returns, this image will then be blurred and added into the frame //
// buffer with the objects stenciled out. //
//==========================================================================================//
pRenderContext->PushRenderTargetAndViewport();
// Save modulation color and blend
Vector vOrigColor;
render->GetColorModulation( vOrigColor.Base() );
float flOrigBlend = render->GetBlend();
// Get pointer to FullFrameFB
ITexture *pRtFullFrame = NULL;
pRtFullFrame = materials->FindTexture( FULL_FRAME_TEXTURE, TEXTURE_GROUP_RENDER_TARGET );
SetRenderTargetAndViewPort( pRtFullFrame, pSetup->width, pSetup->height );
pRenderContext->ClearColor3ub( 0, 0, 0 );
pRenderContext->ClearBuffers( true, false, false );
// Set override material for glow color
IMaterial *pMatGlowColor = NULL;
pMatGlowColor = materials->FindMaterial( "dev/glow_color", TEXTURE_GROUP_OTHER, true );
g_pStudioRender->ForcedMaterialOverride( pMatGlowColor );
ShaderStencilState_t stencilState;
stencilState.m_bEnable = false;
stencilState.m_nReferenceValue = 0;
stencilState.m_nTestMask = 0xFF;
stencilState.m_CompareFunc = STENCILCOMPARISONFUNCTION_ALWAYS;
stencilState.m_PassOp = STENCILOPERATION_KEEP;
stencilState.m_FailOp = STENCILOPERATION_KEEP;
stencilState.m_ZFailOp = STENCILOPERATION_KEEP;
stencilState.SetStencilState( pRenderContext );
//==================//
// Draw the objects //
//==================//
for ( int i = 0; i < m_GlowObjectDefinitions.Count(); ++ i )
{
if ( m_GlowObjectDefinitions[i].IsUnused() || !m_GlowObjectDefinitions[i].ShouldDraw( nSplitScreenSlot ) )
continue;
render->SetBlend( m_GlowObjectDefinitions[i].m_flGlowAlpha );
Vector vGlowColor = m_GlowObjectDefinitions[i].m_vGlowColor * m_GlowObjectDefinitions[i].m_flGlowAlpha;
render->SetColorModulation( &vGlowColor[0] ); // This only sets rgb, not alpha
m_GlowObjectDefinitions[i].DrawModel();
}
if ( g_bDumpRenderTargets )
{
DumpTGAofRenderTarget( pSetup->width, pSetup->height, "GlowModels" );
}
g_pStudioRender->ForcedMaterialOverride( NULL );
render->SetColorModulation( vOrigColor.Base() );
render->SetBlend( flOrigBlend );
ShaderStencilState_t stencilStateDisable;
stencilStateDisable.m_bEnable = false;
stencilStateDisable.SetStencilState( pRenderContext );
pRenderContext->PopRenderTargetAndViewport();
}
void CGlowObjectManager::ApplyEntityGlowEffects( const CViewSetup *pSetup, int nSplitScreenSlot, CMatRenderContextPtr &pRenderContext, float flBloomScale, int x, int y, int w, int h )
{
//=======================================================//
// Render objects into stencil buffer //
//=======================================================//
// Set override shader to the same simple shader we use to render the glow models
IMaterial *pMatGlowColor = materials->FindMaterial( "dev/glow_color", TEXTURE_GROUP_OTHER, true );
g_pStudioRender->ForcedMaterialOverride( pMatGlowColor );
ShaderStencilState_t stencilStateDisable;
stencilStateDisable.m_bEnable = false;
float flSavedBlend = render->GetBlend();
// Set alpha to 0 so we don't touch any color pixels
render->SetBlend( 0.0f );
pRenderContext->OverrideDepthEnable( true, false );
int iNumGlowObjects = 0;
for ( int i = 0; i < m_GlowObjectDefinitions.Count(); ++ i )
{
if ( m_GlowObjectDefinitions[i].IsUnused() || !m_GlowObjectDefinitions[i].ShouldDraw( nSplitScreenSlot ) )
continue;
if ( m_GlowObjectDefinitions[i].m_bRenderWhenOccluded || m_GlowObjectDefinitions[i].m_bRenderWhenUnoccluded )
{
if ( m_GlowObjectDefinitions[i].m_bRenderWhenOccluded && m_GlowObjectDefinitions[i].m_bRenderWhenUnoccluded )
{
ShaderStencilState_t stencilState;
stencilState.m_bEnable = true;
stencilState.m_nReferenceValue = 1;
stencilState.m_CompareFunc = STENCILCOMPARISONFUNCTION_ALWAYS;
stencilState.m_PassOp = STENCILOPERATION_REPLACE;
stencilState.m_FailOp = STENCILOPERATION_KEEP;
stencilState.m_ZFailOp = STENCILOPERATION_REPLACE;
stencilState.SetStencilState( pRenderContext );
m_GlowObjectDefinitions[i].DrawModel();
}
else if ( m_GlowObjectDefinitions[i].m_bRenderWhenOccluded )
{
ShaderStencilState_t stencilState;
stencilState.m_bEnable = true;
stencilState.m_nReferenceValue = 1;
stencilState.m_CompareFunc = STENCILCOMPARISONFUNCTION_ALWAYS;
stencilState.m_PassOp = STENCILOPERATION_KEEP;
stencilState.m_FailOp = STENCILOPERATION_KEEP;
stencilState.m_ZFailOp = STENCILOPERATION_REPLACE;
stencilState.SetStencilState( pRenderContext );
m_GlowObjectDefinitions[i].DrawModel();
}
else if ( m_GlowObjectDefinitions[i].m_bRenderWhenUnoccluded )
{
ShaderStencilState_t stencilState;
stencilState.m_bEnable = true;
stencilState.m_nReferenceValue = 2;
stencilState.m_nTestMask = 0x1;
stencilState.m_nWriteMask = 0x3;
stencilState.m_CompareFunc = STENCILCOMPARISONFUNCTION_EQUAL;
stencilState.m_PassOp = STENCILOPERATION_INCRSAT;
stencilState.m_FailOp = STENCILOPERATION_KEEP;
stencilState.m_ZFailOp = STENCILOPERATION_REPLACE;
stencilState.SetStencilState( pRenderContext );
m_GlowObjectDefinitions[i].DrawModel();
}
}
iNumGlowObjects++;
}
// Need to do a 2nd pass to warm stencil for objects which are rendered only when occluded
for ( int i = 0; i < m_GlowObjectDefinitions.Count(); ++ i )
{
if ( m_GlowObjectDefinitions[i].IsUnused() || !m_GlowObjectDefinitions[i].ShouldDraw( nSplitScreenSlot ) )
continue;
if ( m_GlowObjectDefinitions[i].m_bRenderWhenOccluded && !m_GlowObjectDefinitions[i].m_bRenderWhenUnoccluded )
{
ShaderStencilState_t stencilState;
stencilState.m_bEnable = true;
stencilState.m_nReferenceValue = 2;
stencilState.m_CompareFunc = STENCILCOMPARISONFUNCTION_ALWAYS;
stencilState.m_PassOp = STENCILOPERATION_REPLACE;
stencilState.m_FailOp = STENCILOPERATION_KEEP;
stencilState.m_ZFailOp = STENCILOPERATION_KEEP;
stencilState.SetStencilState( pRenderContext );
m_GlowObjectDefinitions[i].DrawModel();
}
}
pRenderContext->OverrideDepthEnable( false, false );
render->SetBlend( flSavedBlend );
stencilStateDisable.SetStencilState( pRenderContext );
g_pStudioRender->ForcedMaterialOverride( NULL );
// If there aren't any objects to glow, don't do all this other stuff
// this fixes a bug where if there are glow objects in the list, but none of them are glowing,
// the whole screen blooms.
if ( iNumGlowObjects <= 0 )
return;
//=============================================
// Render the glow colors to _rt_FullFrameFB
//=============================================
{
PIXEvent pixEvent( pRenderContext, "RenderGlowModels" );
RenderGlowModels( pSetup, nSplitScreenSlot, pRenderContext );
}
// Get viewport
int nSrcWidth = pSetup->width;
int nSrcHeight = pSetup->height;
int nViewportX, nViewportY, nViewportWidth, nViewportHeight;
pRenderContext->GetViewport( nViewportX, nViewportY, nViewportWidth, nViewportHeight );
// Get material and texture pointers
ITexture *pRtQuarterSize1 = materials->FindTexture( "_rt_SmallFB1", TEXTURE_GROUP_RENDER_TARGET );
{
//=======================================================================================================//
// At this point, pRtQuarterSize0 is filled with the fully colored glow around everything as solid glowy //
// blobs. Now we need to stencil out the original objects by only writing pixels that have no //
// stencil bits set in the range we care about. //
//=======================================================================================================//
IMaterial *pMatHaloAddToScreen = materials->FindMaterial( "dev/halo_add_to_screen", TEXTURE_GROUP_OTHER, true );
// Do not fade the glows out at all (weight = 1.0)
IMaterialVar *pDimVar = pMatHaloAddToScreen->FindVar( "$C0_X", NULL );
pDimVar->SetFloatValue( 1.0f );
// Set stencil state
ShaderStencilState_t stencilState;
stencilState.m_bEnable = true;
stencilState.m_nWriteMask = 0x0; // We're not changing stencil
stencilState.m_nTestMask = 0xFF;
stencilState.m_nReferenceValue = 0x0;
stencilState.m_CompareFunc = STENCILCOMPARISONFUNCTION_EQUAL;
stencilState.m_PassOp = STENCILOPERATION_KEEP;
stencilState.m_FailOp = STENCILOPERATION_KEEP;
stencilState.m_ZFailOp = STENCILOPERATION_KEEP;
stencilState.SetStencilState( pRenderContext );
// Draw quad
pRenderContext->DrawScreenSpaceRectangle( pMatHaloAddToScreen, 0, 0, nViewportWidth, nViewportHeight,
0.0f, -0.5f, nSrcWidth / 4 - 1, nSrcHeight / 4 - 1,
pRtQuarterSize1->GetActualWidth(),
pRtQuarterSize1->GetActualHeight() );
stencilStateDisable.SetStencilState( pRenderContext );
}
}
void CGlowObjectManager::GlowObjectDefinition_t::DrawModel()
{
if ( m_hEntity.Get() )
{
m_hEntity->DrawModel( STUDIO_RENDER );
C_BaseEntity *pAttachment = m_hEntity->FirstMoveChild();
while ( pAttachment != NULL )
{
if ( !g_GlowObjectManager.HasGlowEffect( pAttachment ) && pAttachment->ShouldDraw() )
{
pAttachment->DrawModel( STUDIO_RENDER );
}
pAttachment = pAttachment->NextMovePeer();
}
}
}
#endif // GLOWS_ENABLE | 4,423 |
3,469 | #!/usr/bin/env python
# -*- coding:utf-8 -*-
#
# Copyright 2014 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Model tests
Unit tests for model utility methods.
"""
from __future__ import absolute_import
__author__ = "<EMAIL> (<NAME>)"
import unittest
from googleapiclient.model import BaseModel
from googleapiclient.model import makepatch
TEST_CASES = [
# (message, original, modified, expected)
("Remove an item from an object", {"a": 1, "b": 2}, {"a": 1}, {"b": None}),
("Add an item to an object", {"a": 1}, {"a": 1, "b": 2}, {"b": 2}),
("No changes", {"a": 1, "b": 2}, {"a": 1, "b": 2}, {}),
("Empty objects", {}, {}, {}),
("Modify an item in an object", {"a": 1, "b": 2}, {"a": 1, "b": 3}, {"b": 3}),
("Change an array", {"a": 1, "b": [2, 3]}, {"a": 1, "b": [2]}, {"b": [2]}),
(
"Modify a nested item",
{"a": 1, "b": {"foo": "bar", "baz": "qux"}},
{"a": 1, "b": {"foo": "bar", "baz": "qaax"}},
{"b": {"baz": "qaax"}},
),
(
"Modify a nested array",
{"a": 1, "b": [{"foo": "bar", "baz": "qux"}]},
{"a": 1, "b": [{"foo": "bar", "baz": "qaax"}]},
{"b": [{"foo": "bar", "baz": "qaax"}]},
),
(
"Remove item from a nested array",
{"a": 1, "b": [{"foo": "bar", "baz": "qux"}]},
{"a": 1, "b": [{"foo": "bar"}]},
{"b": [{"foo": "bar"}]},
),
(
"Remove a nested item",
{"a": 1, "b": {"foo": "bar", "baz": "qux"}},
{"a": 1, "b": {"foo": "bar"}},
{"b": {"baz": None}},
),
]
class TestPatch(unittest.TestCase):
def test_patch(self):
for (msg, orig, mod, expected_patch) in TEST_CASES:
self.assertEqual(expected_patch, makepatch(orig, mod), msg=msg)
class TestBaseModel(unittest.TestCase):
def test_build_query(self):
model = BaseModel()
test_cases = [
("hello", "world", "?hello=world"),
("hello", u"world", "?hello=world"),
("hello", "세계", "?hello=%EC%84%B8%EA%B3%84"),
("hello", u"세계", "?hello=%EC%84%B8%EA%B3%84"),
("hello", "こんにちは", "?hello=%E3%81%93%E3%82%93%E3%81%AB%E3%81%A1%E3%81%AF"),
("hello", u"こんにちは", "?hello=%E3%81%93%E3%82%93%E3%81%AB%E3%81%A1%E3%81%AF"),
("hello", "你好", "?hello=%E4%BD%A0%E5%A5%BD"),
("hello", u"你好", "?hello=%E4%BD%A0%E5%A5%BD"),
("hello", "مرحبا", "?hello=%D9%85%D8%B1%D8%AD%D8%A8%D8%A7"),
("hello", u"مرحبا", "?hello=%D9%85%D8%B1%D8%AD%D8%A8%D8%A7"),
]
for case in test_cases:
key, value, expect = case
self.assertEqual(expect, model._build_query({key: value}))
if __name__ == "__main__":
unittest.main()
| 1,586 |
384 | /*
* This file is part of the GROMACS molecular simulation package.
*
* Copyright (c) 2013,2014,2016,2017,2018 by the GROMACS development team.
* Copyright (c) 2019,2020, by the GROMACS development team, led by
* <NAME>, <NAME>, <NAME>, and <NAME>,
* and including many others, as listed in the AUTHORS file in the
* top-level source directory and at http://www.gromacs.org.
*
* GROMACS is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2.1
* of the License, or (at your option) any later version.
*
* GROMACS 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with GROMACS; if not, see
* http://www.gnu.org/licenses, or write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*
* If you want to redistribute modifications to GROMACS, please
* consider that scientific software is very special. Version
* control is crucial - bugs must be traceable. We will be happy to
* consider code for inclusion in the official distribution, but
* derived work must not be called official GROMACS. Details are found
* in the README & COPYING files - if they are missing, get the
* official version at http://www.gromacs.org.
*
* To help us fund GROMACS development, we humbly ask that you cite
* the research papers on the package. Check out http://www.gromacs.org.
*/
/*! \libinternal \file
* \brief
* Wraps mpi.h usage in Gromacs.
*
* This header wraps the MPI header <mpi.h>, and should be included instead of
* that one. It abstracts away the case that depending on compilation
* settings, MPI routines may be provided by <mpi.h> or by thread-MPI.
* In the absence of MPI, this header still declares some types for
* convenience. It also disables MPI C++ bindings that can cause compilation
* issues.
*
* \inlibraryapi
* \ingroup module_utility
*/
#ifndef GMX_UTILITY_GMXMPI_H
#define GMX_UTILITY_GMXMPI_H
#include "config.h"
/*! \cond */
#if GMX_LIB_MPI
/* MPI C++ binding is deprecated and can cause name conflicts (e.g. stdio/mpi seek) */
# define MPICH_SKIP_MPICXX 1
# define OMPI_SKIP_MPICXX 1
/* disable bindings for SGI MPT also */
# define MPI_NO_CPPBIND 1
# include <mpi.h>
/* Starting with 2.2 MPI_INT64_T is required. Earlier version still might have it.
In theory MPI_Datatype doesn't have to be a #define, but current available MPI
implementations (OpenMPI + MPICH (+derivates)) use #define and future versions
should support 2.2. */
# if (MPI_VERSION == 1 || (MPI_VERSION == 2 && MPI_SUBVERSION < 2)) && !defined MPI_INT64_T
# include <limits.h>
# if LONG_MAX == 9223372036854775807L
# define MPI_INT64_T MPI_LONG
# elif LONG_LONG_MAX == 9223372036854775807L
# define MPI_INT64_T MPI_LONG_LONG
# else
# error No MPI_INT64_T and no 64 bit integer found.
# endif
# endif /*MPI_INT64_T*/
#else
# if GMX_THREAD_MPI
# include "thread_mpi/mpi_bindings.h" /* IWYU pragma: export */
# include "thread_mpi/tmpi.h" /* IWYU pragma: export */
# else
typedef void* MPI_Comm;
typedef void* MPI_Request;
typedef void* MPI_Status;
typedef void* MPI_Group;
# define MPI_COMM_NULL nullptr
# define MPI_GROUP_NULL nullptr
# define MPI_COMM_WORLD nullptr
# endif
#endif
//! \endcond
#endif
| 1,304 |
642 | <gh_stars>100-1000
package com.jeesuite.mybatis.plugin.rewrite;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;
import org.apache.commons.lang3.StringUtils;
import org.apache.ibatis.cache.CacheKey;
import org.apache.ibatis.executor.Executor;
import org.apache.ibatis.mapping.BoundSql;
import org.apache.ibatis.mapping.MappedStatement;
import org.apache.ibatis.mapping.ParameterMapping;
import org.apache.ibatis.session.ResultHandler;
import org.apache.ibatis.session.RowBounds;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.jeesuite.common.JeesuiteBaseException;
import com.jeesuite.common.model.OrderBy;
import com.jeesuite.common.model.OrderBy.OrderType;
import com.jeesuite.common.model.PageParams;
import com.jeesuite.common.util.ResourceUtils;
import com.jeesuite.mybatis.MybatisConfigs;
import com.jeesuite.mybatis.MybatisRuntimeContext;
import com.jeesuite.mybatis.core.InterceptorHandler;
import com.jeesuite.mybatis.crud.helper.ColumnMapper;
import com.jeesuite.mybatis.crud.helper.EntityHelper;
import com.jeesuite.mybatis.parser.EntityInfo;
import com.jeesuite.mybatis.parser.MybatisMapperParser;
import com.jeesuite.mybatis.plugin.InvocationVals;
import com.jeesuite.mybatis.plugin.JeesuiteMybatisInterceptor;
import net.sf.jsqlparser.JSQLParserException;
import net.sf.jsqlparser.expression.Expression;
import net.sf.jsqlparser.expression.StringValue;
import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
import net.sf.jsqlparser.expression.operators.relational.EqualsTo;
import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
import net.sf.jsqlparser.expression.operators.relational.InExpression;
import net.sf.jsqlparser.parser.CCJSqlParserUtil;
import net.sf.jsqlparser.schema.Column;
import net.sf.jsqlparser.schema.Table;
import net.sf.jsqlparser.statement.select.Join;
import net.sf.jsqlparser.statement.select.OrderByElement;
import net.sf.jsqlparser.statement.select.PlainSelect;
import net.sf.jsqlparser.statement.select.Select;
/**
* sql重写处理器 <br>
* Class Name : SqlRewriteHandler
*
* @author jiangwei
* @version 1.0.0
* @date 2019年10月28日
*/
public class SqlRewriteHandler implements InterceptorHandler {
private final static Logger logger = LoggerFactory.getLogger("com.jeesuite.mybatis.plugin");
public static final String TENANT_ID = "tenantId";
private static final String FRCH_INDEX_PREFIX = "_frch_index_";
private static final String FRCH_ITEM_PREFIX = "__frch_item_";
private Map<String, Map<String,String>> dataProfileMappings = new HashMap<>();
private boolean isFieldSharddingTenant;
@Override
public void start(JeesuiteMybatisInterceptor context) {
isFieldSharddingTenant = MybatisConfigs.isFieldSharddingTenant(context.getGroupName());
Properties properties = ResourceUtils.getAllProperties("jeesuite.mybatis.dataPermission.mappings");
properties.forEach( (k,v) -> {
String tableName = k.toString().substring(k.toString().indexOf("[") + 1).replace("]", "").trim();
buildTableDataProfileMapping(tableName, v.toString());
} );
final List<EntityInfo> entityInfos = MybatisMapperParser.getEntityInfos(context.getGroupName());
//字段隔离租户模式
if (isFieldSharddingTenant) {
String tenantField = MybatisConfigs.getTenantSharddingField(context.getGroupName());
ColumnMapper tenantColumn;
for (EntityInfo entityInfo : entityInfos) {
tenantColumn = EntityHelper.getTableColumnMappers(entityInfo.getTableName()).stream().filter(o -> {
return o.getColumn().equals(tenantField) || o.getProperty().equals(tenantField);
}).findFirst().orElse(null);
if (tenantColumn == null)
continue;
if (!dataProfileMappings.containsKey(entityInfo.getTableName())) {
dataProfileMappings.put(entityInfo.getTableName(), new HashMap<>());
}
dataProfileMappings.get(entityInfo.getTableName()).put(TENANT_ID, tenantColumn.getColumn());
}
}
logger.info("dataProfileMappings >> {}",dataProfileMappings);
}
@Override
public Object onInterceptor(InvocationVals invocation) throws Throwable {
if(!invocation.isSelect())return null;
Map<String, String[]> dataMappings = MybatisRuntimeContext.getDataProfileMappings();
//
rewriteSql(invocation, dataMappings);
if(invocation.getPageParam() != null)return null;
//不查数据库直接返回
if(invocation.getSql() == null) {
List<Object> list = new ArrayList<>(1);
//
EntityInfo entityInfo = MybatisMapperParser.getEntityInfoByMapper(invocation.getMapperNameSpace());
String methodName = invocation.getMappedStatement().getId().replace(invocation.getMapperNameSpace(), StringUtils.EMPTY).substring(1);
Class<?> returnType = entityInfo.getMapperMethod(methodName).getMethod().getReturnType();
if(returnType == int.class || returnType == Integer.class|| returnType == long.class|| returnType == Long.class) {
list.add(0);
}
return list;
}else {
Executor executor = invocation.getExecutor();
MappedStatement mappedStatement = invocation.getMappedStatement();
ResultHandler<?> resultHandler = (ResultHandler<?>) invocation.getArgs()[3];
List<ParameterMapping> parameterMappings = invocation.getBoundSql().getParameterMappings();
BoundSql newBoundSql = new BoundSql(mappedStatement.getConfiguration(), invocation.getSql(),parameterMappings, invocation.getParameter());
//
copyForeachAdditionlParams(invocation.getBoundSql(), newBoundSql);
CacheKey cacheKey = executor.createCacheKey(mappedStatement, invocation.getParameter(), RowBounds.DEFAULT, newBoundSql);
List<?> resultList = executor.query(mappedStatement, invocation.getParameter(), RowBounds.DEFAULT, resultHandler, cacheKey,newBoundSql);
return resultList;
}
}
public static void copyForeachAdditionlParams(BoundSql originBoundSql, BoundSql newBoundSql) {
List<ParameterMapping> parameterMappings = originBoundSql.getParameterMappings();
Object additionalParamVal;
int itemIndex = 0;
for (ParameterMapping parameterMapping : parameterMappings) {
if(!parameterMapping.getProperty().startsWith(FRCH_ITEM_PREFIX)) {
continue;
}
if(originBoundSql.hasAdditionalParameter(parameterMapping.getProperty())) {
additionalParamVal = originBoundSql.getAdditionalParameter(parameterMapping.getProperty());
newBoundSql.setAdditionalParameter(parameterMapping.getProperty(), additionalParamVal);
newBoundSql.setAdditionalParameter(FRCH_INDEX_PREFIX + itemIndex, itemIndex);
itemIndex++;
}
}
}
/**
* @param invocation
* @param dataMappings
* @return
*/
private void rewriteSql(InvocationVals invocation, Map<String, String[]> dataMapping) {
String orignSql = invocation.getSql();
PageParams pageParam = invocation.getPageParam();
String currentTenantId = null;
if(isFieldSharddingTenant) {
currentTenantId = MybatisRuntimeContext.getCurrentTenant();
if(currentTenantId == null)throw new JeesuiteBaseException("无法获取当前租户ID");
if(dataMapping == null)dataMapping = new HashMap<>(1);
dataMapping.put(TENANT_ID, new String[] {currentTenantId});
}
if(dataMapping == null && currentTenantId == null) {
if(pageParam == null || (pageParam.getOrderBys() == null || pageParam.getOrderBys().isEmpty())) {
return;
}
}
Select select = null;
try {
select = (Select) CCJSqlParserUtil.parse(orignSql);
} catch (JSQLParserException e) {
logger.error("rebuildDataProfileSql_ERROR",e);
throw new RuntimeException("sql解析错误");
}
PlainSelect selectBody = (PlainSelect) select.getSelectBody();
Table table = (Table) selectBody.getFromItem();
Map<String, String> columnMapping;
Set<String> fieldNames;
Expression newExpression = null;
String[] values;
if(dataProfileMappings.containsKey(table.getName())) {
columnMapping = dataProfileMappings.get(table.getName());
fieldNames = columnMapping.keySet();
for (String fieldName : fieldNames) {
if(!dataMapping.containsKey(fieldName))continue;
values = dataMapping.get(fieldName);
//如果某个匹配字段为空直接返回null，不在查询数据库
if(values == null || values.length == 0) {
invocation.setRewriteSql(null);
return;
}
newExpression = appendDataProfileCondition(table, selectBody.getWhere(), columnMapping.get(fieldName),values);
selectBody.setWhere(newExpression);
//TODO 主表已经处理的条件，join表不在处理
}
}
//JOIN
List<Join> joins = selectBody.getJoins();
if(joins != null){
for (Join join : joins) {
table = (Table) join.getRightItem();
if(dataProfileMappings.containsKey(table.getName())) {
columnMapping = dataProfileMappings.get(table.getName());
fieldNames = columnMapping.keySet();
for (String fieldName : fieldNames) {
if(!dataMapping.containsKey(fieldName))continue;
values = dataMapping.get(fieldName);
//如果某个匹配字段为空直接返回null，不在查询数据库
if(values == null || values.length == 0) {
return;
}
//左右连接加在ON 无法过滤
newExpression = appendDataProfileCondition(table, selectBody.getWhere(), columnMapping.get(fieldName),values);
selectBody.setWhere(newExpression);
}
}
}
}
if(pageParam != null && pageParam.getOrderBys() != null && !pageParam.getOrderBys().isEmpty()) {
List<OrderByElement> orderByElements = new ArrayList<>(pageParam.getOrderBys().size());
OrderByElement orderByElement;
for (OrderBy orderBy : pageParam.getOrderBys()) {
if(orderBy == null)continue;
String columnName = MybatisMapperParser.property2ColumnName(invocation.getMapperNameSpace(), orderBy.getField());
if(columnName == null)continue;
orderByElement = new OrderByElement();
orderByElement.setAsc(OrderType.ASC.name().equals(orderBy.getSortType()));
orderByElement.setExpression(new Column(table, columnName));
orderByElements.add(orderByElement);
}
selectBody.setOrderByElements(orderByElements);
}
//
invocation.setRewriteSql(selectBody.toString());
}
private static Expression appendDataProfileCondition(Table table,Expression orginExpression,String columnName,String[] values){
Expression newExpression = null;
Column column = new Column(table, columnName);
if (values.length == 1) {
EqualsTo equalsTo = new EqualsTo();
equalsTo.setLeftExpression(column);
equalsTo.setRightExpression(new StringValue(values[0]));
newExpression = orginExpression == null ? equalsTo : new AndExpression(equalsTo,orginExpression);
} else {
ExpressionList expressionList = new ExpressionList(new ArrayList<>(values.length));
for (String value : values) {
expressionList.getExpressions().add(new StringValue(value));
}
InExpression inExpression = new InExpression(column, expressionList);
newExpression = orginExpression == null ? inExpression : new AndExpression(orginExpression,inExpression);
}
return newExpression;
}
private void buildTableDataProfileMapping(String tableName,String ruleString) {
dataProfileMappings.put(tableName, new HashMap<>());
String[] rules = ruleString.split(",|;");
String[] tmpArr;
for (String rule : rules) {
tmpArr = rule.split(":");
String columnName = tmpArr.length == 2 ? tmpArr[1] : rule;
dataProfileMappings.get(tableName).put(tmpArr[0], columnName);
}
}
@Override
public void onFinished(InvocationVals invocation, Object result) {
}
@Override
public int interceptorOrder() {
//需要在分页前执行
return 2;
}
@Override
public void close() {
}
}
| 4,382 |
1,157 | /*
* Copyright (c) 2018 MariaDB Corporation Ab
*
* Use of this software is governed by the Business Source License included
* in the LICENSE.TXT file and at www.mariadb.com/bsl11.
*
* Change Date: 2025-10-11
*
* On the date above, in accordance with the Business Source License, use
* of this software will be governed by version 2 or later of the General
* Public License.
*/
#pragma once
#include <maxscale/ccdefs.hh>
#include <memory>
#include <string>
/**
* The MXS_AUTHENTICATOR version data. The following should be updated whenever
* the MXS_AUTHENTICATOR structure is changed. See the rules defined in modinfo.h
* that define how these numbers should change.
*/
#define MXS_AUTHENTICATOR_VERSION {3, 0, 0}
namespace maxscale
{
class ConfigParameters;
/**
* Base class off all authenticator modules.
*/
class AuthenticatorModule
{
public:
virtual ~AuthenticatorModule() = default;
/**
* Get name of supported protocol module.
*
* @return Supported protocol
*/
virtual std::string supported_protocol() const = 0;
/**
* Get the module name.
*
* @return Module name
*/
virtual std::string name() const = 0;
};
using SAuthenticatorModule = std::unique_ptr<AuthenticatorModule>;
/**
* This struct contains the authenticator entrypoint in a shared library.
*/
struct AUTHENTICATOR_API
{
/**
* Create an authenticator module instance.
*
* @param options Authenticator options
* @return Authenticator object, or null on error
*/
mxs::AuthenticatorModule* (*create)(ConfigParameters* options);
};
template<class AuthenticatorImplementation>
class AuthenticatorApiGenerator
{
public:
AuthenticatorApiGenerator() = delete;
AuthenticatorApiGenerator(const AuthenticatorApiGenerator&) = delete;
AuthenticatorApiGenerator& operator=(const AuthenticatorApiGenerator&) = delete;
static AuthenticatorModule* createInstance(mxs::ConfigParameters* options)
{
AuthenticatorModule* instance = nullptr;
MXS_EXCEPTION_GUARD(instance = AuthenticatorImplementation::create(options));
return instance;
}
static AUTHENTICATOR_API s_api;
};
template<class AuthenticatorImplementation>
AUTHENTICATOR_API AuthenticatorApiGenerator<AuthenticatorImplementation>::s_api =
{
&AuthenticatorApiGenerator<AuthenticatorImplementation>::createInstance
};
}
namespace maxscale
{
std::unique_ptr<mxs::AuthenticatorModule> authenticator_init(const std::string& authenticator,
mxs::ConfigParameters* options);
}
| 865 |
511 | <filename>external/iotivity/iotivity_1.2-rel/service/scene-manager/include/RemoteSceneList.h
//******************************************************************
//
// Copyright 2016 Samsung Electronics All Rights Reserved.
//
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
#ifndef SM_REMOTE_SCENELIST_H_
#define SM_REMOTE_SCENELIST_H_
#include <memory>
#include <vector>
#include <functional>
#include <mutex>
#include "RemoteSceneCollection.h"
#include "RCSRemoteResourceObject.h"
namespace OIC
{
namespace Service
{
class SceneListResourceRequestor;
/**
* @class RemoteSceneList
*
* @brief RemoteSceneList class is an interface class to send a request to
* SceneList resource on remote side. This class provides APIs for adding
* new SceneCollection resource to the SceneList resource and
* creating a RemoteSceneCollection instance corresponding to the
* created SceneCollection resource. This class also supports retrieving the existing
* instances as well as setting/getting a name attribute of the SceneList resource.
*/
class RemoteSceneList
{
public:
typedef std::unique_ptr< RemoteSceneList > Ptr;
/**
* Callback definition to be invoked when a response of createInstance is
* received.
*
* @param list Created RemoteSceneList instance pointer
* @param eCode The error code received from the SceneList on remote side
*
* @note Error code '200' stands for success, '400' for bad request,
* and '500' for internal error.
*
* @see createInstance
*/
typedef std::function< void(RemoteSceneList::Ptr list, int eCode) >
CreateInstanceCallback;
/**
* Callback definition to be invoked when a response of addNewSceneCollection is
* received.
*
* @param collection Created RemoteSceneCollection instance pointer
* @param eCode The error code received from the SceneList on remote
*
* @note Error code '200' stands for success, '400' for bad request,
* and '500' for internal error.
*
* @see addNewSceneCollection
*/
typedef std::function< void(RemoteSceneCollection::Ptr collection, int eCode) >
AddNewSceneCollectionCallback;
/**
* Callback definition to be invoked when a response of setName is
* received.
*
* @param eCode the error code received from the SceneList on remote
*
* @note Error code '200' stands for success, '400' for bad request,
* and '500' for internal error.
*
* @see setName
*/
typedef std::function< void(int eCode) > SetNameCallback;
public:
~RemoteSceneList() = default;
/**
* Creates RemoteSceneList instance with provided RCSRemoteResourceObject of
* discovered SceneList resource on remote side.
*
* To create RemoteSceneList instance, discovery of SceneList resource
* which has 'oic.wk.scenelist' as resource type is required,
* and the found resource should be provided as parameter.
* After that, one can acceess existing SceneCollections, Scenes, and SceneActions
* instances that are already produced at the SceneList resource.
* Created RemoteSceneList will be delivered to CreateInstanceCallback.
*
* @param sceneListResource RCSRemoteResourceObject pointer of SceneList
* @param cb A callback to receive the response
*
* @throws RCSInvalidParameterException If parameter is invalid.
* @throws PlatformException If the platform operation failed
*
* @see RCSRemoteResourceObject
*/
static void createInstance(
RCSRemoteResourceObject::Ptr sceneListResource, CreateInstanceCallback cb);
/**
* Requests to add new SceneCollection resource to the SceneList resource on remote
* side and creates RemoteSceneCollection instance corresponding to the created
* SceneCollection resource.
*
* @param cb A callback to receive created RemoteSceneCollection instance
*
* @throws RCSInvalidParameterException If callback is null.
* @throws PlatformException If the platform operation failed
*
* @note RemoteSceneCollection instance is only produced by RemoteSceneList class.
*/
void addNewSceneCollection(AddNewSceneCollectionCallback cb);
/**
* Gets all RemoteSceneCollection instances stored in the RemoteSceneList instance.
*
* @return A vector of shared pointers of RemoteSceneCollection instances
*/
std::vector< RemoteSceneCollection::Ptr > getRemoteSceneCollections() const;
/**
* Request to set a name attribute of the SceneList resource on remote side.
*
* @param name A name of the SceneList
* @param cb A callback to receive the response
*
* @throws RCSInvalidParameterException If callback is null.
* @throws PlatformException If the platform operation failed
*/
void setName(const std::string &name, SetNameCallback cb);
/**
* Gets a name attribute of the SceneList resource.
*
* @return A name of the SceneList resource
*/
std::string getName() const;
private:
RemoteSceneList(std::shared_ptr< SceneListResourceRequestor >);
static void onInstanceCreated(const RCSRepresentation &, int, const std::string &,
std::shared_ptr< SceneListResourceRequestor >, const CreateInstanceCallback &);
static RemoteSceneList::Ptr buildSceneList(
std::shared_ptr< SceneListResourceRequestor >, const RCSResourceAttributes &);
RemoteSceneCollection::Ptr createRemoteSceneCollection(
const std::string &link, const std::string &id, const std::string &name);
std::shared_ptr< SceneListResourceRequestor > getListResourceRequestor() const;
std::vector<std::pair<RCSResourceAttributes, std::vector<RCSResourceAttributes>>>
parseSceneListFromAttributes(const RCSResourceAttributes &);
std::vector<RCSResourceAttributes> getChildrenAttributes(
const RCSResourceAttributes &) const;
void onSceneCollectionCreated(
const std::string &link, const std::string &id, const std::string &name,
int, const AddNewSceneCollectionCallback &);
void onNameSet(int, const std::string &, const SetNameCallback &);
private:
std::string m_name;
std::vector< RemoteSceneCollection::Ptr > m_remoteSceneCollections;
mutable std::mutex m_nameLock;
mutable std::mutex m_collectionLock;
std::shared_ptr< SceneListResourceRequestor > m_requestor;
};
}
}
#endif /* SM_REMOTE_SCENELIST_H_ */ | 3,665 |
5,169 | <reponame>Gantios/Specs<filename>Specs/1/1/2/BJTDemoView/0.0.1/BJTDemoView.podspec.json
{
"name": "BJTDemoView",
"version": "0.0.1",
"summary": "A BJTDemoView",
"homepage": "https://github.com/TechAlleyBoy",
"license": "MIT",
"authors": {
"TechAlleyBoy": "<EMAIL>"
},
"platforms": {
"ios": "7.0"
},
"source": {
"git": "https://github.com/TechAlleyBoy/BJTDemo.git",
"tag": "0.0.1"
},
"source_files": "BJTDemoView/*"
}
| 227 |
312 | <filename>test/system/ordered_caller.hpp
// Copyright <NAME> 2021
//
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
#ifndef MQTT_ORDERED_CALLER_HPP
#define MQTT_ORDERED_CALLER_HPP
#include <vector>
#include <string>
#include <functional>
struct ordered_caller {
template <typename... Funcs>
ordered_caller(std::size_t& index, Funcs&&... funcs)
: index_ {index}, funcs_ { std::forward<Funcs>(funcs)... } {}
bool operator()() {
if (index_ >= funcs_.size()) {
return false;
}
funcs_[index_++]();
return true;
}
private:
std::size_t& index_;
std::vector<std::function<void()>> funcs_;
};
static std::map<std::string, std::size_t> ordered_caller_fileline_to_index;
inline void clear_ordered() {
ordered_caller_fileline_to_index.clear();
}
template <typename... Funcs>
auto make_ordered_caller(std::string file, std::size_t line, Funcs&&... funcs) {
return
ordered_caller{
ordered_caller_fileline_to_index[file + std::to_string(line)],
std::forward<Funcs>(funcs)...
}();
}
#define MQTT_ORDERED(...) \
make_ordered_caller(__FILE__, __LINE__, __VA_ARGS__)
#endif // MQTT_ORDERED_CALLER_HPP
| 611 |
952 | package com.guoxiaoxing.phoenix.core.common;
public final class PhoenixConstant {
public static final String PHOENIX_RESULT = "PHOENIX_RESULT";
public static final String PHOENIX_OPTION = "PHOENIX_OPTION";
public static final int IMAGE_PROCESS_TYPE_DEFAULT = 0x000000;
public static final int REQUEST_CODE_PICTURE_EDIT = 0x000001;
public static final int REQUEST_CODE_CAPTURE = 0x000002;
public static final int REQUEST_CODE_CAMERA_PERMISSIONS = 0x000100;
public static final int REQUEST_CODE_PREVIEW = 0x000101;
public static final int TYPE_PREIVEW_FROM_PICK = 0x000100;
public static final int TYPE_PREIVEW_FROM_PREVIEW = 0x000101;
public static final int TYPE_PREIVEW_FROM_CAMERA = 0x000102;
/**
* 拍摄照片的最大数量
*/
public static final String KEY_TAKE_PICTURE_MAX_NUM = "KEY_TAKE_PICTURE_MAX_NUM";
/**
* 文件路径
*/
public static final String KEY_FILE_PATH = "KEY_FILE_PATH";
/**
* 文件byte数组
*/
public static final String KEY_FILE_BYTE = "KEY_FILE_BYTE";
/**
* 当前索引/位置
*/
public static final String KEY_POSITION = "KEY_POSITION";
/**
* 图片方向
*/
public static final String KEY_ORIENTATION = "KEY_ORIENTATION";
/**
* 图片/视频列表
*/
public final static String KEY_ALL_LIST = "KEY_ALL_LIST";
/**
* 已选择的图片/视频列表
*/
public final static String KEY_PICK_LIST = "KEY_PICK_LIST";
public final static String EXTRA_BOTTOM_PREVIEW = "EXTRA_BOTTOM_PREVIEW";
/**
* 预览类型，从选择界面进入/从拍照界面进入。
*/
public static final String KEY_PREVIEW_TYPE = "";
public static final String BITMPA_KEY = "bitmap_key";
public static final String ROTATION_KEY = "rotation_key";
public static final String IMAGE_INFO = "image_info";
public final static String FC_TAG = "picture";
public final static String EXTRA_RESULT_SELECTION = "extra_result_media";
public final static String EXTRA_LOCAL_MEDIAS = "localMedias";
public final static String EXTRA_ON_PICTURE_DELETE_LISTNER = "onPictureDeleteListener";
public final static String EXTRA_MEDIA = "media";
public final static String DIRECTORY_PATH = "directory_path";
public final static String BUNDLE_CAMERA_PATH = "CameraPath";
public final static String BUNDLE_ORIGINAL_PATH = "OriginalPath";
public final static String EXTRA_PICKER_OPTION = "PictureSelectorConfig";
public final static String AUDIO = "audio";
public final static String IMAGE = "image";
public final static String VIDEO = "video";
public final static int FLAG_PREVIEW_UPDATE_SELECT = 2774;// 预览界面更新选中数据 标识
public final static int CLOSE_PREVIEW_FLAG = 2770;// 关闭预览界面 标识
public final static int FLAG_PREVIEW_COMPLETE = 2771;// 预览界面图片 标识
public final static int TYPE_ALL = 0;
public final static int TYPE_IMAGE = 1;
public final static int TYPE_VIDEO = 2;
public final static int TYPE_AUDIO = 3;
public static final int MAX_COMPRESS_SIZE = 102400;
public static final int TYPE_CAMERA = 1;
public static final int TYPE_PICTURE = 2;
}
| 1,311 |
575 | <filename>third_party/blink/renderer/modules/webdatabase/sql_transaction_backend.cc
/*
* Copyright (C) 2007, 2008, 2013 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY APPLE AND ITS 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 APPLE OR ITS 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 "third_party/blink/renderer/modules/webdatabase/sql_transaction_backend.h"
#include <memory>
#include "base/stl_util.h"
#include "third_party/blink/renderer/modules/webdatabase/database.h"
#include "third_party/blink/renderer/modules/webdatabase/database_authorizer.h"
#include "third_party/blink/renderer/modules/webdatabase/database_context.h"
#include "third_party/blink/renderer/modules/webdatabase/database_thread.h"
#include "third_party/blink/renderer/modules/webdatabase/database_tracker.h"
#include "third_party/blink/renderer/modules/webdatabase/sql_error.h"
#include "third_party/blink/renderer/modules/webdatabase/sql_statement_backend.h"
#include "third_party/blink/renderer/modules/webdatabase/sql_transaction.h"
#include "third_party/blink/renderer/modules/webdatabase/sql_transaction_client.h"
#include "third_party/blink/renderer/modules/webdatabase/sql_transaction_coordinator.h"
#include "third_party/blink/renderer/modules/webdatabase/sqlite/sql_value.h"
#include "third_party/blink/renderer/modules/webdatabase/sqlite/sqlite_transaction.h"
#include "third_party/blink/renderer/modules/webdatabase/storage_log.h"
#include "third_party/blink/renderer/platform/wtf/std_lib_extras.h"
// How does a SQLTransaction work?
// ==============================
// The SQLTransaction is a state machine that executes a series of states /
// steps.
//
// The work of the transaction states are defined in section of 4.3.2 of the
// webdatabase spec: http://dev.w3.org/html5/webdatabase/#processing-model
//
// the State Transition Graph at a glance:
// ======================================
//
// Backend . Frontend
// (works with SQLiteDatabase) . (works with Script)
// =========================== . ===================
// .
// 1. Idle .
// v .
// 2. AcquireLock .
// v .
// 3. OpenTransactionAndPreflight -----------------------------------.
// | . |
// `-------------------------> 8. DeliverTransactionCallback --. |
// . | v v
// ,------------------------------' 9. DeliverTransactionErrorCallback +
// | . ^ ^ ^ |
// v . | | | |
// 4. RunStatements -----------------------------------------------' | | |
// | ^ ^ | ^ | . | | |
// |--------' | | | `------> 10. DeliverStatementCallback +----' | |
// | | | `---------------------------------------' | |
// | | `-----------> 11. DeliverQuotaIncreaseCallback + | |
// | `-----------------------------------------------' | |
// v . | |
// 5. PostflightAndCommit --+------------------------------------------' |
// |----> 12. DeliverSuccessCallback + |
// ,--------------------' . | |
// v . | |
// 6. CleanupAndTerminate <-----------------------------------' |
// v ^ . |
// 0. End | . |
// | . |
// 7: CleanupAfterTransactionErrorCallback <--------------------'
// .
//
// the States and State Transitions:
// ================================
// 0. SQLTransactionState::End
// - the end state.
//
// 1. SQLTransactionState::Idle
// - placeholder state while waiting on frontend/backend, etc. See
// comment on "State transitions between SQLTransaction and
// SQLTransactionBackend" below.
//
// 2. SQLTransactionState::AcquireLock (runs in backend)
// - this is the start state.
// - acquire the "lock".
// - on "lock" acquisition, goto
// SQLTransactionState::OpenTransactionAndPreflight.
//
// 3. SQLTransactionState::openTransactionAndPreflight (runs in backend)
// - Sets up an SQLiteTransaction.
// - begin the SQLiteTransaction.
// - call the SQLTransactionWrapper preflight if available.
// - schedule script callback.
// - on error, goto
// SQLTransactionState::DeliverTransactionErrorCallback.
// - goto SQLTransactionState::DeliverTransactionCallback.
//
// 4. SQLTransactionState::DeliverTransactionCallback (runs in frontend)
// - invoke the script function callback() if available.
// - on error, goto
// SQLTransactionState::DeliverTransactionErrorCallback.
// - goto SQLTransactionState::RunStatements.
//
// 5. SQLTransactionState::DeliverTransactionErrorCallback (runs in
// frontend)
// - invoke the script function errorCallback if available.
// - goto SQLTransactionState::CleanupAfterTransactionErrorCallback.
//
// 6. SQLTransactionState::RunStatements (runs in backend)
// - while there are statements {
// - run a statement.
// - if statementCallback is available, goto
// SQLTransactionState::DeliverStatementCallback.
// - on error,
// goto SQLTransactionState::DeliverQuotaIncreaseCallback, or
// goto SQLTransactionState::DeliverStatementCallback, or
// goto SQLTransactionState::deliverTransactionErrorCallback.
// }
// - goto SQLTransactionState::PostflightAndCommit.
//
// 7. SQLTransactionState::DeliverStatementCallback (runs in frontend)
// - invoke script statement callback (assume available).
// - on error, goto
// SQLTransactionState::DeliverTransactionErrorCallback.
// - goto SQLTransactionState::RunStatements.
//
// 8. SQLTransactionState::DeliverQuotaIncreaseCallback (runs in frontend)
// - give client a chance to increase the quota.
// - goto SQLTransactionState::RunStatements.
//
// 9. SQLTransactionState::PostflightAndCommit (runs in backend)
// - call the SQLTransactionWrapper postflight if available.
// - commit the SQLiteTansaction.
// - on error, goto
// SQLTransactionState::DeliverTransactionErrorCallback.
// - if successCallback is available, goto
// SQLTransactionState::DeliverSuccessCallback.
// else goto SQLTransactionState::CleanupAndTerminate.
//
// 10. SQLTransactionState::DeliverSuccessCallback (runs in frontend)
// - invoke the script function successCallback() if available.
// - goto SQLTransactionState::CleanupAndTerminate.
//
// 11. SQLTransactionState::CleanupAndTerminate (runs in backend)
// - stop and clear the SQLiteTransaction.
// - release the "lock".
// - goto SQLTransactionState::End.
//
// 12. SQLTransactionState::CleanupAfterTransactionErrorCallback (runs in
// backend)
// - rollback the SQLiteTransaction.
// - goto SQLTransactionState::CleanupAndTerminate.
//
// State transitions between SQLTransaction and SQLTransactionBackend
// ==================================================================
// As shown above, there are state transitions that crosses the boundary between
// the frontend and backend. For example,
//
// OpenTransactionAndPreflight (state 3 in the backend)
// transitions to DeliverTransactionCallback (state 8 in the frontend),
// which in turn transitions to RunStatements (state 4 in the backend).
//
// This cross boundary transition is done by posting transition requests to the
// other side and letting the other side's state machine execute the state
// transition in the appropriate thread (i.e. the script thread for the
// frontend, and the database thread for the backend).
//
// Logically, the state transitions work as shown in the graph above. But
// physically, the transition mechanism uses the Idle state (both in the
// frontend and backend) as a waiting state for further activity. For example,
// taking a closer look at the 3 state transition example above, what actually
// happens is as follows:
//
// Step 1:
// ======
// In the frontend thread:
// - waiting quietly is Idle. Not doing any work.
//
// In the backend:
// - is in OpenTransactionAndPreflight, and doing its work.
// - when done, it transits to the backend DeliverTransactionCallback.
// - the backend DeliverTransactionCallback sends a request to the frontend
// to transit to DeliverTransactionCallback, and then itself transits to
// Idle.
//
// Step 2:
// ======
// In the frontend thread:
// - transits to DeliverTransactionCallback and does its work.
// - when done, it transits to the frontend RunStatements.
// - the frontend RunStatements sends a request to the backend to transit
// to RunStatements, and then itself transits to Idle.
//
// In the backend:
// - waiting quietly in Idle.
//
// Step 3:
// ======
// In the frontend thread:
// - waiting quietly is Idle. Not doing any work.
//
// In the backend:
// - transits to RunStatements, and does its work.
// ...
//
// So, when the frontend or backend are not active, they will park themselves in
// their Idle states. This means their m_nextState is set to Idle, but they
// never actually run the corresponding state function. Note: for both the
// frontend and backend, the state function for Idle is unreachableState().
//
// The states that send a request to their peer across the front/back boundary
// are implemented with just 2 functions: SQLTransaction::sendToBackendState()
// and SQLTransactionBackend::sendToFrontendState(). These state functions do
// nothing but sends a request to the other side to transit to the current
// state (indicated by m_nextState), and then transits itself to the Idle state
// to wait for further action.
// The Life-Cycle of a SQLTransaction i.e. Who's keeping the SQLTransaction
// alive?
// ==============================================================================
// The RefPtr chain goes something like this:
//
// At birth (in Database::runTransaction()):
// ====================================================
// Database
// // HeapDeque<Member<SQLTransactionBackend>> m_transactionQueue
// // points to ...
// --> SQLTransactionBackend
// // Member<SQLTransaction> m_frontend points to ...
// --> SQLTransaction
// // Member<SQLTransactionBackend> m_backend points to ...
// --> SQLTransactionBackend // which is a circular reference.
//
// Note: there's a circular reference between the SQLTransaction front-end
// and back-end. This circular reference is established in the constructor
// of the SQLTransactionBackend. The circular reference will be broken by
// calling doCleanup() to nullify m_frontend. This is done at the end of the
// transaction's clean up state (i.e. when the transaction should no longer
// be in use thereafter), or if the database was interrupted. See comments
// on "What happens if a transaction is interrupted?" below for details.
//
// After scheduling the transaction with the DatabaseThread
// (Database::scheduleTransaction()):
// ======================================================================================================
// DatabaseThread
// // MessageQueue<DatabaseTask> m_queue points to ...
// --> DatabaseTransactionTask
// // Member<SQLTransactionBackend> m_transaction points to ...
// --> SQLTransactionBackend
// // Member<SQLTransaction> m_frontend points to ...
// --> SQLTransaction
// // Member<SQLTransactionBackend> m_backend points to ...
// --> SQLTransactionBackend // which is a circular reference.
//
// When executing the transaction (in DatabaseThread::databaseThread()):
// ====================================================================
// std::unique_ptr<DatabaseTask> task;
// // points to ...
// --> DatabaseTransactionTask
// // Member<SQLTransactionBackend> m_transaction points to ...
// --> SQLTransactionBackend
// // Member<SQLTransaction> m_frontend;
// --> SQLTransaction
// // Member<SQLTransactionBackend> m_backend points to ...
// --> SQLTransactionBackend // which is a circular reference.
//
// At the end of cleanupAndTerminate():
// ===================================
// At the end of the cleanup state, the SQLTransactionBackend::m_frontend is
// nullified. If by then, a JSObject wrapper is referring to the
// SQLTransaction, then the reference chain looks like this:
//
// JSObjectWrapper
// --> SQLTransaction
// // in Member<SQLTransactionBackend> m_backend points to ...
// --> SQLTransactionBackend
// // which no longer points back to its SQLTransaction.
//
// When the GC collects the corresponding JSObject, the above chain will be
// cleaned up and deleted.
//
// If there is no JSObject wrapper referring to the SQLTransaction when the
// cleanup states nullify SQLTransactionBackend::m_frontend, the
// SQLTransaction will deleted then. However, there will still be a
// DatabaseTask pointing to the SQLTransactionBackend (see the "When
// executing the transaction" chain above). This will keep the
// SQLTransactionBackend alive until DatabaseThread::databaseThread()
// releases its task std::unique_ptr.
//
// What happens if a transaction is interrupted?
// ============================================
// If the transaction is interrupted half way, it won't get to run to state
// CleanupAndTerminate, and hence, would not have called
// SQLTransactionBackend's doCleanup(). doCleanup() is where we nullify
// SQLTransactionBackend::m_frontend to break the reference cycle between
// the frontend and backend. Hence, we need to cleanup the transaction by
// other means.
//
// Note: calling SQLTransactionBackend::notifyDatabaseThreadIsShuttingDown()
// is effectively the same as calling SQLTransactionBackend::doClean().
//
// In terms of who needs to call doCleanup(), there are 5 phases in the
// SQLTransactionBackend life-cycle. These are the phases and how the clean
// up is done:
//
// Phase 1. After Birth, before scheduling
//
// - To clean up, DatabaseThread::databaseThread() will call
// Database::close() during its shutdown.
// - Database::close() will iterate
// Database::m_transactionQueue and call
// notifyDatabaseThreadIsShuttingDown() on each transaction there.
//
// Phase 2. After scheduling, before state AcquireLock
//
// - If the interruption occures before the DatabaseTransactionTask is
// scheduled in DatabaseThread::m_queue but hasn't gotten to execute
// (i.e. DatabaseTransactionTask::performTask() has not been called),
// then the DatabaseTransactionTask may get destructed before it ever
// gets to execute.
// - To clean up, the destructor will check if the task's m_wasExecuted is
// set. If not, it will call notifyDatabaseThreadIsShuttingDown() on
// the task's transaction.
//
// Phase 3. After state AcquireLock, before "lockAcquired"
//
// - In this phase, the transaction would have been added to the
// SQLTransactionCoordinator's CoordinationInfo's pendingTransactions.
// - To clean up, during shutdown, DatabaseThread::databaseThread() calls
// SQLTransactionCoordinator::shutdown(), which calls
// notifyDatabaseThreadIsShuttingDown().
//
// Phase 4: After "lockAcquired", before state CleanupAndTerminate
//
// - In this phase, the transaction would have been added either to the
// SQLTransactionCoordinator's CoordinationInfo's activeWriteTransaction
// or activeReadTransactions.
// - To clean up, during shutdown, DatabaseThread::databaseThread() calls
// SQLTransactionCoordinator::shutdown(), which calls
// notifyDatabaseThreadIsShuttingDown().
//
// Phase 5: After state CleanupAndTerminate
//
// - This is how a transaction ends normally.
// - state CleanupAndTerminate calls doCleanup().
namespace blink {
SQLTransactionBackend::SQLTransactionBackend(Database* db,
SQLTransaction* frontend,
SQLTransactionWrapper* wrapper,
bool read_only)
: frontend_(frontend),
database_(db),
wrapper_(wrapper),
has_callback_(frontend_->HasCallback()),
has_success_callback_(frontend_->HasSuccessCallback()),
has_error_callback_(frontend_->HasErrorCallback()),
should_retry_current_statement_(false),
modified_database_(false),
lock_acquired_(false),
read_only_(read_only),
has_version_mismatch_(false) {
DCHECK(IsMainThread());
DCHECK(database_);
frontend_->SetBackend(this);
requested_state_ = SQLTransactionState::kAcquireLock;
}
SQLTransactionBackend::~SQLTransactionBackend() {
DCHECK(!sqlite_transaction_);
}
void SQLTransactionBackend::Trace(Visitor* visitor) const {
visitor->Trace(wrapper_);
}
void SQLTransactionBackend::DoCleanup() {
if (!frontend_)
return;
// Break the reference cycle. See comment about the life-cycle above.
frontend_ = nullptr;
DCHECK(GetDatabase()
->GetDatabaseContext()
->GetDatabaseThread()
->IsDatabaseThread());
MutexLocker locker(statement_mutex_);
statement_queue_.clear();
if (sqlite_transaction_) {
// In the event we got here because of an interruption or error (i.e. if
// the transaction is in progress), we should roll it back here. Clearing
// m_sqliteTransaction invokes SQLiteTransaction's destructor which does
// just that. We might as well do this unconditionally and free up its
// resources because we're already terminating.
sqlite_transaction_.reset();
}
// Release the lock on this database
if (lock_acquired_)
database_->TransactionCoordinator()->ReleaseLock(this);
// Do some aggresive clean up here except for m_database.
//
// We can't clear m_database here because the frontend may asynchronously
// invoke SQLTransactionBackend::requestTransitToState(), and that function
// uses m_database to schedule a state transition. This may occur because
// the frontend (being in another thread) may already be on the way to
// requesting our next state before it detects an interruption.
//
// There is no harm in letting it finish making the request. It'll set
// m_requestedState, but we won't execute a transition to that state because
// we've already shut down the transaction.
//
// We also can't clear m_currentStatementBackend and m_transactionError.
// m_currentStatementBackend may be accessed asynchronously by the
// frontend's deliverStatementCallback() state. Similarly,
// m_transactionError may be accessed by deliverTransactionErrorCallback().
// This occurs if requests for transition to those states have already been
// registered with the frontend just prior to a clean up request arriving.
//
// So instead, let our destructor handle their clean up since this
// SQLTransactionBackend is guaranteed to not destruct until the frontend
// is also destructing.
wrapper_ = nullptr;
}
SQLStatement* SQLTransactionBackend::CurrentStatement() {
return current_statement_backend_->GetFrontend();
}
SQLErrorData* SQLTransactionBackend::TransactionError() {
return transaction_error_.get();
}
void SQLTransactionBackend::SetShouldRetryCurrentStatement(bool should_retry) {
DCHECK(!should_retry_current_statement_);
should_retry_current_statement_ = should_retry;
}
SQLTransactionBackend::StateFunction SQLTransactionBackend::StateFunctionFor(
SQLTransactionState state) {
static const StateFunction kStateFunctions[] = {
&SQLTransactionBackend::UnreachableState, // 0. end
&SQLTransactionBackend::UnreachableState, // 1. idle
&SQLTransactionBackend::AcquireLock, // 2.
&SQLTransactionBackend::OpenTransactionAndPreflight, // 3.
&SQLTransactionBackend::RunStatements, // 4.
&SQLTransactionBackend::PostflightAndCommit, // 5.
&SQLTransactionBackend::CleanupAndTerminate, // 6.
&SQLTransactionBackend::CleanupAfterTransactionErrorCallback, // 7.
// 8. deliverTransactionCallback
&SQLTransactionBackend::SendToFrontendState,
// 9. deliverTransactionErrorCallback
&SQLTransactionBackend::SendToFrontendState,
// 10. deliverStatementCallback
&SQLTransactionBackend::SendToFrontendState,
// 11. deliverQuotaIncreaseCallback
&SQLTransactionBackend::SendToFrontendState,
// 12. deliverSuccessCallback
&SQLTransactionBackend::SendToFrontendState,
};
DCHECK(base::size(kStateFunctions) ==
static_cast<int>(SQLTransactionState::kNumberOfStates));
DCHECK_LT(state, SQLTransactionState::kNumberOfStates);
return kStateFunctions[static_cast<int>(state)];
}
void SQLTransactionBackend::EnqueueStatementBackend(
SQLStatementBackend* statement_backend) {
DCHECK(IsMainThread());
MutexLocker locker(statement_mutex_);
statement_queue_.push_back(statement_backend);
}
void SQLTransactionBackend::ComputeNextStateAndCleanupIfNeeded() {
DCHECK(GetDatabase()
->GetDatabaseContext()
->GetDatabaseThread()
->IsDatabaseThread());
// Only honor the requested state transition if we're not supposed to be
// cleaning up and shutting down:
if (database_->Opened()) {
SetStateToRequestedState();
DCHECK(next_state_ == SQLTransactionState::kAcquireLock ||
next_state_ == SQLTransactionState::kOpenTransactionAndPreflight ||
next_state_ == SQLTransactionState::kRunStatements ||
next_state_ == SQLTransactionState::kPostflightAndCommit ||
next_state_ == SQLTransactionState::kCleanupAndTerminate ||
next_state_ ==
SQLTransactionState::kCleanupAfterTransactionErrorCallback);
#if DCHECK_IS_ON()
STORAGE_DVLOG(1) << "State " << NameForSQLTransactionState(next_state_);
#endif
return;
}
// If we get here, then we should be shutting down. Do clean up if needed:
if (next_state_ == SQLTransactionState::kEnd)
return;
next_state_ = SQLTransactionState::kEnd;
// If the database was stopped, don't do anything and cancel queued work
STORAGE_DVLOG(1) << "Database was stopped or interrupted - cancelling work "
"for this transaction";
// The current SQLite transaction should be stopped, as well
if (sqlite_transaction_) {
sqlite_transaction_->Stop();
sqlite_transaction_.reset();
}
// Terminate the frontend state machine. This also gets the frontend to
// call computeNextStateAndCleanupIfNeeded() and clear its wrappers
// if needed.
frontend_->RequestTransitToState(SQLTransactionState::kEnd);
// Redirect to the end state to abort, clean up, and end the transaction.
DoCleanup();
}
void SQLTransactionBackend::PerformNextStep() {
ComputeNextStateAndCleanupIfNeeded();
RunStateMachine();
}
void SQLTransactionBackend::ExecuteSQL(SQLStatement* statement,
const String& sql_statement,
const Vector<SQLValue>& arguments,
int permissions) {
DCHECK(IsMainThread());
EnqueueStatementBackend(MakeGarbageCollected<SQLStatementBackend>(
statement, sql_statement, arguments, permissions));
}
void SQLTransactionBackend::NotifyDatabaseThreadIsShuttingDown() {
DCHECK(GetDatabase()
->GetDatabaseContext()
->GetDatabaseThread()
->IsDatabaseThread());
// If the transaction is in progress, we should roll it back here, since this
// is our last opportunity to do something related to this transaction on the
// DB thread. Amongst other work, doCleanup() will clear m_sqliteTransaction
// which invokes SQLiteTransaction's destructor, which will do the roll back
// if necessary.
DoCleanup();
}
SQLTransactionState SQLTransactionBackend::AcquireLock() {
database_->TransactionCoordinator()->AcquireLock(this);
return SQLTransactionState::kIdle;
}
void SQLTransactionBackend::LockAcquired() {
lock_acquired_ = true;
RequestTransitToState(SQLTransactionState::kOpenTransactionAndPreflight);
}
SQLTransactionState SQLTransactionBackend::OpenTransactionAndPreflight() {
DCHECK(GetDatabase()
->GetDatabaseContext()
->GetDatabaseThread()
->IsDatabaseThread());
DCHECK(!database_->SqliteDatabase().TransactionInProgress());
DCHECK(lock_acquired_);
STORAGE_DVLOG(1) << "Opening and preflighting transaction " << this;
// Set the maximum usage for this transaction if this transactions is not
// read-only.
if (!read_only_)
database_->SqliteDatabase().SetMaximumSize(database_->MaximumSize());
DCHECK(!sqlite_transaction_);
sqlite_transaction_ = std::make_unique<SQLiteTransaction>(
database_->SqliteDatabase(), read_only_);
database_->ResetDeletes();
database_->DisableAuthorizer();
sqlite_transaction_->begin();
database_->EnableAuthorizer();
// Spec 4.3.2.1+2: Open a transaction to the database, jumping to the error
// callback if that fails.
if (!sqlite_transaction_->InProgress()) {
DCHECK(!database_->SqliteDatabase().TransactionInProgress());
database_->ReportSqliteError(database_->SqliteDatabase().LastError());
transaction_error_ = SQLErrorData::Create(
SQLError::kDatabaseErr, "unable to begin transaction",
database_->SqliteDatabase().LastError(),
database_->SqliteDatabase().LastErrorMsg());
sqlite_transaction_.reset();
return NextStateForTransactionError();
}
// Note: We intentionally retrieve the actual version even with an empty
// expected version. In multi-process browsers, we take this opportunity to
// update the cached value for the actual version. In single-process browsers,
// this is just a map lookup.
String actual_version;
if (!database_->GetActualVersionForTransaction(actual_version)) {
database_->ReportSqliteError(database_->SqliteDatabase().LastError());
transaction_error_ =
SQLErrorData::Create(SQLError::kDatabaseErr, "unable to read version",
database_->SqliteDatabase().LastError(),
database_->SqliteDatabase().LastErrorMsg());
database_->DisableAuthorizer();
sqlite_transaction_.reset();
database_->EnableAuthorizer();
return NextStateForTransactionError();
}
has_version_mismatch_ = !database_->ExpectedVersion().IsEmpty() &&
(database_->ExpectedVersion() != actual_version);
// Spec 4.3.2.3: Perform preflight steps, jumping to the error callback if
// they fail.
if (wrapper_ && !wrapper_->PerformPreflight(this)) {
database_->DisableAuthorizer();
sqlite_transaction_.reset();
database_->EnableAuthorizer();
if (wrapper_->SqlError()) {
transaction_error_ =
std::make_unique<SQLErrorData>(*wrapper_->SqlError());
} else {
transaction_error_ = std::make_unique<SQLErrorData>(
SQLError::kUnknownErr,
"unknown error occurred during transaction preflight");
}
return NextStateForTransactionError();
}
// Spec 4.3.2.4: Invoke the transaction callback with the new SQLTransaction
// object.
if (has_callback_)
return SQLTransactionState::kDeliverTransactionCallback;
// If we have no callback to make, skip pass to the state after:
return SQLTransactionState::kRunStatements;
}
SQLTransactionState SQLTransactionBackend::RunStatements() {
DCHECK(GetDatabase()
->GetDatabaseContext()
->GetDatabaseThread()
->IsDatabaseThread());
DCHECK(lock_acquired_);
SQLTransactionState next_state;
// If there is a series of statements queued up that are all successful and
// have no associated SQLStatementCallback objects, then we can burn through
// the queue.
do {
if (should_retry_current_statement_ &&
!sqlite_transaction_->WasRolledBackBySqlite()) {
should_retry_current_statement_ = false;
// FIXME - Another place that needs fixing up after
// <rdar://problem/5628468> is addressed.
// See ::openTransactionAndPreflight() for discussion
// Reset the maximum size here, as it was increased to allow us to retry
// this statement. m_shouldRetryCurrentStatement is set to true only when
// a statement exceeds the quota, which can happen only in a read-write
// transaction. Therefore, there is no need to check here if the
// transaction is read-write.
database_->SqliteDatabase().SetMaximumSize(database_->MaximumSize());
} else {
// If the current statement has already been run, failed due to quota
// constraints, and we're not retrying it, that means it ended in an
// error. Handle it now.
if (current_statement_backend_ &&
current_statement_backend_->LastExecutionFailedDueToQuota()) {
return NextStateForCurrentStatementError();
}
// Otherwise, advance to the next statement
GetNextStatement();
}
next_state = RunCurrentStatementAndGetNextState();
} while (next_state == SQLTransactionState::kRunStatements);
return next_state;
}
void SQLTransactionBackend::GetNextStatement() {
DCHECK(GetDatabase()
->GetDatabaseContext()
->GetDatabaseThread()
->IsDatabaseThread());
current_statement_backend_ = nullptr;
MutexLocker locker(statement_mutex_);
if (!statement_queue_.IsEmpty())
current_statement_backend_ = statement_queue_.TakeFirst();
}
SQLTransactionState
SQLTransactionBackend::RunCurrentStatementAndGetNextState() {
if (!current_statement_backend_) {
// No more statements to run. So move on to the next state.
return SQLTransactionState::kPostflightAndCommit;
}
database_->ResetAuthorizer();
if (has_version_mismatch_)
current_statement_backend_->SetVersionMismatchedError(database_.Get());
if (current_statement_backend_->Execute(database_.Get())) {
if (database_->LastActionChangedDatabase()) {
// Flag this transaction as having changed the database for later delegate
// notification.
modified_database_ = true;
}
if (current_statement_backend_->HasStatementCallback()) {
return SQLTransactionState::kDeliverStatementCallback;
}
// If we get here, then the statement doesn't have a callback to invoke.
// We can move on to the next statement. Hence, stay in this state.
return SQLTransactionState::kRunStatements;
}
if (current_statement_backend_->LastExecutionFailedDueToQuota()) {
return SQLTransactionState::kDeliverQuotaIncreaseCallback;
}
return NextStateForCurrentStatementError();
}
SQLTransactionState SQLTransactionBackend::NextStateForCurrentStatementError() {
// Spec 4.3.2.6.6: error - Call the statement's error callback, but if there
// was no error callback, or the transaction was rolled back, jump to the
// transaction error callback.
if (current_statement_backend_->HasStatementErrorCallback() &&
!sqlite_transaction_->WasRolledBackBySqlite())
return SQLTransactionState::kDeliverStatementCallback;
if (current_statement_backend_->SqlError()) {
transaction_error_ =
std::make_unique<SQLErrorData>(*current_statement_backend_->SqlError());
} else {
transaction_error_ = std::make_unique<SQLErrorData>(
SQLError::kDatabaseErr, "the statement failed to execute");
}
return NextStateForTransactionError();
}
SQLTransactionState SQLTransactionBackend::PostflightAndCommit() {
DCHECK(lock_acquired_);
// Spec 4.3.2.7: Perform postflight steps, jumping to the error callback if
// they fail.
if (wrapper_ && !wrapper_->PerformPostflight(this)) {
if (wrapper_->SqlError()) {
transaction_error_ =
std::make_unique<SQLErrorData>(*wrapper_->SqlError());
} else {
transaction_error_ = std::make_unique<SQLErrorData>(
SQLError::kUnknownErr,
"unknown error occurred during transaction postflight");
}
return NextStateForTransactionError();
}
// Spec 4.3.2.7: Commit the transaction, jumping to the error callback if that
// fails.
DCHECK(sqlite_transaction_);
database_->DisableAuthorizer();
sqlite_transaction_->Commit();
database_->EnableAuthorizer();
// If the commit failed, the transaction will still be marked as "in progress"
if (sqlite_transaction_->InProgress()) {
if (wrapper_)
wrapper_->HandleCommitFailedAfterPostflight(this);
database_->ReportSqliteError(database_->SqliteDatabase().LastError());
transaction_error_ = SQLErrorData::Create(
SQLError::kDatabaseErr, "unable to commit transaction",
database_->SqliteDatabase().LastError(),
database_->SqliteDatabase().LastErrorMsg());
return NextStateForTransactionError();
}
// Vacuum the database if anything was deleted.
if (database_->HadDeletes())
database_->IncrementalVacuumIfNeeded();
// The commit was successful. If the transaction modified this database,
// notify the delegates.
if (modified_database_)
database_->TransactionClient()->DidCommitWriteTransaction(GetDatabase());
// Spec 4.3.2.8: Deliver success callback, if there is one.
return SQLTransactionState::kDeliverSuccessCallback;
}
SQLTransactionState SQLTransactionBackend::CleanupAndTerminate() {
DCHECK(lock_acquired_);
// Spec 4.3.2.9: End transaction steps. There is no next step.
STORAGE_DVLOG(1) << "Transaction " << this << " is complete";
DCHECK(!database_->SqliteDatabase().TransactionInProgress());
// Phase 5 cleanup. See comment on the SQLTransaction life-cycle above.
DoCleanup();
database_->InProgressTransactionCompleted();
return SQLTransactionState::kEnd;
}
SQLTransactionState SQLTransactionBackend::NextStateForTransactionError() {
DCHECK(transaction_error_);
if (has_error_callback_)
return SQLTransactionState::kDeliverTransactionErrorCallback;
// No error callback, so fast-forward to the next state and rollback the
// transaction.
return SQLTransactionState::kCleanupAfterTransactionErrorCallback;
}
SQLTransactionState
SQLTransactionBackend::CleanupAfterTransactionErrorCallback() {
DCHECK(lock_acquired_);
STORAGE_DVLOG(1) << "Transaction " << this << " is complete with an error";
database_->DisableAuthorizer();
if (sqlite_transaction_) {
// Spec 4.3.2.10: Rollback the transaction.
sqlite_transaction_->Rollback();
DCHECK(!database_->SqliteDatabase().TransactionInProgress());
sqlite_transaction_.reset();
}
database_->EnableAuthorizer();
DCHECK(!database_->SqliteDatabase().TransactionInProgress());
return SQLTransactionState::kCleanupAndTerminate;
}
// requestTransitToState() can be called from the frontend. Hence, it should
// NOT be modifying SQLTransactionBackend in general. The only safe field to
// modify is m_requestedState which is meant for this purpose.
void SQLTransactionBackend::RequestTransitToState(
SQLTransactionState next_state) {
#if DCHECK_IS_ON()
STORAGE_DVLOG(1) << "Scheduling " << NameForSQLTransactionState(next_state)
<< " for transaction " << this;
#endif
requested_state_ = next_state;
DCHECK_NE(requested_state_, SQLTransactionState::kEnd);
database_->ScheduleTransactionStep(this);
}
// This state function is used as a stub function to plug unimplemented states
// in the state dispatch table. They are unimplemented because they should
// never be reached in the course of correct execution.
SQLTransactionState SQLTransactionBackend::UnreachableState() {
NOTREACHED();
return SQLTransactionState::kEnd;
}
SQLTransactionState SQLTransactionBackend::SendToFrontendState() {
DCHECK_NE(next_state_, SQLTransactionState::kIdle);
frontend_->RequestTransitToState(next_state_);
return SQLTransactionState::kIdle;
}
} // namespace blink
| 13,204 |
482 | package io.nutz.demo.simple.module;
import org.nutz.ioc.loader.annotation.Inject;
import org.nutz.ioc.loader.annotation.IocBean;
import org.nutz.mvc.annotation.At;
import com.bstek.ureport.export.ExportManager;
@At("/report")
@IocBean
public class ReportModule {
@Inject
protected ExportManager exportManager;
@At
public void index() {}
}
| 144 |
626 | /*
* Anserini: A Lucene toolkit for reproducible information retrieval research
*
* 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.anserini.search.topicreader;
import java.io.BufferedReader;
import java.io.IOException;
import java.nio.file.Path;
import java.util.HashMap;
import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;
/**
* Topic reader for simple web topics, like the efficiency queries from the TREC 2005 Terabyte Track:
*
* <pre>
* 1:pierson s twin lakes marina
* 2:nurseries in woodbridge new jersey
* 3:miami white pages
* 4:delta air lines
* 5:hsn
* 6:<NAME> s super off road
* 7:pajaro carpintero
* 8:kitchen canister sets
* 9:buy pills online
* 10:hotel meistertrunk
* ...
* </pre>
*/
public class WebTopicReader extends TopicReader<Integer> {
public WebTopicReader(Path topicFile) {
super(topicFile);
}
@Override
public SortedMap<Integer, Map<String, String>> read(BufferedReader bRdr) throws IOException {
SortedMap<Integer, Map<String, String>> map = new TreeMap<>();
String line;
while ((line = bRdr.readLine()) != null) {
line = line.trim();
String[] arr = line.split(":");
Map<String,String> fields = new HashMap<>();
fields.put("title", arr[1]);
map.put(Integer.valueOf(arr[0]), fields);
}
return map;
}
}
| 596 |
1,338 | /*
* Copyright 2010, <NAME>, <EMAIL>.
* Distributed under the terms of the MIT License.
*/
#include "TerminalRoster.h"
#include <stdio.h>
#include <new>
#include <Looper.h>
#include <Roster.h>
#include <String.h>
#include <AutoLocker.h>
#include "TermConst.h"
static const bigtime_t kAppsRunningCheckInterval = 1000000;
// #pragma mark - Info
/*! Creates an Info with the given \a id and \a team ID.
\c workspaces is set to 0 and \c minimized to \c true.
*/
TerminalRoster::Info::Info(int32 id, team_id team)
:
id(id),
team(team),
workspaces(0),
minimized(true)
{
}
/*! Create an Info and initializes its data from \a archive.
*/
TerminalRoster::Info::Info(const BMessage& archive)
{
if (archive.FindInt32("id", &id) != B_OK)
id = -1;
if (archive.FindInt32("team", &team) != B_OK)
team = -1;
if (archive.FindUInt32("workspaces", &workspaces) != B_OK)
workspaces = 0;
if (archive.FindBool("minimized", &minimized) != B_OK)
minimized = true;
}
/*! Writes the Info's data into fields of \a archive.
The const BMessage& constructor can restore an identical Info from it.
*/
status_t
TerminalRoster::Info::Archive(BMessage& archive) const
{
status_t error;
if ((error = archive.AddInt32("id", id)) != B_OK
|| (error = archive.AddInt32("team", team)) != B_OK
|| (error = archive.AddUInt32("workspaces", workspaces)) != B_OK
|| (error = archive.AddBool("minimized", minimized)) != B_OK) {
return error;
}
return B_OK;
}
/*! Compares two Infos.
Infos are considered equal, iff all data members are.
*/
bool
TerminalRoster::Info::operator==(const Info& other) const
{
return id == other.id && team == other.team
&& workspaces == other.workspaces && minimized == other.minimized;
}
// #pragma mark - TerminalRoster
/*! Creates a TerminalRoster.
Most methods cannot be used until Register() has been invoked.
*/
TerminalRoster::TerminalRoster()
:
BHandler("terminal roster"),
fLock("terminal roster"),
fClipboard(TERM_SIGNATURE),
fInfos(10, true),
fOurInfo(NULL),
fLastCheckedTime(0),
fListener(NULL),
fInfosUpdated(false)
{
}
/*! Locks the object.
Also makes sure the roster list is reasonably up-to-date.
*/
bool
TerminalRoster::Lock()
{
// lock
bool locked = fLock.Lock();
if (!locked)
return false;
// make sure we're registered
if (fOurInfo == NULL) {
fLock.Unlock();
return false;
}
// If the check interval has passed, make sure all infos still have running
// teams.
bigtime_t now = system_time();
if (fLastCheckedTime + kAppsRunningCheckInterval) {
bool needsUpdate = false;
for (int32 i = 0; const Info* info = TerminalAt(i); i++) {
if (!_TeamIsRunning(info->team)) {
needsUpdate = true;
break;
}
}
if (needsUpdate) {
AutoLocker<BClipboard> clipboardLocker(fClipboard);
if (clipboardLocker.IsLocked()) {
if (_UpdateInfos(true) == B_OK)
_UpdateClipboard();
}
} else
fLastCheckedTime = now;
}
return true;
}
/*! Unlocks the object.
As a side effect the listener will be notified, if the terminal list has
changed in any way.
*/
void
TerminalRoster::Unlock()
{
if (fOurInfo != NULL && fInfosUpdated) {
// the infos have changed -- notify our listener
_NotifyListener();
}
fLock.Unlock();
}
/*! Registers a terminal with the roster and establishes a link.
The object attaches itself to the supplied \a looper and will receive
updates via messaging (obviously the looper must run (not necessarily
right now) for this to work).
\param teamID The team ID of this team.
\param looper A looper the object can attach itself to.
\return \c B_OK, if successful, another error code otherwise.
*/
status_t
TerminalRoster::Register(team_id teamID, BLooper* looper)
{
AutoLocker<BLocker> locker(fLock);
if (fOurInfo != NULL) {
// already registered
return B_BAD_VALUE;
}
// lock the clipboard
AutoLocker<BClipboard> clipboardLocker(fClipboard);
if (!clipboardLocker.IsLocked())
return B_BAD_VALUE;
// get the current infos from the clipboard
status_t error = _UpdateInfos(true);
if (error != B_OK)
return error;
// find an unused ID
int32 id = 0;
for (int32 i = 0; const Info* info = TerminalAt(i); i++) {
if (info->id > id)
break;
id++;
}
// create our own info
fOurInfo = new(std::nothrow) Info(id, teamID);
if (fOurInfo == NULL)
return B_NO_MEMORY;
// insert it
if (!fInfos.BinaryInsert(fOurInfo, &_CompareInfos)) {
delete fOurInfo;
fOurInfo = NULL;
return B_NO_MEMORY;
}
// update the clipboard
error = _UpdateClipboard();
if (error != B_OK) {
fInfos.MakeEmpty(true);
fOurInfo = NULL;
return error;
}
// add ourselves to the looper and start watching
looper->AddHandler(this);
be_roster->StartWatching(this, B_REQUEST_QUIT);
fClipboard.StartWatching(this);
// Update again in case we've missed a update message sent before we were
// listening.
_UpdateInfos(false);
return B_OK;
}
/*! Unregisters the terminal from the roster and closes the link.
Basically undoes all effects of Register().
*/
void
TerminalRoster::Unregister()
{
AutoLocker<BLocker> locker(fLock);
if (!locker.IsLocked())
return;
// stop watching and remove ourselves from the looper
be_roster->StartWatching(this);
fClipboard.StartWatching(this);
Looper()->RemoveHandler(this);
// lock the clipboard and get the current infos
AutoLocker<BClipboard> clipboardLocker(fClipboard);
if (!clipboardLocker.IsLocked() || _UpdateInfos(false) != B_OK)
return;
// remove our info and update the clipboard
fInfos.RemoveItem(fOurInfo);
fOurInfo = NULL;
_UpdateClipboard();
}
/*! Returns the ID assigned to this terminal when it was registered.
*/
int32
TerminalRoster::ID() const
{
return fOurInfo != NULL ? fOurInfo->id : -1;
}
/*! Updates this terminal's window status.
All other running terminals will be notified, if the status changed.
\param minimized \c true, if the window is minimized.
\param workspaces The window's workspaces mask.
*/
void
TerminalRoster::SetWindowInfo(bool minimized, uint32 workspaces)
{
AutoLocker<TerminalRoster> locker(this);
if (!locker.IsLocked())
return;
if (minimized == fOurInfo->minimized && workspaces == fOurInfo->workspaces)
return;
fOurInfo->minimized = minimized;
fOurInfo->workspaces = workspaces;
fInfosUpdated = true;
// lock the clipboard and get the current infos
AutoLocker<BClipboard> clipboardLocker(fClipboard);
if (!clipboardLocker.IsLocked() || _UpdateInfos(false) != B_OK)
return;
// update the clipboard to make our change known to the others
_UpdateClipboard();
}
/*! Overriden to handle update messages.
*/
void
TerminalRoster::MessageReceived(BMessage* message)
{
switch (message->what) {
case B_SOME_APP_QUIT:
{
BString signature;
if (message->FindString("be:signature", &signature) != B_OK
|| signature != TERM_SIGNATURE) {
break;
}
// fall through
}
case B_CLIPBOARD_CHANGED:
{
// lock ourselves and the clipboard and update the infos
AutoLocker<TerminalRoster> locker(this);
AutoLocker<BClipboard> clipboardLocker(fClipboard);
if (clipboardLocker.IsLocked()) {
_UpdateInfos(false);
if (fInfosUpdated)
_NotifyListener();
}
break;
}
default:
BHandler::MessageReceived(message);
break;
}
}
/*! Updates the terminal info list from the clipboard.
\param checkApps If \c true, it is checked for each found info whether the
respective team is still running. If not, the info is removed from the
list (though not from the clipboard).
\return \c B_OK, if the update went fine, another error code otherwise. When
an error occurs the object state will still be consistent, but might no
longer be up-to-date.
*/
status_t
TerminalRoster::_UpdateInfos(bool checkApps)
{
BMessage* data = fClipboard.Data();
// find out how many infos we can expect
type_code type;
int32 count;
status_t error = data->GetInfo("teams", &type, &count);
if (error != B_OK)
count = 0;
// create an info list from the message
InfoList infos(10, true);
for (int32 i = 0; i < count; i++) {
// get the team's message
BMessage teamData;
error = data->FindMessage("teams", i, &teamData);
if (error != B_OK)
return error;
// create the info
Info* info = new(std::nothrow) Info(teamData);
if (info == NULL)
return B_NO_MEMORY;
if (info->id < 0 || info->team < 0
|| infos.BinarySearchByKey(info->id, &_CompareIDInfo) != NULL
|| (checkApps && !_TeamIsRunning(info->team))) {
// invalid/duplicate info -- skip
delete info;
fInfosUpdated = true;
continue;
}
// add it to the list
if (!infos.BinaryInsert(info, &_CompareInfos)) {
delete info;
return B_NO_MEMORY;
}
}
// update the current info list from the infos we just read
int32 oldIndex = 0;
int32 newIndex = 0;
while (oldIndex < fInfos.CountItems() || newIndex < infos.CountItems()) {
Info* oldInfo = fInfos.ItemAt(oldIndex);
Info* newInfo = infos.ItemAt(newIndex);
if (oldInfo == NULL || (newInfo != NULL && oldInfo->id > newInfo->id)) {
// new info is not in old list -- transfer it
if (!fInfos.AddItem(newInfo, oldIndex++))
return B_NO_MEMORY;
infos.RemoveItemAt(newIndex);
fInfosUpdated = true;
} else if (newInfo == NULL || oldInfo->id < newInfo->id) {
// old info is not in new list -- delete it, unless it's our own
if (oldInfo == fOurInfo) {
oldIndex++;
} else {
delete fInfos.RemoveItemAt(oldIndex);
fInfosUpdated = true;
}
} else {
// info is in both lists -- update the old info, unless it's our own
if (oldInfo != fOurInfo) {
if (*oldInfo != *newInfo) {
*oldInfo = *newInfo;
fInfosUpdated = true;
}
}
oldIndex++;
newIndex++;
}
}
if (checkApps)
fLastCheckedTime = system_time();
return B_OK;
}
/*! Updates the clipboard with the object's terminal info list.
\return \c B_OK, if the update went fine, another error code otherwise. When
an error occurs the object state will still be consistent, but might no
longer be in sync with the clipboard.
*/
status_t
TerminalRoster::_UpdateClipboard()
{
// get the clipboard data message
BMessage* data = fClipboard.Data();
if (data == NULL)
return B_BAD_VALUE;
// clear the message and add all infos
data->MakeEmpty();
for (int32 i = 0; const Info* info = TerminalAt(i); i++) {
BMessage teamData;
status_t error = info->Archive(teamData);
if (error != B_OK
|| (error = data->AddMessage("teams", &teamData)) != B_OK) {
fClipboard.Revert();
return error;
}
}
// commit the changes
status_t error = fClipboard.Commit();
if (error != B_OK) {
fClipboard.Revert();
return error;
}
return B_OK;
}
/*! Notifies the listener, if something has changed.
*/
void
TerminalRoster::_NotifyListener()
{
if (!fInfosUpdated)
return;
if (fListener != NULL)
fListener->TerminalInfosUpdated(this);
fInfosUpdated = false;
}
/*static*/ int
TerminalRoster::_CompareInfos(const Info* a, const Info* b)
{
return a->id - b->id;
}
/*static*/ int
TerminalRoster::_CompareIDInfo(const int32* id, const Info* info)
{
return *id - info->id;
}
bool
TerminalRoster::_TeamIsRunning(team_id teamID)
{
// we are running for sure
if (fOurInfo != NULL && fOurInfo->team == teamID)
return true;
team_info info;
return get_team_info(teamID, &info) == B_OK;
}
// #pragma mark - Listener
TerminalRoster::Listener::~Listener()
{
}
| 4,212 |
368 | <reponame>lanza/coroutine
/**
* @author github.com/luncliff (<EMAIL>)
*/
#undef NDEBUG
#include <cassert>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <initializer_list>
using namespace std;
//
// interface which doesn't require coroutine
//
using message_t = uint64_t;
using callback_t = void* (*)(void* context, message_t msg);
struct opaque_t;
opaque_t* start_messaging(void* context, callback_t on_message);
void stop_messaging(opaque_t*);
void send_message(opaque_t*, message_t msg);
//
// user code to use the interface
//
void* update_location(void* ptr, message_t msg) {
auto* pmsg = static_cast<message_t*>(ptr);
*pmsg = msg; // update the reference and return it
return pmsg;
}
int main(int, char*[]) {
message_t target = 0;
auto session = start_messaging(&target, //
&update_location);
assert(session != nullptr);
for (auto m : {1u, 2u, 3u}) {
send_message(session, m); // the callback (update)
assert(target == m); // must have changed the memory location
}
stop_messaging(session);
return 0;
}
//
// The implementation uses coroutine
//
#include <coroutine/channel.hpp>
#include <coroutine/return.h>
using channel_t = coro::channel<message_t>;
#if defined(__GNUC__)
using no_return_t = coro::null_frame_t;
#else
using no_return_t = std::nullptr_t;
#endif
opaque_t* start_messaging(void* ctx, callback_t on_message) {
auto* ch = new (std::nothrow) channel_t{};
if (ch == nullptr)
return nullptr;
// attach a receiver coroutine to the channel
[](channel_t* ch, void* context, callback_t callback) -> no_return_t {
puts("start receiving ...");
while (ch) { // always true
auto [msg, ok] = co_await ch->read();
if (ok == false) {
puts("stopped ...");
co_return;
}
// received. invoke the callback
puts("received");
context = callback(context, msg);
}
}(ch, ctx, on_message);
return reinterpret_cast<opaque_t*>(ch);
}
void stop_messaging(opaque_t* ptr) {
auto ch = reinterpret_cast<channel_t*>(ptr);
delete ch;
}
void send_message(opaque_t* ptr, message_t m) {
// spawn a sender coroutine
[](channel_t* ch, message_t msg) mutable -> no_return_t {
// msg will be 'moved' to reader coroutine. so it must be `mutable`
if (co_await ch->write(msg) == false)
puts("can't send anymore"); // the channel is going to destruct ...
puts("sent");
}(reinterpret_cast<channel_t*>(ptr), std::move(m));
}
| 1,106 |
678 | //
// Generated by class-dump 3.5 (64 bit).
//
// class-dump is Copyright (C) 1997-1998, 2000-2001, 2004-2013 by <NAME>.
//
#import "MMUIView.h"
#import "ILinkEventExt.h"
#import "MMWebViewDelegate.h"
@class MMWebViewController, NSString, UIButton, UIImageView;
@interface WCPayOverseasCardTipView : MMUIView <ILinkEventExt, MMWebViewDelegate>
{
UIImageView *_backgroundView;
UIButton *_selectBtn;
UIButton *_cancelButton;
MMWebViewController *_webView;
id <WCPayOverseasCarTipDelegate> m_tipViewDelegate;
}
@property(nonatomic) __weak id <WCPayOverseasCarTipDelegate> m_tipViewDelegate; // @synthesize m_tipViewDelegate;
- (void).cxx_destruct;
- (void)dealloc;
- (id)genBackgroundView;
- (void)initBottomView;
- (void)initTextView;
- (void)onLinkClicked:(id)arg1 withRect:(struct CGRect)arg2;
- (void)onConfirm;
- (void)onCancel;
- (void)webViewReturn:(id)arg1;
- (void)onSelect;
- (void)initView;
- (id)initWithFrame:(struct CGRect)arg1;
// Remaining properties
@property(readonly, copy) NSString *debugDescription;
@property(readonly, copy) NSString *description;
@property(readonly) unsigned long long hash;
@property(readonly) Class superclass;
@end
| 456 |
420 | <filename>app/src/main/java/com/ubergeek42/WeechatAndroid/utils/Constants.java
package com.ubergeek42.WeechatAndroid.utils;
import android.os.Build;
import com.ubergeek42.WeechatAndroid.R;
import com.ubergeek42.WeechatAndroid.Weechat;
import java.util.Set;
public class Constants {
// connection type
final static public String PREF_CONNECTION_GROUP = "connection_group";
final static public String PREF_CONNECTION_TYPE = "connection_type";
final static public String PREF_TYPE_SSH = "ssh";
final static public String PREF_TYPE_SSL = "ssl";
final static public String PREF_TYPE_WEBSOCKET = "websocket";
final static public String PREF_TYPE_WEBSOCKET_SSL = "websocket-ssl";
final static private String PREF_TYPE_PLAIN = "plain"; final public static String PREF_CONNECTION_TYPE_D = PREF_TYPE_PLAIN;
// ssl group
final static public String PREF_SSL_GROUP = "ssl_group";
final static public String PREF_SSL_PIN_REQUIRED = "ssl_pin_required"; final static public boolean PREF_SSL_PIN_REQUIRED_D = false;
final static public String PREF_SSL_CLEAR_CERTS = "ssl_clear_certs";
final static public String PREF_SSL_CLIENT_CERTIFICATE = "ssl_client_certificate"; final static public boolean PREF_SSL_CLIENT_CERTIFICATE_D = false;
// websocket
final static public String PREF_WS_PATH = "ws_path"; final public static String PREF_WS_PATH_D = "weechat";
// ssh group & insides
final static public String PREF_SSH_GROUP = "ssh_group";
final static public String PREF_SSH_HOST = "ssh_host"; final public static String PREF_SSH_HOST_D = "";
final static public String PREF_SSH_PORT = "ssh_port"; final public static String PREF_SSH_PORT_D = "22";
final static public String PREF_SSH_USER = "ssh_user"; final public static String PREF_SSH_USER_D = "";
final static public String PREF_SSH_AUTHENTICATION_METHOD = "ssh_authentication_method";
final static public String PREF_SSH_AUTHENTICATION_METHOD_PASSWORD = "password";
final static public String PREF_SSH_AUTHENTICATION_METHOD_KEY = "key";
final public static String PREF_SSH_AUTHENTICATION_METHOD_D = PREF_SSH_AUTHENTICATION_METHOD_PASSWORD;
final static public String PREF_SSH_PASSWORD = "<PASSWORD>";
final public static String PREF_SSH_PASSWORD_D = "";
final static public String PREF_SSH_KEY_FILE = "ssh_key_file";
final public static String PREF_SSH_KEY_FILE_D = null;
final static public String PREF_SSH_SERVER_KEY_VERIFIER = "ssh_server_key_verifier";
final public static String PREF_SSH_SERVER_KEY_VERIFIER_D = "";
// relay
final static public String PREF_HOST = "host";
final public static String PREF_HOST_D = "";
final static public String PREF_PORT = "port";
final public static String PREF_PORT_D = "9001";
final static public String PREF_PASSWORD = "password";
final public static String PREF_PASSWORD_D = "";
final static public String PREF_HANDSHAKE_METHOD = "handshake_method";
final static public String PREF_HANDSHAKE_METHOD_COMPATIBILITY = "compatibility";
final static public String PREF_HANDSHAKE_METHOD_MODERN_FAST_ONLY = "modern_fast_only";
final static public String PREF_HANDSHAKE_METHOD_MODERN_FAST_AND_SLOW = "modern_fast_and_slow";
final static public String PREF_HANDSHAKE_METHOD_D = PREF_HANDSHAKE_METHOD_COMPATIBILITY;
// misc
final static public String PREF_LINE_INCREMENT = "line_increment";
final public static String PREF_LINE_INCREMENT_D = "300";
final static public String PREF_SEARCH_LINE_INCREMENT = "line_number_to_request_when_starting_search";
final static public String PREF_SEARCH_LINE_INCREMENT_D = "4097";
final static public String PREF_RECONNECT = "reconnect";
final public static boolean PREF_RECONNECT_D = true;
final static public String PREF_BOOT_CONNECT = "boot_connect";
final public static boolean PREF_BOOT_CONNECT_D = false;
public static final String PREF_OPTIMIZE_TRAFFIC = "optimize_traffic";
final public static boolean PREF_OPTIMIZE_TRAFFIC_D = false;
public final static String PREF_HOTLIST_SYNC = "hotlist_sync";
final public static boolean PREF_HOTLIST_SYNC_D = false;
// ping
final static public String PREF_PING_GROUP = "ping_group";
final static public String PREF_PING_ENABLED = "ping_enabled";
final public static boolean PREF_PING_ENABLED_D = true;
final static public String PREF_PING_IDLE = "ping_idle";
final public static String PREF_PING_IDLE_D = "300";
final static public String PREF_PING_TIMEOUT = "ping_timeout";
final public static String PREF_PING_TIMEOUT_D = "30";
// buffer list
public static final String PREF_BUFFERLIST_GROUP = "bufferlist_group";
public static final String PREF_SORT_BUFFERS = "sort_buffers";
final public static boolean PREF_SORT_BUFFERS_D = false;
public static final String PREF_HIDE_HIDDEN_BUFFERS = "hide_hidden_buffers";
final public static boolean PREF_HIDE_HIDDEN_BUFFERS_D = true;
public static final String PREF_FILTER_NONHUMAN_BUFFERS = "filter_nonhuman_buffers";
final public static boolean PREF_FILTER_NONHUMAN_BUFFERS_D = true;
public static final String PREF_SHOW_BUFFER_FILTER = "show_buffer_filter";
final public static boolean PREF_SHOW_BUFFER_FILTER_D = true;
public static final String PREF_USE_GESTURE_EXCLUSION_ZONE = "use_gesture_exclusion_zone";
final public static boolean PREF_USE_GESTURE_EXCLUSION_ZONE_D = true;
// look & feel
final static public String PREF_LOOKFEEL_GROUP = "lookfeel_group";
public static final String PREF_TEXT_SIZE = "text_size";
final public static String PREF_TEXT_SIZE_D = "16";
public static final String PREF_AUTO_HIDE_ACTIONBAR = "auto_hide_actionbar";
public static final boolean PREF_AUTO_HIDE_ACTIONBAR_D = true;
public static final String PREF_FILTER_LINES = "chatview_filters";
final public static boolean PREF_FILTER_LINES_D = true;
public static final String PREF_PREFIX_ALIGN = "prefix_align";
final public static String PREF_PREFIX_ALIGN_D = "right";
final static public String PREF_MAX_WIDTH = "prefix_max_width";
final public static String PREF_MAX_WIDTH_D = "7";
public static final String PREF_ENCLOSE_NICK = "enclose_nick";
final public static boolean PREF_ENCLOSE_NICK_D = false;
final static public String PREF_TIMESTAMP_FORMAT = "timestamp_format";
final public static String PREF_TIMESTAMP_FORMAT_D = "HH:mm:ss";
public static final String PREF_DIM_DOWN = "dim_down";
final public static boolean PREF_DIM_DOWN_D = true;
public static final String PREF_BUFFER_FONT = "buffer_font";
final public static String PREF_BUFFER_FONT_D = "";
public static final String PREF_COLOR_SCHEME_DAY = "color_scheme_day";
final public static String PREF_COLOR_SCHEME_DAY_D = "squirrely-light-theme.properties";
public static final String PREF_COLOR_SCHEME_NIGHT = "color_scheme_night";
final public static String PREF_COLOR_SCHEME_NIGHT_D = "squirrely-dark-theme.properties";
// buttons
public final static String PREF_SHOW_SEND = "sendbtn_show";
final public static boolean PREF_SHOW_SEND_D = true;
public final static String PREF_SHOW_TAB = "tabbtn_show";
final public static boolean PREF_SHOW_TAB_D = true;
public final static String PREF_VOLUME_BTN_SIZE = "volumebtn_size";
final public static boolean PREF_VOLUME_BTN_SIZE_D = true;
final public static String PREF_SHOW_PAPERCLIP = "buttons__show_paperclip";
final public static boolean PREF_SHOW_PAPERCLIP_D = true;
final public static String PREF_PAPERCLIP_ACTION_NONE = "none";
final public static String PREF_PAPERCLIP_ACTION_CONTENT_IMAGES = "content_images";
final public static String PREF_PAPERCLIP_ACTION_CONTENT_MEDIA = "content_media";
final public static String PREF_PAPERCLIP_ACTION_CONTENT_ANYTHING = "content_anything";
final public static String PREF_PAPERCLIP_ACTION_MEDIASTORE_IMAGES = "mediastore_images";
final public static String PREF_PAPERCLIP_ACTION_MEDIASTORE_MEDIA = "mediastore_media";
final public static String PREF_PAPERCLIP_ACTION_CAMERA = "camera";
final public static String PREF_PAPERCLIP_ACTION_1 = "buttons__paperclip_action_1";
final public static String PREF_PAPERCLIP_ACTION_2 = "buttons__paperclip_action_2";
final public static String PREF_PAPERCLIP_ACTION_1_D = PREF_PAPERCLIP_ACTION_CONTENT_MEDIA;
final public static String PREF_PAPERCLIP_ACTION_2_D = PREF_PAPERCLIP_ACTION_CAMERA;
// notifications
final static public String PREF_NOTIFICATION_GROUP = "notif_group";
final static public String PREF_NOTIFICATION_ENABLE = "notification_enable"; final public static boolean PREF_NOTIFICATION_ENABLE_D = true;
final static public String PREF_NOTIFICATION_SOUND = "notification_sound"; final public static String PREF_NOTIFICATION_SOUND_D = "content://settings/system/notification_sound";
final static public String PREF_NOTIFICATION_VIBRATE = "notification_vibrate"; final public static boolean PREF_NOTIFICATION_VIBRATE_D = false;
final static public String PREF_NOTIFICATION_LIGHT = "notification_light"; final public static boolean PREF_NOTIFICATION_LIGHT_D = false;
public final static String EXTRA_BUFFER_POINTER = "com.ubergeek42.BUFFER_POINTER";
public final static String EXTRA_BUFFER_FULL_NAME = "com.ubergeek42.BUFFER_FULL_NAME";
public final static long EXTRA_BUFFER_POINTER_ANY = 0;
public final static String EXTRA_BUFFER_FULL_NAME_ANY = "";
// night mode
final static public String PREF_THEME_GROUP = "theme_group";
final public static String PREF_THEME = "theme";
final public static String PREF_THEME_SYSTEM = "system";
final public static String PREF_THEME_DARK = "dark";
final public static String PREF_THEME_LIGHT = "light";
final public static String PREF_THEME_D = PREF_THEME_SYSTEM;
// media preview
final public static String PREF_MEDIA_PREVIEW_GROUP = "media_preview_group";
final public static String PREF_MEDIA_PREVIEW_ENABLED_FOR_NETWORK = "media_preview_enabled_for_network";
final public static String PREF_MEDIA_PREVIEW_ENABLED_FOR_NETWORK_NEVER = "never";
final public static String PREF_MEDIA_PREVIEW_ENABLED_FOR_NETWORK_WIFI_ONLY = "wifi_only";
final public static String PREF_MEDIA_PREVIEW_ENABLED_FOR_NETWORK_UNMETERED_ONLY = "unmetered_only";
final public static String PREF_MEDIA_PREVIEW_ENABLED_FOR_NETWORK_ALWAYS = "always";
final public static String PREF_MEDIA_PREVIEW_ENABLED_FOR_NETWORK_D = PREF_MEDIA_PREVIEW_ENABLED_FOR_NETWORK_NEVER;
final public static String PREF_MEDIA_PREVIEW_ENABLED_FOR_LOCATION = "media_preview_enabled_for_location";
final public static String PREF_MEDIA_PREVIEW_ENABLED_FOR_LOCATION_CHAT = "chat";
final public static String PREF_MEDIA_PREVIEW_ENABLED_FOR_LOCATION_PASTE = "paste";
final public static String PREF_MEDIA_PREVIEW_ENABLED_FOR_LOCATION_NOTIFICATIONS = "notifications";
final public static Set<String> PREF_MEDIA_PREVIEW_ENABLED_FOR_LOCATION_D =
Build.VERSION.SDK_INT >= 24 ?
Utils.makeSet("chat", "paste", "notifications") :
Utils.makeSet("chat", "paste");
final public static String PREF_MEDIA_PREVIEW_SECURE_REQUEST = "media_preview_secure_request";
final public static String PREF_MEDIA_PREVIEW_SECURE_REQUEST_OPTIONAL = "optional";
final public static String PREF_MEDIA_PREVIEW_SECURE_REQUEST_REWRITE = "rewrite";
final public static String PREF_MEDIA_PREVIEW_SECURE_REQUEST_REQUIRED = "required";
final public static String PREF_MEDIA_PREVIEW_SECURE_REQUEST_D = PREF_MEDIA_PREVIEW_SECURE_REQUEST_REWRITE;
final public static String PREF_MEDIA_PREVIEW_HELP = "media_preview_help";
final public static String PREF_MEDIA_PREVIEW_ADVANCED_GROUP = "media_preview_advanced_group";
final public static String PREF_MEDIA_PREVIEW_MAXIMUM_BODY_SIZE = "media_preview_maximum_body_size";
final public static String PREF_MEDIA_PREVIEW_MAXIMUM_BODY_SIZE_D = "10";
final public static String PREF_IMAGE_DISK_CACHE_SIZE = "image_disk_cache_size";
final public static String PREF_IMAGE_DISK_CACHE_SIZE_D = "250";
final public static String PREF_MEDIA_PREVIEW_SUCCESS_COOLDOWN = "media_preview_success_cooldown";
final public static String PREF_MEDIA_PREVIEW_SUCCESS_COOLDOWN_D = "24";
final public static String PREF_MEDIA_PREVIEW_THUMBNAIL_WIDTH = "media_preview_thumbnail_width";
final public static String PREF_MEDIA_PREVIEW_THUMBNAIL_WIDTH_D = "80";
final public static String PREF_MEDIA_PREVIEW_THUMBNAIL_MIN_HEIGHT = "media_preview_thumbnail_min_height";
final public static String PREF_MEDIA_PREVIEW_THUMBNAIL_MIN_HEIGHT_D = "40";
final public static String PREF_MEDIA_PREVIEW_THUMBNAIL_MAX_HEIGHT = "media_preview_thumbnail_max_height";
final public static String PREF_MEDIA_PREVIEW_THUMBNAIL_MAX_HEIGHT_D = "160";
final public static String PREF_MEDIA_PREVIEW_STRATEGIES = "media_preview_strategies";
final public static String PREF_MEDIA_PREVIEW_STRATEGIES_D = getResourceString(R.string.pref__media_preview__strategies_default);
// uploading
final public static String PREF_UPLOAD_GROUP = "upload_group";
final public static String PREF_UPLOAD_ACCEPT = "upload_accept_shared";
final public static String PREF_UPLOAD_ACCEPT_TEXT_ONLY = "text_only";
final public static String PREF_UPLOAD_ACCEPT_TEXT_AND_MEDIA = "text_and_media";
final public static String PREF_UPLOAD_ACCEPT_EVERYTHING = "everything";
final public static String PREF_UPLOAD_ACCEPT_D = PREF_UPLOAD_ACCEPT_EVERYTHING;
final public static String PREF_UPLOAD_NO_OF_DIRECT_SHARE_TARGETS = "upload_no_of_direct_share_targets"; // "0" ... "4"
final public static String PREF_UPLOAD_NO_OF_DIRECT_SHARE_TARGETS_D = "2";
final public static String PREF_UPLOAD_URI = "upload_uri";
final public static String PREF_UPLOAD_URI_D = "";
final public static String PREF_UPLOAD_FORM_FIELD_NAME = "upload_form_field_name";
final public static String PREF_UPLOAD_FORM_FIELD_NAME_D = "file";
final public static String PREF_UPLOAD_REGEX = "upload_regex";
final public static String PREF_UPLOAD_REGEX_D = "^https://\\S+";
final public static String PREF_UPLOAD_HELP = "upload_help";
final public static String PREF_UPLOAD_ADVANCED_GROUP = "upload_advanced_group";
final public static String PREF_UPLOAD_ADDITIONAL_HEADERS = "upload_additional_headers";
final public static String PREF_UPLOAD_ADDITIONAL_HEADERS_D = "";
final public static String PREF_UPLOAD_ADDITIONAL_FIELDS = "upload_additional_fields";
final public static String PREF_UPLOAD_ADDITIONAL_FIELDS_D = "";
final public static String PREF_UPLOAD_AUTHENTICATION = "upload_authentication";
final public static String PREF_UPLOAD_AUTHENTICATION_NONE = "none";
final public static String PREF_UPLOAD_AUTHENTICATION_BASIC = "basic";
final public static String PREF_UPLOAD_AUTHENTICATION_D = PREF_UPLOAD_AUTHENTICATION_NONE;
final public static String PREF_UPLOAD_AUTHENTICATION_BASIC_USER = "upload_authentication_basic_user";
final public static String PREF_UPLOAD_AUTHENTICATION_BASIC_USER_D = "";
final public static String PREF_UPLOAD_AUTHENTICATION_BASIC_PASSWORD = "<PASSWORD>";
final public static String PREF_UPLOAD_AUTHENTICATION_BASIC_PASSWORD_D = "";
final public static String PREF_UPLOAD_REMEMBER_UPLOADS_FOR = "upload_remember_uploads_for";
final public static String PREF_UPLOAD_REMEMBER_UPLOADS_FOR_D = "24"; // hours
// etc
final public static String PREF_THEME_SWITCH = "theme_switch";
final public static boolean PREF_THEME_SWITCH_D = false;
@SuppressWarnings("SameParameterValue")
private static String getResourceString(int id) {
return Weechat.applicationContext.getResources().getString(id);
}
static public class Deprecated {
final static public String PREF_SSH_PASS = "<PASSWORD>pass"; final public static String PREF_SSH_PASS_D = "";
final static public String PREF_SSH_KEY = "ssh_key"; final public static String PREF_SSH_KEY_D = null;
final static public String PREF_SSH_KEY_PASSPHRASE = "ssh_key_passphrase"; final public static String PREF_SSH_KEY_PASSPHRASE_D = null;
final static public String PREF_SSH_KNOWN_HOSTS = "ssh_known_hosts"; final public static String PREF_SSH_KNOWN_HOSTS_D = "";
}
}
| 5,998 |
494 | /*
* 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.commons.math4.examples.sofm.tsp;
import java.util.List;
import java.util.ArrayList;
import java.util.Set;
import java.util.Collection;
import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.function.DoubleUnaryOperator;
import java.util.concurrent.Future;
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.ExecutionException;
import org.apache.commons.rng.UniformRandomProvider;
import org.apache.commons.rng.sampling.CollectionSampler;
import org.apache.commons.rng.sampling.distribution.ContinuousUniformSampler;
import org.apache.commons.math4.neuralnet.DistanceMeasure;
import org.apache.commons.math4.neuralnet.EuclideanDistance;
import org.apache.commons.math4.neuralnet.FeatureInitializer;
import org.apache.commons.math4.neuralnet.FeatureInitializerFactory;
import org.apache.commons.math4.neuralnet.Network;
import org.apache.commons.math4.neuralnet.Neuron;
import org.apache.commons.math4.neuralnet.oned.NeuronString;
import org.apache.commons.math4.neuralnet.sofm.KohonenUpdateAction;
import org.apache.commons.math4.neuralnet.sofm.KohonenTrainingTask;
import org.apache.commons.math4.neuralnet.sofm.NeighbourhoodSizeFunctionFactory;
import org.apache.commons.math4.neuralnet.sofm.NeighbourhoodSizeFunction;
import org.apache.commons.math4.neuralnet.sofm.LearningFactorFunctionFactory;
import org.apache.commons.math4.neuralnet.sofm.LearningFactorFunction;
/**
* Handles the <a href="https://en.wikipedia.org/wiki/Travelling_salesman_problem">
* "Travelling Salesman's Problem"</a> (i.e. trying to find the sequence of
* cities that minimizes the travel distance) using a 1D SOFM.
*/
public final class TravellingSalesmanSolver {
/** The ID for the first neuron. */
private static final long FIRST_NEURON_ID = 0;
/** SOFM. */
private final Network net;
/** Distance function. */
private final DistanceMeasure distance = new EuclideanDistance();
/** Total number of neurons. */
private final int numberOfNeurons;
/**
* @param numNeurons Number of neurons.
* @param init Neuron intializers.
*/
private TravellingSalesmanSolver(int numNeurons,
FeatureInitializer[] init) {
// Total number of neurons.
numberOfNeurons = numNeurons;
// Create a network with circle topology.
net = new NeuronString(numberOfNeurons, true, init).getNetwork();
}
/**
* @param cities List of cities to be visited.
* @param neuronsPerCity Average number of neurons per city.
* @param numUpdates Number of updates for training the network.
* @param numTasks Number of concurrent tasks.
* @param random RNG for presenting samples to the trainer.
* @return the solution (list of cities in travel order).
*/
public static City[] solve(City[] cities,
double neuronsPerCity,
long numUpdates,
int numTasks,
UniformRandomProvider random) {
if (cities.length <= 2) {
return cities;
}
// Make sure that each city will appear only once in the list.
final Set<City> uniqueCities = City.unique(cities);
final int numNeurons = (int) (neuronsPerCity * uniqueCities.size());
if (numNeurons < uniqueCities.size()) {
throw new IllegalArgumentException("Too few neurons");
}
// Set up network.
final FeatureInitializer[] init = makeInitializers(numNeurons,
uniqueCities,
random);
final TravellingSalesmanSolver solver = new TravellingSalesmanSolver(numNeurons,
init);
// Parallel execution.
final ExecutorService service = Executors.newCachedThreadPool();
final Runnable[] tasks = solver.createTasks(uniqueCities,
random,
numTasks,
numUpdates / numTasks);
final List<Future<?>> execOutput = new ArrayList<>();
// Run tasks.
for (final Runnable r : tasks) {
execOutput.add(service.submit(r));
}
// Wait for completion (ignoring return value).
try {
for (final Future<?> f : execOutput) {
f.get();
}
} catch (InterruptedException | ExecutionException e) {
if (e instanceof InterruptedException) {
// Restore interrupted state...
Thread.currentThread().interrupt();
}
throw new RuntimeException(e);
}
// Terminate all threads.
service.shutdown();
return solver.getCityList(uniqueCities).toArray(new City[0]);
}
/**
* Creates training tasks.
*
* @param cities List of cities to be visited.
* @param random RNG for presenting samples to the trainer.
* @param numTasks Number of tasks to create.
* @param numSamplesPerTask Number of training samples per task.
* @return the created tasks.
*/
private Runnable[] createTasks(Set<City> cities,
UniformRandomProvider random,
int numTasks,
long numSamplesPerTask) {
final Runnable[] tasks = new Runnable[numTasks];
final LearningFactorFunction learning
= LearningFactorFunctionFactory.exponentialDecay(0.9,
0.05,
numSamplesPerTask / 2);
final NeighbourhoodSizeFunction neighbourhood
= NeighbourhoodSizeFunctionFactory.exponentialDecay(numberOfNeurons,
1,
numSamplesPerTask / 2);
for (int i = 0; i < numTasks; i++) {
final KohonenUpdateAction action = new KohonenUpdateAction(distance,
learning,
neighbourhood);
tasks[i] = new KohonenTrainingTask(net,
createIterator(numSamplesPerTask,
cities,
random),
action);
}
return tasks;
}
/**
* Creates an iterator that will present a series of city's coordinates
* in random order.
*
* @param numSamples Number of samples.
* @param uniqueCities Cities.
* @param random RNG.
* @return the iterator.
*/
private static Iterator<double[]> createIterator(final long numSamples,
final Set<City> uniqueCities,
final UniformRandomProvider random) {
final CollectionSampler<City> sampler = new CollectionSampler<>(random, uniqueCities);
return new Iterator<double[]>() {
/** Number of samples. */
private long n;
/** {@inheritDoc} */
@Override
public boolean hasNext() {
return n < numSamples;
}
/** {@inheritDoc} */
@Override
public double[] next() {
if (!hasNext()) {
throw new NoSuchElementException();
}
++n;
return sampler.sample().getCoordinates();
}
/** {@inheritDoc} */
@Override
public void remove() {
throw new UnsupportedOperationException();
}
};
}
/**
* @return the list of linked neurons (i.e. the one-dimensional SOFM).
*/
private List<Neuron> getNeuronList() {
// Sequence of coordinates.
final List<Neuron> list = new ArrayList<>();
// First neuron.
Neuron current = net.getNeuron(FIRST_NEURON_ID);
while (true) {
list.add(current);
final Collection<Neuron> neighbours
= net.getNeighbours(current, list);
final Iterator<Neuron> iter = neighbours.iterator();
if (!iter.hasNext()) {
// All neurons have been visited.
break;
}
current = iter.next();
}
return list;
}
/**
* @return the list of features (coordinates) of linked neurons.
*/
public List<double[]> getCoordinatesList() {
// Sequence of coordinates.
final List<double[]> coordinatesList = new ArrayList<>();
for (final Neuron n : getNeuronList()) {
coordinatesList.add(n.getFeatures());
}
return coordinatesList;
}
/**
* Returns the travel proposed by the solver.
*
* @param cities Cities
* @return the list of cities in travel order.
*/
private List<City> getCityList(Set<City> cities) {
final List<double[]> coord = getCoordinatesList();
final List<City> cityList = new ArrayList<>();
City previous = null;
final int max = coord.size();
for (int i = 0; i < max; i++) {
final double[] c = coord.get(i);
final City next = City.closest(c[0], c[1], cities);
if (!next.equals(previous)) {
cityList.add(next);
previous = next;
}
}
return cityList;
}
/**
* Creates the features' initializers: an approximate circle around the
* barycentre of the cities.
*
* @param numNeurons Number of neurons.
* @param uniqueCities Cities.
* @param random RNG.
* @return an array containing the two initializers.
*/
private static FeatureInitializer[] makeInitializers(final int numNeurons,
final Set<City> uniqueCities,
final UniformRandomProvider random) {
// Barycentre.
final double[] centre = City.barycentre(uniqueCities);
// Largest distance from centre.
final double radius = 0.5 * City.largestDistance(centre[0], centre[1], uniqueCities);
final double omega = 2 * Math.PI / numNeurons;
final DoubleUnaryOperator h1 = new HarmonicOscillator(radius, omega, 0, centre[0]);
final DoubleUnaryOperator h2 = new HarmonicOscillator(radius, omega, 0.5 * Math.PI, centre[1]);
final double r = 0.05 * radius;
final ContinuousUniformSampler u = new ContinuousUniformSampler(random, -r, r);
return new FeatureInitializer[] {
FeatureInitializerFactory.randomize(u, FeatureInitializerFactory.function(h1, 0, 1)),
FeatureInitializerFactory.randomize(u, FeatureInitializerFactory.function(h2, 0, 1))
};
}
}
/**
* Function.
*/
class HarmonicOscillator implements DoubleUnaryOperator {
/** Amplitude. */
private final double amplitude;
/** Angular speed. */
private final double omega;
/** Phase. */
private final double phase;
/** Offset. */
private final double offset;
/**
* @param amplitude Amplitude.
* @param omega Angular speed.
* @param phase Phase.
* @param offset Offset (ordinate).
*/
HarmonicOscillator(double amplitude,
double omega,
double phase,
double offset) {
this.amplitude = amplitude;
this.omega = omega;
this.phase = phase;
this.offset = offset;
}
@Override
public double applyAsDouble(double x) {
return offset + amplitude * Math.cos(omega * x + phase);
}
}
| 5,959 |
10,192 | <reponame>mahak/akka
/*
* Copyright (C) 2020-2021 Lightbend Inc. <https://www.lightbend.com>
*/
package jdocs.akka.persistence.typed;
import akka.actor.typed.ActorRef;
import akka.actor.typed.Behavior;
import akka.persistence.testkit.query.javadsl.PersistenceTestKitReadJournal;
import akka.persistence.typed.ReplicaId;
import akka.persistence.typed.ReplicationId;
import akka.persistence.typed.crdt.ORSet;
import akka.persistence.typed.javadsl.CommandHandler;
import akka.persistence.typed.javadsl.EventHandler;
import akka.persistence.typed.javadsl.ReplicatedEventSourcedBehavior;
import akka.persistence.typed.javadsl.ReplicatedEventSourcing;
import akka.persistence.typed.javadsl.ReplicationContext;
import java.util.Collections;
import java.util.Set;
interface ReplicatedMovieExample {
// #movie-entity
public final class MovieWatchList
extends ReplicatedEventSourcedBehavior<MovieWatchList.Command, ORSet.DeltaOp, ORSet<String>> {
interface Command {}
public static class AddMovie implements Command {
public final String movieId;
public AddMovie(String movieId) {
this.movieId = movieId;
}
}
public static class RemoveMovie implements Command {
public final String movieId;
public RemoveMovie(String movieId) {
this.movieId = movieId;
}
}
public static class GetMovieList implements Command {
public final ActorRef<MovieList> replyTo;
public GetMovieList(ActorRef<MovieList> replyTo) {
this.replyTo = replyTo;
}
}
public static class MovieList {
public final Set<String> movieIds;
public MovieList(Set<String> movieIds) {
this.movieIds = Collections.unmodifiableSet(movieIds);
}
}
public static Behavior<Command> create(
String entityId, ReplicaId replicaId, Set<ReplicaId> allReplicas) {
return ReplicatedEventSourcing.commonJournalConfig(
new ReplicationId("movies", entityId, replicaId),
allReplicas,
PersistenceTestKitReadJournal.Identifier(),
MovieWatchList::new);
}
private MovieWatchList(ReplicationContext replicationContext) {
super(replicationContext);
}
@Override
public ORSet<String> emptyState() {
return ORSet.empty(getReplicationContext().replicaId());
}
@Override
public CommandHandler<Command, ORSet.DeltaOp, ORSet<String>> commandHandler() {
return newCommandHandlerBuilder()
.forAnyState()
.onCommand(
AddMovie.class, (state, command) -> Effect().persist(state.add(command.movieId)))
.onCommand(
RemoveMovie.class,
(state, command) -> Effect().persist(state.remove(command.movieId)))
.onCommand(
GetMovieList.class,
(state, command) -> {
command.replyTo.tell(new MovieList(state.getElements()));
return Effect().none();
})
.build();
}
@Override
public EventHandler<ORSet<String>, ORSet.DeltaOp> eventHandler() {
return newEventHandlerBuilder().forAnyState().onAnyEvent(ORSet::applyOperation);
}
}
// #movie-entity
}
| 1,246 |
651 | <gh_stars>100-1000
/*
* Copyright 2017 <NAME>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.ge.protein.main;
import android.animation.Animator;
import android.animation.AnimatorListenerAdapter;
import android.content.Context;
import android.support.design.widget.CoordinatorLayout;
import android.support.design.widget.TabLayout;
import android.support.v4.app.FragmentActivity;
import android.support.v4.view.ViewPager;
import android.support.v7.widget.Toolbar;
import android.text.TextUtils;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.ImageView;
import android.widget.TextView;
import com.bumptech.glide.Glide;
import com.bumptech.glide.load.engine.DiskCacheStrategy;
import com.ge.protein.R;
import com.ge.protein.data.model.User;
import com.ge.protein.util.AccountManager;
import com.ge.protein.util.RxUtils;
import com.jakewharton.rxbinding2.view.RxView;
import butterknife.BindView;
import butterknife.ButterKnife;
import static com.bumptech.glide.load.resource.drawable.DrawableTransitionOptions.withCrossFade;
import static com.bumptech.glide.request.RequestOptions.placeholderOf;
public class MainView extends CoordinatorLayout implements MainContract.View {
private MainContract.Presenter presenter;
@BindView(R.id.toolbar)
Toolbar toolbar;
@BindView(R.id.user_layout)
View userLayout;
@BindView(R.id.user_avatar)
ImageView userAvatar;
@BindView(R.id.user_name)
TextView userName;
@BindView(R.id.tab_layout)
TabLayout tabLayout;
@BindView(R.id.view_pager)
ViewPager viewPager;
public MainView(Context context) {
super(context);
init(context);
}
public MainView(Context context, AttributeSet attrs) {
super(context, attrs);
init(context);
}
public MainView(Context context, AttributeSet attrs, int defStyleAttr) {
super(context, attrs, defStyleAttr);
init(context);
}
private void init(Context context) {
LayoutInflater.from(context).inflate(R.layout.main_view_content, this, true);
ButterKnife.bind(this);
}
@Override
public void setPresenter(MainContract.Presenter presenter) {
this.presenter = presenter;
}
@Override
public void setupView() {
RxView.clicks(userLayout)
.throttleFirst(RxUtils.WINDOW_DURATION, RxUtils.TIME_UNIT)
.subscribe(o -> presenter.onToolbarUserClicked());
toolbar.inflateMenu(R.menu.main_menu);
toolbar.getMenu().findItem(R.id.action_logout).setEnabled(AccountManager.getInstance().isLogin());
toolbar.setOnMenuItemClickListener(item -> {
if (item.getItemId() == R.id.action_about) {
presenter.toAbout();
return true;
} else if (item.getItemId() == R.id.action_logout) {
presenter.showLogoutDialog();
return true;
}
return false;
});
viewPager.setAdapter(new MainPagerAdapter(((FragmentActivity) getContext()).getSupportFragmentManager()));
// Add 4 tabs for TabLayout
tabLayout.addTab(tabLayout.newTab().setText(R.string.home_tab_popular)); // Popular
if (AccountManager.getInstance().isLogin()) {
tabLayout.addTab(tabLayout.newTab().setText(R.string.home_tab_following)); // Following
}
tabLayout.addTab(tabLayout.newTab().setText(R.string.home_tab_recent)); // Recent
tabLayout.addTab(tabLayout.newTab().setText(R.string.home_tab_debuts)); // Debuts
// Setup sync between TabLayout and ViewPager
viewPager.addOnPageChangeListener(new TabLayout.TabLayoutOnPageChangeListener(tabLayout));
tabLayout.addOnTabSelectedListener(new TabLayout.ViewPagerOnTabSelectedListener(viewPager));
viewPager.setOffscreenPageLimit(3);
}
@Override
public void setDefaultUserInfo() {
Glide.with(getContext())
.load(R.mipmap.ic_launcher)
.transition(withCrossFade())
.into(userAvatar);
setUserName(getContext().getString(R.string.action_login));
}
@Override
public void setUserInfo(User user) {
Glide.with(getContext())
.load(user.avatar_url())
.transition(withCrossFade())
.apply(placeholderOf(R.color.avatar_placeholder).diskCacheStrategy(DiskCacheStrategy.ALL))
.into(userAvatar);
setUserName(user.name());
}
private void setUserName(final String name) {
String previous = userName.getText().toString();
if (TextUtils.isEmpty(previous)) {
userName.setText(name);
userName.setAlpha(0.0f);
userName.animate()
.alpha(1.0f)
.start();
} else {
userName.animate()
.alpha(0.0f)
.setListener(new AnimatorListenerAdapter() {
@Override
public void onAnimationEnd(Animator animation) {
super.onAnimationEnd(animation);
userName.setText(name);
userName.animate().alpha(1.0f).start();
}
}).start();
}
}
}
| 2,473 |
5,193 | <reponame>ls1110924/Aria<gh_stars>1000+
/*
* Copyright (C) 2016 AriaLyy(https://github.com/AriaLyy/Aria)
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.arialyy.aria.core.download.m3u8;
import com.arialyy.aria.core.processor.ILiveTsUrlConverter;
import com.arialyy.aria.util.ALog;
import com.arialyy.aria.util.CheckUtil;
/**
* m3u8直播参数设置
*/
public class M3U8LiveOption extends M3U8Option<M3U8LiveOption> {
private ILiveTsUrlConverter liveTsUrlConverter;
private long liveUpdateInterval;
public M3U8LiveOption() {
super();
}
/**
* M3U8 ts 文件url转换器，对于某些服务器，返回的ts地址可以是相对地址，也可能是处理过的
* 对于这种情况，你需要使用url转换器将地址转换为可正常访问的http地址
*
* @param liveTsUrlConverter {@link ILiveTsUrlConverter}
*/
public M3U8LiveOption setLiveTsUrlConvert(ILiveTsUrlConverter liveTsUrlConverter) {
CheckUtil.checkMemberClass(liveTsUrlConverter.getClass());
this.liveTsUrlConverter = liveTsUrlConverter;
return this;
}
/**
* 设置直播的m3u8文件更新间隔，默认10000微秒。
*
* @param liveUpdateInterval 更新间隔，单位微秒
*/
public M3U8LiveOption setM3U8FileUpdateInterval(long liveUpdateInterval) {
if (liveUpdateInterval <= 1) {
ALog.e(TAG, "间隔时间错误");
return this;
}
this.liveUpdateInterval = liveUpdateInterval;
return this;
}
}
| 836 |
895 | #include "../../slang.h"
#include "slang-ref-object-reflect.h"
#include "slang-generated-obj.h"
#include "slang-generated-obj-macro.h"
#include "slang-ast-support-types.h"
//#include "slang-serialize.h"
#include "slang-serialize-ast-type-info.h"
namespace Slang
{
static const SerialClass* _addClass(SerialClasses* serialClasses, RefObjectType type, RefObjectType super, const List<SerialField>& fields)
{
const SerialClass* superClass = serialClasses->getSerialClass(SerialTypeKind::RefObject, SerialSubType(super));
return serialClasses->add(SerialTypeKind::RefObject, SerialSubType(type), fields.getBuffer(), fields.getCount(), superClass);
}
#define SLANG_REF_OBJECT_ADD_SERIAL_FIELD(FIELD_NAME, TYPE, param) fields.add(SerialField::make(#FIELD_NAME, &obj->FIELD_NAME));
// Note that the obj point is not nullptr, because some compilers notice this is 'indexing from null'
// and warn/error. So we offset from 1.
#define SLANG_REF_OBJECT_ADD_SERIAL_CLASS(NAME, SUPER, ORIGIN, LAST, MARKER, TYPE, param) \
{ \
NAME* obj = SerialField::getPtr<NAME>(); \
SLANG_UNUSED(obj); \
fields.clear(); \
SLANG_FIELDS_RefObject_##NAME(SLANG_REF_OBJECT_ADD_SERIAL_FIELD, param) \
_addClass(serialClasses, RefObjectType::NAME, RefObjectType::SUPER, fields); \
}
struct RefObjectAccess
{
template <typename T>
static void* create(void* context)
{
SLANG_UNUSED(context)
return new T;
}
static void calcClasses(SerialClasses* serialClasses)
{
// Add SerialRefObject first, and specially handle so that we add a null super class
serialClasses->add(SerialTypeKind::RefObject, SerialSubType(RefObjectType::SerialRefObject), nullptr, 0, nullptr);
// Add the rest in order such that Super class is always added before its children
List<SerialField> fields;
SLANG_CHILDREN_RefObject_SerialRefObject(SLANG_REF_OBJECT_ADD_SERIAL_CLASS, _)
}
};
#define SLANG_GET_SUPER_BASE(SUPER) nullptr
#define SLANG_GET_SUPER_INNER(SUPER) &SUPER::kReflectClassInfo
#define SLANG_GET_SUPER_LEAF(SUPER) &SUPER::kReflectClassInfo
#define SLANG_GET_CREATE_FUNC_NONE(NAME) nullptr
#define SLANG_GET_CREATE_FUNC_OBJ_ABSTRACT(NAME) nullptr
#define SLANG_GET_CREATE_FUNC_OBJ(NAME) &RefObjectAccess::create<NAME>
#define SLANG_REFLECT_CLASS_INFO(NAME, SUPER, ORIGIN, LAST, MARKER, TYPE, param) \
/* static */const ReflectClassInfo NAME::kReflectClassInfo = { uint32_t(RefObjectType::NAME), uint32_t(RefObjectType::LAST), SLANG_GET_SUPER_##TYPE(SUPER), #NAME, SLANG_GET_CREATE_FUNC_##MARKER(NAME), nullptr, uint32_t(sizeof(NAME)), uint8_t(SLANG_ALIGN_OF(NAME)) };
SLANG_ALL_RefObject_SerialRefObject(SLANG_REFLECT_CLASS_INFO, _)
/* static */const SerialRefObjects SerialRefObjects::g_singleton;
// Macro to set all of the entries in m_infos for SerialRefObjects
#define SLANG_GET_REFLECT_CLASS_INFO(NAME, SUPER, ORIGIN, LAST, MARKER, TYPE, param) m_infos[Index(RefObjectType::NAME)] = &NAME::kReflectClassInfo;
SerialRefObjects::SerialRefObjects()
{
SLANG_ALL_RefObject_SerialRefObject(SLANG_GET_REFLECT_CLASS_INFO, _)
}
/* static */SlangResult SerialRefObjects::addSerialClasses(SerialClasses* serialClasses)
{
RefObjectAccess::calcClasses(serialClasses);
return SLANG_OK;
}
} // namespace Slang
| 1,219 |
1,510 | <filename>exec/java-exec/src/test/java/org/apache/drill/exec/physical/impl/writer/TestParquetWriterEmptyFiles.java
/*
* 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.drill.exec.physical.impl.writer;
import org.apache.commons.io.FileUtils;
import org.apache.drill.common.types.TypeProtos;
import org.apache.drill.exec.record.BatchSchema;
import org.apache.drill.exec.record.BatchSchemaBuilder;
import org.apache.drill.exec.record.metadata.SchemaBuilder;
import org.apache.drill.test.BaseTestQuery;
import org.apache.drill.categories.ParquetTest;
import org.apache.drill.categories.UnlikelyTest;
import org.apache.drill.exec.ExecConstants;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.experimental.categories.Category;
import java.io.File;
import java.nio.file.Paths;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
@Category({ParquetTest.class, UnlikelyTest.class})
public class TestParquetWriterEmptyFiles extends BaseTestQuery {
@BeforeClass
public static void initFs() throws Exception {
updateTestCluster(3, null);
dirTestWatcher.copyResourceToRoot(Paths.get("schemachange"));
dirTestWatcher.copyResourceToRoot(Paths.get("parquet", "empty"));
dirTestWatcher.copyResourceToRoot(Paths.get("parquet", "alltypes_required.parquet"));
}
@Test
public void testWriteEmptyFile() throws Exception {
final String outputFileName = "testparquetwriteremptyfiles_testwriteemptyfile";
final File outputFile = FileUtils.getFile(dirTestWatcher.getDfsTestTmpDir(), outputFileName);
test("CREATE TABLE dfs.tmp.%s AS SELECT * FROM cp.`employee.json` WHERE 1=0", outputFileName);
assertTrue(outputFile.exists());
}
@Test
public void testWriteEmptyFileWithSchema() throws Exception {
final String outputFileName = "testparquetwriteremptyfiles_testwriteemptyfilewithschema";
test("CREATE TABLE dfs.tmp.%s AS select * from dfs.`parquet/alltypes_required.parquet` where `col_int` = 0", outputFileName);
// Only the last scan scheme is written
SchemaBuilder schemaBuilder = new SchemaBuilder()
.add("col_int", TypeProtos.MinorType.INT)
.add("col_chr", TypeProtos.MinorType.VARCHAR)
.add("col_vrchr", TypeProtos.MinorType.VARCHAR)
.add("col_dt", TypeProtos.MinorType.DATE)
.add("col_tim", TypeProtos.MinorType.TIME)
.add("col_tmstmp", TypeProtos.MinorType.TIMESTAMP)
.add("col_flt", TypeProtos.MinorType.FLOAT4)
.add("col_intrvl_yr", TypeProtos.MinorType.INTERVAL)
.add("col_intrvl_day", TypeProtos.MinorType.INTERVAL)
.add("col_bln", TypeProtos.MinorType.BIT);
BatchSchema expectedSchema = new BatchSchemaBuilder()
.withSchemaBuilder(schemaBuilder)
.build();
testBuilder()
.unOrdered()
.sqlQuery("select * from dfs.tmp.%s", outputFileName)
.schemaBaseLine(expectedSchema)
.go();
}
@Test
public void testWriteEmptyFileWithEmptySchema() throws Exception {
final String outputFileName = "testparquetwriteremptyfiles_testwriteemptyfileemptyschema";
final File outputFile = FileUtils.getFile(dirTestWatcher.getDfsTestTmpDir(), outputFileName);
test("CREATE TABLE dfs.tmp.%s AS SELECT * FROM cp.`empty.json`", outputFileName);
assertFalse(outputFile.exists());
}
@Test
public void testWriteEmptySchemaChange() throws Exception {
final String outputFileName = "testparquetwriteremptyfiles_testwriteemptyschemachange";
final File outputFile = FileUtils.getFile(dirTestWatcher.getDfsTestTmpDir(), outputFileName);
test("CREATE TABLE dfs.tmp.%s AS select id, a, b from dfs.`schemachange/multi/*.json` WHERE id = 0", outputFileName);
// Only the last scan scheme is written
SchemaBuilder schemaBuilder = new SchemaBuilder()
.addNullable("id", TypeProtos.MinorType.BIGINT)
.addNullable("a", TypeProtos.MinorType.BIGINT)
.addNullable("b", TypeProtos.MinorType.BIT);
BatchSchema expectedSchema = new BatchSchemaBuilder()
.withSchemaBuilder(schemaBuilder)
.build();
testBuilder()
.unOrdered()
.sqlQuery("select * from dfs.tmp.%s", outputFileName)
.schemaBaseLine(expectedSchema)
.go();
// Make sure that only 1 parquet file was created
assertEquals(1, outputFile.list((dir, name) -> name.endsWith("parquet")).length);
}
@Test
public void testComplexEmptyFileSchema() throws Exception {
final String outputFileName = "testparquetwriteremptyfiles_testcomplexemptyfileschema";
test("create table dfs.tmp.%s as select * from dfs.`parquet/empty/complex/empty_complex.parquet`", outputFileName);
// end_date column is null, so it missing in result schema.
SchemaBuilder schemaBuilder = new SchemaBuilder()
.addNullable("id", TypeProtos.MinorType.BIGINT)
.addNullable("name", TypeProtos.MinorType.VARCHAR)
.addArray("orders", TypeProtos.MinorType.BIGINT);
BatchSchema expectedSchema = new BatchSchemaBuilder()
.withSchemaBuilder(schemaBuilder)
.build();
testBuilder()
.unOrdered()
.sqlQuery("select * from dfs.tmp.%s", outputFileName)
.schemaBaseLine(expectedSchema)
.go();
}
@Test
public void testWriteEmptyFileAfterFlush() throws Exception {
final String outputFileName = "testparquetwriteremptyfiles_test_write_empty_file_after_flush";
final File outputFile = FileUtils.getFile(dirTestWatcher.getDfsTestTmpDir(), outputFileName);
try {
// this specific value will force a flush just after the final row is written
// this may cause the creation of a new "empty" parquet file
test("ALTER SESSION SET `store.parquet.block-size` = 19926");
final String query = "SELECT * FROM cp.`employee.json` LIMIT 100";
test("CREATE TABLE dfs.tmp.%s AS %s", outputFileName, query);
// Make sure that only 1 parquet file was created
assertEquals(1, outputFile.list((dir, name) -> name.endsWith("parquet")).length);
// this query will fail if an "empty" file was created
testBuilder()
.unOrdered()
.sqlQuery("SELECT * FROM dfs.tmp.%s", outputFileName)
.sqlBaselineQuery(query)
.go();
} finally {
// restore the session option
resetSessionOption(ExecConstants.PARQUET_BLOCK_SIZE);
}
}
}
| 2,486 |
4,551 | <reponame>quipper/robolectric<gh_stars>1000+
package org.robolectric.annotation.processing;
import java.util.Collection;
import java.util.Map;
import java.util.TreeMap;
public class DocumentedPackage extends DocumentedElement {
private final Map<String, DocumentedType> documentedTypes = new TreeMap<>();
DocumentedPackage(String name) {
super(name);
}
public Collection<DocumentedType> getDocumentedTypes() {
return documentedTypes.values();
}
public DocumentedType getDocumentedType(String name) {
DocumentedType documentedType = documentedTypes.get(name);
if (documentedType == null) {
documentedType = new DocumentedType(name);
documentedTypes.put(name, documentedType);
}
return documentedType;
}
}
| 236 |
2,757 | <filename>2021/quals/hw-parking/src/game.py
# 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.
import sys
import time
import string
from PIL import Image, ImageDraw
from matplotlib import pyplot as plt
if sys.platform == 'darwin':
import matplotlib
matplotlib.use('TkAgg')
import os
WALL = -1
blocks = []
board = {}
boardfile = open(sys.argv[1]).read()
header, boardfile = boardfile.split("\n", 1)
W, H = [int(x) for x in header.split()]
flagblocks = {}
target = -1
SZ = 4
target_start = None
def putcar(x,y,w,h,m):
x0 = x*SZ
x1 = (x+w)*SZ
y0 = y*SZ
y1 = (y+h)*SZ
if m == -1:
color = (0, 128, 0)
elif m == -2:
color = (128, 0, 0)
else:
color = (128, 128, 128)
draw.rectangle((x0+1,y0+1,x1-2,y1-2), fill=color)
def putwall(x,y,w,h):
x0 = x*SZ
x1 = (x+w)*SZ
y0 = y*SZ
y1 = (y+h)*SZ
draw.rectangle((x0,y0,x1-1,y1-1), fill=(48,24,0))
walls = []
for line in boardfile.splitlines():
if not line.strip(): continue
x,y,w,h,movable = [int(x) for x in line.split()]
if movable == -1:
flagblocks[len(blocks)] = (x,y)
elif movable == -2:
target = len(blocks)
target_start = x, y
for i in range(x, x+w):
for j in range(y, y+h):
if movable != 0:
if (i,j) in board:
print("Car overlap at %d, %d" % (i,j))
#assert False
board[(i,j)] = len(blocks)
else:
if (i,j) in board and board[i,j] != WALL:
print("Wall-car overlap at %d, %d" % (i,j))
#assert False
board[(i,j)] = WALL
if movable:
blocks.append([x,y,w,h, movable])
else:
walls.append([x,y,w,h])
def printflag():
if os.environ.get("FLAG") == "0":
print("<flag would be here if on real level>")
return
bits = ""
for fl in flagblocks:
orig_xy = flagblocks[fl]
new_xy = tuple(blocks[fl][:2])
bit = 0 if orig_xy == new_xy else 1
bits += str(bit)
flag = b"CTF{"
while bits:
byte, bits = bits[:8], bits[8:]
flag += bytes([ int(byte[::-1], 2) ])
flag += b"}"
print(flag)
def check_win():
x, y = blocks[target][:2]
if target_start is not None and target_start != (x,y):
print("Congratulations, here's your flag:")
printflag()
sys.exit(0)
print("Here's the parking. Can you move the red car?")
print("Green cars' final position will encode the flag.")
print("Move by clicking a car, then clicking a near empty space to move to. Feel free to zoom in using the magnifying glass if necessary!")
#print_board()
def can_move(which, dirx, diry):
x,y,w,h,mv = blocks[which]
if w == 1 and dirx != 0:
print("This car moves only vertically...")
return False
if h == 1 and diry != 0:
print("This car only moves horizontally...")
return False
bad = False
for i in range(x+dirx, x+dirx+w):
for j in range(y+diry, y+diry+h):
if (i,j) in board and board[(i,j)] != which:
bad = True
if bad:
print("Such a move would cause collision...")
return False
return True
def do_move(which, dirx, diry):
x,y,w,h,mv = blocks[which]
for i in range(x, x+w):
for j in range(y, y+h):
del board[(i,j)]
x += dirx
y += diry
blocks[which] = [x, y, w, h, mv]
for i in range(x, x+w):
for j in range(y, y+h):
board[(i,j)] = which
if mv == -1:
print("This setting corresponds to the following flag:")
printflag()
def onclick(event):
global which
global xy
if which is None:
x, y = event.xdata, event.ydata
x, y = int(x), int(y)
xy = (x, y)
try:
which = board[x//SZ, y//SZ]
if which == WALL:
which = None
print("Selected wall...")
return
print("Car %d selected." % which)
except KeyError:
print("Selected empty space...")
which = None
return
dirx, diry = event.xdata - xy[0], event.ydata - xy[1]
if abs(dirx) > abs(diry):
dirx, diry = (1, 0) if dirx > 0 else (-1, 0)
else:
dirx, diry = (0, 1) if diry > 0 else (0, -1)
if not can_move(which, dirx, diry):
which = None
return
do_move(which, dirx, diry)
which = None
redraw()
check_win()
DRAW = True
if os.environ.get("DRAW") == "0":
DRAW = False
first = True
def redraw():
print("Redrawing...")
global draw, first, ax
im = Image.new("RGB", (W*SZ,H*SZ), (255,255,255))
draw = ImageDraw.Draw(im)
for wall in walls:
putwall(*wall)
for block in blocks:
putcar(*block)
print("Redrawn.")
if first:
print("Saving...")
im.save("initial.png")
print("Saved.")
first = False
ax = fig.add_subplot(111)
ax = ax.imshow(im)
ax.set_data(im)
plt.draw()
if DRAW:
fig = plt.figure()
plt.ion()
plt.show()
cid = fig.canvas.mpl_connect('button_press_event', onclick)
redraw()
which = None
xy = None
# Alternative API, you don't have to click ;)
while True:
i = input()
which, dirx, diry = i.strip().split()
which, dirx, diry = int(which), int(dirx), int(diry)
if can_move(which, dirx, diry):
do_move(which, dirx, diry)
print("Moved")
if DRAW:
redraw()
check_win()
else:
print("Invalid")
| 2,941 |
388 | // -*- mode:java; encoding:utf-8 -*-
// vim:set fileencoding=utf-8:
// @homepage@
package example;
import java.awt.*;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import javax.swing.*;
import javax.swing.text.html.HTMLEditorKit;
import javax.swing.text.html.StyleSheet;
public final class MainPanel extends JPanel {
@SuppressWarnings("AvoidEscapedUnicodeCharacters")
private MainPanel() {
super(new BorderLayout());
StyleSheet styleSheet = new StyleSheet();
// styleSheet.addRule("body {font-size: 24pt; font-family: IPAexGothic;}");
HTMLEditorKit htmlEditorKit = new HTMLEditorKit();
htmlEditorKit.setStyleSheet(styleSheet);
JEditorPane editor1 = new JEditorPane();
editor1.setEditorKit(htmlEditorKit);
URL url = getClass().getResource("SurrogatePair.html");
try (Reader reader = new InputStreamReader(url.openStream(), StandardCharsets.UTF_8)) {
editor1.read(reader, "html");
} catch (IOException ex) {
editor1.setText("<html><p>(��) (𦹀)<br />(��) (𠮟)</p></html>");
}
JEditorPane editor2 = new JEditorPane();
// editor2.setFont(new Font("IPAexGothic", Font.PLAIN, 24));
editor2.putClientProperty(JEditorPane.HONOR_DISPLAY_PROPERTIES, Boolean.TRUE);
editor2.setText("(\uD85B\uDE40) (\u26E40)\n(\uD842\uDF9F) (\u20B9F)");
// editor2.setText("(𦹀) (𦹀)\n(𠮟) (𠮟)");
JPanel p = new JPanel(new GridLayout(0, 1));
p.add(makeTitledPanel("Numeric character reference", editor1));
p.add(makeTitledPanel("Unicode escapes", editor2));
JButton button = new JButton("browse: SurrogatePair.html");
button.addActionListener(e -> browseCacheFile(url));
add(p);
add(button, BorderLayout.SOUTH);
setPreferredSize(new Dimension(320, 240));
}
private static void browseCacheFile(URL url) {
if (Desktop.isDesktopSupported()) {
try (InputStream in = new BufferedInputStream(url.openStream())) {
Path path = Files.createTempFile("_tmp", ".html");
path.toFile().deleteOnExit();
Files.copy(in, path, StandardCopyOption.REPLACE_EXISTING);
Desktop.getDesktop().browse(path.toUri());
} catch (IOException ex) {
ex.printStackTrace();
Toolkit.getDefaultToolkit().beep();
}
// try {
// File tmp = File.createTempFile("_tmp", ".html");
// tmp.deleteOnExit();
// try (InputStream in = new BufferedInputStream(url.openStream());
// OutputStream out = new BufferedOutputStream(new FileOutputStream(tmp))) {
// byte buf[] = new byte[256];
// int len;
// while ((len = in.read(buf)) != -1) {
// out.write(buf, 0, len);
// }
// out.flush();
// Desktop.getDesktop().browse(tmp.toURI());
// }
// } catch (IOException ex) {
// ex.printStackTrace();
// }
}
}
private static Component makeTitledPanel(String title, Component c) {
JScrollPane scroll = new JScrollPane(c);
scroll.setBorder(BorderFactory.createTitledBorder(title));
return scroll;
}
public static void main(String[] args) {
EventQueue.invokeLater(MainPanel::createAndShowGui);
}
private static void createAndShowGui() {
try {
UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
} catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {
ex.printStackTrace();
Toolkit.getDefaultToolkit().beep();
}
JFrame frame = new JFrame("@title@");
frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
frame.getContentPane().add(new MainPanel());
frame.pack();
frame.setLocationRelativeTo(null);
frame.setVisible(true);
}
}
| 1,621 |
831 | <filename>adt-ui-model/testSrc/com/android/tools/adtui/model/updater/UpdaterTest.java
/*
* Copyright (C) 2017 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.tools.adtui.model.updater;
import com.android.tools.adtui.model.FakeTimer;
import com.android.tools.adtui.model.updater.Updatable;
import com.android.tools.adtui.model.updater.Updater;
import org.junit.Before;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import static org.junit.Assert.*;
public class UpdaterTest {
private Updater myUpdater;
@Before
public void setUp() {
myUpdater = new Updater(new FakeTimer());
}
@Test
public void testRegister() {
List<Updatable> updated = new ArrayList<>();
FakeUpdatable updatableA = new FakeUpdatable(updated);
FakeUpdatable updatableB = new FakeUpdatable(updated);
myUpdater.register(Arrays.asList(updatableA, updatableB));
updated.clear();
myUpdater.getTimer().tick(1);
assertEquals(Arrays.asList(updatableA, updatableB), updated);
}
@Test
public void updatableRegistersAnotherUpdatable() {
final List<Updatable> updated = new ArrayList<>();
FakeUpdatable updatableD = new FakeUpdatable(updated);
FakeUpdatable updatableA = new FakeUpdatable(updated) {
@Override
public void update(long elapsedNs) {
super.update(elapsedNs);
myUpdater.register(updatableD);
}
};
FakeUpdatable updatableB = new FakeUpdatable(updated);
FakeUpdatable updatableC = new FakeUpdatable(updated);
myUpdater.register(updatableA);
myUpdater.register(updatableB);
myUpdater.register(updatableC);
updated.clear();
myUpdater.getTimer().tick(1);
assertEquals(Arrays.asList(updatableA, updatableB, updatableC), updated);
myUpdater.unregister(updatableA);
updated.clear();
myUpdater.getTimer().tick(1);
assertEquals(Arrays.asList(updatableB, updatableC, updatableD), updated);
}
@Test
public void testUnregister() {
List<Updatable> updated = new ArrayList<>();
FakeUpdatable updatableA = new FakeUpdatable(updated);
FakeUpdatable updatableB = new FakeUpdatable(updated);
myUpdater.register(updatableA);
myUpdater.register(updatableB);
updated.clear();
myUpdater.getTimer().tick(1);
assertEquals(Arrays.asList(updatableA, updatableB), updated);
myUpdater.unregister(updatableA);
updated.clear();
myUpdater.getTimer().tick(1);
assertEquals(Collections.singletonList(updatableB), updated);
}
@Test
public void updatableUnregistersUpdatable() {
List<Updatable> updated = new ArrayList<>();
FakeUpdatable updatableA = new FakeUpdatable(updated);
FakeUpdatable updatableC = new FakeUpdatable(updated);
FakeUpdatable updatableB = new FakeUpdatable(updated) {
@Override
public void update(long elapsedNs) {
super.update(elapsedNs);
myUpdater.unregister(updatableC);
}
};
myUpdater.register(Arrays.asList(updatableA, updatableB, updatableC));
updated.clear();
myUpdater.getTimer().tick(1);
assertEquals(Arrays.asList(updatableA, updatableB, updatableC), updated);
updated.clear();
myUpdater.getTimer().tick(1);
assertEquals(Arrays.asList(updatableA, updatableB), updated);
}
@Test
public void testReset() {
List<Updatable> reset = new ArrayList<>();
List<Updatable> updated = new ArrayList<>();
Updatable updatableA = new FakeUpdatable(updated) {
@Override
public void reset() {
reset.add(this);
}
};
Updatable updatableB = new FakeUpdatable(updated) {
@Override
public void reset() {
reset.add(this);
}
};
myUpdater.register(updatableA);
myUpdater.register(updatableB);
updated.clear();
myUpdater.getTimer().tick(1);
assertEquals(Arrays.asList(updatableA, updatableB), updated);
myUpdater.reset();
reset.clear();
myUpdater.getTimer().tick(1);
assertEquals(Arrays.asList(updatableA, updatableB), reset);
}
private static class FakeUpdatable implements Updatable {
private final List<Updatable> myUpdated;
private FakeUpdatable(List<Updatable> updated) {
myUpdated = updated;
}
@Override
public void update(long elapsedNs) {
myUpdated.add(this);
}
}
}
| 1,863 |
777 | // Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "remoting/client/ios/bridge/frame_consumer_bridge.h"
#include <gtest/gtest.h>
#include <memory>
#include <queue>
#include "base/bind.h"
#include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
#include "third_party/webrtc/modules/desktop_capture/desktop_region.h"
namespace {
const webrtc::DesktopSize kFrameSize(100, 100);
const webrtc::DesktopVector kDpi(100, 100);
const webrtc::DesktopRect FrameRect() {
return webrtc::DesktopRect::MakeSize(kFrameSize);
}
webrtc::DesktopRegion FrameRegion() {
return webrtc::DesktopRegion(FrameRect());
}
void FrameDelivery(webrtc::DesktopFrame* buffer,
const webrtc::DesktopRegion& region) {
ASSERT_TRUE(buffer->size().equals(kFrameSize));
ASSERT_TRUE(region.Equals(FrameRegion()));
};
} // namespace
namespace remoting {
class FrameProducerTester : public FrameProducer {
public:
virtual ~FrameProducerTester(){};
void DrawBuffer(webrtc::DesktopFrame* buffer) override {
frames.push(buffer);
};
void InvalidateRegion(const webrtc::DesktopRegion& region) override {
NOTIMPLEMENTED();
};
void RequestReturnBuffers(const base::Closure& done) override {
// Don't have to actually return the buffers. This function is really
// saying don't use the references anymore, they are now invalid.
while (!frames.empty()) {
frames.pop();
}
done.Run();
};
void SetOutputSizeAndClip(const webrtc::DesktopSize& view_size,
const webrtc::DesktopRect& clip_area) override {
viewSize = view_size;
clipArea = clip_area;
};
std::queue<webrtc::DesktopFrame*> frames;
webrtc::DesktopSize viewSize;
webrtc::DesktopRect clipArea;
};
class FrameConsumerBridgeTest : public ::testing::Test {
protected:
void SetUp() override {
frameProducer_.reset(new FrameProducerTester());
frameConsumer_.reset(new FrameConsumerBridge(base::Bind(&FrameDelivery)));
frameConsumer_->Initialize(frameProducer_.get());
}
void TearDown() override {}
std::unique_ptr<FrameProducerTester> frameProducer_;
std::unique_ptr<FrameConsumerBridge> frameConsumer_;
};
TEST(FrameConsumerBridgeTest_NotInitialized, CreateAndRelease) {
std::unique_ptr<FrameConsumerBridge> frameConsumer_(
new FrameConsumerBridge(base::Bind(&FrameDelivery)));
ASSERT_TRUE(frameConsumer_.get() != NULL);
frameConsumer_.reset();
ASSERT_TRUE(frameConsumer_.get() == NULL);
}
// TODO(nicholss): FrameConsumer has changed since last integration.
// Need to update the tests.
// TEST_F(FrameConsumerBridgeTest, ApplyBuffer) {
// webrtc::DesktopFrame* frame = NULL;
// ASSERT_EQ(0, frameProducer_->frames.size());
// frameConsumer_->SetSourceSize(kFrameSize, kDpi);
// ASSERT_EQ(1, frameProducer_->frames.size());
//
// // Return the frame, and ensure we get it back
// frame = frameProducer_->frames.front();
// frameProducer_->frames.pop();
// ASSERT_EQ(0, frameProducer_->frames.size());
// frameConsumer_->ApplyBuffer(
// kFrameSize, FrameRect(), frame, FrameRegion(), FrameRegion());
// ASSERT_EQ(1, frameProducer_->frames.size());
// ASSERT_TRUE(frame == frameProducer_->frames.front());
// ASSERT_TRUE(frame->data() == frameProducer_->frames.front()->data());
//
// // Change the SourceSize, we should get a new frame, but when the old frame
// is
// // submitted we will not get it back.
// frameConsumer_->SetSourceSize(webrtc::DesktopSize(1, 1), kDpi);
// ASSERT_EQ(2, frameProducer_->frames.size());
// frame = frameProducer_->frames.front();
// frameProducer_->frames.pop();
// ASSERT_EQ(1, frameProducer_->frames.size());
// frameConsumer_->ApplyBuffer(
// kFrameSize, FrameRect(), frame, FrameRegion(), FrameRegion());
// ASSERT_EQ(1, frameProducer_->frames.size());
// }
//
// TEST_F(FrameConsumerBridgeTest, SetSourceSize) {
// frameConsumer_->SetSourceSize(webrtc::DesktopSize(0, 0),
// webrtc::DesktopVector(0, 0));
// ASSERT_TRUE(frameProducer_->viewSize.equals(webrtc::DesktopSize(0, 0)));
// ASSERT_TRUE(frameProducer_->clipArea.equals(
// webrtc::DesktopRect::MakeLTRB(0, 0, 0, 0)));
// ASSERT_EQ(1, frameProducer_->frames.size());
// ASSERT_TRUE(
// frameProducer_->frames.front()->size().equals(webrtc::DesktopSize(0,
// 0)));
//
// frameConsumer_->SetSourceSize(kFrameSize, kDpi);
// ASSERT_TRUE(frameProducer_->viewSize.equals(kFrameSize));
// ASSERT_TRUE(frameProducer_->clipArea.equals(FrameRect()));
// ASSERT_EQ(2, frameProducer_->frames.size());
// frameProducer_->frames.pop();
// ASSERT_TRUE(frameProducer_->frames.front()->size().equals(kFrameSize));
// }
} // namespace remoting
| 1,748 |
1,403 | <gh_stars>1000+
/*
* DbgBuffer.h
*
* This file is part of the "LLGL" project (Copyright (c) 2015-2019 by <NAME>)
* See "LICENSE.txt" for license information.
*/
#ifndef LLGL_DBG_BUFFER_H
#define LLGL_DBG_BUFFER_H
#include <LLGL/Buffer.h>
#include <string>
namespace LLGL
{
class DbgBuffer final : public Buffer
{
public:
void SetName(const char* name) override;
BufferDescriptor GetDesc() const override;
public:
DbgBuffer(Buffer& instance, const BufferDescriptor& desc);
public:
Buffer& instance;
const BufferDescriptor desc;
std::string label;
std::uint64_t elements = 0;
bool initialized = false;
bool mapped = false;
};
} // /namespace LLGL
#endif
// ================================================================================
| 399 |
491 | /*
* Encog(tm) Core v3.4 - Java Version
* http://www.heatonresearch.com/encog/
* https://github.com/encog/encog-java-core
* Copyright 2008-2017 Heaton Research, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
* For more information on Heaton Research copyrights, licenses
* and trademarks visit:
* http://www.heatonresearch.com/copyright
*/
package org.encog.ml.svm;
/**
* Supports both class and new support vector calculations, as well as one-class
* distribution.
*
* For more information about the two "new" support vector types, as well as the
* one-class SVM, refer to the following articles.
*
* <NAME>, <NAME>, <NAME>, and <NAME>. New support vector
* algorithms. Neural Computation, 12, 2000, 1207-1245.
*
* <NAME>, <NAME>, <NAME>, <NAME>, and <NAME>.
* Estimating the support of a high-dimensional distribution. Neural
* Computation, 13, 2001, 1443-1471.
*
*/
public enum SVMType {
/**
* Support vector for classification.
*/
SupportVectorClassification,
/**
* New support vector for classification. For more information see the
* citations in the class header.
*/
NewSupportVectorClassification,
/**
* One class distribution estimation.
*/
SupportVectorOneClass,
/**
* Support vector for regression. Use Epsilon.
*/
EpsilonSupportVectorRegression,
/**
* A "new" support vector machine for regression. For more information see
* the citations in the class header.
*/
NewSupportVectorRegression
}
| 569 |
458 | <reponame>VelocityRa/Ghidra-Cpp-Class-Analyzer
package cppclassanalyzer.analysis.cmd;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import cppclassanalyzer.utils.ConstantPropagationUtils;
import cppclassanalyzer.utils.CppClassAnalyzerUtils;
import ghidra.app.cmd.data.rtti.ClassTypeInfo;
import ghidra.app.cmd.data.rtti.gcc.ClassTypeInfoUtils;
import ghidra.framework.cmd.BackgroundCommand;
import ghidra.framework.model.DomainObject;
import ghidra.program.model.address.Address;
import ghidra.program.model.address.AddressSetView;
import ghidra.program.model.data.DataTypeComponent;
import ghidra.program.model.data.GenericCallingConvention;
import ghidra.program.model.lang.Register;
import ghidra.program.model.listing.*;
import ghidra.program.model.symbol.*;
import ghidra.program.util.SymbolicPropogator;
import ghidra.util.Msg;
import ghidra.util.datastruct.IntSet;
import ghidra.util.exception.CancelledException;
import ghidra.util.task.TaskMonitor;
public abstract class AbstractConstructorAnalysisCmd extends BackgroundCommand {
protected ClassTypeInfo type = null;
protected Program program;
protected TaskMonitor monitor;
protected FunctionManager fManager;
protected ReferenceManager manager;
protected Listing listing;
protected AbstractConstructorAnalysisCmd(String name) {
super(name, false, true, false);
}
public AbstractConstructorAnalysisCmd(String name, ClassTypeInfo typeinfo) {
this(name);
this.type = typeinfo;
}
@Override
public boolean applyTo(DomainObject obj, TaskMonitor taskMonitor) {
if (!(obj instanceof Program)) {
String message = "Can only apply a constructor to a program.";
Msg.error(this, message);
return false;
}
this.program = (Program) obj;
this.monitor = taskMonitor;
this.listing = program.getListing();
this.fManager = program.getFunctionManager();
this.manager = program.getReferenceManager();
try {
// TODO follow calls to new to pick up simpler constructors first
return analyze();
} catch (CancelledException e) {
return false;
} catch (Exception e) {
e.printStackTrace();
Msg.trace(this, e);
return false;
}
}
protected abstract boolean analyze() throws Exception;
public void setTypeInfo(ClassTypeInfo typeinfo) {
this.type = typeinfo;
}
protected boolean isProcessed(Address address) {
Function function = fManager.getFunctionContaining(address);
return !CppClassAnalyzerUtils.isDefaultFunction(function);
}
protected void setDestructor(ClassTypeInfo typeinfo, Function function) throws Exception {
setFunction(typeinfo, function, true);
if (function.isThunk()) {
setFunction(typeinfo, function.getThunkedFunction(false), true);
}
}
protected Function createConstructor(ClassTypeInfo typeinfo, Address address) throws Exception {
Function function = fManager.getFunctionContaining(address);
if (function != null && !CppClassAnalyzerUtils.isDefaultFunction(function)) {
if (function.getName().equals(typeinfo.getName())) {
return function;
}
} else if (function != null) {
function = ClassTypeInfoUtils.getClassFunction(
program, typeinfo, function.getEntryPoint());
} else {
function = ClassTypeInfoUtils.getClassFunction(program, typeinfo, address);
}
setFunction(typeinfo, function, false);
createSubConstructors(typeinfo, function, false);
return function;
}
protected boolean isConstructor(ClassTypeInfo typeinfo, Address address) {
Function function = fManager.getFunctionContaining(address);
if (function != null && function.getName().equals(typeinfo.getName())) {
return true;
}
return false;
}
protected void setFunction(ClassTypeInfo typeinfo, Function function, boolean destructor)
throws Exception {
String name = destructor ? "~"+typeinfo.getName() : typeinfo.getName();
function.setName(name, SourceType.IMPORTED);
function.setParentNamespace(typeinfo.getGhidraClass());
function.setCallingConvention(GenericCallingConvention.thiscall.getDeclarationName());
CppClassAnalyzerUtils.setConstructorDestructorTag(function, !destructor);
}
protected void createSubConstructors(ClassTypeInfo type, Function constructor,
boolean destructor) throws Exception {
if (constructor.getParameter(0).isStackVariable()) {
// TODO Need to figure out how to handle stack parameters
return;
}
ConstructorAnalyzerHelper helper = new ConstructorAnalyzerHelper(type, constructor);
SymbolicPropogator symProp = analyzeFunction(constructor);
Register thisReg = getThisRegister(constructor.getParameter(0));
for (Address address : helper.getCalledFunctionAddresses()) {
monitor.checkCanceled();
Instruction inst = listing.getInstructionAt(address);
int delayDepth = inst.getDelaySlotDepth();
if (delayDepth > 0) {
while (inst.isInDelaySlot()) {
monitor.checkCanceled();
inst = inst.getNext();
}
}
SymbolicPropogator.Value value =
symProp.getRegisterValue(inst.getAddress(), thisReg);
if (value == null || !helper.isValidOffset((int) value.getValue())) {
continue;
}
ClassTypeInfo parent = helper.getParentAt((int) value.getValue());
Function function = getCalledFunction(address);
if (destructor) {
setDestructor(parent, function);
} else {
createConstructor(parent, function.getEntryPoint());
}
}
}
private Function getCalledFunction(Address address) {
Instruction inst = listing.getInstructionAt(address);
// If it didn't this doesn't get reached
Address target = inst.getReferencesFrom()[0].getToAddress();
return listing.getFunctionAt(target);
}
private Register getThisRegister(Parameter param) {
if (param.getAutoParameterType() == AutoParameterType.THIS) {
return param.getRegister();
}
return null;
}
protected SymbolicPropogator analyzeFunction(Function function) throws CancelledException {
return ConstantPropagationUtils.analyzeFunction(function, monitor);
}
protected static class ConstructorAnalyzerHelper {
private final ClassTypeInfo type;
private final Function function;
private final IntSet offsets;
protected ConstructorAnalyzerHelper(ClassTypeInfo type, Function function) {
this.type = type;
this.function = function;
this.offsets = new IntSet(type.getParentModels().length);
DataTypeComponent[] comps = type.getClassDataType().getDefinedComponents();
Arrays.stream(comps)
.filter(c -> c.getFieldName().contains("super_"))
.mapToInt(DataTypeComponent::getOffset)
.forEach(offsets::add);
}
protected List<Address> getCalledFunctionAddresses() {
AddressSetView body = function.getBody();
return function.getCalledFunctions(TaskMonitor.DUMMY)
.stream()
.filter(CppClassAnalyzerUtils::isDefaultFunction)
.map(Function::getSymbol)
.map(Symbol::getReferences)
.flatMap(Arrays::stream)
.map(Reference::getFromAddress)
.filter(body::contains)
.collect(Collectors.toList());
}
protected boolean isValidOffset(int offset) {
return offsets.contains(offset);
}
protected ClassTypeInfo getParentAt(int offset) {
if (!offsets.contains(offset)) {
return null;
}
offsets.remove(offset);
String name = type.getClassDataType()
.getComponentAt(offset)
.getFieldName()
.replace("super_", "");
return Arrays.stream(type.getParentModels())
.filter(t -> t.getName().equals(name))
.findFirst()
.orElse(null);
}
}
}
| 2,483 |
42,609 | {
"plugins": [
"transform-destructuring",
"transform-modules-commonjs",
"transform-member-expression-literals",
"transform-property-literals"
]
}
| 61 |
4,013 | from checkov.common.models.enums import CheckCategories
from checkov.terraform.checks.resource.base_resource_value_check import BaseResourceValueCheck
class EC2DetailedMonitoringEnabled(BaseResourceValueCheck):
def __init__(self):
name = "Ensure that detailed monitoring is enabled for EC2 instances"
id = "CKV_AWS_126"
supported_resources = ['aws_instance']
categories = [CheckCategories.LOGGING]
super().__init__(name=name, id=id, categories=categories, supported_resources=supported_resources)
def get_inspected_key(self):
return 'monitoring'
def get_expected_value(self):
return True
check = EC2DetailedMonitoringEnabled()
| 241 |
1,184 | <reponame>EdwardCoventry/plyer
'''
Module of Windows API helper for plyer.battery.
'''
__all__ = ('battery_status')
import ctypes
from plyer.platforms.win.libs import win_api_defs
def battery_status():
'''
Implementation of Windows system power status API for plyer.battery.
'''
status = win_api_defs.SYSTEM_POWER_STATUS()
if not win_api_defs.GetSystemPowerStatus(ctypes.pointer(status)):
raise Exception('Could not get system power status.')
return dict(
(field, getattr(status, field))
for field, _ in status._fields_
)
| 219 |
659 | <gh_stars>100-1000
"""Tests for parsing of parameters related to forms."""
import pytest
from schemathesis.parameters import PayloadAlternatives
from schemathesis.specs.openapi.parameters import OpenAPI20CompositeBody, OpenAPI20Parameter, OpenAPI30Body
@pytest.mark.parametrize(
"consumes",
(
["application/x-www-form-urlencoded"],
["application/x-www-form-urlencoded", "multipart/form-data"],
),
)
def test_forms_open_api_2(
consumes, assert_parameters, make_openapi_2_schema, user_jsonschema, open_api_2_user_form_parameters
):
# In Open API 2.0, forms are separate "formData" parameters
schema = make_openapi_2_schema(consumes, open_api_2_user_form_parameters)
assert_parameters(
schema,
PayloadAlternatives(
[
# They are represented as a single "composite" body for each media type
OpenAPI20CompositeBody(
definition=[OpenAPI20Parameter(parameter) for parameter in open_api_2_user_form_parameters],
media_type=value,
)
for value in consumes
]
),
# Each converted schema should correspond to the default User schema.
[user_jsonschema] * len(consumes),
)
@pytest.mark.parametrize(
"consumes",
(
["multipart/form-data"],
# When "consumes" is not defined, then multipart is the default media type for "formData" parameters
[],
),
)
def test_multipart_form_open_api_2(
consumes,
assert_parameters,
make_openapi_2_schema,
user_jsonschema_with_file,
open_api_2_user_form_with_file_parameters,
):
# Multipart forms are represented as a list of "formData" parameters
schema = make_openapi_2_schema(consumes, open_api_2_user_form_with_file_parameters)
assert_parameters(
schema,
PayloadAlternatives(
[
# Is represented with a "composite" body
OpenAPI20CompositeBody(
definition=[
OpenAPI20Parameter(parameter) for parameter in open_api_2_user_form_with_file_parameters
],
media_type="multipart/form-data",
)
]
),
[user_jsonschema_with_file],
)
def test_urlencoded_form_open_api_3(assert_parameters, make_openapi_3_schema, open_api_3_user, user_jsonschema):
# A regular urlencoded form in Open API 3
schema = make_openapi_3_schema(
{
"required": True,
"content": {"application/x-www-form-urlencoded": {"schema": open_api_3_user}},
}
)
assert_parameters(
schema,
PayloadAlternatives(
[
OpenAPI30Body(
definition={"schema": open_api_3_user},
media_type="application/x-www-form-urlencoded",
required=True,
)
]
),
# It should correspond to the default User schema
[user_jsonschema],
)
def test_loose_urlencoded_form_open_api_3(assert_parameters, make_openapi_3_schema, make_user_schema, user_jsonschema):
# The schema doesn't define "type": "object"
loose_schema = {"schema": make_user_schema(is_loose=True, middle_name={"type": "string", "nullable": True})}
schema = make_openapi_3_schema(
{
"required": True,
"content": {"application/x-www-form-urlencoded": loose_schema},
}
)
assert_parameters(
schema,
PayloadAlternatives(
[OpenAPI30Body(definition=loose_schema, media_type="application/x-www-form-urlencoded", required=True)]
),
# But when it is converted to JSON Schema, Schemathesis sets `type` to `object`
# Therefore it corresponds to the default JSON Schema defined for a User
[user_jsonschema],
)
def test_multipart_form_open_api_3(
assert_parameters, make_openapi_3_schema, user_jsonschema_with_file, open_api_3_user_with_file
):
# A regular multipart for with a file upload in Open API 3
schema = make_openapi_3_schema(
{
"required": True,
"content": {"multipart/form-data": {"schema": open_api_3_user_with_file}},
}
)
assert_parameters(
schema,
PayloadAlternatives(
[
OpenAPI30Body(
definition={"schema": open_api_3_user_with_file}, media_type="multipart/form-data", required=True
)
]
),
# When converted, the schema corresponds the default schema defined for a User object with a file
[user_jsonschema_with_file],
)
| 2,197 |
1,338 | <reponame>Kirishikesan/haiku<gh_stars>1000+
/*
* Copyright (c) 2002, 2003 <NAME> <<EMAIL>>
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files or portions
* thereof (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge,
* publish, distribute, sublicense, and/or sell copies of the Software,
* and to permit persons to whom the Software is furnished to do so, subject
* to the following conditions:
*
* * Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* * Redistributions in binary form must reproduce the above copyright notice
* in the binary, as well as this list of conditions and the following
* disclaimer in the documentation and/or other materials provided with
* the distribution.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
*/
#include <BufferGroup.h>
#include <Buffer.h>
#include "MediaDebug.h"
#include "DataExchange.h"
#include "SharedBufferList.h"
BBufferGroup::BBufferGroup(size_t size, int32 count, uint32 placement,
uint32 lock)
{
CALLED();
fInitError = _Init();
if (fInitError != B_OK)
return;
// This one is easy. We need to create "count" BBuffers,
// each one "size" bytes large. They all go into one
// area, with "placement" and "lock" attributes.
// The BBuffers created will clone the area, and
// then we delete our area. This way BBuffers are
// independent from the BBufferGroup
// don't allow all placement parameter values
if (placement != B_ANY_ADDRESS && placement != B_ANY_KERNEL_ADDRESS) {
ERROR("BBufferGroup: placement != B_ANY_ADDRESS "
"&& placement != B_ANY_KERNEL_ADDRESS (0x%#" B_PRIx32 ")\n",
placement);
placement = B_ANY_ADDRESS;
}
// first we roundup for a better placement in memory
size_t allocSize = (size + 63) & ~63;
// now we create the area
size_t areaSize
= ((allocSize * count) + B_PAGE_SIZE - 1) & ~(B_PAGE_SIZE - 1);
void* startAddress;
area_id bufferArea = create_area("some buffers area", &startAddress,
placement, areaSize, lock, B_READ_AREA | B_WRITE_AREA | B_CLONEABLE_AREA);
if (bufferArea < 0) {
ERROR("BBufferGroup: failed to allocate %ld bytes area\n", areaSize);
fInitError = (status_t)bufferArea;
return;
}
buffer_clone_info info;
for (int32 i = 0; i < count; i++) {
info.area = bufferArea;
info.offset = i * allocSize;
info.size = size;
fInitError = AddBuffer(info);
if (fInitError != B_OK)
break;
}
delete_area(bufferArea);
}
BBufferGroup::BBufferGroup()
{
CALLED();
fInitError = _Init();
if (fInitError != B_OK)
return;
// this one simply creates an empty BBufferGroup
}
BBufferGroup::BBufferGroup(int32 count, const media_buffer_id* buffers)
{
CALLED();
fInitError = _Init();
if (fInitError != B_OK)
return;
// This one creates "BBuffer"s from "media_buffer_id"s passed
// by the application.
buffer_clone_info info;
for (int32 i = 0; i < count; i++) {
info.buffer = buffers[i];
fInitError = AddBuffer(info);
if (fInitError != B_OK)
break;
}
}
BBufferGroup::~BBufferGroup()
{
CALLED();
if (fBufferList != NULL)
fBufferList->DeleteGroupAndPut(fReclaimSem);
delete_sem(fReclaimSem);
}
status_t
BBufferGroup::InitCheck()
{
CALLED();
return fInitError;
}
status_t
BBufferGroup::AddBuffer(const buffer_clone_info& info, BBuffer** _buffer)
{
CALLED();
if (fInitError != B_OK)
return B_NO_INIT;
status_t status = fBufferList->AddBuffer(fReclaimSem, info, _buffer);
if (status != B_OK) {
ERROR("BBufferGroup: error when adding buffer\n");
return status;
}
atomic_add(&fBufferCount, 1);
return B_OK;
}
BBuffer*
BBufferGroup::RequestBuffer(size_t size, bigtime_t timeout)
{
CALLED();
if (fInitError != B_OK)
return NULL;
if (size <= 0)
return NULL;
BBuffer *buffer = NULL;
fRequestError = fBufferList->RequestBuffer(fReclaimSem, fBufferCount,
size, 0, &buffer, timeout);
return fRequestError == B_OK ? buffer : NULL;
}
status_t
BBufferGroup::RequestBuffer(BBuffer* buffer, bigtime_t timeout)
{
CALLED();
if (fInitError != B_OK)
return B_NO_INIT;
if (buffer == NULL)
return B_BAD_VALUE;
fRequestError = fBufferList->RequestBuffer(fReclaimSem, fBufferCount, 0, 0,
&buffer, timeout);
return fRequestError;
}
status_t
BBufferGroup::RequestError()
{
CALLED();
if (fInitError != B_OK)
return B_NO_INIT;
return fRequestError;
}
status_t
BBufferGroup::CountBuffers(int32* _count)
{
CALLED();
if (fInitError != B_OK)
return B_NO_INIT;
*_count = fBufferCount;
return B_OK;
}
status_t
BBufferGroup::GetBufferList(int32 bufferCount, BBuffer** _buffers)
{
CALLED();
if (fInitError != B_OK)
return B_NO_INIT;
if (bufferCount <= 0 || bufferCount > fBufferCount)
return B_BAD_VALUE;
return fBufferList->GetBufferList(fReclaimSem, bufferCount, _buffers);
}
status_t
BBufferGroup::WaitForBuffers()
{
CALLED();
if (fInitError != B_OK)
return B_NO_INIT;
// TODO: this function is not really useful anyway, and will
// not work exactly as documented, but it is close enough
if (fBufferCount < 0)
return B_BAD_VALUE;
if (fBufferCount == 0)
return B_OK;
// We need to wait until at least one buffer belonging to this group is
// reclaimed.
// This has happened when can aquire "fReclaimSem"
status_t status;
while ((status = acquire_sem(fReclaimSem)) == B_INTERRUPTED)
;
if (status != B_OK)
return status;
// we need to release the "fReclaimSem" now, else we would block
// requesting of new buffers
return release_sem(fReclaimSem);
}
status_t
BBufferGroup::ReclaimAllBuffers()
{
CALLED();
if (fInitError != B_OK)
return B_NO_INIT;
// because additional BBuffers might get added to this group betweeen
// acquire and release
int32 count = fBufferCount;
if (count < 0)
return B_BAD_VALUE;
if (count == 0)
return B_OK;
// we need to wait until all BBuffers belonging to this group are reclaimed.
// this has happened when the "fReclaimSem" can be aquired "fBufferCount"
// times
status_t status = B_ERROR;
do {
status = acquire_sem_etc(fReclaimSem, count, B_RELATIVE_TIMEOUT, 0);
} while (status == B_INTERRUPTED);
if (status != B_OK)
return status;
// we need to release the "fReclaimSem" now, else we would block
// requesting of new buffers
return release_sem_etc(fReclaimSem, count, 0);
}
// #pragma mark - deprecated BeOS R4 API
status_t
BBufferGroup::AddBuffersTo(BMessage* message, const char* name, bool needLock)
{
CALLED();
if (fInitError != B_OK)
return B_NO_INIT;
// BeOS R4 legacy API. Implemented as a wrapper around GetBufferList
// "needLock" is ignored, GetBufferList will do locking
if (message == NULL)
return B_BAD_VALUE;
if (name == NULL || strlen(name) == 0)
return B_BAD_VALUE;
BBuffer* buffers[fBufferCount];
status_t status = GetBufferList(fBufferCount, buffers);
if (status != B_OK)
return status;
for (int32 i = 0; i < fBufferCount; i++) {
status = message->AddInt32(name, int32(buffers[i]->ID()));
if (status != B_OK)
return status;
}
return B_OK;
}
// #pragma mark - private methods
/* not implemented */
//BBufferGroup::BBufferGroup(const BBufferGroup &)
//BBufferGroup & BBufferGroup::operator=(const BBufferGroup &)
status_t
BBufferGroup::_Init()
{
CALLED();
// some defaults in case we drop out early
fBufferList = NULL;
fRequestError = B_ERROR;
fBufferCount = 0;
// Create the reclaim semaphore
// This is also used as a system wide unique identifier for this group
fReclaimSem = create_sem(0, "buffer reclaim sem");
if (fReclaimSem < 0) {
ERROR("BBufferGroup::InitBufferGroup: couldn't create fReclaimSem\n");
return (status_t)fReclaimSem;
}
fBufferList = BPrivate::SharedBufferList::Get();
if (fBufferList == NULL) {
ERROR("BBufferGroup::InitBufferGroup: SharedBufferList::Get() "
"failed\n");
return B_ERROR;
}
return B_OK;
}
| 3,005 |
649 | <filename>serenity-model/src/main/java/net/thucydides/core/matchers/dates/DateTimeIsSameTimeAsMatcher.java
package net.thucydides.core.matchers.dates;
import org.hamcrest.Description;
import org.hamcrest.TypeSafeMatcher;
import org.joda.time.DateTime;
import static net.thucydides.core.matchers.dates.DateMatcherFormatter.formatted;
class DateTimeIsSameTimeAsMatcher extends TypeSafeMatcher<DateTime> {
private final DateTime expectedDate;
public DateTimeIsSameTimeAsMatcher(final DateTime expectedDate) {
this.expectedDate = expectedDate;
}
public boolean matchesSafely(DateTime provided) {
return (DateComparator.sameDate(provided, expectedDate));
}
public void describeTo(Description description) {
description.appendText("a date that is ");
description.appendText(formatted(expectedDate));
}
}
| 296 |
3,783 | <filename>src/problems/easy/ImageSmoother.java<gh_stars>1000+
package problems.easy;
/**
* @author <NAME>.
*/
public class ImageSmoother {
public int[][] imageSmoother(int[][] a) {
if(a==null || a.length==0)return a;
int[][] b=new int[a.length][a[0].length];
for(int i=0; i<a.length; i++){
for(int j=0; j<a[i].length; j++){
int c=c(a, i, j);
int val=v(a, i, j);
// System.out.println(val + " " + i + " " + j + " " + c);
b[i][j]=(int)(Math.floor( (val*1.0)/c));
}
}
return b;
}
int v(int[][]a, int i, int j){
int c=a[i][j];
if(i>0)c+=a[i-1][j];
if(j>0)c+=a[i][j-1];
if(i<a.length-1)c+=a[i+1][j];
if(j<a[i].length-1)c+=a[i][j+1];
if(i>0 && j>0)c+=a[i-1][j-1];
if(i<a.length-1 && j<a[i].length-1)c+=a[i+1][j+1];
if(i<a.length-1 && j>0)c+=a[i+1][j-1];
if(i>0 && j<a[i].length-1)c+=a[i-1][j+1];
return c;
}
int c(int[][]a, int i, int j){
int c=1;
if(i>0)c+=1;
if(j>0)c+=1;
if(i<a.length-1)c+=1;
if(j<a[i].length-1)c+=1;
if(i>0 && j>0)c+=1;
if(i<a.length-1 && j<a[i].length-1)c+=1;
if(i<a.length-1 && j>0)c+=1;
if(i>0 && j<a[i].length-1)c+=1;
return c;
}
}
| 883 |
5,813 | <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.coordination;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.inject.Inject;
import org.apache.commons.lang3.mutable.MutableBoolean;
import org.apache.druid.client.cache.Cache;
import org.apache.druid.client.cache.CacheConfig;
import org.apache.druid.client.cache.CachePopulator;
import org.apache.druid.guice.annotations.Smile;
import org.apache.druid.java.util.common.guava.Accumulator;
import org.apache.druid.java.util.common.guava.Sequence;
import org.apache.druid.java.util.common.guava.Yielder;
import org.apache.druid.java.util.common.guava.YieldingAccumulator;
import org.apache.druid.java.util.common.logger.Logger;
import org.apache.druid.java.util.emitter.service.ServiceEmitter;
import org.apache.druid.query.Query;
import org.apache.druid.query.QueryCapacityExceededException;
import org.apache.druid.query.QueryProcessingPool;
import org.apache.druid.query.QueryRunner;
import org.apache.druid.query.QueryRunnerFactory;
import org.apache.druid.query.QueryRunnerFactoryConglomerate;
import org.apache.druid.query.QueryTimeoutException;
import org.apache.druid.query.QueryToolChest;
import org.apache.druid.query.QueryUnsupportedException;
import org.apache.druid.query.ReportTimelineMissingSegmentQueryRunner;
import org.apache.druid.query.ResourceLimitExceededException;
import org.apache.druid.query.SegmentDescriptor;
import org.apache.druid.segment.ReferenceCountingSegment;
import org.apache.druid.segment.SegmentReference;
import org.apache.druid.segment.join.JoinableFactory;
import org.apache.druid.server.SegmentManager;
import org.apache.druid.server.initialization.ServerConfig;
import org.apache.druid.timeline.VersionedIntervalTimeline;
import java.util.HashSet;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.Function;
/**
* This server manager is designed to test various query failures.
*
* - Missing segments. A segment can be missing during a query if a historical drops the segment
* after the broker issues the query to the historical. To mimic this situation, the historical
* with this server manager announces all segments assigned, but reports missing segments for the
* first 3 segments specified in the query. See ITQueryRetryTestOnMissingSegments.
* - Other query errors. This server manager returns a sequence that always throws an exception
* based on a given query context value. See ITQueryErrorTest.
*
* @see org.apache.druid.query.RetryQueryRunner for query retrying.
* @see org.apache.druid.client.JsonParserIterator for handling query errors from historicals.
*/
public class ServerManagerForQueryErrorTest extends ServerManager
{
// Query context key that indicates this query is for query retry testing.
public static final String QUERY_RETRY_TEST_CONTEXT_KEY = "query-retry-test";
public static final String QUERY_TIMEOUT_TEST_CONTEXT_KEY = "query-timeout-test";
public static final String QUERY_CAPACITY_EXCEEDED_TEST_CONTEXT_KEY = "query-capacity-exceeded-test";
public static final String QUERY_UNSUPPORTED_TEST_CONTEXT_KEY = "query-unsupported-test";
public static final String RESOURCE_LIMIT_EXCEEDED_TEST_CONTEXT_KEY = "resource-limit-exceeded-test";
public static final String QUERY_FAILURE_TEST_CONTEXT_KEY = "query-failure-test";
private static final Logger LOG = new Logger(ServerManagerForQueryErrorTest.class);
private static final int MAX_NUM_FALSE_MISSING_SEGMENTS_REPORTS = 3;
private final ConcurrentHashMap<String, Set<SegmentDescriptor>> queryToIgnoredSegments = new ConcurrentHashMap<>();
@Inject
public ServerManagerForQueryErrorTest(
QueryRunnerFactoryConglomerate conglomerate,
ServiceEmitter emitter,
QueryProcessingPool queryProcessingPool,
CachePopulator cachePopulator,
@Smile ObjectMapper objectMapper,
Cache cache,
CacheConfig cacheConfig,
SegmentManager segmentManager,
JoinableFactory joinableFactory,
ServerConfig serverConfig
)
{
super(
conglomerate,
emitter,
queryProcessingPool,
cachePopulator,
objectMapper,
cache,
cacheConfig,
segmentManager,
joinableFactory,
serverConfig
);
}
@Override
protected <T> QueryRunner<T> buildQueryRunnerForSegment(
Query<T> query,
SegmentDescriptor descriptor,
QueryRunnerFactory<T, Query<T>> factory,
QueryToolChest<T, Query<T>> toolChest,
VersionedIntervalTimeline<String, ReferenceCountingSegment> timeline,
Function<SegmentReference, SegmentReference> segmentMapFn,
AtomicLong cpuTimeAccumulator,
Optional<byte[]> cacheKeyPrefix
)
{
if (query.getContextBoolean(QUERY_RETRY_TEST_CONTEXT_KEY, false)) {
final MutableBoolean isIgnoreSegment = new MutableBoolean(false);
queryToIgnoredSegments.compute(
query.getMostSpecificId(),
(queryId, ignoredSegments) -> {
if (ignoredSegments == null) {
ignoredSegments = new HashSet<>();
}
if (ignoredSegments.size() < MAX_NUM_FALSE_MISSING_SEGMENTS_REPORTS) {
ignoredSegments.add(descriptor);
isIgnoreSegment.setTrue();
}
return ignoredSegments;
}
);
if (isIgnoreSegment.isTrue()) {
LOG.info("Pretending I don't have segment[%s]", descriptor);
return new ReportTimelineMissingSegmentQueryRunner<>(descriptor);
}
} else if (query.getContextBoolean(QUERY_TIMEOUT_TEST_CONTEXT_KEY, false)) {
return (queryPlus, responseContext) -> new Sequence<T>()
{
@Override
public <OutType> OutType accumulate(OutType initValue, Accumulator<OutType, T> accumulator)
{
throw new QueryTimeoutException("query timeout test");
}
@Override
public <OutType> Yielder<OutType> toYielder(OutType initValue, YieldingAccumulator<OutType, T> accumulator)
{
throw new QueryTimeoutException("query timeout test");
}
};
} else if (query.getContextBoolean(QUERY_CAPACITY_EXCEEDED_TEST_CONTEXT_KEY, false)) {
return (queryPlus, responseContext) -> new Sequence<T>()
{
@Override
public <OutType> OutType accumulate(OutType initValue, Accumulator<OutType, T> accumulator)
{
throw QueryCapacityExceededException.withErrorMessageAndResolvedHost("query capacity exceeded test");
}
@Override
public <OutType> Yielder<OutType> toYielder(OutType initValue, YieldingAccumulator<OutType, T> accumulator)
{
throw QueryCapacityExceededException.withErrorMessageAndResolvedHost("query capacity exceeded test");
}
};
} else if (query.getContextBoolean(QUERY_UNSUPPORTED_TEST_CONTEXT_KEY, false)) {
return (queryPlus, responseContext) -> new Sequence<T>()
{
@Override
public <OutType> OutType accumulate(OutType initValue, Accumulator<OutType, T> accumulator)
{
throw new QueryUnsupportedException("query unsupported test");
}
@Override
public <OutType> Yielder<OutType> toYielder(OutType initValue, YieldingAccumulator<OutType, T> accumulator)
{
throw new QueryUnsupportedException("query unsupported test");
}
};
} else if (query.getContextBoolean(RESOURCE_LIMIT_EXCEEDED_TEST_CONTEXT_KEY, false)) {
return (queryPlus, responseContext) -> new Sequence<T>()
{
@Override
public <OutType> OutType accumulate(OutType initValue, Accumulator<OutType, T> accumulator)
{
throw new ResourceLimitExceededException("resource limit exceeded test");
}
@Override
public <OutType> Yielder<OutType> toYielder(OutType initValue, YieldingAccumulator<OutType, T> accumulator)
{
throw new ResourceLimitExceededException("resource limit exceeded test");
}
};
} else if (query.getContextBoolean(QUERY_FAILURE_TEST_CONTEXT_KEY, false)) {
return (queryPlus, responseContext) -> new Sequence<T>()
{
@Override
public <OutType> OutType accumulate(OutType initValue, Accumulator<OutType, T> accumulator)
{
throw new RuntimeException("query failure test");
}
@Override
public <OutType> Yielder<OutType> toYielder(OutType initValue, YieldingAccumulator<OutType, T> accumulator)
{
throw new RuntimeException("query failure test");
}
};
}
return super.buildQueryRunnerForSegment(
query,
descriptor,
factory,
toolChest,
timeline,
segmentMapFn,
cpuTimeAccumulator,
cacheKeyPrefix
);
}
}
| 3,540 |
1,602 | #include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
typedef union {
int64_t a;
int64_t b;
int64_t c;
} intUnion;
void intUnion_print(intUnion x);
typedef struct {
const char* a;
const char* b;
} stringUnion;
void stringUnion_print(stringUnion y);
typedef struct {
void (*fn)(int64_t);
} fnUnion;
void fnUnion_call(fnUnion f);
| 148 |
686 | <gh_stars>100-1000
from crud.schemas.board import Board
from crud.roles.r30_normal_user import normal_user
from crud.schemas.topic import Topic
from crud.schemas.user import User
from crud.schemas.wiki_article import WikiArticle
from pycurd.permission import RoleDefine, TablePerm, A
super_user = RoleDefine({
Topic: TablePerm({
Topic.state: {A.QUERY, A.CREATE, A.READ, A.UPDATE},
Topic.visible: {A.QUERY, A.CREATE, A.READ, A.UPDATE},
Topic.time: {A.CREATE, A.READ},
Topic.user_id: {A.QUERY, A.CREATE, A.READ},
Topic.title: {A.QUERY, A.CREATE, A.READ, A.UPDATE},
Topic.board_id: {A.QUERY, A.CREATE, A.READ, A.UPDATE},
Topic.content: {A.CREATE, A.READ, A.UPDATE},
Topic.awesome: {A.QUERY, A.READ, A.UPDATE},
Topic.weight: {A.QUERY, A.READ, A.UPDATE},
Topic.sticky_weight: {A.READ, A.UPDATE},
}),
WikiArticle: TablePerm({
WikiArticle.state: {A.QUERY, A.CREATE, A.READ, A.UPDATE},
WikiArticle.visible: {A.QUERY, A.CREATE, A.READ, A.UPDATE},
WikiArticle.time: {A.CREATE, A.READ},
WikiArticle.user_id: {A.QUERY, A.CREATE, A.READ},
WikiArticle.title: {A.QUERY, A.CREATE, A.READ, A.UPDATE},
WikiArticle.ref: {A.QUERY, A.CREATE, A.READ, A.UPDATE},
WikiArticle.content: {A.QUERY, A.CREATE, A.READ, A.UPDATE},
}),
Board: TablePerm({
Board.state: {A.QUERY, A.CREATE, A.READ, A.UPDATE},
Board.visible: {A.QUERY, A.CREATE, A.READ, A.UPDATE},
Board.time: {A.CREATE, A.READ},
Board.user_id: {A.QUERY, A.CREATE, A.READ},
Board.name: {A.QUERY, A.CREATE, A.READ, A.UPDATE},
Board.brief: {A.QUERY, A.CREATE, A.READ, A.UPDATE},
Board.desc: {A.QUERY, A.CREATE, A.READ, A.UPDATE},
Board.weight: {A.QUERY, A.CREATE, A.READ, A.UPDATE},
Board.color: {A.CREATE, A.READ, A.UPDATE},
Board.category: {A.QUERY, A.CREATE, A.READ, A.UPDATE},
Board.parent_id: {A.QUERY, A.CREATE, A.READ, A.UPDATE},
Board.can_post_rank: {A.QUERY, A.CREATE, A.READ, A.UPDATE},
}),
User: TablePerm({
User.state: {A.QUERY, A.CREATE, A.READ, A.UPDATE},
User.visible: {A.QUERY, A.CREATE, A.READ, A.UPDATE},
User.time: {A.CREATE, A.READ},
User.user_id: {A.QUERY, A.CREATE, A.READ},
User.password: {<PASSWORD>},
User.email: {A.QUERY, A.CREATE, A.READ, A.UPDATE},
User.nickname: {A.QUERY, A.CREATE, A.READ, A.UPDATE},
User.credit: {A.QUERY, A.CREATE, A.READ, A.UPDATE},
User.repute: {A.QUERY, A.CREATE, A.READ, A.UPDATE},
User.access_time: {A.READ},
User.last_check_in_time: {A.READ},
User.is_wiki_editor: {A.QUERY, A.READ, A.UPDATE},
User.is_board_moderator: {A.QUERY, A.READ, A.UPDATE},
User.is_forum_master: {A.QUERY, A.READ, A.UPDATE},
}),
}, based_on=normal_user)
| 1,429 |
340 | //==================================================================================================
/*
EVE - Expressive Vector Engine
Copyright : EVE Contributors & Maintainers
SPDX-License-Identifier: MIT
*/
//==================================================================================================
#pragma once
#include <eve/function/lambert.hpp>
#include <eve/function/derivative.hpp>
#include <eve/function/if_else.hpp>
#include <eve/function/inc.hpp>
#include <eve/function/is_eqz.hpp>
#include <eve/function/is_negative.hpp>
#include <eve/function/lambert.hpp>
namespace eve::detail
{
template<floating_real_value T>
EVE_FORCEINLINE constexpr auto lambert_(EVE_SUPPORTS(cpu_)
, diff_type<1> const &
, T const &x) noexcept
{
if constexpr( has_native_abi_v<T> )
{
auto [w0, wm1] = lambert(x);
auto xeqz = is_eqz(x);
auto dw0 = if_else(w0 == mone(as(w0)), inf(as(w0)), w0/(x*inc(w0)));
dw0 = if_else(x == inf(as(x)), zero, dw0);
dw0 = if_else(xeqz, one, dw0);
auto dwm1= if_else(wm1 == mone(as(w0)), minf(as(w0)), wm1/(x*inc(wm1)));
dwm1= if_else(is_gez(x), dw0, dwm1);
dwm1= if_else(xeqz&&is_negative(x), minf(as(wm1)), dwm1);
return kumi::make_tuple(dw0, dwm1);
}
else
return apply_over2(diff(lambert), x);
}
}
| 608 |
861 | <gh_stars>100-1000
/*
* Copyright (c) 2018. Univocity Software Pty Ltd
* <p/>
* 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
* <p/>
* http://www.apache.org/licenses/LICENSE-2.0
* <p/>
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.univocity.parsers.issues.github;
import com.univocity.parsers.csv.*;
import org.testng.annotations.*;
import static org.testng.Assert.*;
/**
* From: https://github.com/univocity/univocity-parsers/issues/352
*/
public class Github_352 {
@Test
public void testNullableFields(){
CsvWriterSettings s = new CsvWriterSettings();
s.getFormat().setQuote('\'');
s.setNullValue("null");
s.setEmptyValue("''");
s.setQuoteAllFields(true);
s.setQuoteNulls(false);
CsvWriter w = new CsvWriter(s);
assertEquals(w.writeRowToString(1, "one", "", "empty"), "'1','one','','empty'");
assertEquals(w.writeRowToString(2, "two", null, "null"), "'2','two',null,'null'");
assertEquals(w.writeRowToString(3, null, "THREE", "null"), "'3',null,'THREE','null'");
assertEquals(w.writeRowToString(null, "four", "FOUR", "null"), "null,'four','FOUR','null'");
}
} | 518 |
1,194 | <reponame>R-fred/awesome-streamlit<gh_stars>1000+
"""Page for viewing the awesome Streamlit vision"""
import pathlib
import streamlit as st
import awesome_streamlit as ast
@st.cache
def get_vision_markdown() -> str:
"""Returns the Vision
Returns:
str -- The vision as a string of MarkDown
"""
url = pathlib.Path(__file__).parent.parent.parent / "AWESOME-STREAMLIT.md"
with open(url, mode="r") as file:
readme_md_contents = "".join(file.readlines())
return readme_md_contents.split("\n", 3)[-1]
def write():
"""Method used to write the page in the app.py file"""
ast.shared.components.title_awesome("Vision")
with st.spinner("Loading ..."):
vision = get_vision_markdown()
st.markdown(vision)
| 292 |
848 | <reponame>hito0512/Vitis-AI
/*
* Copyright 2019 Xilinx Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef DEEPHI_BOUNDED_QUEUE_HPP_
#define DEEPHI_BOUNDED_QUEUE_HPP_
#include "shared_queue.hpp"
namespace vitis {
namespace ai {
/**
* A thread safe queue with a size limit.
* It will block on push if full, and on pop if empty.
*/
template <typename T>
class BoundedQueue : public SharedQueue<T> {
public:
explicit BoundedQueue(std::size_t capacity) : capacity_(capacity) {}
/**
* Return the maxium size of the queue.
*/
std::size_t capacity() const { return this->capacity_; }
/**
* Copy the value to the end of this queue.
* This is blocking.
*/
void push(const T& new_value) override {
std::unique_lock<std::mutex> lock(this->mtx_);
this->cond_not_full_.wait(
lock, [this]() { return this->internal_size() < this->capacity_; });
this->internal_push(new_value);
this->cond_not_empty_.notify_one();
}
/**
* Copy the value to the end of this queue.
* This will fail and return false if blocked for more than rel_time.
*/
bool push(const T& new_value, const std::chrono::milliseconds& rel_time) {
std::unique_lock<std::mutex> lock(this->mtx_);
if (this->cond_not_full_.wait_for(lock, rel_time, [this]() {
return this->internal_size() < this->capacity_;
}) == false) {
return false;
}
this->internal_push(new_value);
this->cond_not_empty_.notify_one();
return true;
}
/**
* Look at the top of the queue. i.e. the element that would be poped.
* This will fail and return false if blocked for more than rel_time.
*/
bool top(T& value, const std::chrono::milliseconds& rel_time) {
std::unique_lock<std::mutex> lock(this->mtx_);
if (this->cond_not_empty_.wait_for(lock, rel_time, [this]() {
return !this->internal_empty();
}) == false) {
return false;
}
this->internal_top(value);
return true;
}
/**
* Return the first element in the queue and remove it from the queue.
* This is blocking.
*/
void pop(T& value) override {
std::unique_lock<std::mutex> lock(this->mtx_);
this->cond_not_empty_.wait(lock,
[this]() { return !this->internal_empty(); });
this->internal_pop(value);
this->cond_not_full_.notify_one();
}
/**
* Return the first element in the queue and remove it from the queue.
* This will fail and return false if blocked for more than rel_time.
*/
bool pop(T& value, const std::chrono::milliseconds& rel_time) override {
std::unique_lock<std::mutex> lock(this->mtx_);
if (this->cond_not_empty_.wait_for(lock, rel_time, [this]() {
return !this->internal_empty();
}) == false) {
return false;
}
this->internal_pop(value);
this->cond_not_full_.notify_one();
return true;
}
/**
* Return the first element in the queue that satisfies cond, and remove it
* from the queue.
* This is blocking.
*/
bool pop(T& value, std::function<bool(const T&)>& cond) override {
std::lock_guard<std::mutex> lock(this->mtx_);
if (this->internal_empty()) return false;
auto it =
std::find_if(this->internal_.begin(), this->internal_.end(), cond);
if (it != this->internal_.end()) {
value = std::move(*it);
this->internal_.erase(it);
this->cond_not_full_.notify_one();
return true;
}
return false;
}
/**
* Return the first element in the queue that satisfies cond, and remove it
* from the queue.
* This will fail and return false if blocked for more than rel_time.
*/
bool pop(T& value, std::function<bool(const T&)>& cond,
const std::chrono::milliseconds& rel_time) override {
auto now = std::chrono::steady_clock::now();
std::unique_lock<std::mutex> lock(this->mtx_);
// Wait until not empty
if (!this->cond_not_empty_.wait_for(
lock, rel_time, [this]() { return !this->internal_empty(); })) {
return false;
}
auto it =
std::find_if(this->internal_.begin(), this->internal_.end(), cond);
while (it == this->internal_.end()) {
if (this->cond_not_empty_.wait_until(lock, now + rel_time) ==
std::cv_status::timeout) {
break;
}
it = std::find_if(this->internal_.begin(), this->internal_.end(), cond);
}
it = std::find_if(this->internal_.begin(), this->internal_.end(), cond);
if (it != this->internal_.end()) {
value = std::move(*it);
this->internal_.erase(it);
this->cond_not_full_.notify_one();
return true;
}
return false;
}
protected:
std::size_t capacity_;
std::condition_variable cond_not_full_;
};
} // namespace ai
} // namespace vitis
#endif
| 2,009 |
584 | package com.mercury.platform.ui.adr.components;
import com.mercury.platform.shared.config.descriptor.adr.AdrTrackerGroupDescriptor;
import com.mercury.platform.ui.adr.components.panel.AdrComponentPanel;
import com.mercury.platform.ui.adr.components.panel.AdrTrackerGroupPanel;
import com.mercury.platform.ui.misc.MercuryStoreUI;
import lombok.NonNull;
import rx.Subscription;
import javax.swing.*;
public class AdrTrackerGroupFrame extends AbstractAdrComponentFrame<AdrTrackerGroupDescriptor> {
private AdrTrackerGroupPanel trackerGroupPanel;
private Subscription adrReloadSubscription;
public AdrTrackerGroupFrame(@NonNull AdrTrackerGroupDescriptor descriptor) {
super(descriptor);
}
@Override
public void setPanel(AdrComponentPanel panel) {
this.trackerGroupPanel = new AdrTrackerGroupPanel(this.descriptor, this.componentsFactory);
}
@Override
protected void initialize() {
super.initialize();
this.add(this.trackerGroupPanel);
this.pack();
}
@Override
public void subscribe() {
super.subscribe();
this.adrReloadSubscription = MercuryStoreUI.adrReloadSubject.subscribe(descriptor -> {
if (descriptor.equals(this.descriptor)) {
this.setLocation(descriptor.getLocation());
this.setOpacity(this.descriptor.getOpacity());
this.repaint();
this.pack();
}
});
}
@Override
public void enableSettings() {
super.enableSettings();
this.trackerGroupPanel.enableSettings();
this.trackerGroupPanel.addMouseListener(this.mouseListener);
this.trackerGroupPanel.addMouseListener(this.mouseOverListener);
this.trackerGroupPanel.addMouseMotionListener(this.motionListener);
this.pack();
this.repaint();
}
@Override
public void disableSettings() {
super.disableSettings();
this.trackerGroupPanel.disableSettings();
this.trackerGroupPanel.removeMouseListener(this.mouseListener);
this.trackerGroupPanel.removeMouseListener(this.mouseOverListener);
this.trackerGroupPanel.removeMouseMotionListener(this.motionListener);
this.getRootPane().setBorder(BorderFactory.createEmptyBorder(1, 1, 1, 1));
this.pack();
this.repaint();
}
@Override
public void onDestroy() {
super.onDestroy();
this.adrReloadSubscription.unsubscribe();
this.trackerGroupPanel.onDestroy();
}
@Override
public void onViewInit() {
}
}
| 1,010 |
1,068 | /*
* smallprimes.c: implementation of the array of small primes defined
* in sshkeygen.h.
*/
#include <assert.h>
#include "ssh.h"
#include "sshkeygen.h"
/* The real array that stores the primes. It has to be writable in
* this module, but outside this module, we only expose the
* const-qualified pointer 'smallprimes' so that nobody else can
* accidentally overwrite it. */
static unsigned short smallprimes_array[NSMALLPRIMES];
const unsigned short *const smallprimes = smallprimes_array;
void init_smallprimes(void)
{
if (smallprimes_array[0])
return; /* already done */
bool A[65536];
for (size_t i = 2; i < lenof(A); i++)
A[i] = true;
for (size_t i = 2; i < lenof(A); i++) {
if (!A[i])
continue;
for (size_t j = 2*i; j < lenof(A); j += i)
A[j] = false;
}
size_t pos = 0;
for (size_t i = 2; i < lenof(A); i++) {
if (A[i]) {
assert(pos < NSMALLPRIMES);
smallprimes_array[pos++] = i;
}
}
assert(pos == NSMALLPRIMES);
}
| 539 |
892 | <filename>advisories/unreviewed/2022/04/GHSA-wx92-67c9-p24w/GHSA-wx92-67c9-p24w.json<gh_stars>100-1000
{
"schema_version": "1.2.0",
"id": "GHSA-wx92-67c9-p24w",
"modified": "2022-04-30T18:11:53Z",
"published": "2022-04-30T18:11:53Z",
"aliases": [
"CVE-1999-1142"
],
"details": "SunOS 4.1.2 and earlier allows local users to gain privileges via \"LD_*\" environmental variables to certain dynamically linked setuid or setgid programs such as (1) login, (2) su, or (3) sendmail, that change the real and effective user ids to the same user.",
"severity": [
],
"affected": [
],
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-1999-1142"
},
{
"type": "WEB",
"url": "https://exchange.xforce.ibmcloud.com/vulnerabilities/3152"
},
{
"type": "WEB",
"url": "http://sunsolve.sun.com/pub-cgi/retrieve.pl?doctype=coll&doc=secbull/116"
},
{
"type": "WEB",
"url": "http://www.cert.org/advisories/CA-1992-11.html"
}
],
"database_specific": {
"cwe_ids": [
],
"severity": "HIGH",
"github_reviewed": false
}
} | 533 |
2,151 | <reponame>zipated/src
// Copyright 2015 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/exo/wayland/server.h"
#include <alpha-compositing-unstable-v1-server-protocol.h>
#include <aura-shell-server-protocol.h>
#include <cursor-shapes-unstable-v1-server-protocol.h>
#include <gaming-input-unstable-v1-server-protocol.h>
#include <gaming-input-unstable-v2-server-protocol.h>
#include <grp.h>
#include <input-timestamps-unstable-v1-server-protocol.h>
#include <keyboard-configuration-unstable-v1-server-protocol.h>
#include <keyboard-extension-unstable-v1-server-protocol.h>
#include <linux/input.h>
#include <pointer-gestures-unstable-v1-server-protocol.h>
#include <presentation-time-server-protocol.h>
#include <remote-shell-unstable-v1-server-protocol.h>
#include <secure-output-unstable-v1-server-protocol.h>
#include <stddef.h>
#include <stdint.h>
#include <stylus-tools-unstable-v1-server-protocol.h>
#include <stylus-unstable-v2-server-protocol.h>
#include <viewporter-server-protocol.h>
#include <vsync-feedback-unstable-v1-server-protocol.h>
#include <wayland-server-core.h>
#include <wayland-server-protocol-core.h>
#include <xdg-shell-unstable-v6-server-protocol.h>
#include <algorithm>
#include <cstdlib>
#include <iterator>
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include "ash/display/screen_orientation_controller.h"
#include "ash/frame/caption_buttons/caption_button_types.h"
#include "ash/ime/ime_controller.h"
#include "ash/public/cpp/shell_window_ids.h"
#include "ash/public/cpp/window_properties.h"
#include "ash/public/interfaces/window_pin_type.mojom.h"
#include "ash/public/interfaces/window_state_type.mojom.h"
#include "ash/shell.h"
#include "ash/wm/window_resizer.h"
#include "base/bind.h"
#include "base/cancelable_callback.h"
#include "base/command_line.h"
#include "base/files/file_path.h"
#include "base/macros.h"
#include "base/memory/free_deleter.h"
#include "base/memory/ptr_util.h"
#include "base/memory/weak_ptr.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "base/threading/thread.h"
#include "base/threading/thread_task_runner_handle.h"
#include "components/exo/buffer.h"
#include "components/exo/client_controlled_shell_surface.h"
#include "components/exo/data_device.h"
#include "components/exo/data_device_delegate.h"
#include "components/exo/data_offer.h"
#include "components/exo/data_offer_delegate.h"
#include "components/exo/data_source.h"
#include "components/exo/data_source_delegate.h"
#include "components/exo/display.h"
#include "components/exo/gamepad_delegate.h"
#include "components/exo/gaming_seat.h"
#include "components/exo/gaming_seat_delegate.h"
#include "components/exo/keyboard.h"
#include "components/exo/keyboard_delegate.h"
#include "components/exo/keyboard_device_configuration_delegate.h"
#include "components/exo/keyboard_observer.h"
#include "components/exo/notification_surface.h"
#include "components/exo/notification_surface_manager.h"
#include "components/exo/pointer.h"
#include "components/exo/pointer_delegate.h"
#include "components/exo/pointer_gesture_pinch_delegate.h"
#include "components/exo/shared_memory.h"
#include "components/exo/shell_surface.h"
#include "components/exo/sub_surface.h"
#include "components/exo/surface.h"
#include "components/exo/touch.h"
#include "components/exo/touch_delegate.h"
#include "components/exo/touch_stylus_delegate.h"
#include "components/exo/wm_helper.h"
#include "components/exo/xdg_shell_surface.h"
#include "services/viz/public/interfaces/compositing/compositor_frame_sink.mojom.h"
#include "third_party/skia/include/core/SkRegion.h"
#include "ui/base/class_property.h"
#include "ui/base/hit_test.h"
#include "ui/base/ui_features.h"
#include "ui/compositor/compositor_vsync_manager.h"
#include "ui/display/display_switches.h"
#include "ui/display/manager/display_util.h"
#include "ui/display/manager/managed_display_info.h"
#include "ui/display/screen.h"
#include "ui/events/keycodes/dom/keycode_converter.h"
#include "ui/gfx/buffer_format_util.h"
#include "ui/gfx/buffer_types.h"
#include "ui/gfx/presentation_feedback.h"
#include "ui/views/widget/widget.h"
#include "ui/views/widget/widget_observer.h"
#include "ui/wm/core/coordinate_conversion.h"
#include "ui/wm/core/window_animations.h"
#include "ui/wm/public/activation_change_observer.h"
#if defined(USE_OZONE)
#include <drm_fourcc.h>
#include <linux-dmabuf-unstable-v1-server-protocol.h>
#if defined(OS_CHROMEOS)
#include "ui/events/ozone/layout/xkb/xkb_keyboard_layout_engine.h"
#endif
#endif
#if BUILDFLAG(USE_XKBCOMMON)
#include <xkbcommon/xkbcommon.h>
#include "ui/events/keycodes/scoped_xkb.h" // nogncheck
#endif
DEFINE_UI_CLASS_PROPERTY_TYPE(wl_resource*);
namespace exo {
namespace wayland {
namespace switches {
// This flag can be used to emulate device scale factor for remote shell.
constexpr char kForceRemoteShellScale[] = "force-remote-shell-scale";
// This flag can be used to override the default wayland socket name. It is
// useful when another wayland server is already running and using the
// default name.
constexpr char kWaylandServerSocket[] = "wayland-server-socket";
}
namespace {
// We don't send configure immediately after tablet mode switch
// because layout can change due to orientation lock state or accelerometer.
const int kConfigureDelayAfterLayoutSwitchMs = 300;
// Default wayland socket name.
const base::FilePath::CharType kSocketName[] = FILE_PATH_LITERAL("wayland-0");
// Group used for wayland socket.
const char kWaylandSocketGroup[] = "wayland";
template <class T>
T* GetUserDataAs(wl_resource* resource) {
return static_cast<T*>(wl_resource_get_user_data(resource));
}
template <class T>
std::unique_ptr<T> TakeUserDataAs(wl_resource* resource) {
std::unique_ptr<T> user_data = base::WrapUnique(GetUserDataAs<T>(resource));
wl_resource_set_user_data(resource, nullptr);
return user_data;
}
template <class T>
void DestroyUserData(wl_resource* resource) {
TakeUserDataAs<T>(resource);
}
template <class T>
void SetImplementation(wl_resource* resource,
const void* implementation,
std::unique_ptr<T> user_data) {
wl_resource_set_implementation(resource, implementation, user_data.release(),
DestroyUserData<T>);
}
// Returns the scale factor to be used by remote shell clients.
double GetDefaultDeviceScaleFactor() {
// A flag used by VM to emulate a device scale for a particular board.
base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
if (command_line->HasSwitch(switches::kForceRemoteShellScale)) {
std::string value =
command_line->GetSwitchValueASCII(switches::kForceRemoteShellScale);
double scale = 1.0;
if (base::StringToDouble(value, &scale))
return std::max(1.0, scale);
}
return WMHelper::GetInstance()->GetDefaultDeviceScaleFactor();
}
// Convert a timestamp to a time value that can be used when interfacing
// with wayland. Note that we cast a int64_t value to uint32_t which can
// potentially overflow.
uint32_t TimeTicksToMilliseconds(base::TimeTicks ticks) {
return (ticks - base::TimeTicks()).InMilliseconds();
}
uint32_t NowInMilliseconds() {
return TimeTicksToMilliseconds(base::TimeTicks::Now());
}
class WaylandInputDelegate {
public:
class Observer {
public:
virtual void OnDelegateDestroying(WaylandInputDelegate* delegate) = 0;
virtual void OnSendTimestamp(base::TimeTicks time_stamp) = 0;
protected:
virtual ~Observer() = default;
};
void AddObserver(Observer* observer) { observers_.AddObserver(observer); }
void RemoveObserver(Observer* observer) {
observers_.RemoveObserver(observer);
}
void SendTimestamp(base::TimeTicks time_stamp) {
for (auto& observer : observers_)
observer.OnSendTimestamp(time_stamp);
}
protected:
WaylandInputDelegate() = default;
virtual ~WaylandInputDelegate() {
for (auto& observer : observers_)
observer.OnDelegateDestroying(this);
}
private:
base::ObserverList<Observer> observers_;
DISALLOW_COPY_AND_ASSIGN(WaylandInputDelegate);
};
uint32_t WaylandDataDeviceManagerDndAction(DndAction action) {
switch (action) {
case DndAction::kNone:
return WL_DATA_DEVICE_MANAGER_DND_ACTION_NONE;
case DndAction::kCopy:
return WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY;
case DndAction::kMove:
return WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE;
case DndAction::kAsk:
return WL_DATA_DEVICE_MANAGER_DND_ACTION_ASK;
}
NOTREACHED();
}
uint32_t WaylandDataDeviceManagerDndActions(
const base::flat_set<DndAction>& dnd_actions) {
uint32_t actions = 0;
for (DndAction action : dnd_actions)
actions |= WaylandDataDeviceManagerDndAction(action);
return actions;
}
DndAction DataDeviceManagerDndAction(uint32_t value) {
switch (value) {
case WL_DATA_DEVICE_MANAGER_DND_ACTION_NONE:
return DndAction::kNone;
case WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY:
return DndAction::kCopy;
case WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE:
return DndAction::kMove;
case WL_DATA_DEVICE_MANAGER_DND_ACTION_ASK:
return DndAction::kAsk;
default:
NOTREACHED();
return DndAction::kNone;
}
}
base::flat_set<DndAction> DataDeviceManagerDndActions(uint32_t value) {
base::flat_set<DndAction> actions;
if (value & WL_DATA_DEVICE_MANAGER_DND_ACTION_COPY)
actions.insert(DndAction::kCopy);
if (value & WL_DATA_DEVICE_MANAGER_DND_ACTION_MOVE)
actions.insert(DndAction::kMove);
if (value & WL_DATA_DEVICE_MANAGER_DND_ACTION_ASK)
actions.insert(DndAction::kAsk);
return actions;
}
uint32_t ResizeDirection(int component) {
switch (component) {
case HTCAPTION:
return ZCR_REMOTE_SURFACE_V1_RESIZE_DIRECTION_NONE;
case HTTOP:
return ZCR_REMOTE_SURFACE_V1_RESIZE_DIRECTION_TOP;
case HTTOPRIGHT:
return ZCR_REMOTE_SURFACE_V1_RESIZE_DIRECTION_TOPRIGHT;
case HTRIGHT:
return ZCR_REMOTE_SURFACE_V1_RESIZE_DIRECTION_RIGHT;
case HTBOTTOMRIGHT:
return ZCR_REMOTE_SURFACE_V1_RESIZE_DIRECTION_BOTTOMRIGHT;
case HTBOTTOM:
return ZCR_REMOTE_SURFACE_V1_RESIZE_DIRECTION_BOTTOM;
case HTBOTTOMLEFT:
return ZCR_REMOTE_SURFACE_V1_RESIZE_DIRECTION_BOTTOMLEFT;
case HTLEFT:
return ZCR_REMOTE_SURFACE_V1_RESIZE_DIRECTION_LEFT;
case HTTOPLEFT:
return ZCR_REMOTE_SURFACE_V1_RESIZE_DIRECTION_TOPLEFT;
default:
LOG(ERROR) << "Unknown component:" << component;
break;
}
NOTREACHED();
return ZCR_REMOTE_SURFACE_V1_RESIZE_DIRECTION_NONE;
}
int Component(uint32_t direction) {
switch (direction) {
case ZCR_REMOTE_SURFACE_V1_RESIZE_DIRECTION_NONE:
return HTNOWHERE;
case ZCR_REMOTE_SURFACE_V1_RESIZE_DIRECTION_TOP:
return HTTOP;
case ZCR_REMOTE_SURFACE_V1_RESIZE_DIRECTION_TOPRIGHT:
return HTTOPRIGHT;
case ZCR_REMOTE_SURFACE_V1_RESIZE_DIRECTION_RIGHT:
return HTRIGHT;
case ZCR_REMOTE_SURFACE_V1_RESIZE_DIRECTION_BOTTOMRIGHT:
return HTBOTTOMRIGHT;
case ZCR_REMOTE_SURFACE_V1_RESIZE_DIRECTION_BOTTOM:
return HTBOTTOM;
case ZCR_REMOTE_SURFACE_V1_RESIZE_DIRECTION_BOTTOMLEFT:
return HTBOTTOMLEFT;
case ZCR_REMOTE_SURFACE_V1_RESIZE_DIRECTION_LEFT:
return HTLEFT;
case ZCR_REMOTE_SURFACE_V1_RESIZE_DIRECTION_TOPLEFT:
return HTTOPLEFT;
default:
VLOG(2) << "Unknown direction:" << direction;
break;
}
return HTNOWHERE;
}
uint32_t CaptionButtonMask(uint32_t mask) {
uint32_t caption_button_icon_mask = 0;
if (mask & ZCR_REMOTE_SURFACE_V1_FRAME_BUTTON_TYPE_BACK)
caption_button_icon_mask |= 1 << ash::CAPTION_BUTTON_ICON_BACK;
if (mask & ZCR_REMOTE_SURFACE_V1_FRAME_BUTTON_TYPE_MENU)
caption_button_icon_mask |= 1 << ash::CAPTION_BUTTON_ICON_MENU;
if (mask & ZCR_REMOTE_SURFACE_V1_FRAME_BUTTON_TYPE_MINIMIZE)
caption_button_icon_mask |= 1 << ash::CAPTION_BUTTON_ICON_MINIMIZE;
if (mask & ZCR_REMOTE_SURFACE_V1_FRAME_BUTTON_TYPE_MAXIMIZE_RESTORE)
caption_button_icon_mask |= 1 << ash::CAPTION_BUTTON_ICON_MAXIMIZE_RESTORE;
if (mask & ZCR_REMOTE_SURFACE_V1_FRAME_BUTTON_TYPE_CLOSE)
caption_button_icon_mask |= 1 << ash::CAPTION_BUTTON_ICON_CLOSE;
if (mask & ZCR_REMOTE_SURFACE_V1_FRAME_BUTTON_TYPE_ZOOM)
caption_button_icon_mask |= 1 << ash::CAPTION_BUTTON_ICON_ZOOM;
return caption_button_icon_mask;
}
// A property key containing the surface resource that is associated with
// window. If unset, no surface resource is associated with surface object.
DEFINE_UI_CLASS_PROPERTY_KEY(wl_resource*, kSurfaceResourceKey, nullptr);
// A property key containing a boolean set to true if a viewport is associated
// with with surface object.
DEFINE_UI_CLASS_PROPERTY_KEY(bool, kSurfaceHasViewportKey, false);
// A property key containing a boolean set to true if a security object is
// associated with surface object.
DEFINE_UI_CLASS_PROPERTY_KEY(bool, kSurfaceHasSecurityKey, false);
// A property key containing a boolean set to true if a blending object is
// associated with surface object.
DEFINE_UI_CLASS_PROPERTY_KEY(bool, kSurfaceHasBlendingKey, false);
// A property key containing a boolean set to true if the stylus_tool
// object is associated with surface object.
DEFINE_UI_CLASS_PROPERTY_KEY(bool, kSurfaceHasStylusToolKey, false);
// A property key containing the data offer resource that is associated with
// data offer object.
DEFINE_UI_CLASS_PROPERTY_KEY(wl_resource*, kDataOfferResourceKey, nullptr);
// A property key containing a boolean set to true if na aura surface object is
// associated with surface object.
DEFINE_UI_CLASS_PROPERTY_KEY(bool, kSurfaceHasAuraSurfaceKey, false);
wl_resource* GetSurfaceResource(Surface* surface) {
return surface->GetProperty(kSurfaceResourceKey);
}
wl_resource* GetDataOfferResource(const DataOffer* data_offer) {
return data_offer->GetProperty(kDataOfferResourceKey);
}
////////////////////////////////////////////////////////////////////////////////
// wl_buffer_interface:
void buffer_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
const struct wl_buffer_interface buffer_implementation = {buffer_destroy};
void HandleBufferReleaseCallback(wl_resource* resource) {
wl_buffer_send_release(resource);
wl_client_flush(wl_resource_get_client(resource));
}
////////////////////////////////////////////////////////////////////////////////
// wl_surface_interface:
void surface_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
void surface_attach(wl_client* client,
wl_resource* resource,
wl_resource* buffer,
int32_t x,
int32_t y) {
// TODO(reveman): Implement buffer offset support.
DLOG_IF(WARNING, x || y) << "Unsupported buffer offset: "
<< gfx::Point(x, y).ToString();
GetUserDataAs<Surface>(resource)
->Attach(buffer ? GetUserDataAs<Buffer>(buffer) : nullptr);
}
void surface_damage(wl_client* client,
wl_resource* resource,
int32_t x,
int32_t y,
int32_t width,
int32_t height) {
GetUserDataAs<Surface>(resource)->Damage(gfx::Rect(x, y, width, height));
}
void HandleSurfaceFrameCallback(wl_resource* resource,
base::TimeTicks frame_time) {
if (!frame_time.is_null()) {
wl_callback_send_done(resource, TimeTicksToMilliseconds(frame_time));
// TODO(reveman): Remove this potentially blocking flush and instead watch
// the file descriptor to be ready for write without blocking.
wl_client_flush(wl_resource_get_client(resource));
}
wl_resource_destroy(resource);
}
void surface_frame(wl_client* client,
wl_resource* resource,
uint32_t callback) {
wl_resource* callback_resource =
wl_resource_create(client, &wl_callback_interface, 1, callback);
// base::Unretained is safe as the resource owns the callback.
auto cancelable_callback =
std::make_unique<base::CancelableCallback<void(base::TimeTicks)>>(
base::Bind(&HandleSurfaceFrameCallback,
base::Unretained(callback_resource)));
GetUserDataAs<Surface>(resource)
->RequestFrameCallback(cancelable_callback->callback());
SetImplementation(callback_resource, nullptr, std::move(cancelable_callback));
}
void surface_set_opaque_region(wl_client* client,
wl_resource* resource,
wl_resource* region_resource) {
SkRegion region = region_resource ? *GetUserDataAs<SkRegion>(region_resource)
: SkRegion(SkIRect::MakeEmpty());
GetUserDataAs<Surface>(resource)->SetOpaqueRegion(cc::Region(region));
}
void surface_set_input_region(wl_client* client,
wl_resource* resource,
wl_resource* region_resource) {
Surface* surface = GetUserDataAs<Surface>(resource);
if (region_resource) {
surface->SetInputRegion(
cc::Region(*GetUserDataAs<SkRegion>(region_resource)));
} else
surface->ResetInputRegion();
}
void surface_commit(wl_client* client, wl_resource* resource) {
GetUserDataAs<Surface>(resource)->Commit();
}
void surface_set_buffer_transform(wl_client* client,
wl_resource* resource,
int32_t transform) {
Transform buffer_transform;
switch (transform) {
case WL_OUTPUT_TRANSFORM_NORMAL:
buffer_transform = Transform::NORMAL;
break;
case WL_OUTPUT_TRANSFORM_90:
buffer_transform = Transform::ROTATE_90;
break;
case WL_OUTPUT_TRANSFORM_180:
buffer_transform = Transform::ROTATE_180;
break;
case WL_OUTPUT_TRANSFORM_270:
buffer_transform = Transform::ROTATE_270;
break;
case WL_OUTPUT_TRANSFORM_FLIPPED:
case WL_OUTPUT_TRANSFORM_FLIPPED_90:
case WL_OUTPUT_TRANSFORM_FLIPPED_180:
case WL_OUTPUT_TRANSFORM_FLIPPED_270:
NOTIMPLEMENTED();
return;
default:
wl_resource_post_error(resource, WL_SURFACE_ERROR_INVALID_TRANSFORM,
"buffer transform must be one of the values from "
"the wl_output.transform enum ('%d' specified)",
transform);
return;
}
GetUserDataAs<Surface>(resource)->SetBufferTransform(buffer_transform);
}
void surface_set_buffer_scale(wl_client* client,
wl_resource* resource,
int32_t scale) {
if (scale < 1) {
wl_resource_post_error(resource, WL_SURFACE_ERROR_INVALID_SCALE,
"buffer scale must be at least one "
"('%d' specified)",
scale);
return;
}
GetUserDataAs<Surface>(resource)->SetBufferScale(scale);
}
const struct wl_surface_interface surface_implementation = {
surface_destroy,
surface_attach,
surface_damage,
surface_frame,
surface_set_opaque_region,
surface_set_input_region,
surface_commit,
surface_set_buffer_transform,
surface_set_buffer_scale};
////////////////////////////////////////////////////////////////////////////////
// wl_region_interface:
void region_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
void region_add(wl_client* client,
wl_resource* resource,
int32_t x,
int32_t y,
int32_t width,
int32_t height) {
GetUserDataAs<SkRegion>(resource)
->op(SkIRect::MakeXYWH(x, y, width, height), SkRegion::kUnion_Op);
}
static void region_subtract(wl_client* client,
wl_resource* resource,
int32_t x,
int32_t y,
int32_t width,
int32_t height) {
GetUserDataAs<SkRegion>(resource)
->op(SkIRect::MakeXYWH(x, y, width, height), SkRegion::kDifference_Op);
}
const struct wl_region_interface region_implementation = {
region_destroy, region_add, region_subtract};
////////////////////////////////////////////////////////////////////////////////
// wl_compositor_interface:
void compositor_create_surface(wl_client* client,
wl_resource* resource,
uint32_t id) {
std::unique_ptr<Surface> surface =
GetUserDataAs<Display>(resource)->CreateSurface();
wl_resource* surface_resource = wl_resource_create(
client, &wl_surface_interface, wl_resource_get_version(resource), id);
// Set the surface resource property for type-checking downcast support.
surface->SetProperty(kSurfaceResourceKey, surface_resource);
SetImplementation(surface_resource, &surface_implementation,
std::move(surface));
}
void compositor_create_region(wl_client* client,
wl_resource* resource,
uint32_t id) {
wl_resource* region_resource =
wl_resource_create(client, &wl_region_interface, 1, id);
SetImplementation(region_resource, ®ion_implementation,
base::WrapUnique(new SkRegion));
}
const struct wl_compositor_interface compositor_implementation = {
compositor_create_surface, compositor_create_region};
const uint32_t compositor_version = 3;
void bind_compositor(wl_client* client,
void* data,
uint32_t version,
uint32_t id) {
wl_resource* resource =
wl_resource_create(client, &wl_compositor_interface,
std::min(version, compositor_version), id);
wl_resource_set_implementation(resource, &compositor_implementation, data,
nullptr);
}
////////////////////////////////////////////////////////////////////////////////
// wl_shm_pool_interface:
const struct shm_supported_format {
uint32_t shm_format;
gfx::BufferFormat buffer_format;
} shm_supported_formats[] = {
{WL_SHM_FORMAT_XBGR8888, gfx::BufferFormat::RGBX_8888},
{WL_SHM_FORMAT_ABGR8888, gfx::BufferFormat::RGBA_8888},
{WL_SHM_FORMAT_XRGB8888, gfx::BufferFormat::BGRX_8888},
{WL_SHM_FORMAT_ARGB8888, gfx::BufferFormat::BGRA_8888}};
void shm_pool_create_buffer(wl_client* client,
wl_resource* resource,
uint32_t id,
int32_t offset,
int32_t width,
int32_t height,
int32_t stride,
uint32_t format) {
const auto* supported_format =
std::find_if(shm_supported_formats,
shm_supported_formats + arraysize(shm_supported_formats),
[format](const shm_supported_format& supported_format) {
return supported_format.shm_format == format;
});
if (supported_format ==
(shm_supported_formats + arraysize(shm_supported_formats))) {
wl_resource_post_error(resource, WL_SHM_ERROR_INVALID_FORMAT,
"invalid format 0x%x", format);
return;
}
if (offset < 0) {
wl_resource_post_error(resource, WL_SHM_ERROR_INVALID_FORMAT,
"invalid offset %d", offset);
return;
}
std::unique_ptr<Buffer> buffer =
GetUserDataAs<SharedMemory>(resource)->CreateBuffer(
gfx::Size(width, height), supported_format->buffer_format, offset,
stride);
if (!buffer) {
wl_resource_post_no_memory(resource);
return;
}
wl_resource* buffer_resource =
wl_resource_create(client, &wl_buffer_interface, 1, id);
buffer->set_release_callback(base::Bind(&HandleBufferReleaseCallback,
base::Unretained(buffer_resource)));
SetImplementation(buffer_resource, &buffer_implementation, std::move(buffer));
}
void shm_pool_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
void shm_pool_resize(wl_client* client, wl_resource* resource, int32_t size) {
// Nothing to do here.
}
const struct wl_shm_pool_interface shm_pool_implementation = {
shm_pool_create_buffer, shm_pool_destroy, shm_pool_resize};
////////////////////////////////////////////////////////////////////////////////
// wl_shm_interface:
void shm_create_pool(wl_client* client,
wl_resource* resource,
uint32_t id,
int fd,
int32_t size) {
std::unique_ptr<SharedMemory> shared_memory =
GetUserDataAs<Display>(resource)->CreateSharedMemory(
base::SharedMemoryHandle::ImportHandle(fd, size), size);
if (!shared_memory) {
wl_resource_post_no_memory(resource);
return;
}
wl_resource* shm_pool_resource =
wl_resource_create(client, &wl_shm_pool_interface, 1, id);
SetImplementation(shm_pool_resource, &shm_pool_implementation,
std::move(shared_memory));
}
const struct wl_shm_interface shm_implementation = {shm_create_pool};
void bind_shm(wl_client* client, void* data, uint32_t version, uint32_t id) {
wl_resource* resource = wl_resource_create(client, &wl_shm_interface, 1, id);
wl_resource_set_implementation(resource, &shm_implementation, data, nullptr);
for (const auto& supported_format : shm_supported_formats)
wl_shm_send_format(resource, supported_format.shm_format);
}
#if defined(USE_OZONE)
////////////////////////////////////////////////////////////////////////////////
// linux_buffer_params_interface:
const struct dmabuf_supported_format {
uint32_t dmabuf_format;
gfx::BufferFormat buffer_format;
} dmabuf_supported_formats[] = {
{DRM_FORMAT_RGB565, gfx::BufferFormat::BGR_565},
{DRM_FORMAT_XBGR8888, gfx::BufferFormat::RGBX_8888},
{DRM_FORMAT_ABGR8888, gfx::BufferFormat::RGBA_8888},
{DRM_FORMAT_XRGB8888, gfx::BufferFormat::BGRX_8888},
{DRM_FORMAT_ARGB8888, gfx::BufferFormat::BGRA_8888},
{DRM_FORMAT_NV12, gfx::BufferFormat::YUV_420_BIPLANAR},
{DRM_FORMAT_YVU420, gfx::BufferFormat::YVU_420}};
struct LinuxBufferParams {
struct Plane {
base::ScopedFD fd;
uint32_t stride;
uint32_t offset;
};
explicit LinuxBufferParams(Display* display) : display(display) {}
Display* const display;
std::map<uint32_t, Plane> planes;
};
void linux_buffer_params_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
void linux_buffer_params_add(wl_client* client,
wl_resource* resource,
int32_t fd,
uint32_t plane_idx,
uint32_t offset,
uint32_t stride,
uint32_t modifier_hi,
uint32_t modifier_lo) {
LinuxBufferParams* linux_buffer_params =
GetUserDataAs<LinuxBufferParams>(resource);
LinuxBufferParams::Plane plane{base::ScopedFD(fd), stride, offset};
const auto& inserted = linux_buffer_params->planes.insert(
std::pair<uint32_t, LinuxBufferParams::Plane>(plane_idx,
std::move(plane)));
if (!inserted.second) { // The plane was already there.
wl_resource_post_error(resource, ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_PLANE_SET,
"plane already set");
}
}
bool ValidateLinuxBufferParams(wl_resource* resource,
int32_t width,
int32_t height,
gfx::BufferFormat format,
uint32_t flags) {
if (width <= 0 || height <= 0) {
wl_resource_post_error(resource,
ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_INVALID_DIMENSIONS,
"invalid width or height");
return false;
}
if (flags & (ZWP_LINUX_BUFFER_PARAMS_V1_FLAGS_Y_INVERT |
ZWP_LINUX_BUFFER_PARAMS_V1_FLAGS_INTERLACED)) {
wl_resource_post_error(resource,
ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_INCOMPLETE,
"flags not supported");
return false;
}
LinuxBufferParams* linux_buffer_params =
GetUserDataAs<LinuxBufferParams>(resource);
size_t num_planes = gfx::NumberOfPlanesForBufferFormat(format);
for (uint32_t i = 0; i < num_planes; ++i) {
auto plane_it = linux_buffer_params->planes.find(i);
if (plane_it == linux_buffer_params->planes.end()) {
wl_resource_post_error(resource,
ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_INCOMPLETE,
"missing a plane");
return false;
}
}
if (linux_buffer_params->planes.size() != num_planes) {
wl_resource_post_error(resource, ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_PLANE_IDX,
"plane idx out of bounds");
return false;
}
return true;
}
void linux_buffer_params_create(wl_client* client,
wl_resource* resource,
int32_t width,
int32_t height,
uint32_t format,
uint32_t flags) {
const auto* supported_format = std::find_if(
std::begin(dmabuf_supported_formats), std::end(dmabuf_supported_formats),
[format](const dmabuf_supported_format& supported_format) {
return supported_format.dmabuf_format == format;
});
if (supported_format == std::end(dmabuf_supported_formats)) {
wl_resource_post_error(resource,
ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_INVALID_FORMAT,
"format not supported");
return;
}
if (!ValidateLinuxBufferParams(resource, width, height,
supported_format->buffer_format, flags))
return;
LinuxBufferParams* linux_buffer_params =
GetUserDataAs<LinuxBufferParams>(resource);
size_t num_planes =
gfx::NumberOfPlanesForBufferFormat(supported_format->buffer_format);
std::vector<gfx::NativePixmapPlane> planes;
std::vector<base::ScopedFD> fds;
for (uint32_t i = 0; i < num_planes; ++i) {
auto plane_it = linux_buffer_params->planes.find(i);
LinuxBufferParams::Plane& plane = plane_it->second;
planes.emplace_back(plane.stride, plane.offset, 0);
fds.push_back(std::move(plane.fd));
}
std::unique_ptr<Buffer> buffer =
linux_buffer_params->display->CreateLinuxDMABufBuffer(
gfx::Size(width, height), supported_format->buffer_format, planes,
std::move(fds));
if (!buffer) {
zwp_linux_buffer_params_v1_send_failed(resource);
return;
}
wl_resource* buffer_resource =
wl_resource_create(client, &wl_buffer_interface, 1, 0);
buffer->set_release_callback(base::Bind(&HandleBufferReleaseCallback,
base::Unretained(buffer_resource)));
SetImplementation(buffer_resource, &buffer_implementation, std::move(buffer));
zwp_linux_buffer_params_v1_send_created(resource, buffer_resource);
}
void linux_buffer_params_create_immed(wl_client* client,
wl_resource* resource,
uint32_t buffer_id,
int32_t width,
int32_t height,
uint32_t format,
uint32_t flags) {
const auto* supported_format = std::find_if(
std::begin(dmabuf_supported_formats), std::end(dmabuf_supported_formats),
[format](const dmabuf_supported_format& supported_format) {
return supported_format.dmabuf_format == format;
});
if (supported_format == std::end(dmabuf_supported_formats)) {
wl_resource_post_error(resource,
ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_INVALID_FORMAT,
"format not supported");
return;
}
if (!ValidateLinuxBufferParams(resource, width, height,
supported_format->buffer_format, flags))
return;
LinuxBufferParams* linux_buffer_params =
GetUserDataAs<LinuxBufferParams>(resource);
size_t num_planes =
gfx::NumberOfPlanesForBufferFormat(supported_format->buffer_format);
std::vector<gfx::NativePixmapPlane> planes;
std::vector<base::ScopedFD> fds;
for (uint32_t i = 0; i < num_planes; ++i) {
auto plane_it = linux_buffer_params->planes.find(i);
LinuxBufferParams::Plane& plane = plane_it->second;
planes.emplace_back(plane.stride, plane.offset, 0);
fds.push_back(std::move(plane.fd));
}
std::unique_ptr<Buffer> buffer =
linux_buffer_params->display->CreateLinuxDMABufBuffer(
gfx::Size(width, height), supported_format->buffer_format, planes,
std::move(fds));
if (!buffer) {
// On import failure in case of a create_immed request, the protocol
// allows us to raise a fatal error from zwp_linux_dmabuf_v1 version 2+.
wl_resource_post_error(resource,
ZWP_LINUX_BUFFER_PARAMS_V1_ERROR_INVALID_WL_BUFFER,
"dmabuf import failed");
return;
}
wl_resource* buffer_resource =
wl_resource_create(client, &wl_buffer_interface, 1, buffer_id);
buffer->set_release_callback(base::Bind(&HandleBufferReleaseCallback,
base::Unretained(buffer_resource)));
SetImplementation(buffer_resource, &buffer_implementation, std::move(buffer));
}
const struct zwp_linux_buffer_params_v1_interface
linux_buffer_params_implementation = {
linux_buffer_params_destroy, linux_buffer_params_add,
linux_buffer_params_create, linux_buffer_params_create_immed};
////////////////////////////////////////////////////////////////////////////////
// linux_dmabuf_interface:
void linux_dmabuf_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
void linux_dmabuf_create_params(wl_client* client,
wl_resource* resource,
uint32_t id) {
std::unique_ptr<LinuxBufferParams> linux_buffer_params =
std::make_unique<LinuxBufferParams>(GetUserDataAs<Display>(resource));
wl_resource* linux_buffer_params_resource =
wl_resource_create(client, &zwp_linux_buffer_params_v1_interface,
wl_resource_get_version(resource), id);
SetImplementation(linux_buffer_params_resource,
&linux_buffer_params_implementation,
std::move(linux_buffer_params));
}
const struct zwp_linux_dmabuf_v1_interface linux_dmabuf_implementation = {
linux_dmabuf_destroy, linux_dmabuf_create_params};
const uint32_t linux_dmabuf_version = 2;
void bind_linux_dmabuf(wl_client* client,
void* data,
uint32_t version,
uint32_t id) {
wl_resource* resource =
wl_resource_create(client, &zwp_linux_dmabuf_v1_interface,
std::min(version, linux_dmabuf_version), id);
wl_resource_set_implementation(resource, &linux_dmabuf_implementation, data,
nullptr);
for (const auto& supported_format : dmabuf_supported_formats)
zwp_linux_dmabuf_v1_send_format(resource, supported_format.dmabuf_format);
}
#endif
////////////////////////////////////////////////////////////////////////////////
// wl_subsurface_interface:
void subsurface_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
void subsurface_set_position(wl_client* client,
wl_resource* resource,
int32_t x,
int32_t y) {
GetUserDataAs<SubSurface>(resource)->SetPosition(gfx::Point(x, y));
}
void subsurface_place_above(wl_client* client,
wl_resource* resource,
wl_resource* reference_resource) {
GetUserDataAs<SubSurface>(resource)
->PlaceAbove(GetUserDataAs<Surface>(reference_resource));
}
void subsurface_place_below(wl_client* client,
wl_resource* resource,
wl_resource* sibling_resource) {
GetUserDataAs<SubSurface>(resource)
->PlaceBelow(GetUserDataAs<Surface>(sibling_resource));
}
void subsurface_set_sync(wl_client* client, wl_resource* resource) {
GetUserDataAs<SubSurface>(resource)->SetCommitBehavior(true);
}
void subsurface_set_desync(wl_client* client, wl_resource* resource) {
GetUserDataAs<SubSurface>(resource)->SetCommitBehavior(false);
}
const struct wl_subsurface_interface subsurface_implementation = {
subsurface_destroy, subsurface_set_position, subsurface_place_above,
subsurface_place_below, subsurface_set_sync, subsurface_set_desync};
////////////////////////////////////////////////////////////////////////////////
// wl_subcompositor_interface:
void subcompositor_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
void subcompositor_get_subsurface(wl_client* client,
wl_resource* resource,
uint32_t id,
wl_resource* surface,
wl_resource* parent) {
std::unique_ptr<SubSurface> subsurface =
GetUserDataAs<Display>(resource)->CreateSubSurface(
GetUserDataAs<Surface>(surface), GetUserDataAs<Surface>(parent));
if (!subsurface) {
wl_resource_post_error(resource, WL_SUBCOMPOSITOR_ERROR_BAD_SURFACE,
"invalid surface");
return;
}
wl_resource* subsurface_resource =
wl_resource_create(client, &wl_subsurface_interface, 1, id);
SetImplementation(subsurface_resource, &subsurface_implementation,
std::move(subsurface));
}
const struct wl_subcompositor_interface subcompositor_implementation = {
subcompositor_destroy, subcompositor_get_subsurface};
void bind_subcompositor(wl_client* client,
void* data,
uint32_t version,
uint32_t id) {
wl_resource* resource =
wl_resource_create(client, &wl_subcompositor_interface, 1, id);
wl_resource_set_implementation(resource, &subcompositor_implementation, data,
nullptr);
}
////////////////////////////////////////////////////////////////////////////////
// wl_shell_surface_interface:
void shell_surface_pong(wl_client* client,
wl_resource* resource,
uint32_t serial) {
NOTIMPLEMENTED();
}
void shell_surface_move(wl_client* client,
wl_resource* resource,
wl_resource* seat_resource,
uint32_t serial) {
GetUserDataAs<ShellSurface>(resource)->Move();
}
void shell_surface_resize(wl_client* client,
wl_resource* resource,
wl_resource* seat_resource,
uint32_t serial,
uint32_t edges) {
NOTIMPLEMENTED();
}
void shell_surface_set_toplevel(wl_client* client, wl_resource* resource) {
GetUserDataAs<ShellSurface>(resource)->SetEnabled(true);
}
void shell_surface_set_transient(wl_client* client,
wl_resource* resource,
wl_resource* parent_resource,
int x,
int y,
uint32_t flags) {
ShellSurface* shell_surface = GetUserDataAs<ShellSurface>(resource);
if (shell_surface->enabled())
return;
if (flags & WL_SHELL_SURFACE_TRANSIENT_INACTIVE) {
shell_surface->SetContainer(ash::kShellWindowId_SystemModalContainer);
shell_surface->SetActivatable(false);
}
shell_surface->SetEnabled(true);
}
void shell_surface_set_fullscreen(wl_client* client,
wl_resource* resource,
uint32_t method,
uint32_t framerate,
wl_resource* output_resource) {
ShellSurface* shell_surface = GetUserDataAs<ShellSurface>(resource);
if (shell_surface->enabled())
return;
shell_surface->SetEnabled(true);
shell_surface->SetFullscreen(true);
}
void shell_surface_set_popup(wl_client* client,
wl_resource* resource,
wl_resource* seat_resource,
uint32_t serial,
wl_resource* parent_resource,
int32_t x,
int32_t y,
uint32_t flags) {
NOTIMPLEMENTED();
}
void shell_surface_set_maximized(wl_client* client,
wl_resource* resource,
wl_resource* output_resource) {
ShellSurface* shell_surface = GetUserDataAs<ShellSurface>(resource);
if (shell_surface->enabled())
return;
shell_surface->SetEnabled(true);
shell_surface->Maximize();
}
void shell_surface_set_title(wl_client* client,
wl_resource* resource,
const char* title) {
GetUserDataAs<ShellSurface>(resource)
->SetTitle(base::string16(base::UTF8ToUTF16(title)));
}
void shell_surface_set_class(wl_client* client,
wl_resource* resource,
const char* clazz) {
GetUserDataAs<ShellSurface>(resource)->SetApplicationId(clazz);
}
const struct wl_shell_surface_interface shell_surface_implementation = {
shell_surface_pong, shell_surface_move,
shell_surface_resize, shell_surface_set_toplevel,
shell_surface_set_transient, shell_surface_set_fullscreen,
shell_surface_set_popup, shell_surface_set_maximized,
shell_surface_set_title, shell_surface_set_class};
////////////////////////////////////////////////////////////////////////////////
// wl_shell_interface:
uint32_t HandleShellSurfaceConfigureCallback(
wl_resource* resource,
const gfx::Size& size,
ash::mojom::WindowStateType state_type,
bool resizing,
bool activated,
const gfx::Vector2d& origin_offset) {
wl_shell_surface_send_configure(resource, WL_SHELL_SURFACE_RESIZE_NONE,
size.width(), size.height());
wl_client_flush(wl_resource_get_client(resource));
return 0;
}
void shell_get_shell_surface(wl_client* client,
wl_resource* resource,
uint32_t id,
wl_resource* surface) {
std::unique_ptr<ShellSurface> shell_surface =
GetUserDataAs<Display>(resource)->CreateShellSurface(
GetUserDataAs<Surface>(surface));
if (!shell_surface) {
wl_resource_post_error(resource, WL_SHELL_ERROR_ROLE,
"surface has already been assigned a role");
return;
}
wl_resource* shell_surface_resource =
wl_resource_create(client, &wl_shell_surface_interface, 1, id);
// Shell surfaces are initially disabled and needs to be explicitly mapped
// before they are enabled and can become visible.
shell_surface->SetEnabled(false);
shell_surface->set_configure_callback(
base::Bind(&HandleShellSurfaceConfigureCallback,
base::Unretained(shell_surface_resource)));
shell_surface->set_surface_destroyed_callback(base::Bind(
&wl_resource_destroy, base::Unretained(shell_surface_resource)));
SetImplementation(shell_surface_resource, &shell_surface_implementation,
std::move(shell_surface));
}
const struct wl_shell_interface shell_implementation = {
shell_get_shell_surface};
void bind_shell(wl_client* client, void* data, uint32_t version, uint32_t id) {
wl_resource* resource =
wl_resource_create(client, &wl_shell_interface, 1, id);
wl_resource_set_implementation(resource, &shell_implementation, data,
nullptr);
}
////////////////////////////////////////////////////////////////////////////////
// wl_output_interface:
// Returns the transform that a compositor will apply to a surface to
// compensate for the rotation of an output device.
wl_output_transform OutputTransform(display::Display::Rotation rotation) {
// Note: |rotation| describes the counter clockwise rotation that a
// display's output is currently adjusted for, which is the inverse
// of what we need to return.
switch (rotation) {
case display::Display::ROTATE_0:
return WL_OUTPUT_TRANSFORM_NORMAL;
case display::Display::ROTATE_90:
return WL_OUTPUT_TRANSFORM_270;
case display::Display::ROTATE_180:
return WL_OUTPUT_TRANSFORM_180;
case display::Display::ROTATE_270:
return WL_OUTPUT_TRANSFORM_90;
}
NOTREACHED();
return WL_OUTPUT_TRANSFORM_NORMAL;
}
class WaylandDisplayObserver : public display::DisplayObserver {
public:
class ScaleObserver : public base::SupportsWeakPtr<ScaleObserver> {
public:
ScaleObserver() {}
virtual void OnDisplayScalesChanged(const display::Display& display) = 0;
protected:
virtual ~ScaleObserver() {}
};
WaylandDisplayObserver(int64_t id, wl_resource* output_resource)
: id_(id), output_resource_(output_resource) {
display::Screen::GetScreen()->AddObserver(this);
SendDisplayMetrics();
}
~WaylandDisplayObserver() override {
display::Screen::GetScreen()->RemoveObserver(this);
}
void SetScaleObserver(base::WeakPtr<ScaleObserver> scale_observer) {
scale_observer_ = scale_observer;
SendDisplayMetrics();
}
bool HasScaleObserver() const { return !!scale_observer_; }
// Overridden from display::DisplayObserver:
void OnDisplayMetricsChanged(const display::Display& display,
uint32_t changed_metrics) override {
if (id_ != display.id())
return;
// There is no need to check DISPLAY_METRIC_PRIMARY because when primary
// changes, bounds always changes. (new primary should have had non
// 0,0 origin).
// Only exception is when switching to newly connected primary with
// the same bounds. This happens whenyou're in docked mode, suspend,
// unplug the dislpay, then resume to the internal display which has
// the same resolution. Since metrics does not change, there is no need
// to notify clients.
if (changed_metrics &
(DISPLAY_METRIC_BOUNDS | DISPLAY_METRIC_DEVICE_SCALE_FACTOR |
DISPLAY_METRIC_ROTATION)) {
SendDisplayMetrics();
}
}
private:
void SendDisplayMetrics() {
display::Display display;
bool rv =
display::Screen::GetScreen()->GetDisplayWithDisplayId(id_, &display);
DCHECK(rv);
const display::ManagedDisplayInfo& info =
WMHelper::GetInstance()->GetDisplayInfo(display.id());
const float kInchInMm = 25.4f;
const char* kUnknown = "unknown";
const std::string& make = info.manufacturer_id();
const std::string& model = info.product_id();
gfx::Rect bounds = info.bounds_in_native();
wl_output_send_geometry(
output_resource_, bounds.x(), bounds.y(),
static_cast<int>(kInchInMm * bounds.width() / info.device_dpi()),
static_cast<int>(kInchInMm * bounds.height() / info.device_dpi()),
WL_OUTPUT_SUBPIXEL_UNKNOWN, make.empty() ? kUnknown : make.c_str(),
model.empty() ? kUnknown : model.c_str(),
OutputTransform(display.rotation()));
if (wl_resource_get_version(output_resource_) >=
WL_OUTPUT_SCALE_SINCE_VERSION) {
wl_output_send_scale(output_resource_, display.device_scale_factor());
}
// TODO(reveman): Send real list of modes.
wl_output_send_mode(
output_resource_, WL_OUTPUT_MODE_CURRENT | WL_OUTPUT_MODE_PREFERRED,
bounds.width(), bounds.height(), static_cast<int>(60000));
if (HasScaleObserver())
scale_observer_->OnDisplayScalesChanged(display);
if (wl_resource_get_version(output_resource_) >=
WL_OUTPUT_DONE_SINCE_VERSION) {
wl_output_send_done(output_resource_);
}
wl_client_flush(wl_resource_get_client(output_resource_));
}
// The ID of the display being observed.
const int64_t id_;
// The output resource associated with the display.
wl_resource* const output_resource_;
base::WeakPtr<ScaleObserver> scale_observer_;
DISALLOW_COPY_AND_ASSIGN(WaylandDisplayObserver);
};
const uint32_t output_version = 2;
void bind_output(wl_client* client, void* data, uint32_t version, uint32_t id) {
Server::Output* output = static_cast<Server::Output*>(data);
wl_resource* resource = wl_resource_create(
client, &wl_output_interface, std::min(version, output_version), id);
SetImplementation(
resource, nullptr,
std::make_unique<WaylandDisplayObserver>(output->id(), resource));
}
////////////////////////////////////////////////////////////////////////////////
// xdg_positioner_interface:
struct WaylandPositioner {
// Calculate and return position from current state.
gfx::Point CalculatePosition() const {
gfx::Point position;
if (anchor & ZXDG_POSITIONER_V6_ANCHOR_LEFT)
position.set_x(anchor_rect.x());
else if (anchor & ZXDG_POSITIONER_V6_ANCHOR_RIGHT)
position.set_x(anchor_rect.right());
else
position.set_x(anchor_rect.CenterPoint().x());
if (anchor & ZXDG_POSITIONER_V6_ANCHOR_TOP)
position.set_y(anchor_rect.y());
else if (anchor & ZXDG_POSITIONER_V6_ANCHOR_BOTTOM)
position.set_y(anchor_rect.bottom());
else
position.set_y(anchor_rect.CenterPoint().y());
gfx::Vector2d gravity_offset;
if (gravity & ZXDG_POSITIONER_V6_GRAVITY_LEFT)
gravity_offset.set_x(size.width());
else if (gravity & ZXDG_POSITIONER_V6_GRAVITY_RIGHT)
gravity_offset.set_x(0);
else
gravity_offset.set_x(size.width() / 2);
if (gravity & ZXDG_POSITIONER_V6_GRAVITY_TOP)
gravity_offset.set_y(size.height());
else if (gravity & ZXDG_POSITIONER_V6_GRAVITY_BOTTOM)
gravity_offset.set_y(0);
else
gravity_offset.set_y(size.height() / 2);
return position + offset - gravity_offset;
}
gfx::Size size;
gfx::Rect anchor_rect;
uint32_t anchor = ZXDG_POSITIONER_V6_ANCHOR_NONE;
uint32_t gravity = ZXDG_POSITIONER_V6_GRAVITY_NONE;
gfx::Vector2d offset;
};
void xdg_positioner_v6_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
void xdg_positioner_v6_set_size(wl_client* client,
wl_resource* resource,
int32_t width,
int32_t height) {
if (width < 1 || height < 1) {
wl_resource_post_error(resource, ZXDG_POSITIONER_V6_ERROR_INVALID_INPUT,
"width and height must be positive and non-zero");
return;
}
GetUserDataAs<WaylandPositioner>(resource)->size = gfx::Size(width, height);
}
void xdg_positioner_v6_set_anchor_rect(wl_client* client,
wl_resource* resource,
int32_t x,
int32_t y,
int32_t width,
int32_t height) {
if (width < 1 || height < 1) {
wl_resource_post_error(resource, ZXDG_POSITIONER_V6_ERROR_INVALID_INPUT,
"width and height must be positive and non-zero");
return;
}
GetUserDataAs<WaylandPositioner>(resource)->anchor_rect =
gfx::Rect(x, y, width, height);
}
void xdg_positioner_v6_set_anchor(wl_client* client,
wl_resource* resource,
uint32_t anchor) {
if (((anchor & ZXDG_POSITIONER_V6_ANCHOR_LEFT) &&
(anchor & ZXDG_POSITIONER_V6_ANCHOR_RIGHT)) ||
((anchor & ZXDG_POSITIONER_V6_ANCHOR_TOP) &&
(anchor & ZXDG_POSITIONER_V6_ANCHOR_BOTTOM))) {
wl_resource_post_error(resource, ZXDG_POSITIONER_V6_ERROR_INVALID_INPUT,
"same-axis values are not allowed");
return;
}
GetUserDataAs<WaylandPositioner>(resource)->anchor = anchor;
}
void xdg_positioner_v6_set_gravity(wl_client* client,
wl_resource* resource,
uint32_t gravity) {
if (((gravity & ZXDG_POSITIONER_V6_GRAVITY_LEFT) &&
(gravity & ZXDG_POSITIONER_V6_GRAVITY_RIGHT)) ||
((gravity & ZXDG_POSITIONER_V6_GRAVITY_TOP) &&
(gravity & ZXDG_POSITIONER_V6_GRAVITY_BOTTOM))) {
wl_resource_post_error(resource, ZXDG_POSITIONER_V6_ERROR_INVALID_INPUT,
"same-axis values are not allowed");
return;
}
GetUserDataAs<WaylandPositioner>(resource)->gravity = gravity;
}
void xdg_positioner_v6_set_constraint_adjustment(
wl_client* client,
wl_resource* resource,
uint32_t constraint_adjustment) {
NOTIMPLEMENTED();
}
void xdg_positioner_v6_set_offset(wl_client* client,
wl_resource* resource,
int32_t x,
int32_t y) {
GetUserDataAs<WaylandPositioner>(resource)->offset = gfx::Vector2d(x, y);
}
const struct zxdg_positioner_v6_interface xdg_positioner_v6_implementation = {
xdg_positioner_v6_destroy,
xdg_positioner_v6_set_size,
xdg_positioner_v6_set_anchor_rect,
xdg_positioner_v6_set_anchor,
xdg_positioner_v6_set_gravity,
xdg_positioner_v6_set_constraint_adjustment,
xdg_positioner_v6_set_offset};
////////////////////////////////////////////////////////////////////////////////
// xdg_toplevel_interface:
int XdgToplevelV6ResizeComponent(uint32_t edges) {
switch (edges) {
case ZXDG_TOPLEVEL_V6_RESIZE_EDGE_TOP:
return HTTOP;
case ZXDG_TOPLEVEL_V6_RESIZE_EDGE_BOTTOM:
return HTBOTTOM;
case ZXDG_TOPLEVEL_V6_RESIZE_EDGE_LEFT:
return HTLEFT;
case ZXDG_TOPLEVEL_V6_RESIZE_EDGE_TOP_LEFT:
return HTTOPLEFT;
case ZXDG_TOPLEVEL_V6_RESIZE_EDGE_BOTTOM_LEFT:
return HTBOTTOMLEFT;
case ZXDG_TOPLEVEL_V6_RESIZE_EDGE_RIGHT:
return HTRIGHT;
case ZXDG_TOPLEVEL_V6_RESIZE_EDGE_TOP_RIGHT:
return HTTOPRIGHT;
case ZXDG_TOPLEVEL_V6_RESIZE_EDGE_BOTTOM_RIGHT:
return HTBOTTOMRIGHT;
default:
return HTBOTTOMRIGHT;
}
}
using XdgSurfaceConfigureCallback =
base::Callback<void(const gfx::Size& size,
ash::mojom::WindowStateType state_type,
bool resizing,
bool activated)>;
uint32_t HandleXdgSurfaceV6ConfigureCallback(
wl_resource* resource,
const XdgSurfaceConfigureCallback& callback,
const gfx::Size& size,
ash::mojom::WindowStateType state_type,
bool resizing,
bool activated,
const gfx::Vector2d& origin_offset) {
uint32_t serial = wl_display_next_serial(
wl_client_get_display(wl_resource_get_client(resource)));
callback.Run(size, state_type, resizing, activated);
zxdg_surface_v6_send_configure(resource, serial);
wl_client_flush(wl_resource_get_client(resource));
return serial;
}
// Wrapper around shell surface that allows us to handle the case where the
// xdg surface resource is destroyed before the toplevel resource.
class WaylandToplevel : public aura::WindowObserver {
public:
WaylandToplevel(wl_resource* resource, wl_resource* surface_resource)
: resource_(resource),
shell_surface_(GetUserDataAs<XdgShellSurface>(surface_resource)),
weak_ptr_factory_(this) {
shell_surface_->host_window()->AddObserver(this);
shell_surface_->set_close_callback(
base::Bind(&WaylandToplevel::OnClose, weak_ptr_factory_.GetWeakPtr()));
shell_surface_->set_configure_callback(
base::Bind(&HandleXdgSurfaceV6ConfigureCallback, surface_resource,
base::Bind(&WaylandToplevel::OnConfigure,
weak_ptr_factory_.GetWeakPtr())));
}
~WaylandToplevel() override {
if (shell_surface_)
shell_surface_->host_window()->RemoveObserver(this);
}
// Overridden from aura::WindowObserver:
void OnWindowDestroying(aura::Window* window) override {
shell_surface_ = nullptr;
}
void SetParent(WaylandToplevel* parent) {
if (!shell_surface_)
return;
if (!parent) {
shell_surface_->SetParent(nullptr);
return;
}
// This is a no-op if parent is not mapped.
if (parent->shell_surface_ && parent->shell_surface_->GetWidget())
shell_surface_->SetParent(parent->shell_surface_);
}
void SetTitle(const base::string16& title) {
if (shell_surface_)
shell_surface_->SetTitle(title);
}
void SetApplicationId(const char* application_id) {
if (shell_surface_)
shell_surface_->SetApplicationId(application_id);
}
void Move() {
if (shell_surface_)
shell_surface_->Move();
}
void Resize(int component) {
if (!shell_surface_)
return;
if (component != HTNOWHERE)
shell_surface_->Resize(component);
}
void SetMaximumSize(const gfx::Size& size) {
if (shell_surface_)
shell_surface_->SetMaximumSize(size);
}
void SetMinimumSize(const gfx::Size& size) {
if (shell_surface_)
shell_surface_->SetMinimumSize(size);
}
void Maximize() {
if (shell_surface_)
shell_surface_->Maximize();
}
void Restore() {
if (shell_surface_)
shell_surface_->Restore();
}
void SetFullscreen(bool fullscreen) {
if (shell_surface_)
shell_surface_->SetFullscreen(fullscreen);
}
void Minimize() {
if (shell_surface_)
shell_surface_->Minimize();
}
private:
void OnClose() {
zxdg_toplevel_v6_send_close(resource_);
wl_client_flush(wl_resource_get_client(resource_));
}
static void AddState(wl_array* states, zxdg_toplevel_v6_state state) {
zxdg_toplevel_v6_state* value = static_cast<zxdg_toplevel_v6_state*>(
wl_array_add(states, sizeof(zxdg_toplevel_v6_state)));
DCHECK(value);
*value = state;
}
void OnConfigure(const gfx::Size& size,
ash::mojom::WindowStateType state_type,
bool resizing,
bool activated) {
wl_array states;
wl_array_init(&states);
if (state_type == ash::mojom::WindowStateType::MAXIMIZED)
AddState(&states, ZXDG_TOPLEVEL_V6_STATE_MAXIMIZED);
if (state_type == ash::mojom::WindowStateType::FULLSCREEN)
AddState(&states, ZXDG_TOPLEVEL_V6_STATE_FULLSCREEN);
if (resizing)
AddState(&states, ZXDG_TOPLEVEL_V6_STATE_RESIZING);
if (activated)
AddState(&states, ZXDG_TOPLEVEL_V6_STATE_ACTIVATED);
zxdg_toplevel_v6_send_configure(resource_, size.width(), size.height(),
&states);
wl_array_release(&states);
}
wl_resource* const resource_;
XdgShellSurface* shell_surface_;
base::WeakPtrFactory<WaylandToplevel> weak_ptr_factory_;
DISALLOW_COPY_AND_ASSIGN(WaylandToplevel);
};
void xdg_toplevel_v6_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
void xdg_toplevel_v6_set_parent(wl_client* client,
wl_resource* resource,
wl_resource* parent) {
WaylandToplevel* parent_surface = nullptr;
if (parent)
parent_surface = GetUserDataAs<WaylandToplevel>(parent);
GetUserDataAs<WaylandToplevel>(resource)->SetParent(parent_surface);
}
void xdg_toplevel_v6_set_title(wl_client* client,
wl_resource* resource,
const char* title) {
GetUserDataAs<WaylandToplevel>(resource)->SetTitle(
base::string16(base::UTF8ToUTF16(title)));
}
void xdg_toplevel_v6_set_app_id(wl_client* client,
wl_resource* resource,
const char* app_id) {
NOTIMPLEMENTED();
}
void xdg_toplevel_v6_show_window_menu(wl_client* client,
wl_resource* resource,
wl_resource* seat,
uint32_t serial,
int32_t x,
int32_t y) {
NOTIMPLEMENTED();
}
void xdg_toplevel_v6_move(wl_client* client,
wl_resource* resource,
wl_resource* seat,
uint32_t serial) {
GetUserDataAs<WaylandToplevel>(resource)->Move();
}
void xdg_toplevel_v6_resize(wl_client* client,
wl_resource* resource,
wl_resource* seat,
uint32_t serial,
uint32_t edges) {
GetUserDataAs<WaylandToplevel>(resource)->Resize(
XdgToplevelV6ResizeComponent(edges));
}
void xdg_toplevel_v6_set_max_size(wl_client* client,
wl_resource* resource,
int32_t width,
int32_t height) {
GetUserDataAs<WaylandToplevel>(resource)->SetMaximumSize(
gfx::Size(width, height));
}
void xdg_toplevel_v6_set_min_size(wl_client* client,
wl_resource* resource,
int32_t width,
int32_t height) {
GetUserDataAs<WaylandToplevel>(resource)->SetMinimumSize(
gfx::Size(width, height));
}
void xdg_toplevel_v6_set_maximized(wl_client* client, wl_resource* resource) {
GetUserDataAs<WaylandToplevel>(resource)->Maximize();
}
void xdg_toplevel_v6_unset_maximized(wl_client* client, wl_resource* resource) {
GetUserDataAs<WaylandToplevel>(resource)->Restore();
}
void xdg_toplevel_v6_set_fullscreen(wl_client* client,
wl_resource* resource,
wl_resource* output) {
GetUserDataAs<WaylandToplevel>(resource)->SetFullscreen(true);
}
void xdg_toplevel_v6_unset_fullscreen(wl_client* client,
wl_resource* resource) {
GetUserDataAs<WaylandToplevel>(resource)->SetFullscreen(false);
}
void xdg_toplevel_v6_set_minimized(wl_client* client, wl_resource* resource) {
GetUserDataAs<WaylandToplevel>(resource)->Minimize();
}
const struct zxdg_toplevel_v6_interface xdg_toplevel_v6_implementation = {
xdg_toplevel_v6_destroy, xdg_toplevel_v6_set_parent,
xdg_toplevel_v6_set_title, xdg_toplevel_v6_set_app_id,
xdg_toplevel_v6_show_window_menu, xdg_toplevel_v6_move,
xdg_toplevel_v6_resize, xdg_toplevel_v6_set_max_size,
xdg_toplevel_v6_set_min_size, xdg_toplevel_v6_set_maximized,
xdg_toplevel_v6_unset_maximized, xdg_toplevel_v6_set_fullscreen,
xdg_toplevel_v6_unset_fullscreen, xdg_toplevel_v6_set_minimized};
////////////////////////////////////////////////////////////////////////////////
// xdg_popup_interface:
// Wrapper around shell surface that allows us to handle the case where the
// xdg surface resource is destroyed before the popup resource.
class WaylandPopup {
public:
WaylandPopup(wl_resource* resource, wl_resource* surface_resource)
: resource_(resource), weak_ptr_factory_(this) {
ShellSurface* shell_surface = GetUserDataAs<ShellSurface>(surface_resource);
shell_surface->set_close_callback(
base::Bind(&WaylandPopup::OnClose, weak_ptr_factory_.GetWeakPtr()));
shell_surface->set_configure_callback(
base::Bind(&HandleXdgSurfaceV6ConfigureCallback, surface_resource,
base::Bind(&WaylandPopup::OnConfigure,
weak_ptr_factory_.GetWeakPtr())));
}
private:
void OnClose() {
zxdg_popup_v6_send_popup_done(resource_);
wl_client_flush(wl_resource_get_client(resource_));
}
void OnConfigure(const gfx::Size& size,
ash::mojom::WindowStateType state_type,
bool resizing,
bool activated) {
// Nothing to do here as popups don't have additional configure state.
}
wl_resource* const resource_;
base::WeakPtrFactory<WaylandPopup> weak_ptr_factory_;
DISALLOW_COPY_AND_ASSIGN(WaylandPopup);
};
void xdg_popup_v6_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
void xdg_popup_v6_grab(wl_client* client,
wl_resource* resource,
wl_resource* seat,
uint32_t serial) {
NOTIMPLEMENTED();
}
const struct zxdg_popup_v6_interface xdg_popup_v6_implementation = {
xdg_popup_v6_destroy, xdg_popup_v6_grab};
////////////////////////////////////////////////////////////////////////////////
// xdg_surface_interface:
void xdg_surface_v6_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
void xdg_surface_v6_get_toplevel(wl_client* client,
wl_resource* resource,
uint32_t id) {
ShellSurface* shell_surface = GetUserDataAs<ShellSurface>(resource);
if (shell_surface->enabled()) {
wl_resource_post_error(resource, ZXDG_SURFACE_V6_ERROR_ALREADY_CONSTRUCTED,
"surface has already been constructed");
return;
}
shell_surface->SetCanMinimize(true);
shell_surface->SetEnabled(true);
wl_resource* xdg_toplevel_resource =
wl_resource_create(client, &zxdg_toplevel_v6_interface, 1, id);
SetImplementation(
xdg_toplevel_resource, &xdg_toplevel_v6_implementation,
std::make_unique<WaylandToplevel>(xdg_toplevel_resource, resource));
}
void xdg_surface_v6_get_popup(wl_client* client,
wl_resource* resource,
uint32_t id,
wl_resource* parent_resource,
wl_resource* positioner_resource) {
XdgShellSurface* shell_surface = GetUserDataAs<XdgShellSurface>(resource);
if (shell_surface->enabled()) {
wl_resource_post_error(resource, ZXDG_SURFACE_V6_ERROR_ALREADY_CONSTRUCTED,
"surface has already been constructed");
return;
}
ShellSurface* parent = GetUserDataAs<ShellSurface>(parent_resource);
if (!parent->GetWidget()) {
wl_resource_post_error(resource, ZXDG_SURFACE_V6_ERROR_NOT_CONSTRUCTED,
"popup parent not constructed");
return;
}
gfx::Point position = GetUserDataAs<WaylandPositioner>(positioner_resource)
->CalculatePosition();
// |position| is relative to the parent's contents view origin, and |origin|
// is in screen coordinates.
gfx::Point origin = position;
views::View::ConvertPointToScreen(
parent->GetWidget()->widget_delegate()->GetContentsView(), &origin);
shell_surface->SetOrigin(origin);
shell_surface->SetContainer(ash::kShellWindowId_MenuContainer);
shell_surface->DisableMovement();
shell_surface->SetActivatable(false);
shell_surface->SetCanMinimize(false);
shell_surface->SetEnabled(true);
wl_resource* xdg_popup_resource =
wl_resource_create(client, &zxdg_popup_v6_interface, 1, id);
SetImplementation(
xdg_popup_resource, &xdg_popup_v6_implementation,
std::make_unique<WaylandPopup>(xdg_popup_resource, resource));
}
void xdg_surface_v6_set_window_geometry(wl_client* client,
wl_resource* resource,
int32_t x,
int32_t y,
int32_t width,
int32_t height) {
GetUserDataAs<ShellSurface>(resource)->SetGeometry(
gfx::Rect(x, y, width, height));
}
void xdg_surface_v6_ack_configure(wl_client* client,
wl_resource* resource,
uint32_t serial) {
GetUserDataAs<ShellSurface>(resource)->AcknowledgeConfigure(serial);
}
const struct zxdg_surface_v6_interface xdg_surface_v6_implementation = {
xdg_surface_v6_destroy, xdg_surface_v6_get_toplevel,
xdg_surface_v6_get_popup, xdg_surface_v6_set_window_geometry,
xdg_surface_v6_ack_configure};
////////////////////////////////////////////////////////////////////////////////
// xdg_shell_interface:
void xdg_shell_v6_destroy(wl_client* client, wl_resource* resource) {
// Nothing to do here.
}
void xdg_shell_v6_create_positioner(wl_client* client,
wl_resource* resource,
uint32_t id) {
wl_resource* positioner_resource =
wl_resource_create(client, &zxdg_positioner_v6_interface, 1, id);
SetImplementation(positioner_resource, &xdg_positioner_v6_implementation,
std::make_unique<WaylandPositioner>());
}
void xdg_shell_v6_get_xdg_surface(wl_client* client,
wl_resource* resource,
uint32_t id,
wl_resource* surface) {
std::unique_ptr<ShellSurface> shell_surface =
GetUserDataAs<Display>(resource)->CreateXdgShellSurface(
GetUserDataAs<Surface>(surface));
if (!shell_surface) {
wl_resource_post_error(resource, ZXDG_SHELL_V6_ERROR_ROLE,
"surface has already been assigned a role");
return;
}
// Xdg shell v6 surfaces are initially disabled and needs to be explicitly
// mapped before they are enabled and can become visible.
shell_surface->SetEnabled(false);
wl_resource* xdg_surface_resource =
wl_resource_create(client, &zxdg_surface_v6_interface, 1, id);
SetImplementation(xdg_surface_resource, &xdg_surface_v6_implementation,
std::move(shell_surface));
}
void xdg_shell_v6_pong(wl_client* client,
wl_resource* resource,
uint32_t serial) {
NOTIMPLEMENTED();
}
const struct zxdg_shell_v6_interface xdg_shell_v6_implementation = {
xdg_shell_v6_destroy, xdg_shell_v6_create_positioner,
xdg_shell_v6_get_xdg_surface, xdg_shell_v6_pong};
void bind_xdg_shell_v6(wl_client* client,
void* data,
uint32_t version,
uint32_t id) {
wl_resource* resource =
wl_resource_create(client, &zxdg_shell_v6_interface, 1, id);
wl_resource_set_implementation(resource, &xdg_shell_v6_implementation, data,
nullptr);
}
////////////////////////////////////////////////////////////////////////////////
// remote_surface_interface:
SurfaceFrameType RemoteShellSurfaceFrameType(uint32_t frame_type) {
switch (frame_type) {
case ZCR_REMOTE_SURFACE_V1_FRAME_TYPE_NONE:
return SurfaceFrameType::NONE;
case ZCR_REMOTE_SURFACE_V1_FRAME_TYPE_NORMAL:
return SurfaceFrameType::NORMAL;
case ZCR_REMOTE_SURFACE_V1_FRAME_TYPE_SHADOW:
return SurfaceFrameType::SHADOW;
case ZCR_REMOTE_SURFACE_V1_FRAME_TYPE_AUTOHIDE:
return SurfaceFrameType::AUTOHIDE;
case ZCR_REMOTE_SURFACE_V1_FRAME_TYPE_OVERLAY:
return SurfaceFrameType::OVERLAY;
default:
VLOG(2) << "Unknown remote-shell frame type: " << frame_type;
return SurfaceFrameType::NONE;
}
}
void remote_surface_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
void remote_surface_set_app_id(wl_client* client,
wl_resource* resource,
const char* app_id) {
GetUserDataAs<ShellSurfaceBase>(resource)->SetApplicationId(app_id);
}
void remote_surface_set_window_geometry(wl_client* client,
wl_resource* resource,
int32_t x,
int32_t y,
int32_t width,
int32_t height) {
GetUserDataAs<ShellSurfaceBase>(resource)->SetGeometry(
gfx::Rect(x, y, width, height));
}
void remote_surface_set_orientation(wl_client* client,
wl_resource* resource,
int32_t orientation) {
GetUserDataAs<ClientControlledShellSurface>(resource)->SetOrientation(
orientation == ZCR_REMOTE_SURFACE_V1_ORIENTATION_PORTRAIT
? Orientation::PORTRAIT
: Orientation::LANDSCAPE);
}
void remote_surface_set_scale(wl_client* client,
wl_resource* resource,
wl_fixed_t scale) {
GetUserDataAs<ClientControlledShellSurface>(resource)->SetScale(
wl_fixed_to_double(scale));
}
void remote_surface_set_rectangular_shadow_DEPRECATED(wl_client* client,
wl_resource* resource,
int32_t x,
int32_t y,
int32_t width,
int32_t height) {
NOTIMPLEMENTED();
}
void remote_surface_set_rectangular_shadow_background_opacity_DEPRECATED(
wl_client* client,
wl_resource* resource,
wl_fixed_t opacity) {
NOTIMPLEMENTED();
}
void remote_surface_set_title(wl_client* client,
wl_resource* resource,
const char* title) {
GetUserDataAs<ShellSurfaceBase>(resource)->SetTitle(
base::string16(base::UTF8ToUTF16(title)));
}
void remote_surface_set_top_inset(wl_client* client,
wl_resource* resource,
int32_t height) {
GetUserDataAs<ClientControlledShellSurface>(resource)->SetTopInset(height);
}
void remote_surface_activate(wl_client* client,
wl_resource* resource,
uint32_t serial) {
ShellSurfaceBase* shell_surface = GetUserDataAs<ShellSurfaceBase>(resource);
shell_surface->Activate();
}
void remote_surface_maximize(wl_client* client, wl_resource* resource) {
GetUserDataAs<ClientControlledShellSurface>(resource)->SetMaximized();
}
void remote_surface_minimize(wl_client* client, wl_resource* resource) {
GetUserDataAs<ClientControlledShellSurface>(resource)->SetMinimized();
}
void remote_surface_restore(wl_client* client, wl_resource* resource) {
GetUserDataAs<ClientControlledShellSurface>(resource)->SetRestored();
}
void remote_surface_fullscreen(wl_client* client, wl_resource* resource) {
GetUserDataAs<ClientControlledShellSurface>(resource)->SetFullscreen(true);
}
void remote_surface_unfullscreen(wl_client* client, wl_resource* resource) {
GetUserDataAs<ClientControlledShellSurface>(resource)->SetFullscreen(false);
}
void remote_surface_pin(wl_client* client,
wl_resource* resource,
int32_t trusted) {
GetUserDataAs<ClientControlledShellSurface>(resource)->SetPinned(
trusted ? ash::mojom::WindowPinType::TRUSTED_PINNED
: ash::mojom::WindowPinType::PINNED);
}
void remote_surface_unpin(wl_client* client, wl_resource* resource) {
GetUserDataAs<ClientControlledShellSurface>(resource)->SetPinned(
ash::mojom::WindowPinType::NONE);
}
void remote_surface_set_system_modal(wl_client* client, wl_resource* resource) {
GetUserDataAs<ClientControlledShellSurface>(resource)->SetSystemModal(true);
}
void remote_surface_unset_system_modal(wl_client* client,
wl_resource* resource) {
GetUserDataAs<ClientControlledShellSurface>(resource)->SetSystemModal(false);
}
void remote_surface_set_rectangular_surface_shadow(wl_client* client,
wl_resource* resource,
int32_t x,
int32_t y,
int32_t width,
int32_t height) {
ClientControlledShellSurface* shell_surface =
GetUserDataAs<ClientControlledShellSurface>(resource);
shell_surface->SetShadowBounds(gfx::Rect(x, y, width, height));
}
void remote_surface_set_systemui_visibility(wl_client* client,
wl_resource* resource,
uint32_t visibility) {
GetUserDataAs<ClientControlledShellSurface>(resource)->SetSystemUiVisibility(
visibility != ZCR_REMOTE_SURFACE_V1_SYSTEMUI_VISIBILITY_STATE_VISIBLE);
}
void remote_surface_set_always_on_top(wl_client* client,
wl_resource* resource) {
GetUserDataAs<ClientControlledShellSurface>(resource)->SetAlwaysOnTop(true);
}
void remote_surface_unset_always_on_top(wl_client* client,
wl_resource* resource) {
GetUserDataAs<ClientControlledShellSurface>(resource)->SetAlwaysOnTop(false);
}
void remote_surface_ack_configure(wl_client* client,
wl_resource* resource,
uint32_t serial) {
GetUserDataAs<ShellSurfaceBase>(resource)->AcknowledgeConfigure(serial);
}
void remote_surface_move(wl_client* client, wl_resource* resource) {
GetUserDataAs<ClientControlledShellSurface>(resource)->Move();
}
void remote_surface_set_window_type(wl_client* client,
wl_resource* resource,
uint32_t type) {
if (type == ZCR_REMOTE_SURFACE_V1_WINDOW_TYPE_SYSTEM_UI) {
auto* widget = GetUserDataAs<ShellSurfaceBase>(resource)->GetWidget();
if (widget) {
widget->GetNativeWindow()->SetProperty(ash::kShowInOverviewKey, false);
wm::SetWindowVisibilityAnimationType(
widget->GetNativeWindow(), wm::WINDOW_VISIBILITY_ANIMATION_TYPE_FADE);
}
}
}
void remote_surface_resize(wl_client* client, wl_resource* resource) {
// DEPRECATED
}
void remote_surface_set_resize_outset(wl_client* client,
wl_resource* resource,
int32_t outset) {
GetUserDataAs<ClientControlledShellSurface>(resource)->SetResizeOutset(
outset);
}
void remote_surface_start_move(wl_client* client,
wl_resource* resource,
int32_t x,
int32_t y) {
GetUserDataAs<ClientControlledShellSurface>(resource)->StartDrag(
HTCAPTION, gfx::Point(x, y));
}
void remote_surface_set_can_maximize(wl_client* client, wl_resource* resource) {
GetUserDataAs<ClientControlledShellSurface>(resource)->SetCanMaximize(true);
}
void remote_surface_unset_can_maximize(wl_client* client,
wl_resource* resource) {
GetUserDataAs<ClientControlledShellSurface>(resource)->SetCanMaximize(false);
}
void remote_surface_set_min_size(wl_client* client,
wl_resource* resource,
int32_t width,
int32_t height) {
GetUserDataAs<ClientControlledShellSurface>(resource)->SetMinimumSize(
gfx::Size(width, height));
}
void remote_surface_set_max_size(wl_client* client,
wl_resource* resource,
int32_t width,
int32_t height) {
GetUserDataAs<ClientControlledShellSurface>(resource)->SetMaximumSize(
gfx::Size(width, height));
}
void remote_surface_set_snapped_to_left(wl_client* client,
wl_resource* resource) {
GetUserDataAs<ClientControlledShellSurface>(resource)->SetSnappedToLeft();
}
void remote_surface_set_snapped_to_right(wl_client* client,
wl_resource* resource) {
GetUserDataAs<ClientControlledShellSurface>(resource)->SetSnappedToRight();
}
void remote_surface_start_resize(wl_client* client,
wl_resource* resource,
uint32_t direction,
int32_t x,
int32_t y) {
GetUserDataAs<ClientControlledShellSurface>(resource)->StartDrag(
Component(direction), gfx::Point(x, y));
}
void remote_surface_set_frame(wl_client* client,
wl_resource* resource,
uint32_t type) {
ClientControlledShellSurface* shell_surface =
GetUserDataAs<ClientControlledShellSurface>(resource);
shell_surface->root_surface()->SetFrame(RemoteShellSurfaceFrameType(type));
}
void remote_surface_set_frame_buttons(wl_client* client,
wl_resource* resource,
uint32_t visible_button_mask,
uint32_t enabled_button_mask) {
GetUserDataAs<ClientControlledShellSurface>(resource)->SetFrameButtons(
CaptionButtonMask(visible_button_mask),
CaptionButtonMask(enabled_button_mask));
}
void remote_surface_set_extra_title(wl_client* client,
wl_resource* resource,
const char* extra_title) {
GetUserDataAs<ClientControlledShellSurface>(resource)->SetExtraTitle(
base::string16(base::UTF8ToUTF16(extra_title)));
}
ash::OrientationLockType OrientationLock(uint32_t orientation_lock) {
switch (orientation_lock) {
case ZCR_REMOTE_SURFACE_V1_ORIENTATION_LOCK_NONE:
return ash::OrientationLockType::kAny;
case ZCR_REMOTE_SURFACE_V1_ORIENTATION_LOCK_CURRENT:
return ash::OrientationLockType::kCurrent;
case ZCR_REMOTE_SURFACE_V1_ORIENTATION_LOCK_PORTRAIT:
return ash::OrientationLockType::kPortrait;
case ZCR_REMOTE_SURFACE_V1_ORIENTATION_LOCK_LANDSCAPE:
return ash::OrientationLockType::kLandscape;
case ZCR_REMOTE_SURFACE_V1_ORIENTATION_LOCK_PORTRAIT_PRIMARY:
return ash::OrientationLockType::kPortraitPrimary;
case ZCR_REMOTE_SURFACE_V1_ORIENTATION_LOCK_PORTRAIT_SECONDARY:
return ash::OrientationLockType::kPortraitSecondary;
case ZCR_REMOTE_SURFACE_V1_ORIENTATION_LOCK_LANDSCAPE_PRIMARY:
return ash::OrientationLockType::kLandscapePrimary;
case ZCR_REMOTE_SURFACE_V1_ORIENTATION_LOCK_LANDSCAPE_SECONDARY:
return ash::OrientationLockType::kLandscapeSecondary;
}
VLOG(2) << "Unexpected value of orientation_lock: " << orientation_lock;
return ash::OrientationLockType::kAny;
}
void remote_surface_set_orientation_lock(wl_client* client,
wl_resource* resource,
uint32_t orientation_lock) {
GetUserDataAs<ClientControlledShellSurface>(resource)->SetOrientationLock(
OrientationLock(orientation_lock));
}
void remote_surface_pip(wl_client* client, wl_resource* resource) {
GetUserDataAs<ClientControlledShellSurface>(resource)->SetPip();
}
const struct zcr_remote_surface_v1_interface remote_surface_implementation = {
remote_surface_destroy,
remote_surface_set_app_id,
remote_surface_set_window_geometry,
remote_surface_set_scale,
remote_surface_set_rectangular_shadow_DEPRECATED,
remote_surface_set_rectangular_shadow_background_opacity_DEPRECATED,
remote_surface_set_title,
remote_surface_set_top_inset,
remote_surface_activate,
remote_surface_maximize,
remote_surface_minimize,
remote_surface_restore,
remote_surface_fullscreen,
remote_surface_unfullscreen,
remote_surface_pin,
remote_surface_unpin,
remote_surface_set_system_modal,
remote_surface_unset_system_modal,
remote_surface_set_rectangular_surface_shadow,
remote_surface_set_systemui_visibility,
remote_surface_set_always_on_top,
remote_surface_unset_always_on_top,
remote_surface_ack_configure,
remote_surface_move,
remote_surface_set_orientation,
remote_surface_set_window_type,
remote_surface_resize,
remote_surface_set_resize_outset,
remote_surface_start_move,
remote_surface_set_can_maximize,
remote_surface_unset_can_maximize,
remote_surface_set_min_size,
remote_surface_set_max_size,
remote_surface_set_snapped_to_left,
remote_surface_set_snapped_to_right,
remote_surface_start_resize,
remote_surface_set_frame,
remote_surface_set_frame_buttons,
remote_surface_set_extra_title,
remote_surface_set_orientation_lock,
remote_surface_pip};
////////////////////////////////////////////////////////////////////////////////
// notification_surface_interface:
void notification_surface_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
void notification_surface_set_app_id(wl_client* client,
wl_resource* resource,
const char* app_id) {
GetUserDataAs<NotificationSurface>(resource)->SetApplicationId(app_id);
}
const struct zcr_notification_surface_v1_interface
notification_surface_implementation = {notification_surface_destroy,
notification_surface_set_app_id};
////////////////////////////////////////////////////////////////////////////////
// remote_shell_interface:
// Implements remote shell interface and monitors workspace state needed
// for the remote shell interface.
class WaylandRemoteShell : public ash::TabletModeObserver,
public wm::ActivationChangeObserver,
public display::DisplayObserver {
public:
WaylandRemoteShell(Display* display, wl_resource* remote_shell_resource)
: display_(display),
remote_shell_resource_(remote_shell_resource),
weak_ptr_factory_(this) {
auto* helper = WMHelper::GetInstance();
helper->AddTabletModeObserver(this);
helper->AddActivationObserver(this);
display::Screen::GetScreen()->AddObserver(this);
layout_mode_ = helper->IsTabletModeWindowManagerEnabled()
? ZCR_REMOTE_SHELL_V1_LAYOUT_MODE_TABLET
: ZCR_REMOTE_SHELL_V1_LAYOUT_MODE_WINDOWED;
if (wl_resource_get_version(remote_shell_resource_) >= 8) {
double scale_factor = GetDefaultDeviceScaleFactor();
// Send using 16.16 fixed point.
const int kDecimalBits = 24;
int32_t fixed_scale =
static_cast<int32_t>(scale_factor * (1 << kDecimalBits));
zcr_remote_shell_v1_send_default_device_scale_factor(
remote_shell_resource_, fixed_scale);
}
SendDisplayMetrics();
SendActivated(helper->GetActiveWindow(), nullptr);
}
~WaylandRemoteShell() override {
auto* helper = WMHelper::GetInstance();
helper->RemoveTabletModeObserver(this);
helper->RemoveActivationObserver(this);
display::Screen::GetScreen()->RemoveObserver(this);
}
bool HasRelativeSurfaceHierarchy() const {
return wl_resource_get_version(remote_shell_resource_) >= 9;
}
std::unique_ptr<ClientControlledShellSurface> CreateShellSurface(
Surface* surface,
int container,
double default_device_scale_factor) {
return display_->CreateClientControlledShellSurface(
surface, container, default_device_scale_factor);
}
std::unique_ptr<NotificationSurface> CreateNotificationSurface(
Surface* surface,
const std::string& notification_key) {
return display_->CreateNotificationSurface(surface, notification_key);
}
// Overridden from display::DisplayObserver:
void OnDisplayAdded(const display::Display& new_display) override {
ScheduleSendDisplayMetrics(0);
}
void OnDisplayRemoved(const display::Display& old_display) override {
ScheduleSendDisplayMetrics(0);
}
void OnDisplayMetricsChanged(const display::Display& display,
uint32_t changed_metrics) override {
// No need to update when a primary display has changed without bounds
// change. See WaylandDisplayObserver::OnDisplayMetricsChanged
// for more details.
if (changed_metrics &
(DISPLAY_METRIC_BOUNDS | DISPLAY_METRIC_DEVICE_SCALE_FACTOR |
DISPLAY_METRIC_ROTATION | DISPLAY_METRIC_WORK_AREA)) {
ScheduleSendDisplayMetrics(0);
}
}
// Overridden from ash::TabletModeObserver:
void OnTabletModeStarted() override {
layout_mode_ = ZCR_REMOTE_SHELL_V1_LAYOUT_MODE_TABLET;
ScheduleSendDisplayMetrics(kConfigureDelayAfterLayoutSwitchMs);
}
void OnTabletModeEnding() override {
layout_mode_ = ZCR_REMOTE_SHELL_V1_LAYOUT_MODE_WINDOWED;
ScheduleSendDisplayMetrics(kConfigureDelayAfterLayoutSwitchMs);
}
void OnTabletModeEnded() override {}
// Overridden from wm::ActivationChangeObserver:
void OnWindowActivated(ActivationReason reason,
aura::Window* gained_active,
aura::Window* lost_active) override {
SendActivated(gained_active, lost_active);
}
private:
void ScheduleSendDisplayMetrics(int delay_ms) {
needs_send_display_metrics_ = true;
base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
FROM_HERE, base::Bind(&WaylandRemoteShell::SendDisplayMetrics,
weak_ptr_factory_.GetWeakPtr()),
base::TimeDelta::FromMilliseconds(delay_ms));
}
// Returns the transform that a display's output is currently adjusted for.
wl_output_transform DisplayTransform(display::Display::Rotation rotation) {
switch (rotation) {
case display::Display::ROTATE_0:
return WL_OUTPUT_TRANSFORM_NORMAL;
case display::Display::ROTATE_90:
return WL_OUTPUT_TRANSFORM_90;
case display::Display::ROTATE_180:
return WL_OUTPUT_TRANSFORM_180;
case display::Display::ROTATE_270:
return WL_OUTPUT_TRANSFORM_270;
}
NOTREACHED();
return WL_OUTPUT_TRANSFORM_NORMAL;
}
void SendDisplayMetrics() {
if (!needs_send_display_metrics_)
return;
needs_send_display_metrics_ = false;
const display::Screen* screen = display::Screen::GetScreen();
for (const auto& display : screen->GetAllDisplays()) {
const gfx::Rect& bounds = display.bounds();
const gfx::Insets& insets = display.GetWorkAreaInsets();
double device_scale_factor = WMHelper::GetInstance()
->GetDisplayInfo(display.id())
.device_scale_factor();
zcr_remote_shell_v1_send_workspace(
remote_shell_resource_, static_cast<uint32_t>(display.id() >> 32),
static_cast<uint32_t>(display.id()), bounds.x(), bounds.y(),
bounds.width(), bounds.height(), insets.left(), insets.top(),
insets.right(), insets.bottom(), DisplayTransform(display.rotation()),
wl_fixed_from_double(device_scale_factor), display.IsInternal());
}
zcr_remote_shell_v1_send_configure(remote_shell_resource_, layout_mode_);
wl_client_flush(wl_resource_get_client(remote_shell_resource_));
}
void SendActivated(aura::Window* gained_active, aura::Window* lost_active) {
Surface* gained_active_surface =
gained_active ? ShellSurface::GetMainSurface(gained_active) : nullptr;
Surface* lost_active_surface =
lost_active ? ShellSurface::GetMainSurface(lost_active) : nullptr;
wl_resource* gained_active_surface_resource =
gained_active_surface ? GetSurfaceResource(gained_active_surface)
: nullptr;
wl_resource* lost_active_surface_resource =
lost_active_surface ? GetSurfaceResource(lost_active_surface) : nullptr;
wl_client* client = wl_resource_get_client(remote_shell_resource_);
// If surface that gained active is not owned by remote shell client then
// set it to null.
if (gained_active_surface_resource &&
wl_resource_get_client(gained_active_surface_resource) != client) {
gained_active_surface_resource = nullptr;
}
// If surface that lost active is not owned by remote shell client then
// set it to null.
if (lost_active_surface_resource &&
wl_resource_get_client(lost_active_surface_resource) != client) {
lost_active_surface_resource = nullptr;
}
zcr_remote_shell_v1_send_activated(remote_shell_resource_,
gained_active_surface_resource,
lost_active_surface_resource);
wl_client_flush(client);
}
// The exo display instance. Not owned.
Display* const display_;
// The remote shell resource associated with observer.
wl_resource* const remote_shell_resource_;
bool needs_send_display_metrics_ = true;
int layout_mode_ = ZCR_REMOTE_SHELL_V1_LAYOUT_MODE_WINDOWED;
base::WeakPtrFactory<WaylandRemoteShell> weak_ptr_factory_;
DISALLOW_COPY_AND_ASSIGN(WaylandRemoteShell);
};
void remote_shell_destroy(wl_client* client, wl_resource* resource) {
// Nothing to do here.
}
int RemoteSurfaceContainer(uint32_t container) {
switch (container) {
case ZCR_REMOTE_SHELL_V1_CONTAINER_DEFAULT:
return ash::kShellWindowId_DefaultContainer;
case ZCR_REMOTE_SHELL_V1_CONTAINER_OVERLAY:
return ash::kShellWindowId_SystemModalContainer;
default:
DLOG(WARNING) << "Unsupported container: " << container;
return ash::kShellWindowId_DefaultContainer;
}
}
void HandleRemoteSurfaceCloseCallback(wl_resource* resource) {
zcr_remote_surface_v1_send_close(resource);
wl_client_flush(wl_resource_get_client(resource));
}
void HandleRemoteSurfaceStateChangedCallback(
wl_resource* resource,
ash::mojom::WindowStateType old_state_type,
ash::mojom::WindowStateType new_state_type) {
DCHECK_NE(old_state_type, new_state_type);
uint32_t state_type = ZCR_REMOTE_SHELL_V1_STATE_TYPE_NORMAL;
switch (new_state_type) {
case ash::mojom::WindowStateType::MINIMIZED:
state_type = ZCR_REMOTE_SHELL_V1_STATE_TYPE_MINIMIZED;
break;
case ash::mojom::WindowStateType::MAXIMIZED:
state_type = ZCR_REMOTE_SHELL_V1_STATE_TYPE_MAXIMIZED;
break;
case ash::mojom::WindowStateType::FULLSCREEN:
state_type = ZCR_REMOTE_SHELL_V1_STATE_TYPE_FULLSCREEN;
break;
case ash::mojom::WindowStateType::PINNED:
state_type = ZCR_REMOTE_SHELL_V1_STATE_TYPE_PINNED;
break;
case ash::mojom::WindowStateType::TRUSTED_PINNED:
state_type = ZCR_REMOTE_SHELL_V1_STATE_TYPE_TRUSTED_PINNED;
break;
case ash::mojom::WindowStateType::LEFT_SNAPPED:
state_type = ZCR_REMOTE_SHELL_V1_STATE_TYPE_LEFT_SNAPPED;
break;
case ash::mojom::WindowStateType::RIGHT_SNAPPED:
state_type = ZCR_REMOTE_SHELL_V1_STATE_TYPE_RIGHT_SNAPPED;
break;
case ash::mojom::WindowStateType::PIP:
state_type = ZCR_REMOTE_SHELL_V1_STATE_TYPE_PIP;
break;
default:
break;
}
zcr_remote_surface_v1_send_state_type_changed(resource, state_type);
wl_client_flush(wl_resource_get_client(resource));
}
void HandleRemoteSurfaceBoundsChangedCallback(
wl_resource* resource,
ash::mojom::WindowStateType current_state,
ash::mojom::WindowStateType requested_state,
int64_t display_id,
const gfx::Rect& bounds,
bool resize,
int bounds_change) {
zcr_remote_surface_v1_bounds_change_reason reason =
resize ? ZCR_REMOTE_SURFACE_V1_BOUNDS_CHANGE_REASON_RESIZE
: ZCR_REMOTE_SURFACE_V1_BOUNDS_CHANGE_REASON_MOVE;
if (bounds_change & ash::WindowResizer::kBoundsChange_Resizes) {
reason = ZCR_REMOTE_SURFACE_V1_BOUNDS_CHANGE_REASON_DRAG_RESIZE;
} else if (bounds_change & ash::WindowResizer::kBoundsChange_Repositions) {
reason = ZCR_REMOTE_SURFACE_V1_BOUNDS_CHANGE_REASON_DRAG_MOVE;
} else if (requested_state == ash::mojom::WindowStateType::LEFT_SNAPPED) {
reason = ZCR_REMOTE_SURFACE_V1_BOUNDS_CHANGE_REASON_SNAP_TO_LEFT;
} else if (requested_state == ash::mojom::WindowStateType::RIGHT_SNAPPED) {
reason = ZCR_REMOTE_SURFACE_V1_BOUNDS_CHANGE_REASON_SNAP_TO_RIGHT;
}
zcr_remote_surface_v1_send_bounds_changed(
resource, static_cast<uint32_t>(display_id >> 32),
static_cast<uint32_t>(display_id), bounds.x(), bounds.y(), bounds.width(),
bounds.height(), reason);
wl_client_flush(wl_resource_get_client(resource));
}
void HandleRemoteSurfaceDragStartedCallback(wl_resource* resource,
int component) {
zcr_remote_surface_v1_send_drag_started(resource, ResizeDirection(component));
wl_client_flush(wl_resource_get_client(resource));
}
void HandleRemoteSurfaceDragFinishedCallback(wl_resource* resource,
int x,
int y,
bool canceled) {
zcr_remote_surface_v1_send_drag_finished(resource, x, y, canceled ? 1 : 0);
wl_client_flush(wl_resource_get_client(resource));
}
uint32_t HandleRemoteSurfaceConfigureCallback(
wl_resource* resource,
const gfx::Size& size,
ash::mojom::WindowStateType state_type,
bool resizing,
bool activated,
const gfx::Vector2d& origin_offset) {
wl_array states;
wl_array_init(&states);
uint32_t serial = wl_display_next_serial(
wl_client_get_display(wl_resource_get_client(resource)));
zcr_remote_surface_v1_send_configure(resource,
origin_offset.x(),
origin_offset.y(),
&states, serial);
wl_client_flush(wl_resource_get_client(resource));
wl_array_release(&states);
return serial;
}
void HandleRemoteSurfaceGeometryChangedCallback(wl_resource* resource,
const gfx::Rect& geometry) {
zcr_remote_surface_v1_send_window_geometry_changed(
resource, geometry.x(), geometry.y(), geometry.width(),
geometry.height());
wl_client_flush(wl_resource_get_client(resource));
}
void remote_shell_get_remote_surface(wl_client* client,
wl_resource* resource,
uint32_t id,
wl_resource* surface,
uint32_t container) {
WaylandRemoteShell* shell = GetUserDataAs<WaylandRemoteShell>(resource);
double default_scale_factor = wl_resource_get_version(resource) >= 8
? GetDefaultDeviceScaleFactor()
: 1.0;
std::unique_ptr<ClientControlledShellSurface> shell_surface =
shell->CreateShellSurface(GetUserDataAs<Surface>(surface),
RemoteSurfaceContainer(container),
default_scale_factor);
if (!shell_surface) {
wl_resource_post_error(resource, ZCR_REMOTE_SHELL_V1_ERROR_ROLE,
"surface has already been assigned a role");
return;
}
wl_resource* remote_surface_resource =
wl_resource_create(client, &zcr_remote_surface_v1_interface,
wl_resource_get_version(resource), id);
shell_surface->set_close_callback(
base::Bind(&HandleRemoteSurfaceCloseCallback,
base::Unretained(remote_surface_resource)));
shell_surface->set_state_changed_callback(
base::Bind(&HandleRemoteSurfaceStateChangedCallback,
base::Unretained(remote_surface_resource)));
shell_surface->set_configure_callback(
base::Bind(&HandleRemoteSurfaceConfigureCallback,
base::Unretained(remote_surface_resource)));
if (shell->HasRelativeSurfaceHierarchy()) {
shell_surface->set_geometry_changed_callback(
base::BindRepeating(&HandleRemoteSurfaceGeometryChangedCallback,
base::Unretained(remote_surface_resource)));
}
if (wl_resource_get_version(remote_surface_resource) >= 10) {
shell_surface->set_client_controlled_move_resize(false);
shell_surface->set_bounds_changed_callback(
base::BindRepeating(&HandleRemoteSurfaceBoundsChangedCallback,
base::Unretained(remote_surface_resource)));
shell_surface->set_drag_started_callback(
base::BindRepeating(&HandleRemoteSurfaceDragStartedCallback,
base::Unretained(remote_surface_resource)));
shell_surface->set_drag_finished_callback(
base::BindRepeating(&HandleRemoteSurfaceDragFinishedCallback,
base::Unretained(remote_surface_resource)));
}
SetImplementation(remote_surface_resource, &remote_surface_implementation,
std::move(shell_surface));
}
void remote_shell_get_notification_surface(wl_client* client,
wl_resource* resource,
uint32_t id,
wl_resource* surface,
const char* notification_key) {
if (GetUserDataAs<Surface>(surface)->HasSurfaceDelegate()) {
wl_resource_post_error(resource, ZCR_REMOTE_SHELL_V1_ERROR_ROLE,
"surface has already been assigned a role");
return;
}
std::unique_ptr<NotificationSurface> notification_surface =
GetUserDataAs<WaylandRemoteShell>(resource)->CreateNotificationSurface(
GetUserDataAs<Surface>(surface), std::string(notification_key));
if (!notification_surface) {
wl_resource_post_error(resource,
ZCR_REMOTE_SHELL_V1_ERROR_INVALID_NOTIFICATION_KEY,
"invalid notification key");
return;
}
wl_resource* notification_surface_resource =
wl_resource_create(client, &zcr_notification_surface_v1_interface,
wl_resource_get_version(resource), id);
SetImplementation(notification_surface_resource,
¬ification_surface_implementation,
std::move(notification_surface));
}
const struct zcr_remote_shell_v1_interface remote_shell_implementation = {
remote_shell_destroy, remote_shell_get_remote_surface,
remote_shell_get_notification_surface};
const uint32_t remote_shell_version = 16;
void bind_remote_shell(wl_client* client,
void* data,
uint32_t version,
uint32_t id) {
wl_resource* resource =
wl_resource_create(client, &zcr_remote_shell_v1_interface,
std::min(version, remote_shell_version), id);
SetImplementation(resource, &remote_shell_implementation,
std::make_unique<WaylandRemoteShell>(
static_cast<Display*>(data), resource));
}
////////////////////////////////////////////////////////////////////////////////
// aura_surface_interface:
class AuraSurface : public SurfaceObserver {
public:
explicit AuraSurface(Surface* surface) : surface_(surface) {
surface_->AddSurfaceObserver(this);
surface_->SetProperty(kSurfaceHasAuraSurfaceKey, true);
}
~AuraSurface() override {
if (surface_) {
surface_->RemoveSurfaceObserver(this);
surface_->SetProperty(kSurfaceHasAuraSurfaceKey, false);
}
}
void SetFrame(SurfaceFrameType type) {
if (surface_)
surface_->SetFrame(type);
}
void SetFrameColors(SkColor active_frame_color,
SkColor inactive_frame_color) {
if (surface_)
surface_->SetFrameColors(active_frame_color, inactive_frame_color);
}
void SetParent(AuraSurface* parent, const gfx::Point& position) {
if (surface_)
surface_->SetParent(parent ? parent->surface_ : nullptr, position);
}
void SetStartupId(const char* startup_id) {
if (surface_)
surface_->SetStartupId(startup_id);
}
void SetApplicationId(const char* application_id) {
if (surface_)
surface_->SetApplicationId(application_id);
}
// Overridden from SurfaceObserver:
void OnSurfaceDestroying(Surface* surface) override {
surface->RemoveSurfaceObserver(this);
surface_ = nullptr;
}
private:
Surface* surface_;
DISALLOW_COPY_AND_ASSIGN(AuraSurface);
};
SurfaceFrameType AuraSurfaceFrameType(uint32_t frame_type) {
switch (frame_type) {
case ZAURA_SURFACE_FRAME_TYPE_NONE:
return SurfaceFrameType::NONE;
case ZAURA_SURFACE_FRAME_TYPE_NORMAL:
return SurfaceFrameType::NORMAL;
case ZAURA_SURFACE_FRAME_TYPE_SHADOW:
return SurfaceFrameType::SHADOW;
default:
VLOG(2) << "Unkonwn aura-shell frame type: " << frame_type;
return SurfaceFrameType::NONE;
}
}
void aura_surface_set_frame(wl_client* client, wl_resource* resource,
uint32_t type) {
GetUserDataAs<AuraSurface>(resource)->SetFrame(AuraSurfaceFrameType(type));
}
void aura_surface_set_parent(wl_client* client,
wl_resource* resource,
wl_resource* parent_resource,
int32_t x,
int32_t y) {
GetUserDataAs<AuraSurface>(resource)->SetParent(
parent_resource ? GetUserDataAs<AuraSurface>(parent_resource) : nullptr,
gfx::Point(x, y));
}
void aura_surface_set_frame_colors(wl_client* client,
wl_resource* resource,
uint32_t active_color,
uint32_t inactive_color) {
GetUserDataAs<AuraSurface>(resource)->SetFrameColors(active_color,
inactive_color);
}
void aura_surface_set_startup_id(wl_client* client,
wl_resource* resource,
const char* startup_id) {
GetUserDataAs<AuraSurface>(resource)->SetStartupId(startup_id);
}
void aura_surface_set_application_id(wl_client* client,
wl_resource* resource,
const char* application_id) {
GetUserDataAs<AuraSurface>(resource)->SetApplicationId(application_id);
}
const struct zaura_surface_interface aura_surface_implementation = {
aura_surface_set_frame, aura_surface_set_parent,
aura_surface_set_frame_colors, aura_surface_set_startup_id,
aura_surface_set_application_id};
////////////////////////////////////////////////////////////////////////////////
// aura_output_interface:
class AuraOutput : public WaylandDisplayObserver::ScaleObserver {
public:
explicit AuraOutput(wl_resource* resource) : resource_(resource) {}
// Overridden from WaylandDisplayObserver::ScaleObserver:
void OnDisplayScalesChanged(const display::Display& display) override {
display::DisplayManager* display_manager =
ash::Shell::Get()->display_manager();
const display::ManagedDisplayInfo& display_info =
display_manager->GetDisplayInfo(display.id());
if (wl_resource_get_version(resource_) >=
ZAURA_OUTPUT_SCALE_SINCE_VERSION) {
if (features::IsDisplayZoomSettingEnabled()) {
display::ManagedDisplayMode active_mode;
bool rv = display_manager->GetActiveModeForDisplayId(display.id(),
&active_mode);
DCHECK(rv);
const int32_t current_output_scale =
std::round(display_info.zoom_factor() * 1000.f);
for (double zoom_factor : display::GetDisplayZoomFactors(active_mode)) {
int32_t output_scale = std::round(zoom_factor * 1000.0);
uint32_t flags = 0;
if (output_scale == 1000)
flags |= ZAURA_OUTPUT_SCALE_PROPERTY_PREFERRED;
if (current_output_scale == output_scale)
flags |= ZAURA_OUTPUT_SCALE_PROPERTY_CURRENT;
// TODO(malaykeshav): This can be removed in the future when client
// has been updated.
if (wl_resource_get_version(resource_) < 6)
output_scale = std::round(1000.0 / zoom_factor);
zaura_output_send_scale(resource_, flags, output_scale);
}
} else if (display_manager->GetDisplayIdForUIScaling() == display.id()) {
display::ManagedDisplayMode active_mode;
bool rv = display_manager->GetActiveModeForDisplayId(display.id(),
&active_mode);
DCHECK(rv);
for (auto& mode : display_info.display_modes()) {
uint32_t flags = 0;
if (mode.is_default())
flags |= ZAURA_OUTPUT_SCALE_PROPERTY_PREFERRED;
if (active_mode.IsEquivalent(mode))
flags |= ZAURA_OUTPUT_SCALE_PROPERTY_CURRENT;
int32_t output_scale = std::round(mode.ui_scale() * 1000.f);
// TODO(malaykeshav): This can be removed in the future when client
// has been updated.
if (wl_resource_get_version(resource_) >= 6)
output_scale = std::round(1000.f / mode.ui_scale());
zaura_output_send_scale(resource_, flags, output_scale);
}
} else {
zaura_output_send_scale(resource_,
ZAURA_OUTPUT_SCALE_PROPERTY_CURRENT |
ZAURA_OUTPUT_SCALE_PROPERTY_PREFERRED,
ZAURA_OUTPUT_SCALE_FACTOR_1000);
}
}
if (wl_resource_get_version(resource_) >=
ZAURA_OUTPUT_CONNECTION_SINCE_VERSION) {
zaura_output_send_connection(resource_,
display.IsInternal()
? ZAURA_OUTPUT_CONNECTION_TYPE_INTERNAL
: ZAURA_OUTPUT_CONNECTION_TYPE_UNKNOWN);
}
if (wl_resource_get_version(resource_) >=
ZAURA_OUTPUT_DEVICE_SCALE_FACTOR_SINCE_VERSION) {
zaura_output_send_device_scale_factor(resource_,
display_info.device_scale_factor() *
1000);
}
}
private:
wl_resource* const resource_;
DISALLOW_COPY_AND_ASSIGN(AuraOutput);
};
////////////////////////////////////////////////////////////////////////////////
// aura_shell_interface:
void aura_shell_get_aura_surface(wl_client* client,
wl_resource* resource,
uint32_t id,
wl_resource* surface_resource) {
Surface* surface = GetUserDataAs<Surface>(surface_resource);
if (surface->GetProperty(kSurfaceHasAuraSurfaceKey)) {
wl_resource_post_error(
resource,
ZAURA_SHELL_ERROR_AURA_SURFACE_EXISTS,
"an aura surface object for that surface already exists");
return;
}
wl_resource* aura_surface_resource = wl_resource_create(
client, &zaura_surface_interface, wl_resource_get_version(resource), id);
SetImplementation(aura_surface_resource, &aura_surface_implementation,
std::make_unique<AuraSurface>(surface));
}
void aura_shell_get_aura_output(wl_client* client,
wl_resource* resource,
uint32_t id,
wl_resource* output_resource) {
WaylandDisplayObserver* display_observer =
GetUserDataAs<WaylandDisplayObserver>(output_resource);
if (display_observer->HasScaleObserver()) {
wl_resource_post_error(
resource, ZAURA_SHELL_ERROR_AURA_OUTPUT_EXISTS,
"an aura output object for that output already exists");
return;
}
wl_resource* aura_output_resource = wl_resource_create(
client, &zaura_output_interface, wl_resource_get_version(resource), id);
auto aura_output = std::make_unique<AuraOutput>(aura_output_resource);
display_observer->SetScaleObserver(aura_output->AsWeakPtr());
SetImplementation(aura_output_resource, nullptr, std::move(aura_output));
}
const struct zaura_shell_interface aura_shell_implementation = {
aura_shell_get_aura_surface, aura_shell_get_aura_output};
const uint32_t aura_shell_version = 6;
void bind_aura_shell(wl_client* client,
void* data,
uint32_t version,
uint32_t id) {
wl_resource* resource =
wl_resource_create(client, &zaura_shell_interface,
std::min(version, aura_shell_version), id);
wl_resource_set_implementation(resource, &aura_shell_implementation,
nullptr, nullptr);
}
////////////////////////////////////////////////////////////////////////////////
// vsync_timing_interface:
// Implements VSync timing interface by monitoring updates to VSync parameters.
class VSyncTiming final : public ui::CompositorVSyncManager::Observer {
public:
~VSyncTiming() override {
WMHelper::GetInstance()->RemoveVSyncObserver(this);
}
static std::unique_ptr<VSyncTiming> Create(wl_resource* timing_resource) {
std::unique_ptr<VSyncTiming> vsync_timing(new VSyncTiming(timing_resource));
// Note: AddObserver() will call OnUpdateVSyncParameters.
WMHelper::GetInstance()->AddVSyncObserver(vsync_timing.get());
return vsync_timing;
}
// Overridden from ui::CompositorVSyncManager::Observer:
void OnUpdateVSyncParameters(base::TimeTicks timebase,
base::TimeDelta interval) override {
uint64_t timebase_us = timebase.ToInternalValue();
uint64_t interval_us = interval.ToInternalValue();
// Ignore updates with interval 0.
if (!interval_us)
return;
uint64_t offset_us = timebase_us % interval_us;
// Avoid sending update events if interval did not change.
if (interval_us == last_interval_us_) {
int64_t offset_delta_us =
static_cast<int64_t>(last_offset_us_ - offset_us);
// Reduce the amount of events by only sending an update if the offset
// changed compared to the last offset sent to the client by this amount.
const int64_t kOffsetDeltaThresholdInMicroseconds = 25;
if (std::abs(offset_delta_us) < kOffsetDeltaThresholdInMicroseconds)
return;
}
zcr_vsync_timing_v1_send_update(timing_resource_, timebase_us & 0xffffffff,
timebase_us >> 32, interval_us & 0xffffffff,
interval_us >> 32);
wl_client_flush(wl_resource_get_client(timing_resource_));
last_interval_us_ = interval_us;
last_offset_us_ = offset_us;
}
private:
explicit VSyncTiming(wl_resource* timing_resource)
: timing_resource_(timing_resource) {}
// The VSync timing resource.
wl_resource* const timing_resource_;
uint64_t last_interval_us_{0};
uint64_t last_offset_us_{0};
DISALLOW_COPY_AND_ASSIGN(VSyncTiming);
};
void vsync_timing_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
const struct zcr_vsync_timing_v1_interface vsync_timing_implementation = {
vsync_timing_destroy};
////////////////////////////////////////////////////////////////////////////////
// vsync_feedback_interface:
void vsync_feedback_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
void vsync_feedback_get_vsync_timing(wl_client* client,
wl_resource* resource,
uint32_t id,
wl_resource* output) {
wl_resource* timing_resource =
wl_resource_create(client, &zcr_vsync_timing_v1_interface, 1, id);
SetImplementation(timing_resource, &vsync_timing_implementation,
VSyncTiming::Create(timing_resource));
}
const struct zcr_vsync_feedback_v1_interface vsync_feedback_implementation = {
vsync_feedback_destroy, vsync_feedback_get_vsync_timing};
void bind_vsync_feedback(wl_client* client,
void* data,
uint32_t version,
uint32_t id) {
wl_resource* resource =
wl_resource_create(client, &zcr_vsync_feedback_v1_interface, 1, id);
wl_resource_set_implementation(resource, &vsync_feedback_implementation,
nullptr, nullptr);
}
////////////////////////////////////////////////////////////////////////////////
// wl_data_source_interface:
class WaylandDataSourceDelegate : public DataSourceDelegate {
public:
explicit WaylandDataSourceDelegate(wl_resource* source)
: data_source_resource_(source) {}
// Overridden from DataSourceDelegate:
void OnDataSourceDestroying(DataSource* device) override { delete this; }
void OnTarget(const std::string& mime_type) override {
wl_data_source_send_target(data_source_resource_, mime_type.c_str());
wl_client_flush(wl_resource_get_client(data_source_resource_));
}
void OnSend(const std::string& mime_type, base::ScopedFD fd) override {
wl_data_source_send_send(data_source_resource_, mime_type.c_str(),
fd.get());
wl_client_flush(wl_resource_get_client(data_source_resource_));
}
void OnCancelled() override {
wl_data_source_send_cancelled(data_source_resource_);
wl_client_flush(wl_resource_get_client(data_source_resource_));
}
void OnDndDropPerformed() override {
if (wl_resource_get_version(data_source_resource_) >=
WL_DATA_SOURCE_DND_DROP_PERFORMED_SINCE_VERSION) {
wl_data_source_send_dnd_drop_performed(data_source_resource_);
wl_client_flush(wl_resource_get_client(data_source_resource_));
}
}
void OnDndFinished() override {
if (wl_resource_get_version(data_source_resource_) >=
WL_DATA_SOURCE_DND_FINISHED_SINCE_VERSION) {
wl_data_source_send_dnd_finished(data_source_resource_);
wl_client_flush(wl_resource_get_client(data_source_resource_));
}
}
void OnAction(DndAction dnd_action) override {
if (wl_resource_get_version(data_source_resource_) >=
WL_DATA_SOURCE_ACTION_SINCE_VERSION) {
wl_data_source_send_action(data_source_resource_,
WaylandDataDeviceManagerDndAction(dnd_action));
wl_client_flush(wl_resource_get_client(data_source_resource_));
}
}
private:
wl_resource* const data_source_resource_;
DISALLOW_COPY_AND_ASSIGN(WaylandDataSourceDelegate);
};
void data_source_offer(wl_client* client,
wl_resource* resource,
const char* mime_type) {
GetUserDataAs<DataSource>(resource)->Offer(mime_type);
}
void data_source_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
void data_source_set_actions(wl_client* client,
wl_resource* resource,
uint32_t dnd_actions) {
GetUserDataAs<DataSource>(resource)->SetActions(
DataDeviceManagerDndActions(dnd_actions));
}
const struct wl_data_source_interface data_source_implementation = {
data_source_offer, data_source_destroy, data_source_set_actions};
////////////////////////////////////////////////////////////////////////////////
// wl_data_offer_interface:
class WaylandDataOfferDelegate : public DataOfferDelegate {
public:
explicit WaylandDataOfferDelegate(wl_resource* offer)
: data_offer_resource_(offer) {}
// Overridden from DataOfferDelegate:
void OnDataOfferDestroying(DataOffer* device) override { delete this; }
void OnOffer(const std::string& mime_type) override {
wl_data_offer_send_offer(data_offer_resource_, mime_type.c_str());
wl_client_flush(wl_resource_get_client(data_offer_resource_));
}
void OnSourceActions(
const base::flat_set<DndAction>& source_actions) override {
if (wl_resource_get_version(data_offer_resource_) >=
WL_DATA_OFFER_SOURCE_ACTIONS_SINCE_VERSION) {
wl_data_offer_send_source_actions(
data_offer_resource_,
WaylandDataDeviceManagerDndActions(source_actions));
wl_client_flush(wl_resource_get_client(data_offer_resource_));
}
}
void OnAction(DndAction action) override {
if (wl_resource_get_version(data_offer_resource_) >=
WL_DATA_OFFER_ACTION_SINCE_VERSION) {
wl_data_offer_send_action(data_offer_resource_,
WaylandDataDeviceManagerDndAction(action));
wl_client_flush(wl_resource_get_client(data_offer_resource_));
}
}
private:
wl_resource* const data_offer_resource_;
DISALLOW_COPY_AND_ASSIGN(WaylandDataOfferDelegate);
};
void data_offer_accept(wl_client* client,
wl_resource* resource,
uint32_t serial,
const char* mime_type) {
GetUserDataAs<DataOffer>(resource)->Accept(mime_type);
}
void data_offer_receive(wl_client* client,
wl_resource* resource,
const char* mime_type,
int fd) {
GetUserDataAs<DataOffer>(resource)->Receive(mime_type, base::ScopedFD(fd));
}
void data_offer_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
void data_offer_finish(wl_client* client, wl_resource* resource) {
GetUserDataAs<DataOffer>(resource)->Finish();
}
void data_offer_set_actions(wl_client* client,
wl_resource* resource,
uint32_t dnd_actions,
uint32_t preferred_action) {
GetUserDataAs<DataOffer>(resource)->SetActions(
DataDeviceManagerDndActions(dnd_actions),
DataDeviceManagerDndAction(preferred_action));
}
const struct wl_data_offer_interface data_offer_implementation = {
data_offer_accept, data_offer_receive, data_offer_finish,
data_offer_destroy, data_offer_set_actions};
////////////////////////////////////////////////////////////////////////////////
// wl_data_device_interface:
class WaylandDataDeviceDelegate : public DataDeviceDelegate {
public:
WaylandDataDeviceDelegate(wl_client* client, wl_resource* device_resource)
: client_(client), data_device_resource_(device_resource) {}
// Overridden from DataDeviceDelegate:
void OnDataDeviceDestroying(DataDevice* device) override { delete this; }
bool CanAcceptDataEventsForSurface(Surface* surface) override {
return surface &&
wl_resource_get_client(GetSurfaceResource(surface)) == client_;
}
DataOffer* OnDataOffer() override {
wl_resource* data_offer_resource =
wl_resource_create(client_, &wl_data_offer_interface,
wl_resource_get_version(data_device_resource_), 0);
std::unique_ptr<DataOffer> data_offer = std::make_unique<DataOffer>(
new WaylandDataOfferDelegate(data_offer_resource));
data_offer->SetProperty(kDataOfferResourceKey, data_offer_resource);
SetImplementation(data_offer_resource, &data_offer_implementation,
std::move(data_offer));
wl_data_device_send_data_offer(data_device_resource_, data_offer_resource);
wl_client_flush(client_);
return GetUserDataAs<DataOffer>(data_offer_resource);
}
void OnEnter(Surface* surface,
const gfx::PointF& point,
const DataOffer& data_offer) override {
wl_data_device_send_enter(
data_device_resource_,
wl_display_next_serial(wl_client_get_display(client_)),
GetSurfaceResource(surface), wl_fixed_from_double(point.x()),
wl_fixed_from_double(point.y()), GetDataOfferResource(&data_offer));
wl_client_flush(client_);
}
void OnLeave() override {
wl_data_device_send_leave(data_device_resource_);
wl_client_flush(client_);
}
void OnMotion(base::TimeTicks time_stamp, const gfx::PointF& point) override {
wl_data_device_send_motion(
data_device_resource_, TimeTicksToMilliseconds(time_stamp),
wl_fixed_from_double(point.x()), wl_fixed_from_double(point.y()));
wl_client_flush(client_);
}
void OnDrop() override {
wl_data_device_send_drop(data_device_resource_);
wl_client_flush(client_);
}
void OnSelection(const DataOffer& data_offer) override {
wl_data_device_send_selection(data_device_resource_,
GetDataOfferResource(&data_offer));
wl_client_flush(client_);
}
private:
wl_client* const client_;
wl_resource* const data_device_resource_;
DISALLOW_COPY_AND_ASSIGN(WaylandDataDeviceDelegate);
};
void data_device_start_drag(wl_client* client,
wl_resource* resource,
wl_resource* source_resource,
wl_resource* origin_resource,
wl_resource* icon_resource,
uint32_t serial) {
GetUserDataAs<DataDevice>(resource)->StartDrag(
source_resource ? GetUserDataAs<DataSource>(source_resource) : nullptr,
GetUserDataAs<Surface>(origin_resource),
icon_resource ? GetUserDataAs<Surface>(icon_resource) : nullptr, serial);
}
void data_device_set_selection(wl_client* client,
wl_resource* resource,
wl_resource* data_source,
uint32_t serial) {
GetUserDataAs<DataDevice>(resource)->SetSelection(
data_source ? GetUserDataAs<DataSource>(data_source) : nullptr, serial);
}
void data_device_release(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
const struct wl_data_device_interface data_device_implementation = {
data_device_start_drag, data_device_set_selection, data_device_release};
////////////////////////////////////////////////////////////////////////////////
// wl_data_device_manager_interface:
void data_device_manager_create_data_source(wl_client* client,
wl_resource* resource,
uint32_t id) {
wl_resource* data_source_resource = wl_resource_create(
client, &wl_data_source_interface, wl_resource_get_version(resource), id);
SetImplementation(data_source_resource, &data_source_implementation,
std::make_unique<DataSource>(
new WaylandDataSourceDelegate(data_source_resource)));
}
void data_device_manager_get_data_device(wl_client* client,
wl_resource* resource,
uint32_t id,
wl_resource* seat_resource) {
Display* display = GetUserDataAs<Display>(resource);
wl_resource* data_device_resource = wl_resource_create(
client, &wl_data_device_interface, wl_resource_get_version(resource), id);
SetImplementation(data_device_resource, &data_device_implementation,
display->CreateDataDevice(new WaylandDataDeviceDelegate(
client, data_device_resource)));
}
const struct wl_data_device_manager_interface
data_device_manager_implementation = {
data_device_manager_create_data_source,
data_device_manager_get_data_device};
const uint32_t data_device_manager_version = 3;
void bind_data_device_manager(wl_client* client,
void* data,
uint32_t version,
uint32_t id) {
wl_resource* resource =
wl_resource_create(client, &wl_data_device_manager_interface,
std::min(version, data_device_manager_version), id);
wl_resource_set_implementation(resource, &data_device_manager_implementation,
data, nullptr);
}
////////////////////////////////////////////////////////////////////////////////
// wl_pointer_interface:
// Pointer delegate class that accepts events for surfaces owned by the same
// client as a pointer resource.
class WaylandPointerDelegate : public WaylandInputDelegate,
public PointerDelegate {
public:
explicit WaylandPointerDelegate(wl_resource* pointer_resource)
: pointer_resource_(pointer_resource) {}
// Overridden from PointerDelegate:
void OnPointerDestroying(Pointer* pointer) override { delete this; }
bool CanAcceptPointerEventsForSurface(Surface* surface) const override {
wl_resource* surface_resource = GetSurfaceResource(surface);
// We can accept events for this surface if the client is the same as the
// pointer.
return surface_resource &&
wl_resource_get_client(surface_resource) == client();
}
void OnPointerEnter(Surface* surface,
const gfx::PointF& location,
int button_flags) override {
wl_resource* surface_resource = GetSurfaceResource(surface);
DCHECK(surface_resource);
// Should we be sending button events to the client before the enter event
// if client's pressed button state is different from |button_flags|?
wl_pointer_send_enter(pointer_resource_, next_serial(), surface_resource,
wl_fixed_from_double(location.x()),
wl_fixed_from_double(location.y()));
}
void OnPointerLeave(Surface* surface) override {
wl_resource* surface_resource = GetSurfaceResource(surface);
DCHECK(surface_resource);
wl_pointer_send_leave(pointer_resource_, next_serial(), surface_resource);
}
void OnPointerMotion(base::TimeTicks time_stamp,
const gfx::PointF& location) override {
SendTimestamp(time_stamp);
wl_pointer_send_motion(
pointer_resource_, TimeTicksToMilliseconds(time_stamp),
wl_fixed_from_double(location.x()), wl_fixed_from_double(location.y()));
}
void OnPointerButton(base::TimeTicks time_stamp,
int button_flags,
bool pressed) override {
struct {
ui::EventFlags flag;
uint32_t value;
} buttons[] = {
{ui::EF_LEFT_MOUSE_BUTTON, BTN_LEFT},
{ui::EF_RIGHT_MOUSE_BUTTON, BTN_RIGHT},
{ui::EF_MIDDLE_MOUSE_BUTTON, BTN_MIDDLE},
{ui::EF_FORWARD_MOUSE_BUTTON, BTN_FORWARD},
{ui::EF_BACK_MOUSE_BUTTON, BTN_BACK},
};
uint32_t serial = next_serial();
for (auto button : buttons) {
if (button_flags & button.flag) {
SendTimestamp(time_stamp);
wl_pointer_send_button(
pointer_resource_, serial, TimeTicksToMilliseconds(time_stamp),
button.value, pressed ? WL_POINTER_BUTTON_STATE_PRESSED
: WL_POINTER_BUTTON_STATE_RELEASED);
}
}
}
void OnPointerScroll(base::TimeTicks time_stamp,
const gfx::Vector2dF& offset,
bool discrete) override {
// Same as Weston, the reference compositor.
const double kAxisStepDistance = 10.0 / ui::MouseWheelEvent::kWheelDelta;
if (wl_resource_get_version(pointer_resource_) >=
WL_POINTER_AXIS_SOURCE_SINCE_VERSION) {
int32_t axis_source = discrete ? WL_POINTER_AXIS_SOURCE_WHEEL
: WL_POINTER_AXIS_SOURCE_FINGER;
wl_pointer_send_axis_source(pointer_resource_, axis_source);
}
double x_value = offset.x() * kAxisStepDistance;
SendTimestamp(time_stamp);
wl_pointer_send_axis(pointer_resource_, TimeTicksToMilliseconds(time_stamp),
WL_POINTER_AXIS_HORIZONTAL_SCROLL,
wl_fixed_from_double(-x_value));
double y_value = offset.y() * kAxisStepDistance;
SendTimestamp(time_stamp);
wl_pointer_send_axis(pointer_resource_, TimeTicksToMilliseconds(time_stamp),
WL_POINTER_AXIS_VERTICAL_SCROLL,
wl_fixed_from_double(-y_value));
}
void OnPointerScrollStop(base::TimeTicks time_stamp) override {
if (wl_resource_get_version(pointer_resource_) >=
WL_POINTER_AXIS_STOP_SINCE_VERSION) {
SendTimestamp(time_stamp);
wl_pointer_send_axis_stop(pointer_resource_,
TimeTicksToMilliseconds(time_stamp),
WL_POINTER_AXIS_HORIZONTAL_SCROLL);
SendTimestamp(time_stamp);
wl_pointer_send_axis_stop(pointer_resource_,
TimeTicksToMilliseconds(time_stamp),
WL_POINTER_AXIS_VERTICAL_SCROLL);
}
}
void OnPointerFrame() override {
if (wl_resource_get_version(pointer_resource_) >=
WL_POINTER_FRAME_SINCE_VERSION) {
wl_pointer_send_frame(pointer_resource_);
}
wl_client_flush(client());
}
private:
// The client who own this pointer instance.
wl_client* client() const {
return wl_resource_get_client(pointer_resource_);
}
// Returns the next serial to use for pointer events.
uint32_t next_serial() const {
return wl_display_next_serial(wl_client_get_display(client()));
}
// The pointer resource associated with the pointer.
wl_resource* const pointer_resource_;
DISALLOW_COPY_AND_ASSIGN(WaylandPointerDelegate);
};
void pointer_set_cursor(wl_client* client,
wl_resource* resource,
uint32_t serial,
wl_resource* surface_resource,
int32_t hotspot_x,
int32_t hotspot_y) {
GetUserDataAs<Pointer>(resource)->SetCursor(
surface_resource ? GetUserDataAs<Surface>(surface_resource) : nullptr,
gfx::Point(hotspot_x, hotspot_y));
}
void pointer_release(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
const struct wl_pointer_interface pointer_implementation = {pointer_set_cursor,
pointer_release};
////////////////////////////////////////////////////////////////////////////////
// wl_keyboard_interface:
// Keyboard delegate class that accepts events for surfaces owned by the same
// client as a keyboard resource.
class WaylandKeyboardDelegate : public WaylandInputDelegate,
public KeyboardDelegate,
public KeyboardObserver
#if defined(OS_CHROMEOS)
,
public ash::ImeController::Observer
#endif
{
#if BUILDFLAG(USE_XKBCOMMON)
public:
explicit WaylandKeyboardDelegate(wl_resource* keyboard_resource)
: keyboard_resource_(keyboard_resource),
xkb_context_(xkb_context_new(XKB_CONTEXT_NO_FLAGS)) {
#if defined(OS_CHROMEOS)
ash::ImeController* ime_controller = ash::Shell::Get()->ime_controller();
ime_controller->AddObserver(this);
SendNamedLayout(ime_controller->keyboard_layout_name());
#else
SendLayout(nullptr);
#endif
}
#if defined(OS_CHROMEOS)
~WaylandKeyboardDelegate() override {
ash::Shell::Get()->ime_controller()->RemoveObserver(this);
}
#endif
// Overridden from KeyboardDelegate:
void OnKeyboardDestroying(Keyboard* keyboard) override { delete this; }
bool CanAcceptKeyboardEventsForSurface(Surface* surface) const override {
wl_resource* surface_resource = GetSurfaceResource(surface);
// We can accept events for this surface if the client is the same as the
// keyboard.
return surface_resource &&
wl_resource_get_client(surface_resource) == client();
}
void OnKeyboardEnter(
Surface* surface,
const base::flat_set<ui::DomCode>& pressed_keys) override {
wl_resource* surface_resource = GetSurfaceResource(surface);
DCHECK(surface_resource);
wl_array keys;
wl_array_init(&keys);
for (auto key : pressed_keys) {
uint32_t* value =
static_cast<uint32_t*>(wl_array_add(&keys, sizeof(uint32_t)));
DCHECK(value);
*value = DomCodeToKey(key);
}
wl_keyboard_send_enter(keyboard_resource_, next_serial(), surface_resource,
&keys);
wl_array_release(&keys);
wl_client_flush(client());
}
void OnKeyboardLeave(Surface* surface) override {
wl_resource* surface_resource = GetSurfaceResource(surface);
DCHECK(surface_resource);
wl_keyboard_send_leave(keyboard_resource_, next_serial(), surface_resource);
wl_client_flush(client());
}
uint32_t OnKeyboardKey(base::TimeTicks time_stamp,
ui::DomCode key,
bool pressed) override {
uint32_t serial = next_serial();
SendTimestamp(time_stamp);
wl_keyboard_send_key(keyboard_resource_, serial,
TimeTicksToMilliseconds(time_stamp), DomCodeToKey(key),
pressed ? WL_KEYBOARD_KEY_STATE_PRESSED
: WL_KEYBOARD_KEY_STATE_RELEASED);
wl_client_flush(client());
return serial;
}
void OnKeyboardModifiers(int modifier_flags) override {
xkb_state_update_mask(xkb_state_.get(),
ModifierFlagsToXkbModifiers(modifier_flags), 0, 0, 0,
0, 0);
wl_keyboard_send_modifiers(
keyboard_resource_, next_serial(),
xkb_state_serialize_mods(xkb_state_.get(), XKB_STATE_MODS_DEPRESSED),
xkb_state_serialize_mods(xkb_state_.get(), XKB_STATE_MODS_LOCKED),
xkb_state_serialize_mods(xkb_state_.get(), XKB_STATE_MODS_LATCHED),
xkb_state_serialize_layout(xkb_state_.get(),
XKB_STATE_LAYOUT_EFFECTIVE));
wl_client_flush(client());
}
#if defined(OS_CHROMEOS)
// Overridden from ImeController::Observer:
void OnCapsLockChanged(bool enabled) override {}
void OnKeyboardLayoutNameChanged(const std::string& layout_name) override {
SendNamedLayout(layout_name);
}
#endif
private:
// Returns the corresponding key given a dom code.
uint32_t DomCodeToKey(ui::DomCode code) const {
// This assumes KeycodeConverter has been built with evdev/xkb codes.
xkb_keycode_t xkb_keycode = static_cast<xkb_keycode_t>(
ui::KeycodeConverter::DomCodeToNativeKeycode(code));
// Keycodes are offset by 8 in Xkb.
DCHECK_GE(xkb_keycode, 8u);
return xkb_keycode - 8;
}
// Returns a set of Xkb modififers given a set of modifier flags.
uint32_t ModifierFlagsToXkbModifiers(int modifier_flags) {
struct {
ui::EventFlags flag;
const char* xkb_name;
} modifiers[] = {
{ui::EF_SHIFT_DOWN, XKB_MOD_NAME_SHIFT},
{ui::EF_CONTROL_DOWN, XKB_MOD_NAME_CTRL},
{ui::EF_ALT_DOWN, XKB_MOD_NAME_ALT},
{ui::EF_COMMAND_DOWN, XKB_MOD_NAME_LOGO},
{ui::EF_ALTGR_DOWN, "Mod5"},
{ui::EF_MOD3_DOWN, "Mod3"},
{ui::EF_NUM_LOCK_ON, XKB_MOD_NAME_NUM},
{ui::EF_CAPS_LOCK_ON, XKB_MOD_NAME_CAPS},
};
uint32_t xkb_modifiers = 0;
for (auto modifier : modifiers) {
if (modifier_flags & modifier.flag) {
xkb_modifiers |=
1 << xkb_keymap_mod_get_index(xkb_keymap_.get(), modifier.xkb_name);
}
}
return xkb_modifiers;
}
#if defined(OS_CHROMEOS)
// Send the named keyboard layout to the client.
void SendNamedLayout(const std::string& layout_name) {
std::string layout_id, layout_variant;
ui::XkbKeyboardLayoutEngine::ParseLayoutName(layout_name, &layout_id,
&layout_variant);
xkb_rule_names names = {.rules = nullptr,
.model = "pc101",
.layout = layout_id.c_str(),
.variant = layout_variant.c_str(),
.options = ""};
SendLayout(&names);
}
#endif
// Send the keyboard layout named by XKB rules to the client.
void SendLayout(const xkb_rule_names* names) {
xkb_keymap_.reset(xkb_keymap_new_from_names(xkb_context_.get(), names,
XKB_KEYMAP_COMPILE_NO_FLAGS));
xkb_state_.reset(xkb_state_new(xkb_keymap_.get()));
std::unique_ptr<char, base::FreeDeleter> keymap_string(
xkb_keymap_get_as_string(xkb_keymap_.get(), XKB_KEYMAP_FORMAT_TEXT_V1));
DCHECK(keymap_string.get());
size_t keymap_size = strlen(keymap_string.get()) + 1;
base::SharedMemory shared_keymap;
bool rv = shared_keymap.CreateAndMapAnonymous(keymap_size);
DCHECK(rv);
memcpy(shared_keymap.memory(), keymap_string.get(), keymap_size);
wl_keyboard_send_keymap(keyboard_resource_,
WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1,
shared_keymap.handle().GetHandle(), keymap_size);
wl_client_flush(client());
}
// The client who own this keyboard instance.
wl_client* client() const {
return wl_resource_get_client(keyboard_resource_);
}
// Returns the next serial to use for keyboard events.
uint32_t next_serial() const {
return wl_display_next_serial(wl_client_get_display(client()));
}
// The keyboard resource associated with the keyboard.
wl_resource* const keyboard_resource_;
// The Xkb state used for the keyboard.
std::unique_ptr<xkb_context, ui::XkbContextDeleter> xkb_context_;
std::unique_ptr<xkb_keymap, ui::XkbKeymapDeleter> xkb_keymap_;
std::unique_ptr<xkb_state, ui::XkbStateDeleter> xkb_state_;
DISALLOW_COPY_AND_ASSIGN(WaylandKeyboardDelegate);
#endif
};
#if BUILDFLAG(USE_XKBCOMMON)
void keyboard_release(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
const struct wl_keyboard_interface keyboard_implementation = {keyboard_release};
#endif
////////////////////////////////////////////////////////////////////////////////
// wl_touch_interface:
// Touch delegate class that accepts events for surfaces owned by the same
// client as a touch resource.
class WaylandTouchDelegate : public WaylandInputDelegate, public TouchDelegate {
public:
explicit WaylandTouchDelegate(wl_resource* touch_resource)
: touch_resource_(touch_resource) {}
// Overridden from TouchDelegate:
void OnTouchDestroying(Touch* touch) override { delete this; }
bool CanAcceptTouchEventsForSurface(Surface* surface) const override {
wl_resource* surface_resource = GetSurfaceResource(surface);
// We can accept events for this surface if the client is the same as the
// touch resource.
return surface_resource &&
wl_resource_get_client(surface_resource) == client();
}
void OnTouchDown(Surface* surface,
base::TimeTicks time_stamp,
int id,
const gfx::PointF& location) override {
wl_resource* surface_resource = GetSurfaceResource(surface);
DCHECK(surface_resource);
SendTimestamp(time_stamp);
wl_touch_send_down(touch_resource_, next_serial(),
TimeTicksToMilliseconds(time_stamp), surface_resource,
id, wl_fixed_from_double(location.x()),
wl_fixed_from_double(location.y()));
}
void OnTouchUp(base::TimeTicks time_stamp, int id) override {
SendTimestamp(time_stamp);
wl_touch_send_up(touch_resource_, next_serial(),
TimeTicksToMilliseconds(time_stamp), id);
}
void OnTouchMotion(base::TimeTicks time_stamp,
int id,
const gfx::PointF& location) override {
SendTimestamp(time_stamp);
wl_touch_send_motion(touch_resource_, TimeTicksToMilliseconds(time_stamp),
id, wl_fixed_from_double(location.x()),
wl_fixed_from_double(location.y()));
}
void OnTouchShape(int id, float major, float minor) override {
if (wl_resource_get_version(touch_resource_) >=
WL_TOUCH_SHAPE_SINCE_VERSION) {
wl_touch_send_shape(touch_resource_, id, wl_fixed_from_double(major),
wl_fixed_from_double(minor));
}
}
void OnTouchFrame() override {
if (wl_resource_get_version(touch_resource_) >=
WL_TOUCH_FRAME_SINCE_VERSION) {
wl_touch_send_frame(touch_resource_);
}
wl_client_flush(client());
}
void OnTouchCancel() override {
wl_touch_send_cancel(touch_resource_);
}
private:
// The client who own this touch instance.
wl_client* client() const { return wl_resource_get_client(touch_resource_); }
// Returns the next serial to use for keyboard events.
uint32_t next_serial() const {
return wl_display_next_serial(wl_client_get_display(client()));
}
// The touch resource associated with the touch.
wl_resource* const touch_resource_;
DISALLOW_COPY_AND_ASSIGN(WaylandTouchDelegate);
};
void touch_release(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
const struct wl_touch_interface touch_implementation = {touch_release};
////////////////////////////////////////////////////////////////////////////////
// wl_seat_interface:
void seat_get_pointer(wl_client* client, wl_resource* resource, uint32_t id) {
wl_resource* pointer_resource = wl_resource_create(
client, &wl_pointer_interface, wl_resource_get_version(resource), id);
SetImplementation(
pointer_resource, &pointer_implementation,
std::make_unique<Pointer>(new WaylandPointerDelegate(pointer_resource)));
}
void seat_get_keyboard(wl_client* client, wl_resource* resource, uint32_t id) {
#if BUILDFLAG(USE_XKBCOMMON)
uint32_t version = wl_resource_get_version(resource);
wl_resource* keyboard_resource =
wl_resource_create(client, &wl_keyboard_interface, version, id);
WaylandKeyboardDelegate* delegate =
new WaylandKeyboardDelegate(keyboard_resource);
std::unique_ptr<Keyboard> keyboard =
std::make_unique<Keyboard>(delegate, GetUserDataAs<Seat>(resource));
keyboard->AddObserver(delegate);
SetImplementation(keyboard_resource, &keyboard_implementation,
std::move(keyboard));
// TODO(reveman): Keep repeat info synchronized with chromium and the host OS.
if (version >= WL_KEYBOARD_REPEAT_INFO_SINCE_VERSION)
wl_keyboard_send_repeat_info(keyboard_resource, 40, 500);
#else
NOTIMPLEMENTED();
#endif
}
void seat_get_touch(wl_client* client, wl_resource* resource, uint32_t id) {
wl_resource* touch_resource = wl_resource_create(
client, &wl_touch_interface, wl_resource_get_version(resource), id);
SetImplementation(
touch_resource, &touch_implementation,
std::make_unique<Touch>(new WaylandTouchDelegate(touch_resource)));
}
void seat_release(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
const struct wl_seat_interface seat_implementation = {
seat_get_pointer, seat_get_keyboard, seat_get_touch, seat_release};
const uint32_t seat_version = 6;
void bind_seat(wl_client* client, void* data, uint32_t version, uint32_t id) {
wl_resource* resource = wl_resource_create(
client, &wl_seat_interface, std::min(version, seat_version), id);
wl_resource_set_implementation(resource, &seat_implementation, data, nullptr);
if (version >= WL_SEAT_NAME_SINCE_VERSION)
wl_seat_send_name(resource, "default");
uint32_t capabilities = WL_SEAT_CAPABILITY_POINTER | WL_SEAT_CAPABILITY_TOUCH;
#if BUILDFLAG(USE_XKBCOMMON)
capabilities |= WL_SEAT_CAPABILITY_KEYBOARD;
#endif
wl_seat_send_capabilities(resource, capabilities);
}
////////////////////////////////////////////////////////////////////////////////
// wp_viewport_interface:
// Implements the viewport interface to a Surface. The "viewport"-state is set
// to null upon destruction. A window property will be set during the lifetime
// of this class to prevent multiple instances from being created for the same
// Surface.
class Viewport : public SurfaceObserver {
public:
explicit Viewport(Surface* surface) : surface_(surface) {
surface_->AddSurfaceObserver(this);
surface_->SetProperty(kSurfaceHasViewportKey, true);
}
~Viewport() override {
if (surface_) {
surface_->RemoveSurfaceObserver(this);
surface_->SetCrop(gfx::RectF());
surface_->SetViewport(gfx::Size());
surface_->SetProperty(kSurfaceHasViewportKey, false);
}
}
void SetSource(const gfx::RectF& rect) {
if (surface_)
surface_->SetCrop(rect);
}
void SetDestination(const gfx::Size& size) {
if (surface_)
surface_->SetViewport(size);
}
// Overridden from SurfaceObserver:
void OnSurfaceDestroying(Surface* surface) override {
surface->RemoveSurfaceObserver(this);
surface_ = nullptr;
}
private:
Surface* surface_;
DISALLOW_COPY_AND_ASSIGN(Viewport);
};
void viewport_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
void viewport_set_source(wl_client* client,
wl_resource* resource,
wl_fixed_t x,
wl_fixed_t y,
wl_fixed_t width,
wl_fixed_t height) {
if (x == wl_fixed_from_int(-1) && y == wl_fixed_from_int(-1) &&
width == wl_fixed_from_int(-1) && height == wl_fixed_from_int(-1)) {
GetUserDataAs<Viewport>(resource)->SetSource(gfx::RectF());
return;
}
if (x < 0 || y < 0 || width <= 0 || height <= 0) {
wl_resource_post_error(resource, WP_VIEWPORT_ERROR_BAD_VALUE,
"source rectangle must be non-empty (%dx%d) and"
"have positive origin (%d,%d)",
width, height, x, y);
return;
}
GetUserDataAs<Viewport>(resource)->SetSource(
gfx::RectF(wl_fixed_to_double(x), wl_fixed_to_double(y),
wl_fixed_to_double(width), wl_fixed_to_double(height)));
}
void viewport_set_destination(wl_client* client,
wl_resource* resource,
int32_t width,
int32_t height) {
if (width == -1 && height == -1) {
GetUserDataAs<Viewport>(resource)->SetDestination(gfx::Size());
return;
}
if (width <= 0 || height <= 0) {
wl_resource_post_error(resource, WP_VIEWPORT_ERROR_BAD_VALUE,
"destination size must be positive (%dx%d)", width,
height);
return;
}
GetUserDataAs<Viewport>(resource)->SetDestination(gfx::Size(width, height));
}
const struct wp_viewport_interface viewport_implementation = {
viewport_destroy, viewport_set_source, viewport_set_destination};
////////////////////////////////////////////////////////////////////////////////
// wp_viewporter_interface:
void viewporter_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
void viewporter_get_viewport(wl_client* client,
wl_resource* resource,
uint32_t id,
wl_resource* surface_resource) {
Surface* surface = GetUserDataAs<Surface>(surface_resource);
if (surface->GetProperty(kSurfaceHasViewportKey)) {
wl_resource_post_error(resource, WP_VIEWPORTER_ERROR_VIEWPORT_EXISTS,
"a viewport for that surface already exists");
return;
}
wl_resource* viewport_resource = wl_resource_create(
client, &wp_viewport_interface, wl_resource_get_version(resource), id);
SetImplementation(viewport_resource, &viewport_implementation,
std::make_unique<Viewport>(surface));
}
const struct wp_viewporter_interface viewporter_implementation = {
viewporter_destroy, viewporter_get_viewport};
void bind_viewporter(wl_client* client,
void* data,
uint32_t version,
uint32_t id) {
wl_resource* resource =
wl_resource_create(client, &wp_viewporter_interface, 1, id);
wl_resource_set_implementation(resource, &viewporter_implementation, data,
nullptr);
}
////////////////////////////////////////////////////////////////////////////////
// presentation_interface:
void HandleSurfacePresentationCallback(wl_resource* resource,
base::TimeTicks presentation_time,
base::TimeDelta refresh,
uint32_t flags) {
if (presentation_time.is_null()) {
wp_presentation_feedback_send_discarded(resource);
} else {
int64_t presentation_time_us = presentation_time.ToInternalValue();
int64_t seconds = presentation_time_us / base::Time::kMicrosecondsPerSecond;
int64_t microseconds =
presentation_time_us % base::Time::kMicrosecondsPerSecond;
static_assert(
static_cast<uint32_t>(gfx::PresentationFeedback::Flags::kVSync) ==
static_cast<uint32_t>(WP_PRESENTATION_FEEDBACK_KIND_VSYNC),
"gfx::PresentationFlags::VSync don't match!");
static_assert(
static_cast<uint32_t>(gfx::PresentationFeedback::Flags::kHWClock) ==
static_cast<uint32_t>(WP_PRESENTATION_FEEDBACK_KIND_HW_CLOCK),
"gfx::PresentationFlags::HWClock don't match!");
static_assert(
static_cast<uint32_t>(
gfx::PresentationFeedback::Flags::kHWCompletion) ==
static_cast<uint32_t>(WP_PRESENTATION_FEEDBACK_KIND_HW_COMPLETION),
"gfx::PresentationFlags::HWCompletion don't match!");
static_assert(
static_cast<uint32_t>(gfx::PresentationFeedback::Flags::kZeroCopy) ==
static_cast<uint32_t>(WP_PRESENTATION_FEEDBACK_KIND_ZERO_COPY),
"gfx::PresentationFlags::ZeroCopy don't match!");
wp_presentation_feedback_send_presented(
resource, seconds >> 32, seconds & 0xffffffff,
microseconds * base::Time::kNanosecondsPerMicrosecond,
refresh.InMicroseconds() * base::Time::kNanosecondsPerMicrosecond, 0, 0,
flags);
}
wl_client_flush(wl_resource_get_client(resource));
}
void presentation_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
void presentation_feedback(wl_client* client,
wl_resource* resource,
wl_resource* surface_resource,
uint32_t id) {
wl_resource* presentation_feedback_resource =
wl_resource_create(client, &wp_presentation_feedback_interface,
wl_resource_get_version(resource), id);
// base::Unretained is safe as the resource owns the callback.
auto cancelable_callback = std::make_unique<base::CancelableCallback<void(
base::TimeTicks, base::TimeDelta, uint32_t)>>(
base::Bind(&HandleSurfacePresentationCallback,
base::Unretained(presentation_feedback_resource)));
GetUserDataAs<Surface>(surface_resource)
->RequestPresentationCallback(cancelable_callback->callback());
SetImplementation(presentation_feedback_resource, nullptr,
std::move(cancelable_callback));
}
const struct wp_presentation_interface presentation_implementation = {
presentation_destroy, presentation_feedback};
void bind_presentation(wl_client* client,
void* data,
uint32_t version,
uint32_t id) {
wl_resource* resource =
wl_resource_create(client, &wp_presentation_interface, 1, id);
wl_resource_set_implementation(resource, &presentation_implementation, data,
nullptr);
wp_presentation_send_clock_id(resource, CLOCK_MONOTONIC);
}
////////////////////////////////////////////////////////////////////////////////
// security_interface:
// Implements the security interface to a Surface. The "only visible on secure
// output"-state is set to false upon destruction. A window property will be set
// during the lifetime of this class to prevent multiple instances from being
// created for the same Surface.
class Security : public SurfaceObserver {
public:
explicit Security(Surface* surface) : surface_(surface) {
surface_->AddSurfaceObserver(this);
surface_->SetProperty(kSurfaceHasSecurityKey, true);
}
~Security() override {
if (surface_) {
surface_->RemoveSurfaceObserver(this);
surface_->SetOnlyVisibleOnSecureOutput(false);
surface_->SetProperty(kSurfaceHasSecurityKey, false);
}
}
void OnlyVisibleOnSecureOutput() {
if (surface_)
surface_->SetOnlyVisibleOnSecureOutput(true);
}
// Overridden from SurfaceObserver:
void OnSurfaceDestroying(Surface* surface) override {
surface->RemoveSurfaceObserver(this);
surface_ = nullptr;
}
private:
Surface* surface_;
DISALLOW_COPY_AND_ASSIGN(Security);
};
void security_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
void security_only_visible_on_secure_output(wl_client* client,
wl_resource* resource) {
GetUserDataAs<Security>(resource)->OnlyVisibleOnSecureOutput();
}
const struct zcr_security_v1_interface security_implementation = {
security_destroy, security_only_visible_on_secure_output};
////////////////////////////////////////////////////////////////////////////////
// secure_output_interface:
void secure_output_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
void secure_output_get_security(wl_client* client,
wl_resource* resource,
uint32_t id,
wl_resource* surface_resource) {
Surface* surface = GetUserDataAs<Surface>(surface_resource);
if (surface->GetProperty(kSurfaceHasSecurityKey)) {
wl_resource_post_error(resource, ZCR_SECURE_OUTPUT_V1_ERROR_SECURITY_EXISTS,
"a security object for that surface already exists");
return;
}
wl_resource* security_resource =
wl_resource_create(client, &zcr_security_v1_interface, 1, id);
SetImplementation(security_resource, &security_implementation,
std::make_unique<Security>(surface));
}
const struct zcr_secure_output_v1_interface secure_output_implementation = {
secure_output_destroy, secure_output_get_security};
void bind_secure_output(wl_client* client,
void* data,
uint32_t version,
uint32_t id) {
wl_resource* resource =
wl_resource_create(client, &zcr_secure_output_v1_interface, 1, id);
wl_resource_set_implementation(resource, &secure_output_implementation, data,
nullptr);
}
////////////////////////////////////////////////////////////////////////////////
// blending_interface:
// Implements the blending interface to a Surface. The "blend mode" and
// "alpha"-state is set to SrcOver and 1 upon destruction. A window property
// will be set during the lifetime of this class to prevent multiple instances
// from being created for the same Surface.
class Blending : public SurfaceObserver {
public:
explicit Blending(Surface* surface) : surface_(surface) {
surface_->AddSurfaceObserver(this);
surface_->SetProperty(kSurfaceHasBlendingKey, true);
}
~Blending() override {
if (surface_) {
surface_->RemoveSurfaceObserver(this);
surface_->SetBlendMode(SkBlendMode::kSrcOver);
surface_->SetAlpha(1.0f);
surface_->SetProperty(kSurfaceHasBlendingKey, false);
}
}
void SetBlendMode(SkBlendMode blend_mode) {
if (surface_)
surface_->SetBlendMode(blend_mode);
}
void SetAlpha(float value) {
if (surface_)
surface_->SetAlpha(value);
}
// Overridden from SurfaceObserver:
void OnSurfaceDestroying(Surface* surface) override {
surface->RemoveSurfaceObserver(this);
surface_ = nullptr;
}
private:
Surface* surface_;
DISALLOW_COPY_AND_ASSIGN(Blending);
};
void blending_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
void blending_set_blending(wl_client* client,
wl_resource* resource,
uint32_t equation) {
switch (equation) {
case ZCR_BLENDING_V1_BLENDING_EQUATION_NONE:
GetUserDataAs<Blending>(resource)->SetBlendMode(SkBlendMode::kSrc);
break;
case ZCR_BLENDING_V1_BLENDING_EQUATION_PREMULT:
GetUserDataAs<Blending>(resource)->SetBlendMode(SkBlendMode::kSrcOver);
break;
case ZCR_BLENDING_V1_BLENDING_EQUATION_COVERAGE:
NOTIMPLEMENTED();
break;
default:
DLOG(WARNING) << "Unsupported blending equation: " << equation;
break;
}
}
void blending_set_alpha(wl_client* client,
wl_resource* resource,
wl_fixed_t alpha) {
GetUserDataAs<Blending>(resource)->SetAlpha(wl_fixed_to_double(alpha));
}
const struct zcr_blending_v1_interface blending_implementation = {
blending_destroy, blending_set_blending, blending_set_alpha};
////////////////////////////////////////////////////////////////////////////////
// alpha_compositing_interface:
void alpha_compositing_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
void alpha_compositing_get_blending(wl_client* client,
wl_resource* resource,
uint32_t id,
wl_resource* surface_resource) {
Surface* surface = GetUserDataAs<Surface>(surface_resource);
if (surface->GetProperty(kSurfaceHasBlendingKey)) {
wl_resource_post_error(resource,
ZCR_ALPHA_COMPOSITING_V1_ERROR_BLENDING_EXISTS,
"a blending object for that surface already exists");
return;
}
wl_resource* blending_resource =
wl_resource_create(client, &zcr_blending_v1_interface, 1, id);
SetImplementation(blending_resource, &blending_implementation,
std::make_unique<Blending>(surface));
}
const struct zcr_alpha_compositing_v1_interface
alpha_compositing_implementation = {alpha_compositing_destroy,
alpha_compositing_get_blending};
void bind_alpha_compositing(wl_client* client,
void* data,
uint32_t version,
uint32_t id) {
wl_resource* resource =
wl_resource_create(client, &zcr_alpha_compositing_v1_interface, 1, id);
wl_resource_set_implementation(resource, &alpha_compositing_implementation,
data, nullptr);
}
////////////////////////////////////////////////////////////////////////////////
// gaming_input_interface:
// Gamepad delegate class that forwards gamepad events to the client resource.
class WaylandGamepadDelegate : public GamepadDelegate {
public:
explicit WaylandGamepadDelegate(wl_resource* gamepad_resource)
: gamepad_resource_(gamepad_resource) {}
// If gamepad_resource_ is destroyed first, ResetGamepadResource will
// be called to remove the resource from delegate, and delegate won't
// do anything after that. If delegate is destructed first, it will
// set the data to null in the gamepad_resource_, then the resource
// destroy won't reset the delegate (cause it's gone).
static void ResetGamepadResource(wl_resource* resource) {
WaylandGamepadDelegate* delegate =
GetUserDataAs<WaylandGamepadDelegate>(resource);
if (delegate) {
delegate->gamepad_resource_ = nullptr;
}
}
// Override from GamepadDelegate:
void OnRemoved() override {
if (!gamepad_resource_) {
return;
}
zcr_gamepad_v2_send_removed(gamepad_resource_);
wl_client_flush(client());
// Reset the user data in gamepad_resource.
wl_resource_set_user_data(gamepad_resource_, nullptr);
delete this;
}
void OnAxis(int axis, double value) override {
if (!gamepad_resource_) {
return;
}
zcr_gamepad_v2_send_axis(gamepad_resource_, NowInMilliseconds(), axis,
wl_fixed_from_double(value));
}
void OnButton(int button, bool pressed, double value) override {
if (!gamepad_resource_) {
return;
}
uint32_t state = pressed ? ZCR_GAMEPAD_V2_BUTTON_STATE_PRESSED
: ZCR_GAMEPAD_V2_BUTTON_STATE_RELEASED;
zcr_gamepad_v2_send_button(gamepad_resource_, NowInMilliseconds(), button,
state, wl_fixed_from_double(value));
}
void OnFrame() override {
if (!gamepad_resource_) {
return;
}
zcr_gamepad_v2_send_frame(gamepad_resource_, NowInMilliseconds());
wl_client_flush(client());
}
private:
// The object should be deleted by OnRemoved().
~WaylandGamepadDelegate() override {}
// The client who own this gamepad instance.
wl_client* client() const {
return wl_resource_get_client(gamepad_resource_);
}
// The gamepad resource associated with the gamepad.
wl_resource* gamepad_resource_;
DISALLOW_COPY_AND_ASSIGN(WaylandGamepadDelegate);
};
void gamepad_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
const struct zcr_gamepad_v2_interface gamepad_implementation = {
gamepad_destroy};
// GamingSeat delegate that provide gamepad added.
class WaylandGamingSeatDelegate : public GamingSeatDelegate {
public:
explicit WaylandGamingSeatDelegate(wl_resource* gaming_seat_resource)
: gaming_seat_resource_{gaming_seat_resource} {}
// Override from GamingSeatDelegate:
void OnGamingSeatDestroying(GamingSeat*) override { delete this; }
bool CanAcceptGamepadEventsForSurface(Surface* surface) const override {
wl_resource* surface_resource = GetSurfaceResource(surface);
return surface_resource &&
wl_resource_get_client(surface_resource) ==
wl_resource_get_client(gaming_seat_resource_);
}
GamepadDelegate* GamepadAdded() override {
wl_resource* gamepad_resource =
wl_resource_create(wl_resource_get_client(gaming_seat_resource_),
&zcr_gamepad_v2_interface,
wl_resource_get_version(gaming_seat_resource_), 0);
GamepadDelegate* gamepad_delegate =
new WaylandGamepadDelegate(gamepad_resource);
wl_resource_set_implementation(
gamepad_resource, &gamepad_implementation, gamepad_delegate,
&WaylandGamepadDelegate::ResetGamepadResource);
zcr_gaming_seat_v2_send_gamepad_added(gaming_seat_resource_,
gamepad_resource);
wl_client_flush(wl_resource_get_client(gaming_seat_resource_));
return gamepad_delegate;
}
private:
// The gaming seat resource associated with the gaming seat.
wl_resource* const gaming_seat_resource_;
DISALLOW_COPY_AND_ASSIGN(WaylandGamingSeatDelegate);
};
void gaming_seat_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
const struct zcr_gaming_seat_v2_interface gaming_seat_implementation = {
gaming_seat_destroy};
void gaming_input_get_gaming_seat(wl_client* client,
wl_resource* resource,
uint32_t id,
wl_resource* seat) {
wl_resource* gaming_seat_resource =
wl_resource_create(client, &zcr_gaming_seat_v2_interface,
wl_resource_get_version(resource), id);
SetImplementation(gaming_seat_resource, &gaming_seat_implementation,
std::make_unique<GamingSeat>(
new WaylandGamingSeatDelegate(gaming_seat_resource)));
}
void gaming_input_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
const struct zcr_gaming_input_v2_interface gaming_input_implementation = {
gaming_input_get_gaming_seat, gaming_input_destroy};
void bind_gaming_input(wl_client* client,
void* data,
uint32_t version,
uint32_t id) {
wl_resource* resource =
wl_resource_create(client, &zcr_gaming_input_v2_interface, version, id);
wl_resource_set_implementation(resource, &gaming_input_implementation,
nullptr, nullptr);
}
////////////////////////////////////////////////////////////////////////////////
// touch_stylus interface:
class WaylandTouchStylusDelegate : public TouchStylusDelegate {
public:
WaylandTouchStylusDelegate(wl_resource* resource, Touch* touch)
: resource_(resource), touch_(touch) {
touch_->SetStylusDelegate(this);
}
~WaylandTouchStylusDelegate() override {
if (touch_ != nullptr)
touch_->SetStylusDelegate(nullptr);
}
void OnTouchDestroying(Touch* touch) override { touch_ = nullptr; }
void OnTouchTool(int touch_id, ui::EventPointerType type) override {
uint wayland_type = ZCR_TOUCH_STYLUS_V2_TOOL_TYPE_TOUCH;
if (type == ui::EventPointerType::POINTER_TYPE_PEN)
wayland_type = ZCR_TOUCH_STYLUS_V2_TOOL_TYPE_PEN;
else if (type == ui::EventPointerType::POINTER_TYPE_ERASER)
wayland_type = ZCR_TOUCH_STYLUS_V2_TOOL_TYPE_ERASER;
zcr_touch_stylus_v2_send_tool(resource_, touch_id, wayland_type);
}
void OnTouchForce(base::TimeTicks time_stamp,
int touch_id,
float force) override {
zcr_touch_stylus_v2_send_force(resource_,
TimeTicksToMilliseconds(time_stamp),
touch_id, wl_fixed_from_double(force));
}
void OnTouchTilt(base::TimeTicks time_stamp,
int touch_id,
const gfx::Vector2dF& tilt) override {
zcr_touch_stylus_v2_send_tilt(
resource_, TimeTicksToMilliseconds(time_stamp), touch_id,
wl_fixed_from_double(tilt.x()), wl_fixed_from_double(tilt.y()));
}
private:
wl_resource* resource_;
Touch* touch_;
DISALLOW_COPY_AND_ASSIGN(WaylandTouchStylusDelegate);
};
void touch_stylus_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
const struct zcr_touch_stylus_v2_interface touch_stylus_implementation = {
touch_stylus_destroy};
////////////////////////////////////////////////////////////////////////////////
// stylus_v2 interface:
void stylus_get_touch_stylus(wl_client* client,
wl_resource* resource,
uint32_t id,
wl_resource* touch_resource) {
Touch* touch = GetUserDataAs<Touch>(touch_resource);
if (touch->HasStylusDelegate()) {
wl_resource_post_error(
resource, ZCR_STYLUS_V2_ERROR_TOUCH_STYLUS_EXISTS,
"touch has already been associated with a stylus object");
return;
}
wl_resource* stylus_resource =
wl_resource_create(client, &zcr_touch_stylus_v2_interface, 1, id);
SetImplementation(
stylus_resource, &touch_stylus_implementation,
std::make_unique<WaylandTouchStylusDelegate>(stylus_resource, touch));
}
const struct zcr_stylus_v2_interface stylus_v2_implementation = {
stylus_get_touch_stylus};
void bind_stylus_v2(wl_client* client,
void* data,
uint32_t version,
uint32_t id) {
wl_resource* resource =
wl_resource_create(client, &zcr_stylus_v2_interface, version, id);
wl_resource_set_implementation(resource, &stylus_v2_implementation, data,
nullptr);
}
////////////////////////////////////////////////////////////////////////////////
// pointer_gesture_swipe_v1 interface:
void pointer_gestures_get_swipe_gesture(wl_client* client,
wl_resource* resource,
uint32_t id,
wl_resource* pointer_resource) {
NOTIMPLEMENTED();
}
////////////////////////////////////////////////////////////////////////////////
// pointer_gesture_pinch_v1 interface:
class WaylandPointerGesturePinchDelegate : public PointerGesturePinchDelegate {
public:
WaylandPointerGesturePinchDelegate(wl_resource* resource, Pointer* pointer)
: resource_(resource), pointer_(pointer) {
pointer_->SetGesturePinchDelegate(this);
}
~WaylandPointerGesturePinchDelegate() override {
if (pointer_)
pointer_->SetGesturePinchDelegate(nullptr);
}
void OnPointerDestroying(Pointer* pointer) override { pointer_ = nullptr; }
void OnPointerPinchBegin(uint32_t unique_touch_event_id,
base::TimeTicks time_stamp,
Surface* surface) override {
wl_resource* surface_resource = GetSurfaceResource(surface);
DCHECK(surface_resource);
zwp_pointer_gesture_pinch_v1_send_begin(resource_, unique_touch_event_id,
TimeTicksToMilliseconds(time_stamp),
surface_resource, 2);
}
void OnPointerPinchUpdate(base::TimeTicks time_stamp, float scale) override {
zwp_pointer_gesture_pinch_v1_send_update(
resource_, TimeTicksToMilliseconds(time_stamp), 0, 0,
wl_fixed_from_double(scale), 0);
}
void OnPointerPinchEnd(uint32_t unique_touch_event_id,
base::TimeTicks time_stamp) override {
zwp_pointer_gesture_pinch_v1_send_end(resource_, unique_touch_event_id,
TimeTicksToMilliseconds(time_stamp),
0);
}
private:
wl_resource* const resource_;
Pointer* pointer_;
DISALLOW_COPY_AND_ASSIGN(WaylandPointerGesturePinchDelegate);
};
void pointer_gesture_pinch_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
const struct zwp_pointer_gesture_pinch_v1_interface
pointer_gesture_pinch_implementation = {pointer_gesture_pinch_destroy};
void pointer_gestures_get_pinch_gesture(wl_client* client,
wl_resource* resource,
uint32_t id,
wl_resource* pointer_resource) {
Pointer* pointer = GetUserDataAs<Pointer>(pointer_resource);
wl_resource* pointer_gesture_pinch_resource = wl_resource_create(
client, &zwp_pointer_gesture_pinch_v1_interface, 1, id);
SetImplementation(pointer_gesture_pinch_resource,
&pointer_gesture_pinch_implementation,
std::make_unique<WaylandPointerGesturePinchDelegate>(
pointer_gesture_pinch_resource, pointer));
}
////////////////////////////////////////////////////////////////////////////////
// pointer_gestures_v1 interface:
const struct zwp_pointer_gestures_v1_interface pointer_gestures_implementation =
{pointer_gestures_get_swipe_gesture, pointer_gestures_get_pinch_gesture};
void bind_pointer_gestures(wl_client* client,
void* data,
uint32_t version,
uint32_t id) {
wl_resource* resource = wl_resource_create(
client, &zwp_pointer_gestures_v1_interface, version, id);
wl_resource_set_implementation(resource, &pointer_gestures_implementation,
data, nullptr);
}
////////////////////////////////////////////////////////////////////////////////
// keyboard_device_configuration interface:
class WaylandKeyboardDeviceConfigurationDelegate
: public KeyboardDeviceConfigurationDelegate,
public KeyboardObserver {
public:
WaylandKeyboardDeviceConfigurationDelegate(wl_resource* resource,
Keyboard* keyboard)
: resource_(resource), keyboard_(keyboard) {
keyboard_->SetDeviceConfigurationDelegate(this);
keyboard_->AddObserver(this);
}
~WaylandKeyboardDeviceConfigurationDelegate() override {
if (keyboard_) {
keyboard_->SetDeviceConfigurationDelegate(nullptr);
keyboard_->RemoveObserver(this);
}
}
// Overridden from KeyboardObserver:
void OnKeyboardDestroying(Keyboard* keyboard) override {
keyboard_ = nullptr;
}
// Overridden from KeyboardDeviceConfigurationDelegate:
void OnKeyboardTypeChanged(bool is_physical) override {
zcr_keyboard_device_configuration_v1_send_type_change(
resource_,
is_physical
? ZCR_KEYBOARD_DEVICE_CONFIGURATION_V1_KEYBOARD_TYPE_PHYSICAL
: ZCR_KEYBOARD_DEVICE_CONFIGURATION_V1_KEYBOARD_TYPE_VIRTUAL);
}
private:
wl_resource* resource_;
Keyboard* keyboard_;
DISALLOW_COPY_AND_ASSIGN(WaylandKeyboardDeviceConfigurationDelegate);
};
void keyboard_device_configuration_destroy(wl_client* client,
wl_resource* resource) {
wl_resource_destroy(resource);
}
const struct zcr_keyboard_device_configuration_v1_interface
keyboard_device_configuration_implementation = {
keyboard_device_configuration_destroy};
////////////////////////////////////////////////////////////////////////////////
// keyboard_configuration interface:
void keyboard_configuration_get_keyboard_device_configuration(
wl_client* client,
wl_resource* resource,
uint32_t id,
wl_resource* keyboard_resource) {
Keyboard* keyboard = GetUserDataAs<Keyboard>(keyboard_resource);
if (keyboard->HasDeviceConfigurationDelegate()) {
wl_resource_post_error(
resource,
ZCR_KEYBOARD_CONFIGURATION_V1_ERROR_DEVICE_CONFIGURATION_EXISTS,
"keyboard has already been associated with a device configuration "
"object");
return;
}
wl_resource* keyboard_device_configuration_resource = wl_resource_create(
client, &zcr_keyboard_device_configuration_v1_interface,
wl_resource_get_version(resource), id);
SetImplementation(
keyboard_device_configuration_resource,
&keyboard_device_configuration_implementation,
std::make_unique<WaylandKeyboardDeviceConfigurationDelegate>(
keyboard_device_configuration_resource, keyboard));
}
const struct zcr_keyboard_configuration_v1_interface
keyboard_configuration_implementation = {
keyboard_configuration_get_keyboard_device_configuration};
const uint32_t keyboard_configuration_version = 2;
void bind_keyboard_configuration(wl_client* client,
void* data,
uint32_t version,
uint32_t id) {
wl_resource* resource =
wl_resource_create(client, &zcr_keyboard_configuration_v1_interface,
std::min(version, keyboard_configuration_version), id);
wl_resource_set_implementation(
resource, &keyboard_configuration_implementation, data, nullptr);
}
////////////////////////////////////////////////////////////////////////////////
// stylus_tool interface:
class StylusTool : public SurfaceObserver {
public:
explicit StylusTool(Surface* surface) : surface_(surface) {
surface_->AddSurfaceObserver(this);
surface_->SetProperty(kSurfaceHasStylusToolKey, true);
}
~StylusTool() override {
if (surface_) {
surface_->RemoveSurfaceObserver(this);
surface_->SetProperty(kSurfaceHasStylusToolKey, false);
}
}
void SetStylusOnly() { surface_->SetStylusOnly(); }
// Overridden from SurfaceObserver:
void OnSurfaceDestroying(Surface* surface) override {
surface->RemoveSurfaceObserver(this);
surface_ = nullptr;
}
private:
Surface* surface_;
DISALLOW_COPY_AND_ASSIGN(StylusTool);
};
void stylus_tool_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
void stylus_tool_set_stylus_only(wl_client* client, wl_resource* resource) {
GetUserDataAs<StylusTool>(resource)->SetStylusOnly();
}
const struct zcr_stylus_tool_v1_interface stylus_tool_implementation = {
stylus_tool_destroy, stylus_tool_set_stylus_only};
////////////////////////////////////////////////////////////////////////////////
// stylus_tools interface:
void stylus_tools_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
void stylus_tools_get_stylus_tool(wl_client* client,
wl_resource* resource,
uint32_t id,
wl_resource* surface_resource) {
Surface* surface = GetUserDataAs<Surface>(surface_resource);
if (surface->GetProperty(kSurfaceHasStylusToolKey)) {
wl_resource_post_error(
resource, ZCR_STYLUS_TOOLS_V1_ERROR_STYLUS_TOOL_EXISTS,
"a stylus_tool object for that surface already exists");
return;
}
wl_resource* stylus_tool_resource =
wl_resource_create(client, &zcr_stylus_tool_v1_interface, 1, id);
SetImplementation(stylus_tool_resource, &stylus_tool_implementation,
std::make_unique<StylusTool>(surface));
}
const struct zcr_stylus_tools_v1_interface stylus_tools_implementation = {
stylus_tools_destroy, stylus_tools_get_stylus_tool};
void bind_stylus_tools(wl_client* client,
void* data,
uint32_t version,
uint32_t id) {
wl_resource* resource =
wl_resource_create(client, &zcr_stylus_tools_v1_interface, 1, id);
wl_resource_set_implementation(resource, &stylus_tools_implementation, data,
nullptr);
}
////////////////////////////////////////////////////////////////////////////////
// extended_keyboard interface:
class WaylandExtendedKeyboardImpl : public KeyboardObserver {
public:
explicit WaylandExtendedKeyboardImpl(Keyboard* keyboard)
: keyboard_(keyboard) {
keyboard_->AddObserver(this);
keyboard_->SetNeedKeyboardKeyAcks(true);
}
~WaylandExtendedKeyboardImpl() override {
if (keyboard_) {
keyboard_->RemoveObserver(this);
keyboard_->SetNeedKeyboardKeyAcks(false);
}
}
// Overridden from KeyboardObserver:
void OnKeyboardDestroying(Keyboard* keyboard) override {
DCHECK(keyboard_ == keyboard);
keyboard_ = nullptr;
}
void AckKeyboardKey(uint32_t serial, bool handled) {
if (keyboard_)
keyboard_->AckKeyboardKey(serial, handled);
}
private:
Keyboard* keyboard_;
DISALLOW_COPY_AND_ASSIGN(WaylandExtendedKeyboardImpl);
};
void extended_keyboard_destroy(wl_client* client, wl_resource* resource) {
wl_resource_destroy(resource);
}
void extended_keyboard_ack_key(wl_client* client,
wl_resource* resource,
uint32_t serial,
uint32_t handled_state) {
GetUserDataAs<WaylandExtendedKeyboardImpl>(resource)->AckKeyboardKey(
serial, handled_state == ZCR_EXTENDED_KEYBOARD_V1_HANDLED_STATE_HANDLED);
}
const struct zcr_extended_keyboard_v1_interface
extended_keyboard_implementation = {extended_keyboard_destroy,
extended_keyboard_ack_key};
////////////////////////////////////////////////////////////////////////////////
// keyboard_extension interface:
void keyboard_extension_get_extended_keyboard(wl_client* client,
wl_resource* resource,
uint32_t id,
wl_resource* keyboard_resource) {
Keyboard* keyboard = GetUserDataAs<Keyboard>(keyboard_resource);
if (keyboard->AreKeyboardKeyAcksNeeded()) {
wl_resource_post_error(
resource, ZCR_KEYBOARD_EXTENSION_V1_ERROR_EXTENDED_KEYBOARD_EXISTS,
"keyboard has already been associated with a extended_keyboard object");
return;
}
wl_resource* extended_keyboard_resource =
wl_resource_create(client, &zcr_extended_keyboard_v1_interface, 1, id);
SetImplementation(extended_keyboard_resource,
&extended_keyboard_implementation,
std::make_unique<WaylandExtendedKeyboardImpl>(keyboard));
}
const struct zcr_keyboard_extension_v1_interface
keyboard_extension_implementation = {
keyboard_extension_get_extended_keyboard};
void bind_keyboard_extension(wl_client* client,
void* data,
uint32_t version,
uint32_t id) {
wl_resource* resource = wl_resource_create(
client, &zcr_keyboard_extension_v1_interface, version, id);
wl_resource_set_implementation(resource, &keyboard_extension_implementation,
data, nullptr);
}
////////////////////////////////////////////////////////////////////////////////
// cursor_shapes interface:
static ui::CursorType GetCursorType(int32_t cursor_shape) {
switch (cursor_shape) {
#define ADD_CASE(wayland, chrome) \
case ZCR_CURSOR_SHAPES_V1_CURSOR_SHAPE_TYPE_##wayland: \
return ui::CursorType::chrome
ADD_CASE(POINTER, kPointer);
ADD_CASE(CROSS, kCross);
ADD_CASE(HAND, kHand);
ADD_CASE(IBEAM, kIBeam);
ADD_CASE(WAIT, kWait);
ADD_CASE(HELP, kHelp);
ADD_CASE(EAST_RESIZE, kEastResize);
ADD_CASE(NORTH_RESIZE, kNorthResize);
ADD_CASE(NORTH_EAST_RESIZE, kNorthEastResize);
ADD_CASE(NORTH_WEST_RESIZE, kNorthWestResize);
ADD_CASE(SOUTH_RESIZE, kSouthResize);
ADD_CASE(SOUTH_EAST_RESIZE, kSouthEastResize);
ADD_CASE(SOUTH_WEST_RESIZE, kSouthWestResize);
ADD_CASE(WEST_RESIZE, kWestResize);
ADD_CASE(NORTH_SOUTH_RESIZE, kNorthSouthResize);
ADD_CASE(EAST_WEST_RESIZE, kEastWestResize);
ADD_CASE(NORTH_EAST_SOUTH_WEST_RESIZE, kNorthEastSouthWestResize);
ADD_CASE(NORTH_WEST_SOUTH_EAST_RESIZE, kNorthWestSouthEastResize);
ADD_CASE(COLUMN_RESIZE, kColumnResize);
ADD_CASE(ROW_RESIZE, kRowResize);
ADD_CASE(MIDDLE_PANNING, kMiddlePanning);
ADD_CASE(EAST_PANNING, kEastPanning);
ADD_CASE(NORTH_PANNING, kNorthPanning);
ADD_CASE(NORTH_EAST_PANNING, kNorthEastPanning);
ADD_CASE(NORTH_WEST_PANNING, kNorthWestPanning);
ADD_CASE(SOUTH_PANNING, kSouthPanning);
ADD_CASE(SOUTH_EAST_PANNING, kSouthEastPanning);
ADD_CASE(SOUTH_WEST_PANNING, kSouthWestPanning);
ADD_CASE(WEST_PANNING, kWestPanning);
ADD_CASE(MOVE, kMove);
ADD_CASE(VERTICAL_TEXT, kVerticalText);
ADD_CASE(CELL, kCell);
ADD_CASE(CONTEXT_MENU, kContextMenu);
ADD_CASE(ALIAS, kAlias);
ADD_CASE(PROGRESS, kProgress);
ADD_CASE(NO_DROP, kNoDrop);
ADD_CASE(COPY, kCopy);
ADD_CASE(NONE, kNone);
ADD_CASE(NOT_ALLOWED, kNotAllowed);
ADD_CASE(ZOOM_IN, kZoomIn);
ADD_CASE(ZOOM_OUT, kZoomOut);
ADD_CASE(GRAB, kGrab);
ADD_CASE(GRABBING, kGrabbing);
ADD_CASE(DND_NONE, kDndNone);
ADD_CASE(DND_MOVE, kDndMove);
ADD_CASE(DND_COPY, kDndCopy);
ADD_CASE(DND_LINK, kDndLink);
#undef ADD_CASE
default:
return ui::CursorType::kNull;
}
}
void cursor_shapes_set_cursor_shape(wl_client* client,
wl_resource* resource,
wl_resource* pointer_resource,
int32_t shape) {
ui::CursorType cursor_type = GetCursorType(shape);
if (cursor_type == ui::CursorType::kNull) {
wl_resource_post_error(resource, ZCR_CURSOR_SHAPES_V1_ERROR_INVALID_SHAPE,
"Unrecognized shape %d", shape);
return;
}
Pointer* pointer = GetUserDataAs<Pointer>(pointer_resource);
pointer->SetCursorType(cursor_type);
}
const struct zcr_cursor_shapes_v1_interface cursor_shapes_implementation = {
cursor_shapes_set_cursor_shape};
void bind_cursor_shapes(wl_client* client,
void* data,
uint32_t version,
uint32_t id) {
wl_resource* resource =
wl_resource_create(client, &zcr_cursor_shapes_v1_interface, version, id);
wl_resource_set_implementation(resource, &cursor_shapes_implementation, data,
nullptr);
}
////////////////////////////////////////////////////////////////////////////////
// input_timestamps_v1 interface:
class WaylandInputTimestamps : public WaylandInputDelegate::Observer {
public:
WaylandInputTimestamps(wl_resource* resource, WaylandInputDelegate* delegate)
: resource_(resource), delegate_(delegate) {
delegate_->AddObserver(this);
}
~WaylandInputTimestamps() override {
if (delegate_)
delegate_->RemoveObserver(this);
}
// Overridden from WaylandInputDelegate::Observer:
void OnDelegateDestroying(WaylandInputDelegate* delegate) override {
DCHECK(delegate_ == delegate);
delegate_ = nullptr;
}
void OnSendTimestamp(base::TimeTicks time_stamp) override {
timespec ts = (time_stamp - base::TimeTicks()).ToTimeSpec();
zwp_input_timestamps_v1_send_timestamp(
resource_, static_cast<uint64_t>(ts.tv_sec) >> 32,
ts.tv_sec & 0xffffffff, ts.tv_nsec);
}
private:
wl_resource* const resource_;
WaylandInputDelegate* delegate_;
DISALLOW_COPY_AND_ASSIGN(WaylandInputTimestamps);
};
void input_timestamps_destroy(struct wl_client* client,
struct wl_resource* resource) {
wl_resource_destroy(resource);
}
const struct zwp_input_timestamps_v1_interface input_timestamps_implementation =
{input_timestamps_destroy};
////////////////////////////////////////////////////////////////////////////////
// input_timestamps_manager_v1 interface:
void input_timestamps_manager_destroy(struct wl_client* client,
struct wl_resource* resource) {
wl_resource_destroy(resource);
}
template <typename T, typename D>
void input_timestamps_manager_get_timestamps(wl_client* client,
wl_resource* resource,
uint32_t id,
wl_resource* input_resource) {
wl_resource* input_timestamps_resource =
wl_resource_create(client, &zwp_input_timestamps_v1_interface, 1, id);
auto input_timestamps = std::make_unique<WaylandInputTimestamps>(
input_timestamps_resource,
static_cast<WaylandInputDelegate*>(
static_cast<D*>(GetUserDataAs<T>(input_resource)->delegate())));
SetImplementation(input_timestamps_resource, &input_timestamps_implementation,
std::move(input_timestamps));
}
const struct zwp_input_timestamps_manager_v1_interface
input_timestamps_manager_implementation = {
input_timestamps_manager_destroy,
input_timestamps_manager_get_timestamps<Keyboard,
WaylandKeyboardDelegate>,
input_timestamps_manager_get_timestamps<Pointer,
WaylandPointerDelegate>,
input_timestamps_manager_get_timestamps<Touch, WaylandTouchDelegate>};
void bind_input_timestamps_manager(wl_client* client,
void* data,
uint32_t version,
uint32_t id) {
wl_resource* resource = wl_resource_create(
client, &zwp_input_timestamps_manager_v1_interface, 1, id);
wl_resource_set_implementation(
resource, &input_timestamps_manager_implementation, nullptr, nullptr);
}
} // namespace
////////////////////////////////////////////////////////////////////////////////
// Server::Output, public:
Server::Output::Output(int64_t id) : id_(id) {}
Server::Output::~Output() {
if (global_)
wl_global_destroy(global_);
}
////////////////////////////////////////////////////////////////////////////////
// Server, public:
Server::Server(Display* display)
: display_(display), wl_display_(wl_display_create()) {
wl_global_create(wl_display_.get(), &wl_compositor_interface,
compositor_version, display_, bind_compositor);
wl_global_create(wl_display_.get(), &wl_shm_interface, 1, display_, bind_shm);
#if defined(USE_OZONE)
wl_global_create(wl_display_.get(), &zwp_linux_dmabuf_v1_interface,
linux_dmabuf_version, display_, bind_linux_dmabuf);
#endif
wl_global_create(wl_display_.get(), &wl_subcompositor_interface, 1, display_,
bind_subcompositor);
wl_global_create(wl_display_.get(), &wl_shell_interface, 1, display_,
bind_shell);
display::Screen::GetScreen()->AddObserver(this);
for (const auto& display : display::Screen::GetScreen()->GetAllDisplays())
OnDisplayAdded(display);
wl_global_create(wl_display_.get(), &zxdg_shell_v6_interface, 1, display_,
bind_xdg_shell_v6);
wl_global_create(wl_display_.get(), &zcr_vsync_feedback_v1_interface, 1,
display_, bind_vsync_feedback);
wl_global_create(wl_display_.get(), &wl_data_device_manager_interface,
data_device_manager_version, display_,
bind_data_device_manager);
wl_global_create(wl_display_.get(), &wl_seat_interface, seat_version,
display_->seat(), bind_seat);
wl_global_create(wl_display_.get(), &wp_viewporter_interface, 1, display_,
bind_viewporter);
wl_global_create(wl_display_.get(), &wp_presentation_interface, 1, display_,
bind_presentation);
wl_global_create(wl_display_.get(), &zcr_secure_output_v1_interface, 1,
display_, bind_secure_output);
wl_global_create(wl_display_.get(), &zcr_alpha_compositing_v1_interface, 1,
display_, bind_alpha_compositing);
wl_global_create(wl_display_.get(), &zcr_remote_shell_v1_interface,
remote_shell_version, display_, bind_remote_shell);
wl_global_create(wl_display_.get(), &zaura_shell_interface,
aura_shell_version, display_, bind_aura_shell);
wl_global_create(wl_display_.get(), &zcr_gaming_input_v2_interface, 1,
display_, bind_gaming_input);
wl_global_create(wl_display_.get(), &zcr_stylus_v2_interface, 1, display_,
bind_stylus_v2);
wl_global_create(wl_display_.get(), &zwp_pointer_gestures_v1_interface, 1,
display_, bind_pointer_gestures);
wl_global_create(wl_display_.get(), &zcr_keyboard_configuration_v1_interface,
keyboard_configuration_version, display_,
bind_keyboard_configuration);
wl_global_create(wl_display_.get(), &zcr_stylus_tools_v1_interface, 1,
display_, bind_stylus_tools);
wl_global_create(wl_display_.get(), &zcr_keyboard_extension_v1_interface, 1,
display_, bind_keyboard_extension);
wl_global_create(wl_display_.get(), &zcr_cursor_shapes_v1_interface, 1,
display_, bind_cursor_shapes);
wl_global_create(wl_display_.get(),
&zwp_input_timestamps_manager_v1_interface, 1, display_,
bind_input_timestamps_manager);
}
Server::~Server() {
display::Screen::GetScreen()->RemoveObserver(this);
}
// static
std::unique_ptr<Server> Server::Create(Display* display) {
std::unique_ptr<Server> server(new Server(display));
char* runtime_dir = getenv("XDG_RUNTIME_DIR");
if (!runtime_dir) {
LOG(ERROR) << "XDG_RUNTIME_DIR not set in the environment";
return nullptr;
}
std::string socket_name(kSocketName);
base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
if (command_line->HasSwitch(switches::kWaylandServerSocket)) {
socket_name =
command_line->GetSwitchValueASCII(switches::kWaylandServerSocket);
}
if (!server->AddSocket(socket_name.c_str())) {
LOG(ERROR) << "Failed to add socket: " << socket_name;
return nullptr;
}
base::FilePath socket_path = base::FilePath(runtime_dir).Append(socket_name);
// Change permissions on the socket.
struct group wayland_group;
struct group* wayland_group_res = nullptr;
char buf[10000];
if (HANDLE_EINTR(getgrnam_r(kWaylandSocketGroup, &wayland_group, buf,
sizeof(buf), &wayland_group_res)) < 0) {
PLOG(ERROR) << "getgrnam_r";
return nullptr;
}
if (wayland_group_res) {
if (HANDLE_EINTR(chown(socket_path.MaybeAsASCII().c_str(), -1,
wayland_group.gr_gid)) < 0) {
PLOG(ERROR) << "chown";
return nullptr;
}
} else {
LOG(WARNING) << "Group '" << kWaylandSocketGroup << "' not found";
}
if (!base::SetPosixFilePermissions(socket_path, 0660)) {
PLOG(ERROR) << "Could not set permissions: " << socket_path.value();
return nullptr;
}
return server;
}
bool Server::AddSocket(const std::string name) {
DCHECK(!name.empty());
return !wl_display_add_socket(wl_display_.get(), name.c_str());
}
int Server::GetFileDescriptor() const {
wl_event_loop* event_loop = wl_display_get_event_loop(wl_display_.get());
DCHECK(event_loop);
return wl_event_loop_get_fd(event_loop);
}
void Server::Dispatch(base::TimeDelta timeout) {
wl_event_loop* event_loop = wl_display_get_event_loop(wl_display_.get());
DCHECK(event_loop);
wl_event_loop_dispatch(event_loop, timeout.InMilliseconds());
}
void Server::Flush() {
wl_display_flush_clients(wl_display_.get());
}
void Server::OnDisplayAdded(const display::Display& new_display) {
auto output = std::make_unique<Output>(new_display.id());
output->set_global(wl_global_create(wl_display_.get(), &wl_output_interface,
output_version, output.get(),
bind_output));
DCHECK_EQ(outputs_.count(new_display.id()), 0u);
outputs_.insert(std::make_pair(new_display.id(), std::move(output)));
}
void Server::OnDisplayRemoved(const display::Display& old_display) {
DCHECK_EQ(outputs_.count(old_display.id()), 1u);
outputs_.erase(old_display.id());
}
} // namespace wayland
} // namespace exo
| 86,313 |
45,293 | /*
* Copyright 2010-2015 JetBrains s.r.o.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.jetbrains.kotlin.codegen;
import kotlin.collections.CollectionsKt;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.kotlin.backend.common.output.OutputFile;
import org.jetbrains.kotlin.load.java.JvmAbi;
import org.jetbrains.kotlin.metadata.jvm.deserialization.JvmMetadataVersion;
import org.jetbrains.kotlin.name.FqName;
import org.jetbrains.kotlin.test.ConfigurationKind;
import org.jetbrains.kotlin.utils.ExceptionUtilsKt;
import java.lang.annotation.Annotation;
import java.util.Collection;
import java.util.List;
import static org.jetbrains.kotlin.load.java.JvmAnnotationNames.METADATA_FQ_NAME;
import static org.jetbrains.kotlin.load.java.JvmAnnotationNames.METADATA_VERSION_FIELD_NAME;
public class KotlinSyntheticClassAnnotationTest extends CodegenTestCase {
private static final FqName PACKAGE_NAME = new FqName("test");
@Override
protected void setUp() throws Exception {
super.setUp();
createEnvironmentWithMockJdkAndIdeaAnnotations(ConfigurationKind.ALL);
}
public void testTraitImpl() {
doTestKotlinSyntheticClass(
"interface A { fun foo() = 42 }",
JvmAbi.DEFAULT_IMPLS_SUFFIX
);
}
public void testSamWrapper() {
doTestKotlinSyntheticClass(
"val f = {}\nval foo = Thread(f)",
"$sam"
);
}
public void testSamLambda() {
doTestKotlinSyntheticClass(
"val foo = Thread { }",
"$1"
);
}
public void testCallableReferenceWrapper() {
doTestKotlinSyntheticClass(
"val f = String::get",
"$1"
);
}
public void testLocalFunction() {
doTestKotlinSyntheticClass(
"fun foo() { fun bar() {} }",
"$1"
);
}
public void testAnonymousFunction() {
doTestKotlinSyntheticClass(
"val f = {}",
"$1"
);
}
public void testLocalClass() {
doTestKotlinClass(
"fun foo() { class Local }",
"Local"
);
}
public void testInnerClassOfLocalClass() {
doTestKotlinClass(
"fun foo() { class Local { inner class Inner } }",
"Inner"
);
}
public void testAnonymousObject() {
doTestKotlinClass(
"val o = object {}",
"$1"
);
}
public void testWhenMappings() {
doTestKotlinSyntheticClass(
"enum class E { A }\n" +
"val x = when (E.A) { E.A -> 1; else -> 0; }",
"WhenMappings"
);
}
private void doTestKotlinSyntheticClass(@NotNull String code, @NotNull String classFilePart) {
doTest(code, classFilePart);
}
private void doTestKotlinClass(@NotNull String code, @NotNull String classFilePart) {
doTest(code, classFilePart);
}
private void doTest(@NotNull String code, @NotNull String classFilePart) {
loadText("package " + PACKAGE_NAME + "\n\n" + code);
List<OutputFile> output = generateClassesInFile().asList();
Collection<OutputFile> files = CollectionsKt.filter(output, file -> file.getRelativePath().contains(classFilePart));
assertFalse("No files with \"" + classFilePart + "\" in the name are found: " + output, files.isEmpty());
assertEquals("Exactly one file with \"" + classFilePart + "\" in the name should be found: " + files, 1, files.size());
String path = files.iterator().next().getRelativePath();
String fqName = path.substring(0, path.length() - ".class".length()).replace('/', '.');
Class<?> aClass = generateClass(fqName);
assertAnnotatedWithMetadata(aClass);
}
private void assertAnnotatedWithMetadata(@NotNull Class<?> aClass) {
String annotationFqName = METADATA_FQ_NAME.asString();
Class<? extends Annotation> annotationClass = loadAnnotationClassQuietly(annotationFqName);
assertTrue("No annotation " + annotationFqName + " found in " + aClass, aClass.isAnnotationPresent(annotationClass));
Annotation annotation = aClass.getAnnotation(annotationClass);
int[] version = (int[]) CodegenTestUtil.getAnnotationAttribute(annotation, METADATA_VERSION_FIELD_NAME);
assertNotNull(version);
assertTrue("Annotation " + annotationFqName + " is written with an unsupported format",
new JvmMetadataVersion(version).isCompatible());
}
@NotNull
@SuppressWarnings("unchecked")
private Class<? extends Annotation> loadAnnotationClassQuietly(@NotNull String fqName) {
try {
return (Class<? extends Annotation>) initializedClassLoader.loadClass(fqName);
}
catch (ClassNotFoundException e) {
throw ExceptionUtilsKt.rethrow(e);
}
}
}
| 2,282 |
5,169 | <filename>Specs/3/1/a/StakkKit/1.7.0/StakkKit.podspec.json
{
"name": "StakkKit",
"version": "1.7.0",
"summary": "This a helper kit for ex-Stakk developers to develop iOS applications.",
"description": "This a helper kit for Stakk developers to develop iOS applications.\nTODO: Add long description of the pod here.",
"homepage": "https://bitbucket.org/stakkfactory/sf-stakkkit-mobile-ios.git",
"license": {
"type": "MIT",
"file": "LICENSE"
},
"authors": {
"Derek": "<EMAIL>"
},
"source": {
"git": "https://bitbucket.org/stakkfactory/sf-stakkkit-mobile-ios.git",
"tag": "1.7.0"
},
"platforms": {
"ios": "8.3"
},
"source_files": "StakkKit/Classes/**/*{h,m}",
"resources": "StakkKit/*{xcdatamodeld}",
"dependencies": {
"AFNetworking": [
"~> 3.1.0"
],
"JSONModel": [
"~> 1.5.1"
],
"CocoaLumberjack": [
"~> 3.0.0"
],
"MagicalRecord": [
"~> 2.3.2"
],
"PureLayout": [
"~> 3.0.2"
],
"SDWebImage": [
"~> 4.0"
],
"libextobjc/EXTScope": [
"~> 0.4.1"
]
}
}
| 548 |
1,826 | package com.vladsch.flexmark.formatter;
import com.vladsch.flexmark.util.sequence.SequenceUtils;
import org.jetbrains.annotations.Nullable;
import java.util.Set;
/**
* A renderer for a set of node types.
*/
public interface NodeFormatter {
/**
* @return the mapping of nodes this renderer handles to rendering function
*/
@Nullable Set<NodeFormattingHandler<?>> getNodeFormattingHandlers();
/**
* Collect nodes of given type so that they can be quickly accessed without traversing the AST
* by all formatting extensions.
*
* @return the nodes of interest to this formatter during formatting.
*/
@Nullable Set<Class<?>> getNodeClasses();
/**
* Return character which compacts like block quote prefix
*
* @return character or NUL if none
*/
default char getBlockQuoteLikePrefixChar() {
return SequenceUtils.NUL;
}
}
| 305 |
903 | package php.runtime.ext.core;
import php.runtime.Information;
import php.runtime.Memory;
import php.runtime.annotation.Runtime;
import php.runtime.env.Environment;
import php.runtime.env.TraceInfo;
import php.runtime.ext.support.Extension;
import php.runtime.ext.support.compile.CompileConstant;
import php.runtime.ext.support.compile.FunctionsContainer;
import php.runtime.memory.ArrayMemory;
import php.runtime.memory.LongMemory;
import php.runtime.memory.StringMemory;
import php.runtime.memory.output.PrintR;
import php.runtime.memory.output.Printer;
import php.runtime.memory.output.VarDump;
import php.runtime.memory.output.VarExport;
import php.runtime.memory.support.MemoryUtils;
import php.runtime.reflection.ClassEntity;
import php.runtime.reflection.ConstantEntity;
import php.runtime.reflection.FunctionEntity;
import java.io.StringWriter;
import java.lang.management.ManagementFactory;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
public class InfoFunctions extends FunctionsContainer {
public static Memory phpversion(Environment env, String extension){
if (extension == null || extension.isEmpty())
return new StringMemory(Information.LIKE_PHP_VERSION);
Extension ext = env.scope.getExtension(extension);
if (ext == null)
return Memory.NULL;
else
return new StringMemory(ext.getVersion());
}
public static Memory phpversion(Environment env){
return phpversion(env, null);
}
/** SKIP **/
public static int gc_collect_cycles(){
System.gc();
return 0;
}
public static void gc_disable(){ /* NOP */ }
public static void gc_enable(){ /* NOP */ }
public static boolean gc_enabled(){ return true; }
public static boolean get_magic_quotes_gpc(){ return false; }
public static boolean get_magic_quotes_runtime(){ return false; }
public static boolean set_magic_quotes_runtime(){ return false; }
public static String get_current_user(){
return System.getProperty("user.name");
}
public static Memory get_defined_constants(Environment env, boolean capitalize){
Set<String> exists = new HashSet<String>();
ArrayMemory result = new ArrayMemory();
for(String ext : env.scope.getExtensions()){
Extension extension = env.scope.getExtension(ext);
ArrayMemory item = result;
if (capitalize)
item = (ArrayMemory) result.refOfIndex(ext).assign(new ArrayMemory());
for(CompileConstant constant : extension.getConstants().values()){
item.put(constant.name, constant.value);
exists.add(constant.name);
}
}
ArrayMemory item = result;
if (capitalize)
item = (ArrayMemory) result.refOfIndex("user").assign(new ArrayMemory());
for(ConstantEntity constant : env.scope.getConstants()){
if (!exists.contains(constant.getName()))
item.put(constant.getName(), constant.getValue());
}
for(ConstantEntity constant : env.getConstants().values()){
if (!exists.contains(constant.getName()))
item.put(constant.getName(), constant.getValue());
}
return result;
}
public static Memory get_defined_constants(Environment env){
return get_defined_constants(env, false);
}
public static Memory get_declared_classes(Environment env){
ArrayMemory array = new ArrayMemory();
for(ClassEntity classEntity : env.getClasses()){
if (classEntity.getType() == ClassEntity.Type.CLASS)
array.add(classEntity.getName());
}
return array.toConstant();
}
public static Memory get_declared_interfaces(Environment env){
ArrayMemory array = new ArrayMemory();
for(ClassEntity classEntity : env.getClasses()){
if (classEntity.getType() == ClassEntity.Type.INTERFACE)
array.add(classEntity.getName());
}
return array.toConstant();
}
public static Memory get_declared_traits(Environment env) {
ArrayMemory array = new ArrayMemory();
for(ClassEntity classEntity : env.getClasses()){
if (classEntity.isTrait())
array.add(classEntity.getName());
}
return array.toConstant();
}
public static Memory get_defined_functions(Environment env){
ArrayMemory array = new ArrayMemory();
ArrayMemory item = (ArrayMemory)array.refOfIndex("internal").assign(new ArrayMemory());
for(FunctionEntity entity : env.getFunctions()){
if (entity.isInternal())
item.add(new StringMemory(entity.getName()));
}
item = (ArrayMemory)array.refOfIndex("user").assign(new ArrayMemory());
for(FunctionEntity entity : env.getLoadedFunctions().values()){
if (!entity.isInternal())
item.add(new StringMemory(entity.getName()));
}
return array.toConstant();
}
public static boolean extension_loaded(Environment env, String name){
return env.scope.getExtension(name) != null;
}
public static Memory get_loaded_extensions(Environment env){
return MemoryUtils.valueOf(env.scope.getExtensions());
}
public static Memory get_extension_funcs(Environment env, String name){
Extension ext = env.scope.getExtension(name);
if (ext == null) {
return Memory.FALSE;
}
return ArrayMemory.ofStringCollection(ext.getFunctions().keySet());
}
public static Memory ini_get(Environment env, String name){
return env.getConfigValue(name, Memory.NULL);
}
public static Memory ini_get_all(Environment env, String extension, boolean includingGlobal){
return env.getConfigValues(extension, includingGlobal);
}
public static Memory ini_get_all(Environment env, String extension){
return ini_get_all(env, extension, true);
}
public static void ini_set(Environment env, String name, Memory value){
env.setConfigValue(name, value);
}
public static void ini_alter(Environment env, String name, Memory value){
ini_set(env, name, value);
}
public static void ini_restore(Environment env, String name){
env.restoreConfigValue(name);
}
public static Memory get_included_files(Environment env){
return ArrayMemory.ofStringCollection(env.getModuleManager().getCachedPaths());
}
public static Memory get_required_files(Environment env){
return get_included_files(env);
}
public static Memory getmypid() {
// Should return something like '<pid>@<hostname>', at least in SUN / Oracle JVMs
final String jvmName = ManagementFactory.getRuntimeMXBean().getName();
final int index = jvmName.indexOf('@');
String pid = jvmName.substring(0, index);
return StringMemory.toLong(pid);
}
@Runtime.Immutable
public static String zend_version(){
return Information.LIKE_ZEND_VERSION;
}
public static long zend_thread_id(){
return Thread.currentThread().getId();
}
public static String sys_get_temp_dir(){
return System.getProperty("java.io.tmpdir");
}
public static Memory print_r(Environment env, @Runtime.Reference Memory value, boolean returned){
StringWriter writer = new StringWriter();
Printer printer = new PrintR(env, writer);
printer.print(value);
if (returned){
return new StringMemory(writer.toString());
} else {
env.echo(writer.toString());
return Memory.TRUE;
}
}
public static Memory print_r(Environment env, @Runtime.Reference Memory value){
return print_r(env, value, false);
}
public static Memory var_dump(Environment env, @Runtime.Reference Memory value, @Runtime.Reference Memory... values){
StringWriter writer = new StringWriter();
VarDump printer = new VarDump(env, writer);
printer.print(value);
if (values != null)
for(Memory el : values)
printer.print(el);
env.echo(writer.toString());
return Memory.TRUE;
}
public static Memory var_export(Environment env, TraceInfo trace, @Runtime.Reference Memory value, boolean returned){
StringWriter writer = new StringWriter();
VarExport printer = new VarExport(env, writer);
printer.print(value);
if (printer.isRecursionExists()){
env.warning(trace, "var_export does not handle circular references");
}
if (returned){
return new StringMemory(writer.toString());
} else {
env.echo(writer.toString());
return Memory.TRUE;
}
}
public static Memory var_export(Environment env, TraceInfo trace, @Runtime.Reference Memory value){
return var_export(env, trace, value, false);
}
public static String set_include_path(Environment env, String value){
String old = env.getConfigValue("include_path", Memory.CONST_EMPTY_STRING).toString();
env.setConfigValue("include_path", new StringMemory(value));
return old;
}
public static String get_include_path(Environment env){
return env.getConfigValue("include_path", Memory.CONST_EMPTY_STRING).toString();
}
public static void restore_include_path(Environment env){
env.restoreConfigValue("include_path");
}
public static Memory version_compare(String version1, String version2) {
return LongMemory.valueOf(version_compare0(version1, version2));
}
public static Memory version_compare(String version1, String version2, String operator) {
switch (operator) {
case "<":
case "lt":
return version_compare0(version1, version2) == -1 ? Memory.TRUE : Memory.FALSE;
case "<=":
case "le":
return version_compare0(version1, version2) <= 0 ? Memory.TRUE : Memory.FALSE;
case ">":
case "gt":
return version_compare0(version1, version2) == 1 ? Memory.TRUE : Memory.FALSE;
case ">=":
case "ge":
return version_compare0(version1, version2) >= 0 ? Memory.TRUE : Memory.FALSE;
case "=":
case "==":
case "eq":
return version_compare0(version1, version2) == 0 ? Memory.TRUE : Memory.FALSE;
case "!=":
case "<>":
case "ne":
return version_compare0(version1, version2) != 0 ? Memory.TRUE : Memory.FALSE;
default:
return Memory.NULL;
}
}
private static int version_compare0(String version1, String version2) {
return PHPVersion.of(version1).compareTo(PHPVersion.of(version2));
}
private static String normalizeVersion(String version) {
if (version == null || version.isEmpty())
return version;
StringBuilder buff = new StringBuilder(version.length());
for (int i = 0; i < version.length(); i++) {
char c = version.charAt(i);
switch (c) {
case '-':
case '+':
case '_':
buff.append('.');
break;
default:
if (Character.isLetter(c) && i - 1 >= 0 && Character.isDigit(version.charAt(i - 1))) {
buff.append('.');
} else if (Character.isDigit(c) && i - 1 >= 0 && Character.isLetter(version.charAt(i - 1))) {
buff.append('.');
}
buff.append(c);
}
}
return buff.toString();
}
private static class PHPVersion implements Comparable<PHPVersion> {
private static final int UNSPECIFIED = Integer.MIN_VALUE;
private static final PHPVersion INVALID_VERSION = new PHPVersion(UNSPECIFIED, UNSPECIFIED, UNSPECIFIED, null, UNSPECIFIED);
private static final Map<String, Integer> PRERELEASE_PRECEDENCE;
static {
Map<String, Integer> precedence = new HashMap<>(10);
precedence.put("dev", 0);
precedence.put("alpha", 1);
precedence.put("a", 1);
precedence.put("beta", 2);
precedence.put("b", 2);
precedence.put("RC", 3);
precedence.put("rc", 3);
precedence.put("#", 4);
precedence.put("pl", 5);
precedence.put("p", 5);
PRERELEASE_PRECEDENCE = Collections.unmodifiableMap(precedence);
}
private final int major;
private final int minor;
private final int patch;
private final String preRelease;
private final int build;
private PHPVersion(int major, int minor, int patch, String preRelease, int build) {
this.major = major;
this.minor = minor;
this.patch = patch;
this.preRelease = preRelease;
this.build = build;
}
static PHPVersion of(String version) {
if (version == null || version.isEmpty())
return INVALID_VERSION;
int major = UNSPECIFIED;
int minor = UNSPECIFIED;
int patch = UNSPECIFIED;
String preRelease = null;
int build = UNSPECIFIED;
for (String part : normalizeVersion(version).split("\\.")) {
try {
int partInt = Integer.valueOf(part);
if (preRelease == null) {
if (major == UNSPECIFIED) {
major = partInt;
} else if (minor == UNSPECIFIED) {
minor = partInt;
} else if (patch == UNSPECIFIED) {
patch = partInt;
}
} else if (build == UNSPECIFIED) {
build = partInt;
}
} catch (NumberFormatException e) {
preRelease = part;
}
}
preRelease = preRelease == null ? "#" : preRelease;
return new PHPVersion(major, minor, patch, preRelease, build);
}
@Override
public int compareTo(PHPVersion o) {
if (major != o.major)
return Integer.compare(major, o.major);
if (minor != o.minor)
return Integer.compare(minor, o.minor);
if (patch != o.patch)
return Integer.compare(patch, o.patch);
if (preRelease != null && o.preRelease == null)
return -1;
else if (preRelease == null && o.preRelease != null)
return 1;
if (getPreReleasePrecedence() != o.getPreReleasePrecedence()) {
return Integer.compare(getPreReleasePrecedence(), o.getPreReleasePrecedence());
}
if (build != o.build)
return Integer.compare(build, o.build);
return 0;
}
private int getPreReleasePrecedence() {
return PRERELEASE_PRECEDENCE.getOrDefault(preRelease, UNSPECIFIED);
}
}
}
| 6,629 |
490 | import math
import torch
from fairseq import metrics, utils
from fairseq.criterions import FairseqCriterion, register_criterion
# Grid cross-entropy of pervasive attention models for simultaneous translation
# pa_grid_cross_entropy_v2
@register_criterion('grid_cross_entropy')
class GridCrossEntropyCriterion(FairseqCriterion):
def __init__(self, args, task):
super().__init__(task)
self.eps = args.label_smoothing
self.lower_diag = args.lower_diag
self.finish_reading = args.finish_reading
self.dynamic_denom = args.dynamic_denom
self.sentence_avg = args.sentence_avg
@classmethod
def build_criterion(cls, args, task):
return cls(args, task)
@staticmethod
def add_args(parser):
"""Add criterion-specific arguments to the parser."""
parser.add_argument('--label-smoothing', default=0., type=float, metavar='D',
help='epsilon for label smoothing, 0 means no label smoothing')
parser.add_argument('--lower-diag', default=0, type=int)
parser.add_argument('--finish-reading', default=False, action='store_true')
parser.add_argument('--dynamic-denom', default=False, action='store_true')
def forward(self, model, sample, **kwargs):
net_output = model(**sample['net_input'])
loss, nll_loss = self.compute_loss(model, net_output, sample)
sample_size = sample['target'].size(0) if self.sentence_avg else sample['ntokens']
logging_output = {
'loss': utils.item(loss.data),
'nll_loss': utils.item(nll_loss.data),
'ntokens': sample['ntokens'],
'nsentences': sample['target'].size(0),
'sample_size': sample_size,
}
return loss, sample_size, logging_output
def compute_loss(self, model, net_output, sample):
lprobs = model.get_normalized_probs(net_output, log_probs=True)
B, Tt, Ts, V = lprobs.size()
target = model.get_targets(sample, net_output).unsqueeze(-1).repeat(1, 1, Ts) # B,Tt,Ts
non_pad_mask = target.ne(self.padding_idx)
grid_mask = torch.triu(target.new_ones(Tt, Ts), self.lower_diag)
# Always include Ts in the contexts
grid_mask[:,-1] = 1
if self.finish_reading:
shift_back = target.eq(self.padding_idx).int().sum(dim=-1).max().item() + 1
# Last rows only with full context to predict EOS:
grid_mask[-shift_back:,:-1] = 0
grid_mask[-shift_back:,-1] = 1
if self.dynamic_denom:
denom = grid_mask.sum(-1, keepdim=True).unsqueeze(-1) # B,Tt,1,1
if denom.eq(0).any():
print('Denom:', denom.flatten())
print('Tt,Ts=', Tt, Ts)
print('Grid mask:', grid_mask[0])
print('npad mask:', non_pad_mask)
# Normalize by number of contexts
lprobs = lprobs / denom.type_as(lprobs)
else:
# denom = (Ts - torch.arange(Tt)).clamp(min=1)
denom = grid_mask.sum(dim=-1)
lprobs = lprobs / denom.view(1,Tt,1,1).type_as(lprobs)
grid_mask = grid_mask.repeat(B, 1, 1)
select_mask = non_pad_mask * grid_mask.type_as(non_pad_mask)
lprobs = lprobs.view(-1, V)
select_mask = select_mask.view(-1, 1)
target = target.view(-1, 1)
nll_loss = -lprobs.gather(dim=-1, index=target)[select_mask]
smooth_loss = -lprobs.sum(dim=-1, keepdim=True)[select_mask]
nll_loss = nll_loss.sum()
smooth_loss = smooth_loss.sum()
eps_i = self.eps / lprobs.size(-1)
loss = (1. - self.eps) * nll_loss + eps_i * smooth_loss
return loss, nll_loss
@staticmethod
def reduce_metrics(logging_outputs) -> None:
""" Aggregate logging outputs from data parallel training. """
loss_sum = sum(log.get('loss', 0) for log in logging_outputs)
nll_loss_sum = sum(log.get('nll_loss', 0) for log in logging_outputs)
ntokens = sum(log.get('ntokens', 0) for log in logging_outputs)
sample_size = sum(log.get('sample_size', 0) for log in logging_outputs)
metrics.log_scalar('loss', loss_sum / sample_size / math.log(2), sample_size, round=3)
metrics.log_scalar('nll_loss', nll_loss_sum / ntokens / math.log(2), ntokens, round=3)
metrics.log_derived('ppl', lambda meters: utils.get_perplexity(meters['nll_loss'].avg))
@staticmethod
def logging_outputs_can_be_summed() -> bool:
return True
| 2,113 |
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.tagmanager;
/**
* Service definition for TagManager (v1).
*
* <p>
* This API allows clients to access and modify container and tag
configuration.
* </p>
*
* <p>
* For more information about this service, see the
* <a href="https://developers.google.com/tag-manager" target="_blank">API Documentation</a>
* </p>
*
* <p>
* This service uses {@link TagManagerRequestInitializer} to initialize global parameters via its
* {@link Builder}.
* </p>
*
* @since 1.3
* @author Google, Inc.
*/
@SuppressWarnings("javadoc")
public class TagManager extends com.google.api.client.googleapis.services.json.AbstractGoogleJsonClient {
// Note: Leave this static initializer at the top of the file.
static {
com.google.api.client.util.Preconditions.checkState(
com.google.api.client.googleapis.GoogleUtils.MAJOR_VERSION == 1 &&
com.google.api.client.googleapis.GoogleUtils.MINOR_VERSION >= 15,
"You are currently running with version %s of google-api-client. " +
"You need at least version 1.15 of google-api-client to run version " +
"1.27.0 of the Tag Manager API library.", com.google.api.client.googleapis.GoogleUtils.VERSION);
}
/**
* The default encoded root URL of the service. This is determined when the library is generated
* and normally should not be changed.
*
* @since 1.7
*/
public static final String DEFAULT_ROOT_URL = "https://www.googleapis.com/";
/**
* The default encoded service path of the service. This is determined when the library is
* generated and normally should not be changed.
*
* @since 1.7
*/
public static final String DEFAULT_SERVICE_PATH = "";
/**
* The default encoded batch path of the service. This is determined when the library is
* generated and normally should not be changed.
*
* @since 1.23
*/
public static final String DEFAULT_BATCH_PATH = "batch";
/**
* The default encoded base URL of the service. This is determined when the library is generated
* and normally should not be changed.
*/
public static final String DEFAULT_BASE_URL = DEFAULT_ROOT_URL + DEFAULT_SERVICE_PATH;
/**
* Constructor.
*
* <p>
* Use {@link Builder} if you need to specify any of the optional parameters.
* </p>
*
* @param transport HTTP transport, which should normally be:
* <ul>
* <li>Google App Engine:
* {@code com.google.api.client.extensions.appengine.http.UrlFetchTransport}</li>
* <li>Android: {@code newCompatibleTransport} from
* {@code com.google.api.client.extensions.android.http.AndroidHttp}</li>
* <li>Java: {@link com.google.api.client.googleapis.javanet.GoogleNetHttpTransport#newTrustedTransport()}
* </li>
* </ul>
* @param jsonFactory JSON factory, which may be:
* <ul>
* <li>Jackson: {@code com.google.api.client.json.jackson2.JacksonFactory}</li>
* <li>Google GSON: {@code com.google.api.client.json.gson.GsonFactory}</li>
* <li>Android Honeycomb or higher:
* {@code com.google.api.client.extensions.android.json.AndroidJsonFactory}</li>
* </ul>
* @param httpRequestInitializer HTTP request initializer or {@code null} for none
* @since 1.7
*/
public TagManager(com.google.api.client.http.HttpTransport transport, com.google.api.client.json.JsonFactory jsonFactory,
com.google.api.client.http.HttpRequestInitializer httpRequestInitializer) {
this(new Builder(transport, jsonFactory, httpRequestInitializer));
}
/**
* @param builder builder
*/
TagManager(Builder builder) {
super(builder);
}
@Override
protected void initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest<?> httpClientRequest) throws java.io.IOException {
super.initialize(httpClientRequest);
}
/**
* An accessor for creating requests from the Accounts collection.
*
* <p>The typical use is:</p>
* <pre>
* {@code TagManager tagmanager = new TagManager(...);}
* {@code TagManager.Accounts.List request = tagmanager.accounts().list(parameters ...)}
* </pre>
*
* @return the resource collection
*/
public Accounts accounts() {
return new Accounts();
}
/**
* The "accounts" collection of methods.
*/
public class Accounts {
/**
* Gets a GTM Account.
*
* Create a request for the method "accounts.get".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Get#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @return the request
*/
public Get get(java.lang.String accountId) throws java.io.IOException {
Get result = new Get(accountId);
initialize(result);
return result;
}
public class Get extends TagManagerRequest<com.google.api.services.tagmanager.model.Account> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}";
/**
* Gets a GTM Account.
*
* Create a request for the method "accounts.get".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Get#execute()} method to invoke the remote operation. <p>
* {@link Get#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)}
* must be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @since 1.13
*/
protected Get(java.lang.String accountId) {
super(TagManager.this, "GET", REST_PATH, null, com.google.api.services.tagmanager.model.Account.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
}
@Override
public com.google.api.client.http.HttpResponse executeUsingHead() throws java.io.IOException {
return super.executeUsingHead();
}
@Override
public com.google.api.client.http.HttpRequest buildHttpRequestUsingHead() throws java.io.IOException {
return super.buildHttpRequestUsingHead();
}
@Override
public Get set$Xgafv(java.lang.String $Xgafv) {
return (Get) super.set$Xgafv($Xgafv);
}
@Override
public Get setAccessToken(java.lang.String accessToken) {
return (Get) super.setAccessToken(accessToken);
}
@Override
public Get setAlt(java.lang.String alt) {
return (Get) super.setAlt(alt);
}
@Override
public Get setCallback(java.lang.String callback) {
return (Get) super.setCallback(callback);
}
@Override
public Get setFields(java.lang.String fields) {
return (Get) super.setFields(fields);
}
@Override
public Get setKey(java.lang.String key) {
return (Get) super.setKey(key);
}
@Override
public Get setOauthToken(java.lang.String oauthToken) {
return (Get) super.setOauthToken(oauthToken);
}
@Override
public Get setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Get) super.setPrettyPrint(prettyPrint);
}
@Override
public Get setQuotaUser(java.lang.String quotaUser) {
return (Get) super.setQuotaUser(quotaUser);
}
@Override
public Get setUploadType(java.lang.String uploadType) {
return (Get) super.setUploadType(uploadType);
}
@Override
public Get setUploadProtocol(java.lang.String uploadProtocol) {
return (Get) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Get setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
@Override
public Get set(String parameterName, Object value) {
return (Get) super.set(parameterName, value);
}
}
/**
* Lists all GTM Accounts that a user has access to.
*
* Create a request for the method "accounts.list".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link List#execute()} method to invoke the remote operation.
*
* @return the request
*/
public List list() throws java.io.IOException {
List result = new List();
initialize(result);
return result;
}
public class List extends TagManagerRequest<com.google.api.services.tagmanager.model.ListAccountsResponse> {
private static final String REST_PATH = "tagmanager/v1/accounts";
/**
* Lists all GTM Accounts that a user has access to.
*
* Create a request for the method "accounts.list".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link List#execute()} method to invoke the remote operation. <p>
* {@link List#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)}
* must be called to initialize this instance immediately after invoking the constructor. </p>
*
* @since 1.13
*/
protected List() {
super(TagManager.this, "GET", REST_PATH, null, com.google.api.services.tagmanager.model.ListAccountsResponse.class);
}
@Override
public com.google.api.client.http.HttpResponse executeUsingHead() throws java.io.IOException {
return super.executeUsingHead();
}
@Override
public com.google.api.client.http.HttpRequest buildHttpRequestUsingHead() throws java.io.IOException {
return super.buildHttpRequestUsingHead();
}
@Override
public List set$Xgafv(java.lang.String $Xgafv) {
return (List) super.set$Xgafv($Xgafv);
}
@Override
public List setAccessToken(java.lang.String accessToken) {
return (List) super.setAccessToken(accessToken);
}
@Override
public List setAlt(java.lang.String alt) {
return (List) super.setAlt(alt);
}
@Override
public List setCallback(java.lang.String callback) {
return (List) super.setCallback(callback);
}
@Override
public List setFields(java.lang.String fields) {
return (List) super.setFields(fields);
}
@Override
public List setKey(java.lang.String key) {
return (List) super.setKey(key);
}
@Override
public List setOauthToken(java.lang.String oauthToken) {
return (List) super.setOauthToken(oauthToken);
}
@Override
public List setPrettyPrint(java.lang.Boolean prettyPrint) {
return (List) super.setPrettyPrint(prettyPrint);
}
@Override
public List setQuotaUser(java.lang.String quotaUser) {
return (List) super.setQuotaUser(quotaUser);
}
@Override
public List setUploadType(java.lang.String uploadType) {
return (List) super.setUploadType(uploadType);
}
@Override
public List setUploadProtocol(java.lang.String uploadProtocol) {
return (List) super.setUploadProtocol(uploadProtocol);
}
@Override
public List set(String parameterName, Object value) {
return (List) super.set(parameterName, value);
}
}
/**
* Updates a GTM Account.
*
* Create a request for the method "accounts.update".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Update#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param content the {@link com.google.api.services.tagmanager.model.Account}
* @return the request
*/
public Update update(java.lang.String accountId, com.google.api.services.tagmanager.model.Account content) throws java.io.IOException {
Update result = new Update(accountId, content);
initialize(result);
return result;
}
public class Update extends TagManagerRequest<com.google.api.services.tagmanager.model.Account> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}";
/**
* Updates a GTM Account.
*
* Create a request for the method "accounts.update".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Update#execute()} method to invoke the remote operation.
* <p> {@link
* Update#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must
* be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param content the {@link com.google.api.services.tagmanager.model.Account}
* @since 1.13
*/
protected Update(java.lang.String accountId, com.google.api.services.tagmanager.model.Account content) {
super(TagManager.this, "PUT", REST_PATH, content, com.google.api.services.tagmanager.model.Account.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
}
@Override
public Update set$Xgafv(java.lang.String $Xgafv) {
return (Update) super.set$Xgafv($Xgafv);
}
@Override
public Update setAccessToken(java.lang.String accessToken) {
return (Update) super.setAccessToken(accessToken);
}
@Override
public Update setAlt(java.lang.String alt) {
return (Update) super.setAlt(alt);
}
@Override
public Update setCallback(java.lang.String callback) {
return (Update) super.setCallback(callback);
}
@Override
public Update setFields(java.lang.String fields) {
return (Update) super.setFields(fields);
}
@Override
public Update setKey(java.lang.String key) {
return (Update) super.setKey(key);
}
@Override
public Update setOauthToken(java.lang.String oauthToken) {
return (Update) super.setOauthToken(oauthToken);
}
@Override
public Update setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Update) super.setPrettyPrint(prettyPrint);
}
@Override
public Update setQuotaUser(java.lang.String quotaUser) {
return (Update) super.setQuotaUser(quotaUser);
}
@Override
public Update setUploadType(java.lang.String uploadType) {
return (Update) super.setUploadType(uploadType);
}
@Override
public Update setUploadProtocol(java.lang.String uploadProtocol) {
return (Update) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Update setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/**
* When provided, this fingerprint must match the fingerprint of the account in storage.
*/
@com.google.api.client.util.Key
private java.lang.String fingerprint;
/** When provided, this fingerprint must match the fingerprint of the account in storage.
*/
public java.lang.String getFingerprint() {
return fingerprint;
}
/**
* When provided, this fingerprint must match the fingerprint of the account in storage.
*/
public Update setFingerprint(java.lang.String fingerprint) {
this.fingerprint = fingerprint;
return this;
}
@Override
public Update set(String parameterName, Object value) {
return (Update) super.set(parameterName, value);
}
}
/**
* An accessor for creating requests from the Containers collection.
*
* <p>The typical use is:</p>
* <pre>
* {@code TagManager tagmanager = new TagManager(...);}
* {@code TagManager.Containers.List request = tagmanager.containers().list(parameters ...)}
* </pre>
*
* @return the resource collection
*/
public Containers containers() {
return new Containers();
}
/**
* The "containers" collection of methods.
*/
public class Containers {
/**
* Creates a Container.
*
* Create a request for the method "containers.create".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Create#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param content the {@link com.google.api.services.tagmanager.model.Container}
* @return the request
*/
public Create create(java.lang.String accountId, com.google.api.services.tagmanager.model.Container content) throws java.io.IOException {
Create result = new Create(accountId, content);
initialize(result);
return result;
}
public class Create extends TagManagerRequest<com.google.api.services.tagmanager.model.Container> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers";
/**
* Creates a Container.
*
* Create a request for the method "containers.create".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Create#execute()} method to invoke the remote operation.
* <p> {@link
* Create#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must
* be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param content the {@link com.google.api.services.tagmanager.model.Container}
* @since 1.13
*/
protected Create(java.lang.String accountId, com.google.api.services.tagmanager.model.Container content) {
super(TagManager.this, "POST", REST_PATH, content, com.google.api.services.tagmanager.model.Container.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
checkRequiredParameter(content, "content");
checkRequiredParameter(content.getName(), "Container.getName()");
checkRequiredParameter(content, "content");
checkRequiredParameter(content.getTimeZoneCountryId(), "Container.getTimeZoneCountryId()");
checkRequiredParameter(content, "content");
checkRequiredParameter(content.getTimeZoneId(), "Container.getTimeZoneId()");
}
@Override
public Create set$Xgafv(java.lang.String $Xgafv) {
return (Create) super.set$Xgafv($Xgafv);
}
@Override
public Create setAccessToken(java.lang.String accessToken) {
return (Create) super.setAccessToken(accessToken);
}
@Override
public Create setAlt(java.lang.String alt) {
return (Create) super.setAlt(alt);
}
@Override
public Create setCallback(java.lang.String callback) {
return (Create) super.setCallback(callback);
}
@Override
public Create setFields(java.lang.String fields) {
return (Create) super.setFields(fields);
}
@Override
public Create setKey(java.lang.String key) {
return (Create) super.setKey(key);
}
@Override
public Create setOauthToken(java.lang.String oauthToken) {
return (Create) super.setOauthToken(oauthToken);
}
@Override
public Create setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Create) super.setPrettyPrint(prettyPrint);
}
@Override
public Create setQuotaUser(java.lang.String quotaUser) {
return (Create) super.setQuotaUser(quotaUser);
}
@Override
public Create setUploadType(java.lang.String uploadType) {
return (Create) super.setUploadType(uploadType);
}
@Override
public Create setUploadProtocol(java.lang.String uploadProtocol) {
return (Create) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Create setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
@Override
public Create set(String parameterName, Object value) {
return (Create) super.set(parameterName, value);
}
}
/**
* Deletes a Container.
*
* Create a request for the method "containers.delete".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Delete#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @return the request
*/
public Delete delete(java.lang.String accountId, java.lang.String containerId) throws java.io.IOException {
Delete result = new Delete(accountId, containerId);
initialize(result);
return result;
}
public class Delete extends TagManagerRequest<Void> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}";
/**
* Deletes a Container.
*
* Create a request for the method "containers.delete".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Delete#execute()} method to invoke the remote operation.
* <p> {@link
* Delete#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must
* be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @since 1.13
*/
protected Delete(java.lang.String accountId, java.lang.String containerId) {
super(TagManager.this, "DELETE", REST_PATH, null, Void.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
}
@Override
public Delete set$Xgafv(java.lang.String $Xgafv) {
return (Delete) super.set$Xgafv($Xgafv);
}
@Override
public Delete setAccessToken(java.lang.String accessToken) {
return (Delete) super.setAccessToken(accessToken);
}
@Override
public Delete setAlt(java.lang.String alt) {
return (Delete) super.setAlt(alt);
}
@Override
public Delete setCallback(java.lang.String callback) {
return (Delete) super.setCallback(callback);
}
@Override
public Delete setFields(java.lang.String fields) {
return (Delete) super.setFields(fields);
}
@Override
public Delete setKey(java.lang.String key) {
return (Delete) super.setKey(key);
}
@Override
public Delete setOauthToken(java.lang.String oauthToken) {
return (Delete) super.setOauthToken(oauthToken);
}
@Override
public Delete setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Delete) super.setPrettyPrint(prettyPrint);
}
@Override
public Delete setQuotaUser(java.lang.String quotaUser) {
return (Delete) super.setQuotaUser(quotaUser);
}
@Override
public Delete setUploadType(java.lang.String uploadType) {
return (Delete) super.setUploadType(uploadType);
}
@Override
public Delete setUploadProtocol(java.lang.String uploadProtocol) {
return (Delete) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Delete setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Delete setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
@Override
public Delete set(String parameterName, Object value) {
return (Delete) super.set(parameterName, value);
}
}
/**
* Gets a Container.
*
* Create a request for the method "containers.get".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Get#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @return the request
*/
public Get get(java.lang.String accountId, java.lang.String containerId) throws java.io.IOException {
Get result = new Get(accountId, containerId);
initialize(result);
return result;
}
public class Get extends TagManagerRequest<com.google.api.services.tagmanager.model.Container> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}";
/**
* Gets a Container.
*
* Create a request for the method "containers.get".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Get#execute()} method to invoke the remote operation. <p>
* {@link Get#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)}
* must be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @since 1.13
*/
protected Get(java.lang.String accountId, java.lang.String containerId) {
super(TagManager.this, "GET", REST_PATH, null, com.google.api.services.tagmanager.model.Container.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
}
@Override
public com.google.api.client.http.HttpResponse executeUsingHead() throws java.io.IOException {
return super.executeUsingHead();
}
@Override
public com.google.api.client.http.HttpRequest buildHttpRequestUsingHead() throws java.io.IOException {
return super.buildHttpRequestUsingHead();
}
@Override
public Get set$Xgafv(java.lang.String $Xgafv) {
return (Get) super.set$Xgafv($Xgafv);
}
@Override
public Get setAccessToken(java.lang.String accessToken) {
return (Get) super.setAccessToken(accessToken);
}
@Override
public Get setAlt(java.lang.String alt) {
return (Get) super.setAlt(alt);
}
@Override
public Get setCallback(java.lang.String callback) {
return (Get) super.setCallback(callback);
}
@Override
public Get setFields(java.lang.String fields) {
return (Get) super.setFields(fields);
}
@Override
public Get setKey(java.lang.String key) {
return (Get) super.setKey(key);
}
@Override
public Get setOauthToken(java.lang.String oauthToken) {
return (Get) super.setOauthToken(oauthToken);
}
@Override
public Get setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Get) super.setPrettyPrint(prettyPrint);
}
@Override
public Get setQuotaUser(java.lang.String quotaUser) {
return (Get) super.setQuotaUser(quotaUser);
}
@Override
public Get setUploadType(java.lang.String uploadType) {
return (Get) super.setUploadType(uploadType);
}
@Override
public Get setUploadProtocol(java.lang.String uploadProtocol) {
return (Get) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Get setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Get setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
@Override
public Get set(String parameterName, Object value) {
return (Get) super.set(parameterName, value);
}
}
/**
* Lists all Containers that belongs to a GTM Account.
*
* Create a request for the method "containers.list".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link List#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @return the request
*/
public List list(java.lang.String accountId) throws java.io.IOException {
List result = new List(accountId);
initialize(result);
return result;
}
public class List extends TagManagerRequest<com.google.api.services.tagmanager.model.ListContainersResponse> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers";
/**
* Lists all Containers that belongs to a GTM Account.
*
* Create a request for the method "containers.list".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link List#execute()} method to invoke the remote operation. <p>
* {@link List#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)}
* must be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @since 1.13
*/
protected List(java.lang.String accountId) {
super(TagManager.this, "GET", REST_PATH, null, com.google.api.services.tagmanager.model.ListContainersResponse.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
}
@Override
public com.google.api.client.http.HttpResponse executeUsingHead() throws java.io.IOException {
return super.executeUsingHead();
}
@Override
public com.google.api.client.http.HttpRequest buildHttpRequestUsingHead() throws java.io.IOException {
return super.buildHttpRequestUsingHead();
}
@Override
public List set$Xgafv(java.lang.String $Xgafv) {
return (List) super.set$Xgafv($Xgafv);
}
@Override
public List setAccessToken(java.lang.String accessToken) {
return (List) super.setAccessToken(accessToken);
}
@Override
public List setAlt(java.lang.String alt) {
return (List) super.setAlt(alt);
}
@Override
public List setCallback(java.lang.String callback) {
return (List) super.setCallback(callback);
}
@Override
public List setFields(java.lang.String fields) {
return (List) super.setFields(fields);
}
@Override
public List setKey(java.lang.String key) {
return (List) super.setKey(key);
}
@Override
public List setOauthToken(java.lang.String oauthToken) {
return (List) super.setOauthToken(oauthToken);
}
@Override
public List setPrettyPrint(java.lang.Boolean prettyPrint) {
return (List) super.setPrettyPrint(prettyPrint);
}
@Override
public List setQuotaUser(java.lang.String quotaUser) {
return (List) super.setQuotaUser(quotaUser);
}
@Override
public List setUploadType(java.lang.String uploadType) {
return (List) super.setUploadType(uploadType);
}
@Override
public List setUploadProtocol(java.lang.String uploadProtocol) {
return (List) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public List setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
@Override
public List set(String parameterName, Object value) {
return (List) super.set(parameterName, value);
}
}
/**
* Updates a Container.
*
* Create a request for the method "containers.update".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Update#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param content the {@link com.google.api.services.tagmanager.model.Container}
* @return the request
*/
public Update update(java.lang.String accountId, java.lang.String containerId, com.google.api.services.tagmanager.model.Container content) throws java.io.IOException {
Update result = new Update(accountId, containerId, content);
initialize(result);
return result;
}
public class Update extends TagManagerRequest<com.google.api.services.tagmanager.model.Container> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}";
/**
* Updates a Container.
*
* Create a request for the method "containers.update".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Update#execute()} method to invoke the remote operation.
* <p> {@link
* Update#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must
* be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param content the {@link com.google.api.services.tagmanager.model.Container}
* @since 1.13
*/
protected Update(java.lang.String accountId, java.lang.String containerId, com.google.api.services.tagmanager.model.Container content) {
super(TagManager.this, "PUT", REST_PATH, content, com.google.api.services.tagmanager.model.Container.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
}
@Override
public Update set$Xgafv(java.lang.String $Xgafv) {
return (Update) super.set$Xgafv($Xgafv);
}
@Override
public Update setAccessToken(java.lang.String accessToken) {
return (Update) super.setAccessToken(accessToken);
}
@Override
public Update setAlt(java.lang.String alt) {
return (Update) super.setAlt(alt);
}
@Override
public Update setCallback(java.lang.String callback) {
return (Update) super.setCallback(callback);
}
@Override
public Update setFields(java.lang.String fields) {
return (Update) super.setFields(fields);
}
@Override
public Update setKey(java.lang.String key) {
return (Update) super.setKey(key);
}
@Override
public Update setOauthToken(java.lang.String oauthToken) {
return (Update) super.setOauthToken(oauthToken);
}
@Override
public Update setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Update) super.setPrettyPrint(prettyPrint);
}
@Override
public Update setQuotaUser(java.lang.String quotaUser) {
return (Update) super.setQuotaUser(quotaUser);
}
@Override
public Update setUploadType(java.lang.String uploadType) {
return (Update) super.setUploadType(uploadType);
}
@Override
public Update setUploadProtocol(java.lang.String uploadProtocol) {
return (Update) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Update setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Update setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
/**
* When provided, this fingerprint must match the fingerprint of the container in storage.
*/
@com.google.api.client.util.Key
private java.lang.String fingerprint;
/** When provided, this fingerprint must match the fingerprint of the container in storage.
*/
public java.lang.String getFingerprint() {
return fingerprint;
}
/**
* When provided, this fingerprint must match the fingerprint of the container in storage.
*/
public Update setFingerprint(java.lang.String fingerprint) {
this.fingerprint = fingerprint;
return this;
}
@Override
public Update set(String parameterName, Object value) {
return (Update) super.set(parameterName, value);
}
}
/**
* An accessor for creating requests from the Environments collection.
*
* <p>The typical use is:</p>
* <pre>
* {@code TagManager tagmanager = new TagManager(...);}
* {@code TagManager.Environments.List request = tagmanager.environments().list(parameters ...)}
* </pre>
*
* @return the resource collection
*/
public Environments environments() {
return new Environments();
}
/**
* The "environments" collection of methods.
*/
public class Environments {
/**
* Creates a GTM Environment.
*
* Create a request for the method "environments.create".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Create#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param content the {@link com.google.api.services.tagmanager.model.Environment}
* @return the request
*/
public Create create(java.lang.String accountId, java.lang.String containerId, com.google.api.services.tagmanager.model.Environment content) throws java.io.IOException {
Create result = new Create(accountId, containerId, content);
initialize(result);
return result;
}
public class Create extends TagManagerRequest<com.google.api.services.tagmanager.model.Environment> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/environments";
/**
* Creates a GTM Environment.
*
* Create a request for the method "environments.create".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Create#execute()} method to invoke the remote operation.
* <p> {@link
* Create#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must
* be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param content the {@link com.google.api.services.tagmanager.model.Environment}
* @since 1.13
*/
protected Create(java.lang.String accountId, java.lang.String containerId, com.google.api.services.tagmanager.model.Environment content) {
super(TagManager.this, "POST", REST_PATH, content, com.google.api.services.tagmanager.model.Environment.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
checkRequiredParameter(content, "content");
checkRequiredParameter(content.getName(), "Environment.getName()");
}
@Override
public Create set$Xgafv(java.lang.String $Xgafv) {
return (Create) super.set$Xgafv($Xgafv);
}
@Override
public Create setAccessToken(java.lang.String accessToken) {
return (Create) super.setAccessToken(accessToken);
}
@Override
public Create setAlt(java.lang.String alt) {
return (Create) super.setAlt(alt);
}
@Override
public Create setCallback(java.lang.String callback) {
return (Create) super.setCallback(callback);
}
@Override
public Create setFields(java.lang.String fields) {
return (Create) super.setFields(fields);
}
@Override
public Create setKey(java.lang.String key) {
return (Create) super.setKey(key);
}
@Override
public Create setOauthToken(java.lang.String oauthToken) {
return (Create) super.setOauthToken(oauthToken);
}
@Override
public Create setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Create) super.setPrettyPrint(prettyPrint);
}
@Override
public Create setQuotaUser(java.lang.String quotaUser) {
return (Create) super.setQuotaUser(quotaUser);
}
@Override
public Create setUploadType(java.lang.String uploadType) {
return (Create) super.setUploadType(uploadType);
}
@Override
public Create setUploadProtocol(java.lang.String uploadProtocol) {
return (Create) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Create setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Create setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
@Override
public Create set(String parameterName, Object value) {
return (Create) super.set(parameterName, value);
}
}
/**
* Deletes a GTM Environment.
*
* Create a request for the method "environments.delete".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Delete#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param environmentId The GTM Environment ID.
* @return the request
*/
public Delete delete(java.lang.String accountId, java.lang.String containerId, java.lang.String environmentId) throws java.io.IOException {
Delete result = new Delete(accountId, containerId, environmentId);
initialize(result);
return result;
}
public class Delete extends TagManagerRequest<Void> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/environments/{environmentId}";
/**
* Deletes a GTM Environment.
*
* Create a request for the method "environments.delete".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Delete#execute()} method to invoke the remote operation.
* <p> {@link
* Delete#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must
* be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param environmentId The GTM Environment ID.
* @since 1.13
*/
protected Delete(java.lang.String accountId, java.lang.String containerId, java.lang.String environmentId) {
super(TagManager.this, "DELETE", REST_PATH, null, Void.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
this.environmentId = com.google.api.client.util.Preconditions.checkNotNull(environmentId, "Required parameter environmentId must be specified.");
}
@Override
public Delete set$Xgafv(java.lang.String $Xgafv) {
return (Delete) super.set$Xgafv($Xgafv);
}
@Override
public Delete setAccessToken(java.lang.String accessToken) {
return (Delete) super.setAccessToken(accessToken);
}
@Override
public Delete setAlt(java.lang.String alt) {
return (Delete) super.setAlt(alt);
}
@Override
public Delete setCallback(java.lang.String callback) {
return (Delete) super.setCallback(callback);
}
@Override
public Delete setFields(java.lang.String fields) {
return (Delete) super.setFields(fields);
}
@Override
public Delete setKey(java.lang.String key) {
return (Delete) super.setKey(key);
}
@Override
public Delete setOauthToken(java.lang.String oauthToken) {
return (Delete) super.setOauthToken(oauthToken);
}
@Override
public Delete setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Delete) super.setPrettyPrint(prettyPrint);
}
@Override
public Delete setQuotaUser(java.lang.String quotaUser) {
return (Delete) super.setQuotaUser(quotaUser);
}
@Override
public Delete setUploadType(java.lang.String uploadType) {
return (Delete) super.setUploadType(uploadType);
}
@Override
public Delete setUploadProtocol(java.lang.String uploadProtocol) {
return (Delete) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Delete setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Delete setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
/** The GTM Environment ID. */
@com.google.api.client.util.Key
private java.lang.String environmentId;
/** The GTM Environment ID.
*/
public java.lang.String getEnvironmentId() {
return environmentId;
}
/** The GTM Environment ID. */
public Delete setEnvironmentId(java.lang.String environmentId) {
this.environmentId = environmentId;
return this;
}
@Override
public Delete set(String parameterName, Object value) {
return (Delete) super.set(parameterName, value);
}
}
/**
* Gets a GTM Environment.
*
* Create a request for the method "environments.get".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Get#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param environmentId The GTM Environment ID.
* @return the request
*/
public Get get(java.lang.String accountId, java.lang.String containerId, java.lang.String environmentId) throws java.io.IOException {
Get result = new Get(accountId, containerId, environmentId);
initialize(result);
return result;
}
public class Get extends TagManagerRequest<com.google.api.services.tagmanager.model.Environment> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/environments/{environmentId}";
/**
* Gets a GTM Environment.
*
* Create a request for the method "environments.get".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Get#execute()} method to invoke the remote operation. <p>
* {@link Get#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)}
* must be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param environmentId The GTM Environment ID.
* @since 1.13
*/
protected Get(java.lang.String accountId, java.lang.String containerId, java.lang.String environmentId) {
super(TagManager.this, "GET", REST_PATH, null, com.google.api.services.tagmanager.model.Environment.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
this.environmentId = com.google.api.client.util.Preconditions.checkNotNull(environmentId, "Required parameter environmentId must be specified.");
}
@Override
public com.google.api.client.http.HttpResponse executeUsingHead() throws java.io.IOException {
return super.executeUsingHead();
}
@Override
public com.google.api.client.http.HttpRequest buildHttpRequestUsingHead() throws java.io.IOException {
return super.buildHttpRequestUsingHead();
}
@Override
public Get set$Xgafv(java.lang.String $Xgafv) {
return (Get) super.set$Xgafv($Xgafv);
}
@Override
public Get setAccessToken(java.lang.String accessToken) {
return (Get) super.setAccessToken(accessToken);
}
@Override
public Get setAlt(java.lang.String alt) {
return (Get) super.setAlt(alt);
}
@Override
public Get setCallback(java.lang.String callback) {
return (Get) super.setCallback(callback);
}
@Override
public Get setFields(java.lang.String fields) {
return (Get) super.setFields(fields);
}
@Override
public Get setKey(java.lang.String key) {
return (Get) super.setKey(key);
}
@Override
public Get setOauthToken(java.lang.String oauthToken) {
return (Get) super.setOauthToken(oauthToken);
}
@Override
public Get setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Get) super.setPrettyPrint(prettyPrint);
}
@Override
public Get setQuotaUser(java.lang.String quotaUser) {
return (Get) super.setQuotaUser(quotaUser);
}
@Override
public Get setUploadType(java.lang.String uploadType) {
return (Get) super.setUploadType(uploadType);
}
@Override
public Get setUploadProtocol(java.lang.String uploadProtocol) {
return (Get) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Get setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Get setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
/** The GTM Environment ID. */
@com.google.api.client.util.Key
private java.lang.String environmentId;
/** The GTM Environment ID.
*/
public java.lang.String getEnvironmentId() {
return environmentId;
}
/** The GTM Environment ID. */
public Get setEnvironmentId(java.lang.String environmentId) {
this.environmentId = environmentId;
return this;
}
@Override
public Get set(String parameterName, Object value) {
return (Get) super.set(parameterName, value);
}
}
/**
* Lists all GTM Environments of a GTM Container.
*
* Create a request for the method "environments.list".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link List#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @return the request
*/
public List list(java.lang.String accountId, java.lang.String containerId) throws java.io.IOException {
List result = new List(accountId, containerId);
initialize(result);
return result;
}
public class List extends TagManagerRequest<com.google.api.services.tagmanager.model.ListEnvironmentsResponse> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/environments";
/**
* Lists all GTM Environments of a GTM Container.
*
* Create a request for the method "environments.list".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link List#execute()} method to invoke the remote operation. <p>
* {@link List#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)}
* must be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @since 1.13
*/
protected List(java.lang.String accountId, java.lang.String containerId) {
super(TagManager.this, "GET", REST_PATH, null, com.google.api.services.tagmanager.model.ListEnvironmentsResponse.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
}
@Override
public com.google.api.client.http.HttpResponse executeUsingHead() throws java.io.IOException {
return super.executeUsingHead();
}
@Override
public com.google.api.client.http.HttpRequest buildHttpRequestUsingHead() throws java.io.IOException {
return super.buildHttpRequestUsingHead();
}
@Override
public List set$Xgafv(java.lang.String $Xgafv) {
return (List) super.set$Xgafv($Xgafv);
}
@Override
public List setAccessToken(java.lang.String accessToken) {
return (List) super.setAccessToken(accessToken);
}
@Override
public List setAlt(java.lang.String alt) {
return (List) super.setAlt(alt);
}
@Override
public List setCallback(java.lang.String callback) {
return (List) super.setCallback(callback);
}
@Override
public List setFields(java.lang.String fields) {
return (List) super.setFields(fields);
}
@Override
public List setKey(java.lang.String key) {
return (List) super.setKey(key);
}
@Override
public List setOauthToken(java.lang.String oauthToken) {
return (List) super.setOauthToken(oauthToken);
}
@Override
public List setPrettyPrint(java.lang.Boolean prettyPrint) {
return (List) super.setPrettyPrint(prettyPrint);
}
@Override
public List setQuotaUser(java.lang.String quotaUser) {
return (List) super.setQuotaUser(quotaUser);
}
@Override
public List setUploadType(java.lang.String uploadType) {
return (List) super.setUploadType(uploadType);
}
@Override
public List setUploadProtocol(java.lang.String uploadProtocol) {
return (List) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public List setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public List setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
@Override
public List set(String parameterName, Object value) {
return (List) super.set(parameterName, value);
}
}
/**
* Updates a GTM Environment.
*
* Create a request for the method "environments.update".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Update#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param environmentId The GTM Environment ID.
* @param content the {@link com.google.api.services.tagmanager.model.Environment}
* @return the request
*/
public Update update(java.lang.String accountId, java.lang.String containerId, java.lang.String environmentId, com.google.api.services.tagmanager.model.Environment content) throws java.io.IOException {
Update result = new Update(accountId, containerId, environmentId, content);
initialize(result);
return result;
}
public class Update extends TagManagerRequest<com.google.api.services.tagmanager.model.Environment> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/environments/{environmentId}";
/**
* Updates a GTM Environment.
*
* Create a request for the method "environments.update".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Update#execute()} method to invoke the remote operation.
* <p> {@link
* Update#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must
* be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param environmentId The GTM Environment ID.
* @param content the {@link com.google.api.services.tagmanager.model.Environment}
* @since 1.13
*/
protected Update(java.lang.String accountId, java.lang.String containerId, java.lang.String environmentId, com.google.api.services.tagmanager.model.Environment content) {
super(TagManager.this, "PUT", REST_PATH, content, com.google.api.services.tagmanager.model.Environment.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
this.environmentId = com.google.api.client.util.Preconditions.checkNotNull(environmentId, "Required parameter environmentId must be specified.");
checkRequiredParameter(content, "content");
checkRequiredParameter(content.getName(), "Environment.getName()");
}
@Override
public Update set$Xgafv(java.lang.String $Xgafv) {
return (Update) super.set$Xgafv($Xgafv);
}
@Override
public Update setAccessToken(java.lang.String accessToken) {
return (Update) super.setAccessToken(accessToken);
}
@Override
public Update setAlt(java.lang.String alt) {
return (Update) super.setAlt(alt);
}
@Override
public Update setCallback(java.lang.String callback) {
return (Update) super.setCallback(callback);
}
@Override
public Update setFields(java.lang.String fields) {
return (Update) super.setFields(fields);
}
@Override
public Update setKey(java.lang.String key) {
return (Update) super.setKey(key);
}
@Override
public Update setOauthToken(java.lang.String oauthToken) {
return (Update) super.setOauthToken(oauthToken);
}
@Override
public Update setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Update) super.setPrettyPrint(prettyPrint);
}
@Override
public Update setQuotaUser(java.lang.String quotaUser) {
return (Update) super.setQuotaUser(quotaUser);
}
@Override
public Update setUploadType(java.lang.String uploadType) {
return (Update) super.setUploadType(uploadType);
}
@Override
public Update setUploadProtocol(java.lang.String uploadProtocol) {
return (Update) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Update setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Update setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
/** The GTM Environment ID. */
@com.google.api.client.util.Key
private java.lang.String environmentId;
/** The GTM Environment ID.
*/
public java.lang.String getEnvironmentId() {
return environmentId;
}
/** The GTM Environment ID. */
public Update setEnvironmentId(java.lang.String environmentId) {
this.environmentId = environmentId;
return this;
}
/**
* When provided, this fingerprint must match the fingerprint of the environment in
* storage.
*/
@com.google.api.client.util.Key
private java.lang.String fingerprint;
/** When provided, this fingerprint must match the fingerprint of the environment in storage.
*/
public java.lang.String getFingerprint() {
return fingerprint;
}
/**
* When provided, this fingerprint must match the fingerprint of the environment in
* storage.
*/
public Update setFingerprint(java.lang.String fingerprint) {
this.fingerprint = fingerprint;
return this;
}
@Override
public Update set(String parameterName, Object value) {
return (Update) super.set(parameterName, value);
}
}
}
/**
* An accessor for creating requests from the Folders collection.
*
* <p>The typical use is:</p>
* <pre>
* {@code TagManager tagmanager = new TagManager(...);}
* {@code TagManager.Folders.List request = tagmanager.folders().list(parameters ...)}
* </pre>
*
* @return the resource collection
*/
public Folders folders() {
return new Folders();
}
/**
* The "folders" collection of methods.
*/
public class Folders {
/**
* Creates a GTM Folder.
*
* Create a request for the method "folders.create".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Create#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param content the {@link com.google.api.services.tagmanager.model.Folder}
* @return the request
*/
public Create create(java.lang.String accountId, java.lang.String containerId, com.google.api.services.tagmanager.model.Folder content) throws java.io.IOException {
Create result = new Create(accountId, containerId, content);
initialize(result);
return result;
}
public class Create extends TagManagerRequest<com.google.api.services.tagmanager.model.Folder> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/folders";
/**
* Creates a GTM Folder.
*
* Create a request for the method "folders.create".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Create#execute()} method to invoke the remote operation.
* <p> {@link
* Create#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must
* be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param content the {@link com.google.api.services.tagmanager.model.Folder}
* @since 1.13
*/
protected Create(java.lang.String accountId, java.lang.String containerId, com.google.api.services.tagmanager.model.Folder content) {
super(TagManager.this, "POST", REST_PATH, content, com.google.api.services.tagmanager.model.Folder.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
checkRequiredParameter(content, "content");
checkRequiredParameter(content.getName(), "Folder.getName()");
}
@Override
public Create set$Xgafv(java.lang.String $Xgafv) {
return (Create) super.set$Xgafv($Xgafv);
}
@Override
public Create setAccessToken(java.lang.String accessToken) {
return (Create) super.setAccessToken(accessToken);
}
@Override
public Create setAlt(java.lang.String alt) {
return (Create) super.setAlt(alt);
}
@Override
public Create setCallback(java.lang.String callback) {
return (Create) super.setCallback(callback);
}
@Override
public Create setFields(java.lang.String fields) {
return (Create) super.setFields(fields);
}
@Override
public Create setKey(java.lang.String key) {
return (Create) super.setKey(key);
}
@Override
public Create setOauthToken(java.lang.String oauthToken) {
return (Create) super.setOauthToken(oauthToken);
}
@Override
public Create setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Create) super.setPrettyPrint(prettyPrint);
}
@Override
public Create setQuotaUser(java.lang.String quotaUser) {
return (Create) super.setQuotaUser(quotaUser);
}
@Override
public Create setUploadType(java.lang.String uploadType) {
return (Create) super.setUploadType(uploadType);
}
@Override
public Create setUploadProtocol(java.lang.String uploadProtocol) {
return (Create) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Create setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Create setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
@Override
public Create set(String parameterName, Object value) {
return (Create) super.set(parameterName, value);
}
}
/**
* Deletes a GTM Folder.
*
* Create a request for the method "folders.delete".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Delete#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param folderId The GTM Folder ID.
* @return the request
*/
public Delete delete(java.lang.String accountId, java.lang.String containerId, java.lang.String folderId) throws java.io.IOException {
Delete result = new Delete(accountId, containerId, folderId);
initialize(result);
return result;
}
public class Delete extends TagManagerRequest<Void> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/folders/{folderId}";
/**
* Deletes a GTM Folder.
*
* Create a request for the method "folders.delete".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Delete#execute()} method to invoke the remote operation.
* <p> {@link
* Delete#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must
* be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param folderId The GTM Folder ID.
* @since 1.13
*/
protected Delete(java.lang.String accountId, java.lang.String containerId, java.lang.String folderId) {
super(TagManager.this, "DELETE", REST_PATH, null, Void.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
this.folderId = com.google.api.client.util.Preconditions.checkNotNull(folderId, "Required parameter folderId must be specified.");
}
@Override
public Delete set$Xgafv(java.lang.String $Xgafv) {
return (Delete) super.set$Xgafv($Xgafv);
}
@Override
public Delete setAccessToken(java.lang.String accessToken) {
return (Delete) super.setAccessToken(accessToken);
}
@Override
public Delete setAlt(java.lang.String alt) {
return (Delete) super.setAlt(alt);
}
@Override
public Delete setCallback(java.lang.String callback) {
return (Delete) super.setCallback(callback);
}
@Override
public Delete setFields(java.lang.String fields) {
return (Delete) super.setFields(fields);
}
@Override
public Delete setKey(java.lang.String key) {
return (Delete) super.setKey(key);
}
@Override
public Delete setOauthToken(java.lang.String oauthToken) {
return (Delete) super.setOauthToken(oauthToken);
}
@Override
public Delete setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Delete) super.setPrettyPrint(prettyPrint);
}
@Override
public Delete setQuotaUser(java.lang.String quotaUser) {
return (Delete) super.setQuotaUser(quotaUser);
}
@Override
public Delete setUploadType(java.lang.String uploadType) {
return (Delete) super.setUploadType(uploadType);
}
@Override
public Delete setUploadProtocol(java.lang.String uploadProtocol) {
return (Delete) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Delete setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Delete setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
/** The GTM Folder ID. */
@com.google.api.client.util.Key
private java.lang.String folderId;
/** The GTM Folder ID.
*/
public java.lang.String getFolderId() {
return folderId;
}
/** The GTM Folder ID. */
public Delete setFolderId(java.lang.String folderId) {
this.folderId = folderId;
return this;
}
@Override
public Delete set(String parameterName, Object value) {
return (Delete) super.set(parameterName, value);
}
}
/**
* Gets a GTM Folder.
*
* Create a request for the method "folders.get".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Get#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param folderId The GTM Folder ID.
* @return the request
*/
public Get get(java.lang.String accountId, java.lang.String containerId, java.lang.String folderId) throws java.io.IOException {
Get result = new Get(accountId, containerId, folderId);
initialize(result);
return result;
}
public class Get extends TagManagerRequest<com.google.api.services.tagmanager.model.Folder> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/folders/{folderId}";
/**
* Gets a GTM Folder.
*
* Create a request for the method "folders.get".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Get#execute()} method to invoke the remote operation. <p>
* {@link Get#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)}
* must be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param folderId The GTM Folder ID.
* @since 1.13
*/
protected Get(java.lang.String accountId, java.lang.String containerId, java.lang.String folderId) {
super(TagManager.this, "GET", REST_PATH, null, com.google.api.services.tagmanager.model.Folder.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
this.folderId = com.google.api.client.util.Preconditions.checkNotNull(folderId, "Required parameter folderId must be specified.");
}
@Override
public com.google.api.client.http.HttpResponse executeUsingHead() throws java.io.IOException {
return super.executeUsingHead();
}
@Override
public com.google.api.client.http.HttpRequest buildHttpRequestUsingHead() throws java.io.IOException {
return super.buildHttpRequestUsingHead();
}
@Override
public Get set$Xgafv(java.lang.String $Xgafv) {
return (Get) super.set$Xgafv($Xgafv);
}
@Override
public Get setAccessToken(java.lang.String accessToken) {
return (Get) super.setAccessToken(accessToken);
}
@Override
public Get setAlt(java.lang.String alt) {
return (Get) super.setAlt(alt);
}
@Override
public Get setCallback(java.lang.String callback) {
return (Get) super.setCallback(callback);
}
@Override
public Get setFields(java.lang.String fields) {
return (Get) super.setFields(fields);
}
@Override
public Get setKey(java.lang.String key) {
return (Get) super.setKey(key);
}
@Override
public Get setOauthToken(java.lang.String oauthToken) {
return (Get) super.setOauthToken(oauthToken);
}
@Override
public Get setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Get) super.setPrettyPrint(prettyPrint);
}
@Override
public Get setQuotaUser(java.lang.String quotaUser) {
return (Get) super.setQuotaUser(quotaUser);
}
@Override
public Get setUploadType(java.lang.String uploadType) {
return (Get) super.setUploadType(uploadType);
}
@Override
public Get setUploadProtocol(java.lang.String uploadProtocol) {
return (Get) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Get setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Get setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
/** The GTM Folder ID. */
@com.google.api.client.util.Key
private java.lang.String folderId;
/** The GTM Folder ID.
*/
public java.lang.String getFolderId() {
return folderId;
}
/** The GTM Folder ID. */
public Get setFolderId(java.lang.String folderId) {
this.folderId = folderId;
return this;
}
@Override
public Get set(String parameterName, Object value) {
return (Get) super.set(parameterName, value);
}
}
/**
* Lists all GTM Folders of a Container.
*
* Create a request for the method "folders.list".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link List#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @return the request
*/
public List list(java.lang.String accountId, java.lang.String containerId) throws java.io.IOException {
List result = new List(accountId, containerId);
initialize(result);
return result;
}
public class List extends TagManagerRequest<com.google.api.services.tagmanager.model.ListFoldersResponse> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/folders";
/**
* Lists all GTM Folders of a Container.
*
* Create a request for the method "folders.list".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link List#execute()} method to invoke the remote operation. <p>
* {@link List#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)}
* must be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @since 1.13
*/
protected List(java.lang.String accountId, java.lang.String containerId) {
super(TagManager.this, "GET", REST_PATH, null, com.google.api.services.tagmanager.model.ListFoldersResponse.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
}
@Override
public com.google.api.client.http.HttpResponse executeUsingHead() throws java.io.IOException {
return super.executeUsingHead();
}
@Override
public com.google.api.client.http.HttpRequest buildHttpRequestUsingHead() throws java.io.IOException {
return super.buildHttpRequestUsingHead();
}
@Override
public List set$Xgafv(java.lang.String $Xgafv) {
return (List) super.set$Xgafv($Xgafv);
}
@Override
public List setAccessToken(java.lang.String accessToken) {
return (List) super.setAccessToken(accessToken);
}
@Override
public List setAlt(java.lang.String alt) {
return (List) super.setAlt(alt);
}
@Override
public List setCallback(java.lang.String callback) {
return (List) super.setCallback(callback);
}
@Override
public List setFields(java.lang.String fields) {
return (List) super.setFields(fields);
}
@Override
public List setKey(java.lang.String key) {
return (List) super.setKey(key);
}
@Override
public List setOauthToken(java.lang.String oauthToken) {
return (List) super.setOauthToken(oauthToken);
}
@Override
public List setPrettyPrint(java.lang.Boolean prettyPrint) {
return (List) super.setPrettyPrint(prettyPrint);
}
@Override
public List setQuotaUser(java.lang.String quotaUser) {
return (List) super.setQuotaUser(quotaUser);
}
@Override
public List setUploadType(java.lang.String uploadType) {
return (List) super.setUploadType(uploadType);
}
@Override
public List setUploadProtocol(java.lang.String uploadProtocol) {
return (List) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public List setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public List setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
@Override
public List set(String parameterName, Object value) {
return (List) super.set(parameterName, value);
}
}
/**
* Updates a GTM Folder.
*
* Create a request for the method "folders.update".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Update#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param folderId The GTM Folder ID.
* @param content the {@link com.google.api.services.tagmanager.model.Folder}
* @return the request
*/
public Update update(java.lang.String accountId, java.lang.String containerId, java.lang.String folderId, com.google.api.services.tagmanager.model.Folder content) throws java.io.IOException {
Update result = new Update(accountId, containerId, folderId, content);
initialize(result);
return result;
}
public class Update extends TagManagerRequest<com.google.api.services.tagmanager.model.Folder> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/folders/{folderId}";
/**
* Updates a GTM Folder.
*
* Create a request for the method "folders.update".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Update#execute()} method to invoke the remote operation.
* <p> {@link
* Update#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must
* be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param folderId The GTM Folder ID.
* @param content the {@link com.google.api.services.tagmanager.model.Folder}
* @since 1.13
*/
protected Update(java.lang.String accountId, java.lang.String containerId, java.lang.String folderId, com.google.api.services.tagmanager.model.Folder content) {
super(TagManager.this, "PUT", REST_PATH, content, com.google.api.services.tagmanager.model.Folder.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
this.folderId = com.google.api.client.util.Preconditions.checkNotNull(folderId, "Required parameter folderId must be specified.");
checkRequiredParameter(content, "content");
checkRequiredParameter(content.getName(), "Folder.getName()");
}
@Override
public Update set$Xgafv(java.lang.String $Xgafv) {
return (Update) super.set$Xgafv($Xgafv);
}
@Override
public Update setAccessToken(java.lang.String accessToken) {
return (Update) super.setAccessToken(accessToken);
}
@Override
public Update setAlt(java.lang.String alt) {
return (Update) super.setAlt(alt);
}
@Override
public Update setCallback(java.lang.String callback) {
return (Update) super.setCallback(callback);
}
@Override
public Update setFields(java.lang.String fields) {
return (Update) super.setFields(fields);
}
@Override
public Update setKey(java.lang.String key) {
return (Update) super.setKey(key);
}
@Override
public Update setOauthToken(java.lang.String oauthToken) {
return (Update) super.setOauthToken(oauthToken);
}
@Override
public Update setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Update) super.setPrettyPrint(prettyPrint);
}
@Override
public Update setQuotaUser(java.lang.String quotaUser) {
return (Update) super.setQuotaUser(quotaUser);
}
@Override
public Update setUploadType(java.lang.String uploadType) {
return (Update) super.setUploadType(uploadType);
}
@Override
public Update setUploadProtocol(java.lang.String uploadProtocol) {
return (Update) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Update setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Update setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
/** The GTM Folder ID. */
@com.google.api.client.util.Key
private java.lang.String folderId;
/** The GTM Folder ID.
*/
public java.lang.String getFolderId() {
return folderId;
}
/** The GTM Folder ID. */
public Update setFolderId(java.lang.String folderId) {
this.folderId = folderId;
return this;
}
/**
* When provided, this fingerprint must match the fingerprint of the folder in storage.
*/
@com.google.api.client.util.Key
private java.lang.String fingerprint;
/** When provided, this fingerprint must match the fingerprint of the folder in storage.
*/
public java.lang.String getFingerprint() {
return fingerprint;
}
/**
* When provided, this fingerprint must match the fingerprint of the folder in storage.
*/
public Update setFingerprint(java.lang.String fingerprint) {
this.fingerprint = fingerprint;
return this;
}
@Override
public Update set(String parameterName, Object value) {
return (Update) super.set(parameterName, value);
}
}
/**
* An accessor for creating requests from the Entities collection.
*
* <p>The typical use is:</p>
* <pre>
* {@code TagManager tagmanager = new TagManager(...);}
* {@code TagManager.Entities.List request = tagmanager.entities().list(parameters ...)}
* </pre>
*
* @return the resource collection
*/
public Entities entities() {
return new Entities();
}
/**
* The "entities" collection of methods.
*/
public class Entities {
/**
* List all entities in a GTM Folder.
*
* Create a request for the method "entities.list".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link List#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param folderId The GTM Folder ID.
* @return the request
*/
public List list(java.lang.String accountId, java.lang.String containerId, java.lang.String folderId) throws java.io.IOException {
List result = new List(accountId, containerId, folderId);
initialize(result);
return result;
}
public class List extends TagManagerRequest<com.google.api.services.tagmanager.model.FolderEntities> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/folders/{folderId}/entities";
/**
* List all entities in a GTM Folder.
*
* Create a request for the method "entities.list".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link List#execute()} method to invoke the remote operation. <p>
* {@link List#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)}
* must be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param folderId The GTM Folder ID.
* @since 1.13
*/
protected List(java.lang.String accountId, java.lang.String containerId, java.lang.String folderId) {
super(TagManager.this, "GET", REST_PATH, null, com.google.api.services.tagmanager.model.FolderEntities.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
this.folderId = com.google.api.client.util.Preconditions.checkNotNull(folderId, "Required parameter folderId must be specified.");
}
@Override
public com.google.api.client.http.HttpResponse executeUsingHead() throws java.io.IOException {
return super.executeUsingHead();
}
@Override
public com.google.api.client.http.HttpRequest buildHttpRequestUsingHead() throws java.io.IOException {
return super.buildHttpRequestUsingHead();
}
@Override
public List set$Xgafv(java.lang.String $Xgafv) {
return (List) super.set$Xgafv($Xgafv);
}
@Override
public List setAccessToken(java.lang.String accessToken) {
return (List) super.setAccessToken(accessToken);
}
@Override
public List setAlt(java.lang.String alt) {
return (List) super.setAlt(alt);
}
@Override
public List setCallback(java.lang.String callback) {
return (List) super.setCallback(callback);
}
@Override
public List setFields(java.lang.String fields) {
return (List) super.setFields(fields);
}
@Override
public List setKey(java.lang.String key) {
return (List) super.setKey(key);
}
@Override
public List setOauthToken(java.lang.String oauthToken) {
return (List) super.setOauthToken(oauthToken);
}
@Override
public List setPrettyPrint(java.lang.Boolean prettyPrint) {
return (List) super.setPrettyPrint(prettyPrint);
}
@Override
public List setQuotaUser(java.lang.String quotaUser) {
return (List) super.setQuotaUser(quotaUser);
}
@Override
public List setUploadType(java.lang.String uploadType) {
return (List) super.setUploadType(uploadType);
}
@Override
public List setUploadProtocol(java.lang.String uploadProtocol) {
return (List) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public List setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public List setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
/** The GTM Folder ID. */
@com.google.api.client.util.Key
private java.lang.String folderId;
/** The GTM Folder ID.
*/
public java.lang.String getFolderId() {
return folderId;
}
/** The GTM Folder ID. */
public List setFolderId(java.lang.String folderId) {
this.folderId = folderId;
return this;
}
@Override
public List set(String parameterName, Object value) {
return (List) super.set(parameterName, value);
}
}
}
}
/**
* An accessor for creating requests from the MoveFolders collection.
*
* <p>The typical use is:</p>
* <pre>
* {@code TagManager tagmanager = new TagManager(...);}
* {@code TagManager.MoveFolders.List request = tagmanager.moveFolders().list(parameters ...)}
* </pre>
*
* @return the resource collection
*/
public MoveFolders moveFolders() {
return new MoveFolders();
}
/**
* The "move_folders" collection of methods.
*/
public class MoveFolders {
/**
* Moves entities to a GTM Folder.
*
* Create a request for the method "move_folders.update".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Update#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param folderId The GTM Folder ID.
* @param content the {@link com.google.api.services.tagmanager.model.Folder}
* @return the request
*/
public Update update(java.lang.String accountId, java.lang.String containerId, java.lang.String folderId, com.google.api.services.tagmanager.model.Folder content) throws java.io.IOException {
Update result = new Update(accountId, containerId, folderId, content);
initialize(result);
return result;
}
public class Update extends TagManagerRequest<Void> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/move_folders/{folderId}";
/**
* Moves entities to a GTM Folder.
*
* Create a request for the method "move_folders.update".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Update#execute()} method to invoke the remote operation.
* <p> {@link
* Update#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must
* be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param folderId The GTM Folder ID.
* @param content the {@link com.google.api.services.tagmanager.model.Folder}
* @since 1.13
*/
protected Update(java.lang.String accountId, java.lang.String containerId, java.lang.String folderId, com.google.api.services.tagmanager.model.Folder content) {
super(TagManager.this, "PUT", REST_PATH, content, Void.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
this.folderId = com.google.api.client.util.Preconditions.checkNotNull(folderId, "Required parameter folderId must be specified.");
}
@Override
public Update set$Xgafv(java.lang.String $Xgafv) {
return (Update) super.set$Xgafv($Xgafv);
}
@Override
public Update setAccessToken(java.lang.String accessToken) {
return (Update) super.setAccessToken(accessToken);
}
@Override
public Update setAlt(java.lang.String alt) {
return (Update) super.setAlt(alt);
}
@Override
public Update setCallback(java.lang.String callback) {
return (Update) super.setCallback(callback);
}
@Override
public Update setFields(java.lang.String fields) {
return (Update) super.setFields(fields);
}
@Override
public Update setKey(java.lang.String key) {
return (Update) super.setKey(key);
}
@Override
public Update setOauthToken(java.lang.String oauthToken) {
return (Update) super.setOauthToken(oauthToken);
}
@Override
public Update setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Update) super.setPrettyPrint(prettyPrint);
}
@Override
public Update setQuotaUser(java.lang.String quotaUser) {
return (Update) super.setQuotaUser(quotaUser);
}
@Override
public Update setUploadType(java.lang.String uploadType) {
return (Update) super.setUploadType(uploadType);
}
@Override
public Update setUploadProtocol(java.lang.String uploadProtocol) {
return (Update) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Update setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Update setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
/** The GTM Folder ID. */
@com.google.api.client.util.Key
private java.lang.String folderId;
/** The GTM Folder ID.
*/
public java.lang.String getFolderId() {
return folderId;
}
/** The GTM Folder ID. */
public Update setFolderId(java.lang.String folderId) {
this.folderId = folderId;
return this;
}
/** The tags to be moved to the folder. */
@com.google.api.client.util.Key
private java.util.List<java.lang.String> tagId;
/** The tags to be moved to the folder.
*/
public java.util.List<java.lang.String> getTagId() {
return tagId;
}
/** The tags to be moved to the folder. */
public Update setTagId(java.util.List<java.lang.String> tagId) {
this.tagId = tagId;
return this;
}
/** The triggers to be moved to the folder. */
@com.google.api.client.util.Key
private java.util.List<java.lang.String> triggerId;
/** The triggers to be moved to the folder.
*/
public java.util.List<java.lang.String> getTriggerId() {
return triggerId;
}
/** The triggers to be moved to the folder. */
public Update setTriggerId(java.util.List<java.lang.String> triggerId) {
this.triggerId = triggerId;
return this;
}
/** The variables to be moved to the folder. */
@com.google.api.client.util.Key
private java.util.List<java.lang.String> variableId;
/** The variables to be moved to the folder.
*/
public java.util.List<java.lang.String> getVariableId() {
return variableId;
}
/** The variables to be moved to the folder. */
public Update setVariableId(java.util.List<java.lang.String> variableId) {
this.variableId = variableId;
return this;
}
@Override
public Update set(String parameterName, Object value) {
return (Update) super.set(parameterName, value);
}
}
}
/**
* An accessor for creating requests from the ReauthorizeEnvironments collection.
*
* <p>The typical use is:</p>
* <pre>
* {@code TagManager tagmanager = new TagManager(...);}
* {@code TagManager.ReauthorizeEnvironments.List request = tagmanager.reauthorizeEnvironments().list(parameters ...)}
* </pre>
*
* @return the resource collection
*/
public ReauthorizeEnvironments reauthorizeEnvironments() {
return new ReauthorizeEnvironments();
}
/**
* The "reauthorize_environments" collection of methods.
*/
public class ReauthorizeEnvironments {
/**
* Re-generates the authorization code for a GTM Environment.
*
* Create a request for the method "reauthorize_environments.update".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Update#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param environmentId The GTM Environment ID.
* @param content the {@link com.google.api.services.tagmanager.model.Environment}
* @return the request
*/
public Update update(java.lang.String accountId, java.lang.String containerId, java.lang.String environmentId, com.google.api.services.tagmanager.model.Environment content) throws java.io.IOException {
Update result = new Update(accountId, containerId, environmentId, content);
initialize(result);
return result;
}
public class Update extends TagManagerRequest<com.google.api.services.tagmanager.model.Environment> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/reauthorize_environments/{environmentId}";
/**
* Re-generates the authorization code for a GTM Environment.
*
* Create a request for the method "reauthorize_environments.update".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Update#execute()} method to invoke the remote operation.
* <p> {@link
* Update#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must
* be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param environmentId The GTM Environment ID.
* @param content the {@link com.google.api.services.tagmanager.model.Environment}
* @since 1.13
*/
protected Update(java.lang.String accountId, java.lang.String containerId, java.lang.String environmentId, com.google.api.services.tagmanager.model.Environment content) {
super(TagManager.this, "PUT", REST_PATH, content, com.google.api.services.tagmanager.model.Environment.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
this.environmentId = com.google.api.client.util.Preconditions.checkNotNull(environmentId, "Required parameter environmentId must be specified.");
}
@Override
public Update set$Xgafv(java.lang.String $Xgafv) {
return (Update) super.set$Xgafv($Xgafv);
}
@Override
public Update setAccessToken(java.lang.String accessToken) {
return (Update) super.setAccessToken(accessToken);
}
@Override
public Update setAlt(java.lang.String alt) {
return (Update) super.setAlt(alt);
}
@Override
public Update setCallback(java.lang.String callback) {
return (Update) super.setCallback(callback);
}
@Override
public Update setFields(java.lang.String fields) {
return (Update) super.setFields(fields);
}
@Override
public Update setKey(java.lang.String key) {
return (Update) super.setKey(key);
}
@Override
public Update setOauthToken(java.lang.String oauthToken) {
return (Update) super.setOauthToken(oauthToken);
}
@Override
public Update setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Update) super.setPrettyPrint(prettyPrint);
}
@Override
public Update setQuotaUser(java.lang.String quotaUser) {
return (Update) super.setQuotaUser(quotaUser);
}
@Override
public Update setUploadType(java.lang.String uploadType) {
return (Update) super.setUploadType(uploadType);
}
@Override
public Update setUploadProtocol(java.lang.String uploadProtocol) {
return (Update) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Update setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Update setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
/** The GTM Environment ID. */
@com.google.api.client.util.Key
private java.lang.String environmentId;
/** The GTM Environment ID.
*/
public java.lang.String getEnvironmentId() {
return environmentId;
}
/** The GTM Environment ID. */
public Update setEnvironmentId(java.lang.String environmentId) {
this.environmentId = environmentId;
return this;
}
@Override
public Update set(String parameterName, Object value) {
return (Update) super.set(parameterName, value);
}
}
}
/**
* An accessor for creating requests from the Tags collection.
*
* <p>The typical use is:</p>
* <pre>
* {@code TagManager tagmanager = new TagManager(...);}
* {@code TagManager.Tags.List request = tagmanager.tags().list(parameters ...)}
* </pre>
*
* @return the resource collection
*/
public Tags tags() {
return new Tags();
}
/**
* The "tags" collection of methods.
*/
public class Tags {
/**
* Creates a GTM Tag.
*
* Create a request for the method "tags.create".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Create#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param content the {@link com.google.api.services.tagmanager.model.Tag}
* @return the request
*/
public Create create(java.lang.String accountId, java.lang.String containerId, com.google.api.services.tagmanager.model.Tag content) throws java.io.IOException {
Create result = new Create(accountId, containerId, content);
initialize(result);
return result;
}
public class Create extends TagManagerRequest<com.google.api.services.tagmanager.model.Tag> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/tags";
/**
* Creates a GTM Tag.
*
* Create a request for the method "tags.create".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Create#execute()} method to invoke the remote operation.
* <p> {@link
* Create#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must
* be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param content the {@link com.google.api.services.tagmanager.model.Tag}
* @since 1.13
*/
protected Create(java.lang.String accountId, java.lang.String containerId, com.google.api.services.tagmanager.model.Tag content) {
super(TagManager.this, "POST", REST_PATH, content, com.google.api.services.tagmanager.model.Tag.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
checkRequiredParameter(content, "content");
checkRequiredParameter(content.getName(), "Tag.getName()");
checkRequiredParameter(content, "content");
checkRequiredParameter(content.getType(), "Tag.getType()");
}
@Override
public Create set$Xgafv(java.lang.String $Xgafv) {
return (Create) super.set$Xgafv($Xgafv);
}
@Override
public Create setAccessToken(java.lang.String accessToken) {
return (Create) super.setAccessToken(accessToken);
}
@Override
public Create setAlt(java.lang.String alt) {
return (Create) super.setAlt(alt);
}
@Override
public Create setCallback(java.lang.String callback) {
return (Create) super.setCallback(callback);
}
@Override
public Create setFields(java.lang.String fields) {
return (Create) super.setFields(fields);
}
@Override
public Create setKey(java.lang.String key) {
return (Create) super.setKey(key);
}
@Override
public Create setOauthToken(java.lang.String oauthToken) {
return (Create) super.setOauthToken(oauthToken);
}
@Override
public Create setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Create) super.setPrettyPrint(prettyPrint);
}
@Override
public Create setQuotaUser(java.lang.String quotaUser) {
return (Create) super.setQuotaUser(quotaUser);
}
@Override
public Create setUploadType(java.lang.String uploadType) {
return (Create) super.setUploadType(uploadType);
}
@Override
public Create setUploadProtocol(java.lang.String uploadProtocol) {
return (Create) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Create setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Create setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
@Override
public Create set(String parameterName, Object value) {
return (Create) super.set(parameterName, value);
}
}
/**
* Deletes a GTM Tag.
*
* Create a request for the method "tags.delete".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Delete#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param tagId The GTM Tag ID.
* @return the request
*/
public Delete delete(java.lang.String accountId, java.lang.String containerId, java.lang.String tagId) throws java.io.IOException {
Delete result = new Delete(accountId, containerId, tagId);
initialize(result);
return result;
}
public class Delete extends TagManagerRequest<Void> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/tags/{tagId}";
/**
* Deletes a GTM Tag.
*
* Create a request for the method "tags.delete".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Delete#execute()} method to invoke the remote operation.
* <p> {@link
* Delete#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must
* be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param tagId The GTM Tag ID.
* @since 1.13
*/
protected Delete(java.lang.String accountId, java.lang.String containerId, java.lang.String tagId) {
super(TagManager.this, "DELETE", REST_PATH, null, Void.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
this.tagId = com.google.api.client.util.Preconditions.checkNotNull(tagId, "Required parameter tagId must be specified.");
}
@Override
public Delete set$Xgafv(java.lang.String $Xgafv) {
return (Delete) super.set$Xgafv($Xgafv);
}
@Override
public Delete setAccessToken(java.lang.String accessToken) {
return (Delete) super.setAccessToken(accessToken);
}
@Override
public Delete setAlt(java.lang.String alt) {
return (Delete) super.setAlt(alt);
}
@Override
public Delete setCallback(java.lang.String callback) {
return (Delete) super.setCallback(callback);
}
@Override
public Delete setFields(java.lang.String fields) {
return (Delete) super.setFields(fields);
}
@Override
public Delete setKey(java.lang.String key) {
return (Delete) super.setKey(key);
}
@Override
public Delete setOauthToken(java.lang.String oauthToken) {
return (Delete) super.setOauthToken(oauthToken);
}
@Override
public Delete setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Delete) super.setPrettyPrint(prettyPrint);
}
@Override
public Delete setQuotaUser(java.lang.String quotaUser) {
return (Delete) super.setQuotaUser(quotaUser);
}
@Override
public Delete setUploadType(java.lang.String uploadType) {
return (Delete) super.setUploadType(uploadType);
}
@Override
public Delete setUploadProtocol(java.lang.String uploadProtocol) {
return (Delete) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Delete setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Delete setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
/** The GTM Tag ID. */
@com.google.api.client.util.Key
private java.lang.String tagId;
/** The GTM Tag ID.
*/
public java.lang.String getTagId() {
return tagId;
}
/** The GTM Tag ID. */
public Delete setTagId(java.lang.String tagId) {
this.tagId = tagId;
return this;
}
@Override
public Delete set(String parameterName, Object value) {
return (Delete) super.set(parameterName, value);
}
}
/**
* Gets a GTM Tag.
*
* Create a request for the method "tags.get".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Get#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param tagId The GTM Tag ID.
* @return the request
*/
public Get get(java.lang.String accountId, java.lang.String containerId, java.lang.String tagId) throws java.io.IOException {
Get result = new Get(accountId, containerId, tagId);
initialize(result);
return result;
}
public class Get extends TagManagerRequest<com.google.api.services.tagmanager.model.Tag> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/tags/{tagId}";
/**
* Gets a GTM Tag.
*
* Create a request for the method "tags.get".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Get#execute()} method to invoke the remote operation. <p>
* {@link Get#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)}
* must be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param tagId The GTM Tag ID.
* @since 1.13
*/
protected Get(java.lang.String accountId, java.lang.String containerId, java.lang.String tagId) {
super(TagManager.this, "GET", REST_PATH, null, com.google.api.services.tagmanager.model.Tag.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
this.tagId = com.google.api.client.util.Preconditions.checkNotNull(tagId, "Required parameter tagId must be specified.");
}
@Override
public com.google.api.client.http.HttpResponse executeUsingHead() throws java.io.IOException {
return super.executeUsingHead();
}
@Override
public com.google.api.client.http.HttpRequest buildHttpRequestUsingHead() throws java.io.IOException {
return super.buildHttpRequestUsingHead();
}
@Override
public Get set$Xgafv(java.lang.String $Xgafv) {
return (Get) super.set$Xgafv($Xgafv);
}
@Override
public Get setAccessToken(java.lang.String accessToken) {
return (Get) super.setAccessToken(accessToken);
}
@Override
public Get setAlt(java.lang.String alt) {
return (Get) super.setAlt(alt);
}
@Override
public Get setCallback(java.lang.String callback) {
return (Get) super.setCallback(callback);
}
@Override
public Get setFields(java.lang.String fields) {
return (Get) super.setFields(fields);
}
@Override
public Get setKey(java.lang.String key) {
return (Get) super.setKey(key);
}
@Override
public Get setOauthToken(java.lang.String oauthToken) {
return (Get) super.setOauthToken(oauthToken);
}
@Override
public Get setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Get) super.setPrettyPrint(prettyPrint);
}
@Override
public Get setQuotaUser(java.lang.String quotaUser) {
return (Get) super.setQuotaUser(quotaUser);
}
@Override
public Get setUploadType(java.lang.String uploadType) {
return (Get) super.setUploadType(uploadType);
}
@Override
public Get setUploadProtocol(java.lang.String uploadProtocol) {
return (Get) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Get setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Get setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
/** The GTM Tag ID. */
@com.google.api.client.util.Key
private java.lang.String tagId;
/** The GTM Tag ID.
*/
public java.lang.String getTagId() {
return tagId;
}
/** The GTM Tag ID. */
public Get setTagId(java.lang.String tagId) {
this.tagId = tagId;
return this;
}
@Override
public Get set(String parameterName, Object value) {
return (Get) super.set(parameterName, value);
}
}
/**
* Lists all GTM Tags of a Container.
*
* Create a request for the method "tags.list".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link List#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @return the request
*/
public List list(java.lang.String accountId, java.lang.String containerId) throws java.io.IOException {
List result = new List(accountId, containerId);
initialize(result);
return result;
}
public class List extends TagManagerRequest<com.google.api.services.tagmanager.model.ListTagsResponse> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/tags";
/**
* Lists all GTM Tags of a Container.
*
* Create a request for the method "tags.list".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link List#execute()} method to invoke the remote operation. <p>
* {@link List#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)}
* must be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @since 1.13
*/
protected List(java.lang.String accountId, java.lang.String containerId) {
super(TagManager.this, "GET", REST_PATH, null, com.google.api.services.tagmanager.model.ListTagsResponse.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
}
@Override
public com.google.api.client.http.HttpResponse executeUsingHead() throws java.io.IOException {
return super.executeUsingHead();
}
@Override
public com.google.api.client.http.HttpRequest buildHttpRequestUsingHead() throws java.io.IOException {
return super.buildHttpRequestUsingHead();
}
@Override
public List set$Xgafv(java.lang.String $Xgafv) {
return (List) super.set$Xgafv($Xgafv);
}
@Override
public List setAccessToken(java.lang.String accessToken) {
return (List) super.setAccessToken(accessToken);
}
@Override
public List setAlt(java.lang.String alt) {
return (List) super.setAlt(alt);
}
@Override
public List setCallback(java.lang.String callback) {
return (List) super.setCallback(callback);
}
@Override
public List setFields(java.lang.String fields) {
return (List) super.setFields(fields);
}
@Override
public List setKey(java.lang.String key) {
return (List) super.setKey(key);
}
@Override
public List setOauthToken(java.lang.String oauthToken) {
return (List) super.setOauthToken(oauthToken);
}
@Override
public List setPrettyPrint(java.lang.Boolean prettyPrint) {
return (List) super.setPrettyPrint(prettyPrint);
}
@Override
public List setQuotaUser(java.lang.String quotaUser) {
return (List) super.setQuotaUser(quotaUser);
}
@Override
public List setUploadType(java.lang.String uploadType) {
return (List) super.setUploadType(uploadType);
}
@Override
public List setUploadProtocol(java.lang.String uploadProtocol) {
return (List) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public List setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public List setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
@Override
public List set(String parameterName, Object value) {
return (List) super.set(parameterName, value);
}
}
/**
* Updates a GTM Tag.
*
* Create a request for the method "tags.update".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Update#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param tagId The GTM Tag ID.
* @param content the {@link com.google.api.services.tagmanager.model.Tag}
* @return the request
*/
public Update update(java.lang.String accountId, java.lang.String containerId, java.lang.String tagId, com.google.api.services.tagmanager.model.Tag content) throws java.io.IOException {
Update result = new Update(accountId, containerId, tagId, content);
initialize(result);
return result;
}
public class Update extends TagManagerRequest<com.google.api.services.tagmanager.model.Tag> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/tags/{tagId}";
/**
* Updates a GTM Tag.
*
* Create a request for the method "tags.update".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Update#execute()} method to invoke the remote operation.
* <p> {@link
* Update#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must
* be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param tagId The GTM Tag ID.
* @param content the {@link com.google.api.services.tagmanager.model.Tag}
* @since 1.13
*/
protected Update(java.lang.String accountId, java.lang.String containerId, java.lang.String tagId, com.google.api.services.tagmanager.model.Tag content) {
super(TagManager.this, "PUT", REST_PATH, content, com.google.api.services.tagmanager.model.Tag.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
this.tagId = com.google.api.client.util.Preconditions.checkNotNull(tagId, "Required parameter tagId must be specified.");
checkRequiredParameter(content, "content");
checkRequiredParameter(content.getName(), "Tag.getName()");
}
@Override
public Update set$Xgafv(java.lang.String $Xgafv) {
return (Update) super.set$Xgafv($Xgafv);
}
@Override
public Update setAccessToken(java.lang.String accessToken) {
return (Update) super.setAccessToken(accessToken);
}
@Override
public Update setAlt(java.lang.String alt) {
return (Update) super.setAlt(alt);
}
@Override
public Update setCallback(java.lang.String callback) {
return (Update) super.setCallback(callback);
}
@Override
public Update setFields(java.lang.String fields) {
return (Update) super.setFields(fields);
}
@Override
public Update setKey(java.lang.String key) {
return (Update) super.setKey(key);
}
@Override
public Update setOauthToken(java.lang.String oauthToken) {
return (Update) super.setOauthToken(oauthToken);
}
@Override
public Update setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Update) super.setPrettyPrint(prettyPrint);
}
@Override
public Update setQuotaUser(java.lang.String quotaUser) {
return (Update) super.setQuotaUser(quotaUser);
}
@Override
public Update setUploadType(java.lang.String uploadType) {
return (Update) super.setUploadType(uploadType);
}
@Override
public Update setUploadProtocol(java.lang.String uploadProtocol) {
return (Update) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Update setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Update setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
/** The GTM Tag ID. */
@com.google.api.client.util.Key
private java.lang.String tagId;
/** The GTM Tag ID.
*/
public java.lang.String getTagId() {
return tagId;
}
/** The GTM Tag ID. */
public Update setTagId(java.lang.String tagId) {
this.tagId = tagId;
return this;
}
/**
* When provided, this fingerprint must match the fingerprint of the tag in storage.
*/
@com.google.api.client.util.Key
private java.lang.String fingerprint;
/** When provided, this fingerprint must match the fingerprint of the tag in storage.
*/
public java.lang.String getFingerprint() {
return fingerprint;
}
/**
* When provided, this fingerprint must match the fingerprint of the tag in storage.
*/
public Update setFingerprint(java.lang.String fingerprint) {
this.fingerprint = fingerprint;
return this;
}
@Override
public Update set(String parameterName, Object value) {
return (Update) super.set(parameterName, value);
}
}
}
/**
* An accessor for creating requests from the Triggers collection.
*
* <p>The typical use is:</p>
* <pre>
* {@code TagManager tagmanager = new TagManager(...);}
* {@code TagManager.Triggers.List request = tagmanager.triggers().list(parameters ...)}
* </pre>
*
* @return the resource collection
*/
public Triggers triggers() {
return new Triggers();
}
/**
* The "triggers" collection of methods.
*/
public class Triggers {
/**
* Creates a GTM Trigger.
*
* Create a request for the method "triggers.create".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Create#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param content the {@link com.google.api.services.tagmanager.model.Trigger}
* @return the request
*/
public Create create(java.lang.String accountId, java.lang.String containerId, com.google.api.services.tagmanager.model.Trigger content) throws java.io.IOException {
Create result = new Create(accountId, containerId, content);
initialize(result);
return result;
}
public class Create extends TagManagerRequest<com.google.api.services.tagmanager.model.Trigger> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/triggers";
/**
* Creates a GTM Trigger.
*
* Create a request for the method "triggers.create".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Create#execute()} method to invoke the remote operation.
* <p> {@link
* Create#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must
* be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param content the {@link com.google.api.services.tagmanager.model.Trigger}
* @since 1.13
*/
protected Create(java.lang.String accountId, java.lang.String containerId, com.google.api.services.tagmanager.model.Trigger content) {
super(TagManager.this, "POST", REST_PATH, content, com.google.api.services.tagmanager.model.Trigger.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
checkRequiredParameter(content, "content");
checkRequiredParameter(content.getName(), "Trigger.getName()");
checkRequiredParameter(content, "content");
checkRequiredParameter(content.getType(), "Trigger.getType()");
}
@Override
public Create set$Xgafv(java.lang.String $Xgafv) {
return (Create) super.set$Xgafv($Xgafv);
}
@Override
public Create setAccessToken(java.lang.String accessToken) {
return (Create) super.setAccessToken(accessToken);
}
@Override
public Create setAlt(java.lang.String alt) {
return (Create) super.setAlt(alt);
}
@Override
public Create setCallback(java.lang.String callback) {
return (Create) super.setCallback(callback);
}
@Override
public Create setFields(java.lang.String fields) {
return (Create) super.setFields(fields);
}
@Override
public Create setKey(java.lang.String key) {
return (Create) super.setKey(key);
}
@Override
public Create setOauthToken(java.lang.String oauthToken) {
return (Create) super.setOauthToken(oauthToken);
}
@Override
public Create setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Create) super.setPrettyPrint(prettyPrint);
}
@Override
public Create setQuotaUser(java.lang.String quotaUser) {
return (Create) super.setQuotaUser(quotaUser);
}
@Override
public Create setUploadType(java.lang.String uploadType) {
return (Create) super.setUploadType(uploadType);
}
@Override
public Create setUploadProtocol(java.lang.String uploadProtocol) {
return (Create) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Create setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Create setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
@Override
public Create set(String parameterName, Object value) {
return (Create) super.set(parameterName, value);
}
}
/**
* Deletes a GTM Trigger.
*
* Create a request for the method "triggers.delete".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Delete#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param triggerId The GTM Trigger ID.
* @return the request
*/
public Delete delete(java.lang.String accountId, java.lang.String containerId, java.lang.String triggerId) throws java.io.IOException {
Delete result = new Delete(accountId, containerId, triggerId);
initialize(result);
return result;
}
public class Delete extends TagManagerRequest<Void> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/triggers/{triggerId}";
/**
* Deletes a GTM Trigger.
*
* Create a request for the method "triggers.delete".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Delete#execute()} method to invoke the remote operation.
* <p> {@link
* Delete#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must
* be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param triggerId The GTM Trigger ID.
* @since 1.13
*/
protected Delete(java.lang.String accountId, java.lang.String containerId, java.lang.String triggerId) {
super(TagManager.this, "DELETE", REST_PATH, null, Void.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
this.triggerId = com.google.api.client.util.Preconditions.checkNotNull(triggerId, "Required parameter triggerId must be specified.");
}
@Override
public Delete set$Xgafv(java.lang.String $Xgafv) {
return (Delete) super.set$Xgafv($Xgafv);
}
@Override
public Delete setAccessToken(java.lang.String accessToken) {
return (Delete) super.setAccessToken(accessToken);
}
@Override
public Delete setAlt(java.lang.String alt) {
return (Delete) super.setAlt(alt);
}
@Override
public Delete setCallback(java.lang.String callback) {
return (Delete) super.setCallback(callback);
}
@Override
public Delete setFields(java.lang.String fields) {
return (Delete) super.setFields(fields);
}
@Override
public Delete setKey(java.lang.String key) {
return (Delete) super.setKey(key);
}
@Override
public Delete setOauthToken(java.lang.String oauthToken) {
return (Delete) super.setOauthToken(oauthToken);
}
@Override
public Delete setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Delete) super.setPrettyPrint(prettyPrint);
}
@Override
public Delete setQuotaUser(java.lang.String quotaUser) {
return (Delete) super.setQuotaUser(quotaUser);
}
@Override
public Delete setUploadType(java.lang.String uploadType) {
return (Delete) super.setUploadType(uploadType);
}
@Override
public Delete setUploadProtocol(java.lang.String uploadProtocol) {
return (Delete) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Delete setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Delete setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
/** The GTM Trigger ID. */
@com.google.api.client.util.Key
private java.lang.String triggerId;
/** The GTM Trigger ID.
*/
public java.lang.String getTriggerId() {
return triggerId;
}
/** The GTM Trigger ID. */
public Delete setTriggerId(java.lang.String triggerId) {
this.triggerId = triggerId;
return this;
}
@Override
public Delete set(String parameterName, Object value) {
return (Delete) super.set(parameterName, value);
}
}
/**
* Gets a GTM Trigger.
*
* Create a request for the method "triggers.get".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Get#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param triggerId The GTM Trigger ID.
* @return the request
*/
public Get get(java.lang.String accountId, java.lang.String containerId, java.lang.String triggerId) throws java.io.IOException {
Get result = new Get(accountId, containerId, triggerId);
initialize(result);
return result;
}
public class Get extends TagManagerRequest<com.google.api.services.tagmanager.model.Trigger> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/triggers/{triggerId}";
/**
* Gets a GTM Trigger.
*
* Create a request for the method "triggers.get".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Get#execute()} method to invoke the remote operation. <p>
* {@link Get#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)}
* must be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param triggerId The GTM Trigger ID.
* @since 1.13
*/
protected Get(java.lang.String accountId, java.lang.String containerId, java.lang.String triggerId) {
super(TagManager.this, "GET", REST_PATH, null, com.google.api.services.tagmanager.model.Trigger.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
this.triggerId = com.google.api.client.util.Preconditions.checkNotNull(triggerId, "Required parameter triggerId must be specified.");
}
@Override
public com.google.api.client.http.HttpResponse executeUsingHead() throws java.io.IOException {
return super.executeUsingHead();
}
@Override
public com.google.api.client.http.HttpRequest buildHttpRequestUsingHead() throws java.io.IOException {
return super.buildHttpRequestUsingHead();
}
@Override
public Get set$Xgafv(java.lang.String $Xgafv) {
return (Get) super.set$Xgafv($Xgafv);
}
@Override
public Get setAccessToken(java.lang.String accessToken) {
return (Get) super.setAccessToken(accessToken);
}
@Override
public Get setAlt(java.lang.String alt) {
return (Get) super.setAlt(alt);
}
@Override
public Get setCallback(java.lang.String callback) {
return (Get) super.setCallback(callback);
}
@Override
public Get setFields(java.lang.String fields) {
return (Get) super.setFields(fields);
}
@Override
public Get setKey(java.lang.String key) {
return (Get) super.setKey(key);
}
@Override
public Get setOauthToken(java.lang.String oauthToken) {
return (Get) super.setOauthToken(oauthToken);
}
@Override
public Get setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Get) super.setPrettyPrint(prettyPrint);
}
@Override
public Get setQuotaUser(java.lang.String quotaUser) {
return (Get) super.setQuotaUser(quotaUser);
}
@Override
public Get setUploadType(java.lang.String uploadType) {
return (Get) super.setUploadType(uploadType);
}
@Override
public Get setUploadProtocol(java.lang.String uploadProtocol) {
return (Get) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Get setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Get setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
/** The GTM Trigger ID. */
@com.google.api.client.util.Key
private java.lang.String triggerId;
/** The GTM Trigger ID.
*/
public java.lang.String getTriggerId() {
return triggerId;
}
/** The GTM Trigger ID. */
public Get setTriggerId(java.lang.String triggerId) {
this.triggerId = triggerId;
return this;
}
@Override
public Get set(String parameterName, Object value) {
return (Get) super.set(parameterName, value);
}
}
/**
* Lists all GTM Triggers of a Container.
*
* Create a request for the method "triggers.list".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link List#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @return the request
*/
public List list(java.lang.String accountId, java.lang.String containerId) throws java.io.IOException {
List result = new List(accountId, containerId);
initialize(result);
return result;
}
public class List extends TagManagerRequest<com.google.api.services.tagmanager.model.ListTriggersResponse> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/triggers";
/**
* Lists all GTM Triggers of a Container.
*
* Create a request for the method "triggers.list".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link List#execute()} method to invoke the remote operation. <p>
* {@link List#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)}
* must be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @since 1.13
*/
protected List(java.lang.String accountId, java.lang.String containerId) {
super(TagManager.this, "GET", REST_PATH, null, com.google.api.services.tagmanager.model.ListTriggersResponse.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
}
@Override
public com.google.api.client.http.HttpResponse executeUsingHead() throws java.io.IOException {
return super.executeUsingHead();
}
@Override
public com.google.api.client.http.HttpRequest buildHttpRequestUsingHead() throws java.io.IOException {
return super.buildHttpRequestUsingHead();
}
@Override
public List set$Xgafv(java.lang.String $Xgafv) {
return (List) super.set$Xgafv($Xgafv);
}
@Override
public List setAccessToken(java.lang.String accessToken) {
return (List) super.setAccessToken(accessToken);
}
@Override
public List setAlt(java.lang.String alt) {
return (List) super.setAlt(alt);
}
@Override
public List setCallback(java.lang.String callback) {
return (List) super.setCallback(callback);
}
@Override
public List setFields(java.lang.String fields) {
return (List) super.setFields(fields);
}
@Override
public List setKey(java.lang.String key) {
return (List) super.setKey(key);
}
@Override
public List setOauthToken(java.lang.String oauthToken) {
return (List) super.setOauthToken(oauthToken);
}
@Override
public List setPrettyPrint(java.lang.Boolean prettyPrint) {
return (List) super.setPrettyPrint(prettyPrint);
}
@Override
public List setQuotaUser(java.lang.String quotaUser) {
return (List) super.setQuotaUser(quotaUser);
}
@Override
public List setUploadType(java.lang.String uploadType) {
return (List) super.setUploadType(uploadType);
}
@Override
public List setUploadProtocol(java.lang.String uploadProtocol) {
return (List) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public List setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public List setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
@Override
public List set(String parameterName, Object value) {
return (List) super.set(parameterName, value);
}
}
/**
* Updates a GTM Trigger.
*
* Create a request for the method "triggers.update".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Update#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param triggerId The GTM Trigger ID.
* @param content the {@link com.google.api.services.tagmanager.model.Trigger}
* @return the request
*/
public Update update(java.lang.String accountId, java.lang.String containerId, java.lang.String triggerId, com.google.api.services.tagmanager.model.Trigger content) throws java.io.IOException {
Update result = new Update(accountId, containerId, triggerId, content);
initialize(result);
return result;
}
public class Update extends TagManagerRequest<com.google.api.services.tagmanager.model.Trigger> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/triggers/{triggerId}";
/**
* Updates a GTM Trigger.
*
* Create a request for the method "triggers.update".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Update#execute()} method to invoke the remote operation.
* <p> {@link
* Update#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must
* be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param triggerId The GTM Trigger ID.
* @param content the {@link com.google.api.services.tagmanager.model.Trigger}
* @since 1.13
*/
protected Update(java.lang.String accountId, java.lang.String containerId, java.lang.String triggerId, com.google.api.services.tagmanager.model.Trigger content) {
super(TagManager.this, "PUT", REST_PATH, content, com.google.api.services.tagmanager.model.Trigger.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
this.triggerId = com.google.api.client.util.Preconditions.checkNotNull(triggerId, "Required parameter triggerId must be specified.");
checkRequiredParameter(content, "content");
checkRequiredParameter(content.getName(), "Trigger.getName()");
}
@Override
public Update set$Xgafv(java.lang.String $Xgafv) {
return (Update) super.set$Xgafv($Xgafv);
}
@Override
public Update setAccessToken(java.lang.String accessToken) {
return (Update) super.setAccessToken(accessToken);
}
@Override
public Update setAlt(java.lang.String alt) {
return (Update) super.setAlt(alt);
}
@Override
public Update setCallback(java.lang.String callback) {
return (Update) super.setCallback(callback);
}
@Override
public Update setFields(java.lang.String fields) {
return (Update) super.setFields(fields);
}
@Override
public Update setKey(java.lang.String key) {
return (Update) super.setKey(key);
}
@Override
public Update setOauthToken(java.lang.String oauthToken) {
return (Update) super.setOauthToken(oauthToken);
}
@Override
public Update setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Update) super.setPrettyPrint(prettyPrint);
}
@Override
public Update setQuotaUser(java.lang.String quotaUser) {
return (Update) super.setQuotaUser(quotaUser);
}
@Override
public Update setUploadType(java.lang.String uploadType) {
return (Update) super.setUploadType(uploadType);
}
@Override
public Update setUploadProtocol(java.lang.String uploadProtocol) {
return (Update) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Update setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Update setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
/** The GTM Trigger ID. */
@com.google.api.client.util.Key
private java.lang.String triggerId;
/** The GTM Trigger ID.
*/
public java.lang.String getTriggerId() {
return triggerId;
}
/** The GTM Trigger ID. */
public Update setTriggerId(java.lang.String triggerId) {
this.triggerId = triggerId;
return this;
}
/**
* When provided, this fingerprint must match the fingerprint of the trigger in storage.
*/
@com.google.api.client.util.Key
private java.lang.String fingerprint;
/** When provided, this fingerprint must match the fingerprint of the trigger in storage.
*/
public java.lang.String getFingerprint() {
return fingerprint;
}
/**
* When provided, this fingerprint must match the fingerprint of the trigger in storage.
*/
public Update setFingerprint(java.lang.String fingerprint) {
this.fingerprint = fingerprint;
return this;
}
@Override
public Update set(String parameterName, Object value) {
return (Update) super.set(parameterName, value);
}
}
}
/**
* An accessor for creating requests from the Variables collection.
*
* <p>The typical use is:</p>
* <pre>
* {@code TagManager tagmanager = new TagManager(...);}
* {@code TagManager.Variables.List request = tagmanager.variables().list(parameters ...)}
* </pre>
*
* @return the resource collection
*/
public Variables variables() {
return new Variables();
}
/**
* The "variables" collection of methods.
*/
public class Variables {
/**
* Creates a GTM Variable.
*
* Create a request for the method "variables.create".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Create#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param content the {@link com.google.api.services.tagmanager.model.Variable}
* @return the request
*/
public Create create(java.lang.String accountId, java.lang.String containerId, com.google.api.services.tagmanager.model.Variable content) throws java.io.IOException {
Create result = new Create(accountId, containerId, content);
initialize(result);
return result;
}
public class Create extends TagManagerRequest<com.google.api.services.tagmanager.model.Variable> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/variables";
/**
* Creates a GTM Variable.
*
* Create a request for the method "variables.create".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Create#execute()} method to invoke the remote operation.
* <p> {@link
* Create#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must
* be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param content the {@link com.google.api.services.tagmanager.model.Variable}
* @since 1.13
*/
protected Create(java.lang.String accountId, java.lang.String containerId, com.google.api.services.tagmanager.model.Variable content) {
super(TagManager.this, "POST", REST_PATH, content, com.google.api.services.tagmanager.model.Variable.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
checkRequiredParameter(content, "content");
checkRequiredParameter(content.getName(), "Variable.getName()");
checkRequiredParameter(content, "content");
checkRequiredParameter(content.getType(), "Variable.getType()");
}
@Override
public Create set$Xgafv(java.lang.String $Xgafv) {
return (Create) super.set$Xgafv($Xgafv);
}
@Override
public Create setAccessToken(java.lang.String accessToken) {
return (Create) super.setAccessToken(accessToken);
}
@Override
public Create setAlt(java.lang.String alt) {
return (Create) super.setAlt(alt);
}
@Override
public Create setCallback(java.lang.String callback) {
return (Create) super.setCallback(callback);
}
@Override
public Create setFields(java.lang.String fields) {
return (Create) super.setFields(fields);
}
@Override
public Create setKey(java.lang.String key) {
return (Create) super.setKey(key);
}
@Override
public Create setOauthToken(java.lang.String oauthToken) {
return (Create) super.setOauthToken(oauthToken);
}
@Override
public Create setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Create) super.setPrettyPrint(prettyPrint);
}
@Override
public Create setQuotaUser(java.lang.String quotaUser) {
return (Create) super.setQuotaUser(quotaUser);
}
@Override
public Create setUploadType(java.lang.String uploadType) {
return (Create) super.setUploadType(uploadType);
}
@Override
public Create setUploadProtocol(java.lang.String uploadProtocol) {
return (Create) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Create setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Create setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
@Override
public Create set(String parameterName, Object value) {
return (Create) super.set(parameterName, value);
}
}
/**
* Deletes a GTM Variable.
*
* Create a request for the method "variables.delete".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Delete#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param variableId The GTM Variable ID.
* @return the request
*/
public Delete delete(java.lang.String accountId, java.lang.String containerId, java.lang.String variableId) throws java.io.IOException {
Delete result = new Delete(accountId, containerId, variableId);
initialize(result);
return result;
}
public class Delete extends TagManagerRequest<Void> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/variables/{variableId}";
/**
* Deletes a GTM Variable.
*
* Create a request for the method "variables.delete".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Delete#execute()} method to invoke the remote operation.
* <p> {@link
* Delete#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must
* be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param variableId The GTM Variable ID.
* @since 1.13
*/
protected Delete(java.lang.String accountId, java.lang.String containerId, java.lang.String variableId) {
super(TagManager.this, "DELETE", REST_PATH, null, Void.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
this.variableId = com.google.api.client.util.Preconditions.checkNotNull(variableId, "Required parameter variableId must be specified.");
}
@Override
public Delete set$Xgafv(java.lang.String $Xgafv) {
return (Delete) super.set$Xgafv($Xgafv);
}
@Override
public Delete setAccessToken(java.lang.String accessToken) {
return (Delete) super.setAccessToken(accessToken);
}
@Override
public Delete setAlt(java.lang.String alt) {
return (Delete) super.setAlt(alt);
}
@Override
public Delete setCallback(java.lang.String callback) {
return (Delete) super.setCallback(callback);
}
@Override
public Delete setFields(java.lang.String fields) {
return (Delete) super.setFields(fields);
}
@Override
public Delete setKey(java.lang.String key) {
return (Delete) super.setKey(key);
}
@Override
public Delete setOauthToken(java.lang.String oauthToken) {
return (Delete) super.setOauthToken(oauthToken);
}
@Override
public Delete setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Delete) super.setPrettyPrint(prettyPrint);
}
@Override
public Delete setQuotaUser(java.lang.String quotaUser) {
return (Delete) super.setQuotaUser(quotaUser);
}
@Override
public Delete setUploadType(java.lang.String uploadType) {
return (Delete) super.setUploadType(uploadType);
}
@Override
public Delete setUploadProtocol(java.lang.String uploadProtocol) {
return (Delete) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Delete setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Delete setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
/** The GTM Variable ID. */
@com.google.api.client.util.Key
private java.lang.String variableId;
/** The GTM Variable ID.
*/
public java.lang.String getVariableId() {
return variableId;
}
/** The GTM Variable ID. */
public Delete setVariableId(java.lang.String variableId) {
this.variableId = variableId;
return this;
}
@Override
public Delete set(String parameterName, Object value) {
return (Delete) super.set(parameterName, value);
}
}
/**
* Gets a GTM Variable.
*
* Create a request for the method "variables.get".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Get#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param variableId The GTM Variable ID.
* @return the request
*/
public Get get(java.lang.String accountId, java.lang.String containerId, java.lang.String variableId) throws java.io.IOException {
Get result = new Get(accountId, containerId, variableId);
initialize(result);
return result;
}
public class Get extends TagManagerRequest<com.google.api.services.tagmanager.model.Variable> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/variables/{variableId}";
/**
* Gets a GTM Variable.
*
* Create a request for the method "variables.get".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Get#execute()} method to invoke the remote operation. <p>
* {@link Get#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)}
* must be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param variableId The GTM Variable ID.
* @since 1.13
*/
protected Get(java.lang.String accountId, java.lang.String containerId, java.lang.String variableId) {
super(TagManager.this, "GET", REST_PATH, null, com.google.api.services.tagmanager.model.Variable.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
this.variableId = com.google.api.client.util.Preconditions.checkNotNull(variableId, "Required parameter variableId must be specified.");
}
@Override
public com.google.api.client.http.HttpResponse executeUsingHead() throws java.io.IOException {
return super.executeUsingHead();
}
@Override
public com.google.api.client.http.HttpRequest buildHttpRequestUsingHead() throws java.io.IOException {
return super.buildHttpRequestUsingHead();
}
@Override
public Get set$Xgafv(java.lang.String $Xgafv) {
return (Get) super.set$Xgafv($Xgafv);
}
@Override
public Get setAccessToken(java.lang.String accessToken) {
return (Get) super.setAccessToken(accessToken);
}
@Override
public Get setAlt(java.lang.String alt) {
return (Get) super.setAlt(alt);
}
@Override
public Get setCallback(java.lang.String callback) {
return (Get) super.setCallback(callback);
}
@Override
public Get setFields(java.lang.String fields) {
return (Get) super.setFields(fields);
}
@Override
public Get setKey(java.lang.String key) {
return (Get) super.setKey(key);
}
@Override
public Get setOauthToken(java.lang.String oauthToken) {
return (Get) super.setOauthToken(oauthToken);
}
@Override
public Get setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Get) super.setPrettyPrint(prettyPrint);
}
@Override
public Get setQuotaUser(java.lang.String quotaUser) {
return (Get) super.setQuotaUser(quotaUser);
}
@Override
public Get setUploadType(java.lang.String uploadType) {
return (Get) super.setUploadType(uploadType);
}
@Override
public Get setUploadProtocol(java.lang.String uploadProtocol) {
return (Get) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Get setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Get setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
/** The GTM Variable ID. */
@com.google.api.client.util.Key
private java.lang.String variableId;
/** The GTM Variable ID.
*/
public java.lang.String getVariableId() {
return variableId;
}
/** The GTM Variable ID. */
public Get setVariableId(java.lang.String variableId) {
this.variableId = variableId;
return this;
}
@Override
public Get set(String parameterName, Object value) {
return (Get) super.set(parameterName, value);
}
}
/**
* Lists all GTM Variables of a Container.
*
* Create a request for the method "variables.list".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link List#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @return the request
*/
public List list(java.lang.String accountId, java.lang.String containerId) throws java.io.IOException {
List result = new List(accountId, containerId);
initialize(result);
return result;
}
public class List extends TagManagerRequest<com.google.api.services.tagmanager.model.ListVariablesResponse> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/variables";
/**
* Lists all GTM Variables of a Container.
*
* Create a request for the method "variables.list".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link List#execute()} method to invoke the remote operation. <p>
* {@link List#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)}
* must be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @since 1.13
*/
protected List(java.lang.String accountId, java.lang.String containerId) {
super(TagManager.this, "GET", REST_PATH, null, com.google.api.services.tagmanager.model.ListVariablesResponse.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
}
@Override
public com.google.api.client.http.HttpResponse executeUsingHead() throws java.io.IOException {
return super.executeUsingHead();
}
@Override
public com.google.api.client.http.HttpRequest buildHttpRequestUsingHead() throws java.io.IOException {
return super.buildHttpRequestUsingHead();
}
@Override
public List set$Xgafv(java.lang.String $Xgafv) {
return (List) super.set$Xgafv($Xgafv);
}
@Override
public List setAccessToken(java.lang.String accessToken) {
return (List) super.setAccessToken(accessToken);
}
@Override
public List setAlt(java.lang.String alt) {
return (List) super.setAlt(alt);
}
@Override
public List setCallback(java.lang.String callback) {
return (List) super.setCallback(callback);
}
@Override
public List setFields(java.lang.String fields) {
return (List) super.setFields(fields);
}
@Override
public List setKey(java.lang.String key) {
return (List) super.setKey(key);
}
@Override
public List setOauthToken(java.lang.String oauthToken) {
return (List) super.setOauthToken(oauthToken);
}
@Override
public List setPrettyPrint(java.lang.Boolean prettyPrint) {
return (List) super.setPrettyPrint(prettyPrint);
}
@Override
public List setQuotaUser(java.lang.String quotaUser) {
return (List) super.setQuotaUser(quotaUser);
}
@Override
public List setUploadType(java.lang.String uploadType) {
return (List) super.setUploadType(uploadType);
}
@Override
public List setUploadProtocol(java.lang.String uploadProtocol) {
return (List) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public List setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public List setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
@Override
public List set(String parameterName, Object value) {
return (List) super.set(parameterName, value);
}
}
/**
* Updates a GTM Variable.
*
* Create a request for the method "variables.update".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Update#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param variableId The GTM Variable ID.
* @param content the {@link com.google.api.services.tagmanager.model.Variable}
* @return the request
*/
public Update update(java.lang.String accountId, java.lang.String containerId, java.lang.String variableId, com.google.api.services.tagmanager.model.Variable content) throws java.io.IOException {
Update result = new Update(accountId, containerId, variableId, content);
initialize(result);
return result;
}
public class Update extends TagManagerRequest<com.google.api.services.tagmanager.model.Variable> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/variables/{variableId}";
/**
* Updates a GTM Variable.
*
* Create a request for the method "variables.update".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Update#execute()} method to invoke the remote operation.
* <p> {@link
* Update#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must
* be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param variableId The GTM Variable ID.
* @param content the {@link com.google.api.services.tagmanager.model.Variable}
* @since 1.13
*/
protected Update(java.lang.String accountId, java.lang.String containerId, java.lang.String variableId, com.google.api.services.tagmanager.model.Variable content) {
super(TagManager.this, "PUT", REST_PATH, content, com.google.api.services.tagmanager.model.Variable.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
this.variableId = com.google.api.client.util.Preconditions.checkNotNull(variableId, "Required parameter variableId must be specified.");
checkRequiredParameter(content, "content");
checkRequiredParameter(content.getName(), "Variable.getName()");
checkRequiredParameter(content, "content");
checkRequiredParameter(content.getType(), "Variable.getType()");
}
@Override
public Update set$Xgafv(java.lang.String $Xgafv) {
return (Update) super.set$Xgafv($Xgafv);
}
@Override
public Update setAccessToken(java.lang.String accessToken) {
return (Update) super.setAccessToken(accessToken);
}
@Override
public Update setAlt(java.lang.String alt) {
return (Update) super.setAlt(alt);
}
@Override
public Update setCallback(java.lang.String callback) {
return (Update) super.setCallback(callback);
}
@Override
public Update setFields(java.lang.String fields) {
return (Update) super.setFields(fields);
}
@Override
public Update setKey(java.lang.String key) {
return (Update) super.setKey(key);
}
@Override
public Update setOauthToken(java.lang.String oauthToken) {
return (Update) super.setOauthToken(oauthToken);
}
@Override
public Update setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Update) super.setPrettyPrint(prettyPrint);
}
@Override
public Update setQuotaUser(java.lang.String quotaUser) {
return (Update) super.setQuotaUser(quotaUser);
}
@Override
public Update setUploadType(java.lang.String uploadType) {
return (Update) super.setUploadType(uploadType);
}
@Override
public Update setUploadProtocol(java.lang.String uploadProtocol) {
return (Update) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Update setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Update setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
/** The GTM Variable ID. */
@com.google.api.client.util.Key
private java.lang.String variableId;
/** The GTM Variable ID.
*/
public java.lang.String getVariableId() {
return variableId;
}
/** The GTM Variable ID. */
public Update setVariableId(java.lang.String variableId) {
this.variableId = variableId;
return this;
}
/**
* When provided, this fingerprint must match the fingerprint of the variable in storage.
*/
@com.google.api.client.util.Key
private java.lang.String fingerprint;
/** When provided, this fingerprint must match the fingerprint of the variable in storage.
*/
public java.lang.String getFingerprint() {
return fingerprint;
}
/**
* When provided, this fingerprint must match the fingerprint of the variable in storage.
*/
public Update setFingerprint(java.lang.String fingerprint) {
this.fingerprint = fingerprint;
return this;
}
@Override
public Update set(String parameterName, Object value) {
return (Update) super.set(parameterName, value);
}
}
}
/**
* An accessor for creating requests from the Versions collection.
*
* <p>The typical use is:</p>
* <pre>
* {@code TagManager tagmanager = new TagManager(...);}
* {@code TagManager.Versions.List request = tagmanager.versions().list(parameters ...)}
* </pre>
*
* @return the resource collection
*/
public Versions versions() {
return new Versions();
}
/**
* The "versions" collection of methods.
*/
public class Versions {
/**
* Creates a Container Version.
*
* Create a request for the method "versions.create".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Create#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param content the {@link com.google.api.services.tagmanager.model.CreateContainerVersionRequestVersionOptions}
* @return the request
*/
public Create create(java.lang.String accountId, java.lang.String containerId, com.google.api.services.tagmanager.model.CreateContainerVersionRequestVersionOptions content) throws java.io.IOException {
Create result = new Create(accountId, containerId, content);
initialize(result);
return result;
}
public class Create extends TagManagerRequest<com.google.api.services.tagmanager.model.CreateContainerVersionResponse> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/versions";
/**
* Creates a Container Version.
*
* Create a request for the method "versions.create".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Create#execute()} method to invoke the remote operation.
* <p> {@link
* Create#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must
* be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param content the {@link com.google.api.services.tagmanager.model.CreateContainerVersionRequestVersionOptions}
* @since 1.13
*/
protected Create(java.lang.String accountId, java.lang.String containerId, com.google.api.services.tagmanager.model.CreateContainerVersionRequestVersionOptions content) {
super(TagManager.this, "POST", REST_PATH, content, com.google.api.services.tagmanager.model.CreateContainerVersionResponse.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
}
@Override
public Create set$Xgafv(java.lang.String $Xgafv) {
return (Create) super.set$Xgafv($Xgafv);
}
@Override
public Create setAccessToken(java.lang.String accessToken) {
return (Create) super.setAccessToken(accessToken);
}
@Override
public Create setAlt(java.lang.String alt) {
return (Create) super.setAlt(alt);
}
@Override
public Create setCallback(java.lang.String callback) {
return (Create) super.setCallback(callback);
}
@Override
public Create setFields(java.lang.String fields) {
return (Create) super.setFields(fields);
}
@Override
public Create setKey(java.lang.String key) {
return (Create) super.setKey(key);
}
@Override
public Create setOauthToken(java.lang.String oauthToken) {
return (Create) super.setOauthToken(oauthToken);
}
@Override
public Create setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Create) super.setPrettyPrint(prettyPrint);
}
@Override
public Create setQuotaUser(java.lang.String quotaUser) {
return (Create) super.setQuotaUser(quotaUser);
}
@Override
public Create setUploadType(java.lang.String uploadType) {
return (Create) super.setUploadType(uploadType);
}
@Override
public Create setUploadProtocol(java.lang.String uploadProtocol) {
return (Create) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Create setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Create setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
@Override
public Create set(String parameterName, Object value) {
return (Create) super.set(parameterName, value);
}
}
/**
* Deletes a Container Version.
*
* Create a request for the method "versions.delete".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Delete#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param containerVersionId The GTM Container Version ID.
* @return the request
*/
public Delete delete(java.lang.String accountId, java.lang.String containerId, java.lang.String containerVersionId) throws java.io.IOException {
Delete result = new Delete(accountId, containerId, containerVersionId);
initialize(result);
return result;
}
public class Delete extends TagManagerRequest<Void> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/versions/{containerVersionId}";
/**
* Deletes a Container Version.
*
* Create a request for the method "versions.delete".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Delete#execute()} method to invoke the remote operation.
* <p> {@link
* Delete#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must
* be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param containerVersionId The GTM Container Version ID.
* @since 1.13
*/
protected Delete(java.lang.String accountId, java.lang.String containerId, java.lang.String containerVersionId) {
super(TagManager.this, "DELETE", REST_PATH, null, Void.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
this.containerVersionId = com.google.api.client.util.Preconditions.checkNotNull(containerVersionId, "Required parameter containerVersionId must be specified.");
}
@Override
public Delete set$Xgafv(java.lang.String $Xgafv) {
return (Delete) super.set$Xgafv($Xgafv);
}
@Override
public Delete setAccessToken(java.lang.String accessToken) {
return (Delete) super.setAccessToken(accessToken);
}
@Override
public Delete setAlt(java.lang.String alt) {
return (Delete) super.setAlt(alt);
}
@Override
public Delete setCallback(java.lang.String callback) {
return (Delete) super.setCallback(callback);
}
@Override
public Delete setFields(java.lang.String fields) {
return (Delete) super.setFields(fields);
}
@Override
public Delete setKey(java.lang.String key) {
return (Delete) super.setKey(key);
}
@Override
public Delete setOauthToken(java.lang.String oauthToken) {
return (Delete) super.setOauthToken(oauthToken);
}
@Override
public Delete setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Delete) super.setPrettyPrint(prettyPrint);
}
@Override
public Delete setQuotaUser(java.lang.String quotaUser) {
return (Delete) super.setQuotaUser(quotaUser);
}
@Override
public Delete setUploadType(java.lang.String uploadType) {
return (Delete) super.setUploadType(uploadType);
}
@Override
public Delete setUploadProtocol(java.lang.String uploadProtocol) {
return (Delete) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Delete setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Delete setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
/** The GTM Container Version ID. */
@com.google.api.client.util.Key
private java.lang.String containerVersionId;
/** The GTM Container Version ID.
*/
public java.lang.String getContainerVersionId() {
return containerVersionId;
}
/** The GTM Container Version ID. */
public Delete setContainerVersionId(java.lang.String containerVersionId) {
this.containerVersionId = containerVersionId;
return this;
}
@Override
public Delete set(String parameterName, Object value) {
return (Delete) super.set(parameterName, value);
}
}
/**
* Gets a Container Version.
*
* Create a request for the method "versions.get".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Get#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param containerVersionId The GTM Container Version ID. Specify published to retrieve
the currently published version.
* @return the request
*/
public Get get(java.lang.String accountId, java.lang.String containerId, java.lang.String containerVersionId) throws java.io.IOException {
Get result = new Get(accountId, containerId, containerVersionId);
initialize(result);
return result;
}
public class Get extends TagManagerRequest<com.google.api.services.tagmanager.model.ContainerVersion> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/versions/{containerVersionId}";
/**
* Gets a Container Version.
*
* Create a request for the method "versions.get".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Get#execute()} method to invoke the remote operation. <p>
* {@link Get#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)}
* must be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param containerVersionId The GTM Container Version ID. Specify published to retrieve
the currently published version.
* @since 1.13
*/
protected Get(java.lang.String accountId, java.lang.String containerId, java.lang.String containerVersionId) {
super(TagManager.this, "GET", REST_PATH, null, com.google.api.services.tagmanager.model.ContainerVersion.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
this.containerVersionId = com.google.api.client.util.Preconditions.checkNotNull(containerVersionId, "Required parameter containerVersionId must be specified.");
}
@Override
public com.google.api.client.http.HttpResponse executeUsingHead() throws java.io.IOException {
return super.executeUsingHead();
}
@Override
public com.google.api.client.http.HttpRequest buildHttpRequestUsingHead() throws java.io.IOException {
return super.buildHttpRequestUsingHead();
}
@Override
public Get set$Xgafv(java.lang.String $Xgafv) {
return (Get) super.set$Xgafv($Xgafv);
}
@Override
public Get setAccessToken(java.lang.String accessToken) {
return (Get) super.setAccessToken(accessToken);
}
@Override
public Get setAlt(java.lang.String alt) {
return (Get) super.setAlt(alt);
}
@Override
public Get setCallback(java.lang.String callback) {
return (Get) super.setCallback(callback);
}
@Override
public Get setFields(java.lang.String fields) {
return (Get) super.setFields(fields);
}
@Override
public Get setKey(java.lang.String key) {
return (Get) super.setKey(key);
}
@Override
public Get setOauthToken(java.lang.String oauthToken) {
return (Get) super.setOauthToken(oauthToken);
}
@Override
public Get setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Get) super.setPrettyPrint(prettyPrint);
}
@Override
public Get setQuotaUser(java.lang.String quotaUser) {
return (Get) super.setQuotaUser(quotaUser);
}
@Override
public Get setUploadType(java.lang.String uploadType) {
return (Get) super.setUploadType(uploadType);
}
@Override
public Get setUploadProtocol(java.lang.String uploadProtocol) {
return (Get) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Get setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Get setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
/**
* The GTM Container Version ID. Specify published to retrieve the currently published
* version.
*/
@com.google.api.client.util.Key
private java.lang.String containerVersionId;
/** The GTM Container Version ID. Specify published to retrieve the currently published version.
*/
public java.lang.String getContainerVersionId() {
return containerVersionId;
}
/**
* The GTM Container Version ID. Specify published to retrieve the currently published
* version.
*/
public Get setContainerVersionId(java.lang.String containerVersionId) {
this.containerVersionId = containerVersionId;
return this;
}
@Override
public Get set(String parameterName, Object value) {
return (Get) super.set(parameterName, value);
}
}
/**
* Lists all Container Versions of a GTM Container.
*
* Create a request for the method "versions.list".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link List#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @return the request
*/
public List list(java.lang.String accountId, java.lang.String containerId) throws java.io.IOException {
List result = new List(accountId, containerId);
initialize(result);
return result;
}
public class List extends TagManagerRequest<com.google.api.services.tagmanager.model.ListContainerVersionsResponse> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/versions";
/**
* Lists all Container Versions of a GTM Container.
*
* Create a request for the method "versions.list".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link List#execute()} method to invoke the remote operation. <p>
* {@link List#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)}
* must be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @since 1.13
*/
protected List(java.lang.String accountId, java.lang.String containerId) {
super(TagManager.this, "GET", REST_PATH, null, com.google.api.services.tagmanager.model.ListContainerVersionsResponse.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
}
@Override
public com.google.api.client.http.HttpResponse executeUsingHead() throws java.io.IOException {
return super.executeUsingHead();
}
@Override
public com.google.api.client.http.HttpRequest buildHttpRequestUsingHead() throws java.io.IOException {
return super.buildHttpRequestUsingHead();
}
@Override
public List set$Xgafv(java.lang.String $Xgafv) {
return (List) super.set$Xgafv($Xgafv);
}
@Override
public List setAccessToken(java.lang.String accessToken) {
return (List) super.setAccessToken(accessToken);
}
@Override
public List setAlt(java.lang.String alt) {
return (List) super.setAlt(alt);
}
@Override
public List setCallback(java.lang.String callback) {
return (List) super.setCallback(callback);
}
@Override
public List setFields(java.lang.String fields) {
return (List) super.setFields(fields);
}
@Override
public List setKey(java.lang.String key) {
return (List) super.setKey(key);
}
@Override
public List setOauthToken(java.lang.String oauthToken) {
return (List) super.setOauthToken(oauthToken);
}
@Override
public List setPrettyPrint(java.lang.Boolean prettyPrint) {
return (List) super.setPrettyPrint(prettyPrint);
}
@Override
public List setQuotaUser(java.lang.String quotaUser) {
return (List) super.setQuotaUser(quotaUser);
}
@Override
public List setUploadType(java.lang.String uploadType) {
return (List) super.setUploadType(uploadType);
}
@Override
public List setUploadProtocol(java.lang.String uploadProtocol) {
return (List) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public List setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public List setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
/** Retrieve headers only when true. */
@com.google.api.client.util.Key
private java.lang.Boolean headers;
/** Retrieve headers only when true. [default: false]
*/
public java.lang.Boolean getHeaders() {
return headers;
}
/** Retrieve headers only when true. */
public List setHeaders(java.lang.Boolean headers) {
this.headers = headers;
return this;
}
/**
* Convenience method that returns only {@link Boolean#TRUE} or {@link Boolean#FALSE}.
*
* <p>
* Boolean properties can have four possible values:
* {@code null}, {@link com.google.api.client.util.Data#NULL_BOOLEAN}, {@link Boolean#TRUE}
* or {@link Boolean#FALSE}.
* </p>
*
* <p>
* This method returns {@link Boolean#TRUE} if the default of the property is {@link Boolean#TRUE}
* and it is {@code null} or {@link com.google.api.client.util.Data#NULL_BOOLEAN}.
* {@link Boolean#FALSE} is returned if the default of the property is {@link Boolean#FALSE} and
* it is {@code null} or {@link com.google.api.client.util.Data#NULL_BOOLEAN}.
* </p>
*
* <p>
* Retrieve headers only when true.
* </p>
*/
public boolean isHeaders() {
if (headers == null || headers == com.google.api.client.util.Data.NULL_BOOLEAN) {
return false;
}
return headers;
}
/** Also retrieve deleted (archived) versions when true. */
@com.google.api.client.util.Key
private java.lang.Boolean includeDeleted;
/** Also retrieve deleted (archived) versions when true. [default: false]
*/
public java.lang.Boolean getIncludeDeleted() {
return includeDeleted;
}
/** Also retrieve deleted (archived) versions when true. */
public List setIncludeDeleted(java.lang.Boolean includeDeleted) {
this.includeDeleted = includeDeleted;
return this;
}
/**
* Convenience method that returns only {@link Boolean#TRUE} or {@link Boolean#FALSE}.
*
* <p>
* Boolean properties can have four possible values:
* {@code null}, {@link com.google.api.client.util.Data#NULL_BOOLEAN}, {@link Boolean#TRUE}
* or {@link Boolean#FALSE}.
* </p>
*
* <p>
* This method returns {@link Boolean#TRUE} if the default of the property is {@link Boolean#TRUE}
* and it is {@code null} or {@link com.google.api.client.util.Data#NULL_BOOLEAN}.
* {@link Boolean#FALSE} is returned if the default of the property is {@link Boolean#FALSE} and
* it is {@code null} or {@link com.google.api.client.util.Data#NULL_BOOLEAN}.
* </p>
*
* <p>
* Also retrieve deleted (archived) versions when true.
* </p>
*/
public boolean isIncludeDeleted() {
if (includeDeleted == null || includeDeleted == com.google.api.client.util.Data.NULL_BOOLEAN) {
return false;
}
return includeDeleted;
}
@Override
public List set(String parameterName, Object value) {
return (List) super.set(parameterName, value);
}
}
/**
* Publishes a Container Version.
*
* Create a request for the method "versions.publish".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Publish#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param containerVersionId The GTM Container Version ID.
* @return the request
*/
public Publish publish(java.lang.String accountId, java.lang.String containerId, java.lang.String containerVersionId) throws java.io.IOException {
Publish result = new Publish(accountId, containerId, containerVersionId);
initialize(result);
return result;
}
public class Publish extends TagManagerRequest<com.google.api.services.tagmanager.model.PublishContainerVersionResponse> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/versions/{containerVersionId}/publish";
/**
* Publishes a Container Version.
*
* Create a request for the method "versions.publish".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Publish#execute()} method to invoke the remote operation.
* <p> {@link
* Publish#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must
* be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param containerVersionId The GTM Container Version ID.
* @since 1.13
*/
protected Publish(java.lang.String accountId, java.lang.String containerId, java.lang.String containerVersionId) {
super(TagManager.this, "POST", REST_PATH, null, com.google.api.services.tagmanager.model.PublishContainerVersionResponse.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
this.containerVersionId = com.google.api.client.util.Preconditions.checkNotNull(containerVersionId, "Required parameter containerVersionId must be specified.");
}
@Override
public Publish set$Xgafv(java.lang.String $Xgafv) {
return (Publish) super.set$Xgafv($Xgafv);
}
@Override
public Publish setAccessToken(java.lang.String accessToken) {
return (Publish) super.setAccessToken(accessToken);
}
@Override
public Publish setAlt(java.lang.String alt) {
return (Publish) super.setAlt(alt);
}
@Override
public Publish setCallback(java.lang.String callback) {
return (Publish) super.setCallback(callback);
}
@Override
public Publish setFields(java.lang.String fields) {
return (Publish) super.setFields(fields);
}
@Override
public Publish setKey(java.lang.String key) {
return (Publish) super.setKey(key);
}
@Override
public Publish setOauthToken(java.lang.String oauthToken) {
return (Publish) super.setOauthToken(oauthToken);
}
@Override
public Publish setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Publish) super.setPrettyPrint(prettyPrint);
}
@Override
public Publish setQuotaUser(java.lang.String quotaUser) {
return (Publish) super.setQuotaUser(quotaUser);
}
@Override
public Publish setUploadType(java.lang.String uploadType) {
return (Publish) super.setUploadType(uploadType);
}
@Override
public Publish setUploadProtocol(java.lang.String uploadProtocol) {
return (Publish) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Publish setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Publish setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
/** The GTM Container Version ID. */
@com.google.api.client.util.Key
private java.lang.String containerVersionId;
/** The GTM Container Version ID.
*/
public java.lang.String getContainerVersionId() {
return containerVersionId;
}
/** The GTM Container Version ID. */
public Publish setContainerVersionId(java.lang.String containerVersionId) {
this.containerVersionId = containerVersionId;
return this;
}
/**
* When provided, this fingerprint must match the fingerprint of the container version in
* storage.
*/
@com.google.api.client.util.Key
private java.lang.String fingerprint;
/** When provided, this fingerprint must match the fingerprint of the container version in storage.
*/
public java.lang.String getFingerprint() {
return fingerprint;
}
/**
* When provided, this fingerprint must match the fingerprint of the container version in
* storage.
*/
public Publish setFingerprint(java.lang.String fingerprint) {
this.fingerprint = fingerprint;
return this;
}
@Override
public Publish set(String parameterName, Object value) {
return (Publish) super.set(parameterName, value);
}
}
/**
* Restores a Container Version. This will overwrite the container's current configuration
* (including its variables, triggers and tags). The operation will not have any effect on the
* version that is being served (i.e. the published version).
*
* Create a request for the method "versions.restore".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Restore#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param containerVersionId The GTM Container Version ID.
* @return the request
*/
public Restore restore(java.lang.String accountId, java.lang.String containerId, java.lang.String containerVersionId) throws java.io.IOException {
Restore result = new Restore(accountId, containerId, containerVersionId);
initialize(result);
return result;
}
public class Restore extends TagManagerRequest<com.google.api.services.tagmanager.model.ContainerVersion> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/versions/{containerVersionId}/restore";
/**
* Restores a Container Version. This will overwrite the container's current configuration
* (including its variables, triggers and tags). The operation will not have any effect on the
* version that is being served (i.e. the published version).
*
* Create a request for the method "versions.restore".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Restore#execute()} method to invoke the remote operation.
* <p> {@link
* Restore#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must
* be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param containerVersionId The GTM Container Version ID.
* @since 1.13
*/
protected Restore(java.lang.String accountId, java.lang.String containerId, java.lang.String containerVersionId) {
super(TagManager.this, "POST", REST_PATH, null, com.google.api.services.tagmanager.model.ContainerVersion.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
this.containerVersionId = com.google.api.client.util.Preconditions.checkNotNull(containerVersionId, "Required parameter containerVersionId must be specified.");
}
@Override
public Restore set$Xgafv(java.lang.String $Xgafv) {
return (Restore) super.set$Xgafv($Xgafv);
}
@Override
public Restore setAccessToken(java.lang.String accessToken) {
return (Restore) super.setAccessToken(accessToken);
}
@Override
public Restore setAlt(java.lang.String alt) {
return (Restore) super.setAlt(alt);
}
@Override
public Restore setCallback(java.lang.String callback) {
return (Restore) super.setCallback(callback);
}
@Override
public Restore setFields(java.lang.String fields) {
return (Restore) super.setFields(fields);
}
@Override
public Restore setKey(java.lang.String key) {
return (Restore) super.setKey(key);
}
@Override
public Restore setOauthToken(java.lang.String oauthToken) {
return (Restore) super.setOauthToken(oauthToken);
}
@Override
public Restore setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Restore) super.setPrettyPrint(prettyPrint);
}
@Override
public Restore setQuotaUser(java.lang.String quotaUser) {
return (Restore) super.setQuotaUser(quotaUser);
}
@Override
public Restore setUploadType(java.lang.String uploadType) {
return (Restore) super.setUploadType(uploadType);
}
@Override
public Restore setUploadProtocol(java.lang.String uploadProtocol) {
return (Restore) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Restore setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Restore setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
/** The GTM Container Version ID. */
@com.google.api.client.util.Key
private java.lang.String containerVersionId;
/** The GTM Container Version ID.
*/
public java.lang.String getContainerVersionId() {
return containerVersionId;
}
/** The GTM Container Version ID. */
public Restore setContainerVersionId(java.lang.String containerVersionId) {
this.containerVersionId = containerVersionId;
return this;
}
@Override
public Restore set(String parameterName, Object value) {
return (Restore) super.set(parameterName, value);
}
}
/**
* Undeletes a Container Version.
*
* Create a request for the method "versions.undelete".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Undelete#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param containerVersionId The GTM Container Version ID.
* @return the request
*/
public Undelete undelete(java.lang.String accountId, java.lang.String containerId, java.lang.String containerVersionId) throws java.io.IOException {
Undelete result = new Undelete(accountId, containerId, containerVersionId);
initialize(result);
return result;
}
public class Undelete extends TagManagerRequest<com.google.api.services.tagmanager.model.ContainerVersion> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/versions/{containerVersionId}/undelete";
/**
* Undeletes a Container Version.
*
* Create a request for the method "versions.undelete".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Undelete#execute()} method to invoke the remote operation.
* <p> {@link
* Undelete#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)}
* must be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param containerVersionId The GTM Container Version ID.
* @since 1.13
*/
protected Undelete(java.lang.String accountId, java.lang.String containerId, java.lang.String containerVersionId) {
super(TagManager.this, "POST", REST_PATH, null, com.google.api.services.tagmanager.model.ContainerVersion.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
this.containerVersionId = com.google.api.client.util.Preconditions.checkNotNull(containerVersionId, "Required parameter containerVersionId must be specified.");
}
@Override
public Undelete set$Xgafv(java.lang.String $Xgafv) {
return (Undelete) super.set$Xgafv($Xgafv);
}
@Override
public Undelete setAccessToken(java.lang.String accessToken) {
return (Undelete) super.setAccessToken(accessToken);
}
@Override
public Undelete setAlt(java.lang.String alt) {
return (Undelete) super.setAlt(alt);
}
@Override
public Undelete setCallback(java.lang.String callback) {
return (Undelete) super.setCallback(callback);
}
@Override
public Undelete setFields(java.lang.String fields) {
return (Undelete) super.setFields(fields);
}
@Override
public Undelete setKey(java.lang.String key) {
return (Undelete) super.setKey(key);
}
@Override
public Undelete setOauthToken(java.lang.String oauthToken) {
return (Undelete) super.setOauthToken(oauthToken);
}
@Override
public Undelete setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Undelete) super.setPrettyPrint(prettyPrint);
}
@Override
public Undelete setQuotaUser(java.lang.String quotaUser) {
return (Undelete) super.setQuotaUser(quotaUser);
}
@Override
public Undelete setUploadType(java.lang.String uploadType) {
return (Undelete) super.setUploadType(uploadType);
}
@Override
public Undelete setUploadProtocol(java.lang.String uploadProtocol) {
return (Undelete) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Undelete setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Undelete setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
/** The GTM Container Version ID. */
@com.google.api.client.util.Key
private java.lang.String containerVersionId;
/** The GTM Container Version ID.
*/
public java.lang.String getContainerVersionId() {
return containerVersionId;
}
/** The GTM Container Version ID. */
public Undelete setContainerVersionId(java.lang.String containerVersionId) {
this.containerVersionId = containerVersionId;
return this;
}
@Override
public Undelete set(String parameterName, Object value) {
return (Undelete) super.set(parameterName, value);
}
}
/**
* Updates a Container Version.
*
* Create a request for the method "versions.update".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Update#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param containerVersionId The GTM Container Version ID.
* @param content the {@link com.google.api.services.tagmanager.model.ContainerVersion}
* @return the request
*/
public Update update(java.lang.String accountId, java.lang.String containerId, java.lang.String containerVersionId, com.google.api.services.tagmanager.model.ContainerVersion content) throws java.io.IOException {
Update result = new Update(accountId, containerId, containerVersionId, content);
initialize(result);
return result;
}
public class Update extends TagManagerRequest<com.google.api.services.tagmanager.model.ContainerVersion> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/containers/{containerId}/versions/{containerVersionId}";
/**
* Updates a Container Version.
*
* Create a request for the method "versions.update".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Update#execute()} method to invoke the remote operation.
* <p> {@link
* Update#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must
* be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param containerId The GTM Container ID.
* @param containerVersionId The GTM Container Version ID.
* @param content the {@link com.google.api.services.tagmanager.model.ContainerVersion}
* @since 1.13
*/
protected Update(java.lang.String accountId, java.lang.String containerId, java.lang.String containerVersionId, com.google.api.services.tagmanager.model.ContainerVersion content) {
super(TagManager.this, "PUT", REST_PATH, content, com.google.api.services.tagmanager.model.ContainerVersion.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.containerId = com.google.api.client.util.Preconditions.checkNotNull(containerId, "Required parameter containerId must be specified.");
this.containerVersionId = com.google.api.client.util.Preconditions.checkNotNull(containerVersionId, "Required parameter containerVersionId must be specified.");
}
@Override
public Update set$Xgafv(java.lang.String $Xgafv) {
return (Update) super.set$Xgafv($Xgafv);
}
@Override
public Update setAccessToken(java.lang.String accessToken) {
return (Update) super.setAccessToken(accessToken);
}
@Override
public Update setAlt(java.lang.String alt) {
return (Update) super.setAlt(alt);
}
@Override
public Update setCallback(java.lang.String callback) {
return (Update) super.setCallback(callback);
}
@Override
public Update setFields(java.lang.String fields) {
return (Update) super.setFields(fields);
}
@Override
public Update setKey(java.lang.String key) {
return (Update) super.setKey(key);
}
@Override
public Update setOauthToken(java.lang.String oauthToken) {
return (Update) super.setOauthToken(oauthToken);
}
@Override
public Update setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Update) super.setPrettyPrint(prettyPrint);
}
@Override
public Update setQuotaUser(java.lang.String quotaUser) {
return (Update) super.setQuotaUser(quotaUser);
}
@Override
public Update setUploadType(java.lang.String uploadType) {
return (Update) super.setUploadType(uploadType);
}
@Override
public Update setUploadProtocol(java.lang.String uploadProtocol) {
return (Update) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Update setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM Container ID. */
@com.google.api.client.util.Key
private java.lang.String containerId;
/** The GTM Container ID.
*/
public java.lang.String getContainerId() {
return containerId;
}
/** The GTM Container ID. */
public Update setContainerId(java.lang.String containerId) {
this.containerId = containerId;
return this;
}
/** The GTM Container Version ID. */
@com.google.api.client.util.Key
private java.lang.String containerVersionId;
/** The GTM Container Version ID.
*/
public java.lang.String getContainerVersionId() {
return containerVersionId;
}
/** The GTM Container Version ID. */
public Update setContainerVersionId(java.lang.String containerVersionId) {
this.containerVersionId = containerVersionId;
return this;
}
/**
* When provided, this fingerprint must match the fingerprint of the container version in
* storage.
*/
@com.google.api.client.util.Key
private java.lang.String fingerprint;
/** When provided, this fingerprint must match the fingerprint of the container version in storage.
*/
public java.lang.String getFingerprint() {
return fingerprint;
}
/**
* When provided, this fingerprint must match the fingerprint of the container version in
* storage.
*/
public Update setFingerprint(java.lang.String fingerprint) {
this.fingerprint = fingerprint;
return this;
}
@Override
public Update set(String parameterName, Object value) {
return (Update) super.set(parameterName, value);
}
}
}
}
/**
* An accessor for creating requests from the Permissions collection.
*
* <p>The typical use is:</p>
* <pre>
* {@code TagManager tagmanager = new TagManager(...);}
* {@code TagManager.Permissions.List request = tagmanager.permissions().list(parameters ...)}
* </pre>
*
* @return the resource collection
*/
public Permissions permissions() {
return new Permissions();
}
/**
* The "permissions" collection of methods.
*/
public class Permissions {
/**
* Creates a user's Account & Container Permissions.
*
* Create a request for the method "permissions.create".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Create#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param content the {@link com.google.api.services.tagmanager.model.UserAccess}
* @return the request
*/
public Create create(java.lang.String accountId, com.google.api.services.tagmanager.model.UserAccess content) throws java.io.IOException {
Create result = new Create(accountId, content);
initialize(result);
return result;
}
public class Create extends TagManagerRequest<com.google.api.services.tagmanager.model.UserAccess> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/permissions";
/**
* Creates a user's Account & Container Permissions.
*
* Create a request for the method "permissions.create".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Create#execute()} method to invoke the remote operation.
* <p> {@link
* Create#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must
* be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param content the {@link com.google.api.services.tagmanager.model.UserAccess}
* @since 1.13
*/
protected Create(java.lang.String accountId, com.google.api.services.tagmanager.model.UserAccess content) {
super(TagManager.this, "POST", REST_PATH, content, com.google.api.services.tagmanager.model.UserAccess.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
checkRequiredParameter(content, "content");
checkRequiredParameter(content.getEmailAddress(), "UserAccess.getEmailAddress()");
}
@Override
public Create set$Xgafv(java.lang.String $Xgafv) {
return (Create) super.set$Xgafv($Xgafv);
}
@Override
public Create setAccessToken(java.lang.String accessToken) {
return (Create) super.setAccessToken(accessToken);
}
@Override
public Create setAlt(java.lang.String alt) {
return (Create) super.setAlt(alt);
}
@Override
public Create setCallback(java.lang.String callback) {
return (Create) super.setCallback(callback);
}
@Override
public Create setFields(java.lang.String fields) {
return (Create) super.setFields(fields);
}
@Override
public Create setKey(java.lang.String key) {
return (Create) super.setKey(key);
}
@Override
public Create setOauthToken(java.lang.String oauthToken) {
return (Create) super.setOauthToken(oauthToken);
}
@Override
public Create setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Create) super.setPrettyPrint(prettyPrint);
}
@Override
public Create setQuotaUser(java.lang.String quotaUser) {
return (Create) super.setQuotaUser(quotaUser);
}
@Override
public Create setUploadType(java.lang.String uploadType) {
return (Create) super.setUploadType(uploadType);
}
@Override
public Create setUploadProtocol(java.lang.String uploadProtocol) {
return (Create) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Create setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
@Override
public Create set(String parameterName, Object value) {
return (Create) super.set(parameterName, value);
}
}
/**
* Removes a user from the account, revoking access to it and all of its containers.
*
* Create a request for the method "permissions.delete".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Delete#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param permissionId The GTM User ID.
* @return the request
*/
public Delete delete(java.lang.String accountId, java.lang.String permissionId) throws java.io.IOException {
Delete result = new Delete(accountId, permissionId);
initialize(result);
return result;
}
public class Delete extends TagManagerRequest<Void> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/permissions/{permissionId}";
/**
* Removes a user from the account, revoking access to it and all of its containers.
*
* Create a request for the method "permissions.delete".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Delete#execute()} method to invoke the remote operation.
* <p> {@link
* Delete#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must
* be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param permissionId The GTM User ID.
* @since 1.13
*/
protected Delete(java.lang.String accountId, java.lang.String permissionId) {
super(TagManager.this, "DELETE", REST_PATH, null, Void.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.permissionId = com.google.api.client.util.Preconditions.checkNotNull(permissionId, "Required parameter permissionId must be specified.");
}
@Override
public Delete set$Xgafv(java.lang.String $Xgafv) {
return (Delete) super.set$Xgafv($Xgafv);
}
@Override
public Delete setAccessToken(java.lang.String accessToken) {
return (Delete) super.setAccessToken(accessToken);
}
@Override
public Delete setAlt(java.lang.String alt) {
return (Delete) super.setAlt(alt);
}
@Override
public Delete setCallback(java.lang.String callback) {
return (Delete) super.setCallback(callback);
}
@Override
public Delete setFields(java.lang.String fields) {
return (Delete) super.setFields(fields);
}
@Override
public Delete setKey(java.lang.String key) {
return (Delete) super.setKey(key);
}
@Override
public Delete setOauthToken(java.lang.String oauthToken) {
return (Delete) super.setOauthToken(oauthToken);
}
@Override
public Delete setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Delete) super.setPrettyPrint(prettyPrint);
}
@Override
public Delete setQuotaUser(java.lang.String quotaUser) {
return (Delete) super.setQuotaUser(quotaUser);
}
@Override
public Delete setUploadType(java.lang.String uploadType) {
return (Delete) super.setUploadType(uploadType);
}
@Override
public Delete setUploadProtocol(java.lang.String uploadProtocol) {
return (Delete) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Delete setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM User ID. */
@com.google.api.client.util.Key
private java.lang.String permissionId;
/** The GTM User ID.
*/
public java.lang.String getPermissionId() {
return permissionId;
}
/** The GTM User ID. */
public Delete setPermissionId(java.lang.String permissionId) {
this.permissionId = permissionId;
return this;
}
@Override
public Delete set(String parameterName, Object value) {
return (Delete) super.set(parameterName, value);
}
}
/**
* Gets a user's Account & Container Permissions.
*
* Create a request for the method "permissions.get".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Get#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param permissionId The GTM User ID.
* @return the request
*/
public Get get(java.lang.String accountId, java.lang.String permissionId) throws java.io.IOException {
Get result = new Get(accountId, permissionId);
initialize(result);
return result;
}
public class Get extends TagManagerRequest<com.google.api.services.tagmanager.model.UserAccess> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/permissions/{permissionId}";
/**
* Gets a user's Account & Container Permissions.
*
* Create a request for the method "permissions.get".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Get#execute()} method to invoke the remote operation. <p>
* {@link Get#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)}
* must be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param permissionId The GTM User ID.
* @since 1.13
*/
protected Get(java.lang.String accountId, java.lang.String permissionId) {
super(TagManager.this, "GET", REST_PATH, null, com.google.api.services.tagmanager.model.UserAccess.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.permissionId = com.google.api.client.util.Preconditions.checkNotNull(permissionId, "Required parameter permissionId must be specified.");
}
@Override
public com.google.api.client.http.HttpResponse executeUsingHead() throws java.io.IOException {
return super.executeUsingHead();
}
@Override
public com.google.api.client.http.HttpRequest buildHttpRequestUsingHead() throws java.io.IOException {
return super.buildHttpRequestUsingHead();
}
@Override
public Get set$Xgafv(java.lang.String $Xgafv) {
return (Get) super.set$Xgafv($Xgafv);
}
@Override
public Get setAccessToken(java.lang.String accessToken) {
return (Get) super.setAccessToken(accessToken);
}
@Override
public Get setAlt(java.lang.String alt) {
return (Get) super.setAlt(alt);
}
@Override
public Get setCallback(java.lang.String callback) {
return (Get) super.setCallback(callback);
}
@Override
public Get setFields(java.lang.String fields) {
return (Get) super.setFields(fields);
}
@Override
public Get setKey(java.lang.String key) {
return (Get) super.setKey(key);
}
@Override
public Get setOauthToken(java.lang.String oauthToken) {
return (Get) super.setOauthToken(oauthToken);
}
@Override
public Get setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Get) super.setPrettyPrint(prettyPrint);
}
@Override
public Get setQuotaUser(java.lang.String quotaUser) {
return (Get) super.setQuotaUser(quotaUser);
}
@Override
public Get setUploadType(java.lang.String uploadType) {
return (Get) super.setUploadType(uploadType);
}
@Override
public Get setUploadProtocol(java.lang.String uploadProtocol) {
return (Get) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Get setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM User ID. */
@com.google.api.client.util.Key
private java.lang.String permissionId;
/** The GTM User ID.
*/
public java.lang.String getPermissionId() {
return permissionId;
}
/** The GTM User ID. */
public Get setPermissionId(java.lang.String permissionId) {
this.permissionId = permissionId;
return this;
}
@Override
public Get set(String parameterName, Object value) {
return (Get) super.set(parameterName, value);
}
}
/**
* List all users that have access to the account along with Account and Container Permissions
* granted to each of them.
*
* Create a request for the method "permissions.list".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link List#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @return the request
*/
public List list(java.lang.String accountId) throws java.io.IOException {
List result = new List(accountId);
initialize(result);
return result;
}
public class List extends TagManagerRequest<com.google.api.services.tagmanager.model.ListAccountUsersResponse> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/permissions";
/**
* List all users that have access to the account along with Account and Container Permissions
* granted to each of them.
*
* Create a request for the method "permissions.list".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link List#execute()} method to invoke the remote operation. <p>
* {@link List#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)}
* must be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @since 1.13
*/
protected List(java.lang.String accountId) {
super(TagManager.this, "GET", REST_PATH, null, com.google.api.services.tagmanager.model.ListAccountUsersResponse.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
}
@Override
public com.google.api.client.http.HttpResponse executeUsingHead() throws java.io.IOException {
return super.executeUsingHead();
}
@Override
public com.google.api.client.http.HttpRequest buildHttpRequestUsingHead() throws java.io.IOException {
return super.buildHttpRequestUsingHead();
}
@Override
public List set$Xgafv(java.lang.String $Xgafv) {
return (List) super.set$Xgafv($Xgafv);
}
@Override
public List setAccessToken(java.lang.String accessToken) {
return (List) super.setAccessToken(accessToken);
}
@Override
public List setAlt(java.lang.String alt) {
return (List) super.setAlt(alt);
}
@Override
public List setCallback(java.lang.String callback) {
return (List) super.setCallback(callback);
}
@Override
public List setFields(java.lang.String fields) {
return (List) super.setFields(fields);
}
@Override
public List setKey(java.lang.String key) {
return (List) super.setKey(key);
}
@Override
public List setOauthToken(java.lang.String oauthToken) {
return (List) super.setOauthToken(oauthToken);
}
@Override
public List setPrettyPrint(java.lang.Boolean prettyPrint) {
return (List) super.setPrettyPrint(prettyPrint);
}
@Override
public List setQuotaUser(java.lang.String quotaUser) {
return (List) super.setQuotaUser(quotaUser);
}
@Override
public List setUploadType(java.lang.String uploadType) {
return (List) super.setUploadType(uploadType);
}
@Override
public List setUploadProtocol(java.lang.String uploadProtocol) {
return (List) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public List setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
@Override
public List set(String parameterName, Object value) {
return (List) super.set(parameterName, value);
}
}
/**
* Updates a user's Account & Container Permissions.
*
* Create a request for the method "permissions.update".
*
* This request holds the parameters needed by the tagmanager server. After setting any optional
* parameters, call the {@link Update#execute()} method to invoke the remote operation.
*
* @param accountId The GTM Account ID.
* @param permissionId The GTM User ID.
* @param content the {@link com.google.api.services.tagmanager.model.UserAccess}
* @return the request
*/
public Update update(java.lang.String accountId, java.lang.String permissionId, com.google.api.services.tagmanager.model.UserAccess content) throws java.io.IOException {
Update result = new Update(accountId, permissionId, content);
initialize(result);
return result;
}
public class Update extends TagManagerRequest<com.google.api.services.tagmanager.model.UserAccess> {
private static final String REST_PATH = "tagmanager/v1/accounts/{accountId}/permissions/{permissionId}";
/**
* Updates a user's Account & Container Permissions.
*
* Create a request for the method "permissions.update".
*
* This request holds the parameters needed by the the tagmanager server. After setting any
* optional parameters, call the {@link Update#execute()} method to invoke the remote operation.
* <p> {@link
* Update#initialize(com.google.api.client.googleapis.services.AbstractGoogleClientRequest)} must
* be called to initialize this instance immediately after invoking the constructor. </p>
*
* @param accountId The GTM Account ID.
* @param permissionId The GTM User ID.
* @param content the {@link com.google.api.services.tagmanager.model.UserAccess}
* @since 1.13
*/
protected Update(java.lang.String accountId, java.lang.String permissionId, com.google.api.services.tagmanager.model.UserAccess content) {
super(TagManager.this, "PUT", REST_PATH, content, com.google.api.services.tagmanager.model.UserAccess.class);
this.accountId = com.google.api.client.util.Preconditions.checkNotNull(accountId, "Required parameter accountId must be specified.");
this.permissionId = com.google.api.client.util.Preconditions.checkNotNull(permissionId, "Required parameter permissionId must be specified.");
}
@Override
public Update set$Xgafv(java.lang.String $Xgafv) {
return (Update) super.set$Xgafv($Xgafv);
}
@Override
public Update setAccessToken(java.lang.String accessToken) {
return (Update) super.setAccessToken(accessToken);
}
@Override
public Update setAlt(java.lang.String alt) {
return (Update) super.setAlt(alt);
}
@Override
public Update setCallback(java.lang.String callback) {
return (Update) super.setCallback(callback);
}
@Override
public Update setFields(java.lang.String fields) {
return (Update) super.setFields(fields);
}
@Override
public Update setKey(java.lang.String key) {
return (Update) super.setKey(key);
}
@Override
public Update setOauthToken(java.lang.String oauthToken) {
return (Update) super.setOauthToken(oauthToken);
}
@Override
public Update setPrettyPrint(java.lang.Boolean prettyPrint) {
return (Update) super.setPrettyPrint(prettyPrint);
}
@Override
public Update setQuotaUser(java.lang.String quotaUser) {
return (Update) super.setQuotaUser(quotaUser);
}
@Override
public Update setUploadType(java.lang.String uploadType) {
return (Update) super.setUploadType(uploadType);
}
@Override
public Update setUploadProtocol(java.lang.String uploadProtocol) {
return (Update) super.setUploadProtocol(uploadProtocol);
}
/** The GTM Account ID. */
@com.google.api.client.util.Key
private java.lang.String accountId;
/** The GTM Account ID.
*/
public java.lang.String getAccountId() {
return accountId;
}
/** The GTM Account ID. */
public Update setAccountId(java.lang.String accountId) {
this.accountId = accountId;
return this;
}
/** The GTM User ID. */
@com.google.api.client.util.Key
private java.lang.String permissionId;
/** The GTM User ID.
*/
public java.lang.String getPermissionId() {
return permissionId;
}
/** The GTM User ID. */
public Update setPermissionId(java.lang.String permissionId) {
this.permissionId = permissionId;
return this;
}
@Override
public Update set(String parameterName, Object value) {
return (Update) super.set(parameterName, value);
}
}
}
}
/**
* Builder for {@link TagManager}.
*
* <p>
* Implementation is not thread-safe.
* </p>
*
* @since 1.3.0
*/
public static final class Builder extends com.google.api.client.googleapis.services.json.AbstractGoogleJsonClient.Builder {
/**
* Returns an instance of a new builder.
*
* @param transport HTTP transport, which should normally be:
* <ul>
* <li>Google App Engine:
* {@code com.google.api.client.extensions.appengine.http.UrlFetchTransport}</li>
* <li>Android: {@code newCompatibleTransport} from
* {@code com.google.api.client.extensions.android.http.AndroidHttp}</li>
* <li>Java: {@link com.google.api.client.googleapis.javanet.GoogleNetHttpTransport#newTrustedTransport()}
* </li>
* </ul>
* @param jsonFactory JSON factory, which may be:
* <ul>
* <li>Jackson: {@code com.google.api.client.json.jackson2.JacksonFactory}</li>
* <li>Google GSON: {@code com.google.api.client.json.gson.GsonFactory}</li>
* <li>Android Honeycomb or higher:
* {@code com.google.api.client.extensions.android.json.AndroidJsonFactory}</li>
* </ul>
* @param httpRequestInitializer HTTP request initializer or {@code null} for none
* @since 1.7
*/
public Builder(com.google.api.client.http.HttpTransport transport, com.google.api.client.json.JsonFactory jsonFactory,
com.google.api.client.http.HttpRequestInitializer httpRequestInitializer) {
super(
transport,
jsonFactory,
DEFAULT_ROOT_URL,
DEFAULT_SERVICE_PATH,
httpRequestInitializer,
false);
setBatchPath(DEFAULT_BATCH_PATH);
}
/** Builds a new instance of {@link TagManager}. */
@Override
public TagManager build() {
return new TagManager(this);
}
@Override
public Builder setRootUrl(String rootUrl) {
return (Builder) super.setRootUrl(rootUrl);
}
@Override
public Builder setServicePath(String servicePath) {
return (Builder) super.setServicePath(servicePath);
}
@Override
public Builder setBatchPath(String batchPath) {
return (Builder) super.setBatchPath(batchPath);
}
@Override
public Builder setHttpRequestInitializer(com.google.api.client.http.HttpRequestInitializer httpRequestInitializer) {
return (Builder) super.setHttpRequestInitializer(httpRequestInitializer);
}
@Override
public Builder setApplicationName(String applicationName) {
return (Builder) super.setApplicationName(applicationName);
}
@Override
public Builder setSuppressPatternChecks(boolean suppressPatternChecks) {
return (Builder) super.setSuppressPatternChecks(suppressPatternChecks);
}
@Override
public Builder setSuppressRequiredParameterChecks(boolean suppressRequiredParameterChecks) {
return (Builder) super.setSuppressRequiredParameterChecks(suppressRequiredParameterChecks);
}
@Override
public Builder setSuppressAllChecks(boolean suppressAllChecks) {
return (Builder) super.setSuppressAllChecks(suppressAllChecks);
}
/**
* Set the {@link TagManagerRequestInitializer}.
*
* @since 1.12
*/
public Builder setTagManagerRequestInitializer(
TagManagerRequestInitializer tagmanagerRequestInitializer) {
return (Builder) super.setGoogleClientRequestInitializer(tagmanagerRequestInitializer);
}
@Override
public Builder setGoogleClientRequestInitializer(
com.google.api.client.googleapis.services.GoogleClientRequestInitializer googleClientRequestInitializer) {
return (Builder) super.setGoogleClientRequestInitializer(googleClientRequestInitializer);
}
}
}
| 126,973 |
702 | <reponame>gluckzhang/besu
/*
* Copyright Hyperledger Besu Contributors.
*
* 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.
*
* SPDX-License-Identifier: Apache-2.0
*/
package org.hyperledger.besu.ethereum.api.jsonrpc.internal.results;
import org.hyperledger.besu.datatypes.Hash;
import org.hyperledger.besu.ethereum.api.jsonrpc.internal.methods.ExecutionEngineJsonRpcMethod.ExecutionStatus;
import java.util.Optional;
import com.fasterxml.jackson.annotation.JsonGetter;
import com.fasterxml.jackson.annotation.JsonPropertyOrder;
@JsonPropertyOrder({"status", "latestValidHash", "validationError"})
public class EngineExecutionResult {
ExecutionStatus status;
Optional<Hash> latestValidHash;
Optional<String> validationError;
public EngineExecutionResult(
final ExecutionStatus status, final Hash latestValidHash, final String validationError) {
this.status = status;
this.latestValidHash = Optional.ofNullable(latestValidHash);
this.validationError = Optional.ofNullable(validationError);
}
@JsonGetter(value = "status")
public String getStatus() {
return status.name();
}
@JsonGetter(value = "latestValidHash")
public String getLatestValidHash() {
return latestValidHash.map(Hash::toHexString).orElse(null);
}
@JsonGetter(value = "validationError")
public String getValidationError() {
return validationError.orElse(null);
}
}
| 573 |
3,586 | package com.linkedin.metadata.graph;
import com.linkedin.common.urn.Urn;
import com.linkedin.metadata.query.filter.Filter;
import com.linkedin.metadata.query.filter.RelationshipDirection;
import com.linkedin.metadata.query.filter.RelationshipFilter;
import org.testng.Assert;
import org.testng.annotations.DataProvider;
import org.testng.annotations.Test;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import java.net.URISyntaxException;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import static com.linkedin.metadata.search.utils.QueryUtils.EMPTY_FILTER;
import static com.linkedin.metadata.search.utils.QueryUtils.newFilter;
import static com.linkedin.metadata.search.utils.QueryUtils.newRelationshipFilter;
import static org.testng.Assert.*;
/**
* Base class for testing any GraphService implementation.
* Derive the test class from this base and get your GraphService implementation
* tested with all these tests.
*
* You can add implementation specific tests in derived classes, or add general tests
* here and have all existing implementations tested in the same way.
*
* The `getPopulatedGraphService` method calls `GraphService.addEdge` to provide a populated Graph.
* Feel free to add a test to your test implementation that calls `getPopulatedGraphService` and
* asserts the state of the graph in an implementation specific way.
*/
abstract public class GraphServiceTestBase {
private static class RelatedEntityComparator implements Comparator<RelatedEntity> {
@Override
public int compare(RelatedEntity left, RelatedEntity right) {
int cmp = left.relationshipType.compareTo(right.relationshipType);
if (cmp != 0) {
return cmp;
}
return left.urn.compareTo(right.urn);
}
}
protected static final RelatedEntityComparator RELATED_ENTITY_COMPARATOR = new RelatedEntityComparator();
/**
* Some test URN types.
*/
protected static String datasetType = "dataset";
protected static String userType = "user";
/**
* Some test datasets.
*/
protected static String datasetOneUrnString = "urn:li:" + datasetType + ":(urn:li:dataPlatform:type,SampleDatasetOne,PROD)";
protected static String datasetTwoUrnString = "urn:li:" + datasetType + ":(urn:li:dataPlatform:type,SampleDatasetTwo,PROD)";
protected static String datasetThreeUrnString = "urn:li:" + datasetType + ":(urn:li:dataPlatform:type,SampleDatasetThree,PROD)";
protected static String datasetFourUrnString = "urn:li:" + datasetType + ":(urn:li:dataPlatform:type,SampleDatasetFour,PROD)";
protected static Urn datasetOneUrn = createFromString(datasetOneUrnString);
protected static Urn datasetTwoUrn = createFromString(datasetTwoUrnString);
protected static Urn datasetThreeUrn = createFromString(datasetThreeUrnString);
protected static Urn datasetFourUrn = createFromString(datasetFourUrnString);
protected static String unknownUrnString = "urn:li:unknown:(urn:li:unknown:Unknown)";
/**
* Some dataset owners.
*/
protected static String userOneUrnString = "urn:li:" + userType + ":(urn:li:user:system,Ingress,PROD)";
protected static String userTwoUrnString = "urn:li:" + userType + ":(urn:li:user:individual,UserA,DEV)";
protected static Urn userOneUrn = createFromString(userOneUrnString);
protected static Urn userTwoUrn = createFromString(userTwoUrnString);
protected static Urn unknownUrn = createFromString(unknownUrnString);
/**
* Some test relationships.
*/
protected static String downstreamOf = "DownstreamOf";
protected static String hasOwner = "HasOwner";
protected static String knowsUser = "KnowsUser";
protected static Set<String> allRelationshipTypes = new HashSet<>(Arrays.asList(downstreamOf, hasOwner, knowsUser));
/**
* Some expected related entities.
*/
protected static RelatedEntity downstreamOfDatasetOneRelatedEntity = new RelatedEntity(downstreamOf, datasetOneUrnString);
protected static RelatedEntity downstreamOfDatasetTwoRelatedEntity = new RelatedEntity(downstreamOf, datasetTwoUrnString);
protected static RelatedEntity downstreamOfDatasetThreeRelatedEntity = new RelatedEntity(downstreamOf, datasetThreeUrnString);
protected static RelatedEntity downstreamOfDatasetFourRelatedEntity = new RelatedEntity(downstreamOf, datasetFourUrnString);
protected static RelatedEntity hasOwnerDatasetOneRelatedEntity = new RelatedEntity(hasOwner, datasetOneUrnString);
protected static RelatedEntity hasOwnerDatasetTwoRelatedEntity = new RelatedEntity(hasOwner, datasetTwoUrnString);
protected static RelatedEntity hasOwnerDatasetThreeRelatedEntity = new RelatedEntity(hasOwner, datasetThreeUrnString);
protected static RelatedEntity hasOwnerDatasetFourRelatedEntity = new RelatedEntity(hasOwner, datasetFourUrnString);
protected static RelatedEntity hasOwnerUserOneRelatedEntity = new RelatedEntity(hasOwner, userOneUrnString);
protected static RelatedEntity hasOwnerUserTwoRelatedEntity = new RelatedEntity(hasOwner, userTwoUrnString);
protected static RelatedEntity knowsUserOneRelatedEntity = new RelatedEntity(knowsUser, userOneUrnString);
protected static RelatedEntity knowsUserTwoRelatedEntity = new RelatedEntity(knowsUser, userTwoUrnString);
/**
* Some relationship filters.
*/
protected static RelationshipFilter outgoingRelationships = newRelationshipFilter(EMPTY_FILTER, RelationshipDirection.OUTGOING);
protected static RelationshipFilter incomingRelationships = newRelationshipFilter(EMPTY_FILTER, RelationshipDirection.INCOMING);
protected static RelationshipFilter undirectedRelationships = newRelationshipFilter(EMPTY_FILTER, RelationshipDirection.UNDIRECTED);
/**
* Any source and destination type value.
*/
protected static @Nullable String anyType = null;
@Test
public void testStaticUrns() {
assertNotNull(datasetOneUrn);
assertNotNull(datasetTwoUrn);
assertNotNull(datasetThreeUrn);
assertNotNull(datasetFourUrn);
assertNotNull(userOneUrn);
assertNotNull(userTwoUrn);
}
/**
* Provides the current GraphService instance to test. This is being called by the test method
* at most once. The serviced graph should be empty.
*
* @return the GraphService instance to test
* @throws Exception on failure
*/
@Nonnull
abstract protected GraphService getGraphService() throws Exception;
/**
* Allows the specific GraphService test implementation to wait for GraphService writes to
* be synced / become available to reads.
*
* @throws Exception on failure
*/
abstract protected void syncAfterWrite() throws Exception;
/**
* Calls getGraphService to retrieve the test GraphService and populates it
* with edges via `GraphService.addEdge`.
*
* @return test GraphService
* @throws Exception on failure
*/
protected GraphService getPopulatedGraphService() throws Exception {
GraphService service = getGraphService();
List<Edge> edges = Arrays.asList(
new Edge(datasetTwoUrn, datasetOneUrn, downstreamOf),
new Edge(datasetThreeUrn, datasetTwoUrn, downstreamOf),
new Edge(datasetFourUrn, datasetTwoUrn, downstreamOf),
new Edge(datasetOneUrn, userOneUrn, hasOwner),
new Edge(datasetTwoUrn, userOneUrn, hasOwner),
new Edge(datasetThreeUrn, userTwoUrn, hasOwner),
new Edge(datasetFourUrn, userTwoUrn, hasOwner),
new Edge(userOneUrn, userTwoUrn, knowsUser),
new Edge(userTwoUrn, userOneUrn, knowsUser)
);
edges.forEach(service::addEdge);
syncAfterWrite();
return service;
}
protected static @Nullable
Urn createFromString(@Nonnull String rawUrn) {
try {
return Urn.createFromString(rawUrn);
} catch (URISyntaxException e) {
return null;
}
}
protected void assertEqualsAnyOrder(RelatedEntitiesResult actual, List<RelatedEntity> expected) {
assertEqualsAnyOrder(actual, new RelatedEntitiesResult(0, expected.size(), expected.size(), expected));
}
protected void assertEqualsAnyOrder(RelatedEntitiesResult actual, RelatedEntitiesResult expected) {
assertEquals(actual.start, expected.start);
assertEquals(actual.count, expected.count);
assertEquals(actual.total, expected.total);
assertEqualsAnyOrder(actual.entities, expected.entities, RELATED_ENTITY_COMPARATOR);
}
protected <T> void assertEqualsAnyOrder(List<T> actual, List<T> expected) {
assertEquals(
actual.stream().sorted().collect(Collectors.toList()),
expected.stream().sorted().collect(Collectors.toList())
);
}
protected <T> void assertEqualsAnyOrder(List<T> actual, List<T> expected, Comparator<T> comparator) {
assertEquals(
actual.stream().sorted(comparator).collect(Collectors.toList()),
expected.stream().sorted(comparator).collect(Collectors.toList())
);
}
@DataProvider(name = "AddEdgeTests")
public Object[][] getAddEdgeTests() {
return new Object[][]{
new Object[]{
Arrays.asList(),
Arrays.asList(),
Arrays.asList()
},
new Object[]{
Arrays.asList(new Edge(datasetOneUrn, datasetTwoUrn, downstreamOf)),
Arrays.asList(downstreamOfDatasetTwoRelatedEntity),
Arrays.asList(downstreamOfDatasetOneRelatedEntity)
},
new Object[]{
Arrays.asList(
new Edge(datasetOneUrn, datasetTwoUrn, downstreamOf),
new Edge(datasetTwoUrn, datasetThreeUrn, downstreamOf)
),
Arrays.asList(downstreamOfDatasetTwoRelatedEntity, downstreamOfDatasetThreeRelatedEntity),
Arrays.asList(downstreamOfDatasetOneRelatedEntity, downstreamOfDatasetTwoRelatedEntity)
},
new Object[]{
Arrays.asList(
new Edge(datasetOneUrn, datasetTwoUrn, downstreamOf),
new Edge(datasetOneUrn, userOneUrn, hasOwner),
new Edge(datasetTwoUrn, userTwoUrn, hasOwner),
new Edge(userOneUrn, userTwoUrn, knowsUser)
),
Arrays.asList(
downstreamOfDatasetTwoRelatedEntity,
hasOwnerUserOneRelatedEntity, hasOwnerUserTwoRelatedEntity,
knowsUserTwoRelatedEntity
),
Arrays.asList(
downstreamOfDatasetOneRelatedEntity,
hasOwnerDatasetOneRelatedEntity,
hasOwnerDatasetTwoRelatedEntity,
knowsUserOneRelatedEntity
)
},
new Object[]{
Arrays.asList(
new Edge(userOneUrn, userOneUrn, knowsUser),
new Edge(userOneUrn, userOneUrn, knowsUser),
new Edge(userOneUrn, userOneUrn, knowsUser)
),
Arrays.asList(knowsUserOneRelatedEntity),
Arrays.asList(knowsUserOneRelatedEntity)
}
};
}
@Test(dataProvider = "AddEdgeTests")
public void testAddEdge(List<Edge> edges, List<RelatedEntity> expectedOutgoing, List<RelatedEntity> expectedIncoming) throws Exception {
GraphService service = getGraphService();
edges.forEach(service::addEdge);
syncAfterWrite();
RelatedEntitiesResult relatedOutgoing = service.findRelatedEntities(
anyType, EMPTY_FILTER,
anyType, EMPTY_FILTER,
Arrays.asList(downstreamOf, hasOwner, knowsUser),
outgoingRelationships,
0, 100
);
assertEqualsAnyOrder(relatedOutgoing, expectedOutgoing);
RelatedEntitiesResult relatedIncoming = service.findRelatedEntities(
anyType, EMPTY_FILTER,
anyType, EMPTY_FILTER,
Arrays.asList(downstreamOf, hasOwner, knowsUser),
incomingRelationships,
0, 100
);
assertEqualsAnyOrder(relatedIncoming, expectedIncoming);
}
@Test
public void testPopulatedGraphService() throws Exception {
GraphService service = getPopulatedGraphService();
RelatedEntitiesResult relatedOutgoingEntitiesBeforeRemove = service.findRelatedEntities(
anyType, EMPTY_FILTER,
anyType, EMPTY_FILTER,
Arrays.asList(downstreamOf, hasOwner, knowsUser), outgoingRelationships,
0, 100);
assertEqualsAnyOrder(
relatedOutgoingEntitiesBeforeRemove,
Arrays.asList(
downstreamOfDatasetOneRelatedEntity, downstreamOfDatasetTwoRelatedEntity,
hasOwnerUserOneRelatedEntity, hasOwnerUserTwoRelatedEntity,
knowsUserOneRelatedEntity, knowsUserTwoRelatedEntity
)
);
RelatedEntitiesResult relatedIncomingEntitiesBeforeRemove = service.findRelatedEntities(
anyType, EMPTY_FILTER,
anyType, EMPTY_FILTER,
Arrays.asList(downstreamOf, hasOwner, knowsUser), incomingRelationships,
0, 100);
assertEqualsAnyOrder(
relatedIncomingEntitiesBeforeRemove,
Arrays.asList(
downstreamOfDatasetTwoRelatedEntity, downstreamOfDatasetThreeRelatedEntity, downstreamOfDatasetFourRelatedEntity,
hasOwnerDatasetOneRelatedEntity, hasOwnerDatasetTwoRelatedEntity, hasOwnerDatasetThreeRelatedEntity, hasOwnerDatasetFourRelatedEntity,
knowsUserOneRelatedEntity, knowsUserTwoRelatedEntity
)
);
}
@DataProvider(name = "FindRelatedEntitiesSourceEntityFilterTests")
public Object[][] getFindRelatedEntitiesSourceEntityFilterTests() {
return new Object[][] {
new Object[] {
newFilter("urn", datasetTwoUrnString),
Arrays.asList(downstreamOf),
outgoingRelationships,
Arrays.asList(downstreamOfDatasetOneRelatedEntity)
},
new Object[] {
newFilter("urn", datasetTwoUrnString),
Arrays.asList(downstreamOf),
incomingRelationships,
Arrays.asList(downstreamOfDatasetThreeRelatedEntity, downstreamOfDatasetFourRelatedEntity)
},
new Object[] {
newFilter("urn", datasetTwoUrnString),
Arrays.asList(downstreamOf),
undirectedRelationships,
Arrays.asList(downstreamOfDatasetOneRelatedEntity, downstreamOfDatasetThreeRelatedEntity, downstreamOfDatasetFourRelatedEntity)
},
new Object[] {
newFilter("urn", datasetTwoUrnString),
Arrays.asList(hasOwner),
outgoingRelationships,
Arrays.asList(hasOwnerUserOneRelatedEntity)
},
new Object[] {
newFilter("urn", datasetTwoUrnString),
Arrays.asList(hasOwner),
incomingRelationships,
Arrays.asList()
},
new Object[] {
newFilter("urn", datasetTwoUrnString),
Arrays.asList(hasOwner),
undirectedRelationships,
Arrays.asList(hasOwnerUserOneRelatedEntity)
},
new Object[] {
newFilter("urn", userOneUrnString),
Arrays.asList(hasOwner),
outgoingRelationships,
Arrays.asList()
},
new Object[] {
newFilter("urn", userOneUrnString),
Arrays.asList(hasOwner),
incomingRelationships,
Arrays.asList(hasOwnerDatasetOneRelatedEntity, hasOwnerDatasetTwoRelatedEntity)
},
new Object[] {
newFilter("urn", userOneUrnString),
Arrays.asList(hasOwner),
undirectedRelationships,
Arrays.asList(hasOwnerDatasetOneRelatedEntity, hasOwnerDatasetTwoRelatedEntity)
}
};
}
@Test(dataProvider = "FindRelatedEntitiesSourceEntityFilterTests")
public void testFindRelatedEntitiesSourceEntityFilter(Filter sourceEntityFilter,
List<String> relationshipTypes,
RelationshipFilter relationships,
List<RelatedEntity> expectedRelatedEntities) throws Exception {
doTestFindRelatedEntities(
sourceEntityFilter,
EMPTY_FILTER,
relationshipTypes,
relationships,
expectedRelatedEntities
);
}
@DataProvider(name = "FindRelatedEntitiesDestinationEntityFilterTests")
public Object[][] getFindRelatedEntitiesDestinationEntityFilterTests() {
return new Object[][] {
new Object[] {
newFilter("urn", datasetTwoUrnString),
Arrays.asList(downstreamOf),
outgoingRelationships,
Arrays.asList(downstreamOfDatasetTwoRelatedEntity)
},
new Object[] {
newFilter("urn", datasetTwoUrnString),
Arrays.asList(downstreamOf),
incomingRelationships,
Arrays.asList(downstreamOfDatasetTwoRelatedEntity)
},
new Object[] {
newFilter("urn", datasetTwoUrnString),
Arrays.asList(downstreamOf),
undirectedRelationships,
Arrays.asList(downstreamOfDatasetTwoRelatedEntity)
},
new Object[] {
newFilter("urn", userOneUrnString),
Arrays.asList(downstreamOf),
outgoingRelationships,
Arrays.asList()
},
new Object[] {
newFilter("urn", userOneUrnString),
Arrays.asList(downstreamOf),
incomingRelationships,
Arrays.asList()
},
new Object[] {
newFilter("urn", userOneUrnString),
Arrays.asList(downstreamOf),
undirectedRelationships,
Arrays.asList()
},
new Object[] {
newFilter("urn", userOneUrnString),
Arrays.asList(hasOwner),
outgoingRelationships,
Arrays.asList(hasOwnerUserOneRelatedEntity)
},
new Object[] {
newFilter("urn", userOneUrnString),
Arrays.asList(hasOwner),
incomingRelationships,
Arrays.asList()
},
new Object[] {
newFilter("urn", userOneUrnString),
Arrays.asList(hasOwner),
undirectedRelationships,
Arrays.asList(hasOwnerUserOneRelatedEntity)
}
};
}
@Test(dataProvider = "FindRelatedEntitiesDestinationEntityFilterTests")
public void testFindRelatedEntitiesDestinationEntityFilter(Filter destinationEntityFilter,
List<String> relationshipTypes,
RelationshipFilter relationships,
List<RelatedEntity> expectedRelatedEntities) throws Exception {
doTestFindRelatedEntities(
EMPTY_FILTER,
destinationEntityFilter,
relationshipTypes,
relationships,
expectedRelatedEntities
);
}
private void doTestFindRelatedEntities(
final Filter sourceEntityFilter,
final Filter destinationEntityFilter,
List<String> relationshipTypes,
final RelationshipFilter relationshipFilter,
List<RelatedEntity> expectedRelatedEntities
) throws Exception {
GraphService service = getPopulatedGraphService();
RelatedEntitiesResult relatedEntities = service.findRelatedEntities(
anyType, sourceEntityFilter,
anyType, destinationEntityFilter,
relationshipTypes, relationshipFilter,
0, 10
);
assertEqualsAnyOrder(relatedEntities, expectedRelatedEntities);
}
@DataProvider(name = "FindRelatedEntitiesSourceTypeTests")
public Object[][] getFindRelatedEntitiesSourceTypeTests() {
return new Object[][]{
new Object[] {
null,
Arrays.asList(downstreamOf),
outgoingRelationships,
Arrays.asList(downstreamOfDatasetOneRelatedEntity, downstreamOfDatasetTwoRelatedEntity)
},
new Object[] {
null,
Arrays.asList(downstreamOf),
incomingRelationships,
Arrays.asList(downstreamOfDatasetTwoRelatedEntity, downstreamOfDatasetThreeRelatedEntity, downstreamOfDatasetFourRelatedEntity)
},
new Object[] {
null,
Arrays.asList(downstreamOf),
undirectedRelationships,
Arrays.asList(
downstreamOfDatasetOneRelatedEntity, downstreamOfDatasetTwoRelatedEntity,
downstreamOfDatasetThreeRelatedEntity, downstreamOfDatasetFourRelatedEntity
)
},
// "" used to be any type before v0.9.0, which is now encoded by null
new Object[] {
"",
Arrays.asList(downstreamOf),
outgoingRelationships,
Collections.emptyList()
},
new Object[] {
"",
Arrays.asList(downstreamOf),
incomingRelationships,
Collections.emptyList()
},
new Object[] {
"",
Arrays.asList(downstreamOf),
undirectedRelationships,
Collections.emptyList()
},
new Object[]{
datasetType,
Arrays.asList(downstreamOf),
outgoingRelationships,
Arrays.asList(downstreamOfDatasetOneRelatedEntity, downstreamOfDatasetTwoRelatedEntity)
},
new Object[]{
datasetType,
Arrays.asList(downstreamOf),
incomingRelationships,
Arrays.asList(downstreamOfDatasetTwoRelatedEntity, downstreamOfDatasetThreeRelatedEntity, downstreamOfDatasetFourRelatedEntity)
},
new Object[]{
datasetType,
Arrays.asList(downstreamOf),
undirectedRelationships,
Arrays.asList(
downstreamOfDatasetOneRelatedEntity, downstreamOfDatasetTwoRelatedEntity,
downstreamOfDatasetThreeRelatedEntity, downstreamOfDatasetFourRelatedEntity
)
},
new Object[]{
userType,
Arrays.asList(downstreamOf),
outgoingRelationships,
Arrays.asList()
},
new Object[]{
userType,
Arrays.asList(downstreamOf),
incomingRelationships,
Arrays.asList()
},
new Object[]{
userType,
Arrays.asList(downstreamOf),
undirectedRelationships,
Arrays.asList()
},
new Object[]{
userType,
Arrays.asList(hasOwner),
outgoingRelationships,
Arrays.asList()
},
new Object[]{
userType,
Arrays.asList(hasOwner),
incomingRelationships,
Arrays.asList(
hasOwnerDatasetOneRelatedEntity, hasOwnerDatasetTwoRelatedEntity,
hasOwnerDatasetThreeRelatedEntity, hasOwnerDatasetFourRelatedEntity
)
},
new Object[]{
userType,
Arrays.asList(hasOwner),
undirectedRelationships,
Arrays.asList(
hasOwnerDatasetOneRelatedEntity, hasOwnerDatasetTwoRelatedEntity,
hasOwnerDatasetThreeRelatedEntity, hasOwnerDatasetFourRelatedEntity
)
}
};
}
@Test(dataProvider = "FindRelatedEntitiesSourceTypeTests")
public void testFindRelatedEntitiesSourceType(String datasetType,
List<String> relationshipTypes,
RelationshipFilter relationships,
List<RelatedEntity> expectedRelatedEntities) throws Exception {
doTestFindRelatedEntities(
datasetType,
anyType,
relationshipTypes,
relationships,
expectedRelatedEntities
);
}
@DataProvider(name = "FindRelatedEntitiesDestinationTypeTests")
public Object[][] getFindRelatedEntitiesDestinationTypeTests() {
return new Object[][] {
new Object[] {
null,
Arrays.asList(downstreamOf),
outgoingRelationships,
Arrays.asList(downstreamOfDatasetOneRelatedEntity, downstreamOfDatasetTwoRelatedEntity)
},
new Object[] {
null,
Arrays.asList(downstreamOf),
incomingRelationships,
Arrays.asList(downstreamOfDatasetTwoRelatedEntity, downstreamOfDatasetThreeRelatedEntity, downstreamOfDatasetFourRelatedEntity)
},
new Object[] {
null,
Arrays.asList(downstreamOf),
undirectedRelationships,
Arrays.asList(
downstreamOfDatasetOneRelatedEntity, downstreamOfDatasetTwoRelatedEntity,
downstreamOfDatasetThreeRelatedEntity, downstreamOfDatasetFourRelatedEntity
)
},
new Object[] {
"",
Arrays.asList(downstreamOf),
outgoingRelationships,
Collections.emptyList()
},
new Object[] {
"",
Arrays.asList(downstreamOf),
incomingRelationships,
Collections.emptyList()
},
new Object[] {
"",
Arrays.asList(downstreamOf),
undirectedRelationships,
Collections.emptyList()
},
new Object[] {
datasetType,
Arrays.asList(downstreamOf),
outgoingRelationships,
Arrays.asList(downstreamOfDatasetOneRelatedEntity, downstreamOfDatasetTwoRelatedEntity)
},
new Object[] {
datasetType,
Arrays.asList(downstreamOf),
incomingRelationships,
Arrays.asList(downstreamOfDatasetTwoRelatedEntity, downstreamOfDatasetThreeRelatedEntity, downstreamOfDatasetFourRelatedEntity)
},
new Object[] {
datasetType,
Arrays.asList(downstreamOf),
undirectedRelationships,
Arrays.asList(
downstreamOfDatasetOneRelatedEntity, downstreamOfDatasetTwoRelatedEntity,
downstreamOfDatasetThreeRelatedEntity, downstreamOfDatasetFourRelatedEntity
)
},
new Object[] {
datasetType,
Arrays.asList(hasOwner),
outgoingRelationships,
Arrays.asList()
},
new Object[] {
datasetType,
Arrays.asList(hasOwner),
incomingRelationships,
Arrays.asList(
hasOwnerDatasetOneRelatedEntity, hasOwnerDatasetTwoRelatedEntity,
hasOwnerDatasetThreeRelatedEntity, hasOwnerDatasetFourRelatedEntity
)
},
new Object[] {
datasetType,
Arrays.asList(hasOwner),
undirectedRelationships,
Arrays.asList(
hasOwnerDatasetOneRelatedEntity, hasOwnerDatasetTwoRelatedEntity,
hasOwnerDatasetThreeRelatedEntity, hasOwnerDatasetFourRelatedEntity
)
},
new Object[] {
userType,
Arrays.asList(hasOwner),
outgoingRelationships,
Arrays.asList(hasOwnerUserOneRelatedEntity, hasOwnerUserTwoRelatedEntity)
},
new Object[] {
userType,
Arrays.asList(hasOwner),
incomingRelationships,
Arrays.asList()
},
new Object[] {
userType,
Arrays.asList(hasOwner),
undirectedRelationships,
Arrays.asList(hasOwnerUserOneRelatedEntity, hasOwnerUserTwoRelatedEntity)
}
};
}
@Test(dataProvider = "FindRelatedEntitiesDestinationTypeTests")
public void testFindRelatedEntitiesDestinationType(String datasetType,
List<String> relationshipTypes,
RelationshipFilter relationships,
List<RelatedEntity> expectedRelatedEntities) throws Exception {
doTestFindRelatedEntities(
anyType,
datasetType,
relationshipTypes,
relationships,
expectedRelatedEntities
);
}
private void doTestFindRelatedEntities(
final String sourceType,
final String destinationType,
final List<String> relationshipTypes,
final RelationshipFilter relationshipFilter,
List<RelatedEntity> expectedRelatedEntities
) throws Exception {
GraphService service = getPopulatedGraphService();
RelatedEntitiesResult relatedEntities = service.findRelatedEntities(
sourceType, EMPTY_FILTER,
destinationType, EMPTY_FILTER,
relationshipTypes, relationshipFilter,
0, 10
);
assertEqualsAnyOrder(relatedEntities, expectedRelatedEntities);
}
private void doTestFindRelatedEntitiesEntityType(@Nullable String sourceType,
@Nullable String destinationType,
@Nonnull String relationshipType,
@Nonnull RelationshipFilter relationshipFilter,
@Nonnull GraphService service,
@Nonnull RelatedEntity... expectedEntities) {
RelatedEntitiesResult actualEntities = service.findRelatedEntities(
sourceType, EMPTY_FILTER,
destinationType, EMPTY_FILTER,
Arrays.asList(relationshipType), relationshipFilter,
0, 100
);
assertEqualsAnyOrder(actualEntities, Arrays.asList(expectedEntities));
}
@Test
public void testFindRelatedEntitiesNullSourceType() throws Exception {
GraphService service = getGraphService();
Urn nullUrn = createFromString("urn:li:null:(urn:li:null:Null)");
assertNotNull(nullUrn);
RelatedEntity nullRelatedEntity = new RelatedEntity(downstreamOf, nullUrn.toString());
doTestFindRelatedEntitiesEntityType(anyType, "null", downstreamOf, outgoingRelationships, service);
doTestFindRelatedEntitiesEntityType(anyType, null, downstreamOf, outgoingRelationships, service);
service.addEdge(new Edge(datasetTwoUrn, datasetOneUrn, downstreamOf));
syncAfterWrite();
doTestFindRelatedEntitiesEntityType(anyType, "null", downstreamOf, outgoingRelationships, service);
doTestFindRelatedEntitiesEntityType(anyType, null, downstreamOf, outgoingRelationships, service, downstreamOfDatasetOneRelatedEntity);
service.addEdge(new Edge(datasetOneUrn, nullUrn, downstreamOf));
syncAfterWrite();
doTestFindRelatedEntitiesEntityType(anyType, "null", downstreamOf, outgoingRelationships, service, nullRelatedEntity);
doTestFindRelatedEntitiesEntityType(anyType, null, downstreamOf, outgoingRelationships, service, nullRelatedEntity, downstreamOfDatasetOneRelatedEntity);
}
@Test
public void testFindRelatedEntitiesNullDestinationType() throws Exception {
GraphService service = getGraphService();
Urn nullUrn = createFromString("urn:li:null:(urn:li:null:Null)");
assertNotNull(nullUrn);
RelatedEntity nullRelatedEntity = new RelatedEntity(downstreamOf, nullUrn.toString());
doTestFindRelatedEntitiesEntityType(anyType, "null", downstreamOf, outgoingRelationships, service);
doTestFindRelatedEntitiesEntityType(anyType, null, downstreamOf, outgoingRelationships, service);
service.addEdge(new Edge(datasetTwoUrn, datasetOneUrn, downstreamOf));
syncAfterWrite();
doTestFindRelatedEntitiesEntityType(anyType, "null", downstreamOf, outgoingRelationships, service);
doTestFindRelatedEntitiesEntityType(anyType, null, downstreamOf, outgoingRelationships, service, downstreamOfDatasetOneRelatedEntity);
service.addEdge(new Edge(datasetOneUrn, nullUrn, downstreamOf));
syncAfterWrite();
doTestFindRelatedEntitiesEntityType(anyType, "null", downstreamOf, outgoingRelationships, service, nullRelatedEntity);
doTestFindRelatedEntitiesEntityType(anyType, null, downstreamOf, outgoingRelationships, service, nullRelatedEntity, downstreamOfDatasetOneRelatedEntity);
}
@Test
public void testFindRelatedEntitiesRelationshipTypes() throws Exception {
GraphService service = getPopulatedGraphService();
RelatedEntitiesResult allOutgoingRelatedEntities = service.findRelatedEntities(
anyType, EMPTY_FILTER,
anyType, EMPTY_FILTER,
Arrays.asList(downstreamOf, hasOwner, knowsUser), outgoingRelationships,
0, 100
);
assertEqualsAnyOrder(
allOutgoingRelatedEntities,
Arrays.asList(
downstreamOfDatasetOneRelatedEntity, downstreamOfDatasetTwoRelatedEntity,
hasOwnerUserOneRelatedEntity, hasOwnerUserTwoRelatedEntity,
knowsUserOneRelatedEntity, knowsUserTwoRelatedEntity
)
);
RelatedEntitiesResult allIncomingRelatedEntities = service.findRelatedEntities(
anyType, EMPTY_FILTER,
anyType, EMPTY_FILTER,
Arrays.asList(downstreamOf, hasOwner, knowsUser), incomingRelationships,
0, 100
);
assertEqualsAnyOrder(
allIncomingRelatedEntities,
Arrays.asList(
downstreamOfDatasetTwoRelatedEntity, downstreamOfDatasetThreeRelatedEntity, downstreamOfDatasetFourRelatedEntity,
hasOwnerDatasetOneRelatedEntity, hasOwnerDatasetTwoRelatedEntity, hasOwnerDatasetThreeRelatedEntity, hasOwnerDatasetFourRelatedEntity,
knowsUserOneRelatedEntity, knowsUserTwoRelatedEntity
)
);
RelatedEntitiesResult allUnknownRelationshipTypeRelatedEntities = service.findRelatedEntities(
anyType, EMPTY_FILTER,
anyType, EMPTY_FILTER,
Arrays.asList("unknownRelationshipType", "unseenRelationshipType"), outgoingRelationships,
0, 100
);
assertEqualsAnyOrder(
allUnknownRelationshipTypeRelatedEntities,
Collections.emptyList()
);
RelatedEntitiesResult someUnknownRelationshipTypeRelatedEntities = service.findRelatedEntities(
anyType, EMPTY_FILTER,
anyType, EMPTY_FILTER,
Arrays.asList("unknownRelationshipType", downstreamOf), outgoingRelationships,
0, 100
);
assertEqualsAnyOrder(
someUnknownRelationshipTypeRelatedEntities,
Arrays.asList(downstreamOfDatasetOneRelatedEntity, downstreamOfDatasetTwoRelatedEntity)
);
}
@Test
public void testFindRelatedEntitiesNoRelationshipTypes() throws Exception {
GraphService service = getPopulatedGraphService();
RelatedEntitiesResult relatedEntities = service.findRelatedEntities(
anyType, EMPTY_FILTER,
anyType, EMPTY_FILTER,
Collections.emptyList(), outgoingRelationships,
0, 10
);
assertEquals(relatedEntities.entities, Collections.emptyList());
// does the test actually test something? is the Collections.emptyList() the only reason why we did not get any related urns?
RelatedEntitiesResult relatedEntitiesAll = service.findRelatedEntities(
anyType, EMPTY_FILTER,
anyType, EMPTY_FILTER,
Arrays.asList(downstreamOf, hasOwner, knowsUser), outgoingRelationships,
0, 10
);
assertNotEquals(relatedEntitiesAll.entities, Collections.emptyList());
}
@Test
public void testFindRelatedEntitiesAllFilters() throws Exception {
GraphService service = getPopulatedGraphService();
RelatedEntitiesResult relatedEntities = service.findRelatedEntities(
datasetType, newFilter("urn", datasetOneUrnString),
userType, newFilter("urn", userOneUrnString),
Arrays.asList(hasOwner), outgoingRelationships,
0, 10
);
assertEquals(relatedEntities.entities, Arrays.asList(hasOwnerUserOneRelatedEntity));
relatedEntities = service.findRelatedEntities(
datasetType, newFilter("urn", datasetOneUrnString),
userType, newFilter("urn", userTwoUrnString),
Arrays.asList(hasOwner), incomingRelationships,
0, 10
);
assertEquals(relatedEntities.entities, Collections.emptyList());
}
@Test
public void testFindRelatedEntitiesOffsetAndCount() throws Exception {
GraphService service = getPopulatedGraphService();
// populated graph asserted in testPopulatedGraphService
RelatedEntitiesResult allRelatedEntities = service.findRelatedEntities(
datasetType, EMPTY_FILTER,
anyType, EMPTY_FILTER,
Arrays.asList(downstreamOf, hasOwner, knowsUser), outgoingRelationships,
0, 100
);
List<RelatedEntity> individualRelatedEntities = new ArrayList<>();
IntStream.range(0, allRelatedEntities.entities.size())
.forEach(idx -> individualRelatedEntities.addAll(
service.findRelatedEntities(
datasetType, EMPTY_FILTER,
anyType, EMPTY_FILTER,
Arrays.asList(downstreamOf, hasOwner, knowsUser), outgoingRelationships,
idx, 1
).entities
));
Assert.assertEquals(individualRelatedEntities, allRelatedEntities.entities);
}
@DataProvider(name = "RemoveEdgesFromNodeTests")
public Object[][] getRemoveEdgesFromNodeTests() {
return new Object[][] {
new Object[] {
datasetTwoUrn,
Arrays.asList(downstreamOf),
outgoingRelationships,
Arrays.asList(downstreamOfDatasetOneRelatedEntity),
Arrays.asList(downstreamOfDatasetThreeRelatedEntity, downstreamOfDatasetFourRelatedEntity),
Arrays.asList(),
Arrays.asList(downstreamOfDatasetThreeRelatedEntity, downstreamOfDatasetFourRelatedEntity)
},
new Object[] {
datasetTwoUrn,
Arrays.asList(downstreamOf),
incomingRelationships,
Arrays.asList(downstreamOfDatasetOneRelatedEntity),
Arrays.asList(downstreamOfDatasetThreeRelatedEntity, downstreamOfDatasetFourRelatedEntity),
Arrays.asList(downstreamOfDatasetOneRelatedEntity),
Arrays.asList(),
},
new Object[] {
datasetTwoUrn,
Arrays.asList(downstreamOf),
undirectedRelationships,
Arrays.asList(downstreamOfDatasetOneRelatedEntity),
Arrays.asList(downstreamOfDatasetThreeRelatedEntity, downstreamOfDatasetFourRelatedEntity),
Arrays.asList(),
Arrays.asList()
},
new Object[] {
userOneUrn,
Arrays.asList(hasOwner, knowsUser),
outgoingRelationships,
Arrays.asList(knowsUserTwoRelatedEntity),
Arrays.asList(hasOwnerDatasetOneRelatedEntity, hasOwnerDatasetTwoRelatedEntity, knowsUserTwoRelatedEntity),
Arrays.asList(),
Arrays.asList(hasOwnerDatasetOneRelatedEntity, hasOwnerDatasetTwoRelatedEntity, knowsUserTwoRelatedEntity)
},
new Object[] {
userOneUrn,
Arrays.asList(hasOwner, knowsUser),
incomingRelationships,
Arrays.asList(knowsUserTwoRelatedEntity),
Arrays.asList(hasOwnerDatasetOneRelatedEntity, hasOwnerDatasetTwoRelatedEntity, knowsUserTwoRelatedEntity),
Arrays.asList(knowsUserTwoRelatedEntity),
Arrays.asList()
},
new Object[] {
userOneUrn,
Arrays.asList(hasOwner, knowsUser),
undirectedRelationships,
Arrays.asList(knowsUserTwoRelatedEntity),
Arrays.asList(hasOwnerDatasetOneRelatedEntity, hasOwnerDatasetTwoRelatedEntity, knowsUserTwoRelatedEntity),
Arrays.asList(),
Arrays.asList()
}
};
}
@Test(dataProvider = "RemoveEdgesFromNodeTests")
public void testRemoveEdgesFromNode(@Nonnull Urn nodeToRemoveFrom,
@Nonnull List<String> relationTypes,
@Nonnull RelationshipFilter relationshipFilter,
List<RelatedEntity> expectedOutgoingRelatedUrnsBeforeRemove,
List<RelatedEntity> expectedIncomingRelatedUrnsBeforeRemove,
List<RelatedEntity> expectedOutgoingRelatedUrnsAfterRemove,
List<RelatedEntity> expectedIncomingRelatedUrnsAfterRemove) throws Exception {
GraphService service = getPopulatedGraphService();
List<String> allOtherRelationTypes =
allRelationshipTypes.stream()
.filter(relation -> !relationTypes.contains(relation))
.collect(Collectors.toList());
assertTrue(allOtherRelationTypes.size() > 0);
RelatedEntitiesResult actualOutgoingRelatedUrnsBeforeRemove = service.findRelatedEntities(
anyType, newFilter("urn", nodeToRemoveFrom.toString()),
anyType, EMPTY_FILTER,
relationTypes, outgoingRelationships,
0, 100);
RelatedEntitiesResult actualIncomingRelatedUrnsBeforeRemove = service.findRelatedEntities(
anyType, newFilter("urn", nodeToRemoveFrom.toString()),
anyType, EMPTY_FILTER,
relationTypes, incomingRelationships,
0, 100);
assertEqualsAnyOrder(actualOutgoingRelatedUrnsBeforeRemove, expectedOutgoingRelatedUrnsBeforeRemove);
assertEqualsAnyOrder(actualIncomingRelatedUrnsBeforeRemove, expectedIncomingRelatedUrnsBeforeRemove);
// we expect these do not change
RelatedEntitiesResult relatedEntitiesOfOtherOutgoingRelationTypesBeforeRemove = service.findRelatedEntities(
anyType, newFilter("urn", nodeToRemoveFrom.toString()),
anyType, EMPTY_FILTER,
allOtherRelationTypes, outgoingRelationships,
0, 100);
RelatedEntitiesResult relatedEntitiesOfOtherIncomingRelationTypesBeforeRemove = service.findRelatedEntities(
anyType, newFilter("urn", nodeToRemoveFrom.toString()),
anyType, EMPTY_FILTER,
allOtherRelationTypes, incomingRelationships,
0, 100);
service.removeEdgesFromNode(
nodeToRemoveFrom,
relationTypes,
relationshipFilter
);
syncAfterWrite();
RelatedEntitiesResult actualOutgoingRelatedUrnsAfterRemove = service.findRelatedEntities(
anyType, newFilter("urn", nodeToRemoveFrom.toString()),
anyType, EMPTY_FILTER,
relationTypes, outgoingRelationships,
0, 100);
RelatedEntitiesResult actualIncomingRelatedUrnsAfterRemove = service.findRelatedEntities(
anyType, newFilter("urn", nodeToRemoveFrom.toString()),
anyType, EMPTY_FILTER,
relationTypes, incomingRelationships,
0, 100);
assertEqualsAnyOrder(actualOutgoingRelatedUrnsAfterRemove, expectedOutgoingRelatedUrnsAfterRemove);
assertEqualsAnyOrder(actualIncomingRelatedUrnsAfterRemove, expectedIncomingRelatedUrnsAfterRemove);
// assert these did not change
RelatedEntitiesResult relatedEntitiesOfOtherOutgoingRelationTypesAfterRemove = service.findRelatedEntities(
anyType, newFilter("urn", nodeToRemoveFrom.toString()),
anyType, EMPTY_FILTER,
allOtherRelationTypes, outgoingRelationships,
0, 100);
RelatedEntitiesResult relatedEntitiesOfOtherIncomingRelationTypesAfterRemove = service.findRelatedEntities(
anyType, newFilter("urn", nodeToRemoveFrom.toString()),
anyType, EMPTY_FILTER,
allOtherRelationTypes, incomingRelationships,
0, 100);
assertEqualsAnyOrder(relatedEntitiesOfOtherOutgoingRelationTypesAfterRemove, relatedEntitiesOfOtherOutgoingRelationTypesBeforeRemove);
assertEqualsAnyOrder(relatedEntitiesOfOtherIncomingRelationTypesAfterRemove, relatedEntitiesOfOtherIncomingRelationTypesBeforeRemove);
}
@Test
public void testRemoveEdgesFromNodeNoRelationshipTypes() throws Exception {
GraphService service = getPopulatedGraphService();
Urn nodeToRemoveFrom = datasetOneUrn;
// populated graph asserted in testPopulatedGraphService
RelatedEntitiesResult relatedOutgoingEntitiesBeforeRemove = service.findRelatedEntities(
anyType, newFilter("urn", nodeToRemoveFrom.toString()),
anyType, EMPTY_FILTER,
Arrays.asList(downstreamOf, hasOwner, knowsUser), outgoingRelationships,
0, 100);
// can be replaced with a single removeEdgesFromNode and undirectedRelationships once supported by all implementations
service.removeEdgesFromNode(
nodeToRemoveFrom,
Collections.emptyList(),
outgoingRelationships
);
service.removeEdgesFromNode(
nodeToRemoveFrom,
Collections.emptyList(),
incomingRelationships
);
syncAfterWrite();
RelatedEntitiesResult relatedOutgoingEntitiesAfterRemove = service.findRelatedEntities(
anyType, newFilter("urn", nodeToRemoveFrom.toString()),
anyType, EMPTY_FILTER,
Arrays.asList(downstreamOf, hasOwner, knowsUser), outgoingRelationships,
0, 100);
assertEqualsAnyOrder(relatedOutgoingEntitiesAfterRemove, relatedOutgoingEntitiesBeforeRemove);
// does the test actually test something? is the Collections.emptyList() the only reason why we did not see changes?
service.removeEdgesFromNode(
nodeToRemoveFrom,
Arrays.asList(downstreamOf, hasOwner, knowsUser),
outgoingRelationships
);
service.removeEdgesFromNode(
nodeToRemoveFrom,
Arrays.asList(downstreamOf, hasOwner, knowsUser),
incomingRelationships
);
syncAfterWrite();
RelatedEntitiesResult relatedOutgoingEntitiesAfterRemoveAll = service.findRelatedEntities(
anyType, newFilter("urn", nodeToRemoveFrom.toString()),
anyType, EMPTY_FILTER,
Arrays.asList(downstreamOf, hasOwner, knowsUser), outgoingRelationships,
0, 100);
assertEqualsAnyOrder(relatedOutgoingEntitiesAfterRemoveAll, Collections.emptyList());
}
@Test
public void testRemoveEdgesFromUnknownNode() throws Exception {
GraphService service = getPopulatedGraphService();
Urn nodeToRemoveFrom = unknownUrn;
// populated graph asserted in testPopulatedGraphService
RelatedEntitiesResult relatedOutgoingEntitiesBeforeRemove = service.findRelatedEntities(
anyType, EMPTY_FILTER,
anyType, EMPTY_FILTER,
Arrays.asList(downstreamOf, hasOwner, knowsUser), outgoingRelationships,
0, 100);
// can be replaced with a single removeEdgesFromNode and undirectedRelationships once supported by all implementations
service.removeEdgesFromNode(
nodeToRemoveFrom,
Arrays.asList(downstreamOf, hasOwner, knowsUser),
outgoingRelationships
);
service.removeEdgesFromNode(
nodeToRemoveFrom,
Arrays.asList(downstreamOf, hasOwner, knowsUser),
incomingRelationships
);
syncAfterWrite();
RelatedEntitiesResult relatedOutgoingEntitiesAfterRemove = service.findRelatedEntities(
anyType, EMPTY_FILTER,
anyType, EMPTY_FILTER,
Arrays.asList(downstreamOf, hasOwner, knowsUser), outgoingRelationships,
0, 100);
assertEqualsAnyOrder(relatedOutgoingEntitiesAfterRemove, relatedOutgoingEntitiesBeforeRemove);
}
@Test
public void testRemoveNode() throws Exception {
GraphService service = getPopulatedGraphService();
service.removeNode(datasetTwoUrn);
syncAfterWrite();
// assert the modified graph
assertEqualsAnyOrder(
service.findRelatedEntities(
anyType, EMPTY_FILTER,
anyType, EMPTY_FILTER,
Arrays.asList(downstreamOf, hasOwner, knowsUser), outgoingRelationships,
0, 100
),
Arrays.asList(
hasOwnerUserOneRelatedEntity, hasOwnerUserTwoRelatedEntity,
knowsUserOneRelatedEntity, knowsUserTwoRelatedEntity
)
);
}
@Test
public void testRemoveUnknownNode() throws Exception {
GraphService service = getPopulatedGraphService();
// populated graph asserted in testPopulatedGraphService
RelatedEntitiesResult entitiesBeforeRemove = service.findRelatedEntities(
anyType, EMPTY_FILTER,
anyType, EMPTY_FILTER,
Arrays.asList(downstreamOf, hasOwner, knowsUser), outgoingRelationships,
0, 100);
service.removeNode(unknownUrn);
syncAfterWrite();
RelatedEntitiesResult entitiesAfterRemove = service.findRelatedEntities(
anyType, EMPTY_FILTER,
anyType, EMPTY_FILTER,
Arrays.asList(downstreamOf, hasOwner, knowsUser), outgoingRelationships,
0, 100);
assertEqualsAnyOrder(entitiesBeforeRemove, entitiesAfterRemove);
}
@Test
public void testClear() throws Exception {
GraphService service = getPopulatedGraphService();
// populated graph asserted in testPopulatedGraphService
service.clear();
syncAfterWrite();
// assert the modified graph: check all nodes related to upstreamOf and nextVersionOf edges again
assertEqualsAnyOrder(
service.findRelatedEntities(
datasetType, EMPTY_FILTER,
anyType, EMPTY_FILTER,
Arrays.asList(downstreamOf), outgoingRelationships,
0, 100
),
Collections.emptyList()
);
assertEqualsAnyOrder(
service.findRelatedEntities(
userType, EMPTY_FILTER,
anyType, EMPTY_FILTER,
Arrays.asList(hasOwner), outgoingRelationships,
0, 100
),
Collections.emptyList()
);
assertEqualsAnyOrder(
service.findRelatedEntities(
anyType, EMPTY_FILTER,
userType, EMPTY_FILTER,
Arrays.asList(knowsUser), outgoingRelationships,
0, 100
),
Collections.emptyList()
);
}
private List<Edge> getFullyConnectedGraph(int nodes, List<String> relationshipTypes) {
List<Edge> edges = new ArrayList<>();
for (int sourceNode = 1; sourceNode <= nodes; sourceNode++) {
for (int destinationNode = 1; destinationNode <= nodes; destinationNode++) {
for (String relationship : relationshipTypes) {
int sourceType = sourceNode % 3;
Urn source = createFromString("urn:li:type" + sourceType + ":(urn:li:node" + sourceNode + ")");
int destinationType = destinationNode % 3;
Urn destination = createFromString("urn:li:type" + destinationType + ":(urn:li:node" + destinationNode + ")");
edges.add(new Edge(source, destination, relationship));
}
}
}
return edges;
}
@Test
public void testConcurrentAddEdge() throws Exception {
final GraphService service = getGraphService();
// too many edges may cause too many threads throwing
// java.util.concurrent.RejectedExecutionException: Thread limit exceeded replacing blocked worker
int nodes = 5;
int relationshipTypes = 5;
List<String> allRelationships = IntStream.range(1, relationshipTypes + 1).mapToObj(id -> "relationship" + id).collect(Collectors.toList());
List<Edge> edges = getFullyConnectedGraph(nodes, allRelationships);
List<Runnable> operations = edges.stream().map(edge -> new Runnable() {
@Override
public void run() {
service.addEdge(edge);
}
}).collect(Collectors.toList());
doTestConcurrentOp(operations);
syncAfterWrite();
RelatedEntitiesResult relatedEntities = service.findRelatedEntities(
null, EMPTY_FILTER,
null, EMPTY_FILTER,
allRelationships, outgoingRelationships,
0, nodes * relationshipTypes * 2
);
Set<RelatedEntity> expectedRelatedEntities = edges.stream()
.map(edge -> new RelatedEntity(edge.getRelationshipType(), edge.getDestination().toString()))
.collect(Collectors.toSet());
assertEquals(new HashSet<>(relatedEntities.entities), expectedRelatedEntities);
}
@Test
public void testConcurrentRemoveEdgesFromNode() throws Exception {
final GraphService service = getGraphService();
int nodes = 10;
int relationshipTypes = 5;
List<String> allRelationships = IntStream.range(1, relationshipTypes + 1).mapToObj(id -> "relationship" + id).collect(Collectors.toList());
List<Edge> edges = getFullyConnectedGraph(nodes, allRelationships);
// add fully connected graph
edges.forEach(service::addEdge);
syncAfterWrite();
// assert the graph is there
RelatedEntitiesResult relatedEntities = service.findRelatedEntities(
null, EMPTY_FILTER,
null, EMPTY_FILTER,
allRelationships, outgoingRelationships,
0, nodes * relationshipTypes * 2
);
assertEquals(relatedEntities.entities.size(), nodes * relationshipTypes);
// delete all edges concurrently
List<Runnable> operations = edges.stream().map(edge -> new Runnable() {
@Override
public void run() {
service.removeEdgesFromNode(edge.getSource(), Arrays.asList(edge.getRelationshipType()), outgoingRelationships);
}
}).collect(Collectors.toList());
doTestConcurrentOp(operations);
syncAfterWrite();
// assert the graph is gone
RelatedEntitiesResult relatedEntitiesAfterDeletion = service.findRelatedEntities(
null, EMPTY_FILTER,
null, EMPTY_FILTER,
allRelationships, outgoingRelationships,
0, nodes * relationshipTypes * 2
);
assertEquals(relatedEntitiesAfterDeletion.entities.size(), 0);
}
@Test
public void testConcurrentRemoveNodes() throws Exception {
final GraphService service = getGraphService();
// too many edges may cause too many threads throwing
// java.util.concurrent.RejectedExecutionException: Thread limit exceeded replacing blocked worker
int nodes = 10;
int relationshipTypes = 5;
List<String> allRelationships = IntStream.range(1, relationshipTypes + 1).mapToObj(id -> "relationship" + id).collect(Collectors.toList());
List<Edge> edges = getFullyConnectedGraph(nodes, allRelationships);
// add fully connected graph
edges.forEach(service::addEdge);
syncAfterWrite();
// assert the graph is there
RelatedEntitiesResult relatedEntities = service.findRelatedEntities(
null, EMPTY_FILTER,
null, EMPTY_FILTER,
allRelationships, outgoingRelationships,
0, nodes * relationshipTypes * 2
);
assertEquals(relatedEntities.entities.size(), nodes * relationshipTypes);
// remove all nodes concurrently
// nodes will be removed multiple times
List<Runnable> operations = edges.stream().map(edge -> new Runnable() {
@Override
public void run() {
service.removeNode(edge.getSource());
}
}).collect(Collectors.toList());
doTestConcurrentOp(operations);
syncAfterWrite();
// assert the graph is gone
RelatedEntitiesResult relatedEntitiesAfterDeletion = service.findRelatedEntities(
null, EMPTY_FILTER,
null, EMPTY_FILTER,
allRelationships, outgoingRelationships,
0, nodes * relationshipTypes * 2
);
assertEquals(relatedEntitiesAfterDeletion.entities.size(), 0);
}
private void doTestConcurrentOp(List<Runnable> operations) throws Exception {
final Queue<Throwable> throwables = new ConcurrentLinkedQueue<>();
final CountDownLatch started = new CountDownLatch(operations.size());
final CountDownLatch finished = new CountDownLatch(operations.size());
operations.forEach(operation -> new Thread(new Runnable() {
@Override
public void run() {
try {
started.countDown();
try {
if (!started.await(10, TimeUnit.SECONDS)) {
fail("Timed out waiting for all threads to start");
}
} catch (InterruptedException e) {
fail("Got interrupted waiting for all threads to start");
}
operation.run();
finished.countDown();
} catch (Throwable t) {
t.printStackTrace();
throwables.add(t);
}
}
}).start());
assertTrue(finished.await(10, TimeUnit.SECONDS));
assertEquals(throwables.size(), 0);
}
}
| 26,831 |
3,056 | <gh_stars>1000+
// 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
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include <string>
#include <system_error> // NOLINT(build/c++11)
#include "absl/flags/flag.h"
#include "absl/flags/parse.h"
#include "absl/flags/usage.h"
#include "absl/strings/string_view.h"
#include "architecture_utils.h"
#include "encoder_main_lib.h"
#include "glog/logging.h"
#include "include/ghc/filesystem.hpp"
ABSL_FLAG(std::string, input_path, "",
"Complete path to the WAV file to be encoded.");
ABSL_FLAG(std::string, output_dir, "",
"The dir for the encoded file to be written out. Recursively "
"creates dir if it does not exist. Output files use the same "
"name as the wav file they come from with a '.lyra' postfix. Will "
"overwrite existing files.");
ABSL_FLAG(bool, enable_preprocessing, false,
"If enabled runs the input signal through the preprocessing "
"module before encoding.");
ABSL_FLAG(bool, enable_dtx, false,
"Enables discontinuous transmission (DTX). DTX does not send packets "
"when noise is detected.");
ABSL_FLAG(
std::string, model_path, "wavegru",
"Path to directory containing quantization files. For mobile "
"this is the absolute path, like '/sdcard/wavegru/'. For desktop this is "
"the path relative to the binary.");
int main(int argc, char** argv) {
absl::SetProgramUsageMessage(argv[0]);
absl::ParseCommandLine(argc, argv);
const ghc::filesystem::path input_path(absl::GetFlag(FLAGS_input_path));
const ghc::filesystem::path output_dir(absl::GetFlag(FLAGS_output_dir));
const ghc::filesystem::path model_path =
chromemedia::codec::GetCompleteArchitecturePath(
absl::GetFlag(FLAGS_model_path));
const bool enable_preprocessing = absl::GetFlag(FLAGS_enable_preprocessing);
const bool enable_dtx = absl::GetFlag(FLAGS_enable_dtx);
if (input_path.empty()) {
LOG(ERROR) << "Flag --input_path not set.";
return -1;
}
if (output_dir.empty()) {
LOG(ERROR) << "Flag --output_dir not set.";
return -1;
}
std::error_code error_code;
if (!ghc::filesystem::is_directory(output_dir, error_code)) {
LOG(INFO) << "Creating non existent output dir " << output_dir;
if (!ghc::filesystem::create_directories(output_dir, error_code)) {
LOG(ERROR) << "Tried creating output dir " << output_dir
<< " but failed.";
return -1;
}
}
const auto output_path =
ghc::filesystem::path(output_dir) / input_path.stem().concat(".lyra");
if (!chromemedia::codec::EncodeFile(input_path, output_path,
enable_preprocessing, enable_dtx,
model_path)) {
LOG(ERROR) << "Failed to encode " << input_path;
return -1;
}
return 0;
}
| 1,262 |
407 | package com.alibaba.tesla.appmanager.server.controller;
import com.alibaba.tesla.appmanager.api.provider.RtAppInstanceProvider;
import com.alibaba.tesla.appmanager.auth.controller.AppManagerBaseController;
import com.alibaba.tesla.appmanager.common.constants.DefaultConstant;
import com.alibaba.tesla.appmanager.common.pagination.Pagination;
import com.alibaba.tesla.appmanager.common.util.VersionUtil;
import com.alibaba.tesla.appmanager.domain.dto.*;
import com.alibaba.tesla.appmanager.domain.req.rtappinstance.RtAppInstanceHistoryQueryReq;
import com.alibaba.tesla.appmanager.domain.req.rtappinstance.RtAppInstanceQueryReq;
import com.alibaba.tesla.appmanager.domain.req.rtappinstance.RtComponentInstanceHistoryQueryReq;
import com.alibaba.tesla.appmanager.server.job.OrphanComponentInstanceJob;
import com.alibaba.tesla.common.base.TeslaBaseResult;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.oauth2.provider.OAuth2Authentication;
import org.springframework.web.bind.annotation.*;
import javax.servlet.http.HttpServletRequest;
/**
* 实时应用实例管理
*
* @author <EMAIL>
*/
@Slf4j
@RequestMapping("/realtime/app-instances")
@RestController
public class RtAppInstanceController extends AppManagerBaseController {
@Autowired
private RtAppInstanceProvider rtAppInstanceProvider;
@Autowired
private OrphanComponentInstanceJob orphanComponentInstanceJob;
@GetMapping("")
public TeslaBaseResult list(
@ModelAttribute RtAppInstanceQueryReq request,
HttpServletRequest r, OAuth2Authentication auth) {
if (StringUtils.isEmpty(request.getClusterId())) {
request.setClusterId(null);
}
if (StringUtils.isEmpty(request.getNamespaceId())) {
request.setNamespaceId(null);
}
if (StringUtils.isEmpty(request.getStageId())) {
request.setStageId(null);
}
Pagination<RtAppInstanceDTO> result = rtAppInstanceProvider.queryByCondition(request);
return buildSucceedResult(result);
}
@GetMapping(value = "/statistics")
public TeslaBaseResult statistics(
RtAppInstanceQueryReq request, HttpServletRequest r, OAuth2Authentication auth) {
request.setPagination(false);
Pagination<RtAppInstanceDTO> result = rtAppInstanceProvider.queryByCondition(request);
long upgradeCount = result.getItems().stream()
.filter(instance ->
VersionUtil.compareTo(instance.getLatestVersion(), instance.getSimpleVersion()) > 0)
.count();
RtAppInstanceStatisticsDTO response = RtAppInstanceStatisticsDTO.builder()
.deployCount(result.getTotal())
.upgradeCount(upgradeCount)
.build();
return buildSucceedResult(response);
}
@GetMapping("{appInstanceId}")
public TeslaBaseResult get(
@PathVariable("appInstanceId") String appInstanceId,
HttpServletRequest r, OAuth2Authentication auth) {
RtAppInstanceDTO result = rtAppInstanceProvider.get(appInstanceId);
return buildSucceedResult(result);
}
@DeleteMapping("{appInstanceId}")
public TeslaBaseResult delete(
@PathVariable("appInstanceId") String appInstanceId,
HttpServletRequest r, OAuth2Authentication auth) {
rtAppInstanceProvider.delete(appInstanceId);
return buildSucceedResult(DefaultConstant.EMPTY_OBJ);
}
@GetMapping("{appInstanceId}/histories")
public TeslaBaseResult listHistory(
@PathVariable("appInstanceId") String appInstanceId,
@ModelAttribute RtAppInstanceHistoryQueryReq request,
HttpServletRequest r, OAuth2Authentication auth) {
request.setAppInstanceId(appInstanceId);
Pagination<RtAppInstanceHistoryDTO> result = rtAppInstanceProvider.queryAppInstanceHistoryByCondition(request);
return buildSucceedResult(result);
}
@GetMapping("{appInstanceId}/component-instances/{componentInstanceId}")
public TeslaBaseResult getComponentInstance(
@PathVariable("appInstanceId") String appInstanceId,
@PathVariable("componentInstanceId") String componentInstanceId,
HttpServletRequest r, OAuth2Authentication auth) {
RtComponentInstanceDTO result = rtAppInstanceProvider.getComponentInstance(appInstanceId, componentInstanceId);
if (result == null) {
return buildClientErrorResult("cannot find specified component instance");
}
return buildSucceedResult(result);
}
@GetMapping("{appInstanceId}/component-instances/{componentInstanceId}/histories")
public TeslaBaseResult listHistory(
@PathVariable("appInstanceId") String appInstanceId,
@PathVariable("componentInstanceId") String componentInstanceId,
@ModelAttribute RtComponentInstanceHistoryQueryReq request,
HttpServletRequest r, OAuth2Authentication auth) {
request.setComponentInstanceId(componentInstanceId);
Pagination<RtComponentInstanceHistoryDTO> result = rtAppInstanceProvider
.queryComponentInstanceHistoryByCondition(request);
return buildSucceedResult(result);
}
@PostMapping("/retryOrphanComponents")
public TeslaBaseResult orphanComponents() {
orphanComponentInstanceJob.run();
return buildSucceedResult(DefaultConstant.EMPTY_OBJ);
}
}
| 2,104 |
575 | // 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 COMPONENTS_PASSWORD_MANAGER_CORE_BROWSER_CHANGE_PASSWORD_URL_SERVICE_H_
#define COMPONENTS_PASSWORD_MANAGER_CORE_BROWSER_CHANGE_PASSWORD_URL_SERVICE_H_
#include "components/keyed_service/core/keyed_service.h"
class GURL;
namespace password_manager {
class ChangePasswordUrlService : public KeyedService {
public:
// Prefetch the change password URLs that point to the password change form
// from gstatic.
virtual void PrefetchURLs() = 0;
// Returns a change password url for a given |origin| using eTLD+1. If no
// override is available or the fetch is not completed yet an empty GURL is
// returned.
virtual GURL GetChangePasswordUrl(const GURL& url) = 0;
};
} // namespace password_manager
#endif // COMPONENTS_PASSWORD_MANAGER_CORE_BROWSER_CHANGE_PASSWORD_URL_SERVICE_H_
| 318 |
1,131 | <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
// the License. You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
package com.cloud.utils.db;
import org.junit.Assert;
import org.junit.Test;
public class FilterTest {
@Test
/*
* This test verifies that the Order By clause generated by the filter is correct and it separates each
* order by field with a comma. Using DbTestVO to assert it
*/
public void testAddOrderBy() {
Filter filter = new Filter(DbTestVO.class, "fieldString", true, 1L, 1L);
Assert.assertTrue(filter.getOrderBy().trim().toLowerCase().equals("order by test.fld_string asc"));
filter.addOrderBy(DbTestVO.class, "fieldLong", true);
Assert.assertTrue(filter.getOrderBy().contains(","));
Assert.assertTrue(filter.getOrderBy().split(",")[1].trim().toLowerCase().equals("test.fld_long asc"));
filter.addOrderBy(DbTestVO.class, "fieldInt", true);
Assert.assertTrue(filter.getOrderBy().split(",").length == 3);
Assert.assertTrue(filter.getOrderBy().split(",")[2].trim().toLowerCase().equals("test.fld_int asc"));
}
}
| 583 |
1,272 | <filename>ApplicationUtilities/Resources/Audio/src/CommunicationsAudioFactory.cpp
/*
* Copyright Amazon.com, Inc. or its affiliates. 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.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0/
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
#include "Audio/CommunicationsAudioFactory.h"
#include <AVSCommon/Utils/Stream/StreamFunctions.h>
#include <Audio/Data/med_comms_call_connected.mp3.h>
#include <Audio/Data/med_comms_call_disconnected.mp3.h>
#include <Audio/Data/med_comms_call_incoming_ringtone.mp3.h>
#include <Audio/Data/med_comms_drop_in_incoming.mp3.h>
#include <Audio/Data/med_comms_outbound_ringtone.mp3.h>
namespace alexaClientSDK {
namespace applicationUtilities {
namespace resources {
namespace audio {
using namespace avsCommon::utils;
static std::pair<std::unique_ptr<std::istream>, const avsCommon::utils::MediaType> callConnectedRingtoneFactory() {
return std::make_pair(
avsCommon::utils::stream::streamFromData(
data::med_comms_call_connected_mp3, sizeof(data::med_comms_call_connected_mp3)),
avsCommon::utils::MimeTypeToMediaType(data::med_comms_call_connected_mp3_mimetype));
}
static std::pair<std::unique_ptr<std::istream>, const avsCommon::utils::MediaType> callDisconnectedRingtoneFactory() {
return std::make_pair(
avsCommon::utils::stream::streamFromData(
data::med_comms_call_disconnected_mp3, sizeof(data::med_comms_call_disconnected_mp3)),
avsCommon::utils::MimeTypeToMediaType(data::med_comms_call_disconnected_mp3_mimetype));
}
static std::pair<std::unique_ptr<std::istream>, const avsCommon::utils::MediaType> outboundRingtoneFactory() {
return std::make_pair(
avsCommon::utils::stream::streamFromData(
data::med_comms_outbound_ringtone_mp3, sizeof(data::med_comms_outbound_ringtone_mp3)),
avsCommon::utils::MimeTypeToMediaType(data::med_comms_outbound_ringtone_mp3_mimetype));
}
static std::pair<std::unique_ptr<std::istream>, const avsCommon::utils::MediaType> dropInIncomingFactory() {
return std::make_pair(
avsCommon::utils::stream::streamFromData(
data::med_comms_drop_in_incoming_mp3, sizeof(data::med_comms_drop_in_incoming_mp3)),
avsCommon::utils::MimeTypeToMediaType(data::med_comms_drop_in_incoming_mp3_mimetype));
}
static std::pair<std::unique_ptr<std::istream>, const avsCommon::utils::MediaType> callIncomingRingtoneFactory() {
return std::make_pair(
avsCommon::utils::stream::streamFromData(
data::med_comms_call_incoming_ringtone_mp3, sizeof(data::med_comms_call_incoming_ringtone_mp3)),
avsCommon::utils::MimeTypeToMediaType(data::med_comms_call_incoming_ringtone_mp3_mimetype));
}
std::function<std::pair<std::unique_ptr<std::istream>, const avsCommon::utils::MediaType>()>
CommunicationsAudioFactory::callConnectedRingtone() const {
return callConnectedRingtoneFactory;
}
std::function<std::pair<std::unique_ptr<std::istream>, const avsCommon::utils::MediaType>()>
CommunicationsAudioFactory::callDisconnectedRingtone() const {
return callDisconnectedRingtoneFactory;
}
std::function<std::pair<std::unique_ptr<std::istream>, const avsCommon::utils::MediaType>()>
CommunicationsAudioFactory::outboundRingtone() const {
return outboundRingtoneFactory;
}
std::function<std::pair<std::unique_ptr<std::istream>, const avsCommon::utils::MediaType>()>
CommunicationsAudioFactory::dropInIncoming() const {
return dropInIncomingFactory;
}
std::function<std::pair<std::unique_ptr<std::istream>, const avsCommon::utils::MediaType>()>
CommunicationsAudioFactory::callIncomingRingtone() const {
return callIncomingRingtoneFactory;
}
} // namespace audio
} // namespace resources
} // namespace applicationUtilities
} // namespace alexaClientSDK
| 1,482 |
324 | <gh_stars>100-1000
/*
* Copyright (c) 2011-2018, <NAME>. All Rights Reserved.
*
* 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.
*/
#include "http_service.h"
#include "route_info.h"
#include "config_loader.h"
#include "discovery_service.h"
#include "monitor_collector.h"
using namespace meituan_mns;
muduo::MutexLock HttpService::http_service_lock_;
HttpService *HttpService::http_service_ = NULL;
HttpService *HttpService::GetInstance() {
if (NULL == http_service_) {
muduo::MutexLockGuard lock(http_service_lock_);
if (NULL == http_service_) {
http_service_ = new HttpService();
}
}
return http_service_;
}
HttpService::~HttpService() {
if (NULL != http_service_loop_) {
http_service_loop_->quit();
usleep(kThreadTime * http_service_loop_->queueSize());
delete http_service_loop_;
http_service_loop_ = NULL;
}
}
/*
* parse data from http
*/
int32_t HttpService::ParseServiceDataFromHttp(const char *post_data,
ServicePtr &service) {
if (NULL == post_data) {
NS_LOG_ERROR("the http post msg is null");
return FAILURE;
}
cJSON *root = cJSON_Parse(post_data);
if (NULL == root) {
NS_LOG_ERROR("the cJSON_Parse error");
return FAILURE;
}
cJSON *pItem = cJSON_GetObjectItem(root, "remoteAppkey");
if (NULL != pItem) {
std::string remote_appkey = pItem->valuestring;
boost::trim(remote_appkey);
if (!remote_appkey.empty()) {
service->__set_remoteAppkey(remote_appkey);
} else {
NS_LOG_ERROR("remoteappkey is empty.");
cJSON_Delete(root);
return FAILURE;
}
} else {
NS_LOG_ERROR("the flush service remoteappkey is null");
cJSON_Delete(root);
return FAILURE;
}
pItem = cJSON_GetObjectItem(root, "protocol");
if (NULL != pItem) {
std::string protocol = pItem->valuestring;
boost::trim(protocol);
if (!protocol.empty()) {
service->__set_protocol(protocol);
} else {
NS_LOG_ERROR("procotol is empty.");
cJSON_Delete(root);
return FAILURE;
}
} else {
NS_LOG_ERROR("the flush service procotol is null");
cJSON_Delete(root);
return FAILURE;
}
pItem = cJSON_GetObjectItem(root, "localAppkey");
if (NULL != pItem) {
service->__set_localAppkey(pItem->valuestring);
}
pItem = cJSON_GetObjectItem(root, "version");
if (NULL != pItem) {
service->__set_version(pItem->valuestring);
}
pItem = cJSON_GetObjectItem(root, "serviceList");
if (NULL != pItem) {
std::vector<SGService> servicelist;
int size = cJSON_GetArraySize(pItem);
cJSON *item = NULL;
for (int i = 0; i < size; ++i) {
SGService serviceInfo;
item = cJSON_GetArrayItem(pItem, i);
if (SUCCESS == ParseNodeData(item, serviceInfo)) {
serviceInfo.__set_appkey(service->remoteAppkey);
serviceInfo.__set_protocol(service->protocol);
serviceInfo.__set_envir(CXmlFile::GetAppenv()->GetIntEnv());//获取本地sg_agent环境
serviceInfo.__set_lastUpdateTime(time(NULL));//获取当前时间
servicelist.push_back(serviceInfo);
} else {
NS_LOG_WARN("Failed to parse the " << i << "th serviceInfo.");
}
}
if (!servicelist.empty()) {
service->__set_serviceList(servicelist);
} else {
NS_LOG_WARN("servlist is empty , remoteAppkey = " << service->remoteAppkey
<< ", protocol = " << service->protocol);
}
}
cJSON_Delete(root);
return SUCCESS;
}
int32_t HttpService::ParseNodeData(cJSON *root, SGService &service_info) {
cJSON *pItem = cJSON_GetObjectItem(root, "ip");
if (NULL != pItem) {
service_info.__set_ip(pItem->valuestring);
} else {
NS_LOG_ERROR("the flush service ip is null");
return FAILURE;
}
pItem = cJSON_GetObjectItem(root, "port");
if (NULL != pItem) {
service_info.__set_port(pItem->valueint);
} else {
NS_LOG_ERROR("the flush port is null");
return FAILURE;
}
pItem = cJSON_GetObjectItem(root, "version");
if (NULL != pItem) {
service_info.__set_version(pItem->valuestring);
}
pItem = cJSON_GetObjectItem(root, "weight");
if (NULL != pItem) {
service_info.__set_weight(pItem->valueint);
}
pItem = cJSON_GetObjectItem(root, "status");
if (NULL != pItem) {
service_info.__set_status(pItem->valueint);
}
pItem = cJSON_GetObjectItem(root, "role");
if (NULL != pItem) {
service_info.__set_role(pItem->valueint);
}
pItem = cJSON_GetObjectItem(root, "serverType");
if (NULL != pItem) {
service_info.__set_serverType(pItem->valueint);
}
pItem = cJSON_GetObjectItem(root, "heartbeatSupport");
if (NULL != pItem) {
service_info.__set_heartbeatSupport(pItem->valueint);
}
pItem = cJSON_GetObjectItem(root, "serviceInfo");
if (pItem) {
cJSON *svrNames = pItem;
int size = cJSON_GetArraySize(svrNames);
for (int i = 0; i < size; ++i) {
cJSON *item = cJSON_GetArrayItem(svrNames, i);
if (NULL != item) {
std::string serviceName(item->string);
NS_LOG_INFO("service name is:" << serviceName);
bool unifiedProto =
(0 != cJSON_GetObjectItem(item, "unifiedProto")->valueint);
ServiceDetail srv;
srv.__set_unifiedProto(unifiedProto);
service_info.serviceInfo[serviceName] = srv;
}
}
}
NS_LOG_INFO("node flush info: appkey:"
<< service_info.appkey << " ip: "
<< service_info.ip << " status:"
<< service_info.status << " last update time: "
<< service_info.lastUpdateTime);
return SUCCESS;
}
void HttpService::StartService() {
char local_ip[LOCAL_IP], local_mask[LOCAL_MASK];
memset(local_ip, '0', LOCAL_IP);
memset(local_mask, '0', LOCAL_MASK);
if (getIntranet(local_ip, local_mask) < 0) {
NS_LOG_ERROR("getIntranet failed");
return;
} else {
NS_LOG_INFO(
"getIntranet ip and mask are " << local_ip << "," << local_mask);
}
struct event_base *base;
struct evhttp *http;
base = event_base_new();
if (!base) {
NS_LOG_ERROR("event_base_new() failed");
return;
}
http = evhttp_new(base);
if (!http) {
NS_LOG_ERROR("evhttp_new() http server failed");
event_base_free(base);
return;
}
if (evhttp_bind_socket(http, listen_ip.c_str(), http_port)) {
NS_LOG_ERROR("http bind socket failed");
evhttp_free(http);
event_base_free(base);
return;
}
evhttp_set_gencb(http, HttpHandler, this);
event_base_dispatch(base);
evhttp_free(http);
event_base_free(base);
return;
}
int32_t HttpService::UpdateServiceInCache(const ServicePtr &service) {
NS_LOG_INFO("http service:update service ");
int32_t ret = DiscoveryService::GetInstance()->UpdateSrvList(service);
if (SUCCESS != ret) {
NS_LOG_ERROR("Run mns update srv list failed, ret = " << ret);
}
return ret;
}
int32_t HttpService::GetServListAndCacheSize(ServListAndCache &list_and_cache,
const std::string &protocol,
const std::string &appkey) {
NS_LOG_INFO("http service:get service, protocol = " << protocol << " ,appkey = " << appkey);
int32_t ret = DiscoveryService::GetInstance()->GetSrvListAndCacheSize(list_and_cache,
protocol, appkey);
if (SUCCESS != ret) {
NS_LOG_ERROR("Run mns get srvlist and buffer failed, ret = " << ret);
}
return ret;
}
int32_t HttpService::RepalceServlistAndCache(const ServicePtr &service) {
NS_LOG_INFO("http service:replace service.");
int32_t ret = DiscoveryService::GetInstance()->RepalceSrvlist(service);
if (SUCCESS != ret) {
NS_LOG_ERROR("Run mns replace srvlist and cache failed, ret = " << ret);
}
return ret;
}
int32_t HttpService::ServiceListByProtocol(const ProtocolRequest &req,
ProtocolResponse &_return) {
NS_LOG_INFO("http service GET servicelist.");
bool enable_swimlane2 = false;
boost::shared_ptr<ServiceChannels> service_channel = boost::make_shared<ServiceChannels>();
service_channel->SetAllChannel(false);
service_channel->SetBankboneChannel(false);
service_channel->SetOriginChannel(false);
service_channel->SetSwimlaneChannel(enable_swimlane2);
int32_t ret = DiscoveryService::GetInstance()->DiscGetSrvList(_return
.servicelist, req,service_channel);
NS_LOG_INFO("Http ServiceListByProtocol size = " << _return.servicelist.size
());
_return.errcode = ret;
if (SUCCESS != ret) {
NS_LOG_ERROR("Http ServiceListByProtocol failed, and ret = " << ret);
}
return ret;
}
void HttpService::HttpHandler(struct evhttp_request *http_request, void *info) {
if (NULL == http_request || NULL == info) {
NS_LOG_ERROR("the http handler para is null");
return;
}
u_char *req_buf;
req_buf = EVBUFFER_DATA(http_request->input_buffer);
const char *decode_uri = evhttp_request_uri(http_request);
char *url = evhttp_decode_uri(decode_uri);
NS_LOG_DEBUG("the remote host is: " << http_request->remote_host
<< ", input url method = " << url
<< ",the req data = " << req_buf);
struct evbuffer *buf = evbuffer_new();//response buffer
if (NULL == buf) {
NS_LOG_ERROR("Failed to create response buffer");
return;
}
HttpService *httpService = (HttpService *) info;
int http_err_code = HTTP_OK;
if (EVHTTP_REQ_GET == http_request->type) {
http_err_code = httpService->Response2RequestByGet(url, buf);
} else if (EVHTTP_REQ_POST == http_request->type) {
http_err_code = httpService->Response2RequestByPost(url, req_buf, buf);
}
evhttp_send_reply(http_request,
http_err_code,
"decode the json data ok!",
buf);
if (NULL != buf) {
evbuffer_free(buf);
}
SAFE_FREE(url);
}
int32_t HttpService::ServiceListActionByPost(const int service_method,
const u_char *req_buf,
struct evbuffer *buf) {
int http_err_code = HTTP_RESPONSE_OK;
ServicePtr service(new getservice_res_param_t());
int ret_code = ParseServiceDataFromHttp((const char *) req_buf, service);
if (SUCCESS != ret_code) {
NS_LOG_ERROR("Failed to parse data, ret = " << ret_code);
evbuffer_add_printf(buf, "request param error");
return HTTP_PARAM_ERROR;
}
switch (service_method) {
case ADD_SERVICE: {
NS_LOG_INFO("http add method");
break;
}
case UPDATE_SERVICE: {
if (SUCCESS != UpdateServiceInCache(service)) {
NS_LOG_ERROR("http-update in agent failed");
http_err_code = HTTP_INNER_ERROR;
}
break;
}
case DELETE_SERVICE: {
NS_LOG_INFO("http delete method");
http_err_code = HTTP_NOT_SUPPORT;
break;
}
case GET_SERVICE: {
ServListAndCache list_and_cache;
if (SUCCESS != GetServListAndCacheSize(list_and_cache,
service->protocol,
service->remoteAppkey)) {
NS_LOG_ERROR("http-get in agent failed");
http_err_code = HTTP_INNER_ERROR;
} else {
std::string response = "";
int ret = ServListAndCache2Json(list_and_cache, response);
if (SUCCESS != ret) {
NS_LOG_ERROR("ServListAndCache(response) to str failed, ret = " << ret);
http_err_code = HTTP_INNER_ERROR;
} else {
evbuffer_add_printf(buf, response.c_str());
}
}
break;
}
case REPLACE_SERVICE: {
if (SUCCESS != RepalceServlistAndCache(service)) {
NS_LOG_ERROR("http-replace in agent failed");
http_err_code = HTTP_INNER_ERROR;
}
break;
}
default: {
http_err_code = HTTP_NOT_SUPPORT;
NS_LOG_ERROR("unkown service method, disgardless");
break;
}
}
return http_err_code;
}
int32_t HttpService::IsHealthy() {
if (IdcUtil::IsInIdcs(CXmlFile::GetStrPara(CXmlFile::LocalIp))) {
return HTTP_RESPONSE_OK;
}
return HTTP_INNER_ERROR;
}
int32_t HttpService::EncodeHealthyInfo(std::string &res) {
char *out;
int ret = HTTP_RESPONSE_OK;
int ret_json = -1;
cJSON *json = cJSON_CreateObject();
if (!json) {
NS_LOG_ERROR("json is NULL, create json_object failed.");
return FAILURE;
}
ret = IsHealthy();
cJSON_AddNumberToObject(json, "ret", ret);
cJSON_AddStringToObject(json, "retMsg", "success");
cJSON_AddStringToObject(json, "endpoint", CXmlFile::GetAppenv()->GetStrEnv().c_str());
out = cJSON_Print(json);
if(NULL!= out){
res = out;
SAFE_FREE(out);
cJSON_Delete(json);
NS_LOG_INFO("EncodeHealthyInfo success = "
<< res << "local ip = " << CXmlFile::GetAppenv()->GetStrEnv());
return SUCCESS;
}else{
cJSON_Delete(json);
res = HTTP_RESPONSE_NULL;
NS_LOG_ERROR("EncodeHealthyInfo failed = "
<< res << "local ip = "
<< CXmlFile::GetAppenv()->GetStrEnv());
return FAILURE;
}
}
//获取监控信息reqBuf无需做空判断处理
int32_t HttpService::MonitorActionByPost(int service_method,
const u_char *req_buf,
struct evbuffer *buf) {
int http_err_code = HTTP_RESPONSE_OK;
switch (service_method) {
case GET_MONITOR_SERVICE: {
std::string response = "";
int32_t ret = MonitorCollector::GetInstance()->GetCollectorMonitorInfo(response);
if (SUCCESS != ret) {
NS_LOG_ERROR("Get collectorMonitorInfo failed, ret = " << ret);
http_err_code = HTTP_INNER_ERROR;
} else {
evbuffer_add_printf(buf, response.c_str());
}
break;
}
default:http_err_code = HTTP_INNER_ERROR;
break;
}
return http_err_code;
}
/*
* response to HTTP requests
* 缺省为服务列表操作，后续扩展其它
*/
int32_t HttpService::Response2RequestByPost(const char *url,
const u_char *req_buf,
struct evbuffer *buf) {
int serviceMethod = GetServiceMethodFromHttp(url);
switch (serviceMethod) {
case GET_MONITOR_SERVICE: {
return MonitorActionByPost(serviceMethod, req_buf, buf);
}
case HEALTHY_CHECK: {
return HealthyCheckByPost(serviceMethod, req_buf, buf);
}
default: {
return ServiceListActionByPost(serviceMethod, req_buf, buf);
}
}
return HTTP_RESPONSE_OK;
}
/*
* ServListAndCache struct to Json
*/
int32_t HttpService::ServListAndCache2Json(const ServListAndCache &list_and_cache,
std::string &response) {
cJSON *json = cJSON_CreateObject();
char *out;
if (!json) {
NS_LOG_ERROR("json is NULL, create json_object failed.");
return FAILURE;
}
cJSON_AddNumberToObject(json, "origin_servlist_size", list_and_cache.origin_servlist_size);
cJSON_AddNumberToObject(json, "filte_servlist_size", list_and_cache.filte_servlist_size);
cJSON_AddNumberToObject(json, "origin_cache_size", list_and_cache.origin_cache_size);
cJSON_AddNumberToObject(json, "filte_cache_size", list_and_cache.filte_cache_size);
int ret = Service2Json(list_and_cache.origin_servicelist, json, "origin_servicelist");
if (SUCCESS != ret) {
NS_LOG_ERROR("Failed to change origin_servicelist to json, ret = " << ret);
cJSON_Delete(json);
return FAILURE;
}
ret = Service2Json(list_and_cache.filte_servicelist, json, "filte_servicelist");
if (SUCCESS != ret) {
NS_LOG_ERROR("Failed to change filte_servicelist to json, ret = " << ret);
cJSON_Delete(json);
return FAILURE;
}
out = cJSON_Print(json);
response = out;
SAFE_FREE(out);
cJSON_Delete(json);
boost::trim(response);
if (response.empty()) {
NS_LOG_ERROR("json to str failed, the response json is empty.");
return FAILURE;
}
return SUCCESS;
}
/*
* SGService to json
*/
int32_t HttpService::Service2Json(const std::vector<SGService> &servicelist,
cJSON *json,
const char *type) {
cJSON *all_srvlist_json = cJSON_CreateArray();
if (!all_srvlist_json) {
NS_LOG_ERROR("all_srvlist_json is NULL, create json_object failed.");
return FAILURE;
}
for (std::vector<SGService>::const_iterator iter = servicelist.begin();
iter != servicelist.end(); ++iter) {
cJSON *item = cJSON_CreateObject();
int ret = SGService2Json(*iter, item);
if (SUCCESS != ret) {
NS_LOG_ERROR("SGService2Json failed, ret = " << ret);
return FAILURE;
}
cJSON_AddItemToArray(all_srvlist_json, item);
}
cJSON_AddItemToObject(json, type, all_srvlist_json);
return SUCCESS;
}
int32_t HttpService::SGService2Json(const SGService &oservice, cJSON *root) {
cJSON_AddItemToObject(root, "appkey", cJSON_CreateString(oservice.appkey.c_str()));
cJSON_AddItemToObject(root, "version", cJSON_CreateString(oservice.version.c_str()));
cJSON_AddItemToObject(root, "ip", cJSON_CreateString(oservice.ip.c_str()));
cJSON_AddNumberToObject(root, "port", oservice.port);
cJSON_AddNumberToObject(root, "weight", oservice.weight);
cJSON_AddNumberToObject(root, "status", oservice.status);
cJSON_AddNumberToObject(root, "role", oservice.role);
cJSON_AddNumberToObject(root, "env", CXmlFile::GetAppenv()->GetIntEnv());
cJSON_AddNumberToObject(root, "lastUpdateTime", oservice.lastUpdateTime);
//后续添加,注意有可能没有
cJSON_AddNumberToObject(root, "fweight", oservice.fweight);
cJSON_AddNumberToObject(root, "serverType", oservice.serverType);
int32_t heartbeatSupport = oservice.heartbeatSupport;
cJSON_AddNumberToObject(root, "heartbeatSupport", heartbeatSupport);
cJSON_AddItemToObject(root, "protocol", cJSON_CreateString(oservice.protocol.c_str()));
cJSON *item = cJSON_CreateObject();
if (NULL == item) {
NS_LOG_ERROR("cJson failed to CreateObject. Item is serviceInfo");
return FAILURE;
}
int ret = JsonZkMgr::cJson_AddServiceObject(oservice.serviceInfo, root,
item, std::string("serviceInfo"));
if (0 != ret) {
NS_LOG_ERROR("failed to add serviceName to root");
return FAILURE;
}
return SUCCESS;
}
int32_t HttpService::GetKeyValueFromUrl(const std::string &url,
const std::string &key,
std::string &value) {
int len = url.length();
size_t pos = url.find(key);
if (std::string::npos != pos) {
for (int i = pos + key.length(); i < len && '&' != url[i]; ++i) {
value += url[i];
}
if (value.empty()) {
NS_LOG_DEBUG("key: " << key << " is empty.");
return FAILURE;
}
} else {
NS_LOG_DEBUG("key: " << key << " does not exist");
return FAILURE;
}
return SUCCESS;
}
int32_t HttpService::GetServiceParamFromUrl(const std::string &url,
ProtocolRequest ¶ms) {
NS_LOG_DEBUG("the MNS url is: " << url);
std::string tmp_url = url;
boost::trim(tmp_url);
size_t pos = tmp_url.find("/api/servicelist?");
size_t appkey_pos = tmp_url.find("appkey=");
size_t protocol_pos = tmp_url.find("protocol=");
if (std::string::npos != pos && std::string::npos != appkey_pos
&& std::string::npos != protocol_pos) {
std::string env = "";
int ret = GetKeyValueFromUrl(tmp_url, "env=", env);
if (SUCCESS == ret) {
if (env == CXmlFile::GetAppenv()->GetStrEnv()) {
NS_LOG_DEBUG("env is " << env);
} else {
NS_LOG_ERROR("env:" << env << " is different from local env:" << CXmlFile::GetAppenv()->GetStrEnv());
return ERR_INVALID_ENV;
}
} else {
NS_LOG_WARN("env error, ret = " << ret);
}
std::string appkey = "";
ret = GetKeyValueFromUrl(tmp_url, "appkey=", appkey);
if (SUCCESS == ret) {
params.remoteAppkey = appkey;
} else {
NS_LOG_ERROR("appkey error, ret = " << ret);
return HTTP_PARAM_ERROR;
}
std::string protocol = "";
ret = GetKeyValueFromUrl(tmp_url, "protocol=", protocol);
if (SUCCESS == ret) {
params.protocol = protocol;
} else {
NS_LOG_ERROR("protocol error, ret = " << ret);
return HTTP_PARAM_ERROR;
}
std::string hostname = "";
ret = GetKeyValueFromUrl(tmp_url, "hostname=", hostname);
if (SUCCESS == ret) {
NS_LOG_INFO("hostname is " << hostname);
} else {
NS_LOG_WARN("hostname error, ret = " << ret);
}
std::string localip = "";
ret = GetKeyValueFromUrl(tmp_url, "localip=", localip);
if (SUCCESS == ret) {
NS_LOG_INFO("localip is " << localip);
} else {
NS_LOG_WARN("localip error ,ret = " << ret);
}
} else {
NS_LOG_ERROR("params are empty.");
return HTTP_PARAM_ERROR;
}
return HTTP_OK;
}
int32_t HttpService::Response2RequestByGet(const char *url,
struct evbuffer *buf) {
ProtocolRequest req;
int http_code = GetServiceParamFromUrl(url, req);
if (HTTP_OK != http_code) {
NS_LOG_ERROR("http response failed, err_code = " << http_code);
return http_code;
}
std::vector<SGService> result;
req.__set_remoteAppkey(req.remoteAppkey);
req.__set_protocol(req.protocol);
ProtocolResponse _return;
int ret = ServiceListByProtocol(req, _return);
if (SUCCESS != ret) {
NS_LOG_ERROR("Failed to get servicelist by http, ret = " << ret);
return HTTP_INNER_ERROR;
}
std::string response = "";
ret = ProtocolResponse2Json(_return, response);
if (SUCCESS != ret) {
NS_LOG_ERROR("Failed to ProtocolResponse2Json, ret = " << ret);
return HTTP_INNER_ERROR;
}
evbuffer_add_printf(buf, response.c_str());
//NS_LOG_INFO("response : " << response);
return http_code;
}
int32_t HttpService::HealthyCheckByPost(int serviceMethod, const u_char
*req_buf, struct evbuffer *buf) {
NS_LOG_INFO("the healthy check by post");
int http_err_code = HTTP_RESPONSE_OK;
std::string response = "";
if (SUCCESS != EncodeHealthyInfo(response)) {
NS_LOG_ERROR("Get collectorMonitorInfo failed, ret = ");
http_err_code = HTTP_INNER_ERROR;
} else {
evbuffer_add_printf(buf, response.c_str());
}
return http_err_code;
}
int32_t HttpService::ProtocolResponse2Json(const ProtocolResponse &res,
std::string &response) {
cJSON *parent = cJSON_CreateObject();
char *out;
if (NULL == parent) {
NS_LOG_ERROR("Failed to create json object:parent.");
return FAILURE;
}
cJSON *child = cJSON_CreateObject();
if (NULL == child) {
NS_LOG_ERROR("Failed to create json object:child.");
return FAILURE;
}
cJSON_AddNumberToObject(parent, "ret", HTTP_RESPONSE_OK);
cJSON_AddStringToObject(parent, "retMsg", "success");
int ret = Service2Json(res.servicelist, child, "serviceList");
if (SUCCESS != ret) {
NS_LOG_ERROR("Failed to parse service, ret = " << ret);
cJSON_Delete(parent);
return FAILURE;
}
cJSON_AddItemToObject(parent, "data", child);
out = cJSON_Print(parent);
response = out;
// NS_LOG_INFO("the response service list is "<< response);
boost::trim(response);
if (response.empty()) {
NS_LOG_ERROR("json to str failed, the response json is empty.");
SAFE_FREE(out);
cJSON_Delete(parent);
return FAILURE;
}
SAFE_FREE(out);
cJSON_Delete(parent);
return SUCCESS;
}
//todo:monitor子方法后续细分后解析
int32_t HttpService::DecodeMonitorUrlMethod(const std::string &url) {
NS_LOG_INFO("the monitor url is:" << url);
return GET_MONITOR_SERVICE;
}
int32_t HttpService::DecodeMnsUrlMethod(const std::string &url) {
NS_LOG_INFO("the Mns Url is:" << url);
std::string strtmp = "";
strtmp.assign(url, strlen("/api/mns/provider/"), url.length());
NS_LOG_INFO("find method:" << strtmp);
if (SUCCESS == strtmp.compare("add")) {
return ADD_SERVICE;
} else if (SUCCESS == strtmp.compare("delete")) {
return DELETE_SERVICE;
} else if (SUCCESS == strtmp.compare("update")) {
return UPDATE_SERVICE;
} else if (SUCCESS == strtmp.compare("get")) {
return GET_SERVICE;
} else if (SUCCESS == strtmp.compare("monitorinfo")) {//名字修改monitor
return GET_MONITOR_SERVICE;
} else if (SUCCESS == strtmp.compare("replace")) {//强制替换列表
return REPLACE_SERVICE;
} else {
NS_LOG_ERROR("unkown http sub method");
}
return INVALID_METHOD;
}
int32_t HttpService::DecodeHealthyMethod(const std::string &url) {
NS_LOG_INFO("the monitor url is:" << url);
return HEALTHY_CHECK;
}
int32_t HttpService::GetServiceMethodFromHttp(const char *input_method) {
if (NULL == input_method) {
NS_LOG_ERROR("the inputMethod is null");
return INVALID_METHOD;
}
std::string input_str = input_method;
NS_LOG_INFO("Input str = " << input_str);
std::size_t pos_mns = input_str.find("/api/mns/provider/");
if (std::string::npos != pos_mns && 0 == pos_mns) {
return DecodeMnsUrlMethod(input_str);
}
std::size_t pos_mon = input_str.find("/api/monitor");
if (std::string::npos != pos_mon && 0 == pos_mon) {
return DecodeMonitorUrlMethod(input_str);
}
std::size_t pos_hlh = input_str.find("/api/healthy");
if (std::string::npos != pos_hlh && 0 == pos_hlh) {
return DecodeHealthyMethod(input_str);
}
return INVALID_METHOD;
}
void HttpService::StartHttpServer() {
NS_LOG_INFO("http server init");
http_service_loop_ = http_service_thread_.startLoop();
http_service_loop_->runInLoop(boost::bind(&HttpService::StartService, this));
}
| 11,317 |
3,227 | // Copyright (c) 1998-2021
// Utrecht University (The Netherlands),
// ETH Zurich (Switzerland),
// INRIA Sophia-Antipolis (France),
// Max-Planck-Institute Saarbruecken (Germany),
// and Tel-Aviv University (Israel). All rights reserved.
//
// This file is part of CGAL (www.cgal.org)
//
// $URL$
// $Id$
// SPDX-License-Identifier: LGPL-3.0-or-later OR LicenseRef-Commercial
//
//
// Author(s) : <NAME>, <NAME>
#ifndef CGAL_DISTANCE_3_POINT_3_POINT_3_H
#define CGAL_DISTANCE_3_POINT_3_POINT_3_H
#include <CGAL/Point_3.h>
namespace CGAL {
namespace internal {
template <class K>
inline
typename K::FT
squared_distance(const typename K::Point_3& pt1,
const typename K::Point_3& pt2,
const K& k)
{
return k.compute_squared_distance_3_object()(pt1, pt2);
}
} // namespace internal
template <class K>
inline
typename K::FT
squared_distance(const Point_3<K>& pt1,
const Point_3<K>& pt2)
{
return internal::squared_distance(pt1, pt2, K());
}
} // namespace CGAL
#endif // CGAL_DISTANCE_3_POINT_3_POINT_3_H
| 461 |
5,941 | /**
* FreeRDP: A Remote Desktop Protocol Implementation
* RDP protocol "scancodes"
*
* Copyright 2009-2012 <NAME> <<EMAIL>>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef FREERDP_LOCALE_KEYBOARD_RDP_SCANCODE_H
#define FREERDP_LOCALE_KEYBOARD_RDP_SCANCODE_H
#include <winpr/input.h>
/* @msdn{cc240584} says:
* "... (a scancode is an 8-bit value specifying a key location on the keyboard).
* The server accepts a scancode value and translates it into the correct character depending on the
* language locale and keyboard layout used in the session." The 8-bit value is later called
* "keyCode" The extended flag is for all practical an important 9th bit with a strange encoding -
* not just a modifier.
*/
#define RDP_SCANCODE_CODE(_rdp_scancode) ((BYTE)(_rdp_scancode & 0xFF))
#define RDP_SCANCODE_EXTENDED(_rdp_scancode) (((_rdp_scancode)&KBDEXT) ? TRUE : FALSE)
#define MAKE_RDP_SCANCODE(_code, _extended) (((_code)&0xFF) | ((_extended) ? KBDEXT : 0))
/* Defines for known RDP_SCANCODE protocol values.
* Mostly the same as the PKBDLLHOOKSTRUCT scanCode, "A hardware scan code for the key",
* @msdn{ms644967}. Based @msdn{ms894073} US, @msdn{ms894072} UK, @msdn{ms892472} */
#define RDP_SCANCODE_UNKNOWN MAKE_RDP_SCANCODE(0x00, FALSE)
#define RDP_SCANCODE_ESCAPE MAKE_RDP_SCANCODE(0x01, FALSE) /* VK_ESCAPE */
#define RDP_SCANCODE_KEY_1 MAKE_RDP_SCANCODE(0x02, FALSE) /* VK_KEY_1 */
#define RDP_SCANCODE_KEY_2 MAKE_RDP_SCANCODE(0x03, FALSE) /* VK_KEY_2 */
#define RDP_SCANCODE_KEY_3 MAKE_RDP_SCANCODE(0x04, FALSE) /* VK_KEY_3 */
#define RDP_SCANCODE_KEY_4 MAKE_RDP_SCANCODE(0x05, FALSE) /* VK_KEY_4 */
#define RDP_SCANCODE_KEY_5 MAKE_RDP_SCANCODE(0x06, FALSE) /* VK_KEY_5 */
#define RDP_SCANCODE_KEY_6 MAKE_RDP_SCANCODE(0x07, FALSE) /* VK_KEY_6 */
#define RDP_SCANCODE_KEY_7 MAKE_RDP_SCANCODE(0x08, FALSE) /* VK_KEY_7 */
#define RDP_SCANCODE_KEY_8 MAKE_RDP_SCANCODE(0x09, FALSE) /* VK_KEY_8 */
#define RDP_SCANCODE_KEY_9 MAKE_RDP_SCANCODE(0x0A, FALSE) /* VK_KEY_9 */
#define RDP_SCANCODE_KEY_0 MAKE_RDP_SCANCODE(0x0B, FALSE) /* VK_KEY_0 */
#define RDP_SCANCODE_OEM_MINUS MAKE_RDP_SCANCODE(0x0C, FALSE) /* VK_OEM_MINUS */
#define RDP_SCANCODE_OEM_PLUS MAKE_RDP_SCANCODE(0x0D, FALSE) /* VK_OEM_PLUS */
#define RDP_SCANCODE_BACKSPACE MAKE_RDP_SCANCODE(0x0E, FALSE) /* VK_BACK Backspace */
#define RDP_SCANCODE_TAB MAKE_RDP_SCANCODE(0x0F, FALSE) /* VK_TAB */
#define RDP_SCANCODE_KEY_Q MAKE_RDP_SCANCODE(0x10, FALSE) /* VK_KEY_Q */
#define RDP_SCANCODE_KEY_W MAKE_RDP_SCANCODE(0x11, FALSE) /* VK_KEY_W */
#define RDP_SCANCODE_KEY_E MAKE_RDP_SCANCODE(0x12, FALSE) /* VK_KEY_E */
#define RDP_SCANCODE_KEY_R MAKE_RDP_SCANCODE(0x13, FALSE) /* VK_KEY_R */
#define RDP_SCANCODE_KEY_T MAKE_RDP_SCANCODE(0x14, FALSE) /* VK_KEY_T */
#define RDP_SCANCODE_KEY_Y MAKE_RDP_SCANCODE(0x15, FALSE) /* VK_KEY_Y */
#define RDP_SCANCODE_KEY_U MAKE_RDP_SCANCODE(0x16, FALSE) /* VK_KEY_U */
#define RDP_SCANCODE_KEY_I MAKE_RDP_SCANCODE(0x17, FALSE) /* VK_KEY_I */
#define RDP_SCANCODE_KEY_O MAKE_RDP_SCANCODE(0x18, FALSE) /* VK_KEY_O */
#define RDP_SCANCODE_KEY_P MAKE_RDP_SCANCODE(0x19, FALSE) /* VK_KEY_P */
#define RDP_SCANCODE_OEM_4 MAKE_RDP_SCANCODE(0x1A, FALSE) /* VK_OEM_4 '[' on US */
#define RDP_SCANCODE_OEM_6 MAKE_RDP_SCANCODE(0x1B, FALSE) /* VK_OEM_6 ']' on US */
#define RDP_SCANCODE_RETURN MAKE_RDP_SCANCODE(0x1C, FALSE) /* VK_RETURN Normal Enter */
#define RDP_SCANCODE_LCONTROL MAKE_RDP_SCANCODE(0x1D, FALSE) /* VK_LCONTROL */
#define RDP_SCANCODE_KEY_A MAKE_RDP_SCANCODE(0x1E, FALSE) /* VK_KEY_A */
#define RDP_SCANCODE_KEY_S MAKE_RDP_SCANCODE(0x1F, FALSE) /* VK_KEY_S */
#define RDP_SCANCODE_KEY_D MAKE_RDP_SCANCODE(0x20, FALSE) /* VK_KEY_D */
#define RDP_SCANCODE_KEY_F MAKE_RDP_SCANCODE(0x21, FALSE) /* VK_KEY_F */
#define RDP_SCANCODE_KEY_G MAKE_RDP_SCANCODE(0x22, FALSE) /* VK_KEY_G */
#define RDP_SCANCODE_KEY_H MAKE_RDP_SCANCODE(0x23, FALSE) /* VK_KEY_H */
#define RDP_SCANCODE_KEY_J MAKE_RDP_SCANCODE(0x24, FALSE) /* VK_KEY_J */
#define RDP_SCANCODE_KEY_K MAKE_RDP_SCANCODE(0x25, FALSE) /* VK_KEY_K */
#define RDP_SCANCODE_KEY_L MAKE_RDP_SCANCODE(0x26, FALSE) /* VK_KEY_L */
#define RDP_SCANCODE_OEM_1 MAKE_RDP_SCANCODE(0x27, FALSE) /* VK_OEM_1 ';' on US */
#define RDP_SCANCODE_OEM_7 MAKE_RDP_SCANCODE(0x28, FALSE) /* VK_OEM_7 "'" on US */
#define RDP_SCANCODE_OEM_3 \
MAKE_RDP_SCANCODE(0x29, FALSE) /* VK_OEM_3 Top left, '`' on US, JP DBE_SBCSCHAR */
#define RDP_SCANCODE_LSHIFT MAKE_RDP_SCANCODE(0x2A, FALSE) /* VK_LSHIFT */
#define RDP_SCANCODE_OEM_5 MAKE_RDP_SCANCODE(0x2B, FALSE) /* VK_OEM_5 Next to Enter, '\' on US */
#define RDP_SCANCODE_KEY_Z MAKE_RDP_SCANCODE(0x2C, FALSE) /* VK_KEY_Z */
#define RDP_SCANCODE_KEY_X MAKE_RDP_SCANCODE(0x2D, FALSE) /* VK_KEY_X */
#define RDP_SCANCODE_KEY_C MAKE_RDP_SCANCODE(0x2E, FALSE) /* VK_KEY_C */
#define RDP_SCANCODE_KEY_V MAKE_RDP_SCANCODE(0x2F, FALSE) /* VK_KEY_V */
#define RDP_SCANCODE_KEY_B MAKE_RDP_SCANCODE(0x30, FALSE) /* VK_KEY_B */
#define RDP_SCANCODE_KEY_N MAKE_RDP_SCANCODE(0x31, FALSE) /* VK_KEY_N */
#define RDP_SCANCODE_KEY_M MAKE_RDP_SCANCODE(0x32, FALSE) /* VK_KEY_M */
#define RDP_SCANCODE_OEM_COMMA MAKE_RDP_SCANCODE(0x33, FALSE) /* VK_OEM_COMMA */
#define RDP_SCANCODE_OEM_PERIOD MAKE_RDP_SCANCODE(0x34, FALSE) /* VK_OEM_PERIOD */
#define RDP_SCANCODE_OEM_2 MAKE_RDP_SCANCODE(0x35, FALSE) /* VK_OEM_2 '/' on US */
#define RDP_SCANCODE_RSHIFT MAKE_RDP_SCANCODE(0x36, FALSE) /* VK_RSHIFT */
#define RDP_SCANCODE_MULTIPLY MAKE_RDP_SCANCODE(0x37, FALSE) /* VK_MULTIPLY Numerical */
#define RDP_SCANCODE_LMENU MAKE_RDP_SCANCODE(0x38, FALSE) /* VK_LMENU Left 'Alt' key */
#define RDP_SCANCODE_SPACE MAKE_RDP_SCANCODE(0x39, FALSE) /* VK_SPACE */
#define RDP_SCANCODE_CAPSLOCK \
MAKE_RDP_SCANCODE(0x3A, FALSE) /* VK_CAPITAL 'Caps Lock', JP DBE_ALPHANUMERIC */
#define RDP_SCANCODE_F1 MAKE_RDP_SCANCODE(0x3B, FALSE) /* VK_F1 */
#define RDP_SCANCODE_F2 MAKE_RDP_SCANCODE(0x3C, FALSE) /* VK_F2 */
#define RDP_SCANCODE_F3 MAKE_RDP_SCANCODE(0x3D, FALSE) /* VK_F3 */
#define RDP_SCANCODE_F4 MAKE_RDP_SCANCODE(0x3E, FALSE) /* VK_F4 */
#define RDP_SCANCODE_F5 MAKE_RDP_SCANCODE(0x3F, FALSE) /* VK_F5 */
#define RDP_SCANCODE_F6 MAKE_RDP_SCANCODE(0x40, FALSE) /* VK_F6 */
#define RDP_SCANCODE_F7 MAKE_RDP_SCANCODE(0x41, FALSE) /* VK_F7 */
#define RDP_SCANCODE_F8 MAKE_RDP_SCANCODE(0x42, FALSE) /* VK_F8 */
#define RDP_SCANCODE_F9 MAKE_RDP_SCANCODE(0x43, FALSE) /* VK_F9 */
#define RDP_SCANCODE_F10 MAKE_RDP_SCANCODE(0x44, FALSE) /* VK_F10 */
#define RDP_SCANCODE_NUMLOCK \
MAKE_RDP_SCANCODE(0x45, FALSE) \
/* VK_NUMLOCK */ /* Note: when this seems to appear in PKBDLLHOOKSTRUCT it means Pause which \
must be sent as Ctrl + NumLock */
#define RDP_SCANCODE_SCROLLLOCK \
MAKE_RDP_SCANCODE(0x46, FALSE) /* VK_SCROLL 'Scroll Lock', JP OEM_SCROLL */
#define RDP_SCANCODE_NUMPAD7 MAKE_RDP_SCANCODE(0x47, FALSE) /* VK_NUMPAD7 */
#define RDP_SCANCODE_NUMPAD8 MAKE_RDP_SCANCODE(0x48, FALSE) /* VK_NUMPAD8 */
#define RDP_SCANCODE_NUMPAD9 MAKE_RDP_SCANCODE(0x49, FALSE) /* VK_NUMPAD9 */
#define RDP_SCANCODE_SUBTRACT MAKE_RDP_SCANCODE(0x4A, FALSE) /* VK_SUBTRACT */
#define RDP_SCANCODE_NUMPAD4 MAKE_RDP_SCANCODE(0x4B, FALSE) /* VK_NUMPAD4 */
#define RDP_SCANCODE_NUMPAD5 MAKE_RDP_SCANCODE(0x4C, FALSE) /* VK_NUMPAD5 */
#define RDP_SCANCODE_NUMPAD6 MAKE_RDP_SCANCODE(0x4D, FALSE) /* VK_NUMPAD6 */
#define RDP_SCANCODE_ADD MAKE_RDP_SCANCODE(0x4E, FALSE) /* VK_ADD */
#define RDP_SCANCODE_NUMPAD1 MAKE_RDP_SCANCODE(0x4F, FALSE) /* VK_NUMPAD1 */
#define RDP_SCANCODE_NUMPAD2 MAKE_RDP_SCANCODE(0x50, FALSE) /* VK_NUMPAD2 */
#define RDP_SCANCODE_NUMPAD3 MAKE_RDP_SCANCODE(0x51, FALSE) /* VK_NUMPAD3 */
#define RDP_SCANCODE_NUMPAD0 MAKE_RDP_SCANCODE(0x52, FALSE) /* VK_NUMPAD0 */
#define RDP_SCANCODE_DECIMAL MAKE_RDP_SCANCODE(0x53, FALSE) /* VK_DECIMAL Numerical, '.' on US */
#define RDP_SCANCODE_SYSREQ MAKE_RDP_SCANCODE(0x54, FALSE) /* Sys Req */
#define RDP_SCANCODE_OEM_102 MAKE_RDP_SCANCODE(0x56, FALSE) /* VK_OEM_102 Lower left '\' on US */
#define RDP_SCANCODE_F11 MAKE_RDP_SCANCODE(0x57, FALSE) /* VK_F11 */
#define RDP_SCANCODE_F12 MAKE_RDP_SCANCODE(0x58, FALSE) /* VK_F12 */
#define RDP_SCANCODE_SLEEP \
MAKE_RDP_SCANCODE(0x5F, FALSE) /* VK_SLEEP OEM_8 on FR (undocumented?) \
*/
#define RDP_SCANCODE_ZOOM MAKE_RDP_SCANCODE(0x62, FALSE) /* VK_ZOOM (undocumented?) */
#define RDP_SCANCODE_HELP MAKE_RDP_SCANCODE(0x63, FALSE) /* VK_HELP (undocumented?) */
#define RDP_SCANCODE_F13 \
MAKE_RDP_SCANCODE(0x64, FALSE) /* VK_F13 */ /* JP agree, should 0x7d according to ms894073 */
#define RDP_SCANCODE_F14 MAKE_RDP_SCANCODE(0x65, FALSE) /* VK_F14 */
#define RDP_SCANCODE_F15 MAKE_RDP_SCANCODE(0x66, FALSE) /* VK_F15 */
#define RDP_SCANCODE_F16 MAKE_RDP_SCANCODE(0x67, FALSE) /* VK_F16 */
#define RDP_SCANCODE_F17 MAKE_RDP_SCANCODE(0x68, FALSE) /* VK_F17 */
#define RDP_SCANCODE_F18 MAKE_RDP_SCANCODE(0x69, FALSE) /* VK_F18 */
#define RDP_SCANCODE_F19 MAKE_RDP_SCANCODE(0x6A, FALSE) /* VK_F19 */
#define RDP_SCANCODE_F20 MAKE_RDP_SCANCODE(0x6B, FALSE) /* VK_F20 */
#define RDP_SCANCODE_F21 MAKE_RDP_SCANCODE(0x6C, FALSE) /* VK_F21 */
#define RDP_SCANCODE_F22 MAKE_RDP_SCANCODE(0x6D, FALSE) /* VK_F22 */
#define RDP_SCANCODE_F23 MAKE_RDP_SCANCODE(0x6E, FALSE) /* VK_F23 */ /* JP agree */
#define RDP_SCANCODE_F24 \
MAKE_RDP_SCANCODE(0x6F, FALSE) /* VK_F24 */ /* 0x87 according to ms894073 */
#define RDP_SCANCODE_HIRAGANA MAKE_RDP_SCANCODE(0x70, FALSE) /* JP DBE_HIRAGANA */
#define RDP_SCANCODE_HANJA_KANJI \
MAKE_RDP_SCANCODE(0x71, FALSE) /* VK_HANJA / VK_KANJI (undocumented?) */
#define RDP_SCANCODE_KANA_HANGUL \
MAKE_RDP_SCANCODE(0x72, FALSE) /* VK_KANA / VK_HANGUL (undocumented?) */
#define RDP_SCANCODE_ABNT_C1 MAKE_RDP_SCANCODE(0x73, FALSE) /* VK_ABNT_C1 JP OEM_102 */
#define RDP_SCANCODE_F24_JP MAKE_RDP_SCANCODE(0x76, FALSE) /* JP F24 */
#define RDP_SCANCODE_CONVERT_JP MAKE_RDP_SCANCODE(0x79, FALSE) /* JP VK_CONVERT */
#define RDP_SCANCODE_NONCONVERT_JP MAKE_RDP_SCANCODE(0x7B, FALSE) /* JP VK_NONCONVERT */
#define RDP_SCANCODE_TAB_JP MAKE_RDP_SCANCODE(0x7C, FALSE) /* JP TAB */
#define RDP_SCANCODE_BACKSLASH_JP MAKE_RDP_SCANCODE(0x7D, FALSE) /* JP OEM_5 ('\') */
#define RDP_SCANCODE_ABNT_C2 MAKE_RDP_SCANCODE(0x7E, FALSE) /* VK_ABNT_C2, JP */
#define RDP_SCANCODE_HANJA MAKE_RDP_SCANCODE(0x71, FALSE) /* KR VK_HANJA */
#define RDP_SCANCODE_HANGUL MAKE_RDP_SCANCODE(0x72, FALSE) /* KR VK_HANGUL */
#define RDP_SCANCODE_RETURN_KP \
MAKE_RDP_SCANCODE(0x1C, TRUE) /* not RDP_SCANCODE_RETURN Numerical Enter */
#define RDP_SCANCODE_RCONTROL MAKE_RDP_SCANCODE(0x1D, TRUE) /* VK_RCONTROL */
#define RDP_SCANCODE_DIVIDE MAKE_RDP_SCANCODE(0x35, TRUE) /* VK_DIVIDE Numerical */
#define RDP_SCANCODE_PRINTSCREEN \
MAKE_RDP_SCANCODE(0x37, TRUE) /* VK_EXECUTE/VK_PRINT/VK_SNAPSHOT Print Screen */
#define RDP_SCANCODE_RMENU MAKE_RDP_SCANCODE(0x38, TRUE) /* VK_RMENU Right 'Alt' / 'Alt Gr' */
#define RDP_SCANCODE_PAUSE \
MAKE_RDP_SCANCODE(0x46, TRUE) /* VK_PAUSE Pause / Break (Slightly special handling) */
#define RDP_SCANCODE_HOME MAKE_RDP_SCANCODE(0x47, TRUE) /* VK_HOME */
#define RDP_SCANCODE_UP MAKE_RDP_SCANCODE(0x48, TRUE) /* VK_UP */
#define RDP_SCANCODE_PRIOR MAKE_RDP_SCANCODE(0x49, TRUE) /* VK_PRIOR 'Page Up' */
#define RDP_SCANCODE_LEFT MAKE_RDP_SCANCODE(0x4B, TRUE) /* VK_LEFT */
#define RDP_SCANCODE_RIGHT MAKE_RDP_SCANCODE(0x4D, TRUE) /* VK_RIGHT */
#define RDP_SCANCODE_END MAKE_RDP_SCANCODE(0x4F, TRUE) /* VK_END */
#define RDP_SCANCODE_DOWN MAKE_RDP_SCANCODE(0x50, TRUE) /* VK_DOWN */
#define RDP_SCANCODE_NEXT MAKE_RDP_SCANCODE(0x51, TRUE) /* VK_NEXT 'Page Down' */
#define RDP_SCANCODE_INSERT MAKE_RDP_SCANCODE(0x52, TRUE) /* VK_INSERT */
#define RDP_SCANCODE_DELETE MAKE_RDP_SCANCODE(0x53, TRUE) /* VK_DELETE */
#define RDP_SCANCODE_NULL MAKE_RDP_SCANCODE(0x54, TRUE) /* <00> */
#define RDP_SCANCODE_HELP2 \
MAKE_RDP_SCANCODE(0x56, TRUE) /* Help - documented, different from VK_HELP */
#define RDP_SCANCODE_LWIN MAKE_RDP_SCANCODE(0x5B, TRUE) /* VK_LWIN */
#define RDP_SCANCODE_RWIN MAKE_RDP_SCANCODE(0x5C, TRUE) /* VK_RWIN */
#define RDP_SCANCODE_APPS MAKE_RDP_SCANCODE(0x5D, TRUE) /* VK_APPS Application */
#define RDP_SCANCODE_POWER_JP MAKE_RDP_SCANCODE(0x5E, TRUE) /* JP POWER */
#define RDP_SCANCODE_SLEEP_JP MAKE_RDP_SCANCODE(0x5F, TRUE) /* JP SLEEP */
/* _not_ valid scancode, but this is what a windows PKBDLLHOOKSTRUCT for NumLock contains */
#define RDP_SCANCODE_NUMLOCK_EXTENDED \
MAKE_RDP_SCANCODE(0x45, TRUE) /* should be RDP_SCANCODE_NUMLOCK */
#define RDP_SCANCODE_RSHIFT_EXTENDED \
MAKE_RDP_SCANCODE(0x36, TRUE) /* should be RDP_SCANCODE_RSHIFT */
/* Audio */
#define RDP_SCANCODE_VOLUME_MUTE MAKE_RDP_SCANCODE(0x20, TRUE) /* VK_VOLUME_MUTE */
#define RDP_SCANCODE_VOLUME_DOWN MAKE_RDP_SCANCODE(0x2E, TRUE) /* VK_VOLUME_DOWN */
#define RDP_SCANCODE_VOLUME_UP MAKE_RDP_SCANCODE(0x30, TRUE) /* VK_VOLUME_UP */
/* Media */
#define RDP_SCANCODE_MEDIA_NEXT_TRACK MAKE_RDP_SCANCODE(0x19, TRUE) /* VK_MEDIA_NEXT_TRACK */
#define RDP_SCANCODE_MEDIA_PREV_TRACK MAKE_RDP_SCANCODE(0x10, TRUE) /* VK_MEDIA_PREV_TRACK */
#define RDP_SCANCODE_MEDIA_STOP MAKE_RDP_SCANCODE(0x24, TRUE) /* VK_MEDIA_MEDIA_STOP */
#define RDP_SCANCODE_MEDIA_PLAY_PAUSE \
MAKE_RDP_SCANCODE(0x22, TRUE) /* VK_MEDIA_MEDIA_PLAY_PAUSE \
*/
/* Browser functions */
#define RDP_SCANCODE_BROWSER_BACK MAKE_RDP_SCANCODE(0x6A, TRUE) /* VK_BROWSER_BACK */
#define RDP_SCANCODE_BROWSER_FORWARD MAKE_RDP_SCANCODE(0x69, TRUE) /* VK_BROWSER_FORWARD */
#define RDP_SCANCODE_BROWSER_REFRESH MAKE_RDP_SCANCODE(0x67, TRUE) /* VK_BROWSER_REFRESH */
#define RDP_SCANCODE_BROWSER_STOP MAKE_RDP_SCANCODE(0x68, TRUE) /* VK_BROWSER_STOP */
#define RDP_SCANCODE_BROWSER_SEARCH MAKE_RDP_SCANCODE(0x65, TRUE) /* VK_BROWSER_SEARCH */
#define RDP_SCANCODE_BROWSER_FAVORITES MAKE_RDP_SCANCODE(0x66, TRUE) /* VK_BROWSER_FAVORITES */
#define RDP_SCANCODE_BROWSER_HOME MAKE_RDP_SCANCODE(0x32, TRUE) /* VK_BROWSER_HOME */
/* Misc. */
#define RDP_SCANCODE_LAUNCH_MAIL MAKE_RDP_SCANCODE(0x6C, TRUE) /* VK_LAUNCH_MAIL */
#define RDP_SCANCODE_LAUNCH_MEDIA_SELECT \
MAKE_RDP_SCANCODE(0x6D, TRUE) /* VK_LAUNCH_MEDIA_SELECT \
*/
#define RDP_SCANCODE_LAUNCH_APP1 MAKE_RDP_SCANCODE(0x6E, TRUE) /* VK_LAUNCH_APP1 */
#define RDP_SCANCODE_LAUNCH_APP2 MAKE_RDP_SCANCODE(0x6F, TRUE) /* VK_LAUNCH_APP2 */
#endif /* FREERDP_LOCALE_KEYBOARD_RDP_SCANCODE_H */
| 7,607 |
882 | {
"keys": [
{
"kty": "RSA",
"alg": "RS256",
"use": "sig",
"kid": "ab844f3d4c69feee0de2501b04e1a4c8d78eead1",
"n": "<KEY>",
"e": "AQAB"
},
{
"kty": "RSA",
"alg": "RS256",
"use": "sig",
"kid": "550326e0aacb4674d22905a1a51a808cfa7463b0",
"n": "<KEY>",
"e": "AQAB"
}
]
}
| 195 |
412 | #include <assert.h>
#include <inttypes.h>
#include <math.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdlib.h>
int main()
{
int8_t i1 = 2;
int16_t i2 = 3;
int32_t i3 = 4;
int64_t i4 = 5;
int8_t in1 = -2;
int16_t in2 = -3;
int32_t in3 = -4;
int64_t in4 = -5;
uint8_t u8 = 'a';
uint16_t u16 = 8;
uint32_t u32 = 16;
uint64_t u64 = 32;
void *ptr = malloc(1);
assert(false);
return 0;
}
| 222 |
324 | <reponame>cclauss/vergeml<gh_stars>100-1000
PARAM_DESCR = {
'epochs': 'How many epochs to train.',
'learning rate': 'Optimizer learning rate.',
'batch size': 'The number of samples to use in one training batch.',
'decay': 'Learning rate decay.',
'early stopping': 'Early stopping delta and patience.',
'dropout': 'Dropout rate.',
'layers': 'The number of hidden layers.',
'optimizer': 'Which optimizer to use.'
}
LONG_DESCR = {
'learning rate': 'A hyperparameter which determines how quickly new learnings override old ones during training. In general, find a learning rate that is low enough that the network will converge to something useful, but high enough that the training does not take too much time.',
'batch size': 'Defines the number of samples to be propagated through the network at once in a batch. The higher the batch size, the more memory you will need.',
'epochs': 'The number of epochs define how often the network will see the complete set of samples during training.',
'decay': 'When using learning rate decay, the learning rate is gradually reduced during training which may result in getting closer to the optimal performance.',
'early stopping': 'Early Stopping is a form of regularization used to avoid overfitting when training. It is controlled via two parameters: Delta defines the minimum change in the monitored quantity to qualify as an improvement. Patience sets the number of epochs with no improvement after which training will be stopped.',
'dropout': 'Dropout is a regularization technique for reducing overfitting in neural networks, The term "dropout" refers to dropping out units (both hidden and visible) in a neural network during training.',
'layers': 'Deep learning models consist of a number of layers which contain one or more neurons. Typically, the neurons in one layer are connected to the next. Models with a higher number of layers can learn more complex representations, but are also more prone to overfitting.',
'optimizer': 'The algorithm which updates model parameters such as the weight and bias values when training the network.',
'sgd': 'Stochastic gradient descent, also known as incremental gradient descent, is a method for optimizing a neural network. It is called stochastic because samples are selected randomly instead of as a single group, as in standard gradient descent.',
'adam': 'The Adam optimization algorithm is an extension to stochastic gradient descent which computes adaptive learning rates for each parameter. Adam is well suited for many practical deep learning problems.',
'environment variables': """\
The following environment variables are available in VergeML:
- VERGEML_PERSISTENCE The number of persistent instances
- VERGEML_THEME The theme of the command line application
- VERGEML_FUNKY_ROBOTS Funky robots""",
"overfitting": "When a model performs well on the training samples, but is not able to generalize well to unseen data. During training, a typical sign for overfitting is when your validation loss goes up while your training loss goes down.",
"underfitting": "When a model can neither model the training data nor generalize to new data.",
"hyperparameters": "Hyperparameters are the parameters of a model that can be set from outside, i.e. are not learned during training. (e.g. learning rate, number of layers, kernel size).",
"random seed": "An integer value that seeds the random generator to generate random values. It is used to repeatably reproduce tasks and experiments.",
"project": "A VergeML project is just a directory. Typically it contains a vergeml.yaml file, a trainings directory and a samples directory.",
'project file': "A YAML file you can use to configure models, device usage, data processing and taks options.",
'checkpoint': 'A checkpoint is a static image of a trained AI. It can be used to restore the AI after training and make predictions.',
'stats': 'Stats are used to measure the performance of a model (e.g. accuracy).',
'samples': 'Samples are pieces of data (e.g. images, texts) that is being used to train models to create AIs.',
'val split': "Samples different from training samples that are used to evaluate the performance of model hyperparameters. You can set it via the --val-split option. See 'ml help split'.",
'test split': "Samples different from training samples that are used to evaluate the final performance of the model. You can set it via the --test-split option. See 'ml help split'.",
'split': 'split is a part of the sample data reserved for validation and testing (--val-split and --test-split options). It can be configured as either a percentage value (e.g. --val-split=10%) to reserve a fraction of training samples, a number to reserve a fixed number of samples, or a directory where the samples of the split are stored.',
'cache dir': 'A directory which contains the processed data.',
}
SYNONYMS = {
'stochastic gradient descent': 'sgd',
'hyperparameter': 'hyperparameters',
'project dir': 'project',
'training samples': 'samples',
'overfit': 'overfitting',
'underfit': 'underfitting'
}
def long_descr(key):
key = key.replace("-", " ")
key = SYNONYMS.get(key, key)
return LONG_DESCR.get(key, "").strip()
def short_param_descr(key):
key = key.replace("-", " ")
key = SYNONYMS.get(key, key)
return PARAM_DESCR.get(key, "").strip()
| 1,454 |
348 | {"nom":"<NAME>","circ":"5ème circonscription","dpt":"Seine-Maritime","inscrits":518,"abs":252,"votants":266,"blancs":0,"nuls":1,"exp":265,"res":[{"nuance":"SOC","nom":"<NAME>","voix":150},{"nuance":"LR","nom":"<NAME>","voix":43},{"nuance":"FN","nom":"<NAME>","voix":34},{"nuance":"FI","nom":"Mme <NAME>","voix":29},{"nuance":"ECO","nom":"M. <NAME>","voix":6},{"nuance":"EXG","nom":"<NAME>","voix":2},{"nuance":"DIV","nom":"<NAME>","voix":1},{"nuance":"DVG","nom":"M. <NAME>","voix":0}]} | 197 |
3,442 | from mmdnn.conversion.rewriter.rewriter import UnitRewriterBase
import numpy as np
import re
class LSTMRewriter(UnitRewriterBase):
def __init__(self, graph, weights_dict):
return super(LSTMRewriter, self).__init__(graph, weights_dict)
def process_lstm_cell(self, match_result):
if 'lstm_cell' not in match_result._pattern_to_op.keys():
return
kwargs = dict()
top_node = match_result._pattern_to_op[match_result._name_to_pattern['lstm_cell']]
w_e = match_result.get_op("cell_kernel")
w = self._weights_dict[w_e.name.replace('/read', '')]
num_units = w.shape[1]//4
[wx, wh] = np.split(w, [-1 * num_units])
input_size = wx.shape[0]
kwargs['num_units'] = num_units
kwargs['input_size'] = input_size
if hasattr(top_node, 'kwargs'):
top_node.kwargs.update(kwargs)
else:
top_node.kwargs = kwargs
def process_rnn_h_zero(self, match_result):
if 'h_zero' not in match_result._name_to_pattern.keys():
return
kwargs = dict()
top_node = match_result._pattern_to_op[match_result._name_to_pattern['h_zero']]
fill_size = match_result.get_op('fill_size')
fill_value = match_result.get_op('fill_value')
kwargs['fill_size'] = fill_size.get_attr('value').int_val[0]
kwargs['fill_value'] = fill_value.get_attr('value').float_val[0]
if hasattr(top_node, 'kwargs'):
top_node.kwargs.update(kwargs)
else:
top_node.kwargs = kwargs
def process_match_result(self, match_result, pattern_name):
if pattern_name == 'lstm_cell':
self.process_lstm_cell(match_result)
elif pattern_name == 'h_zero':
if self.check_match_scope(match_result, 'LSTMCellZeroState'):
self.process_rnn_h_zero(match_result)
'''For some short pattern, to avoid match other pattern, check it's scope'''
def check_match_scope(self, match_result, scope_name):
ops = match_result._pattern_to_op.values()
for op in ops:
op_name_splits = op.name.split('/')
if len(op_name_splits) < 2:
return False
if re.sub(r'(_\d+)*$', '', op_name_splits[-2]) != scope_name:
if len(op_name_splits) > 2:
if re.sub(r'(_\d+)*$', '', op_name_splits[-3]) != scope_name:
return False
else:
return False
return True
def run(self):
return super(LSTMRewriter, self).run(['lstm_cell', 'h_zero'], 'tensorflow') | 1,302 |
1,655 | <filename>Example_oc/Pods/Headers/Public/FlexLib/FlexBaseVC.h
/**
* Copyright (c) 2017-present, zhenglibao, Inc.
* email: <EMAIL>
* All rights reserved.
*
* This source code is licensed under the MIT-style license found in the
* LICENSE file in the root directory of this source tree.
*/
#import <UIKit/UIKit.h>
@class FlexRootView;
@interface FlexBaseVC : UIViewController<UITextFieldDelegate,UITextViewDelegate>
@property(nonatomic,readonly) FlexRootView* rootView;
//自动躲避键盘
@property(nonatomic,assign) BOOL avoidKeyboard;
@property(nonatomic,readonly) float keyboardHeight;
//是否避开iPhoneX底部区域,默认是YES
@property(nonatomic,assign) BOOL avoidiPhoneXBottom;
//是否保持navibar透明，默认为yes,该属性会影响页面布局,如果
//navibar的translucent属性为NO，则可能需要重写getSafeArea来修正布局
@property(nonatomic,assign) BOOL keepNavbarTranslucent;
// call this to provide flex res name
-(instancetype)initWithFlexName:(NSString*)flexName;
// override this to provide flex res name
-(NSString*)getFlexName;
// find the view with viewName in xml layout
-(UIView*)findByName:(NSString*)viewName;
// 支持热更新
- (void)resetByFlexData:(NSData*)flexData;
// override this to do something when xml updated
-(void)onLayoutReload;
// override this to provide status bar height
-(CGFloat)getStatusBarHeight:(BOOL)portrait;
// override this to provide different safeArea
- (UIEdgeInsets)getSafeArea:(BOOL)portrait;
-(void)layoutFlexRootViews;
// 查找view所在的最近一层的scrollview
-(UIScrollView*)scrollViewOfControl:(UIView*)view;
//scroll滚动到可见区域,该view必须位于UIScrollView上
-(void)scrollViewToVisible:(UIView*)view
animated:(BOOL)bAnim;
// derived class call this to prepare inputs
-(void)prepareInputs;
// override to submit form
-(void)submitForm;
@end
| 744 |
675 | <reponame>Canva/intellij
/*
* Copyright 2016 The Bazel 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.
*/
package com.google.idea.blaze.java.sync.projectstructure;
import static com.google.common.truth.Truth.assertThat;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.idea.blaze.base.BlazeIntegrationTestCase;
import com.google.idea.blaze.base.model.primitives.WorkspacePath;
import com.google.idea.blaze.base.projectview.section.Glob.GlobSet;
import com.google.idea.blaze.java.sync.importer.emptylibrary.EmptyJarTracker;
import com.google.idea.blaze.java.sync.model.BlazeContentEntry;
import com.google.idea.blaze.java.sync.model.BlazeJavaImportResult;
import com.google.idea.blaze.java.sync.model.BlazeJavaSyncData;
import com.google.idea.blaze.java.sync.model.BlazeSourceDirectory;
import com.intellij.openapi.Disposable;
import com.intellij.openapi.roots.ContentEntry;
import com.intellij.openapi.roots.ModuleRootManager;
import com.intellij.openapi.roots.SourceFolder;
import com.intellij.openapi.util.Disposer;
import com.intellij.openapi.vfs.VirtualFile;
import java.io.File;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
/** Tests for {@link JavaSourceFolderProvider} */
@RunWith(JUnit4.class)
public class JavaSourceFolderProviderTest extends BlazeIntegrationTestCase {
private Disposable thisClassDisposable; // disposed prior to calling parent class's @After methods
@Before
public void doSetup() {
thisClassDisposable = Disposer.newDisposable();
}
@After
public void doTearDown() {
Disposer.dispose(thisClassDisposable);
}
@Test
public void testInitializeSourceFolders() {
ImmutableList<BlazeContentEntry> contentEntries =
ImmutableList.of(
BlazeContentEntry.builder("/src/workspace/java/apps")
.addSource(
BlazeSourceDirectory.builder("/src/workspace/java/apps")
.setPackagePrefix("apps")
.build())
.addSource(
BlazeSourceDirectory.builder("/src/workspace/java/apps/gen")
.setPackagePrefix("apps.gen")
.setGenerated(true)
.build())
.addSource(
BlazeSourceDirectory.builder("/src/workspace/java/apps/resources")
.setPackagePrefix("apps.resources")
.setResource(true)
.build())
.build(),
BlazeContentEntry.builder("/src/workspace/javatests/apps/example")
.addSource(
BlazeSourceDirectory.builder("/src/workspace/javatests/apps/example")
.setPackagePrefix("apps.example")
.build())
.build());
JavaSourceFolderProvider provider =
new JavaSourceFolderProvider(
new BlazeJavaSyncData(
BlazeJavaImportResult.builder()
.setContentEntries(contentEntries)
.setLibraries(ImmutableMap.of())
.setBuildOutputJars(ImmutableList.of())
.setJavaSourceFiles(ImmutableSet.of())
.setSourceVersion(null)
.setEmptyJarTracker(EmptyJarTracker.builder().build())
.setPluginProcessorJars(ImmutableSet.of())
.build(),
new GlobSet(ImmutableList.of())));
VirtualFile root = workspace.createDirectory(new WorkspacePath("java/apps"));
VirtualFile gen = workspace.createDirectory(new WorkspacePath("java/apps/gen"));
VirtualFile res = workspace.createDirectory(new WorkspacePath("java/apps/resources"));
ImmutableMap<File, SourceFolder> sourceFolders =
provider.initializeSourceFolders(getContentEntry(root));
assertThat(sourceFolders).hasSize(3);
SourceFolder rootSource = sourceFolders.get(new File(root.getPath()));
assertThat(rootSource.getPackagePrefix()).isEqualTo("apps");
assertThat(JavaSourceFolderProvider.isGenerated(rootSource)).isFalse();
assertThat(JavaSourceFolderProvider.isResource(rootSource)).isFalse();
SourceFolder genSource = sourceFolders.get(new File(gen.getPath()));
assertThat(genSource.getPackagePrefix()).isEqualTo("apps.gen");
assertThat(JavaSourceFolderProvider.isGenerated(genSource)).isTrue();
assertThat(JavaSourceFolderProvider.isResource(genSource)).isFalse();
SourceFolder resSource = sourceFolders.get(new File(res.getPath()));
assertThat(JavaSourceFolderProvider.isGenerated(resSource)).isFalse();
assertThat(JavaSourceFolderProvider.isResource(resSource)).isTrue();
VirtualFile testRoot = workspace.createDirectory(new WorkspacePath("javatests/apps/example"));
sourceFolders = provider.initializeSourceFolders(getContentEntry(testRoot));
assertThat(sourceFolders).hasSize(1);
assertThat(sourceFolders.get(new File(testRoot.getPath())).getPackagePrefix())
.isEqualTo("apps.example");
}
@Test
public void testRelativePackagePrefix() {
ImmutableList<BlazeContentEntry> contentEntries =
ImmutableList.of(
BlazeContentEntry.builder("/src/workspace/java/apps")
.addSource(
BlazeSourceDirectory.builder("/src/workspace/java/apps")
.setPackagePrefix("apps")
.build())
.build());
JavaSourceFolderProvider provider =
new JavaSourceFolderProvider(
new BlazeJavaSyncData(
BlazeJavaImportResult.builder()
.setContentEntries(contentEntries)
.setLibraries(ImmutableMap.of())
.setBuildOutputJars(ImmutableList.of())
.setJavaSourceFiles(ImmutableSet.of())
.setSourceVersion(null)
.setEmptyJarTracker(EmptyJarTracker.builder().build())
.setPluginProcessorJars(ImmutableSet.of())
.build(),
new GlobSet(ImmutableList.of())));
VirtualFile root = workspace.createDirectory(new WorkspacePath("java/apps"));
ContentEntry contentEntry = getContentEntry(root);
ImmutableMap<File, SourceFolder> sourceFolders = provider.initializeSourceFolders(contentEntry);
assertThat(sourceFolders).hasSize(1);
VirtualFile testRoot = workspace.createDirectory(new WorkspacePath("java/apps/tests/model"));
SourceFolder testSourceChild =
provider.setSourceFolderForLocation(
contentEntry,
sourceFolders.get(new File(root.getPath())),
new File(testRoot.getPath()),
true);
assertThat(testSourceChild.isTestSource()).isTrue();
assertThat(testSourceChild.getPackagePrefix()).isEqualTo("apps.tests.model");
}
@Test
public void testRelativePackagePrefixWithoutParentPrefix() {
ImmutableList<BlazeContentEntry> contentEntries =
ImmutableList.of(
BlazeContentEntry.builder("/src/workspace/java")
.addSource(
BlazeSourceDirectory.builder("/src/workspace/java")
.setPackagePrefix("")
.build())
.build());
JavaSourceFolderProvider provider =
new JavaSourceFolderProvider(
new BlazeJavaSyncData(
BlazeJavaImportResult.builder()
.setContentEntries(contentEntries)
.setLibraries(ImmutableMap.of())
.setBuildOutputJars(ImmutableList.of())
.setJavaSourceFiles(ImmutableSet.of())
.setSourceVersion(null)
.setEmptyJarTracker(EmptyJarTracker.builder().build())
.setPluginProcessorJars(ImmutableSet.of())
.build(),
new GlobSet(ImmutableList.of())));
VirtualFile root = workspace.createDirectory(new WorkspacePath("java"));
ContentEntry contentEntry = getContentEntry(root);
ImmutableMap<File, SourceFolder> sourceFolders = provider.initializeSourceFolders(contentEntry);
assertThat(sourceFolders).hasSize(1);
VirtualFile testRoot = workspace.createDirectory(new WorkspacePath("java/apps/tests"));
SourceFolder testSourceChild =
provider.setSourceFolderForLocation(
contentEntry,
sourceFolders.get(new File(root.getPath())),
new File(testRoot.getPath()),
true);
assertThat(testSourceChild.isTestSource()).isTrue();
assertThat(testSourceChild.getPackagePrefix()).isEqualTo("apps.tests");
}
private ContentEntry getContentEntry(VirtualFile root) {
ContentEntry entry =
ModuleRootManager.getInstance(testFixture.getModule())
.getModifiableModel()
.addContentEntry(root);
if (entry instanceof Disposable) {
// need to dispose the content entry and child disposables before the TestFixture is disposed
Disposer.register(thisClassDisposable, (Disposable) entry);
}
return entry;
}
}
| 4,036 |
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.tax;
import org.netbeans.tax.TreeElementDecl.ContentType;
import org.netbeans.tests.xml.XTest;
import org.openide.util.Utilities;
abstract class AbstractFactoryTest extends XTest {
final private static String NOT_EXCEPTION = "The InvalidArgumetException wasn't throwed ";
public AbstractFactoryTest(String testName) {
super(testName);
}
//--------------------------------------------------------------------------
static TreeAttlistDecl createAttlistDecl(java.lang.String string, String view) throws Exception {
TreeAttlistDecl node = new TreeAttlistDecl(string);
assertEquals(node, view);
cloneNodeTest(node, view);
return node;
}
static void createAttlistDeclInvalid(java.lang.String string) throws Exception {
try {
new TreeAttlistDecl(string);
// Fail if previous line doesn't trhow exception.
fail(NOT_EXCEPTION + "from: new TreeAttlistDecl(string)");
} catch (InvalidArgumentException e) {
// OK
}
}
//--------------------------------------------------------------------------
static TreeAttribute createAttribute(java.lang.String string, java.lang.String string1, boolean boolean_val, String view) throws Exception {
TreeAttribute node = new TreeAttribute(string, string1, boolean_val);
assertEquals(node, view);
cloneNodeTest(node, view);
return node;
}
static void createAttributeInvalid(java.lang.String string, java.lang.String string1, boolean boolean_val) throws Exception {
try {
new TreeAttribute(string, string1, boolean_val);
// Fail if previous line doesn't trhow exception.
fail(NOT_EXCEPTION + "from: new TreeAttribute(string, string1, boolean_val)");
} catch (InvalidArgumentException e) {
// OK
}
}
//--------------------------------------------------------------------------
static TreeAttribute createAttribute(java.lang.String string, java.lang.String string1, String view) throws Exception {
TreeAttribute node = new TreeAttribute(string, string1);
assertEquals(node, view);
cloneNodeTest(node, view);
return node;
}
static void createAttributeInvalid(java.lang.String string, java.lang.String string1) throws Exception {
try {
new TreeAttribute(string, string1);
// Fail if previous line doesn't trhow exception.
fail(NOT_EXCEPTION + "from: new TreeAttribute(string, string1)");
} catch (InvalidArgumentException e) {
// OK
}
}
//--------------------------------------------------------------------------
static TreeCDATASection createCDATASection(java.lang.String string, String view) throws Exception {
TreeCDATASection node = new TreeCDATASection(string);
assertEquals(node, view);
cloneNodeTest(node, view);
return node;
}
static void createCDATASectionInvalid(java.lang.String string) throws Exception {
try {
new TreeCDATASection(string);
// Fail if previous line doesn't trhow exception.
fail(NOT_EXCEPTION + "from: new TreeCDATASection(string)");
} catch (InvalidArgumentException e) {
// OK
}
}
//--------------------------------------------------------------------------
static TreeCharacterReference createCharacterReference(java.lang.String string, String view) throws Exception {
TreeCharacterReference node = new TreeCharacterReference(string);
assertEquals(node, view);
cloneNodeTest(node, view);
return node;
}
static void createCharacterReferenceInvalid(java.lang.String string) throws Exception {
try {
new TreeCharacterReference(string);
// Fail if previous line doesn't trhow exception.
fail(NOT_EXCEPTION + "from: new TreeCharacterReference(string)");
} catch (InvalidArgumentException e) {
// OK
}
}
//--------------------------------------------------------------------------
static TreeComment createComment(java.lang.String string, String view) throws Exception {
TreeComment node = new TreeComment(string);
assertEquals(node, view);
cloneNodeTest(node, view);
return node;
}
static void createCommentInvalid(java.lang.String string) throws Exception {
try {
new TreeComment(string);
// Fail if previous line doesn't trhow exception.
fail(NOT_EXCEPTION + "from: new TreeComment(string)");
} catch (InvalidArgumentException e) {
// OK
}
}
//--------------------------------------------------------------------------
static TreeConditionalSection createConditionalSection(boolean boolean_val, String view) throws Exception {
TreeConditionalSection node = new TreeConditionalSection(boolean_val);
assertEquals(node, view);
cloneNodeTest(node, view);
return node;
}
//--------------------------------------------------------------------------
static TreeDTD createDTD(java.lang.String string, java.lang.String string1, String view) throws Exception {
TreeDTD node = new TreeDTD(string, string1);
assertEquals(node, view);
cloneNodeTest(node, view);
return node;
}
static void createDTDInvalid(java.lang.String string, java.lang.String string1) throws Exception {
try {
new TreeDTD(string, string1);
// Fail if previous line doesn't trhow exception.
fail(NOT_EXCEPTION + "from: new TreeDTD(string, string1)");
} catch (InvalidArgumentException e) {
// OK
}
}
//--------------------------------------------------------------------------
static TreeDocument createDocument(java.lang.String string, java.lang.String string1, java.lang.String string2, String view) throws Exception {
TreeDocument node = new TreeDocument(string, string1, string2);
assertEquals(node, view);
cloneNodeTest(node, view);
return node;
}
static void createDocumentInvalid(java.lang.String string, java.lang.String string1, java.lang.String string2) throws Exception {
try {
new TreeDocument(string, string1, string2);
// Fail if previous line doesn't trhow exception.
fail(NOT_EXCEPTION + "from: new TreeDocument(string, string1, string2)");
} catch (InvalidArgumentException e) {
// OK
}
}
//--------------------------------------------------------------------------
static TreeDocumentFragment createDocumentFragment(java.lang.String string, java.lang.String string1, String view) throws Exception {
TreeDocumentFragment node = new TreeDocumentFragment(string, string1);
assertEquals(node, view);
cloneNodeTest(node, view);
return node;
}
static void createDocumentFragmentInvalid(java.lang.String string, java.lang.String string1) throws Exception {
try {
new TreeDocumentFragment(string, string1);
// Fail if previous line doesn't trhow exception.
fail(NOT_EXCEPTION + "from: new TreeDocumentFragment(string, string1)");
} catch (InvalidArgumentException e) {
// OK
}
}
//--------------------------------------------------------------------------
static TreeDocumentType createDocumentType(java.lang.String string, java.lang.String string1, java.lang.String string2, String view) throws Exception {
TreeDocumentType node = new TreeDocumentType(string, string1, string2);
assertEquals(node, view);
cloneNodeTest(node, view);
return node;
}
static void createDocumentTypeInvalid(java.lang.String string, java.lang.String string1, java.lang.String string2) throws Exception {
try {
new TreeDocumentType(string, string1, string2);
// Fail if previous line doesn't trhow exception.
fail(NOT_EXCEPTION + "from: new TreeDocumentType(string, string1, string2)");
} catch (InvalidArgumentException e) {
// OK
}
}
//--------------------------------------------------------------------------
static TreeDocumentType createDocumentType(java.lang.String string, String view) throws Exception {
TreeDocumentType node = new TreeDocumentType(string);
assertEquals(node, view);
cloneNodeTest(node, view);
return node;
}
static void createDocumentTypeInvalid(java.lang.String string) throws Exception {
try {
new TreeDocumentType(string);
// Fail if previous line doesn't trhow exception.
fail(NOT_EXCEPTION + "from: new TreeDocumentType(string)");
} catch (InvalidArgumentException e) {
// OK
}
}
//--------------------------------------------------------------------------
static TreeElement createElement(java.lang.String string, boolean boolean_val, String view) throws Exception {
TreeElement node = new TreeElement(string, boolean_val);
assertEquals(node, view);
cloneNodeTest(node, view);
return node;
}
static void createElementInvalid(java.lang.String string, boolean boolean_val) throws Exception {
try {
new TreeElement(string, boolean_val);
// Fail if previous line doesn't trhow exception.
fail(NOT_EXCEPTION + "from: new TreeElement(string, boolean_val)");
} catch (InvalidArgumentException e) {
// OK
}
}
//--------------------------------------------------------------------------
static TreeElement createElement(java.lang.String string, String view) throws Exception {
TreeElement node = new TreeElement(string);
assertEquals(node, view);
cloneNodeTest(node, view);
return node;
}
static void createElementInvalid(java.lang.String string) throws Exception {
try {
new TreeElement(string);
// Fail if previous line doesn't trhow exception.
fail(NOT_EXCEPTION + "from: new TreeElement(string)");
} catch (InvalidArgumentException e) {
// OK
}
}
//--------------------------------------------------------------------------
static TreeElementDecl createElementDecl(java.lang.String string, ContentType treeelementdecl$contenttype, String view) throws Exception {
TreeElementDecl node = new TreeElementDecl(string, treeelementdecl$contenttype);
assertEquals(node, view);
cloneNodeTest(node, view);
return node;
}
static void createElementDeclInvalid(java.lang.String string, ContentType treeelementdecl$contenttype) throws Exception {
try {
new TreeElementDecl(string, treeelementdecl$contenttype);
// Fail if previous line doesn't trhow exception.
fail(NOT_EXCEPTION + "from: new TreeElementDecl(string, treeelementdecl$contenttype)");
} catch (InvalidArgumentException e) {
// OK
}
}
//--------------------------------------------------------------------------
/*
static TreeElementDecl createElementDecl(java.lang.String string, java.lang.String string1, String view) throws Exception {
TreeElementDecl node = new TreeElementDecl(string, string1);
assertEquals(node, view);
cloneNodeTest(node, view);
return node;
}
static void createElementDeclInvalid(java.lang.String string, java.lang.String string1) throws Exception {
try {
new TreeElementDecl(string, string1);
// Fail if previous line doesn't trhow exception.
fail(NOT_EXCEPTION + "from: new TreeElementDecl(string, string1)");
} catch (InvalidArgumentException e) {
// OK
}
}
*/
//--------------------------------------------------------------------------
static TreeEntityDecl createEntityDecl(boolean boolean_val, java.lang.String string, java.lang.String string2, String view) throws Exception {
TreeEntityDecl node = new TreeEntityDecl(boolean_val, string, string2);
assertEquals(node, view);
cloneNodeTest(node, view);
return node;
}
static void createEntityDeclInvalid(boolean boolean_val, java.lang.String string, java.lang.String string2) throws Exception {
try {
new TreeEntityDecl(boolean_val, string, string2);
// Fail if previous line doesn't trhow exception.
fail(NOT_EXCEPTION + "from: new TreeEntityDecl(boolean_val, string, string2)");
} catch (InvalidArgumentException e) {
// OK
}
}
//--------------------------------------------------------------------------
static TreeEntityDecl createEntityDecl(java.lang.String string, java.lang.String string1, String view) throws Exception {
TreeEntityDecl node = new TreeEntityDecl(string, string1);
assertEquals(node, view);
cloneNodeTest(node, view);
return node;
}
static void createEntityDeclInvalid(java.lang.String string, java.lang.String string1) throws Exception {
try {
new TreeEntityDecl(string, string1);
// Fail if previous line doesn't trhow exception.
fail(NOT_EXCEPTION + "from: new TreeEntityDecl(string, string1)");
} catch (InvalidArgumentException e) {
// OK
}
}
//--------------------------------------------------------------------------
static TreeEntityDecl createEntityDecl(boolean boolean_val, java.lang.String string, java.lang.String string2, java.lang.String string3, String view) throws Exception {
TreeEntityDecl node = new TreeEntityDecl(boolean_val, string, string2, string3);
assertEquals(node, view);
cloneNodeTest(node, view);
return node;
}
static void createEntityDeclInvalid(boolean boolean_val, java.lang.String string, java.lang.String string2, java.lang.String string3) throws Exception {
try {
new TreeEntityDecl(boolean_val, string, string2, string3);
// Fail if previous line doesn't trhow exception.
fail(NOT_EXCEPTION + "from: new TreeEntityDecl(boolean_val, string, string2, string3)");
} catch (InvalidArgumentException e) {
// OK
}
}
//--------------------------------------------------------------------------
static TreeEntityDecl createEntityDecl(java.lang.String string, java.lang.String string1, java.lang.String string2, String view) throws Exception {
TreeEntityDecl node = new TreeEntityDecl(string, string1, string2);
assertEquals(node, view);
cloneNodeTest(node, view);
return node;
}
static void createEntityDeclInvalid(java.lang.String string, java.lang.String string1, java.lang.String string2) throws Exception {
try {
new TreeEntityDecl(string, string1, string2);
// Fail if previous line doesn't trhow exception.
fail(NOT_EXCEPTION + "from: new TreeEntityDecl(string, string1, string2)");
} catch (InvalidArgumentException e) {
// OK
}
}
//--------------------------------------------------------------------------
static TreeEntityDecl createEntityDecl(java.lang.String string, java.lang.String string1, java.lang.String string2, java.lang.String string3, String view) throws Exception {
TreeEntityDecl node = new TreeEntityDecl(string, string1, string2, string3);
assertEquals(node, view);
cloneNodeTest(node, view);
return node;
}
static void createEntityDeclInvalid(java.lang.String string, java.lang.String string1, java.lang.String string2, java.lang.String string3) throws Exception {
try {
new TreeEntityDecl(string, string1, string2, string3);
// Fail if previous line doesn't trhow exception.
fail(NOT_EXCEPTION + "from: new TreeEntityDecl(string, string1, string2, string3)");
} catch (InvalidArgumentException e) {
// OK
}
}
//--------------------------------------------------------------------------
static TreeGeneralEntityReference createGeneralEntityReference(java.lang.String string, String view) throws Exception {
TreeGeneralEntityReference node = new TreeGeneralEntityReference(string);
assertEquals(node, view);
cloneNodeTest(node, view);
return node;
}
static void createGeneralEntityReferenceInvalid(java.lang.String string) throws Exception {
try {
new TreeGeneralEntityReference(string);
// Fail if previous line doesn't trhow exception.
fail(NOT_EXCEPTION + "from: new TreeGeneralEntityReference(string)");
} catch (InvalidArgumentException e) {
// OK
}
}
//--------------------------------------------------------------------------
static TreeNotationDecl createNotationDecl(java.lang.String string, java.lang.String string1, java.lang.String string2, String view) throws Exception {
TreeNotationDecl node = new TreeNotationDecl(string, string1, string2);
assertEquals(node, view);
cloneNodeTest(node, view);
return node;
}
static void createNotationDeclInvalid(java.lang.String string, java.lang.String string1, java.lang.String string2) throws Exception {
try {
new TreeNotationDecl(string, string1, string2);
// Fail if previous line doesn't trhow exception.
fail(NOT_EXCEPTION + "from: new TreeNotationDecl(string, string1, string2)");
} catch (InvalidArgumentException e) {
// OK
}
}
//--------------------------------------------------------------------------
static TreeParameterEntityReference createParameterEntityReference(java.lang.String string, String view) throws Exception {
TreeParameterEntityReference node = new TreeParameterEntityReference(string);
assertEquals(node, view);
cloneNodeTest(node, view);
return node;
}
static void createParameterEntityReferenceInvalid(java.lang.String string) throws Exception {
try {
new TreeParameterEntityReference(string);
// Fail if previous line doesn't trhow exception.
fail(NOT_EXCEPTION + "from: new TreeParameterEntityReference(string)");
} catch (InvalidArgumentException e) {
// OK
}
}
//--------------------------------------------------------------------------
static TreeProcessingInstruction createProcessingInstruction(java.lang.String string, java.lang.String string1, String view) throws Exception {
TreeProcessingInstruction node = new TreeProcessingInstruction(string, string1);
assertEquals(node, view);
cloneNodeTest(node, view);
return node;
}
static void createProcessingInstructionInvalid(java.lang.String string, java.lang.String string1) throws Exception {
try {
new TreeProcessingInstruction(string, string1);
// Fail if previous line doesn't trhow exception.
fail(NOT_EXCEPTION + "from: new TreeProcessingInstruction(string, string1)");
} catch (InvalidArgumentException e) {
// OK
}
}
//--------------------------------------------------------------------------
static TreeText createText(java.lang.String string, String view) throws Exception {
TreeText node = new TreeText(string);
assertEquals(node, view);
cloneNodeTest(node, view);
return node;
}
static void createTextInvalid(java.lang.String string) throws Exception {
try {
new TreeText(string);
// Fail if previous line doesn't trhow exception.
fail(NOT_EXCEPTION + "from: new TreeText(string)");
} catch (InvalidArgumentException e) {
// OK
}
}
private static void cloneNodeTest(TreeParentNode node, String view) throws Exception {
TreeParentNode clone = (TreeParentNode) node.clone(true);
assertNotEquals(clone, node);
assertEquals(clone, view);
clone = (TreeParentNode) node.clone(false);
assertNotEquals(clone, node);
assertEquals(clone, view);
}
private static void cloneNodeTest(TreeNode node, String view) throws Exception {
TreeNode clone = (TreeNode) node.clone();
assertNotEquals(clone, node);
assertEquals(clone, view);
}
private static void assertNotEquals(Object orig, Object clone) {
if (orig == clone) {
fail("Invalid clone.");
}
}
private static void assertEquals(TreeNode node, String view) throws TreeException{
String str = TestUtil.nodeToString(node).replace("\n", "");
if (!!! str.equals(view)) {
fail("Invalid node view \n is : \"" + str + "\"\n should be: \"" + view + "\"");
}
}
}
| 8,642 |
319 | <reponame>NathanWalker/ios-runtime
//
// JSWarnings.h
// NativeScript
//
// Created by <NAME> on 9/16/14.
// Copyright (c) 2014 Telerik. All rights reserved.
//
#ifndef __NativeScript__JSWarnings__
#define __NativeScript__JSWarnings__
namespace NativeScript {
void warn(JSC::ExecState*, const WTF::String&);
}
#endif /* defined(__NativeScript__JSWarnings__) */
| 135 |
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.lib.v8debug.commands;
import org.netbeans.lib.v8debug.PropertyLong;
import org.netbeans.lib.v8debug.V8Arguments;
import org.netbeans.lib.v8debug.V8Body;
import org.netbeans.lib.v8debug.V8Command;
import org.netbeans.lib.v8debug.V8Request;
/**
*
* @author <NAME>
*/
public final class Source {
private Source() {}
public static V8Request createRequest(long sequence, Long frame, Long fromLine, Long toLine) {
return new V8Request(sequence, V8Command.Source, new Arguments(frame, fromLine, toLine));
}
public static final class Arguments extends V8Arguments {
private final PropertyLong frame;
private final PropertyLong fromLine;
private final PropertyLong toLine;
public Arguments(Long frame, Long fromLine, Long toLine) {
this.frame = new PropertyLong(frame);
this.fromLine = new PropertyLong(fromLine);
this.toLine = new PropertyLong(toLine);
}
public PropertyLong getFrame() {
return frame;
}
public PropertyLong getFromLine() {
return fromLine;
}
public PropertyLong getToLine() {
return toLine;
}
}
public static final class ResponseBody extends V8Body {
private final String source;
private final long fromLine;
private final long toLine;
private final long fromPosition;
private final long toPosition;
private final long totalLines;
public ResponseBody(String source, long fromLine, long toLine,
long fromPosition, long toPosition, long totalLines) {
this.source = source;
this.fromLine = fromLine;
this.toLine = toLine;
this.fromPosition = fromPosition;
this.toPosition = toPosition;
this.totalLines = totalLines;
}
public String getSource() {
return source;
}
public long getFromLine() {
return fromLine;
}
public long getToLine() {
return toLine;
}
public long getFromPosition() {
return fromPosition;
}
public long getToPosition() {
return toPosition;
}
public long getTotalLines() {
return totalLines;
}
}
}
| 1,277 |
590 | <gh_stars>100-1000
# coding: utf-8
"""
https://leetcode.com/problems/product-of-array-except-self/
"""
from typing import List
class Solution:
def productExceptSelf(self, nums: List[int]) -> List[int]:
output = []
for i in range(len(nums)):
product = 1
for num in nums[0:i] + nums[i + 1:]:
product = product * num
output.append(product)
return output
class Solution2:
def productExceptSelf(self, nums: List[int]) -> List[int]:
length = len(nums)
output = []
left_products = [1, ] * length
right_products = [1, ] * length
for i in range(1, length):
# start from the second leftmost index to right
left_products[i] = nums[i - 1] * left_products[i - 1]
# start from the second rightmost index to left
right_products[-(i + 1)] = nums[-i] * right_products[-i]
for i in range(length):
output.append(left_products[i] * right_products[i])
return output
| 478 |
Subsets and Splits