repo_name stringlengths 6 101 | path stringlengths 4 300 | text stringlengths 7 1.31M |
|---|---|---|
hchenji/optimsoc | external/opensocdebug/software/src/libosd/hostctrl.c | <gh_stars>10-100
/* Copyright 2017 The Open SoC Debug 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.
*/
#include <osd/hostctrl.h>
#include <osd/osd.h>
#include <osd/packet.h>
#include "osd-private.h"
#include "worker.h"
#include <assert.h>
#include <errno.h>
#include <stdbool.h>
#include <string.h>
/**
* Host Controller context
*/
struct osd_hostctrl_ctx {
/** Logging context */
struct osd_log_ctx *log_ctx;
/** DI subnet address */
unsigned int subnet_addr;
/** I/O worker context */
struct worker_ctx *ioworker_ctx;
/** Is the router running? */
bool is_running;
};
struct iothread_usr_ctx {
/** Host controller router socket */
zsock_t *router_socket;
/** ZeroMQ address/URL this host controller is bound to */
char *router_address;
/** Our DI subnet address */
unsigned int subnet_addr;
/** Debug modules registered in this subnet */
zframe_t **mods_in_subnet;
/** Gateways registered in this subnet */
zframe_t **gateways;
};
/**
* Get an available address in the local subnet
*/
static osd_result get_available_diaddr(struct worker_thread_ctx *thread_ctx,
unsigned int *diaddr)
{
assert(thread_ctx);
struct iothread_usr_ctx *usrctx = thread_ctx->usr;
assert(usrctx);
unsigned int localaddr;
for (localaddr = 1; localaddr <= OSD_DIADDR_LOCAL_MAX; localaddr++) {
if (usrctx->mods_in_subnet[localaddr] == NULL) {
*diaddr = osd_diaddr_build(usrctx->subnet_addr, localaddr);
return OSD_OK;
}
}
return OSD_ERROR_FAILURE;
}
/**
* Register a host address for a given DI address
*/
static osd_result register_diaddr(struct worker_thread_ctx *thread_ctx,
const zframe_t *hostaddr, unsigned int diaddr)
{
assert(thread_ctx);
struct iothread_usr_ctx *usrctx = thread_ctx->usr;
assert(usrctx);
unsigned int localaddr = osd_diaddr_localaddr(diaddr);
if (usrctx->mods_in_subnet[localaddr] != NULL) {
return OSD_ERROR_FAILURE;
}
usrctx->mods_in_subnet[localaddr] = zframe_dup_c(hostaddr);
#ifdef DEBUG
char *hostaddr_str = zframe_strhex((zframe_t *)hostaddr);
dbg(thread_ctx->log_ctx, "Registered diaddr %u.%u (%u) for host module %s",
osd_diaddr_subnet(diaddr), osd_diaddr_localaddr(diaddr), diaddr,
hostaddr_str);
free(hostaddr_str);
#endif
return OSD_OK;
}
static void mgmt_send_ack(struct worker_thread_ctx *thread_ctx,
const zframe_t *dest)
{
assert(thread_ctx);
assert(dest);
struct iothread_usr_ctx *usrctx = thread_ctx->usr;
assert(usrctx);
zmsg_t *msg = zmsg_new();
zmsg_add(msg, zframe_dup_c(dest));
zmsg_addstr(msg, "M");
zmsg_addstr(msg, "ACK");
zmsg_send(&msg, usrctx->router_socket);
}
static void mgmt_send_nack(struct worker_thread_ctx *thread_ctx,
const zframe_t *dest)
{
assert(thread_ctx);
assert(dest);
struct iothread_usr_ctx *usrctx = thread_ctx->usr;
assert(usrctx);
zmsg_t *msg = zmsg_new();
zmsg_add(msg, zframe_dup_c(dest));
zmsg_addstr(msg, "M");
zmsg_addstr(msg, "NACK");
zmsg_send(&msg, usrctx->router_socket);
}
/**
* Assign a new DI address to a host module in our subnet
*/
static void mgmt_diaddr_request(struct worker_thread_ctx *thread_ctx,
const zframe_t *hostaddr)
{
assert(thread_ctx);
assert(hostaddr);
struct iothread_usr_ctx *usrctx = thread_ctx->usr;
assert(usrctx);
osd_result rv;
unsigned int diaddr;
rv = get_available_diaddr(thread_ctx, &diaddr);
// XXX: Return error to host module instead of failing hard
assert(OSD_SUCCEEDED(rv));
rv = register_diaddr(thread_ctx, hostaddr, diaddr);
assert(OSD_SUCCEEDED(rv));
zmsg_t *msg = zmsg_new();
zmsg_add(msg, zframe_dup_c(hostaddr));
zmsg_addstr(msg, "M");
zmsg_addstrf(msg, "%u", diaddr);
zmsg_send(&msg, usrctx->router_socket);
}
static void mgmt_diaddr_release(struct worker_thread_ctx *thread_ctx,
const zframe_t *hostaddr)
{
assert(thread_ctx);
assert(hostaddr);
struct iothread_usr_ctx *usrctx = thread_ctx->usr;
assert(usrctx);
unsigned int i, localaddr;
int found = 0;
for (i = 1; i < OSD_DIADDR_SUBNET_MAX; i++) {
if (zframe_eq_c(usrctx->mods_in_subnet[i], hostaddr)) {
localaddr = i;
found = 1;
break;
}
}
if (!found) {
err(thread_ctx->log_ctx,
"Trying to release address for host which "
"isn't registered.");
return mgmt_send_nack(thread_ctx, hostaddr);
}
zframe_destroy(&usrctx->mods_in_subnet[localaddr]);
#ifdef DEBUG
char *hostaddr_str = zframe_strhex((zframe_t *)hostaddr);
dbg(thread_ctx->log_ctx, "Releasing address %u for host module %s\n",
localaddr, hostaddr_str);
free(hostaddr_str);
#endif
return mgmt_send_ack(thread_ctx, hostaddr);
}
static void mgmt_gw_register(struct worker_thread_ctx *thread_ctx,
const zframe_t *hostaddr, const char *params)
{
assert(thread_ctx);
assert(hostaddr);
struct iothread_usr_ctx *usrctx = thread_ctx->usr;
assert(usrctx);
char *end;
unsigned int subnet = strtol(params, &end, 10);
assert(!*end);
assert(subnet <= OSD_DIADDR_SUBNET_MAX);
if (usrctx->gateways[subnet] != NULL) {
err(thread_ctx->log_ctx, "A gateway for subnet %u is already "
"registered.", subnet);
return mgmt_send_nack(thread_ctx, hostaddr);
}
usrctx->gateways[subnet] = zframe_dup_c(hostaddr);
#ifdef DEBUG
char *hostaddr_str = zframe_strhex((zframe_t *)hostaddr);
dbg(thread_ctx->log_ctx, "Registered gateway %s for subnet %u",
hostaddr_str, subnet);
free(hostaddr_str);
#endif
mgmt_send_ack(thread_ctx, hostaddr);
}
static void mgmt_gw_unregister(struct worker_thread_ctx *thread_ctx,
const zframe_t *hostaddr, const char *params)
{
assert(thread_ctx);
assert(hostaddr);
struct iothread_usr_ctx *usrctx = thread_ctx->usr;
assert(usrctx);
char *end;
unsigned int subnet = strtol(params, &end, 10);
assert(!*end);
assert(subnet <= OSD_DIADDR_SUBNET_MAX);
if (usrctx->gateways[subnet] == NULL) {
err(thread_ctx->log_ctx, "No gateway registered for subnet %d.",
subnet);
return mgmt_send_nack(thread_ctx, hostaddr);
}
if (!zframe_eq_c(usrctx->gateways[subnet], hostaddr)) {
char *hostaddr_str = zframe_strhex((zframe_t *)hostaddr);
err(thread_ctx->log_ctx,
"Host address %s is not registered as gateway "
"for subnet %u.",
hostaddr_str, subnet);
free(hostaddr_str);
return mgmt_send_nack(thread_ctx, hostaddr);
}
zframe_destroy(&usrctx->gateways[subnet]);
usrctx->gateways[subnet] = NULL;
#ifdef DEBUG
char *hostaddr_str = zframe_strhex((zframe_t *)hostaddr);
dbg(thread_ctx->log_ctx, "Unregistered gateway %s for subnet %u",
hostaddr_str, subnet);
free(hostaddr_str);
#endif
mgmt_send_ack(thread_ctx, hostaddr);
}
/**
* Process an incoming management message (from the host modules)
*
* This function gains ownership of the passed zframe_t arguments and is
* expected to destroy and NULL them.
*/
static void process_mgmt_msg(struct worker_thread_ctx *thread_ctx,
zframe_t **src_p, zframe_t **payload_frame_p)
{
assert(thread_ctx);
assert(src_p);
assert(payload_frame_p);
zframe_t *src = *src_p;
assert(src);
zframe_t *payload_frame = *payload_frame_p;
assert(payload_frame);
char *request = zframe_strdup(payload_frame);
dbg(thread_ctx->log_ctx, "Received management message %s", request);
if (!strcmp(request, "DIADDR_REQUEST")) {
mgmt_diaddr_request(thread_ctx, src);
} else if (!strcmp(request, "DIADDR_RELEASE")) {
mgmt_diaddr_release(thread_ctx, src);
} else if (!strncmp(request, "GW_REGISTER", strlen("GW_REGISTER"))) {
mgmt_gw_register(thread_ctx, src, request + strlen("GW_REGISTER "));
} else if (!strncmp(request, "GW_UNREGISTER", strlen("GW_UNREGISTER"))) {
mgmt_gw_unregister(thread_ctx, src, request + strlen("GW_UNREGISTER "));
} else {
mgmt_send_ack(thread_ctx, src);
}
free(request);
zframe_destroy(src_p);
zframe_destroy(payload_frame_p);
}
/**
* Route a DI data message to its destination
*
* This function gains ownership of the passed zframe_t arguments and is
* expected to destroy and NULL them.
*/
static void process_data_msg(struct worker_thread_ctx *thread_ctx,
zframe_t **src_p, zframe_t **payload_frame_p)
{
assert(thread_ctx);
assert(src_p);
assert(payload_frame_p);
zframe_t *src = *src_p;
assert(src);
zframe_t *payload_frame = *payload_frame_p;
assert(payload_frame);
struct iothread_usr_ctx *usrctx = thread_ctx->usr;
assert(usrctx);
osd_result rv;
struct osd_packet *pkg = NULL;
rv = osd_packet_new_from_zframe(&pkg, payload_frame);
if (OSD_FAILED(rv)) {
err(thread_ctx->log_ctx, "Dropping invalid data packet (%d)", rv);
goto free_return;
}
unsigned int dest_diaddr_subnet =
osd_diaddr_subnet(osd_packet_get_dest(pkg));
unsigned int dest_diaddr_local =
osd_diaddr_localaddr(osd_packet_get_dest(pkg));
dbg(thread_ctx->log_ctx,
"Routing lookup for packet with destination %u.%u. Local subnet is %u.",
dest_diaddr_subnet, dest_diaddr_local, usrctx->subnet_addr);
const zframe_t *dest_hostaddr;
if (dest_diaddr_subnet == usrctx->subnet_addr) {
// routing inside our subnet
dest_hostaddr = usrctx->mods_in_subnet[dest_diaddr_local];
if (dest_hostaddr == NULL) {
err(thread_ctx->log_ctx,
"No destination module registered for DI address %u.%u",
dest_diaddr_subnet, dest_diaddr_local);
goto free_return;
}
dbg(thread_ctx->log_ctx,
"Destination address is local, routing directly to destination.");
} else {
// routing through a gateway
dest_hostaddr = usrctx->gateways[dest_diaddr_subnet];
if (dest_hostaddr == NULL) {
char* src_str = zframe_strhex(src);
err(thread_ctx->log_ctx,
"No gateway for subnet %u registered to route DI address %u.%u, "
"packet coming from %s",
dest_diaddr_subnet, dest_diaddr_subnet, dest_diaddr_local,
src_str);
free(src_str);
goto free_return;
}
dbg(thread_ctx->log_ctx,
"Destination address is in a different subnet, routing through "
"gateway.");
}
#ifdef DEBUG
char *dest_hostaddr_str = zframe_strhex((zframe_t *)dest_hostaddr);
dbg(thread_ctx->log_ctx, "Routing data packet to %s", dest_hostaddr_str);
free(dest_hostaddr_str);
#endif
int zmq_rv;
zmsg_t *msg = zmsg_new();
assert(msg);
zframe_t *dest_hostaddr_dup = zframe_dup_c(dest_hostaddr);
zmq_rv = zmsg_append(msg, &dest_hostaddr_dup);
assert(zmq_rv == 0);
zmq_rv = zmsg_addstr(msg, "D");
assert(zmq_rv == 0);
zmsg_append(msg, payload_frame_p);
assert(zmq_rv == 0);
zmq_rv = zmsg_send(&msg, usrctx->router_socket);
assert(zmq_rv == 0);
free_return:
zframe_destroy(src_p);
zframe_destroy(payload_frame_p);
osd_packet_free(&pkg);
}
/**
* Process incoming messages
*
* @return 0 if the message was processed, -1 if @p loop should be terminated
*/
static int iothread_handle_ext_msg(zloop_t *loop, zsock_t *reader,
void *thread_ctx_void)
{
struct worker_thread_ctx *thread_ctx =
(struct worker_thread_ctx *)thread_ctx_void;
assert(thread_ctx);
struct iothread_usr_ctx *usrctx = thread_ctx->usr;
assert(usrctx);
zmsg_t *msg = zmsg_recv(reader);
if (!msg) {
return -1; // process was interrupted, terminate zloop
}
zframe_t *src_frame = zmsg_pop(msg);
zframe_t *type_frame = zmsg_pop(msg);
char *type_str = zframe_strdup(type_frame);
if (type_str[0] == 'M') {
zframe_t *payload_frame = zmsg_pop(msg);
process_mgmt_msg(thread_ctx, &src_frame, &payload_frame);
zframe_destroy(&payload_frame);
} else if (type_str[0] == 'D') {
zframe_t *payload_frame = zmsg_pop(msg);
process_data_msg(thread_ctx, &src_frame, &payload_frame);
zframe_destroy(&payload_frame);
} else {
err(thread_ctx->log_ctx, "Ignoring message of unknown type '%s'.",
type_str);
}
free(type_str);
zframe_destroy(&src_frame);
zframe_destroy(&type_frame);
zmsg_destroy(&msg);
return 0;
}
/**
* Start host controller router function in I/O thread
*
* This function is called by the worker as response to a I-START message.
* It create a new ZeroMQ ROUTER socket acting as host controller and registers
* an event handler function if new packages are received. After all startup
* tasks are done a I-START-DONE message is sent to the main thread.
*/
static void iothread_router_start(struct worker_thread_ctx *thread_ctx)
{
struct iothread_usr_ctx *usrctx = thread_ctx->usr;
assert(usrctx);
osd_result retval;
// create new ROUTER socket for host controller
usrctx->router_socket = zsock_new_router(usrctx->router_address);
if (!usrctx->router_socket) {
err(thread_ctx->log_ctx, "Unable to bind to %s",
usrctx->router_address);
retval = OSD_ERROR_CONNECTION_FAILED;
goto free_return;
}
zsock_set_rcvtimeo(usrctx->router_socket, ZMQ_RCV_TIMEOUT);
// Don't silently drop unroutable messages
zsock_set_router_mandatory(usrctx->router_socket, 1);
// register event handler for incoming messages
int zmq_rv;
zmq_rv = zloop_reader(thread_ctx->zloop, usrctx->router_socket,
iothread_handle_ext_msg, thread_ctx);
assert(zmq_rv == 0);
zloop_reader_set_tolerant(thread_ctx->zloop, usrctx->router_socket);
retval = OSD_OK;
free_return:
worker_send_status(thread_ctx->inproc_socket, "I-START-DONE", retval);
}
/**
* Stop the host controller router function in the I/O thread
*/
static void iothread_router_stop(struct worker_thread_ctx *thread_ctx)
{
struct iothread_usr_ctx *usrctx = thread_ctx->usr;
assert(usrctx);
osd_result retval;
zloop_reader_end(thread_ctx->zloop, usrctx->router_socket);
zsock_destroy(&usrctx->router_socket);
retval = OSD_OK;
worker_send_status(thread_ctx->inproc_socket, "I-STOP-DONE", retval);
}
static osd_result iothread_handle_inproc_msg(
struct worker_thread_ctx *thread_ctx, const char *name, zmsg_t *msg)
{
struct thread_ctx_usr *usrctx = thread_ctx->usr;
assert(usrctx);
// we don't use |msg|, but we gained ownership -- destroy it!
zmsg_destroy(&msg);
if (!strcmp(name, "I-START")) {
iothread_router_start(thread_ctx);
} else if (!strcmp(name, "I-STOP")) {
iothread_router_stop(thread_ctx);
} else {
assert(0 && "Received unknown message from main thread.");
}
return OSD_OK;
}
static osd_result iothread_destroy(struct worker_thread_ctx *thread_ctx)
{
assert(thread_ctx);
struct iothread_usr_ctx *usrctx = thread_ctx->usr;
assert(usrctx);
for (unsigned int l = 1; l <= OSD_DIADDR_LOCAL_MAX; l++) {
zframe_destroy(&usrctx->mods_in_subnet[l]);
}
free(usrctx->mods_in_subnet);
free(usrctx->router_address);
free(usrctx->gateways);
free(usrctx);
thread_ctx->usr = NULL;
return OSD_OK;
}
API_EXPORT
osd_result osd_hostctrl_new(struct osd_hostctrl_ctx **ctx,
struct osd_log_ctx *log_ctx,
const char *router_address)
{
osd_result rv;
struct osd_hostctrl_ctx *c = calloc(1, sizeof(struct osd_hostctrl_ctx));
assert(c);
c->log_ctx = log_ctx;
c->is_running = false;
// prepare custom data passed to I/O thread
struct iothread_usr_ctx *iothread_usr_data =
calloc(1, sizeof(struct iothread_usr_ctx));
assert(iothread_usr_data);
iothread_usr_data->router_address = strdup(router_address);
// Our subnet: always 1 for now.
// XXX: make this dynamic
iothread_usr_data->subnet_addr = 1;
// allocate routing lookup tables
// mods_in_subnet is 1024 * 8B = 8 kB
iothread_usr_data->mods_in_subnet =
calloc(OSD_DIADDR_LOCAL_MAX + 1, sizeof(zframe_t *));
assert(iothread_usr_data->mods_in_subnet);
// gateways is 64 * 8B = 1 kB
iothread_usr_data->gateways =
calloc(OSD_DIADDR_SUBNET_MAX + 1, sizeof(zframe_t *));
assert(iothread_usr_data->gateways);
rv = worker_new(&c->ioworker_ctx, log_ctx, NULL, iothread_destroy,
iothread_handle_inproc_msg, iothread_usr_data);
if (OSD_FAILED(rv)) {
return rv;
}
*ctx = c;
return OSD_OK;
}
API_EXPORT
void osd_hostctrl_free(struct osd_hostctrl_ctx **ctx_p)
{
assert(ctx_p);
struct osd_hostctrl_ctx *ctx = *ctx_p;
if (!ctx) {
return;
}
assert(!ctx->is_running);
worker_free(&ctx->ioworker_ctx);
free(ctx);
*ctx_p = NULL;
}
API_EXPORT
osd_result osd_hostctrl_start(struct osd_hostctrl_ctx *ctx)
{
osd_result rv;
assert(ctx);
assert(!ctx->is_running);
worker_send_status(ctx->ioworker_ctx->inproc_socket, "I-START", 0);
int retval;
rv = worker_wait_for_status(ctx->ioworker_ctx->inproc_socket,
"I-START-DONE", &retval);
if (OSD_FAILED(rv) || retval == -1) {
err(ctx->log_ctx, "Unable to start router functionality.");
return OSD_ERROR_CONNECTION_FAILED;
}
ctx->is_running = true;
dbg(ctx->log_ctx, "Host controller started, accepting connections.");
return OSD_OK;
}
API_EXPORT
osd_result osd_hostctrl_stop(struct osd_hostctrl_ctx *ctx)
{
osd_result rv;
assert(ctx);
if (!ctx->is_running) {
return OSD_ERROR_NOT_CONNECTED;
}
worker_send_status(ctx->ioworker_ctx->inproc_socket, "I-STOP", 0);
osd_result retval;
rv = worker_wait_for_status(ctx->ioworker_ctx->inproc_socket, "I-STOP-DONE",
&retval);
if (OSD_FAILED(rv)) {
return rv;
}
if (OSD_FAILED(retval)) {
return retval;
}
ctx->is_running = false;
return OSD_OK;
}
API_EXPORT
bool osd_hostctrl_is_running(struct osd_hostctrl_ctx *ctx)
{
return ctx->is_running;
}
|
lauracristinaes/aula-java | hibernate-release-5.3.7.Final/project/hibernate-core/src/main/java/org/hibernate/boot/archive/spi/ArchiveEntry.java | /*
* Hibernate, Relational Persistence for Idiomatic Java
*
* License: GNU Lesser General Public License (LGPL), version 2.1 or later.
* See the lgpl.txt file in the root directory or <http://www.gnu.org/licenses/lgpl-2.1.html>.
*/
package org.hibernate.boot.archive.spi;
/**
* Represent an entry in the archive.
*
* @author <NAME>
*/
public interface ArchiveEntry {
/**
* Get the entry's name
*
* @return The name
*/
public String getName();
/**
* Get the relative name of the entry within the archive. Typically what we are looking for here is
* the ClassLoader resource lookup name.
*
* @return The name relative to the archive root
*/
public String getNameWithinArchive();
/**
* Get access to the stream for the entry
*
* @return Obtain stream access to the entry
*/
public InputStreamAccess getStreamAccess();
}
|
nafs1/testing_project | src/main/java/com/numericalmethod/suanshu/DeepCopyable.java | /*
* Copyright (c) Numerical Method Inc.
* http://www.numericalmethod.com/
*
* THIS SOFTWARE IS LICENSED, NOT SOLD.
*
* YOU MAY USE THIS SOFTWARE ONLY AS DESCRIBED IN THE LICENSE.
* IF YOU ARE NOT AWARE OF AND/OR DO NOT AGREE TO THE TERMS OF THE LICENSE,
* DO NOT USE THIS SOFTWARE.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITH NO WARRANTY WHATSOEVER,
* EITHER EXPRESS OR IMPLIED, INCLUDING, WITHOUT LIMITATION,
* ANY WARRANTIES OF ACCURACY, ACCESSIBILITY, COMPLETENESS,
* FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABILITY, NON-INFRINGEMENT,
* TITLE AND USEFULNESS.
*
* IN NO EVENT AND UNDER NO LEGAL THEORY,
* WHETHER IN ACTION, CONTRACT, NEGLIGENCE, TORT, OR OTHERWISE,
* SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
* ANY CLAIMS, DAMAGES OR OTHER LIABILITIES,
* ARISING AS A RESULT OF USING OR OTHER DEALINGS IN THE SOFTWARE.
*/
package com.numericalmethod.suanshu;
/**
* This interface provides a way to do polymorphic copying.
* <p/>
* An interface (a class) that extends (implements) this interface should
* override the return type of {@link #deepCopy()} in the interface (class)
* itself to provide as much information as possible to avoid unnecessary casting.
* <p/>
* For example,
* <pre><code>
* public interface Matrix extends DeepCopyable {
* ...
* Matrix deepCopy();
* }
* </code></pre>
*
* @author <NAME>
*/
public interface DeepCopyable {
/**
* The implementation returns an instance created from {@code this} by the copy
* constructor of the class, or just {@code this} if the instance itself is
* <em>immutable</em>.
*
* @return an independent (deep) copy of the instance
*/
Object deepCopy();
}
|
metux/chromium-deb | cc/output/software_output_device.h | <gh_stars>0
// Copyright 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CC_OUTPUT_SOFTWARE_OUTPUT_DEVICE_H_
#define CC_OUTPUT_SOFTWARE_OUTPUT_DEVICE_H_
#include <memory>
#include "base/macros.h"
#include "cc/cc_export.h"
#include "third_party/skia/include/core/SkSurface.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/size.h"
#include "ui/gfx/geometry/vector2d.h"
class SkCanvas;
namespace gfx {
class VSyncProvider;
}
namespace cc {
// This is a "tear-off" class providing software drawing support to
// OutputSurface, such as to a platform-provided window framebuffer.
class CC_EXPORT SoftwareOutputDevice {
public:
SoftwareOutputDevice();
virtual ~SoftwareOutputDevice();
// Discards any pre-existing backing buffers and allocates memory for a
// software device of |size|. This must be called before the
// |SoftwareOutputDevice| can be used in other ways.
virtual void Resize(const gfx::Size& pixel_size, float scale_factor);
// Called on BeginDrawingFrame. The compositor will draw into the returned
// SkCanvas. The |SoftwareOutputDevice| implementation needs to provide a
// valid SkCanvas of at least size |damage_rect|. This class retains ownership
// of the SkCanvas.
virtual SkCanvas* BeginPaint(const gfx::Rect& damage_rect);
// Called on FinishDrawingFrame. The compositor will no longer mutate the the
// SkCanvas instance returned by |BeginPaint| and should discard any reference
// that it holds to it.
virtual void EndPaint();
// Discard the backing buffer in the surface provided by this instance.
virtual void DiscardBackbuffer() {}
// Ensures that there is a backing buffer available on this instance.
virtual void EnsureBackbuffer() {}
// VSyncProvider used to update the timer used to schedule draws with the
// hardware vsync. Return NULL if a provider doesn't exist.
virtual gfx::VSyncProvider* GetVSyncProvider();
protected:
gfx::Size viewport_pixel_size_;
gfx::Rect damage_rect_;
sk_sp<SkSurface> surface_;
std::unique_ptr<gfx::VSyncProvider> vsync_provider_;
private:
DISALLOW_COPY_AND_ASSIGN(SoftwareOutputDevice);
};
} // namespace cc
#endif // CC_OUTPUT_SOFTWARE_OUTPUT_DEVICE_H_
|
Lee12312/CodingTest | Java/src/Chapter07/actualproblem02/MySourceCode2.java | package Chapter07.actualproblem02;
import java.util.*;
public class MySourceCode2 {
public static int n, m;
public static int[] store;
public static int[] finds;
public static boolean binarySearch(int start, int end, int target){
if(start > end) return false;
int mid = (start + end) / 2;
if(store[mid] == target) return true;
else if (store[mid] > target) return binarySearch(start, mid - 1, target);
else return binarySearch(mid + 1, end, target);
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
n = sc.nextInt();
store = new int[n];
for(int i = 0; i < n; i++){
store[i] = sc.nextInt();
}
m = sc.nextInt();
finds = new int[m];
for(int i = 0; i < m; i++){
finds[i] = sc.nextInt();
}
Arrays.sort(store);
Arrays.sort(finds);
for (int find : finds) {
boolean result = binarySearch(0, n, find);
if(!result){
System.out.print("no ");
} else {
System.out.print("yes ");
}
}
}
}
|
hgogov/Job-Posting-Board-Java-Spring-MVC- | src/main/java/com/company/jobs/service/impl/JobExperienceLevelServiceImpl.java | <filename>src/main/java/com/company/jobs/service/impl/JobExperienceLevelServiceImpl.java
package com.company.jobs.service.impl;
import com.company.jobs.dto.JobExperienceLevelDTO;
import com.company.jobs.exception.NotFoundException;
import com.company.jobs.mapper.JobExperienceLevelMapper;
import com.company.jobs.repository.JobExperienceLevelRepository;
import com.company.jobs.service.JobExperienceLevelService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.stream.Collectors;
@Service
public class JobExperienceLevelServiceImpl implements JobExperienceLevelService {
private final JobExperienceLevelRepository jobExperienceLevelRepository;
private final JobExperienceLevelMapper mapper;
@Autowired
public JobExperienceLevelServiceImpl(JobExperienceLevelRepository jobExperienceLevelRepository, JobExperienceLevelMapper mapper) {
this.jobExperienceLevelRepository = jobExperienceLevelRepository;
this.mapper = mapper;
}
@Override
public List<JobExperienceLevelDTO> findAll() {
return jobExperienceLevelRepository.findAll()
.stream()
.map(mapper::mapToJobExperienceLevelDTO)
.collect(Collectors.toList());
}
@Override
public JobExperienceLevelDTO findById(Long jobExperienceLevelId) {
return mapper.mapToJobExperienceLevelDTO(jobExperienceLevelRepository.findById(jobExperienceLevelId)
.orElseThrow(() -> new NotFoundException("Job experience level with id: "
+ jobExperienceLevelId + " is not found.")));
}
}
|
michel-pi/xenforo-documentation | docs/2-1-0/d9/d00/class_x_f_1_1_template_1_1_compiler_1_1_tag_1_1_form_row.js | <reponame>michel-pi/xenforo-documentation
var class_x_f_1_1_template_1_1_compiler_1_1_tag_1_1_form_row =
[
[ "compile", "d9/d00/class_x_f_1_1_template_1_1_compiler_1_1_tag_1_1_form_row.html#a553985f10d04ca8607ed52f394087367", null ]
]; |
paullewallencom/java-978-1-7882-9625-0 | _src/Scripts/Chapter01/src/com/ioc/factory/ExportDataFactory.java | <reponame>paullewallencom/java-978-1-7882-9625-0
package com.ioc.factory;
public class ExportDataFactory {
public static IExportData getExportData(String type){
IExportData exportData = null;
if("TO_HTML".equalsIgnoreCase(type)){
exportData = new ExportHTML();
}else if("TO_PDF".equalsIgnoreCase(type)){
exportData = new ExportPDF();
}else {
return null;
}
return exportData;
}
}
|
tek/fs2-pdf | src/main/scala/fs2/pdf/IndirectObj.scala | <reponame>tek/fs2-pdf
package fs2
package pdf
import cats.implicits._
import scodec.{Attempt, Codec}
import scodec.bits.{BitVector, ByteVector}
import scodec.codecs.bits
case class IndirectObj(index: Obj.Index, data: Prim, stream: Option[BitVector])
object IndirectObj
{
def streamCodec: Codec[BitVector] =
Codecs.constantLine("stream") ~> bits <~ Codecs.newline <~ Codecs.constantLine("endstream")
implicit def Codec_IndirectObj: Codec[IndirectObj] =
Codecs.productCodec(
(Obj.Index.Codec_Index <~ Codecs.linuxNewline) ~
(Prim.Codec_Prim <~ Codecs.linuxNewline) ~
Codecs.opt(streamCodec) <~
Codecs.constantLine("endobj")
)
def nostream(number: Long, generation: Int, data: Prim): IndirectObj =
IndirectObj(Obj.Index(number, generation), data, None)
def addLength(stream: BitVector): Prim => Prim = {
case Prim.Dict(data) => Prim.Dict(data.updated("Length", Prim.Number(stream.bytes.size)))
case a => a
}
def ensureLength(stream: BitVector)(data: Prim): Prim =
Prim.tryDict("Length")(data).as(data).getOrElse(addLength(stream)(data))
def stream(number: Long, generation: Int, data: Prim, stream: BitVector): IndirectObj =
IndirectObj(Obj.Index(number, generation), ensureLength(stream)(data), Some(stream))
}
case class EncodedObj(xref: XrefObjMeta, bytes: ByteVector)
object EncodedObj
{
def indirect(obj: IndirectObj): Attempt[EncodedObj] =
Codecs.encodeBytes(obj).map(bytes => EncodedObj(XrefObjMeta(obj.index, bytes.size), bytes))
}
|
txlos/wpf | src/Microsoft.DotNet.Wpf/src/WpfGfx/core/fxjit/Collector/P_u16x8.cpp | // Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.
//+----------------------------------------------------------------------------
//
//
// Abstract:
// Prototype class to represent pointer to C_u16x8 variable.
//
#include "precomp.h"
//+-----------------------------------------------------------------------------
//
// Member:
// P_u16x8::operator+=
//
// Synopsis:
// Add scaled constant offset to the pointer to u16x8 value.
//
// Usage example:
// P_u16x8 pa = ...;
// pa += 3;
//
// Result: pa increased by 3.
// Note that given constant is implicitly multiplied by sizeof(u16x8).
//
//------------------------------------------------------------------------------
P_u16x8 &
P_u16x8::operator+=(int nIndexDelta)
{
if (nIndexDelta)
{
CProgram * pProgram = WarpPlatform::GetCurrentProgram();
SOperator *pOperator = pProgram->AddOperator(otPtrOffset, m_ID, m_ID);
pOperator->m_uDisplacement = (UINT_PTR)(nIndexDelta * sizeof(u16x8));
}
return *this;
}
//+-----------------------------------------------------------------------------
//
// Member:
// P_u16x8::operator++ (preincrement)
//
// Synopsis:
// Increment value by 1 (scaled by sizeof(u16x8))
//
// Usage example:
// P_u16x8 pa = ...;
// P_u16x8 pb = ++pa;
//
// Result: pa = pb = incremented value of pa.
//
//------------------------------------------------------------------------------
P_u16x8&
P_u16x8::operator++()
{
return *this += 1;
}
//+-----------------------------------------------------------------------------
//
// Member:
// P_u16x8::operator++ (postincrement)
//
// Synopsis:
// Increment value by 1 (scaled by sizeof(u16x8))
//
// Usage example:
// P_u16x8 pa = ...;
// P_u16x8 pb = pa++;
//
// Result: pa = incremented value of pa;
// pb = value of pa before incrementing.
//
//------------------------------------------------------------------------------
P_u16x8
P_u16x8::operator++(int)
{
P_u16x8 tmp = *this;
++*this;
return tmp;
}
//+-----------------------------------------------------------------------------
//
// Member:
// R_u16x8::R_u16x8
//
// Synopsis:
// Construct all-const instance of R_u16x8.
// This instance is required to resolve expessions
// like p[n] where p is P_u16x8.
// When such expression is handled by C++, it's yet unknown whether
// it'll be used for writing or reading. To bypass this trouble,
// we create intermediate reference type R_u16x8 which
// in turn has "operator C_u16x8()" for reading and
// "operator=(C_u16x8 const& origin)" for writing.
//
//------------------------------------------------------------------------------
R_u16x8::R_u16x8(
RefType refType,
UINT32 uVarID,
UINT_PTR uDisplacement
)
: m_refType(refType)
, m_uVarID(uVarID)
, m_uDisplacement(uDisplacement)
{
}
//+-----------------------------------------------------------------------------
//
// Member:
// P_u16x8::operator[]
//
// Synopsis:
// Creates intermediate reference type to access in-memory variable.
//
// Usage examples:
// 1.
// P_u16x8 ptr = ...;
// UINT32 idx = ...;
// C_u16x8 f = ptr[idx];
//
// Result: f = ptr[idx]; ptr, idx and ptr[idx] unchanged.
//
// 2.
// P_u16x8 ptr = ...;
// UINT32 idx = ...;
// C_u16x8 f = ...;
// ptr[idx] = f;
//
// Result: ptr[idx] = f; f, ptr and idx unchanged.
//
//------------------------------------------------------------------------------
R_u16x8
P_u16x8::operator[](int nIndex) const
{
return R_u16x8(RefType_Base, GetID(), nIndex*sizeof(u16x8));
}
//+-----------------------------------------------------------------------------
//
// Member:
// R_u16x8::operator C_u16x8
//
// Synopsis:
// Cast reference type R_u16x8 to data type C_u16x8.
// Treated as fetching data from array.
//
// Usage example:
// P_u16x8 ptr = ...;
// UINT32 idx = ...;
// C_u16x8 f = ptr[idx];
//
//------------------------------------------------------------------------------
R_u16x8::operator C_u16x8() const
{
C_u16x8 tmp;
CProgram * pProgram = WarpPlatform::GetCurrentProgram();
SOperator * pOperator = pProgram->AddOperator(otXmmIntLoad, tmp.GetID(), m_uVarID);
pOperator->m_refType = m_refType;
pOperator->m_uDisplacement = m_uDisplacement;
return tmp;
}
//+-----------------------------------------------------------------------------
//
// Member:
// R_u16x8::operator=
//
// Synopsis:
// Stores data in an element of array.
//
// Usage example:
// P_u16x8 ptr = ...;
// UINT32 idx = ...;
// C_u16x8 f = ...;
// ptr[idx] = f;
//------------------------------------------------------------------------------
C_u16x8 const&
R_u16x8::operator=(C_u16x8 const& origin)
{
CProgram * pProgram = WarpPlatform::GetCurrentProgram();
SOperator * pOperator = pProgram->AddOperator(otXmmIntStore, 0, origin.GetID(), m_uVarID);
pOperator->m_refType = m_refType;
pOperator->m_uDisplacement = m_uDisplacement;
return origin;
}
|
pengchenyu111/ScalaStudy | src/main/scala/com/pcy/chapter05/set/Set01.scala | package com.pcy.chapter05.set
import scala.collection.mutable
/**
* @author pengchenyu
* @date 2020/7/10 12:02
*
* 默认情况下，Scala 使 用 的 是 不 可 变 集 合 ， 如 果 你 想 使 用 可 变 集 合 ， 需 要 引 用
* scala.collection.mutable.Set 包
*/
object Set01 {
def main(args: Array[String]): Unit = {
println("------------ set创建------------")
//创建
val set = Set(1, 2, 3) //不可变
println(set)
val set2 = mutable.Set(1, 2, "hello") //可以变
println("set2" + set2)
println("------------ set添加------------")
//如果添加的对象已经存在，则不会重复添加，也不会报错
set2.add(4)
set2 += 6
set2.+=(5)
println(set2)
println("------------ set删除------------")
//如果删除的对象不存在，则不生效，也不会报错
set2 -= 2 // 操作符形式
set2.remove("hello") // 方法的形式，scala 的 Set 可以直接删除值
println(set2)
}
}
|
netarchivesuite/webarchive-commons | src/main/java/org/archive/url/URLCanonicalizer.java | <filename>src/main/java/org/archive/url/URLCanonicalizer.java
package org.archive.url;
public interface URLCanonicalizer {
public void canonicalize(HandyURL url);
}
|
jauhari-i/minigames-new | src/controllers/GameControllers/index.js | <filename>src/controllers/GameControllers/index.js
import services from '../../services'
import { handleError } from '../../helpers/error'
import { validationResult } from 'express-validator'
const {
GameServices: {
AddGame,
DeleteGame,
ListGameAdmin,
DetailGame,
ActivateGame,
UpdateGame,
DisableGame,
ListGameUser,
ListGameWeb,
DetailGameWeb,
},
} = services
const controller = {
addGameHandler: async (req, res) => {
const validationError = validationResult(req)
if (validationError.errors.length) {
handleError(
{
statusCode: 400,
message: 'Input error',
errors: validationError.errors,
},
res
)
} else {
const {
title,
poster,
image,
genre,
price,
discount,
rating,
description,
difficulty,
capacity,
duration,
url,
ready,
} = req.body
const data = {
title,
poster,
image,
genre,
price,
discount,
rating,
description,
difficulty,
capacity,
duration,
url,
ready,
}
const adminId = req.adminId
const query = await AddGame(data, adminId)
if (query) {
if (!query.success) {
handleError(query, res)
} else {
res.status(query.statusCode).json(query)
}
} else {
handleError({ statusCode: 500, message: 'Internal server error' }, res)
}
}
},
deleteGameHandler: async (req, res) => {
const { gameId } = req.params
const query = await DeleteGame(gameId)
if (query) {
if (!query.success) {
handleError(query, res)
} else {
res.status(query.statusCode).json(query)
}
} else {
handleError({ statusCode: 500, message: 'Internal server error' }, res)
}
},
updateGameHandler: async (req, res) => {
const validationError = validationResult(req)
if (validationError.errors.length) {
handleError(
{
statusCode: 400,
message: 'Input error',
errors: validationError.errors,
},
res
)
} else {
const {
title,
poster,
image,
genre,
price,
discount,
rating,
description,
difficulty,
capacity,
duration,
url,
ready,
} = req.body
const data = {
title,
poster,
image,
genre,
price,
discount,
rating,
description,
difficulty,
capacity,
duration,
url,
ready,
}
const { gameId } = req.params
const query = await UpdateGame(data, gameId)
if (query) {
if (!query.success) {
handleError(query, res)
} else {
res.status(query.statusCode).json(query)
}
} else {
handleError({ statusCode: 500, message: 'Internal server error' }, res)
}
}
},
detailGameHandler: async (req, res) => {
const { gameId } = req.params
const query = await DetailGame(gameId)
if (query) {
if (!query.success) {
handleError(query, res)
} else {
res.status(query.statusCode).json(query)
}
} else {
handleError({ statusCode: 500, message: 'Internal server error' }, res)
}
},
listGameAdminHandler: async (req, res) => {
const query = await ListGameAdmin()
if (query) {
if (!query.success) {
handleError(query, res)
} else {
res.status(query.statusCode).json(query)
}
} else {
handleError({ statusCode: 500, message: 'Internal server error' }, res)
}
},
activateGameHandler: async (req, res) => {
const { gameId } = req.params
const query = await ActivateGame(gameId)
if (query) {
if (!query.success) {
handleError(query, res)
} else {
res.status(query.statusCode).json(query)
}
} else {
handleError({ statusCode: 500, message: 'Internal server error' }, res)
}
},
disableGameHandler: async (req, res) => {
const { gameId } = req.params
const query = await DisableGame(gameId)
if (query) {
if (!query.success) {
handleError(query, res)
} else {
res.status(query.statusCode).json(query)
}
} else {
handleError({ statusCode: 500, message: 'Internal server error' }, res)
}
},
listGameWebHandler: async (req, res) => {
const { userId } = req
const query = await ListGameWeb(userId)
if (query) {
if (!query.success) {
handleError(query, res)
} else {
res.status(query.statusCode).json(query)
}
} else {
handleError({ statusCode: 500, message: 'Internal server error' }, res)
}
},
listGameUserHandler: async (req, res) => {
const { userId } = req
const query = await ListGameUser(userId)
if (query) {
if (!query.success) {
handleError(query, res)
} else {
res.status(query.statusCode).json(query)
}
} else {
handleError({ statusCode: 500, message: 'Internal server error' }, res)
}
},
detailGameWebHandler: async (req, res) => {
const { gameId } = req.params
const { userId } = req
const query = await DetailGameWeb(gameId, userId)
if (query) {
if (!query.success) {
handleError(query, res)
} else {
res.status(query.statusCode).json(query)
}
} else {
handleError({ statusCode: 500, message: 'Internal server error' }, res)
}
},
}
export { controller }
|
krattai/AEBL | blades/mediatomb/src/youtube_service.h | /*MT*
MediaTomb - http://www.mediatomb.cc/
youtube_service.h - this file is part of MediaTomb.
Copyright (C) 2005 <NAME> <<EMAIL>>,
<NAME> <<EMAIL>>
Copyright (C) 2006-2010 <NAME> <<EMAIL>>,
<NAME> <<EMAIL>>,
<NAME> <<EMAIL>>
MediaTomb is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License version 2
as published by the Free Software Foundation.
MediaTomb is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
version 2 along with MediaTomb; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.
$Id$
*/
/// \file youtube_service.h
/// \brief Definition of the YouTubeService class.
#if defined(YOUTUBE) // make sure to add more ifdefs when we get more services
#ifndef __YOUTUBE_SERVICE_H__
#define __YOUTUBE_SERVICE_H__
#include "zmm/zmm.h"
#include "mxml/mxml.h"
#include "online_service.h"
#include "url.h"
#include "dictionary.h"
#include "youtube_content_handler.h"
#include <curl/curl.h>
typedef enum
{
YT_request_none = 0,
YT_request_video_search,
YT_request_stdfeed,
YT_request_user_favorites,
YT_request_user_playlists,
YT_request_user_subscriptions,
YT_request_user_uploads,
YT_subrequest_playlists,
YT_subrequest_subscriptions,
} yt_requests_t;
typedef enum
{
YT_region_au = 0,
YT_region_br,
YT_region_ca,
YT_region_fr,
YT_region_de,
YT_region_gb,
YT_region_nl,
YT_region_hk,
YT_region_ie,
YT_region_it,
YT_region_jp,
YT_region_mx,
YT_region_nz,
YT_region_pl,
YT_region_ru,
YT_region_kr,
YT_region_es,
YT_region_tw,
YT_region_us,
YT_region_none,
} yt_regions_t;
/// \brief This is an interface for all online services, the function
/// handles adding/refreshing content in the database.
class YouTubeService : public OnlineService
{
public:
YouTubeService();
~YouTubeService();
/// \brief Retrieves user specified content from the service and adds
/// the items to the database.
virtual bool refreshServiceData(zmm::Ref<Layout> layout);
/// \brief Get the type of the service (i.e. YouTube, Shoutcast, etc.)
virtual service_type_t getServiceType();
/// \brief Get the human readable name for the service
virtual zmm::String getServiceName();
/// \brief Parse the xml fragment from the configuration and gather
/// the user settings in a service task structure.
virtual zmm::Ref<zmm::Object> defineServiceTask(zmm::Ref<mxml::Element> xmlopt, zmm::Ref<zmm::Object> params);
/// \brief Get the human readable name of a particular request type, i.e.
/// did we request Favorites or Featured videos, etc.
static zmm::String getRequestName(yt_requests_t request);
/// \brief Get the human readable category name
static zmm::String getRegionName(yt_regions_t region_code);
protected:
// the handle *must never be used from multiple threads*
CURL *curl_handle;
// safeguard to ensure the above
pthread_t pid;
// url retriever class
zmm::Ref<URL> url;
/// \brief This function will retrieve the XML according to the parametrs
zmm::Ref<mxml::Element> getData(zmm::String url_part, zmm::Ref<Dictionary> params, bool construct_url = true);
/// \brief This class defines the so called "YouTube task", the task
/// holds various parameters that are needed to perform. A task means
/// the process of downloading, parsing service data and creating
/// CdsObjects.
class YouTubeTask : public zmm::Object
{
public:
YouTubeTask();
/// \brief Request identifier
yt_requests_t request;
/// \brief Region setting
yt_regions_t region;
/// \brief Constructed URL that will be prepended with the base and
/// appended with parameters.
zmm::String url_part;
/// \brief It was so nice when using with the REST API, now we will
/// have to convert the parameters to a specific string.
zmm::Ref<Dictionary> parameters;
/// \brief Amount of items that we are allowed to get.
int amount;
/// \brief Amount of items that have been fetched.
int amount_fetched;
/// \brief Starting index of the item to fetch
int start_index;
/// \brief Starging index as specified in the configuration by the user
int cfg_start_index;
/// \brief Name of the actual subrequest
zmm::String sub_request_name;
/// \brief Special requests have a subfeed
zmm::Ref<YouTubeSubFeed> subfeed;
int subfeed_index;
/// \brief Task must be removed from the tasklist after one time
/// execution
bool kill;
};
/// \brief task that we will be working with when refreshServiceData is
/// called.
int current_task;
// helper functions for parsing config.xml
// zmm::String getCheckAttr(zmm::Ref<mxml::Element> xml, zmm::String attrname);
// int getCheckPosIntAttr(zmm::Ref<mxml::Element> xml, zmm::String attrname);
void getPagingParams(zmm::Ref<mxml::Element> xml,
zmm::Ref<YouTubeTask> task);
void addTimeParams(zmm::Ref<mxml::Element> xml, zmm::Ref<YouTubeTask> task);
yt_regions_t getRegion(zmm::Ref<mxml::Element> xml);
zmm::String getFeed(zmm::Ref<mxml::Element> xml);
// subrequests are spawned as one time tasks, they are removed from the
// task list after one time execution - this function takes care of it
void killOneTimeTasks(zmm::Ref<zmm::Array<zmm::Object> > tasklist);
};
#endif//__ONLINE_SERVICE_H__
#endif//YOUTUBE
|
neha-b2001/wildfly-core | cli/src/test/java/org/jboss/as/cli/completion/address/test/NodeNameFormattingTestCase.java | <gh_stars>100-1000
/*
* JBoss, Home of Professional Open Source.
* Copyright 2015, Red Hat, Inc., and individual contributors
* as indicated by the @author tags. See the copyright.txt file in the
* distribution for a full listing of individual contributors.
*
* This 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.
*
* This software 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 this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
package org.jboss.as.cli.completion.address.test;
import static org.junit.Assert.assertEquals;
import java.util.Arrays;
import java.util.Collections;
import org.jboss.as.cli.completion.mock.MockNode;
import org.junit.Test;
/**
*
* @author <NAME>
*/
public class NodeNameFormattingTestCase extends AbstractAddressCompleterTest {
public NodeNameFormattingTestCase() {
super();
MockNode root = addRoot("root");
root.addChild("colon:");
root.addChild("slash/");
root.addChild("back\\slash");
root.addChild("both/:");
root.addChild("all equals= slash/ colon: \"quotes\"");
root.addChild("equals=equals");
MockNode datasource = root.addChild("datasources").addChild("data-source");
datasource.addChild("java:/H2DS1");
datasource.addChild("java:/H2DS2");
}
@Test
public void testAll() {
assertEquals(Arrays.asList("all equals= slash/ colon: \"quotes\"", "back\\slash", "both/:", "colon:", "datasources", "equals=equals", "slash/"), fetchCandidates("/root="));
}
@Test
public void testColon() {
//assertEquals(Arrays.asList("\"colon:\""), fetchCandidates("/root=c"));
assertEquals(Arrays.asList("colon\\:"), fetchCandidates("/root=c"));
}
@Test
public void testSlash() {
//assertEquals(Arrays.asList("\"slash/\""), fetchCandidates("/root=s"));
assertEquals(Arrays.asList("slash\\/"), fetchCandidates("/root=s"));
}
@Test
public void testBackSlash() {
assertEquals(Arrays.asList("back\\\\slash"), fetchCandidates("/root=ba"));
}
@Test
public void testBoth() {
//assertEquals(Arrays.asList("\"both/:\""), fetchCandidates("/root=b"));
assertEquals(Arrays.asList("both\\/\\:"), fetchCandidates("/root=bo"));
}
@Test
public void testQuotes() {
//assertEquals(Arrays.asList("\"all equals= slash/ colon: \\\"quotes\\\"\""), fetchCandidates("/root=a"));
assertEquals(Arrays.asList("all\\ equals\\=\\ slash\\/\\ colon\\:\\ \\\"quotes\\\""), fetchCandidates("/root=a"));
}
@Test
public void testEquals() {
assertEquals(Collections.emptyList(), fetchCandidates("/root=equals="));
assertEquals(Arrays.asList("equals\\=equals"), fetchCandidates("/root=\"equals=\""));
}
@Test
public void testH2DS() {
assertEquals(Arrays.asList("data-source="), fetchCandidates("/root=datasources/"));
assertEquals(Arrays.asList("java\\:\\/H2DS1", "java\\:\\/H2DS2"), fetchCandidates("/root=datasources/data-source=j"));
}
}
|
UprootStaging/maven-OpenViewerFX-src | OpenViewerFX/src/main/java/org/jpedal/parser/image/utils/JPegImageDecoder.java | <reponame>UprootStaging/maven-OpenViewerFX-src
/*
* ===========================================
* Java Pdf Extraction Decoding Access Library
* ===========================================
*
* Project Info: http://www.idrsolutions.com
* Help section for developers at http://www.idrsolutions.com/support/
*
* (C) Copyright 1997-2015 IDRsolutions and Contributors.
*
* This file is part of JPedal/JPDF2HTML5
*
This library 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.
This library 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 this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* ---------------
* JPegImageDecoder.java
* ---------------
*/
package org.jpedal.parser.image.utils;
import java.awt.image.BufferedImage;
import org.jpedal.color.ColorSpaces;
import org.jpedal.color.DeviceCMYKColorSpace;
import org.jpedal.color.DeviceRGBColorSpace;
import org.jpedal.color.GenericColorSpace;
import org.jpedal.external.ErrorTracker;
import org.jpedal.objects.raw.PdfObject;
import org.jpedal.parser.ParserOptions;
import org.jpedal.parser.image.data.ImageData;
import org.jpedal.utils.LogWriter;
/**
*
* @author markee
*/
public class JPegImageDecoder {
public static BufferedImage decode(final String name, int w, int h, boolean arrayInverted,
GenericColorSpace decodeColorData, byte[] data, final float[] decodeArray, final ImageData imageData,
final PdfObject XObject, ErrorTracker errorTracker, ParserOptions parserOptions) {
GenericColorSpace jpegDecodeColorData=decodeColorData;
BufferedImage image=null;
//handle JPEGS
if(LogWriter.isOutput()) {
LogWriter.writeLog("JPeg Image " + name + ' ' + w + "W * " + h + 'H' + " arrayInverted=" + arrayInverted);
}
/**
try {
java.io.FileOutputStream a =new java.io.FileOutputStream("/Users/markee/Desktop/jpg.jpg");
a.write(data);
a.flush();
a.close();
} catch (Exception e) {
LogWriter.writeLog("Unable to save jpeg " + name);
} /**/
//if ICC with Alt RGB, use alternative first
boolean decodedOnAltColorspace=false;
if(decodeColorData.getID()==ColorSpaces.ICC){
//try first and catch any error
final int alt=decodeColorData.getAlternateColorSpace();
GenericColorSpace altDecodeColorData = null;
if(alt==ColorSpaces.DeviceRGB) {
altDecodeColorData = new DeviceRGBColorSpace();
} else if(alt==ColorSpaces.DeviceCMYK) {
altDecodeColorData = new DeviceCMYKColorSpace();
}
//try if any alt found
if(altDecodeColorData!=null){
try{
image=altDecodeColorData.JPEGToRGBImage(data, w, h, decodeArray,imageData.getpX() , imageData.getpY() , arrayInverted, XObject);
//if it returns image it worked flag and switch over
if(image!=null){
decodedOnAltColorspace=true;
jpegDecodeColorData=altDecodeColorData;
//flag if YCCK
if(jpegDecodeColorData.isImageYCCK()) {
parserOptions.hasYCCKimages = true;
}
}
}catch(final Exception e){
errorTracker.addPageFailureMessage("Unable to use alt colorspace with " + name + " to JPEG");
//tell user and log
if(LogWriter.isOutput()) {
LogWriter.writeLog("Exception: " + e.getMessage());
}
//
if(image!=null){
image.flush();
}
image=null;
}
}
}
/**decode if not done above*/
if(!decodedOnAltColorspace){
//separation, renderer
try{
image=jpegDecodeColorData.JPEGToRGBImage(data, w, h, decodeArray,imageData.getpX(),imageData.getpY() , arrayInverted, XObject);
//flag if YCCK
if(jpegDecodeColorData.isImageYCCK()) {
parserOptions.hasYCCKimages = true;
}
//image=simulateOP(image);
}catch(final Exception e){
errorTracker.addPageFailureMessage("Problem converting " + name + " to JPEG");
//tell user and log
if(LogWriter.isOutput()) {
LogWriter.writeLog("Exception: " + e.getMessage());
}
//
image.flush();
image=null;
}
}
return image;
}
}
|
harrinry/QRPortal | public/src/body-rules-list/index.js | import { connect } from 'react-redux';
import BodyRulesList from './brl-model';
import { childConstructor, SearchChildConstructor, standardsChildConstructor } from './brl-lib';
import { fetchDetailsData } from 'details-section/ds-actions';
import { setSelected } from './brl-actions';
import { setSelectedSearchResult } from 'global-search/gs-actions';
import './style';
const mapDispatchToProps = (dispatch) => {
return {
arrayChildConstructor: (val, index) => {
return childConstructor(val, index, () => {
if(val.searchid) dispatch(setSelectedSearchResult(val.id));
else dispatch(setSelected(val.id));
dispatch(fetchDetailsData(val.href));
});
},
SearchArrayChildConstructor: (val, index) => {
return SearchChildConstructor(val, index, () => {
if(val.searchid) dispatch(setSelectedSearchResult(val.id));
else dispatch(setSelected(val.id));
dispatch(fetchDetailsData(val.href));
});
},
arrayChildConstructorFromStandards: (val, index) => {
return standardsChildConstructor(val, index, () => {
if(val.searchid) dispatch(setSelectedSearchResult(val.id));
else dispatch(setSelected(val.id));
dispatch(fetchDetailsData(val.href));
});
},
};
};
const mapStateToProps = (state) => {
return {
data: state.rulesList.data,
searchVisible: state.search.resultsVisible,
searchResults: state.search.results,
loading: state.rulesList.loading,
customMessage: state.rulesList.customMessage,
listCount: state.contentBody.listCount,
};
};
export default connect(mapStateToProps,mapDispatchToProps)(BodyRulesList);
|
snowberryfield/printemps | printemps/option/enumerate/enumerate.h | /*****************************************************************************/
// Copyright (c) 2020-2021 <NAME>
// Released under the MIT license
// https://opensource.org/licenses/mit-license.php
/*****************************************************************************/
#ifndef PRINTEMPS_OPTION_ENUMERATE_H__
#define PRINTEMPS_OPTION_ENUMERATE_H__
#include "selection_mode.h"
#include "chain_move_reduce_mode.h"
#include "improvability_screening_mode.h"
#include "verbose.h"
#include "tabu_mode.h"
#endif
/*****************************************************************************/
// END
/*****************************************************************************/ |
HritikR/secretlint | examples/benchmark/targets/js-primer/tools/typo-finder.js | <reponame>HritikR/secretlint
// LICENSE : MIT
"use strict";
const globby = require("globby");
const fs = require("fs");
const path = require("path");
const sourceDir = path.join(__dirname, "..", "source");
const remark = require("remark")();
const select = require("unist-util-select");
const lodash = require("lodash");
const levenshtein = require("js-levenshtein");
/**
* Usage: node typo-finder.js
*
* Find typo using levenshtein algorithm.
*/
const files = globby.sync([
`${sourceDir}/**/*.md`,
`!${sourceDir}/**/node_modules{,/**}`,
`!**/OUTLINE.md`
]);
const strings = [];
files.forEach(filePath => {
const content = fs.readFileSync(filePath, "utf-8");
const AST = remark.parse(content);
const codes = select(AST, `inlineCode`);
codes.forEach(code => {
strings.push(code.value);
});
});
class Typo {
constructor(strings) {
this.strings = strings;
this.gropupByKey = lodash.groupBy(strings);
}
keys() {
return Object.keys(this.gropupByKey);
}
countOfKey(key) {
if (key in this.gropupByKey) {
return this.gropupByKey[key].length;
}
return 0;
}
getSimilarKey(key, { distance, minKeyLength }) {
const allKeys = this.keys();
return allKeys.map(targetKey => {
const distance = levenshtein(key, targetKey);
return {
key: targetKey,
length: targetKey.length,
distance
};
}).filter(keyInfo => {
return keyInfo.distance === distance && keyInfo.length >= minKeyLength;
});
}
preferKey(keyA, keyB) {
return this.countOfKey(keyA) - this.countOfKey(keyB);
}
}
const typo = new Typo(strings);
typo.keys().forEach(key => {
const matches = typo.getSimilarKey(key, {
distance: 1,
minKeyLength: 3
});
if (matches.length === 0) {
return;
}
const preferResults = matches.filter(match => {
return typo.preferKey(key, match.key) < 0;
});
if (preferResults.length === 0) {
return;
}
const print = (results) => {
return results.map(result => {
return `${result.key} is used ${typo.countOfKey(result.key)} times. Distance is ${result.distance}`;
}).join("\n");
};
console.log(`
-----------------------
${key} may be typo. It is used at ${typo.countOfKey(key)} times.
Alternatives:
${print(preferResults)}
-----------------------
`);
});
|
emerfelippini/Curso_em_video-Aulas_Python | ex023a.py | #frase = input('Digite um número de 0 a 9999: ')
#print('A unidade é {}'.format(frase[3]))
#print('A dezena é {}'.format(frase[2]))
#print('A centena é {}'.format(frase[1]))
#print('A milhar é {}'.format(frase[0]))
num = int(input('Digite um número: '))
print('Analisando seu número ...')
u = num // 1 % 10
d = num // 10 % 10
c = num // 100 % 10
m = num // 1000 % 10
print('A unidade é {} '.format(u))
print('A dezena é {}'.format(d))
print('A centena é {}'.format(c))
print('O milhar é {}'.format(m)) |
weimingtom/eepp | src/eepp/window/backend/SDL2/cbackendsdl2.hpp | #ifndef EE_WINDOWCBACKENDSDL2_HPP
#define EE_WINDOWCBACKENDSDL2_HPP
#include <eepp/window/cbackend.hpp>
#include <eepp/window/backend/SDL2/base.hpp>
#ifdef EE_BACKEND_SDL2
#include <eepp/window/backend/SDL2/cwindowsdl2.hpp>
namespace EE { namespace Window { namespace Backend { namespace SDL2 {
class EE_API cBackendSDL2 : public cBackend {
public:
cBackendSDL2();
~cBackendSDL2();
};
}}}}
#endif
#endif
|
1587257781/test | main/java/com/tenhisi/web/cgs/entity/CqsHomeinfoDisabledEntity.java | <gh_stars>0
/*
* All content copyright http://www.tenhisi.com, unless
* otherwise indicated. All rights reserved.
* No deletion without permission
*/
package com.tenhisi.web.cgs.entity;
import com.baomidou.mybatisplus.annotation.*;
import javax.validation.constraints.NotNull;
import com.baomidou.mybatisplus.annotation.TableLogic;
import com.tenhisi.common.core.base.entity.BaseEntity;
import lombok.Getter;
import lombok.Setter;
/**
* cqs_homeinfo_disabled
* @author: Shane
* @date 2021-09-06 02:39:54
*/
@Getter
@Setter
@TableName("cqs_homeinfo_disabled")
public class CqsHomeinfoDisabledEntity extends BaseEntity {
private static final long serialVersionUID = 1L;
/** 主键 */
@TableId(value = "id",type = IdType.ASSIGN_ID)
private Long id;
/** 父键 */
@NotNull(message = "参数值不能为空")
private Long pid;
/** 残疾类别 */
private String hdType;
/** 等级 */
private String hdGrade;
/** 残疾人证号 */
private String hdIdno;
/** 爱好特长 */
private String hobbies;
/** 监护人 */
private String guardian;
/** 删除标志（0代表存在 1代表删除） */
@TableLogic
@TableField(value = "del_flag", fill = FieldFill.INSERT)
private String delFlag;
}
|
couldhll/AMS | modules/keyboardmenus/client/controllers/manage.keyboardmenus.client.controller.js | <filename>modules/keyboardmenus/client/controllers/manage.keyboardmenus.client.controller.js
'use strict';
// Manage Keyboardmenu controller
angular.module('keyboardmenus').controller('ManageKeyboardmenusController', ['$scope', '$stateParams', '$location', 'Authentication', 'Keyboardmenus', 'ImageUploader', '$window', '$timeout',
function ($scope, $stateParams, $location, Authentication, Keyboardmenus, ImageUploader, $window, $timeout) {
$scope.authentication = Authentication;
$scope.keyboardmenus = Keyboardmenus.query();
// Uploader
$scope.uploader = ImageUploader.uploader;
$scope.uploadPicture = function () {
ImageUploader.uploadPicture();
};
$scope.uploader.onSuccessItem = function (fileItem, response, status, headers) {
// Update image url
var keyboardmenu = response;
$scope.uploaderKeyboardmenu.iconiPad1xURL = keyboardmenu.iconiPad1xURL;
$scope.uploaderKeyboardmenu.iconiPad2xURL = keyboardmenu.iconiPad2xURL;
$scope.uploaderKeyboardmenu.iconiPhone2xURL = keyboardmenu.iconiPhone2xURL;
$scope.uploaderKeyboardmenu.iconiPhone3xURL = keyboardmenu.iconiPhone3xURL;
$scope.uploaderKeyboardmenu.selectIconiPad1xURL = keyboardmenu.selectIconiPad1xURL;
$scope.uploaderKeyboardmenu.selectIconiPad2xURL = keyboardmenu.selectIconiPad2xURL;
$scope.uploaderKeyboardmenu.selectIconiPhone2xURL = keyboardmenu.selectIconiPhone2xURL;
$scope.uploaderKeyboardmenu.selectIconiPhone3xURL = keyboardmenu.selectIconiPhone3xURL;
$scope.uploaderKeyboardmenu.highlightIconiPad1xURL = keyboardmenu.highlightIconiPad1xURL;
$scope.uploaderKeyboardmenu.highlightIconiPad2xURL = keyboardmenu.highlightIconiPad2xURL;
$scope.uploaderKeyboardmenu.highlightIconiPhone2xURL = keyboardmenu.highlightIconiPhone2xURL;
$scope.uploaderKeyboardmenu.highlightIconiPhone3xURL = keyboardmenu.highlightIconiPhone3xURL;
$scope.uploaderKeyboardmenu.iconThemeiPad1xURL = keyboardmenu.iconThemeiPad1xURL;
$scope.uploaderKeyboardmenu.iconThemeiPad2xURL = keyboardmenu.iconThemeiPad2xURL;
$scope.uploaderKeyboardmenu.iconThemeiPhone2xURL = keyboardmenu.iconThemeiPhone2xURL;
$scope.uploaderKeyboardmenu.iconThemeiPhone3xURL = keyboardmenu.iconThemeiPhone3xURL;
$scope.uploaderKeyboardmenu.selectIconThemeiPad1xURL = keyboardmenu.selectIconThemeiPad1xURL;
$scope.uploaderKeyboardmenu.selectIconThemeiPad2xURL = keyboardmenu.selectIconThemeiPad2xURL;
$scope.uploaderKeyboardmenu.selectIconThemeiPhone2xURL = keyboardmenu.selectIconThemeiPhone2xURL;
$scope.uploaderKeyboardmenu.selectIconThemeiPhone3xURL = keyboardmenu.selectIconThemeiPhone3xURL;
$scope.uploaderKeyboardmenu.highlightIconThemeiPad1xURL = keyboardmenu.highlightIconThemeiPad1xURL;
$scope.uploaderKeyboardmenu.highlightIconThemeiPad2xURL = keyboardmenu.highlightIconThemeiPad2xURL;
$scope.uploaderKeyboardmenu.highlightIconThemeiPhone2xURL = keyboardmenu.highlightIconThemeiPhone2xURL;
$scope.uploaderKeyboardmenu.highlightIconThemeiPhone3xURL = keyboardmenu.highlightIconThemeiPhone3xURL;
};
// Init keyboardmenu
$scope.keyboardmenuGridOptions = {
// Sort
enableSorting: true,
// Select
enableRowSelection: true,
multiSelect: false,
modifierKeysToMultiSelect: false,
noUnselect: true,
enableFullRowSelection: true,
// Export
exporterCsvFilename: 'myFile.csv',
exporterPdfDefaultStyle: {fontSize: 9},
exporterPdfTableStyle: {margin: [30, 30, 30, 30]},
exporterPdfTableHeaderStyle: {fontSize: 10, bold: true, italics: true, color: 'red'},
exporterPdfHeader: { text: "Keyboardmenu", style: 'headerStyle' },
exporterPdfFooter: function ( currentPage, pageCount ) {
return { text: currentPage.toString() + ' of ' + pageCount.toString(), style: 'footerStyle' };
},
exporterPdfCustomFormatter: function ( docDefinition ) {
docDefinition.styles.headerStyle = { fontSize: 22, bold: true };
docDefinition.styles.footerStyle = { fontSize: 10, bold: true };
return docDefinition;
},
exporterPdfOrientation: 'portrait',
exporterPdfPageSize: 'LETTER',
exporterPdfMaxGridWidth: 500,
exporterCsvLinkElement: angular.element(document.querySelectorAll(".custom-csv-link-location")),
// Data
enableGridMenu: true,
rowTemplate: '<div grid="grid" class="ui-grid-draggable-row" draggable="true"><div ng-repeat="(colRenderIndex, col) in colContainer.renderedColumns track by col.colDef.name" class="ui-grid-cell" ng-class="{ \'ui-grid-row-header-cell\': col.isRowHeader, \'custom\': true }" ui-grid-cell></div></div>',
columnDefs: [
{ field: '_id', minWidth: '100', enableCellEdit:false },
{ field: 'type', minWidth: '100',
editableCellTemplate: 'ui-grid/dropdownEditor',
editDropdownOptionsArray: [
{ type: 'classic' },
{ type: 'nijigen' }
],
editDropdownIdLabel: 'type',
editDropdownValueLabel: 'type' },
{ field: 'position', minWidth: '100',
editableCellTemplate: 'ui-grid/dropdownEditor',
editDropdownOptionsArray: [
{ position: 'menu' },
{ position: 'toolbar' }
],
editDropdownIdLabel: 'position',
editDropdownValueLabel: 'position' },
{ field: 'name' , minWidth: '100' },
{ field: 'title' , minWidth: '100' },
{ field: 'selectTitle' , minWidth: '100' },
{ field: 'iconFile' , minWidth: '100' },
{ field: 'iconiPad1xURL', minWidth: '150',
cellTemplate: '<div class="ui-grid-cell-contents"><img width="48" height="48" src="{{ COL_FIELD }}" /></div>',
editableCellTemplate: '<div contentEditable ui-grid-edit-upload><span class="btn btn-default btn-file">Browse <input type="file" nv-file-select uploader="grid.appScope.uploader"></span><button type="button" class="btn btn-success" ng-click="grid.appScope.uploadClick();$emit(\'EventUpload\');">Upload</button></div>' },
{ field: 'iconiPad2xURL', minWidth: '150',
cellTemplate: '<div class="ui-grid-cell-contents"><img width="96" height="96" src="{{ COL_FIELD }}" set-row-height /></div>',
editableCellTemplate: '<div contentEditable ui-grid-edit-upload><span class="btn btn-default btn-file">Browse <input type="file" nv-file-select uploader="grid.appScope.uploader"></span><button type="button" class="btn btn-success" ng-click="grid.appScope.uploadClick();$emit(\'EventUpload\');">Upload</button></div>' },
{ field: 'iconiPhone2xURL', minWidth: '150',
cellTemplate: '<div class="ui-grid-cell-contents"><img width="53" height="53" src="{{ COL_FIELD }}" /></div>',
editableCellTemplate: '<div contentEditable ui-grid-edit-upload><span class="btn btn-default btn-file">Browse <input type="file" nv-file-select uploader="grid.appScope.uploader"></span><button type="button" class="btn btn-success" ng-click="grid.appScope.uploadClick();$emit(\'EventUpload\');">Upload</button></div>' },
{ field: 'iconiPhone3xURL', minWidth: '150',
cellTemplate: '<div class="ui-grid-cell-contents"><img width="80" height="80" src="{{ COL_FIELD }}" /></div>',
editableCellTemplate: '<div contentEditable ui-grid-edit-upload><span class="btn btn-default btn-file">Browse <input type="file" nv-file-select uploader="grid.appScope.uploader"></span><button type="button" class="btn btn-success" ng-click="grid.appScope.uploadClick();$emit(\'EventUpload\');">Upload</button></div>' },
{ field: 'selectIconFile', minWidth: '100' },
{ field: 'selectIconiPad1xURL', minWidth: '150',
cellTemplate: '<div class="ui-grid-cell-contents"><img width="48" height="48" src="{{ COL_FIELD }}" /></div>',
editableCellTemplate: '<div contentEditable ui-grid-edit-upload><span class="btn btn-default btn-file">Browse <input type="file" nv-file-select uploader="grid.appScope.uploader"></span><button type="button" class="btn btn-success" ng-click="grid.appScope.uploadClick();$emit(\'EventUpload\');">Upload</button></div>' },
{ field: 'selectIconiPad2xURL', minWidth: '150',
cellTemplate: '<div class="ui-grid-cell-contents"><img width="96" height="96" src="{{ COL_FIELD }}" /></div>',
editableCellTemplate: '<div contentEditable ui-grid-edit-upload><span class="btn btn-default btn-file">Browse <input type="file" nv-file-select uploader="grid.appScope.uploader"></span><button type="button" class="btn btn-success" ng-click="grid.appScope.uploadClick();$emit(\'EventUpload\');">Upload</button></div>' },
{ field: 'selectIconiPhone2xURL', minWidth: '150',
cellTemplate: '<div class="ui-grid-cell-contents"><img width="53" height="53" src="{{ COL_FIELD }}" /></div>',
editableCellTemplate: '<div contentEditable ui-grid-edit-upload><span class="btn btn-default btn-file">Browse <input type="file" nv-file-select uploader="grid.appScope.uploader"></span><button type="button" class="btn btn-success" ng-click="grid.appScope.uploadClick();$emit(\'EventUpload\');">Upload</button></div>' },
{ field: 'selectIconiPhone3xURL', minWidth: '150',
cellTemplate: '<div class="ui-grid-cell-contents"><img width="80" height="80" src="{{ COL_FIELD }}" /></div>',
editableCellTemplate: '<div contentEditable ui-grid-edit-upload><span class="btn btn-default btn-file">Browse <input type="file" nv-file-select uploader="grid.appScope.uploader"></span><button type="button" class="btn btn-success" ng-click="grid.appScope.uploadClick();$emit(\'EventUpload\');">Upload</button></div>' },
{ field: 'highlightIconFile', minWidth: '100' },
{ field: 'highlightIconiPad1xURL', minWidth: '150',
cellTemplate: '<div class="ui-grid-cell-contents"><img width="48" height="48" src="{{ COL_FIELD }}" /></div>',
editableCellTemplate: '<div contentEditable ui-grid-edit-upload><span class="btn btn-default btn-file">Browse <input type="file" nv-file-select uploader="grid.appScope.uploader"></span><button type="button" class="btn btn-success" ng-click="grid.appScope.uploadClick();$emit(\'EventUpload\');">Upload</button></div>' },
{ field: 'highlightIconiPad2xURL', minWidth: '150',
cellTemplate: '<div class="ui-grid-cell-contents"><img width="96" height="96" src="{{ COL_FIELD }}" /></div>',
editableCellTemplate: '<div contentEditable ui-grid-edit-upload><span class="btn btn-default btn-file">Browse <input type="file" nv-file-select uploader="grid.appScope.uploader"></span><button type="button" class="btn btn-success" ng-click="grid.appScope.uploadClick();$emit(\'EventUpload\');">Upload</button></div>' },
{ field: 'highlightIconiPhone2xURL', minWidth: '150',
cellTemplate: '<div class="ui-grid-cell-contents"><img width="53" height="53" src="{{ COL_FIELD }}" /></div>',
editableCellTemplate: '<div contentEditable ui-grid-edit-upload><span class="btn btn-default btn-file">Browse <input type="file" nv-file-select uploader="grid.appScope.uploader"></span><button type="button" class="btn btn-success" ng-click="grid.appScope.uploadClick();$emit(\'EventUpload\');">Upload</button></div>' },
{ field: 'highlightIconiPhone3xURL', minWidth: '150',
cellTemplate: '<div class="ui-grid-cell-contents"><img width="80" height="80" src="{{ COL_FIELD }}" /></div>',
editableCellTemplate: '<div contentEditable ui-grid-edit-upload><span class="btn btn-default btn-file">Browse <input type="file" nv-file-select uploader="grid.appScope.uploader"></span><button type="button" class="btn btn-success" ng-click="grid.appScope.uploadClick();$emit(\'EventUpload\');">Upload</button></div>' },
{ field: 'iconThemeFile', minWidth: '100' },
{ field: 'iconThemeiPad1xURL', minWidth: '150',
cellTemplate: '<div class="ui-grid-cell-contents"><img width="48" height="48" src="{{ COL_FIELD }}" /></div>',
editableCellTemplate: '<div contentEditable ui-grid-edit-upload><span class="btn btn-default btn-file">Browse <input type="file" nv-file-select uploader="grid.appScope.uploader"></span><button type="button" class="btn btn-success" ng-click="grid.appScope.uploadClick();$emit(\'EventUpload\');">Upload</button></div>' },
{ field: 'iconThemeiPad2xURL', minWidth: '150',
cellTemplate: '<div class="ui-grid-cell-contents"><img width="96" height="96" src="{{ COL_FIELD }}" /></div>',
editableCellTemplate: '<div contentEditable ui-grid-edit-upload><span class="btn btn-default btn-file">Browse <input type="file" nv-file-select uploader="grid.appScope.uploader"></span><button type="button" class="btn btn-success" ng-click="grid.appScope.uploadClick();$emit(\'EventUpload\');">Upload</button></div>' },
{ field: 'iconThemeiPhone2xURL', minWidth: '150',
cellTemplate: '<div class="ui-grid-cell-contents"><img width="53" height="53" src="{{ COL_FIELD }}" /></div>',
editableCellTemplate: '<div contentEditable ui-grid-edit-upload><span class="btn btn-default btn-file">Browse <input type="file" nv-file-select uploader="grid.appScope.uploader"></span><button type="button" class="btn btn-success" ng-click="grid.appScope.uploadClick();$emit(\'EventUpload\');">Upload</button></div>' },
{ field: 'iconThemeiPhone3xURL', minWidth: '150',
cellTemplate: '<div class="ui-grid-cell-contents"><img width="80" height="80" src="{{ COL_FIELD }}" /></div>',
editableCellTemplate: '<div contentEditable ui-grid-edit-upload><span class="btn btn-default btn-file">Browse <input type="file" nv-file-select uploader="grid.appScope.uploader"></span><button type="button" class="btn btn-success" ng-click="grid.appScope.uploadClick();$emit(\'EventUpload\');">Upload</button></div>' },
{ field: 'selectIconThemeFile', minWidth: '100' },
{ field: 'selectIconThemeiPad1xURL', minWidth: '150',
cellTemplate: '<div class="ui-grid-cell-contents"><img width="48" height="48" src="{{ COL_FIELD }}" /></div>',
editableCellTemplate: '<div contentEditable ui-grid-edit-upload><span class="btn btn-default btn-file">Browse <input type="file" nv-file-select uploader="grid.appScope.uploader"></span><button type="button" class="btn btn-success" ng-click="grid.appScope.uploadClick();$emit(\'EventUpload\');">Upload</button></div>' },
{ field: 'selectIconThemeiPad2xURL', minWidth: '150',
cellTemplate: '<div class="ui-grid-cell-contents"><img width="96" height="96" src="{{ COL_FIELD }}" /></div>',
editableCellTemplate: '<div contentEditable ui-grid-edit-upload><span class="btn btn-default btn-file">Browse <input type="file" nv-file-select uploader="grid.appScope.uploader"></span><button type="button" class="btn btn-success" ng-click="grid.appScope.uploadClick();$emit(\'EventUpload\');">Upload</button></div>' },
{ field: 'selectIconThemeiPhone2xURL', minWidth: '150',
cellTemplate: '<div class="ui-grid-cell-contents"><img width="53" height="53" src="{{ COL_FIELD }}" /></div>',
editableCellTemplate: '<div contentEditable ui-grid-edit-upload><span class="btn btn-default btn-file">Browse <input type="file" nv-file-select uploader="grid.appScope.uploader"></span><button type="button" class="btn btn-success" ng-click="grid.appScope.uploadClick();$emit(\'EventUpload\');">Upload</button></div>' },
{ field: 'selectIconThemeiPhone3xURL', minWidth: '150',
cellTemplate: '<div class="ui-grid-cell-contents"><img width="80" height="80" src="{{ COL_FIELD }}" /></div>',
editableCellTemplate: '<div contentEditable ui-grid-edit-upload><span class="btn btn-default btn-file">Browse <input type="file" nv-file-select uploader="grid.appScope.uploader"></span><button type="button" class="btn btn-success" ng-click="grid.appScope.uploadClick();$emit(\'EventUpload\');">Upload</button></div>' },
{ field: 'highlightIconThemeFile', minWidth: '100' },
{ field: 'highlightIconThemeiPad1xURL', minWidth: '150',
cellTemplate: '<div class="ui-grid-cell-contents"><img width="48" height="48" src="{{ COL_FIELD }}" /></div>',
editableCellTemplate: '<div contentEditable ui-grid-edit-upload><span class="btn btn-default btn-file">Browse <input type="file" nv-file-select uploader="grid.appScope.uploader"></span><button type="button" class="btn btn-success" ng-click="grid.appScope.uploadClick();$emit(\'EventUpload\');">Upload</button></div>' },
{ field: 'highlightIconThemeiPad2xURL', minWidth: '150',
cellTemplate: '<div class="ui-grid-cell-contents"><img width="96" height="96" src="{{ COL_FIELD }}" /></div>',
editableCellTemplate: '<div contentEditable ui-grid-edit-upload><span class="btn btn-default btn-file">Browse <input type="file" nv-file-select uploader="grid.appScope.uploader"></span><button type="button" class="btn btn-success" ng-click="grid.appScope.uploadClick();$emit(\'EventUpload\');">Upload</button></div>' },
{ field: 'highlightIconThemeiPhone2xURL', minWidth: '150',
cellTemplate: '<div class="ui-grid-cell-contents"><img width="53" height="53" src="{{ COL_FIELD }}" /></div>',
editableCellTemplate: '<div contentEditable ui-grid-edit-upload><span class="btn btn-default btn-file">Browse <input type="file" nv-file-select uploader="grid.appScope.uploader"></span><button type="button" class="btn btn-success" ng-click="grid.appScope.uploadClick();$emit(\'EventUpload\');">Upload</button></div>' },
{ field: 'highlightIconThemeiPhone3xURL', minWidth: '150',
cellTemplate: '<div class="ui-grid-cell-contents"><img width="80" height="80" src="{{ COL_FIELD }}" /></div>',
editableCellTemplate: '<div contentEditable ui-grid-edit-upload><span class="btn btn-default btn-file">Browse <input type="file" nv-file-select uploader="grid.appScope.uploader"></span><button type="button" class="btn btn-success" ng-click="grid.appScope.uploadClick();$emit(\'EventUpload\');">Upload</button></div>' },
{ name: '<NAME>', minWidth: '100', field: 'user.displayName', enableCellEdit:false },
{ name: '<NAME>', minWidth: '100', field: 'created', enableCellEdit:false }
],
data: 'data' };
$scope.addKeyboardmenu = function() {
var keyboardmenus=$scope.keyboardmenus;
var selectKeyboardmenuGroup=$scope.selectKeyboardmenuGroup;
var n = keyboardmenus.length + 1;
// add
var keyboardmenu = new Keyboardmenus({
type: "classic",
position: "menu",
name: n,
title: "Menu " + n,
index: n,
group: selectKeyboardmenuGroup
});
keyboardmenu.$save(function (response) {
// show
var keyboardmenu = response;
keyboardmenus.push(keyboardmenu);
}, function (errorResponse) {
$scope.error = errorResponse.data.message;
});
};
$scope.removeKeyboardmenu = function(removeEntity) {
var keyboardmenu = removeEntity;
};
$scope.beginEditKeyboardmenu = function(rowEntity, colDef, triggerEvent) {
var keyboardmenu = rowEntity;
if (colDef.field=='iconiPad1xURL') {
$scope.uploader.url = '/api/keyboardmenus/' + keyboardmenu._id + '/iconiPad1x';
}
else if(colDef.field=='iconiPad2xURL') {
$scope.uploader.url = '/api/keyboardmenus/' + keyboardmenu._id + '/iconiPad2x';
}
else if(colDef.field=='iconiPhone2xURL') {
$scope.uploader.url = '/api/keyboardmenus/' + keyboardmenu._id + '/iconiPhone2x';
}
else if(colDef.field=='iconiPhone3xURL') {
$scope.uploader.url = '/api/keyboardmenus/' + keyboardmenu._id + '/iconiPhone3x';
}
else if (colDef.field=='selectIconiPad1xURL') {
$scope.uploader.url = '/api/keyboardmenus/' + keyboardmenu._id + '/selectIconiPad1x';
}
else if(colDef.field=='selectIconiPad2xURL') {
$scope.uploader.url = '/api/keyboardmenus/' + keyboardmenu._id + '/selectIconiPad2x';
}
else if(colDef.field=='selectIconiPhone2xURL') {
$scope.uploader.url = '/api/keyboardmenus/' + keyboardmenu._id + '/selectIconiPhone2x';
}
else if(colDef.field=='selectIconiPhone3xURL') {
$scope.uploader.url = '/api/keyboardmenus/' + keyboardmenu._id + '/selectIconiPhone3x';
}
else if (colDef.field=='highlightIconiPad1xURL') {
$scope.uploader.url = '/api/keyboardmenus/' + keyboardmenu._id + '/highlightIconiPad1x';
}
else if(colDef.field=='highlightIconiPad2xURL') {
$scope.uploader.url = '/api/keyboardmenus/' + keyboardmenu._id + '/highlightIconiPad2x';
}
else if(colDef.field=='highlightIconiPhone2xURL') {
$scope.uploader.url = '/api/keyboardmenus/' + keyboardmenu._id + '/highlightIconiPhone2x';
}
else if(colDef.field=='highlightIconiPhone3xURL') {
$scope.uploader.url = '/api/keyboardmenus/' + keyboardmenu._id + '/highlightIconiPhone3x';
}
else if (colDef.field=='iconThemeiPad1xURL') {
$scope.uploader.url = '/api/keyboardmenus/' + keyboardmenu._id + '/iconThemeiPad1x';
}
else if(colDef.field=='iconThemeiPad2xURL') {
$scope.uploader.url = '/api/keyboardmenus/' + keyboardmenu._id + '/iconThemeiPad2x';
}
else if(colDef.field=='iconThemeiPhone2xURL') {
$scope.uploader.url = '/api/keyboardmenus/' + keyboardmenu._id + '/iconThemeiPhone2x';
}
else if(colDef.field=='iconThemeiPhone3xURL') {
$scope.uploader.url = '/api/keyboardmenus/' + keyboardmenu._id + '/iconThemeiPhone3x';
}
else if (colDef.field=='selectIconThemeiPad1xURL') {
$scope.uploader.url = '/api/keyboardmenus/' + keyboardmenu._id + '/selectIconThemeiPad1x';
}
else if(colDef.field=='selectIconThemeiPad2xURL') {
$scope.uploader.url = '/api/keyboardmenus/' + keyboardmenu._id + '/selectIconThemeiPad2x';
}
else if(colDef.field=='selectIconThemeiPhone2xURL') {
$scope.uploader.url = '/api/keyboardmenus/' + keyboardmenu._id + '/selectIconThemeiPhone2x';
}
else if(colDef.field=='selectIconThemeiPhone3xURL') {
$scope.uploader.url = '/api/keyboardmenus/' + keyboardmenu._id + '/selectIconThemeiPhone3x';
}
else if (colDef.field=='highlightIconThemeiPad1xURL') {
$scope.uploader.url = '/api/keyboardmenus/' + keyboardmenu._id + '/highlightIconThemeiPad1x';
}
else if(colDef.field=='highlightIconThemeiPad2xURL') {
$scope.uploader.url = '/api/keyboardmenus/' + keyboardmenu._id + '/highlightIconThemeiPad2x';
}
else if(colDef.field=='highlightIconThemeiPhone2xURL') {
$scope.uploader.url = '/api/keyboardmenus/' + keyboardmenu._id + '/highlightIconThemeiPhone2x';
}
else if(colDef.field=='highlightIconThemeiPhone3xURL') {
$scope.uploader.url = '/api/keyboardmenus/' + keyboardmenu._id + '/highlightIconThemeiPhone3x';
}
$scope.uploaderKeyboardmenu = keyboardmenu;
};
$scope.afterEditKeyboardmenu = function(rowEntity, colDef, newValue, oldValue) {
var keyboardmenu = rowEntity;
if (colDef.name=='Group')
{
var groupId = newValue;
var keyboardmenuGroups=$scope.keyboardmenuGroups;
// find group with id
var group = null;
for(var i=0;i<keyboardmenuGroups.length;i++) {
var keyboardmenuGroup = keyboardmenuGroups[i];
if (keyboardmenuGroup._id == groupId) {
group = keyboardmenuGroup;
break;
}
}
keyboardmenu.group=group;
}
};
$scope.importKeyboardmenu = function(grid, newObjects) {
var keyboardmenus=$scope.keyboardmenus;
var selectKeyboardmenuGroup=$scope.selectKeyboardmenuGroup;
var newKeyboardmenus=newObjects;
var importSuccessCallback = function (response) {
// show
var keyboardmenu = response;
keyboardmenus.push(keyboardmenu);
};
var importErrorCallback = function (errorResponse) {
$scope.error = errorResponse.data.message;
};
// add
for(var i=0;i<newKeyboardmenus.length;i++) {
var newKeyboardmenu = newKeyboardmenus[i];
var n = keyboardmenus.length + 1 + i;
var keyboardmenu = new Keyboardmenus({
type: newKeyboardmenu.type,
position: newKeyboardmenu.position,
name: newKeyboardmenu.name,
title: newKeyboardmenu.title,
index: n,
group: selectKeyboardmenuGroup
});
keyboardmenu.$save(importSuccessCallback, importErrorCallback);
}
};
}
]);
|
electric-eloquence/fepper-npm | test/tests/readme-tests.js | <filename>test/tests/readme-tests.js
'use strict';
const {expect} = require('chai');
const fs = require('fs-extra');
const {
fepper,
responseFactory
} = require('../init')();
const readme = fepper.tcpIp.fpExpress.readme;
describe('Readme', function () {
after(function () {
fs.unlinkSync(`${global.rootDir}/README.md`);
});
it('responds with a 404 if no README.md present', function (done) {
new Promise(
(resolve) => {
readme.main()(
{},
responseFactory(resolve)
);
})
.then((response) => {
expect(response.responseText).to.equal('HTTP 404: Not Found');
done();
})
.catch((err) => {
done(err);
});
});
it('responds with README.md rendered as HTML if README.md present', function (done) {
new Promise(
(resolve) => {
fs.writeFileSync(
`${global.rootDir}/README.md`,
'# Fepper\n\n## A frontend prototyper tool for rapid prototyping of websites'
);
readme.main()(
{},
responseFactory(resolve)
);
})
.then((response) => {
/* eslint-disable max-len */
expect(response.responseText).to.equal(`
<!DOCTYPE html>
<html class="">
<head>
<title id="title">Fepper</title>
<meta charset="utf-8">
<!-- Disable cache -->
<meta http-equiv="cache-control" content="max-age=0">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">
<meta http-equiv="expires" content="Tue, 01 Jan 1980 1:00:00 GMT">
<meta http-equiv="pragma" content="no-cache">
<link rel="stylesheet" href="/webserved/core.css">
</head>
<body class="text">
<main id="readme" class="readme">
<div id="message" class="message "></div><h1 id="fepper">Fepper</h1>
<h2 id="a-frontend-prototyper-tool-for-rapid-prototyping-of-websites">A frontend prototyper tool for rapid prototyping of websites</h2>
</main>
</body>
</html>`);
/* eslint-enable max-len */
done();
})
.catch((err) => {
done(err);
});
});
});
|
harkhuang/harkcode | go/thewaytogo/exercises/chapter_15/http_fetch2.go | <filename>go/thewaytogo/exercises/chapter_15/http_fetch2.go
// httpfetch.go
package main
import (
"bufio"
"fmt"
"net/http"
"io/ioutil"
"log"
"os"
"strings"
)
func main() {
fmt.Print("Give the url from which to read: ")
iread := bufio.NewReader(os.Stdin)
url, _ := iread.ReadString('\n')
url = strings.Trim(url," \n\r") // trimming space,etc.
// fmt.Println("***", url,"***") // debugging
res, err := http.Get(url)
CheckError(err)
data, err := ioutil.ReadAll(res.Body)
CheckError(err)
fmt.Printf("Got: %q", string(data))
}
func CheckError(err error) {
if err != nil {
log.Fatalf("Get: %v", err)
}
}
|
Tau-Coin/taucoin-mobile-mining-ipfs | taucoinj-core/src/main/java/io/taucoin/db/state/StateRecord.java | <reponame>Tau-Coin/taucoin-mobile-mining-ipfs
package io.taucoin.db.state;
import io.taucoin.core.AccountState;
import io.taucoin.db.ByteArrayWrapper;
import org.spongycastle.util.encoders.Hex;
/**
States tag file record format:
Hex(address):Hex(RLP(AccountState))
*/
public class StateRecord {
private ByteArrayWrapper address;
private AccountState state;
public StateRecord(String recordStr) {
if (recordStr != null && !recordStr.isEmpty()) {
String[] elements = recordStr.split(":");
if (elements != null && elements.length == 2) {
address = new ByteArrayWrapper(Hex.decode(elements[0]));
state = new AccountState(Hex.decode(elements[1]));
}
}
}
public ByteArrayWrapper getAddress() {
return address;
}
public AccountState getAccountState() {
return state;
}
public boolean isValid() {
return address != null && state != null;
}
@Override
public String toString() {
String str;
if (!isValid()) {
str = "[null]";
} else {
str = "[" + Hex.toHexString(address.getData()) + ":" + state.toString() + "]";
}
return str;
}
}
|
DreadfullyDistinct/virtual-schemas | src/main/java/com/exasol/adapter/dialects/bigquery/BigQuerySqlDialectFactory.java | package com.exasol.adapter.dialects.bigquery;
import java.sql.Connection;
import com.exasol.adapter.AdapterProperties;
import com.exasol.adapter.dialects.AbstractSqlDialectFactory;
import com.exasol.adapter.dialects.SqlDialect;
/**
* Factory for the BigQuery SQL dialect.
*/
public class BigQuerySqlDialectFactory extends AbstractSqlDialectFactory {
@Override
public String getSqlDialectName() {
return BigQuerySqlDialect.NAME;
}
@Override
public SqlDialect createSqlDialect(final Connection connection, final AdapterProperties properties) {
return new BigQuerySqlDialect(connection, properties);
}
} |
uktrade/fadmin2 | end_of_month/management/commands/calculate_period_outturn.py | <reponame>uktrade/fadmin2<filename>end_of_month/management/commands/calculate_period_outturn.py
from django.core.management.base import BaseCommand
from core.utils.generic_helpers import get_current_financial_year
from end_of_month.monthly_outturn import (
OutturnInvalidPeriodError,
OuturnNotArchivedMonthError,
validate_period_for_outturn,
create_outturn_for_variance,
)
class Command(BaseCommand):
help = "Calculate previous period outturns. Valid periods between 1 and 14"
def add_arguments(self, parser):
parser.add_argument("period", type=int)
# Named (optional) arguments
parser.add_argument(
"--latest",
action="store_true",
help="Create the previous outturn used by the current period",
)
def handle(self, *args, **options):
try:
period_code = options["period"]
try:
validate_period_for_outturn(period_code)
except OutturnInvalidPeriodError:
self.stdout.write(self.style.ERROR("Valid Period is between 1 and 15."))
return
except OuturnNotArchivedMonthError:
self.stdout.write(
self.style.ERROR("The selected period has not yet been archived.")
)
return
if options["latest"]:
use_for_current = True
else:
use_for_current = False
create_outturn_for_variance(
period_code, get_current_financial_year(), use_for_current
)
self.stdout.write(
self.style.SUCCESS(f"Outturn for period {period_code} calculated.")
)
except Exception as ex:
self.stdout.write(self.style.ERROR(f"An error occured: {ex}"))
|
ProofSuite/ProofCryptoFiat | test/proxies/rewards.js | /* global artifacts:true, web3: true, contract: true */
import chai from 'chai'
chai.use(require('chai-bignumber')(web3.BigNumber)).should()
const Store = artifacts.require('./Store.sol')
const RewardsStorageProxy = artifacts.require('./RewardsStorageProxy.sol')
contract('Rewards Storage Proxy', (accounts) => {
let store
let rewardsStorageProxy
beforeEach(async() => {
store = await Store.new()
rewardsStorageProxy = await RewardsStorageProxy.new()
await store.authorizeAccess(rewardsStorageProxy.address)
})
describe('Pool index', async () => {
it('should set and get current pool index', async () => {
let poolIndex
let expectedPoolIndex = 1
await rewardsStorageProxy.setCurrentPoolIndex(store.address, 1)
poolIndex = await rewardsStorageProxy.getCurrentPoolIndex(store.address)
poolIndex.should.be.bignumber.equal(expectedPoolIndex)
})
it('should increment the current pool index', async () => {
let poolIndex
let increment = 10
await rewardsStorageProxy.incrementCurrentPoolIndex(store.address, increment)
poolIndex = await rewardsStorageProxy.getCurrentPoolIndex(store.address)
poolIndex.should.be.bignumber.equal(increment)
})
})
describe('Current Epoch', async () => {
it('should set and get current epoch', async () => {
let epoch
let expectedEpoch = 1
await rewardsStorageProxy.setCurrentEpoch(store.address, 1)
epoch = await rewardsStorageProxy.getCurrentEpoch(store.address)
epoch.should.be.bignumber.equal(expectedEpoch)
})
it('should increment the current epoch', async () => {
let epoch
let increment = 10
await rewardsStorageProxy.incrementCurrentEpoch(store.address, increment)
epoch = await rewardsStorageProxy.getCurrentEpoch(store.address)
epoch.should.be.bignumber.equal(increment)
})
})
describe('Current Pool Balance', async () => {
it('should set and get current pool balance', async () => {
let poolBalance
let expectedPoolBalance = 1
await rewardsStorageProxy.setCurrentPoolBalance(store.address, 1)
poolBalance = await rewardsStorageProxy.getCurrentPoolBalance(store.address)
poolBalance.should.be.bignumber.equal(expectedPoolBalance)
})
it('should increment the current pool balance', async () => {
let poolBalance
let increment = 10
await rewardsStorageProxy.incrementCurrentPoolBalance(store.address, increment)
poolBalance = await rewardsStorageProxy.getCurrentPoolBalance(store.address)
poolBalance.should.be.bignumber.equal(increment)
})
})
describe('Nth pool dividends', async() => {
it('should set and get Nth pool dividends', async () => {
let dividends
let poolIndex = 1
let expectedDividends = 1 * 10 ** 18
await rewardsStorageProxy.setNthPoolBalance(store.address, poolIndex, expectedDividends)
dividends = await rewardsStorageProxy.getNthPoolBalance(store.address, poolIndex)
dividends.should.be.bignumber.equal(expectedDividends)
})
it('should set and get Nth pool remaining dividends', async () => {
let storedValue
let poolIndex = 1
let expectedValue = 1 * 10 ** 18
await rewardsStorageProxy.setNthPoolRemainingDividends(store.address, poolIndex, expectedValue)
storedValue = await rewardsStorageProxy.getNthPoolRemainingDividends(store.address, poolIndex)
storedValue.should.be.bignumber.equal(expectedValue)
})
})
describe('Account Last withdrawal', async() => {
it('should set and get the last account withdrawal', async() => {
let account = '<KEY>'
let storedValue = 10
let expectedValue = 1 * 10 ** 18
await rewardsStorageProxy.setAccountLastWithdrawal(store.address, account, expectedValue)
storedValue = await await rewardsStorageProxy.getAccountLastWithdrawal(store.address, account)
storedValue.should.be.bignumber.equal(expectedValue)
})
})
})
|
yinxiaoer/jietu-laundry | laundry-jt/laundry-admin-dao/src/main/java/com/jietu/admin/utils/PasswordUtil.java | <reponame>yinxiaoer/jietu-laundry
package com.jietu.admin.utils;
import org.apache.shiro.crypto.hash.SimpleHash;
import org.apache.shiro.util.ByteSource;
/**
* 用户密码加密工具类
* @author: 印修河
* @date: 2017/12/11 14:14
*/
public class PasswordUtil {
public static String encrypting(String password, String salt){
String hashAlgorithmName = "MD5";
String credentials = password;
int hashIterations = 16;
ByteSource credentialsSalt = ByteSource.Util.bytes(salt);
Object obj = new SimpleHash(hashAlgorithmName, credentials, credentialsSalt, hashIterations);
return obj.toString();
}
public static void main(String[] args) {
System.out.println(encrypting("admin", "admin"));
}
}
|
phatblat/macOSPrivateFrameworks | PrivateFrameworks/EmailDaemon/EDMailboxRepository.h | //
// Generated by class-dump 3.5 (64 bit).
//
// class-dump is Copyright (C) 1997-1998, 2000-2001, 2004-2013 by <NAME>.
//
#import "NSObject.h"
#import "EFLoggable.h"
@class EDMailboxPersistence, NSObject<OS_dispatch_queue>, NSString;
@interface EDMailboxRepository : NSObject <EFLoggable>
{
EDMailboxPersistence *_mailboxPersistence;
NSObject<OS_dispatch_queue> *_serializationQueue;
}
+ (id)log;
@property(readonly, nonatomic) NSObject<OS_dispatch_queue> *serializationQueue; // @synthesize serializationQueue=_serializationQueue;
@property(retain, nonatomic) EDMailboxPersistence *mailboxPersistence; // @synthesize mailboxPersistence=_mailboxPersistence;
- (void).cxx_destruct;
- (BOOL)_performRenameMailboxChangeAction:(id)arg1;
- (BOOL)_performMoveMailboxChangeAction:(id)arg1;
- (BOOL)_performDeleteMailboxChangeAction:(id)arg1;
- (BOOL)_performCreateMailboxChangeAction:(id)arg1;
- (void)mailboxTypeForMailboxObjectID:(id)arg1 completionHandler:(CDUnknownBlockType)arg2;
- (void)mailboxObjectIDsForMailboxType:(long long)arg1 completionHandler:(CDUnknownBlockType)arg2;
- (void)refreshMailboxList;
- (void)performMailboxChangeAction:(id)arg1 completionHandler:(CDUnknownBlockType)arg2;
- (void)cancelObservation:(id)arg1;
- (void)startObservingMailboxChangesWithChangeObserver:(id)arg1 observationIdentifier:(id)arg2;
- (void)getMailboxesWithCompletion:(CDUnknownBlockType)arg1;
- (id)initWithMailboxPersistence:(id)arg1;
// Remaining properties
@property(readonly, copy) NSString *debugDescription;
@property(readonly, copy) NSString *description;
@property(readonly) unsigned long long hash;
@property(readonly) Class superclass;
@end
|
rajkovukovic/tfux | utils/engines/jspm/tools/jspm-dependency-depth.js | 'use strict';
const { parseJspmJSONDependency } = require('./parse-jspm.js');
const { generateModuleName } = require('../../../naming-utils/generate-module-name.js');
function calcOneDependencyDepth(dependencyMap, dependencyName) {
const dependency = dependencyMap.get(dependencyName);
if (!dependency) {
throw new Error(`Can not find dependency "${dependencyName}" in dependencyMap`);
}
if (dependency && Number.isFinite(dependency.nestedDependencyLevel)) {
return dependency.nestedDependencyLevel;
}
if (!dependency.dependencies) {
dependency.nestedDependencyLevel = 0;
} else {
dependency.nestedDependencyLevel =
Math.max(
...dependency.dependencies.map((depName) => calcOneDependencyDepth(dependencyMap, depName))
) + 1;
}
return dependency.nestedDependencyLevel;
}
function calcDependencyDepth(jspmJSON) {
const dependencyMap = new Map();
Object.entries(jspmJSON.dependencies).forEach(([fullName, info]) => {
const [group, name, version] = parseJspmJSONDependency(fullName);
dependencyMap.set(fullName, {
fullName,
group,
name,
version,
relativeDestinationPath: generateModuleName(group, name, version),
importPath: generateModuleName(group, name, version.split('.').slice(0, -1).join('.')),
relativeInstallPath: `${group ? group + '/' : ''}${name}@${version}`,
dependencies: info.resolve ? Object.values(info.resolve) : null,
nestedDependencyLevel: null,
});
});
Array.from(dependencyMap.keys()).forEach((dependencyName) =>
calcOneDependencyDepth(dependencyMap, dependencyName)
);
return dependencyMap;
}
exports.calcDependencyDepth = calcDependencyDepth;
|
mowangblog/MoWang-Shop | mowang-shop-gateway/src/main/java/top/mowang/shop/gateway/GateWayMain.java | package top.mowang.shop.gateway;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration;
import org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
/**
* MoWang-Shop
*
* @author : <NAME><<EMAIL>>
* @website : https://mowangblog.top
* @date : 2021/11/07 16:09
**/
@SpringBootApplication
@EnableDiscoveryClient
public class GateWayMain {
public static void main(String[] args) {
SpringApplication.run(GateWayMain.class,args);
}
}
|
dm1try/bjob | spec/backend/unix_socket_spec.rb | require 'bjob/backend/unix_socket'
require 'json'
require 'socket'
RSpec.describe BJob::Backend::UNIXSocket do
let(:working_pool) { double(:working_pool, schedule: :ok) }
let(:socket_path) { '/tmp/test_socket' }
subject { described_class.new(path: socket_path, working_pool: working_pool) }
after do
FileUtils.rm(socket_path) if File.exist?(socket_path)
end
context 'with valid JSON formatted request from client' do
let(:some_job) { {'some' => 'job'} }
let(:client_request) { JSON.dump(some_job) }
it 'transfers request from client to working_pool using unix socket' do
expect(working_pool).to receive(:schedule).with(some_job)
subject.start
sleep 0.1 # TODO: re-check
send_request
end
def send_request
UNIXSocket.new(socket_path).puts(client_request)
end
end
context 'socket file already exists in the system' do
before do
FileUtils.touch(socket_path)
end
it 'removes socket file if it exists' do
expect{subject.start}.not_to raise_error(Errno::EADDRINUSE)
end
end
end
|
KerchumA222/WebIDE-Frontend | app/IDE/index.js | // This is the access point to the API that Coding WebIDE exposes
// Idea taken from atom, this is the equivalence of `window.atom`
//
// see: https://github.com/atom/atom/blob/master/src/atom-environment.coffee
import IdeEnvironment from './IdeEnvironment'
export default window.ide = IdeEnvironment()
|
liamchalcroft/nitorch | nitorch/io/utils/__init__.py | <reponame>liamchalcroft/nitorch
from . import indexing
from . import volutils
|
the-zebulan/CodeWars | katas/kyu_7/reduce_my_fraction.py | <reponame>the-zebulan/CodeWars<gh_stars>10-100
from fractions import Fraction
def reduce(fraction):
""" Shadows built-in name 'reduce' (forced by Codewars) """
f = Fraction(*fraction)
return [f.numerator, f.denominator]
|
mrdrivingduck/leet-code | 703.KthLargestElementInAStream.cpp | /**
* @author <NAME>.
* @version 2021/02/11
*/
/*
Design a class to find the kth largest element in a stream. Note that
it is the kth largest element in the sorted order, not the kth distinct
element.
Implement KthLargest class:
KthLargest(int k, int[] nums) Initializes the object with the
integer k and the stream of integers nums.
int add(int val) Returns the element representing the kth
largest element in the stream.
Example 1:
Input
["KthLargest", "add", "add", "add", "add", "add"]
[[3, [4, 5, 8, 2]], [3], [5], [10], [9], [4]]
Output
[null, 4, 5, 5, 8, 8]
Explanation
KthLargest kthLargest = new KthLargest(3, [4, 5, 8, 2]);
kthLargest.add(3); // return 4
kthLargest.add(5); // return 5
kthLargest.add(10); // return 5
kthLargest.add(9); // return 8
kthLargest.add(4); // return 8
Constraints:
1 <= k <= 104
0 <= nums.length <= 104
-104 <= nums[i] <= 104
-104 <= val <= 104
At most 104 calls will be made to add.
It is guaranteed that there will be at least k elements in the
array when you search for the kth element.
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/kth-largest-element-in-a-stream
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
*/
/*
维护一个长度为 k 的小顶堆，堆顶元素即为第 k 大的元素。如果队列内元素数量超出
k 个，那么需要将堆大小调整至 k。
*/
#include <cassert>
#include <iostream>
#include <vector>
#include <algorithm>
using std::cout;
using std::endl;
using std::vector;
class KthLargest {
private:
int k;
vector<int> nums;
public:
KthLargest(int k, vector<int>& nums) {
std::make_heap(nums.begin(), nums.end(), std::greater<int>());
while ((int) nums.size() > k) {
std::pop_heap(nums.begin(), nums.end(), std::greater<int>());
nums.pop_back();
}
this->k = k;
this->nums = nums;
}
int add(int val) {
nums.push_back(val);
std::push_heap(nums.begin(), nums.end(), std::greater<int>());
if ((int) nums.size() > k) {
std::pop_heap(nums.begin(), nums.end(), std::greater<int>());
nums.pop_back();
}
return nums[0];
}
};
/**
* Your KthLargest object will be instantiated and called as such:
* KthLargest* obj = new KthLargest(k, nums);
* int param_1 = obj->add(val);
*/
int main()
{
vector<int> nums;
nums = { 4,5,8,2 };
KthLargest kthLargest(3, nums);
assert(4 == kthLargest.add(3)); // return 4
assert(5 == kthLargest.add(5)); // return 5
assert(5 == kthLargest.add(10)); // return 5
assert(8 == kthLargest.add(9)); // return 8
assert(8 == kthLargest.add(4)); // return 8
// nums = {};
// KthLargest kthLargest(1, nums);
// assert(-3 == kthLargest.add(-3)); // return -3
// assert(-2 == kthLargest.add(-2)); // return -2
// assert(-2 == kthLargest.add(-4)); // return -2
// assert(0 == kthLargest.add(0)); // return 0
// assert(4 == kthLargest.add(4)); // return 4
return 0;
}
|
afterloe/opencv-practice | equipment_engineering/meter_reader_4_pointer/docs/conf.py | #!/usr/bin/env python3
# -*- coding=utf-8 -*-
import cv2 as cv
"""
"""
def main():
pass
if "__main__" == __name__:
main()
|
jbs321/Israelim.ca | resources/assets/js/form/Registration/Validation/RegisterBusinessLocationFormValidation.js | import axios from "axios/index";
export const validate = (values) => {
const errors = {};
const requiredFields = [
'address',
'city',
'province',
'postal_code',
];
requiredFields.forEach(field => {
if (!values[field]) {
errors[field] = `Required`
}
});
requiredFields.forEach(field => {
if (values[field] && values[field].length > 191) {
errors[field] = `Too Long`;
}
});
return errors;
};
export const asyncValidate = values => {
let form = new FormData();
form.append("postal_code", values.postal_code);
form.append("province", values.province);
form.append("city", values.city);
form.append("apartment", values.apartment);
form.append("address", values.address);
form.append("country", "canada");
const promise = new Promise((resolve, reject) => {
axios.post("/business/register/location/validate", values).then((data) => {
resolve(data);
}).catch((data) => reject(data));
}
);
return promise
.then((data) => {
let errors = {};
if (data.data.validation === "success") {
return true;
}
_.each(data.data, function (value, key) {
errors[key] = value.pop();
});
throw errors;
}).catch((data) => {
throw data;
});
}; |
cassiusvm/Architecting-Modern-Java-EE-Applications | Chapter07/test/src/test/java/com/sebastian_daschner/test/boundary/CarManufacturerTestComponent.java | package com.sebastian_daschner.test.boundary;
import com.sebastian_daschner.test.control.CarFactoryComponent;
import com.sebastian_daschner.test.entity.Car;
import com.sebastian_daschner.test.entity.Specification;
import org.assertj.core.api.AssertionsForClassTypes;
import org.junit.Before;
import org.junit.Test;
public class CarManufacturerTestComponent {
private CarManufacturerComponent carManufacture;
private CarFactoryComponent carFactory;
@Before
public void setUp() {
carFactory = new CarFactoryComponent();
carManufacture = new CarManufacturerComponent(carFactory);
}
@Test
public void test() {
Specification spec = new Specification();
Car expected = new Car(spec);
AssertionsForClassTypes.assertThat(carManufacture.manufactureCar(spec)).isEqualTo(expected);
carManufacture.verifyManufacture(expected);
carFactory.verifyCarCreation(spec);
}
}
|
mcybulsk/civ5-pbem-server | src/main/java/me/cybulski/civ5pbemserver/game/GameTurnFactory.java | <gh_stars>1-10
package me.cybulski.civ5pbemserver.game;
import lombok.AccessLevel;
import lombok.RequiredArgsConstructor;
import me.cybulski.civ5pbemserver.exception.ResourceNotFoundException;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;
import java.util.Comparator;
import java.util.List;
import java.util.function.Predicate;
/**
* @author <NAME>
*/
@Component
@RequiredArgsConstructor(access = AccessLevel.PACKAGE)
class GameTurnFactory {
private final GameTurnRepository gameTurnRepository;
public GameTurn createFirstGameTurn(Game game) {
Assert.state(GameState.WAITING_FOR_FIRST_MOVE.equals(game.getGameState()),
"Game must be in WAITING_FOR_FIRST_MOVE to add first turn");
GameTurn firstGameTurn = GameTurn.builder()
.currentPlayer(game.findPlayer(game.getHost()).orElseThrow(ResourceNotFoundException::new))
.game(game)
.previousGameTurn(null)
.saveFilename(null)
.turnNumber(0)
.build();
firstGameTurn = gameTurnRepository.save(firstGameTurn);
return firstGameTurn;
}
public GameTurn createNextTurn(GameTurn previousGameTurn, List<Player> players, String saveFilename) {
Player nextHumanPlayer = players.stream()
.filter(humanPlayerPredicate())
.filter(player -> player.getPlayerNumber() > previousGameTurn.getCurrentPlayer().getPlayerNumber())
.findFirst()
.orElseGet(() -> players.stream()
.filter(humanPlayerPredicate())
.min(Comparator.comparingInt(Player::getPlayerNumber))
.orElseThrow(RuntimeException::new));
GameTurn nextGameTurn = GameTurn.builder()
.game(previousGameTurn.getGame())
.currentPlayer(nextHumanPlayer)
.turnNumber(previousGameTurn.getCurrentPlayer().getPlayerNumber() >= nextHumanPlayer.getPlayerNumber()
? previousGameTurn.getTurnNumber() + 1
: previousGameTurn.getTurnNumber())
.saveFilename(saveFilename)
.previousGameTurn(previousGameTurn)
.build();
nextGameTurn = gameTurnRepository.save(nextGameTurn);
return nextGameTurn;
}
private Predicate<Player> humanPlayerPredicate() {
return player -> PlayerType.HUMAN.equals(player.getPlayerType());
}
}
|
Bingwen-Hu/hackaway | books/exploreC++11/experience/by_ref.cpp | #include <iostream>
#include <iterator>
#include <vector>
void modify(int& x)
{
x = 10;
}
int triple(int x)
{
return 3 * x;
}
// using const to prevent accidently modification
// rule of thumb is to keep the const keyword as close as
// possible to whatever it is modifying
void print_vector(std::vector<int> const& v)
{
// const test
// v.front() = 42;
std::cout << "{";
std::copy(v.begin(), v.end(), std::ostream_iterator<int>{std::cout, ""});
std::cout << "}\n";
}
void add(std::vector<int>& v, int a)
{
for (auto iter{v.begin()}, end{v.end()}; iter != end; ++iter){
*iter = *iter + a;
}
}
int main()
{
int a{42};
modify(a);
std::cout << "a=" << a << std::endl;
int b{triple(14)};
std::cout << "b=" << b << std::endl;
std::vector<int> data{10, 20, 40, 50};
print_vector(data);
add(data, 42);
print_vector(data);
}
|
bblue000/CACProject | SocketDemo/src/com/rubick/cac/server/CACServerUtils.java | package com.rubick.cac.server;
import java.net.Socket;
import java.util.Collection;
/**
* 服务端的处理
*
* @author <NAME>
*
*/
class CACServerUtils {
/**
* 接收连接延迟时间
*/
public static final int SERVER_ACCEPT_TIMEOUT = 30 * 1000;
/**
* 客户端连接时，进入闲置阶段的延迟时间
*/
public static final int CLIENT_IDLE_TIMEOUT = 30 * 1000;
/**
* 关闭与客户端连接的信号
*/
public static final String CLOSE_SIGNATURE = "0";
public static void dispatchClientConnect(Socket client, Collection<ClientConnectListener> c) {
if (null == c || c.isEmpty()) {
return;
}
for(ClientConnectListener listener : c) {
listener.onConnect(client);
}
}
public static void dispatchClientDisconnect(Socket client, Collection<ClientConnectListener> c) {
if (null == c || c.isEmpty()) {
return;
}
for(ClientConnectListener listener : c) {
listener.onDisconnect(client);
}
}
public static void dispatchClientMessage(Socket client, MessageBean message,
EasyInteractObject easyInteractObject,
Collection<ClientConnectListener> c) {
if (null == c || c.isEmpty()) {
return;
}
for(ClientConnectListener listener : c) {
listener.onReceive(client, message, easyInteractObject);
}
}
public static MessageBean transferMessage(String message) {
return new MessageBean(message);
}
}
|
lowlander/nederrock | src/parser_nodes/not_parser_node.cpp | //
// Copyright (c) 2020 <NAME> <<EMAIL>>
//
// SPDX-License-Identifier: MIT
//
#include "not_parser_node.hpp"
#include "separator_parser_node.hpp"
#include "comparison_parser_node.hpp"
#include "parser_node.hpp"
#include <memory>
#include <istream>
#include <string>
void Not_Parser_Node::Choice_1::dump(std::wostream& output) const
{
output << m_keyword;
m_separator->dump(output);
m_not->dump(output);
}
void Not_Parser_Node::Choice_2::dump(std::wostream& output) const
{
m_comparison->dump(output);
}
Not_Parser_Node::Not_Parser_Node(Choice_1&& choice)
: m_choice(std::move(choice))
{
}
Not_Parser_Node::Not_Parser_Node(Choice_2&& choice)
: m_choice(std::move(choice))
{
}
Not_Parser_Node_Ptr
Not_Parser_Node::parse_choice_1(Token_Stream& input)
{
auto offset = input.tellg();
Choice_1 choice;
choice.m_keyword = check_and_remove(input, L"not");
if (choice.m_keyword.empty()) {
input.seekg(offset);
return nullptr;
}
choice.m_separator = Separator_Parser_Node::parse(input);
if (choice.m_separator == nullptr) {
input.seekg(offset);
return nullptr;
}
choice.m_not = Not_Parser_Node::parse(input);
if (choice.m_not == nullptr) {
input.seekg(offset);
return nullptr;
}
return std::make_shared<Not_Parser_Node>(std::move(choice));
}
Not_Parser_Node_Ptr
Not_Parser_Node::parse_choice_2(Token_Stream& input)
{
auto offset = input.tellg();
Choice_2 choice;
choice.m_comparison = Comparison_Parser_Node::parse(input);
if (choice.m_comparison == nullptr) {
input.seekg(offset);
return nullptr;
}
return std::make_shared<Not_Parser_Node>(std::move(choice));
}
Not_Parser_Node_Ptr
Not_Parser_Node::parse(Token_Stream& input)
{
auto offset = input.tellg();
auto node = parse_choice_1(input);
if (node) {
return node;
}
input.seekg(offset);
node = parse_choice_2(input);
if (node) {
return node;
}
input.seekg(offset);
return nullptr;
}
void Not_Parser_Node::dump(std::wostream& output) const
{
std::visit([&output](auto&& choice){ choice.dump(output); }, m_choice);
}
void Not_Parser_Node::Choice_1::generate_cpp(Scope_State_Ptr state) const
{
state->add_code(L"!(");
m_not->generate_cpp(state);
state->add_code(L")");
}
void Not_Parser_Node::Choice_2::generate_cpp(Scope_State_Ptr state) const
{
m_comparison->generate_cpp(state);
}
void Not_Parser_Node::generate_cpp(Scope_State_Ptr state) const
{
std::visit([&state](auto&& choice){ choice.generate_cpp(state); }, m_choice);
}
void Not_Parser_Node::Choice_1::collect_variables(Scope_State_Ptr state) const
{
m_not->collect_variables(state);
}
void Not_Parser_Node::Choice_2::collect_variables(Scope_State_Ptr state) const
{
m_comparison->collect_variables(state);
}
void Not_Parser_Node::collect_variables(Scope_State_Ptr state) const
{
std::visit([&state](auto&& choice){ choice.collect_variables(state); }, m_choice);
}
|
zipated/src | remoting/protocol/ice_config.h | <filename>remoting/protocol/ice_config.h
// 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.
#ifndef REMOTING_PROTOCOL_ICE_CONFIG_H_
#define REMOTING_PROTOCOL_ICE_CONFIG_H_
#include <string>
#include <vector>
#include "base/time/time.h"
#include "third_party/webrtc/p2p/base/portallocator.h"
#include "third_party/webrtc/rtc_base/socketaddress.h"
namespace base {
class DictionaryValue;
} // namespace base
namespace remoting {
namespace protocol {
struct IceConfig {
IceConfig();
IceConfig(const IceConfig& other);
~IceConfig();
bool is_null() const { return expiration_time.is_null(); }
// Parses JSON representation of the config. Returns null config if parsing
// fails.
static IceConfig Parse(const base::DictionaryValue& dictionary);
static IceConfig Parse(const std::string& config_json);
// Time when the config will stop being valid and need to be refreshed.
base::Time expiration_time;
std::vector<rtc::SocketAddress> stun_servers;
// Legacy GTURN relay servers.
std::vector<std::string> relay_servers;
std::string relay_token;
// Standard TURN servers
std::vector<cricket::RelayServerConfig> turn_servers;
};
} // namespace protocol
} // namespace remoting
#endif // REMOTING_PROTOCOL_ICE_CONFIG_H_
|
Matt-Hayes24/hivemq-community-edition | src/main/java/com/hivemq/extensions/interceptor/disconnect/parameter/DisconnectOutboundOutputImpl.java | <filename>src/main/java/com/hivemq/extensions/interceptor/disconnect/parameter/DisconnectOutboundOutputImpl.java
/*
* Copyright 2019-present HiveMQ GmbH
*
* 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.hivemq.extensions.interceptor.disconnect.parameter;
import com.hivemq.extension.sdk.api.annotations.NotNull;
import com.hivemq.extension.sdk.api.interceptor.disconnect.parameter.DisconnectOutboundOutput;
import com.hivemq.extensions.executor.PluginOutPutAsyncer;
import com.hivemq.extensions.executor.task.AbstractSimpleAsyncOutput;
import com.hivemq.extensions.packets.disconnect.ModifiableOutboundDisconnectPacketImpl;
/**
* @author <NAME>
* @author <NAME>
*/
public class DisconnectOutboundOutputImpl extends AbstractSimpleAsyncOutput<DisconnectOutboundOutput>
implements DisconnectOutboundOutput {
private final @NotNull ModifiableOutboundDisconnectPacketImpl disconnectPacket;
private boolean failed = false;
public DisconnectOutboundOutputImpl(
final @NotNull PluginOutPutAsyncer asyncer,
final @NotNull ModifiableOutboundDisconnectPacketImpl disconnectPacket) {
super(asyncer);
this.disconnectPacket = disconnectPacket;
}
@Override
public @NotNull ModifiableOutboundDisconnectPacketImpl getDisconnectPacket() {
return disconnectPacket;
}
public boolean isFailed() {
return failed;
}
public void markAsFailed() {
failed = true;
}
public @NotNull DisconnectOutboundOutputImpl update(final @NotNull DisconnectOutboundInputImpl input) {
return new DisconnectOutboundOutputImpl(asyncer, disconnectPacket.update(input.getDisconnectPacket()));
}
}
|
Brook1711/biubiu_Qt6 | vlc_linux/vlc-3.0.16/modules/demux/adaptive/playlist/BasePeriod.cpp | <filename>vlc_linux/vlc-3.0.16/modules/demux/adaptive/playlist/BasePeriod.cpp
/*
* BasePeriod.cpp
*****************************************************************************
* Copyright (C) 2010 - 2011 Klagenfurt University
*
* Created on: Aug 10, 2010
* Authors: <NAME> <<EMAIL>>
* <NAME> <<EMAIL>>
*
* This program 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.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with this program; if not, write to the Free Software Foundation,
* Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
*****************************************************************************/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "BasePeriod.h"
#include "AbstractPlaylist.hpp"
#include "../Streams.hpp"
#include <vlc_common.h>
#include <vlc_arrays.h>
#include <cassert>
using namespace adaptive::playlist;
BasePeriod::BasePeriod(AbstractPlaylist *playlist_) :
SegmentInformation( playlist_ )
{
duration.Set(0);
startTime.Set(0);
playlist = playlist_;
}
BasePeriod::~BasePeriod ()
{
vlc_delete_all( adaptationSets );
childs.clear();
}
AbstractPlaylist *BasePeriod::getPlaylist() const
{
return playlist;
}
const std::vector<BaseAdaptationSet*>& BasePeriod::getAdaptationSets() const
{
return adaptationSets;
}
void BasePeriod::addAdaptationSet(BaseAdaptationSet *adaptationSet)
{
if ( adaptationSet != NULL )
{
if(adaptationSet->getRepresentations().empty())
{
assert(!adaptationSet->getRepresentations().empty());
return; /* will leak */
}
adaptationSets.push_back(adaptationSet);
childs.push_back(adaptationSet);
}
}
BaseAdaptationSet *BasePeriod::getAdaptationSetByID(const adaptive::ID &id)
{
std::vector<BaseAdaptationSet*>::const_iterator it;
for(it = adaptationSets.begin(); it!= adaptationSets.end(); ++it)
{
if( (*it)->getID() == id )
return *it;
}
return NULL;
}
void BasePeriod::debug(vlc_object_t *obj, int indent) const
{
std::string text(indent, ' ');
text.append("Period");
msg_Dbg(obj, "%s", text.c_str());
std::vector<BaseAdaptationSet *>::const_iterator k;
for(k = adaptationSets.begin(); k != adaptationSets.end(); ++k)
(*k)->debug(obj, indent + 1);
}
mtime_t BasePeriod::getPeriodStart() const
{
return startTime.Get();
}
mtime_t BasePeriod::getPeriodDuration() const
{
return duration.Get();
}
|
UO-CIS/CIS399AndroidDemos | Multi-ActivityDemo/app/src/main/java/edu/uoregon/bbird/multi_activitydemo/ActivityTwo.java | <filename>Multi-ActivityDemo/app/src/main/java/edu/uoregon/bbird/multi_activitydemo/ActivityTwo.java
package edu.uoregon.bbird.mulit_activitydemo;
import android.app.Activity;
import android.os.Bundle;
public class ActivityTwo extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_two);
// Just setting the parent in the manifest is enough
// enable the up button. You don't need the method below
// getActionBar().setDisplayHomeAsUpEnabled(true);
}
}
|
grepx/archivorg | app/src/main/java/gregpearce/archivorg/data/network/TopFeedServiceFactory.java | package gregpearce.archivorg.data.network;
import gregpearce.archivorg.domain.model.FeedContentType;
import gregpearce.archivorg.domain.service.FeedService;
public interface TopFeedServiceFactory {
FeedService get(FeedContentType feedContentType);
}
|
MediaByte/portfolio | node_modules/@material-ui/icons/AttachFile.js | <filename>node_modules/@material-ui/icons/AttachFile.js<gh_stars>0
'use strict';
Object.defineProperty(exports, "__esModule", {
value: true
});
var _react = require('react');
var _react2 = _interopRequireDefault(_react);
var _createSvgIcon = require('./utils/createSvgIcon');
var _createSvgIcon2 = _interopRequireDefault(_createSvgIcon);
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
exports.default = (0, _createSvgIcon2.default)(_react2.default.createElement(
'g',
null,
_react2.default.createElement('path', { d: 'M16.5 6v11.5c0 2.21-1.79 4-4 4s-4-1.79-4-4V5c0-1.38 1.12-2.5 2.5-2.5s2.5 1.12 2.5 2.5v10.5c0 .55-.45 1-1 1s-1-.45-1-1V6H10v9.5c0 1.38 1.12 2.5 2.5 2.5s2.5-1.12 2.5-2.5V5c0-2.21-1.79-4-4-4S7 2.79 7 5v12.5c0 3.04 2.46 5.5 5.5 5.5s5.5-2.46 5.5-5.5V6h-1.5z' })
), 'AttachFile'); |
llorllale/youtrack-api | src/main/java/org/llorllale/youtrack/api/Issue.java | <reponame>llorllale/youtrack-api<gh_stars>10-100
/*
* Copyright 2017 <NAME>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.llorllale.youtrack.api;
import java.io.IOException;
import java.time.Instant;
import java.util.Collection;
import java.util.Optional;
import org.llorllale.youtrack.api.session.Login;
import org.llorllale.youtrack.api.session.UnauthorizedException;
/**
* A {@link YouTrack} issue.
*
* <p>Two issues are equal if their {@link #project() projects} are both equal, and their
* {@link #id() ids} are also equal.
*
* @author <NAME> (<EMAIL>)
* @since 0.1.0
*/
public interface Issue {
/**
* The {@link Project} that the issue was created in.
*
* @return the ID of the project that the issue was created in
* @since 0.4.0
*/
Project project();
/**
* The issue's id.
*
* @return the issue's id
* @since 0.1.0
*/
String id();
/**
* The date the issue was created.
*
* @return The date the issue was created.
* @since 0.1.0
*/
Instant creationDate();
/**
* The issue's summary.
*
* @return The issue's summary.
* @since 0.1.0
*/
String summary();
/**
* The issue's description.
*
* @return the issue's description
* @since 0.1.0
*/
Optional<String> description();
/**
* Access to the issue's {@link User users}.
*
* @return access to the issue's {@link User users}
* @since 0.5.0
*/
UsersOfIssue users();
/**
* Access to the issue's {@link Comment comments}.
*
* @return Access to the issue's {@link Comment comments}.
* @since 0.4.0
*/
Comments comments();
/**
* Access to the issue's {@link TimeTrackEntry timetracking}.
*
* <p><strong>Note:</strong> it is important that you first check whether timetracking is
* {@link ProjectTimeTracking#enabled() enabled} for the {@link Project}.</p>
*
* @return access to the issue's {@link TimeTrackEntry timetracking}.
* @see ProjectTimeTracking#enabled()
* @since 0.4.0
*/
IssueTimeTracking timetracking();
/**
* Returns the same {@link Issue} after refreshing its data from the server.
*
* <p>
* This is a convenient shortcut for {@code issue.project().issues().get(issue.id()).get()}.
* </p>
*
* @return the same {@link Issue} after refreshing its data from the server
* @throws IOException if the server is unavailable
* @throws UnauthorizedException if the user's {@link Login} is not authorized to perform this
* operation
* @since 0.5.0
*/
Issue refresh() throws IOException, UnauthorizedException;
/**
* The {@link UpdateIssue} API for this {@link Issue}.
*
* @return the {@link UpdateIssue} API for this {@link Issue}
* @since 0.9.0
*/
UpdateIssue update();
/**
* All {@link AssignedField fields} of this {@link Issue}.
*
* @return all {@link AssignedField fields} of this {@link Issue}
* @see UpdateIssue#fields(java.util.Map)
* @since 0.8.0
*/
Collection<AssignedField> fields();
/**
* Attachments for this issue.
* @return attachments API
* @since 1.1.0
*/
Attachments attachments();
}
|
huynhphuchuy/goku | api/Authentication/auth.routes.go | package authroutes
import (
authv1_0 "Gogin/api/Authentication/v1.0"
"github.com/gin-gonic/gin"
)
var bearerAuthControllerV1_0 authv1_0.IBearerAuthController = authv1_0.BearerAuthController{}
// Routes Group
func Routes(r *gin.Engine) {
client := r.Group("/auth")
{
client.GET("/bearer/v1.0/verify", bearerAuthControllerV1_0.VerifyToken)
}
}
|
Muhamedali/crazy_text | src/main/java/com/input/text/crazy/client/utils/Clipboard.java | package com.input.text.crazy.client.utils;
public interface Clipboard {
public void put(String text);
public String get();
public boolean isEmpty();
}
|
zhangs919/laravelvip-b2b2c | resources/static/assets/js/customform/edit.js | <reponame>zhangs919/laravelvip-b2b2c
// 表单回显数据, 覆盖index.js的内容
var o_header_img = $('#header_img');
$('#imagegroup_container').imagegroup({
host: image_url_host,
size: $(this).data("size"),
values: o_header_img.val().split("|"),
gallery: true,
// 回调函数
callback: function(data) {
var url = '';
if (data.src) {
url = data.src;
}
o_header_img.val(url);
$.validator.clearError(o_header_img);
},
// 移除的回调函数
remove: function(value, values) {
o_header_img.val("");
}
});
var o_body_img = $('#bg_img');
$('#bg_img_container').imagegroup({
host: image_url_host,
size: $(this).data("size"),
values: o_body_img.val().split("|"),
gallery: true,
// 回调函数
callback: function(data) {
var url = '';
if (data.src) {
url = data.src;
}
o_body_img.val(url);
$.validator.clearError(o_body_img);
},
// 移除的回调函数
remove: function(value, values) {
o_body_img.val("");
}
});
// ----- 地区级联插件 ----- //
var o_region_container = $('#region_container');
var o_address_code = $("#address_code");
var selector_setting = {
value: '',
sale_scope: 0,
widget_class: 'render-selector',
select_class: "form-control m-t-5",
change: function(value, names, is_last) {
o_address_code.val(value);
// 遍历获取所有的内容 - 设置地址文本
var selectors = o_region_container.find('.render-selector');
var texts = [];
var len = selectors.length;
if (len <= 3 && len > 0) {
selectors.each(function(i, v) {
var self = $(this);
var text = self.find('option:selected').text();
var val = self.val();
if (val == '') {
text = '';
}
texts.push(text);
});
}
var o_address_text = $('#address_text');
o_address_text.val(texts.join('-'));
},
// 在将组件添加到页面之后就会被调用
select_callback: function() {
// 检测当前select数量的个数, 因为可能会有更多级, 只保留3级联动
var len = o_region_container.find('.render-selector').length;
if (len > 2) {
o_region_container.find('.render-selector:gt(2)').remove();
}
}
}
o_region_container.regionselector(selector_setting);
// ----- 默认时间插件 ----- //
var default_time_setting = {
language: 'zh-CN',
weekStart: 1,
todayBtn: 1,
autoclose: 1,
todayHighlight: 1,
startView: 2,
forceParse: 0,
showMeridian: 1,
minView: 2,
maxView: 4,
format: "yyyy-mm-dd"
};
var o_default_time = $('#default_time');
o_default_time.datetimepicker(default_time_setting).on('changeDate', function(ev) {
$(this).trigger("blur");
});
// ----- 时间显示级别 ----- //
$('#time_level').change(function() {
// 获取当前的时间级别
var self = $(this);
var level = self.val();
// 清空上面的时间
o_default_time.val('');
// 获取当前时间级别对应的设置
var special_setting = time_level[level];
if (special_setting && typeof special_setting === 'object') {
// 合并后的配置
$.extend(default_time_setting, special_setting);
o_default_time.datetimepicker('remove');
o_default_time.datetimepicker(default_time_setting);
}
});
// 右侧编辑内容，对齐选择js
var o_layout = $('#layout');
var o_layout_items = $('.fGroupItem');
o_layout_items.find("li").click(function() {
var self = $(this);
self.addClass("selected").siblings().removeClass("selected");
var layout = self.data('layout');
o_layout.val(layout);
}); |
Maplenormandy/qg-edgeofchaos | plot_scripts/lyapunov_plots.py | <gh_stars>1-10
# -*- coding: utf-8 -*-
"""
Created on Wed Sep 29 10:35:45 2021
@author: maple
"""
import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl
font = {'size' : 6,
'family' : 'sans-serif',
'serif' : ['CMU Serif'],
'sans-serif' : ['CMU Sans Serif']}
linescale = 0.4
mpl.rc('axes', unicode_minus=False, linewidth=linescale)
tick_major = {'size': 3.5*linescale, 'width': 0.8*linescale}
tick_minor = {'size': 2.0*linescale, 'width': 0.6*linescale}
mpl.rc('xtick.major', **tick_major)
mpl.rc('ytick.major', **tick_major)
mpl.rc('xtick.minor', **tick_minor)
mpl.rc('ytick.minor', **tick_minor)
mpl.rc('xtick', direction='in')
mpl.rc('ytick', direction='in')
mpl.rc('font', **font)
mpl.rc('mathtext', fontset='cm')
# %% formatting for phase
def multiple_formatter(denominator=2, number=np.pi, latex='\pi'):
def gcd(a, b):
while b:
a, b = b, a%b
return a
def _multiple_formatter(x, pos):
den = denominator
num = np.int32(np.rint(den*x/number))
com = gcd(num,den)
(num,den) = (int(num/com),int(den/com))
if den==1:
if num==0:
return r'$0$'
if num==1:
return r'$%s$'%latex
elif num==-1:
return r'$-%s$'%latex
else:
return r'$%s%s$'%(num,latex)
else:
if num==1:
return r'$%s/%s$'%(latex,den)
elif num==-1:
return r'$-%s/%s$'%(latex,den)
else:
return r'$%s%s/%s$'%(num,latex,den)
return _multiple_formatter
# %% Figure generated via Scripts/Eigenfunctions/Trajectories/poincare_section_lyapunov.py
case = 1
tab20c = mpl.cm.get_cmap('tab20c')
fig, ax = plt.subplots(1, 2, figsize=(3.375, 3.375*0.6), dpi=300)
vardata = np.load('case{}_eigencomponent_extradata.npz'.format(case))
mode0_phasedeviation = vardata['mode0_phasedeviation']
energydeviation = vardata['energydeviation']
#amprange = np.arange(0.6, 1.31, 0.05)
ax[0].axvspan(np.sqrt(np.min(energydeviation)), np.sqrt(np.max(energydeviation)), color=tab20c(7.5/20.0))
j = 0
if case == 1:
numwaves = [3, 4, 5, 6, 7, 8]
else:
numwaves = [13, 14, 15, 16, 17]
for i in numwaves:
data = np.load('../lyapunovs/case{}_lyaps_multicontour_{}modes.npz'.format(case,i))
lyaps = data['lyaps']
lyapstds = data['lyapstds']
amprange = data['amprange']
#ax[0].errorbar(amprange, lyaps, yerr=lyapstds, c=tab20c((3.5-j)/20.0), label=str(i))
ax[0].plot(amprange, lyaps, c=tab20c((3.5-j)/20.0), label=str(i))
j = j+1
ax[0].text(-0.1, 1.02, r'$\bar{\lambda}$', transform=ax[0].transAxes)
ax[0].legend(loc='upper left')
ax[0].set_yscale('log')
ax[0].set_xlabel('Mode amplitude')
ax[0].yaxis.set_minor_locator(plt.NullLocator())
#ax[0].set_ylim([5e-6, 5e2])
ax[0].set_title('vs. number of modes')
"""
data = np.load('../lyapunovs/case{}_lyaps_multicontour_allphases.npz'.format(case))
amprange = data['amprange']
phrange = data['phrange']
lyaps = data['lyaps']
lyapstds = data['lyapstds']
#ax[1].axvspan(np.min(mode0_phasedeviation), np.max(mode0_phasedeviation), color=tab20c(7.5/20.0))
#ax[1].axvline(0.0, ls='--', c=tab20c(4.5/20.0))
for i in range(len(amprange)):
#ax[1].errorbar(phrange, lyaps[:,i], yerr=lyapstds[:,i], c=tab20c((15.5-i)/20.0), label='{0:.2f}'.format(amprange[i]))
ax[1].plot(phrange, lyaps[:,i], c=tab20c((15.5-i)/20.0), label='{0:.2f}'.format(amprange[i]))
#ax[1].text(0.05, lyaps[len(phrange)//2,i]*0.7, '{0:.2f}'.format(amprange[i]))
ax[1].text(-0.1, 1.02, r'$\bar{\lambda}$', transform=ax[1].transAxes)
ax[1].legend(loc='upper center', ncol=2)
ax[1].set_yscale('log')
ax[1].set_ylim(None, 2e1)
ax[1].set_xlabel('Mode 1 phase in $x$')
ax[1].xaxis.set_major_locator(plt.MultipleLocator(np.pi / 2))
ax[1].xaxis.set_major_formatter(plt.FuncFormatter(multiple_formatter()))
ax[1].yaxis.set_minor_locator(plt.NullLocator())
ax[1].set_title('vs. phase of mode 1')
"""
data = np.load('../lyapunovs/case{}_lyaps_numwaves_uphsort.npz'.format(case))
numwaves = data['numwaves']
lyaps = data['lyaps']
lyapstds = data['lyapstds']
i=0
ax[1].plot(numwaves, lyaps, c=tab20c((15.5-i)/20.0), marker='.')
ax[1].set_yscale('log')
#ax[1].xaxis.set_major_locator(plt.MultipleLocator(np.pi / 2))
#ax[1].xaxis.set_major_formatter(plt.FuncFormatter(multiple_formatter()))
#ax[1].yaxis.set_minor_locator(plt.NullLocator())
plt.suptitle('Lyapunov Exponents')
plt.tight_layout(h_pad=1.6)
plt.tight_layout(h_pad=1.6)
#plt.savefig('lyapunov_exponents.pdf', dpi=200)
#plt.savefig('lyapunov_exponents.png', dpi=300)
|
evanthebouncy/nnhmm | uai_sushi/active_learning.py | <reponame>evanthebouncy/nnhmm<filename>uai_sushi/active_learning.py
from model import *
# ------------------------------------------------------------------ helpers and mgmt
def get_feed_dic_obs(obs):
# needing to create all the nessisary feeds
obs_x = []
obs_y = []
obs_tf = []
for _ in range(OBS_SIZE):
obs_x.append(np.zeros([N_BATCH,L]))
obs_y.append(np.zeros([N_BATCH,L]))
obs_tf.append(np.zeros([N_BATCH,2]))
num_obs = len(obs)
for ob_idx in range(num_obs):
ob_coord, ob_lab = obs[ob_idx]
ob_x, ob_y = vectorize(ob_coord)
obs_x[ob_idx] = np.tile(ob_x, [50,1])
obs_y[ob_idx] = np.tile(ob_y, [50,1])
obs_tf[ob_idx] = np.tile(ob_lab, [50,1])
feed_dic = dict(zip(ph_obs_x + ph_obs_y + ph_obs_tf,
obs_x + obs_y + obs_tf))
return feed_dic
def get_inv(sess, obs):
num_obs = len(obs)
return get_inv_tr(sess, obs)[num_obs]
def get_all_preds(sess, obs):
feed_dic = get_feed_dic_obs(obs)
all_querys = []
for i in range(L):
for j in range(L):
all_querys.append((i,j))
ret = [[] for _ in range(OBS_SIZE+1)]
for q in all_querys:
q_x, q_y = vectorize(q)
feed_dic[ph_new_ob_x] = np.tile(q_x, [N_BATCH,1])
feed_dic[ph_new_ob_y] = np.tile(q_y, [N_BATCH,1])
pred_tfs = sess.run(query_preds, feed_dict=feed_dic)
for key_ob in range(OBS_SIZE+1):
ret[key_ob].append((q, pred_tfs[key_ob][0]))
return ret
def get_preds_batch(sess, obs, batch_querys):
ret = [[] for _ in range(OBS_SIZE+1)]
feed_dic = get_feed_dic_obs(obs)
assert len(batch_querys) == N_BATCH
new_ob_x = []
new_ob_y = []
for q in batch_querys:
q_x, q_y = vectorize(q)
new_ob_x.append(q_x)
new_ob_y.append(q_y)
feed_dic[ph_new_ob_x] = np.array(new_ob_x)
feed_dic[ph_new_ob_y] = np.array(new_ob_y)
pred_tfs = sess.run(query_preds, feed_dict=feed_dic)
for key_ob in range(OBS_SIZE+1):
for q_idx, q in enumerate(batch_querys):
ret[key_ob].append((q, pred_tfs[key_ob][q_idx]))
return ret
def get_all_preds_fast(sess, obs):
all_querys = []
for i in range(L):
for j in range(L):
all_querys.append((i,j))
def batch_qrys(all_qs):
ret = []
while len(all_qs) != 0:
to_add = [(0,0) for _ in range(N_BATCH)]
for idk in range(N_BATCH):
if len(all_qs) == 0:
break
to_add[idk] = all_qs.pop()
ret.append(to_add)
return ret
ret = [[] for _ in range(OBS_SIZE+1)]
batched_qrysss = batch_qrys(all_querys)
for batched_q in batched_qrysss:
ppp = get_preds_batch(sess, obs, batched_q)
for ijk in range(OBS_SIZE+1):
ret[ijk] += ppp[ijk]
return ret
def get_most_confuse(sess, obs):
key_ob = len(obs)
all_preds = get_all_preds_fast(sess, obs)
all_pred_at_key = all_preds[key_ob]
most_confs = [(abs(x[1][0] - x[1][1]), x[0]) for x in all_pred_at_key]
most_conf = min(most_confs)
return most_conf[1]
def get_random_inv(sess, query, OBS_SIZE=OBS_SIZE):
ob_pts = [sample_coord_bias(query) for _ in range(OBS_SIZE)]
obs = [(op, query(op)) for op in ob_pts]
feed_dic = get_feed_dic_obs(obs)
invs = [(x[0], np.argmax(x[0])) for x in sess.run(x_invs, feed_dict=feed_dic)]
return zip([None] + obs, get_all_preds(sess, obs), invs)
def get_random_inv_direct(sess, query):
ob_pts = [(np.random.randint(0, L), np.random.randint(0,L)) for _ in range(OBS_SIZE)]
obs = [(op, query(op)) for op in ob_pts]
ret = sess.run([inv_s1_xs[OBS_SIZE],
inv_s1_ys[OBS_SIZE],
inv_s1_os[OBS_SIZE],
inv_s2_xs[OBS_SIZE],
inv_s2_ys[OBS_SIZE],
inv_s2_os[OBS_SIZE]], feed_dict=get_feed_dic_obs(obs))
return [x[0] for x in ret]
def get_active_inv_direct(sess, query):
obs = []
for i in range(OBS_SIZE):
most_conf = get_most_confuse(sess, obs)
obs.append((most_conf, query(most_conf)))
ret = sess.run([inv_s1_xs[OBS_SIZE],
inv_s1_ys[OBS_SIZE],
inv_s1_os[OBS_SIZE],
inv_s2_xs[OBS_SIZE],
inv_s2_ys[OBS_SIZE],
inv_s2_os[OBS_SIZE]], feed_dict=get_feed_dic_obs(obs))
return [x[0] for x in ret]
def get_active_inv(sess, query, OBS_SIZE=OBS_SIZE):
obs = []
for i in range(OBS_SIZE):
most_conf = get_most_confuse(sess, obs)
print "most conf so far ", most_conf
obs.append((most_conf, query(most_conf)))
feed_dic = get_feed_dic_obs(obs)
invs = [(x[0], np.argmax(x[0])) for x in sess.run(x_invs, feed_dict=feed_dic)]
return zip([None] + obs, get_all_preds(sess, obs), invs)
|
Mikma03/InfoShareacademy_Python_Courses | Part_3_advanced/m06_re/findall_finditer/homework_1_solution.py | <filename>Part_3_advanced/m06_re/findall_finditer/homework_1_solution.py<gh_stars>0
# Napisz funkcje która przyjmie tekst zawierający potencjalnie wiele różnych adresów email
# a następnie wypisze każdy z nich (z podziałem na nazwę, domenę i rozszerzenie).
# Wykorzystaj metodę findall
import re
def run_example():
example_text = "To jest tekst, który ma adresy email: <EMAIL> oraz <EMAIL>"
find_all_emails(example_text)
def find_all_emails(text):
email_pattern = re.compile(r"(\w+)@(\w+)((?:\.\w+)+)")
email_matches = email_pattern.findall(text)
for email_match in email_matches:
print_email_details(email_match)
def print_email_details(email_match):
print(20 * "-")
print(f"Adres email:")
print(f"Nazwa: {email_match[0]}")
print(f"Domena: {email_match[1]}")
print(f"Rozszerzenie domeny: {email_match[2]}")
if __name__ == "__main__":
run_example()
|
DANIELROCHA1990/nindika | spec/components/app/toast_component_spec.rb | <filename>spec/components/app/toast_component_spec.rb
# frozen_string_literal: true
require 'rails_helper'
RSpec.describe App::ToastComponent, type: :component do
subject(:rendered) { render_inline(described_class.new) }
context 'when flash is empty' do
it "doesn't render" do
expect(rendered.to_html).to be_blank
end
end
context 'when flash is filled' do
subject(:rendered) { render_inline(component) }
let(:component) { described_class.new }
let(:flash) { ActionDispatch::Flash::FlashHash.new }
before do
flash[:danger] = 'some message'
allow(component).to receive(:helpers).and_return(double(flash: flash)) # rubocop:disable RSpec/VerifiedDoubles
end
it 'renders component' do
expect(rendered.to_html).to be_present
end
end
end
|
Lugdunum3D/Lugdunum3D | include/lug/Graphics/Vulkan/API/Semaphore.hpp | <filename>include/lug/Graphics/Vulkan/API/Semaphore.hpp
#pragma once
#include <lug/Graphics/Export.hpp>
#include <lug/Graphics/Vulkan/Vulkan.hpp>
namespace lug {
namespace Graphics {
namespace Vulkan {
namespace API {
namespace Builder {
class Semaphore;
} // Builder
class Device;
class LUG_GRAPHICS_API Semaphore {
friend class Builder::Semaphore;
public:
Semaphore() = default;
Semaphore(const Semaphore&) = delete;
Semaphore(Semaphore&& semaphore);
Semaphore& operator=(const Semaphore&) = delete;
Semaphore& operator=(Semaphore&& semaphore);
~Semaphore();
explicit operator VkSemaphore() const {
return _semaphore;
}
void destroy();
private:
explicit Semaphore(VkSemaphore semaphore, const Device* device);
private:
VkSemaphore _semaphore{VK_NULL_HANDLE};
const Device* _device{nullptr};
};
} // API
} // Vulkan
} // Graphics
} // lug
|
keki/dd-trace-java | dd-java-agent/agent-profiling/profiling-controller/src/test/java/com/datadog/profiling/controller/ControllerFactoryTest.java | <reponame>keki/dd-trace-java<filename>dd-java-agent/agent-profiling/profiling-controller/src/test/java/com/datadog/profiling/controller/ControllerFactoryTest.java
package com.datadog.profiling.controller;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertThrows;
import static org.junit.jupiter.api.condition.JRE.JAVA_8;
import datadog.trace.api.Config;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.condition.EnabledOnJre;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
/** Note: some additional tests for this class are located in profiling-controller-openjdk module */
@ExtendWith(MockitoExtension.class)
public class ControllerFactoryTest {
@Mock private Config config;
@Test
@EnabledOnJre({JAVA_8})
public void testCreateControllerJava8() {
UnsupportedEnvironmentException unsupportedEnvironmentException =
assertThrows(
UnsupportedEnvironmentException.class,
() -> {
ControllerFactory.createController(config);
});
String expected =
"Not enabling profiling; it requires OpenJDK 11+, Oracle Java 11+, or Zulu Java 8 (1.8.0_212+).";
final String javaVendor = System.getProperty("java.vendor");
final String javaRuntimeName = System.getProperty("java.runtime.name");
final String javaVersion = System.getProperty("java.version");
if ("Azul Systems, Inc.".equals(javaVendor)) {
expected = "Not enabling profiling; it requires Zulu Java 8 (1.8.0_212+).";
} else if ("Java(TM) SE Runtime Environment".equals(javaRuntimeName)
&& "Oracle Corporation".equals(javaVendor)
&& javaVersion.startsWith("1.8")) {
// condition for OracleJRE8 (with proprietary JFR inside)
expected = "Not enabling profiling; it requires Oracle Java 11+.";
}
assertEquals(
expected,
unsupportedEnvironmentException.getMessage(),
"'" + javaRuntimeName + "' / '" + javaVendor + "' / '" + javaVersion + "'");
}
}
|
naphaso/nlisp | pkg/vm/vm.go | package vm
import (
"errors"
"fmt"
"time"
"github.com/naphaso/nlisp/pkg/sexp"
"github.com/naphaso/nlisp/pkg/symbol"
)
func New() *VM {
return &VM{
env: sexp.NewEnv(),
}
}
var (
symbolPlus = symbol.ByName("plus")
symbolEval = symbol.ByName("eval")
)
type VM struct {
env *sexp.Env
stack1 Stack
stack2 Stack
}
func (s *VM) Eval(e sexp.Sexp) (sexp.Sexp, error) {
var err error
s.stack1.Push(symbolEval)
s.stack1.Push(e)
var c sexp.Sexp
for {
fmt.Printf("stack1: %s\n", s.stack1.String())
fmt.Printf("stack2: %s\n", s.stack2.String())
for {
c = s.stack1.Pop()
if c == nil {
break
}
if c.Equal(symbolPlus) {
err = s.evalPlus()
if err != nil {
return nil, err
}
} else if c.Equal(symbolEval) {
err = s.evalEval()
if err != nil {
return nil, err
}
}
}
s.stack1, s.stack2 = s.stack2, s.stack1
time.Sleep(5 * time.Second)
}
}
func (s *VM) evalEval() error {
e := s.stack1.Pop()
if e == nil {
return errors.New("eval nil")
}
switch ev := e.(type) {
case *sexp.Int64:
s.stack2.Push(e)
case sexp.Symbol:
s.stack2.Push(s.env.Get(ev))
case sexp.Pair:
s.stack2.Push(symbolPlus)
for e != nil {
p, ok := e.(sexp.Pair)
if !ok {
return errors.New("not a pair")
}
s.stack2.Push(symbolEval)
s.stack2.Push(p.Head)
e = p.Tail
}
}
return nil
}
func (s *VM) evalPlus() error {
var value int64
for {
e := s.stack1.Pop()
if e == nil {
s.stack2.Push(sexp.NewInt64(value))
break
}
ei, ok := e.(sexp.Int64)
if !ok {
return errors.New("plus not integer")
}
value += int64(ei)
}
return nil
}
|
VereinGegenTierfabriken/cgeo | main/src/cgeo/geocaching/connector/capability/ISearchByFinder.java | <gh_stars>1-10
package cgeo.geocaching.connector.capability;
import cgeo.geocaching.SearchResult;
import cgeo.geocaching.connector.IConnector;
import cgeo.geocaching.loaders.RecaptchaReceiver;
import android.support.annotation.NonNull;
public interface ISearchByFinder extends IConnector {
SearchResult searchByFinder(@NonNull final String finder, @NonNull final RecaptchaReceiver recaptchaReceiver);
}
|
LeonardTay748/main | src/test/java/seedu/address/model/FlashCardTestModelTest.java | package seedu.address.model;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;
import java.util.LinkedList;
import java.util.List;
import org.junit.jupiter.api.Test;
import seedu.address.model.flashcard.FlashCard;
import seedu.address.testutil.FlashCardTestListBuilder;
public class FlashCardTestModelTest {
private FlashCardTestModel flashCardTestModel;
private List<FlashCard> testList = new FlashCardTestListBuilder().build();
@Test
public void isEmpty_emptyList_success() {
flashCardTestModel = new FlashCardTestModel(new LinkedList<>());
assertTrue(flashCardTestModel.isEmpty());
}
@Test
public void isEmpty_nonEmptyList_success() {
flashCardTestModel = new FlashCardTestModel(testList);
assertFalse(flashCardTestModel.isEmpty());
}
@Test
public void getQuestion_validTestList_success() {
flashCardTestModel = new FlashCardTestModel(testList);
flashCardTestModel.setFlashcard();
String expectedOutput = "0 + 10";
assertEquals(expectedOutput, flashCardTestModel.getQuestion());
}
@Test
public void equals() {
flashCardTestModel = new FlashCardTestModel(testList);
FlashCardTestModel anotherFlashCardTestModel = new FlashCardTestModel(testList);
assertTrue(flashCardTestModel.equals(anotherFlashCardTestModel));
}
}
|
nclslbrn/xyz | src/js/sketch-common/remap.js | <reponame>nclslbrn/xyz<filename>src/js/sketch-common/remap.js
/**
* P5js map
*
* @url https://github.com/processing/p5.js/blob/7375939aa4e4e5ada7381815ace2dcb8a0daa74c/src/math/calculation.js#L451
* @method map
* @param {Number} value the incoming value to be converted
* @param {Number} start1 lower bound of the value's current range
* @param {Number} stop1 upper bound of the value's current range
* @param {Number} start2 lower bound of the value's target range
* @param {Number} stop2 upper bound of the value's target range
* @param {Boolean} [withinBounds] constrain the value to the newly mapped range
* @return {Number} remapped number
*/
export default function (n, start1, stop1, start2, stop2) {
return ((n - start1) / (stop1 - start1)) * (stop2 - start2) + start2
}
|
afonsopbarros/appcenter-cli | dist/commands/codepush/lib/validation-utils.js | "use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateVersion = exports.isValidDeployment = exports.isValidRollout = exports.isValidRange = exports.isValidVersion = void 0;
const semver = require("semver");
const apis_1 = require("../../../util/apis");
const regexpForMajor = /^\d+$/;
const regexpForMajorMinor = /^\d+\.\d+$/;
// Check if the given string is a semver-compliant version number (e.g. '1.2.3')
// (missing minor/patch values will be added on server side to pass semver.satisfies check)
function isValidVersion(version) {
return !!semver.valid(version) || regexpForMajorMinor.test(version) || regexpForMajor.test(version);
}
exports.isValidVersion = isValidVersion;
// Allow plain integer versions (as well as '1.0' values) for now, e.g. '1' is valid here and we assume that it is equal to '1.0.0'.
function isValidRange(semverRange) {
return !!semver.validRange(semverRange);
}
exports.isValidRange = isValidRange;
function isValidRollout(rollout) {
return rollout && rollout > 0 && rollout <= 100;
}
exports.isValidRollout = isValidRollout;
function isValidDeployment(client, app, deploymentName) {
var _a;
return __awaiter(this, void 0, void 0, function* () {
let httpRequest;
try {
httpRequest = yield apis_1.clientRequest((cb) => client.codePushDeployments.get(deploymentName, app.ownerName, app.appName, cb));
}
catch (error) {
if (((_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.statusCode) === 404) {
// 404 is correct status code for this case
return false;
}
throw error;
}
return httpRequest.response.statusCode === 200;
});
}
exports.isValidDeployment = isValidDeployment;
function validateVersion(version) {
if (regexpForMajorMinor.test(version)) {
return version + ".X";
}
else if (regexpForMajor.test(version)) {
return version + ".X.X";
}
else {
return null;
}
}
exports.validateVersion = validateVersion;
|
hgzerowzh/Django | Django_learning/Django_test_03/Django_test_03/__init__.py | import pymysql
pymysql.version_info=(1,3,13,"final",0)
pymysql.install_as_MySQLdb()
|
xscottx/learn-react | expensify-app/src/tests/components/expenses-summary.test.js | <filename>expensify-app/src/tests/components/expenses-summary.test.js
import React from 'react';
import {shallow} from 'enzyme';
import expenses from '../fixtures/expenses';
import {ExpensesSummary} from '../../components/expenses-summary';
test('should correctly render expenses summary with 1 expense', () => {
const wrapper = shallow(<ExpensesSummary expenseCount={1} expensesTotal={235} />);
expect(wrapper).toMatchSnapshot();
})
test('should correctly render expenses summary with multiple expenses', () => {
const wrapper = shallow(<ExpensesSummary expenseCount={23} expensesTotal={123456789} />);
expect(wrapper).toMatchSnapshot();
}) |
realvitya/fmcapi | fmcapi/api_objects/object_services/applicationproductivities.py | from fmcapi.api_objects.apiclasstemplate import APIClassTemplate
import logging
import warnings
class ApplicationProductivities(APIClassTemplate):
"""
The ApplicationProductivities Object in the FMC.
"""
VALID_JSON_DATA = ["id", "name", "type"]
VALID_FOR_KWARGS = VALID_JSON_DATA + []
URL_SUFFIX = "/object/applicationproductivities"
VALID_CHARACTERS_FOR_NAME = """[.\w\d_\- ]"""
def __init__(self, fmc, **kwargs):
super().__init__(fmc, **kwargs)
logging.debug("In __init__() for ApplicationProductivities class.")
self.parse_kwargs(**kwargs)
def post(self):
logging.info("POST method for API for ApplicationProductivities not supported.")
pass
def put(self):
logging.info("PUT method for API for ApplicationProductivities not supported.")
pass
def delete(self):
logging.info(
"DELETE method for API for ApplicationProductivities not supported."
)
pass
class ApplicationProductivity(ApplicationProductivities):
"""Dispose of this Class after 20210101."""
def __init__(self, fmc, **kwargs):
warnings.resetwarnings()
warnings.warn(
"Deprecated: ApplicationProductivity() should be called via ApplicationProductivities()."
)
super().__init__(fmc, **kwargs)
|
danielbraga/hcap | project/settings/env.py | <reponame>danielbraga/hcap<filename>project/settings/env.py
"""
django-environ:
https://django-environ.readthedocs.io/en/latest/#django-environ
"""
import environ
from pathlib import Path
ENV_PATH = Path.joinpath(Path(__file__).parent.parent.parent, ".env")
env = environ.Env()
if ENV_PATH.exists() and ENV_PATH.is_file():
environ.Env.read_env(env_file=ENV_PATH.open())
ENV = env("HCAP__ENV", default="dev")
|
pmacleod/geotrellis | layer/src/test/scala/geotrellis/layer/LayoutDefinitionSpec.scala | <gh_stars>1-10
/*
* Copyright 2016 Azavea
*
* 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 geotrellis.layer
import geotrellis.raster._
import geotrellis.vector.Extent
import org.scalatest._
class LayoutDefinitionSpec extends FunSpec with Matchers {
describe("LayoutDefinition"){
it("should not buffer the extent of a grid that fits within it's bounds"){
val e = Extent(-31.4569758, 27.6350020, 40.2053192, 80.7984255)
val cs = CellSize(0.08332825, 0.08332825)
val tileSize = 256
val ld = LayoutDefinition(GridExtent[Long](e, cs), tileSize, tileSize)
val ld2 = LayoutDefinition(GridExtent[Long](ld.extent, cs), ld.tileCols, ld.tileRows)
ld2.extent should be (ld.extent)
}
val grid = GridExtent[Long](Extent(-180, -90, 180, 90), CellSize(0.001, 0.001))
val layout = LayoutDefinition(grid, 300, 300)
it("not equal its GridExtent") {
layout.cellSize shouldBe grid.cellSize
(layout.cols) shouldBe grid.cols
(layout.rows) shouldBe grid.rows
layout should not equal (grid)
}
}
}
|
herrywen-nanj/51reboot | lesson02/yaoxiaodong/homework2.py | <reponame>herrywen-nanj/51reboot<filename>lesson02/yaoxiaodong/homework2.py
data = [3, 7, 2, 5, 20, 11]
num = len(data)
for one in range(num-1):
for two in range(num-one-1):
if data[two] > data[two+1]:
data[two],data[two+1] = data[two+1],data[two]
print(data)
|
HPI-Information-Systems/TimeEval | timeeval/__init__.py | from ._version import __version__
from .algorithm import Algorithm
from .data_types import AlgorithmParameter, TrainingType, InputDimensionality
from .datasets import Datasets, DatasetManager, MultiDatasetManager
from .remote_configuration import RemoteConfiguration
from .resource_constraints import ResourceConstraints
from .timeeval import TimeEval, Status
from .utils.metrics import Metric
|
tessia-project/tessia-baselib | tessia/baselib/common/ssh/exceptions.py | # Copyright 2016, 2017 IBM Corp.
#
# 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.
"""
Defines the exceptions used by the ssh module
"""
#
# IMPORTS
#
#
# CONSTANTS AND DEFINITIONS
#
#
# CODE
#
# this module defines all the exceptions used by ssh package
class SshClientError(Exception):
"""
Exception used by SshClient class when problems related to the underlying
library occur.
"""
# SshClientError
class SshShellError(Exception):
"""
Exception used by SshShell class when problems related to the actual shell
usage occur.
"""
# SshShellError
|
jenswi-linaro/hafnium | inc/hf/spinlock.h | <gh_stars>1-10
/*
* Copyright 2018 The Hafnium Authors.
*
* Use of this source code is governed by a BSD-style
* license that can be found in the LICENSE file or at
* https://opensource.org/licenses/BSD-3-Clause.
*/
#pragma once
/*
* Includes the arch-specific definition of 'struct spinlock' and
* implementations of:
* - SPINLOCK_INIT
* - sl_lock()
* - sl_unlock()
*/
#include "hf/arch/spinlock.h"
static inline void sl_init(struct spinlock *l)
{
*l = SPINLOCK_INIT;
}
/**
* Locks both locks, enforcing the lowest address first ordering for locks of
* the same kind.
*/
static inline void sl_lock_both(struct spinlock *a, struct spinlock *b)
{
if (a < b) {
sl_lock(a);
sl_lock(b);
} else {
sl_lock(b);
sl_lock(a);
}
}
|
dukfaar/ffxivcrafter | packages/custom/ffxivcrafter-bot/server/commands/potatofarm.js | 'use strict'
let mongoose = require('mongoose')
let q = require('q')
let _ = require('lodash')
let path = require('path')
mongoose.Promise = q.Promise
var logger = require('log4js').getLogger('app.bot.potatofarm')
let config = require(path.join(__dirname, '../config/config.js'))
let farmingTimeouts = {
}
module.exports = function (botDef) {
setTimeout(initTimeouts, 5000)
let commandRegex = /(potatofarm) ([0-9]*(\.[0-9]+)?)/i
return {
name: commandRegex,
command: command
}
var User
var UserDiscord
var GameStats
function findOrCreateGameStats (user) {
return GameStats.findOne({user: user}).exec()
.then(gamestats => {
if (gamestats) return gamestats
let newstats = new GameStats()
newstats.user = user
return newstats
})
}
function updateFarmResults (id, gold) {
UserDiscord.findOne({_id: id})
.exec().then(userDiscord => {
userDiscord.gold += gold
userDiscord.save().then(() => {
logger.info('farming for user %s was successfull, added %s gold', userDiscord._id, gold)
delete farmingTimeouts[userDiscord._id]
findOrCreateGameStats(userDiscord.user)
.then(gamestats => {
gamestats.farmStart = undefined
gamestats.farmDuration = 0
gamestats.save()
})
})
})
}
function command (params, message) {
User = User || mongoose.model('User')
UserDiscord = UserDiscord || mongoose.model('UserDiscord')
GameStats = GameStats || mongoose.model('GameStats')
let attackerName = message.author.username + '#' + message.author.discriminator
let regexResult = commandRegex.exec(message)
let farmDuration_h = Number.parseFloat(regexResult[2])
let farmDuration_m = farmDuration_h * 60
let farmDuration_s = farmDuration_m * 60
let farmDuration_ms = farmDuration_s * 1000
UserDiscord.findOne({discord: attackerName})
.exec().then(userDiscord => {
if (!userDiscord) throw new Error('User is not known')
if (!farmingTimeouts[userDiscord._id]) {
farmingTimeouts[userDiscord._id] = setTimeout(() => {
updateFarmResults(userDiscord._id, farmDuration_s * config.bot.game.potatofarm.goldPerSecond)
}, farmDuration_ms)
findOrCreateGameStats(userDiscord.user)
.then(gamestats => {
gamestats.farmStart = new Date()
gamestats.farmDuration = farmDuration_ms
logger.info(gamestats)
gamestats.save()
.catch(logger.error)
})
logger.info('Farming started for user %s for %ss', userDiscord._id, farmDuration_s)
message.channel.send('Farming has begun! You will finish in ' + farmDuration_m + ' minutes.')
} else {
logger.info('User %s tried working while work is already in progress', userDiscord._id)
message.channel.send('Your farming is already in progress.')
}
})
.catch(err => {
logger.error(err)
message.channel.send('Sorry something went wrong there. *smashes head against a wall*')
})
}
function checkGameStats (gamestats) {
if (gamestats.farmStart && gamestats.farmDuration) {
let now = new Date()
let nowMs = now.getTime()
let thenMs = gamestats.farmStart.getTime() + gamestats.farmDuration
let distance = thenMs - nowMs
let farmDuration_ms = distance
UserDiscord.findOne({user: gamestats.user})
.exec().then(userDiscord => {
if (farmDuration_ms > 0) {
logger.info('Restarted farm command for user %s, %s ms remaining', userDiscord.user, farmDuration_ms)
farmingTimeouts[userDiscord._id] = setTimeout(() => {
updateFarmResults(userDiscord._id, (gamestats.farmDuration / 1000) * config.bot.game.potatofarm.goldPerSecond)
}, farmDuration_ms)
} else {
logger.info('Farming for user %s already done, processing', userDiscord.user)
updateFarmResults(userDiscord._id, (gamestats.farmDuration / 1000) * config.bot.game.potatofarm.goldPerSecond)
}
})
}
}
function initTimeouts () {
GameStats = GameStats || mongoose.model('GameStats')
UserDiscord = UserDiscord || mongoose.model('UserDiscord')
GameStats.find({}).exec().then(stats => {
_.forEach(stats, checkGameStats)
})
}
}
|
datanucleus/datanucleus-scala | src/test/scala/org/datanucleus/scala/test/RandomUtils.scala | <gh_stars>1-10
package org.datanucleus.scala.test
import java.time.LocalDate
import java.util
import java.util.UUID
import java.util.concurrent.ThreadLocalRandom
import scala.util.Random
trait RandomUtils {
def randomString(): String = UUID.randomUUID().toString
def randomLocalDate(): LocalDate = {
val minDay = LocalDate.of(1970, 1, 1).toEpochDay
val maxDay = LocalDate.of(2095, 12, 31).toEpochDay
val randomDay = ThreadLocalRandom.current.nextLong(minDay, maxDay)
LocalDate.ofEpochDay(randomDay)
}
}
|
dshkuratov/dibctl | tests/test_timeout.py | #!/usr/bin/python
import os
import inspect
import sys
import pytest
import mock
import time
from mock import sentinel
@pytest.fixture
def timeout():
from dibctl import timeout
return timeout
def test_timeout_real_timeout(timeout):
with pytest.raises(timeout.TimeoutError):
with timeout.timeout(1):
import time
time.sleep(2)
def test_timeout_after_exception(timeout):
# based on real bug: alarm wasn't cleared after error handler
with pytest.raises(ValueError):
with timeout.timeout(1):
raise ValueError
time.sleep(2)
def test_timeout_check_no_error(timeout):
with timeout.timeout(1):
pass
def test_timeout_bad_signal(timeout):
t = timeout.timeout(1)
with pytest.raises(RuntimeError):
t.raise_timeout("NOT A TIMEOUT", sentinel.frame)
if __name__ == "__main__":
ourfilename = os.path.abspath(inspect.getfile(inspect.currentframe()))
currentdir = os.path.dirname(ourfilename)
parentdir = os.path.dirname(currentdir)
file_to_test = os.path.join(
parentdir,
os.path.basename(parentdir),
os.path.basename(ourfilename).replace("test_", '', 1)
)
pytest.main([
"-vv",
"--cov", file_to_test,
"--cov-report", "term-missing"
] + sys.argv)
|
CHRUdeLille/scout | tests/server/blueprints/variants/test_controllers.py | from scout.server.blueprints.variants.controllers import sanger, cancel_sanger
def url_for(param, institute_id, case_name, variant_id):
pass
def test_sanger_mail_sent(mock_mail, variant_database, institute_obj, case_obj, user_obj,
mock_sender):
# Given we have a variant the we want to order sanger for
variant_obj = variant_database.variant_collection.find_one()
variant_obj['hgnc_symbols'] = ''
variant_obj['panels'] = ''
# When calling sanger method
sanger(variant_database, mock_mail, institute_obj, case_obj, user_obj, variant_obj,
mock_sender, url_for)
# Then the supplied mail objects send method should have been called
assert mock_mail._send_was_called
# Then the supplied mail objects send method should have received a message object
assert mock_mail._message
def test_cancel_sanger_mail_sent(mock_mail, variant_database, institute_obj, case_obj, user_obj,
mock_sender):
# Given we have a variant the we want to order sanger for
variant_obj = variant_database.variant_collection.find_one()
variant_obj['hgnc_symbols'] = ''
variant_obj['panels'] = ''
# When calling sanger method
cancel_sanger(variant_database, mock_mail, institute_obj, case_obj, user_obj, variant_obj,
mock_sender, url_for)
# Then the supplied mail objects send method should have been called
assert mock_mail._send_was_called
# Then the supplied mail objects send method should have received a message object
assert mock_mail._message
|
icatproject-contrib/ijp.server | src/test/java/org/icatproject/ijp/server/manager/XmlFileManagerTest.java | package org.icatproject.ijp.server.manager;
import org.icatproject.ijp.shared.InternalException;
import org.icatproject.ijp.shared.xmlmodel.JobType;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TemporaryFolder;
import java.io.File;
import java.io.IOException;
import java.io.PrintWriter;
import static org.hamcrest.CoreMatchers.equalTo;
import static org.junit.Assert.assertThat;
public class XmlFileManagerTest {
@Rule
public TemporaryFolder folder = new TemporaryFolder();
@Test
public void testJobTypeModel_multipleTrue_multipleTrue() throws IOException, InternalException {
File input = folder.newFile("test.xml");
try(PrintWriter writer = new PrintWriter(input)) {
writer.write("<jobType>\n" +
" <multiple>true</multiple>\n" +
"</jobType>");
};
XmlFileManager fileManager = new XmlFileManager();
JobType jt = fileManager.getJobType(input);
assertThat(jt.getMultiple().isMultiple(), equalTo(true));
}
@Test
public void testJobTypeModel_multipleFalse_multipleFalse() throws IOException, InternalException {
File input = folder.newFile("test.xml");
try(PrintWriter writer = new PrintWriter(input)) {
writer.write("<jobType>\n" +
" <multiple>false</multiple>\n" +
"</jobType>");
};
XmlFileManager fileManager = new XmlFileManager();
JobType jt = fileManager.getJobType(input);
assertThat(jt.getMultiple().isMultiple(), equalTo(false));
}
@Test
public void testJobTypeModel_noMultipleEntry_multipleFalse() throws IOException, InternalException {
File input = folder.newFile("test.xml");
try(PrintWriter writer = new PrintWriter(input)) {
writer.write("<jobType>\n" +
"</jobType>");
};
XmlFileManager fileManager = new XmlFileManager();
JobType jt = fileManager.getJobType(input);
assertThat(jt.getMultiple().isMultiple(), equalTo(false));
}
@Test
public void testJobTypeModel_forceSingleJob_forceSingleJobIsTrue() throws IOException, InternalException {
File input = folder.newFile("test.xml");
try(PrintWriter writer = new PrintWriter(input)) {
writer.write("<jobType>\n" +
" <multiple forceSingleJob=\"true\">true</multiple>\n" +
"</jobType>");
};
XmlFileManager fileManager = new XmlFileManager();
JobType jt = fileManager.getJobType(input);
assertThat(jt.getMultiple().isForceSingleJob(), equalTo(true));
}
@Test
public void testJobTypeModel_noForceSingleJobAttribute_forceSingleJobIsFalse() throws IOException,
InternalException {
File input = folder.newFile("test.xml");
try(PrintWriter writer = new PrintWriter(input)) {
writer.write("<jobType>\n" +
" <multiple>true</multiple>\n" +
"</jobType>");
};
XmlFileManager fileManager = new XmlFileManager();
JobType jt = fileManager.getJobType(input);
assertThat(jt.getMultiple().isForceSingleJob(), equalTo(false));
}
@Test
public void testJobTypeModel_forceSingleJobAttributeIsFalse_forceSingleJobIsFalse() throws IOException,
InternalException {
File input = folder.newFile("test.xml");
try(PrintWriter writer = new PrintWriter(input)) {
writer.write("<jobType>\n" +
" <multiple forceSingleJob=\"false\">true</multiple>\n" +
"</jobType>");
};
XmlFileManager fileManager = new XmlFileManager();
JobType jt = fileManager.getJobType(input);
assertThat(jt.getMultiple().isForceSingleJob(), equalTo(false));
}
}
|
Birdasaur/LitFX | litfx-demos/src/main/java/lit/litfx/demos/controllers/AnimatedWavesDemoController.java | package lit.litfx.demos.controllers;
import java.net.URL;
import java.util.ArrayList;
import java.util.ResourceBundle;
import javafx.application.Platform;
import javafx.beans.property.SimpleLongProperty;
import javafx.concurrent.Task;
import javafx.fxml.FXML;
import javafx.fxml.Initializable;
import javafx.geometry.Point2D;
import javafx.scene.control.CheckBox;
import javafx.scene.control.Slider;
import javafx.scene.control.TabPane;
import javafx.scene.effect.BlurType;
import javafx.scene.effect.DropShadow;
import javafx.scene.effect.Effect;
import javafx.scene.effect.Glow;
import javafx.scene.input.MouseButton;
import javafx.scene.input.MouseEvent;
import javafx.scene.layout.Pane;
import javafx.scene.paint.Color;
import javafx.scene.paint.CycleMethod;
import javafx.scene.paint.RadialGradient;
import javafx.scene.paint.Stop;
import javafx.scene.shape.Circle;
import lit.litfx.core.components.BandEmitter;
import lit.litfx.core.components.CircleQuadBandCreator;
/**
* FXML Controller class
*
* @author Birdasaur
*/
public class AnimatedWavesDemoController implements Initializable {
@FXML
Pane centerPane;
@FXML
TabPane tabPane;
//Dynamics
@FXML
private Slider pointsSlider;
@FXML
private Slider pointDivergenceSlider;
@FXML
private Slider radiusSlider;
@FXML
private Slider velocitySlider;
@FXML
private Slider updateDelaySlider;
//Special effects controls
@FXML
CheckBox showPathLines;
@FXML
CheckBox showControlPoints;
@FXML
CheckBox enableGradientFill;
@FXML
Slider pathThicknessSlider;
@FXML
Slider glowSlider;
@FXML
Slider shadowSlider;
@FXML
Slider opacitySlider;
@FXML
Circle circle1;
@FXML
Circle circle2;
@FXML
SimpleLongProperty timeDelayProp = new SimpleLongProperty(500);
ArrayList<BandEmitter> bandEmitters = new ArrayList<>();
RadialGradient gradient1 = new RadialGradient(0, 0.1, 0.5, 0.5,
0.55, true, CycleMethod.NO_CYCLE,
new Stop(0, Color.BLUE.deriveColor(1, 1, 1, 0.1)),
new Stop(0.7, Color.YELLOW.deriveColor(1, 1, 1, 0.2)),
new Stop(0.8, Color.YELLOW.deriveColor(1, 1, 1, 0.8)),
new Stop(1, Color.RED.deriveColor(1, 1, 1, 0.8))
);
/**
* Initializes the controller class.
* @param url
* @param rb
*/
@Override
public void initialize(URL url, ResourceBundle rb) {
//Create the default band emitters
BandEmitter be1 = createBandEmitter(circle1.getLayoutX(), circle1.getLayoutY(),
Double.valueOf(pointsSlider.getValue()).intValue(),
radiusSlider.getValue(), pointDivergenceSlider.getValue(), velocitySlider.getValue());
bandEmitters.add(be1);
BandEmitter be2 = createBandEmitter(circle2.getLayoutX(), circle2.getLayoutY(),
Double.valueOf(pointsSlider.getValue()).intValue(),
radiusSlider.getValue(), pointDivergenceSlider.getValue(), velocitySlider.getValue());
bandEmitters.add(be2);
centerPane.getChildren().addAll(be1, be2);
centerPane.setOnMouseClicked((MouseEvent event) -> {
// if(event.getButton() == MouseButton.PRIMARY)
// start = new Point2D(event.getX(), event.getY());
// else if(event.getButton() == MouseButton.SECONDARY)
// end = new Point2D(event.getX(), event.getY());
});
timeDelayProp.bind(updateDelaySlider.valueProperty());
Task animationTask = new Task() {
@Override
protected Void call() throws Exception {
while(!this.isCancelled() && !this.isDone()) {
updateBands();
Thread.sleep(timeDelayProp.get());
}
return null;
}
};
Thread animationThread = new Thread(animationTask);
animationThread.setDaemon(true);
animationThread.start();
tabPane.setOnMouseEntered(event -> tabPane.requestFocus());
}
private BandEmitter createBandEmitter(double x, double y, int points,
double initialRadius, double divergence, double velocity) {
BandEmitter be = new BandEmitter(points, velocity, initialRadius, divergence);
be.setGeneratorCenterX(x);
be.setGeneratorCenterY(y);
return be;
}
public void updateBands() {
// Platform.runLater(()-> {
bandEmitters.stream().forEach(be -> {
//QuadBandCreator fields
be.setPolygonPoints(Double.valueOf(pointsSlider.getValue()).intValue());
be.setEdgeVariation(pointDivergenceSlider.getValue());
//CircleQuadBandCreator specific fields
CircleQuadBandCreator cqbc = (CircleQuadBandCreator) be.getQuadBandCreator();
cqbc.setInitialRadius(radiusSlider.getValue());
//Band specific factors
cqbc.setVelocity(velocitySlider.getValue());
be.setPathThickness(pathThicknessSlider.getValue());
be.setEffect(collectEffects());
be.setOpacity(opacitySlider.getValue());
be.setShowPoints(showControlPoints.isSelected());
if(showPathLines.isSelected())
be.setCustomStroke(BandEmitter.DEFAULT_STROKE);
else
be.setCustomStroke(Color.TRANSPARENT);
if(enableGradientFill.isSelected())
be.setCustomFill(gradient1);
else
be.setCustomFill(BandEmitter.DEFAULT_FILL);
be.createQuadBand();
});
// });
}
private Effect collectEffects() {
Glow glow = new Glow(glowSlider.getValue());
DropShadow shadow = new DropShadow(BlurType.GAUSSIAN, Color.AZURE, shadowSlider.getValue(), 0.5, 0, 0);
shadow.setInput(glow);
return shadow;
}
}
|
Daschi1/updated-java-sql-generator | src/main/java/org/sql/generation/implementation/grammar/query/OrderByClauseImpl.java | <filename>src/main/java/org/sql/generation/implementation/grammar/query/OrderByClauseImpl.java
/*
* Copyright (c) 2010, <NAME>. 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 org.sql.generation.implementation.grammar.query;
import org.sql.generation.api.common.NullArgumentException;
import org.sql.generation.api.grammar.query.OrderByClause;
import org.sql.generation.api.grammar.query.SortSpecification;
import org.sql.generation.implementation.grammar.common.SQLSyntaxElementBase;
import org.sql.generation.implementation.transformation.spi.SQLProcessorAggregator;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* @author <NAME>
*/
public class OrderByClauseImpl extends SQLSyntaxElementBase<OrderByClause, OrderByClause>
implements OrderByClause {
private final List<SortSpecification> _sortSpecs;
public OrderByClauseImpl(final SQLProcessorAggregator processor, final List<SortSpecification> sortSpecs) {
super(processor, OrderByClause.class);
NullArgumentException.validateNotNull("sort specifications", sortSpecs);
for (final SortSpecification sortSpec : sortSpecs) {
NullArgumentException.validateNotNull("sort specification", sortSpec);
}
this._sortSpecs = Collections.unmodifiableList(new ArrayList<>(sortSpecs));
}
@Override
public List<SortSpecification> getOrderingColumns() {
return this._sortSpecs;
}
@Override
protected boolean doesEqual(final OrderByClause another) {
return this._sortSpecs.equals(another.getOrderingColumns());
}
}
|
clayne/phasar | include/phasar/Utils/NlohmannLogging.h | <filename>include/phasar/Utils/NlohmannLogging.h
/******************************************************************************
* Copyright (c) 2022 <NAME>.
* All rights reserved. This program and the accompanying materials are made
* available under the terms of LICENSE.txt.
*
* Contributors:
* <NAME> and others
*****************************************************************************/
#ifndef PHASAR_UTILS_NLOHMANNLOGGING_H
#define PHASAR_UTILS_NLOHMANNLOGGING_H
#include "llvm/Support/FormatVariadic.h"
#include "llvm/Support/raw_ostream.h"
#include "nlohmann/json.hpp"
namespace llvm {
class raw_ostream;
}
namespace nlohmann::detail {
class llvm_output_stream_adapter : public output_adapter_protocol<char> {
public:
explicit llvm_output_stream_adapter(llvm::raw_ostream &OS) noexcept
: OS(OS) {}
void write_character(char c) override { OS.write(c); }
void write_characters(const char *Str, std::size_t Length) override {
OS.write(Str, static_cast<std::streamsize>(Length));
}
private:
llvm::raw_ostream &OS;
};
template <typename StringType = std::basic_string<char>>
class llvm_output_adapter {
public:
template <typename AllocatorType = std::allocator<char>>
llvm_output_adapter(llvm::raw_ostream &OS)
: OA(std::make_shared<llvm_output_stream_adapter>(OS)) {}
operator output_adapter_t<char>() { return OA; }
private:
output_adapter_t<char> OA = nullptr;
};
} // namespace nlohmann::detail
namespace psr {
llvm::raw_ostream &operator<<(llvm::raw_ostream &OS, const nlohmann::json &J);
};
#endif /* PHASAR_UTILS_NLOHMANNLOGGING_H */
|
jainsakshi2395/linux | include/linux/dsa/mv88e6xxx.h | <reponame>jainsakshi2395/linux<gh_stars>10-100
/* SPDX-License-Identifier: GPL-2.0
* Copyright 2021 NXP
*/
#ifndef _NET_DSA_TAG_MV88E6XXX_H
#define _NET_DSA_TAG_MV88E6XXX_H
#include <linux/if_vlan.h>
#define MV88E6XXX_VID_STANDALONE 0
#define MV88E6XXX_VID_BRIDGED (VLAN_N_VID - 1)
#endif
|
alphagov-mirror/verify-stub-idp | stub-idp/src/main/java/uk/gov/ida/stub/idp/resources/idp/ConsentResource.java | <filename>stub-idp/src/main/java/uk/gov/ida/stub/idp/resources/idp/ConsentResource.java
package uk.gov.ida.stub.idp.resources.idp;
import com.google.common.base.Strings;
import uk.gov.ida.common.SessionId;
import uk.gov.ida.saml.core.domain.AuthnContext;
import uk.gov.ida.stub.idp.Urls;
import uk.gov.ida.stub.idp.cookies.CookieNames;
import uk.gov.ida.stub.idp.domain.DatabaseIdpUser;
import uk.gov.ida.stub.idp.exceptions.GenericStubIdpException;
import uk.gov.ida.stub.idp.filters.SessionCookieValueMustExistAsASession;
import uk.gov.ida.stub.idp.repositories.Idp;
import uk.gov.ida.stub.idp.repositories.IdpSession;
import uk.gov.ida.stub.idp.repositories.IdpStubsRepository;
import uk.gov.ida.stub.idp.repositories.SessionRepository;
import uk.gov.ida.stub.idp.services.NonSuccessAuthnResponseService;
import uk.gov.ida.stub.idp.services.SuccessAuthnResponseService;
import uk.gov.ida.stub.idp.views.ConsentView;
import uk.gov.ida.stub.idp.views.SamlResponseRedirectViewFactory;
import javax.inject.Inject;
import javax.servlet.http.HttpServletRequest;
import javax.validation.constraints.NotNull;
import javax.ws.rs.CookieParam;
import javax.ws.rs.FormParam;
import javax.ws.rs.GET;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Produces;
import javax.ws.rs.core.Context;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
import java.util.List;
import java.util.Optional;
@Path(Urls.CONSENT_RESOURCE)
@Produces(MediaType.TEXT_HTML)
@SessionCookieValueMustExistAsASession
public class ConsentResource {
private final IdpStubsRepository idpStubsRepository;
private final SessionRepository<IdpSession> sessionRepository;
private final SuccessAuthnResponseService successAuthnResponseService;
private final NonSuccessAuthnResponseService nonSuccessAuthnResponseService;
private final SamlResponseRedirectViewFactory samlResponseRedirectViewFactory;
public static final String I_AGREE_SUBMIT_VALUE = "I Agree";
public static final String I_REFUSE_SUBMIT_VALUE = "I Refuse";
@Inject
public ConsentResource(
IdpStubsRepository idpStubsRepository,
SessionRepository<IdpSession> sessionRepository,
SuccessAuthnResponseService successAuthnResponseService,
NonSuccessAuthnResponseService nonSuccessAuthnResponseService,
SamlResponseRedirectViewFactory samlResponseRedirectViewFactory) {
this.successAuthnResponseService = successAuthnResponseService;
this.idpStubsRepository = idpStubsRepository;
this.sessionRepository = sessionRepository;
this.nonSuccessAuthnResponseService = nonSuccessAuthnResponseService;
this.samlResponseRedirectViewFactory = samlResponseRedirectViewFactory;
}
@GET
public Response get(
@PathParam(Urls.IDP_ID_PARAM) @NotNull String idpName,
@CookieParam(CookieNames.SESSION_COOKIE_NAME) @NotNull SessionId sessionCookie) {
IdpSession session = getAndValidateSession(idpName, sessionCookie);
DatabaseIdpUser idpUser = session.getIdpUser().get();
List<AuthnContext> requestLevelsOfAssurance = session.getIdaAuthnRequestFromHub().getLevelsOfAssurance();
AuthnContext userLevelOfAssurance = idpUser.getLevelOfAssurance();
boolean isUserLOATooLow = requestLevelsOfAssurance.stream().noneMatch(loa -> loa.equals(userLevelOfAssurance));
Idp idp = idpStubsRepository.getIdpWithFriendlyId(idpName);
return Response.ok(new ConsentView(idp.getDisplayName(), idp.getFriendlyId(), idp.getAssetId(), idpUser, isUserLOATooLow, userLevelOfAssurance, requestLevelsOfAssurance)).build();
}
private GenericStubIdpException errorResponse(String error) {
return new GenericStubIdpException(error, Response.Status.BAD_REQUEST);
}
@POST
public Response consent(
@Context HttpServletRequest httpServletRequest,
@PathParam(Urls.IDP_ID_PARAM) @NotNull String idpName,
@FormParam(Urls.SUBMIT_PARAM) @NotNull String submitButtonValue,
@FormParam(Urls.RANDOMISE_PID_PARAM) boolean randomisePid,
@CookieParam(CookieNames.SESSION_COOKIE_NAME) @NotNull SessionId sessionCookie) {
IdpSession session = getAndValidateSession(idpName, sessionCookie);
sessionRepository.deleteSession(sessionCookie);
switch (submitButtonValue) {
case I_AGREE_SUBMIT_VALUE:
return samlResponseRedirectViewFactory.sendSamlMessage(successAuthnResponseService.getSuccessResponse(randomisePid, httpServletRequest.getRemoteAddr(), idpName, session));
case I_REFUSE_SUBMIT_VALUE:
return samlResponseRedirectViewFactory.sendSamlMessage(nonSuccessAuthnResponseService.generateNoAuthnContext(idpName, session.getIdaAuthnRequestFromHub().getId(), session.getRelayState()));
default:
throw errorResponse("Invalid button value " + submitButtonValue);
}
}
private IdpSession getAndValidateSession(String idpName, SessionId sessionCookie) {
if (Strings.isNullOrEmpty(sessionCookie.toString())) {
throw errorResponse("Unable to locate session cookie for " + idpName);
}
Optional<IdpSession> session = sessionRepository.get(sessionCookie);
if (!session.isPresent() || !session.get().getIdpUser().isPresent() || session.get().getIdaAuthnRequestFromHub() == null) {
throw errorResponse("Session is invalid for " + idpName);
}
return session.get();
}
}
|
bkmgit/indico | indico/modules/events/editing/models/review_conditions.py | # This file is part of Indico.
# Copyright (C) 2002 - 2022 CERN
#
# Indico is free software; you can redistribute it and/or
# modify it under the terms of the MIT License; see the
# LICENSE file for more details.
from indico.core.db import db
from indico.core.db.sqlalchemy import PyIntEnum
from indico.modules.events.editing.models.editable import EditableType
from indico.util.string import format_repr
class EditingReviewCondition(db.Model):
__tablename__ = 'review_conditions'
__table_args__ = {'schema': 'event_editing'}
id = db.Column(
db.Integer,
primary_key=True
)
type = db.Column(
PyIntEnum(EditableType),
nullable=False
)
event_id = db.Column(
db.Integer,
db.ForeignKey('events.events.id'),
index=True,
nullable=False
)
event = db.relationship(
'Event',
lazy=True,
backref=db.backref(
'editing_review_conditions',
cascade='all, delete-orphan',
lazy=True
)
)
file_types = db.relationship(
'EditingFileType',
secondary='event_editing.review_condition_file_types',
collection_class=set,
lazy=False,
backref=db.backref(
'review_conditions',
collection_class=set,
lazy=True
)
)
# relationship backrefs:
# - file_types (EditingFileType.review_conditions)
def __repr__(self):
return format_repr(self, 'id', 'event_id')
db.Table(
'review_condition_file_types',
db.metadata,
db.Column(
'review_condition_id',
db.ForeignKey('event_editing.review_conditions.id'),
primary_key=True,
autoincrement=False,
index=True
),
db.Column(
'file_type_id',
db.ForeignKey('event_editing.file_types.id'),
primary_key=True,
autoincrement=False,
index=True
),
schema='event_editing'
)
|
sjnonweb/spoj | Solutions/STAMPS.cpp | #include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
int main()
{
int test,more,people,i,j=1,sum;
scanf("%d",&test);
while(test--)
{
scanf("%d",&more);
scanf("%d",&people);
int *arr=new int[people];
for(i=0;i<people;i++)
scanf("%d",&arr[i]);
sort(arr,arr+people);
sum=0;
for(i=people-1;i>=0;i--)
{
sum=sum+arr[i];
if(sum>=more)
{
printf("Scenario #%d:\n%d\n",j,people-i);
break;
}
}
if(i<0)
{
printf("Scenario #%d:\nimpossible\n",j);
}
j++;
printf("\n");
delete arr;
}
return 0;
}
|
hsamgle/wheel | framework/basic/src/main/java/com/hsamgle/basic/exception/ParamsMissException.java | <reponame>hsamgle/wheel<gh_stars>0
package com.hsamgle.basic.exception;
/**
*
* @类功能: TODO 参数缺失异常
* @文件名: ParamsMissException.java
* @所在包: com.com.dplus.project.exception
* @开发者: 黄先国
* @邮_件: <EMAIL>
* @时_间: 2016年12月2日下午2:08:43
* @公_司: 广州讯动网络科技有限公司
*/
public class ParamsMissException extends RuntimeException{
private static final long serialVersionUID = -4112393625948442457L;
private String msg = "必要参数丢失";
private String param;
public ParamsMissException(String param,String msg) {
this.param = param;
this.msg = msg;
}
public ParamsMissException(String param) {
this.param = param;
}
public String getParam() {
return param;
}
public void setParam(String param) {
this.param = param;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
@Override
public String toString() {
return "ParamsMissException [msg=" + msg + ", param=" + param + "]";
}
}
|
realXtend/tundra-urho3d | src/Plugins/UrhoRenderer/GraphicsWorld.cpp | <filename>src/Plugins/UrhoRenderer/GraphicsWorld.cpp<gh_stars>10-100
// For conditions of distribution and use, see copyright notice in LICENSE
#include "StableHeaders.h"
#include "GraphicsWorld.h"
#include "UrhoRenderer.h"
#include "Entity.h"
#include "Scene/Scene.h"
#include "ConfigAPI.h"
#include "FrameAPI.h"
#include "LoggingFunctions.h"
#include "Camera.h"
#include "Placeable.h"
#include "Framework.h"
#include "Math/Transform.h"
#include "Math/Color.h"
#include <Math/float2.h>
#include <Math/float3x4.h>
#include <Geometry/AABB.h>
#include <Geometry/OBB.h>
#include <Geometry/Plane.h>
#include <Geometry/LineSegment.h>
#include <Math/float3.h>
#include <Math/float4.h>
#include <Geometry/Circle.h>
#include <Geometry/Sphere.h>
#include <Urho3D/Core/Profiler.h>
#include <Urho3D/Scene/Scene.h>
#include <Urho3D/Graphics/Camera.h>
#include <Urho3D/Core/CoreEvents.h>
#include <Urho3D/Graphics/DebugRenderer.h>
#include <Urho3D/Graphics/Drawable.h>
#include <Urho3D/Graphics/Octree.h>
#include <Urho3D/Graphics/OctreeQuery.h>
#include <Urho3D/Graphics/Renderer.h>
#include <Urho3D/Graphics/View.h>
#include <Urho3D/Graphics/Viewport.h>
#include <Urho3D/Graphics/Zone.h>
namespace Tundra
{
StringHash GraphicsWorld::entityLink("ENTITY");
StringHash GraphicsWorld::componentLink("COMPONENT");
GraphicsWorld::GraphicsWorld(UrhoRenderer* owner, Scene* scene) :
Object(owner->GetContext()),
framework_(scene->GetFramework()),
renderer_(owner),
scene_(scene)
{
urhoScene_ = new Urho3D::Scene(context_);
urhoScene_->CreateComponent<Urho3D::Octree>();
urhoScene_->CreateComponent<Urho3D::DebugRenderer>();
// Set a default ambient color that matches the default ambient color of EnvironmentLight, in case there is no environmentlight component.
Urho3D::Zone* zone = urhoScene_->CreateComponent<Urho3D::Zone>();
// Just set up a large bounding zone for the whole scene
/// \todo The octree size is not adjusted yet, so objects outside the default octree range always end up in the root octqant
zone->SetBoundingBox(Urho3D::BoundingBox(-100000.0f, 100000.0f));
zone->SetAmbientColor(DefaultSceneAmbientLightColor());
SetDefaultSceneFog();
SubscribeToEvent(Urho3D::E_POSTRENDERUPDATE, URHO3D_HANDLER(GraphicsWorld, HandlePostRenderUpdate));
}
GraphicsWorld::~GraphicsWorld()
{
urhoScene_.Reset();
}
void GraphicsWorld::HandlePostRenderUpdate(StringHash /*eventType*/, VariantMap& /*eventData*/)
{
URHO3D_PROFILE(GraphicsWorld_PostRenderUpdate);
visibleEntities_.Clear();
Urho3D::Renderer* renderer = GetSubsystem<Urho3D::Renderer>();
Camera* cameraComp = renderer_->MainCameraComponent();
if (IsActive() && renderer)
{
Urho3D::Camera* cam = cameraComp ? cameraComp->UrhoCamera() : nullptr;
Urho3D::Viewport* vp = renderer->GetViewport(0);
Urho3D::View* view = vp ? vp->GetView() : nullptr;
if (view)
{
const Urho3D::PODVector<Urho3D::Drawable*>& geometries = view->GetGeometries();
for (uint i = 0; i < geometries.Size(); ++i)
{
// Verify that the geometry is in main camera view, as also eg. shadow geometries get listed
Urho3D::Drawable* dr = geometries[i];
if (!dr || !dr->IsInView(cam))
continue;
EntityWeakPtr ent(static_cast<Entity*>(dr->GetNode()->GetVar(entityLink).GetPtr()));
if (!ent)
continue;
visibleEntities_.Insert(ent);
}
}
}
// Perform visibility change tracking
for (HashMap<EntityWeakPtr, bool>::Iterator i = visibilityTrackedEntities_.Begin(); i != visibilityTrackedEntities_.End();)
{
// Check whether entity has expired
if (!i->first_)
i = visibilityTrackedEntities_.Erase(i);
else
{
bool current = visibleEntities_.Contains(i->first_);
bool prev = i->second_;
if (current != prev)
{
i->second_ = current;
if (current)
{
i->first_->EmitEnterView(cameraComp);
EntityEnterView.Emit(i->first_.Get());
}
else
{
i->first_->EmitLeaveView(cameraComp);
EntityLeaveView.Emit(i->first_.Get());
}
}
++i;
}
}
}
Color GraphicsWorld::DefaultSceneAmbientLightColor()
{
return Color(0.364f, 0.364f, 0.364f, 1.f);
}
void GraphicsWorld::SetDefaultSceneFog()
{
Urho3D::Zone* zone = UrhoZone();
if (!zone)
return;
zone->SetFogStart(2000.0f);
zone->SetFogEnd(4000.0f);
zone->SetFogColor(Urho3D::Color::BLACK);
}
RayQueryResult GraphicsWorld::Raycast(int x, int y)
{
return Raycast(x, y, 0xffffffff, FLOAT_INF);
}
RayQueryResult GraphicsWorld::Raycast(int x, int y, float maxDistance)
{
return Raycast(x, y, 0xffffffff, maxDistance);
}
RayQueryResult GraphicsWorld::Raycast(int x, int y, unsigned layerMask)
{
return Raycast(x, y, layerMask, FLOAT_INF);
}
RayQueryResult GraphicsWorld::Raycast(const Ray& ray, unsigned layerMask)
{
return Raycast(ray, layerMask, FLOAT_INF);
}
RayQueryResult GraphicsWorld::Raycast(int x, int y, unsigned layerMask, float maxDistance)
{
Ray ray;
Camera* camera = renderer_->MainCameraComponent();
if (camera)
ray = camera->ScreenPointToRay(x, y);
RaycastInternal(ray, layerMask, maxDistance, false);
// Return the closest hit, or a cleared raycastresult if no hits
return rayHits_.Size() ? rayHits_[0] : RayQueryResult();
}
RayQueryResult GraphicsWorld::Raycast(const Ray& ray, unsigned layerMask, float maxDistance)
{
RaycastInternal(ray, layerMask, maxDistance, false);
// Return the closest hit, or a cleared raycastresult if no hits
return rayHits_.Size() ? rayHits_[0] : RayQueryResult();
}
Vector<RayQueryResult> GraphicsWorld::RaycastAll(int x, int y)
{
return RaycastAll(x, y, 0xffffffff, FLOAT_INF);
}
Vector<RayQueryResult> GraphicsWorld::RaycastAll(int x, int y, float maxDistance)
{
return RaycastAll(x, y, 0xffffffff, maxDistance);
}
Vector<RayQueryResult> GraphicsWorld::RaycastAll(int x, int y, unsigned layerMask)
{
return RaycastAll(x, y, layerMask, FLOAT_INF);
}
Vector<RayQueryResult> GraphicsWorld::RaycastAll(const Ray& ray, unsigned layerMask)
{
return RaycastAll(ray, layerMask, FLOAT_INF);
}
Vector<RayQueryResult> GraphicsWorld::RaycastAll(int x, int y, unsigned layerMask, float maxDistance)
{
Ray ray;
Camera* camera = renderer_->MainCameraComponent();
if (camera)
ray = camera->ScreenPointToRay(x, y);
RaycastInternal(ray, layerMask, maxDistance, true);
return rayHits_;
}
Vector<RayQueryResult> GraphicsWorld::RaycastAll(const Ray& ray, unsigned layerMask, float maxDistance)
{
RaycastInternal(ray, layerMask, maxDistance, true);
return rayHits_;
}
void GraphicsWorld::RaycastInternal(const Ray& ray, unsigned layerMask, float maxDistance, bool getAllResults)
{
URHO3D_PROFILE(GraphicsWorld_Raycast);
rayHits_.Clear();
Urho3D::PODVector<Urho3D::RayQueryResult> result;
Urho3D::Octree* octree = urhoScene_->GetComponent<Urho3D::Octree>();
Urho3D::RayOctreeQuery query(result, ray, Urho3D::RAY_TRIANGLE, maxDistance, Urho3D::DRAWABLE_GEOMETRY);
octree->Raycast(query);
for (Urho3D::PODVector<Urho3D::RayQueryResult>::ConstIterator i = result.Begin(); i != result.End(); ++i)
{
if (!i->node_)
continue;
Entity* entity = static_cast<Entity*>(i->node_->GetVar(entityLink).GetPtr());
if (!entity)
continue; // Not a drawable associated with Tundra entity
Placeable* placeable = entity->Component<Placeable>();
if (placeable && (placeable->selectionLayer.Get() & layerMask) == 0)
continue;
IComponent* component = static_cast<IComponent*>(i->node_->GetVar(componentLink).GetPtr());
RayQueryResult res;
res.component = component;
res.entity = entity;
res.pos = i->position_;
res.normal = i->normal_;
/// \todo Fill the rest, like submesh information
rayHits_.Push(res);
if (!getAllResults)
break;
}
}
EntityVector GraphicsWorld::FrustumQuery(const Urho3D::IntRect &viewrect) const
{
URHO3D_PROFILE(GraphicsWorld_FrustumQuery);
EntityVector ret;
Camera* cameraComp = renderer_->MainCameraComponent();
if (!cameraComp || cameraComp->ParentScene() != scene_)
return ret;
Urho3D::Camera* cam = cameraComp->UrhoCamera();
if (!cam)
return ret;
int width = renderer_->WindowWidth();
int height = renderer_->WindowHeight();
float w = (float)width;
float h = (float)height;
float left = (float)(viewrect.left_) / w, right = (float)(viewrect.right_) / w;
float top = (float)(viewrect.top_) / h, bottom = (float)(viewrect.bottom_) / h;
if (left > right) std::swap(left, right);
if (top > bottom) std::swap(top, bottom);
// don't do selection if box is too small
if ((right - left) * (bottom - top) < 0.0001)
return ret;
Urho3D::Frustum fr;
fr.vertices_[0] = cam->ScreenToWorldPoint(Urho3D::Vector3(right, top, cam->GetNearClip()));
fr.vertices_[1] = cam->ScreenToWorldPoint(Urho3D::Vector3(right, bottom, cam->GetNearClip()));
fr.vertices_[2] = cam->ScreenToWorldPoint(Urho3D::Vector3(left, bottom, cam->GetNearClip()));
fr.vertices_[3] = cam->ScreenToWorldPoint(Urho3D::Vector3(left, top, cam->GetNearClip()));
fr.vertices_[4] = cam->ScreenToWorldPoint(Urho3D::Vector3(right, top, cam->GetFarClip()));
fr.vertices_[5] = cam->ScreenToWorldPoint(Urho3D::Vector3(right, bottom, cam->GetFarClip()));
fr.vertices_[6] = cam->ScreenToWorldPoint(Urho3D::Vector3(left, bottom, cam->GetFarClip()));
fr.vertices_[7] = cam->ScreenToWorldPoint(Urho3D::Vector3(left, top, cam->GetFarClip()));
fr.UpdatePlanes();
Urho3D::PODVector<Urho3D::Drawable*> result;
Urho3D::FrustumOctreeQuery query(result, fr, Urho3D::DRAWABLE_GEOMETRY);
urhoScene_->GetComponent<Urho3D::Octree>()->GetDrawables(query);
for (Urho3D::PODVector<Urho3D::Drawable*>::ConstIterator i = result.Begin(); i != result.End(); ++i)
{
Entity* entity = static_cast<Entity*>((*i)->GetNode()->GetVar(entityLink).GetPtr());
if (entity)
ret.Push(EntityPtr(entity));
}
return ret;
}
bool GraphicsWorld::IsEntityVisible(Entity* entity) const
{
return entity ? visibleEntities_.Contains(EntityWeakPtr(entity)) : false;
}
EntityVector GraphicsWorld::VisibleEntities() const
{
EntityVector ret;
for (HashSet<EntityWeakPtr>::ConstIterator i = visibleEntities_.Begin(); i != visibleEntities_.End(); ++i)
{
if (*i)
ret.Push(i->Lock());
}
return ret;
}
bool GraphicsWorld::IsActive() const
{
Entity* mainCamera = renderer_->MainCamera();
return mainCamera && mainCamera->ParentScene() == scene_;
}
Urho3D::Zone* GraphicsWorld::UrhoZone() const
{
return urhoScene_->GetComponent<Urho3D::Zone>();
}
void GraphicsWorld::DebugDrawAABB(const AABB &aabb, const Color &clr, bool depthTest)
{
for(int i = 0; i < 12; ++i)
DebugDrawLineSegment(aabb.Edge(i), clr, depthTest);
}
void GraphicsWorld::DebugDrawOBB(const OBB &obb, const Color &clr, bool depthTest)
{
for(int i = 0; i < 12; ++i)
DebugDrawLineSegment(obb.Edge(i), clr, depthTest);
}
void GraphicsWorld::DebugDrawLineSegment(const LineSegment &l, const Color &clr, bool depthTest)
{
Urho3D::DebugRenderer* debug = urhoScene_->GetComponent<Urho3D::DebugRenderer>();
if (debug)
debug->AddLine(l.a, l.b, clr, depthTest);
}
void GraphicsWorld::DebugDrawLine(const float3& start, const float3& end, const Color &clr, bool depthTest)
{
Urho3D::DebugRenderer* debug = urhoScene_->GetComponent<Urho3D::DebugRenderer>();
if (debug)
debug->AddLine(start, end, clr, depthTest);
}
void GraphicsWorld::DebugDrawPlane(const Plane &plane, const Color &clr, const float3 &refPoint, float uSpacing, float vSpacing,
int uSegments, int vSegments, bool depthTest)
{
float U0 = -uSegments * uSpacing / 2.f;
float V0 = -vSegments * vSpacing / 2.f;
float U1 = uSegments * uSpacing / 2.f;
float V1 = vSegments * vSpacing / 2.f;
for(int y = 0; y < vSegments; ++y)
for(int x = 0; x < uSegments; ++x)
{
float u = U0 + x * uSpacing;
float v = V0 + y * vSpacing;
DebugDrawLine(plane.Point(U0, v, refPoint), plane.Point(U1, v, refPoint), clr, depthTest);
DebugDrawLine(plane.Point(u, V0, refPoint), plane.Point(u, V1, refPoint), clr, depthTest);
}
}
void GraphicsWorld::DebugDrawTransform(const Transform &t, float axisLength, float boxSize, const Color &clr, bool depthTest)
{
DebugDrawFloat3x4(t.ToFloat3x4(), axisLength, boxSize, clr, depthTest);
}
void GraphicsWorld::DebugDrawFloat3x4(const float3x4 &t, float axisLength, float boxSize, const Color &clr, bool depthTest)
{
AABB aabb(float3::FromScalar(-boxSize/2.f), float3::FromScalar(boxSize/2.f));
OBB obb = aabb.Transform(t);
DebugDrawOBB(obb, clr);
DebugDrawLineSegment(LineSegment(t.TranslatePart(), t.TranslatePart() + axisLength * t.Col(0)), 1, 0, 0, depthTest);
DebugDrawLineSegment(LineSegment(t.TranslatePart(), t.TranslatePart() + axisLength * t.Col(1)), 0, 1, 0, depthTest);
DebugDrawLineSegment(LineSegment(t.TranslatePart(), t.TranslatePart() + axisLength * t.Col(2)), 0, 0, 1, depthTest);
}
void GraphicsWorld::DebugDrawCircle(const Circle &c, int numSubdivisions, const Color &clr, bool depthTest)
{
float3 p = c.GetPoint(0);
for(int i = 1; i <= numSubdivisions; ++i)
{
float3 p2 = c.GetPoint(i * 2.f * 3.14f / numSubdivisions);
DebugDrawLineSegment(LineSegment(p, p2), clr, depthTest);
p = p2;
}
}
void GraphicsWorld::DebugDrawAxes(const float3x4 &t, bool depthTest)
{
float3 translate, scale;
Quat rotate;
t.Decompose(translate, rotate, scale);
DebugDrawLine(translate, translate + rotate * float3(scale.x, 0.f, 0.f), 1, 0, 0, depthTest);
DebugDrawLine(translate, translate + rotate * float3(0., scale.y, 0.f), 0, 1, 0, depthTest);
DebugDrawLine(translate, translate + rotate * float3(0.f, 0.f, scale.z), 0, 0, 1, depthTest);
}
void GraphicsWorld::DebugDrawSphere(const float3& center, float radius, int vertices, const Color &clr, bool depthTest)
{
if (vertices <= 0)
return;
Vector<float3> positions(vertices);
Sphere sphere(center, radius);
int actualVertices = sphere.Triangulate(&positions[0], 0, 0, vertices, true);
for (int i = 0; i < actualVertices; i += 3)
{
DebugDrawLine(positions[i], positions[i + 1], clr, depthTest);
DebugDrawLine(positions[i + 1], positions[i + 2], clr, depthTest);
DebugDrawLine(positions[i + 2], positions[i], clr, depthTest);
}
}
void GraphicsWorld::DebugDrawLight(const float3x4 &t, int lightType, float range, float spotAngle, const Color &clr, bool depthTest)
{
float3 translate, scale;
Quat rotate;
t.Decompose(translate, rotate, scale);
float3 lightDirection = rotate * float3(0.0f, 0.0f, 1.0f);
switch (lightType)
{
// Point
case 0:
DebugDrawCircle(Circle(translate, float3(1.f, 0.f, 0.f), range), 8, clr, depthTest);
DebugDrawCircle(Circle(translate, float3(0.f, 1.f, 0.f), range), 8, clr, depthTest);
DebugDrawCircle(Circle(translate, float3(0.f, 0.f, 1.f), range), 8, clr, depthTest);
break;
// Spot
case 1:
{
float3 endPoint = translate + range * lightDirection;
float coneRadius = range * sinf(DegToRad(spotAngle));
Circle spotCircle(endPoint, -lightDirection, coneRadius);
DebugDrawCircle(Circle(endPoint, -lightDirection, coneRadius), 8, clr, depthTest);
for (int i = 1; i <= 8; ++i)
DebugDrawLine(translate, spotCircle.GetPoint(i * 2.f * 3.14f / 8), clr, depthTest);
}
break;
// Directional
case 2:
{
const float cDirLightRange = 10.f;
float3 endPoint = translate + cDirLightRange * lightDirection;
float3 offset = rotate * float3(1.f, 0.f, 0.f);
DebugDrawLine(translate, endPoint, clr, depthTest);
DebugDrawLine(translate + offset, endPoint + offset, clr, depthTest);
DebugDrawLine(translate - offset, endPoint - offset, clr, depthTest);
}
break;
}
}
void GraphicsWorld::DebugDrawCamera(const float3x4 &t, float size, const Color &clr, bool depthTest)
{
AABB aabb(float3(-size/2.f, -size/2.f, -size), float3(size/2.f, size/2.f, size));
OBB obb = aabb.Transform(t);
DebugDrawOBB(obb, clr, depthTest);
float3 translate(0, 0, -size * 1.25f);
AABB aabb2(translate + float3::FromScalar(-size/4.f), translate + float3::FromScalar(size/4.f));
OBB obb2 = aabb2.Transform(t);
DebugDrawOBB(obb2, clr, depthTest);
}
void GraphicsWorld::DebugDrawSoundSource(const float3 &soundPos, float soundInnerRadius, float soundOuterRadius, const Color & /*clr*/, bool depthTest)
{
// Draw three concentric diamonds as a visual cue
for (int i = 2; i < 5; ++i)
DebugDrawSphere(soundPos, i/3.f, 24, i==2?1.0f:0.0f, i==3?1.0f:0.0f, i==4?1.0f:0.0f, depthTest);
DebugDrawSphere(soundPos, soundInnerRadius, 384, 1, 0, 0, depthTest);
DebugDrawSphere(soundPos, soundOuterRadius, 384, 0, 1, 0, depthTest);
}
void GraphicsWorld::StartViewTracking(Entity* entity)
{
if (entity && entity->ParentScene() == scene_.Get())
visibilityTrackedEntities_[EntityWeakPtr(entity)] = IsEntityVisible(entity);
}
/// Stop tracking an entity's visibility
void GraphicsWorld::StopViewTracking(Entity* entity)
{
visibilityTrackedEntities_.Erase(EntityWeakPtr(entity));
}
}
|
iamhuwjones/hermes | corvus-main/src/main/java/hk/hku/cecid/piazza/corvus/core/main/handler/RemoteCommandRegistrar.java | package hk.hku.cecid.piazza.corvus.core.main.handler;
import java.util.Properties;
import hk.hku.cecid.piazza.commons.ejb.util.RemoteCommandHandler;
import hk.hku.cecid.piazza.commons.spa.Extension;
import hk.hku.cecid.piazza.commons.spa.ExtensionPointIteratedHandler;
import hk.hku.cecid.piazza.commons.spa.PluginException;
/**
* RemoteCommandRegistrar handles the registration of any remote command
* with the central remote command handler.
*
* @author <NAME>
*
*/
public class RemoteCommandRegistrar extends ExtensionPointIteratedHandler {
/**
* Adds a remote command to the central remote command handler.
*
* @param extension the extension which represents the remote command.
* @throws PluginException if unable to add the remote command.
* @see hk.hku.cecid.piazza.commons.spa.ExtensionPointHandler#processExtensions(java.util.Collection)
*/
public void processExtension(Extension extension) throws PluginException {
String commandName = extension.getParameter("command");
String className = extension.getParameter("class");
try {
Properties command = new Properties();
command.putAll(extension.getParameters());
if (className != null) {
Class theClass = extension.getPlugin().loadClass(className);
command.put("class", theClass);
}
RemoteCommandHandler.register(commandName, command);
}
catch (Exception e) {
throw new PluginException("Unable to register the remote command: "+commandName, e);
}
}
}
|
J-Swift/caseflow | app/models/decision_drafting_attorney.rb | # frozen_string_literal: true
class DecisionDraftingAttorney < JudgeTeamRole; end
|
desweemerl/erp-lib-server | src/main/java/com/erp/lib/server/servlet/filter/SecurityFilter.java | <filename>src/main/java/com/erp/lib/server/servlet/filter/SecurityFilter.java
package com.erp.lib.server.servlet.filter;
import com.google.inject.Inject;
import com.google.inject.Singleton;
import org.apache.shiro.web.mgt.WebSecurityManager;
import org.apache.shiro.web.servlet.AbstractShiroFilter;
@Singleton
public class SecurityFilter extends AbstractShiroFilter {
@Inject
public SecurityFilter(WebSecurityManager securityManager) {
setSecurityManager(securityManager);
}
}
|
alefherrera/worms | src/main/java/worms/model/ControllerListener.java | package worms.model;
import worms.engine.actions.controller.ControllerAction;
public interface ControllerListener {
void onControllerAction(ControllerAction action);
}
|
temcocontrols/ModbusToBacnetModule | Bluetooth/external/bacnet-stack/ports/linux/dlmstp_linux.c | <reponame>temcocontrols/ModbusToBacnetModule
/**************************************************************************
*
* Copyright (C) 2008 <NAME> <<EMAIL>>
*
* Permission is hereby granted, free of charge, to any person obtaining
* a copy of this software and associated documentation files (the
* "Software"), to deal in the Software without restriction, including
* without limitation the rights to use, copy, modify, merge, publish,
* distribute, sublicense, and/or sell copies of the Software, and to
* permit persons to whom the Software is furnished to do so, subject to
* the following conditions:
*
* The above copyright notice and this permission notice shall be included
* in all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
*********************************************************************/
#include <stdbool.h>
#include <stdint.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <time.h>
#include "bacdef.h"
#include "bacaddr.h"
#include "mstp.h"
/*#include "dlmstp.h" */
#include "dlmstp_linux.h"
#include "rs485.h"
#include "npdu.h"
#include "bits.h"
/* OS Specific include */
#include "net.h"
#include "ringbuf.h"
/** @file linux/dlmstp.c Provides Linux-specific DataLink functions for MS/TP. */
#define BACNET_PDU_CONTROL_BYTE_OFFSET 1
#define BACNET_DATA_EXPECTING_REPLY_BIT 2
#define BACNET_DATA_EXPECTING_REPLY(control) ( (control & (1 << BACNET_DATA_EXPECTING_REPLY_BIT) ) > 0 )
#define INCREMENT_AND_LIMIT_UINT16(x) {if (x < 0xFFFF) x++;}
uint32_t Timer_Silence(
void *poPort)
{
struct timeval now, tmp_diff;
SHARED_MSTP_DATA *poSharedData;
struct mstp_port_struct_t *mstp_port =
(struct mstp_port_struct_t *) poPort;
if (!mstp_port) {
return -1;
}
poSharedData = (SHARED_MSTP_DATA *) mstp_port->UserData;
if (!poSharedData) {
return -1;
}
int32_t res;
gettimeofday(&now, NULL);
timersub(&poSharedData->start, &now, &tmp_diff);
res = ((tmp_diff.tv_sec) * 1000 + (tmp_diff.tv_usec) / 1000);
return (res >= 0 ? res : -res);
}
void Timer_Silence_Reset(
void *poPort)
{
SHARED_MSTP_DATA *poSharedData;
struct mstp_port_struct_t *mstp_port =
(struct mstp_port_struct_t *) poPort;
if (!mstp_port) {
return;
}
poSharedData = (SHARED_MSTP_DATA *) mstp_port->UserData;
if (!poSharedData) {
return;
}
gettimeofday(&poSharedData->start, NULL);
}
void get_abstime(
struct timespec *abstime,
unsigned long milliseconds)
{
struct timeval now, offset, result;
gettimeofday(&now, NULL);
offset.tv_sec = 0;
offset.tv_usec = milliseconds * 1000;
timeradd(&now, &offset, &result);
abstime->tv_sec = result.tv_sec;
abstime->tv_nsec = result.tv_usec * 1000;
}
void dlmstp_cleanup(
void *poPort)
{
SHARED_MSTP_DATA *poSharedData;
struct mstp_port_struct_t *mstp_port =
(struct mstp_port_struct_t *) poPort;
if (!mstp_port) {
return;
}
poSharedData = (SHARED_MSTP_DATA *) mstp_port->UserData;
if (!poSharedData) {
return;
}
/* restore the old port settings */
tcsetattr(poSharedData->RS485_Handle, TCSANOW,
&poSharedData->RS485_oldtio);
close(poSharedData->RS485_Handle);
pthread_cond_destroy(&poSharedData->Received_Frame_Flag);
pthread_cond_destroy(&poSharedData->Receive_Packet_Flag);
pthread_cond_destroy(&poSharedData->Master_Done_Flag);
pthread_mutex_destroy(&poSharedData->Received_Frame_Mutex);
pthread_mutex_destroy(&poSharedData->Receive_Packet_Mutex);
pthread_mutex_destroy(&poSharedData->Master_Done_Mutex);
}
/* returns number of bytes sent on success, zero on failure */
int dlmstp_send_pdu(
void *poPort,
BACNET_ADDRESS * dest, /* destination address */
uint8_t * pdu, /* any data to be sent - may be null */
unsigned pdu_len)
{ /* number of bytes of data */
int bytes_sent = 0;
struct mstp_pdu_packet *pkt;
unsigned i = 0;
SHARED_MSTP_DATA *poSharedData;
struct mstp_port_struct_t *mstp_port =
(struct mstp_port_struct_t *) poPort;
if (!mstp_port) {
return 0;
}
poSharedData = (SHARED_MSTP_DATA *) mstp_port->UserData;
if (!poSharedData) {
return 0;
}
pkt = (struct mstp_pdu_packet *) Ringbuf_Data_Peek(&poSharedData->PDU_Queue);
if (pkt) {
pkt->data_expecting_reply =
BACNET_DATA_EXPECTING_REPLY(pdu[BACNET_PDU_CONTROL_BYTE_OFFSET]);
for (i = 0; i < pdu_len; i++) {
pkt->buffer[i] = pdu[i];
}
pkt->length = pdu_len;
pkt->destination_mac = dest->mac[0];
if (Ringbuf_Data_Put(&poSharedData->PDU_Queue, (uint8_t *)pkt)) {
bytes_sent = pdu_len;
}
}
return bytes_sent;
}
uint16_t dlmstp_receive(
void *poPort,
BACNET_ADDRESS * src, /* source address */
uint8_t * pdu, /* PDU data */
uint16_t max_pdu, /* amount of space available in the PDU */
unsigned timeout)
{ /* milliseconds to wait for a packet */
uint16_t pdu_len = 0;
struct timespec abstime;
int rv = 0;
SHARED_MSTP_DATA *poSharedData;
struct mstp_port_struct_t *mstp_port =
(struct mstp_port_struct_t *) poPort;
if (!mstp_port) {
return 0;
}
poSharedData = (SHARED_MSTP_DATA *) mstp_port->UserData;
if (!poSharedData) {
return 0;
}
(void) max_pdu;
/* see if there is a packet available, and a place
to put the reply (if necessary) and process it */
get_abstime(&abstime, timeout);
rv = pthread_cond_timedwait(&poSharedData->Receive_Packet_Flag,
&poSharedData->Receive_Packet_Mutex, &abstime);
if (rv == 0) {
if (poSharedData->Receive_Packet.ready) {
if (poSharedData->Receive_Packet.pdu_len) {
poSharedData->MSTP_Packets++;
if (src) {
memmove(src, &poSharedData->Receive_Packet.address,
sizeof(poSharedData->Receive_Packet.address));
}
if (pdu) {
memmove(pdu, &poSharedData->Receive_Packet.pdu,
sizeof(poSharedData->Receive_Packet.pdu));
}
pdu_len = poSharedData->Receive_Packet.pdu_len;
}
poSharedData->Receive_Packet.ready = false;
}
}
return pdu_len;
}
void *dlmstp_receive_fsm_task(
void *pArg)
{
bool received_frame;
SHARED_MSTP_DATA *poSharedData;
struct mstp_port_struct_t *mstp_port = (struct mstp_port_struct_t *) pArg;
if (!mstp_port) {
return NULL;
}
poSharedData =
(SHARED_MSTP_DATA *) ((struct mstp_port_struct_t *) pArg)->UserData;
if (!poSharedData) {
return NULL;
}
for (;;) {
/* only do receive state machine while we don't have a frame */
if ((mstp_port->ReceivedValidFrame == false) &&
(mstp_port->ReceivedInvalidFrame == false)) {
do {
RS485_Check_UART_Data(mstp_port);
MSTP_Receive_Frame_FSM((volatile struct mstp_port_struct_t *)
pArg);
received_frame = mstp_port->ReceivedValidFrame ||
mstp_port->ReceivedInvalidFrame;
if (received_frame) {
pthread_cond_signal(&poSharedData->Received_Frame_Flag);
break;
}
} while (mstp_port->DataAvailable);
}
}
return NULL;
}
void *dlmstp_master_fsm_task(
void *pArg)
{
uint32_t silence = 0;
bool run_master = false;
SHARED_MSTP_DATA *poSharedData;
struct mstp_port_struct_t *mstp_port = (struct mstp_port_struct_t *) pArg;
if (!mstp_port) {
return NULL;
}
poSharedData =
(SHARED_MSTP_DATA *) ((struct mstp_port_struct_t *) pArg)->UserData;
if (!poSharedData) {
return NULL;
}
for (;;) {
if (mstp_port->ReceivedValidFrame == false &&
mstp_port->ReceivedInvalidFrame == false) {
RS485_Check_UART_Data(mstp_port);
MSTP_Receive_Frame_FSM(mstp_port);
}
if (mstp_port->ReceivedValidFrame || mstp_port->ReceivedInvalidFrame) {
run_master = true;
} else {
silence = mstp_port->SilenceTimer(NULL);
switch (mstp_port->master_state) {
case MSTP_MASTER_STATE_IDLE:
if (silence >= Tno_token)
run_master = true;
break;
case MSTP_MASTER_STATE_WAIT_FOR_REPLY:
if (silence >= poSharedData->Treply_timeout)
run_master = true;
break;
case MSTP_MASTER_STATE_POLL_FOR_MASTER:
if (silence >= poSharedData->Tusage_timeout)
run_master = true;
break;
default:
run_master = true;
break;
}
}
if (run_master) {
if (mstp_port->This_Station <= DEFAULT_MAX_MASTER) {
while (MSTP_Master_Node_FSM(mstp_port)) {
/* do nothing while immediate transitioning */
}
} else if (mstp_port->This_Station < 255) {
MSTP_Slave_Node_FSM(mstp_port);
}
}
}
return NULL;
}
void dlmstp_fill_bacnet_address(
BACNET_ADDRESS * src,
uint8_t mstp_address)
{
int i = 0;
if (mstp_address == MSTP_BROADCAST_ADDRESS) {
/* mac_len = 0 if broadcast address */
src->mac_len = 0;
src->mac[0] = 0;
} else {
src->mac_len = 1;
src->mac[0] = mstp_address;
}
/* fill with 0's starting with index 1; index 0 filled above */
for (i = 1; i < MAX_MAC_LEN; i++) {
src->mac[i] = 0;
}
src->net = 0;
src->len = 0;
for (i = 0; i < MAX_MAC_LEN; i++) {
src->adr[i] = 0;
}
}
/* for the MS/TP state machine to use for putting received data */
uint16_t MSTP_Put_Receive(
volatile struct mstp_port_struct_t *mstp_port)
{
uint16_t pdu_len = 0;
SHARED_MSTP_DATA *poSharedData = (SHARED_MSTP_DATA *) mstp_port->UserData;
if (!poSharedData) {
return 0;
}
if (!poSharedData->Receive_Packet.ready) {
/* bounds check - maybe this should send an abort? */
pdu_len = mstp_port->DataLength;
if (pdu_len > sizeof(poSharedData->Receive_Packet.pdu))
pdu_len = sizeof(poSharedData->Receive_Packet.pdu);
memmove((void *) &poSharedData->Receive_Packet.pdu[0],
(void *) &mstp_port->InputBuffer[0], pdu_len);
dlmstp_fill_bacnet_address(&poSharedData->Receive_Packet.address,
mstp_port->SourceAddress);
poSharedData->Receive_Packet.pdu_len = mstp_port->DataLength;
poSharedData->Receive_Packet.ready = true;
pthread_cond_signal(&poSharedData->Receive_Packet_Flag);
}
return pdu_len;
}
/* for the MS/TP state machine to use for getting data to send */
/* Return: amount of PDU data */
uint16_t MSTP_Get_Send(
volatile struct mstp_port_struct_t * mstp_port,
unsigned timeout)
{ /* milliseconds to wait for a packet */
uint16_t pdu_len = 0;
uint8_t frame_type = 0;
struct mstp_pdu_packet *pkt;
SHARED_MSTP_DATA *poSharedData = (SHARED_MSTP_DATA *) mstp_port->UserData;
if (!poSharedData) {
return 0;
}
(void) timeout;
if (Ringbuf_Empty(&poSharedData->PDU_Queue)) {
return 0;
}
pkt = (struct mstp_pdu_packet *) Ringbuf_Peek(&poSharedData->PDU_Queue);
if (pkt->data_expecting_reply) {
frame_type = FRAME_TYPE_BACNET_DATA_EXPECTING_REPLY;
} else {
frame_type = FRAME_TYPE_BACNET_DATA_NOT_EXPECTING_REPLY;
}
/* convert the PDU into the MSTP Frame */
pdu_len = MSTP_Create_Frame(&mstp_port->OutputBuffer[0], /* <-- loading this */
mstp_port->OutputBufferSize, frame_type, pkt->destination_mac,
mstp_port->This_Station, (uint8_t *) & pkt->buffer[0], pkt->length);
(void) Ringbuf_Pop(&poSharedData->PDU_Queue, NULL);
return pdu_len;
}
bool dlmstp_compare_data_expecting_reply(
uint8_t * request_pdu,
uint16_t request_pdu_len,
uint8_t src_address,
uint8_t * reply_pdu,
uint16_t reply_pdu_len,
uint8_t dest_address)
{
uint16_t offset;
/* One way to check the message is to compare NPDU
src, dest, along with the APDU type, invoke id.
Seems a bit overkill */
struct DER_compare_t {
BACNET_NPDU_DATA npdu_data;
BACNET_ADDRESS address;
uint8_t pdu_type;
uint8_t invoke_id;
uint8_t service_choice;
};
struct DER_compare_t request;
struct DER_compare_t reply;
/* unused parameters */
request_pdu_len = request_pdu_len;
reply_pdu_len = reply_pdu_len;
/* decode the request data */
request.address.mac[0] = src_address;
request.address.mac_len = 1;
offset =
npdu_decode(&request_pdu[0], NULL, &request.address,
&request.npdu_data);
if (request.npdu_data.network_layer_message) {
#if PRINT_ENABLED
fprintf(stderr,
"DLMSTP: DER Compare failed: " "Request is Network message.\n");
#endif
return false;
}
request.pdu_type = request_pdu[offset] & 0xF0;
if (request.pdu_type != PDU_TYPE_CONFIRMED_SERVICE_REQUEST) {
#if PRINT_ENABLED
fprintf(stderr,
"DLMSTP: DER Compare failed: " "Not Confirmed Request.\n");
#endif
return false;
}
request.invoke_id = request_pdu[offset + 2];
/* segmented message? */
if (request_pdu[offset] & BIT3) {
request.service_choice = request_pdu[offset + 5];
} else {
request.service_choice = request_pdu[offset + 3];
}
/* decode the reply data */
reply.address.mac[0] = dest_address;
reply.address.mac_len = 1;
offset =
npdu_decode(&reply_pdu[0], &reply.address, NULL, &reply.npdu_data);
if (reply.npdu_data.network_layer_message) {
#if PRINT_ENABLED
fprintf(stderr,
"DLMSTP: DER Compare failed: " "Reply is Network message.\n");
#endif
return false;
}
/* reply could be a lot of things:
confirmed, simple ack, abort, reject, error */
reply.pdu_type = reply_pdu[offset] & 0xF0;
switch (reply.pdu_type) {
case PDU_TYPE_CONFIRMED_SERVICE_REQUEST:
reply.invoke_id = reply_pdu[offset + 2];
/* segmented message? */
if (reply_pdu[offset] & BIT3) {
reply.service_choice = reply_pdu[offset + 5];
} else {
reply.service_choice = reply_pdu[offset + 3];
}
break;
case PDU_TYPE_SIMPLE_ACK:
reply.invoke_id = reply_pdu[offset + 1];
reply.service_choice = reply_pdu[offset + 2];
break;
case PDU_TYPE_COMPLEX_ACK:
reply.invoke_id = reply_pdu[offset + 1];
/* segmented message? */
if (reply_pdu[offset] & BIT3) {
reply.service_choice = reply_pdu[offset + 4];
} else {
reply.service_choice = reply_pdu[offset + 2];
}
break;
case PDU_TYPE_ERROR:
reply.invoke_id = reply_pdu[offset + 1];
reply.service_choice = reply_pdu[offset + 2];
break;
case PDU_TYPE_REJECT:
case PDU_TYPE_ABORT:
reply.invoke_id = reply_pdu[offset + 1];
break;
default:
return false;
}
/* these don't have service choice included */
if ((reply.pdu_type == PDU_TYPE_REJECT) ||
(reply.pdu_type == PDU_TYPE_ABORT)) {
if (request.invoke_id != reply.invoke_id) {
#if PRINT_ENABLED
fprintf(stderr,
"DLMSTP: DER Compare failed: " "Invoke ID mismatch.\n");
#endif
return false;
}
} else {
if (request.invoke_id != reply.invoke_id) {
#if PRINT_ENABLED
fprintf(stderr,
"DLMSTP: DER Compare failed: " "Invoke ID mismatch.\n");
#endif
return false;
}
if (request.service_choice != reply.service_choice) {
#if PRINT_ENABLED
fprintf(stderr,
"DLMSTP: DER Compare failed: " "Service choice mismatch.\n");
#endif
return false;
}
}
if (request.npdu_data.protocol_version != reply.npdu_data.protocol_version) {
#if PRINT_ENABLED
fprintf(stderr,
"DLMSTP: DER Compare failed: "
"NPDU Protocol Version mismatch.\n");
#endif
return false;
}
#if 0
/* the NDPU priority doesn't get passed through the stack, and
all outgoing messages have NORMAL priority */
if (request.npdu_data.priority != reply.npdu_data.priority) {
#if PRINT_ENABLED
fprintf(stderr,
"DLMSTP: DER Compare failed: " "NPDU Priority mismatch.\n");
#endif
return false;
}
#endif
if (!bacnet_address_same(&request.address, &reply.address)) {
#if PRINT_ENABLED
fprintf(stderr,
"DLMSTP: DER Compare failed: " "BACnet Address mismatch.\n");
#endif
return false;
}
return true;
}
/* Get the reply to a DATA_EXPECTING_REPLY frame, or nothing */
uint16_t MSTP_Get_Reply(
volatile struct mstp_port_struct_t * mstp_port,
unsigned timeout)
{ /* milliseconds to wait for a packet */
uint16_t pdu_len = 0; /* return value */
bool matched = false;
uint8_t frame_type = 0;
struct mstp_pdu_packet *pkt;
SHARED_MSTP_DATA *poSharedData = (SHARED_MSTP_DATA *) mstp_port->UserData;
if (!poSharedData) {
return 0;
}
if (Ringbuf_Empty(&poSharedData->PDU_Queue)) {
return 0;
}
pkt = (struct mstp_pdu_packet *) Ringbuf_Peek(&poSharedData->PDU_Queue);
/* is this the reply to the DER? */
matched =
dlmstp_compare_data_expecting_reply(&mstp_port->InputBuffer[0],
mstp_port->DataLength, mstp_port->SourceAddress,
(uint8_t *) & pkt->buffer[0], pkt->length, pkt->destination_mac);
if (!matched) {
return 0;
}
if (pkt->data_expecting_reply) {
frame_type = FRAME_TYPE_BACNET_DATA_EXPECTING_REPLY;
} else {
frame_type = FRAME_TYPE_BACNET_DATA_NOT_EXPECTING_REPLY;
}
/* convert the PDU into the MSTP Frame */
pdu_len = MSTP_Create_Frame(&mstp_port->OutputBuffer[0], /* <-- loading this */
mstp_port->OutputBufferSize, frame_type, pkt->destination_mac,
mstp_port->This_Station, (uint8_t *) & pkt->buffer[0], pkt->length);
(void) Ringbuf_Pop(&poSharedData->PDU_Queue, NULL);
return pdu_len;
}
void dlmstp_set_mac_address(
void *poPort,
uint8_t mac_address)
{
/* SHARED_MSTP_DATA * poSharedData; */
struct mstp_port_struct_t *mstp_port =
(struct mstp_port_struct_t *) poPort;
if (!mstp_port) {
return;
}
/*
poSharedData = (SHARED_MSTP_DATA *) mstp_port->UserData;
if(!poSharedData)
{
return;
}
*/
/* Master Nodes can only have address 0-127 */
if (mac_address <= 127) {
mstp_port->This_Station = mac_address;
/* FIXME: implement your data storage */
/* I2C_Write_Byte(
EEPROM_DEVICE_ADDRESS,
mac_address,
EEPROM_MSTP_MAC_ADDR); */
if (mac_address > mstp_port->Nmax_master)
dlmstp_set_max_master(mstp_port, mac_address);
}
return;
}
uint8_t dlmstp_mac_address(
void *poPort)
{
/* SHARED_MSTP_DATA * poSharedData; */
struct mstp_port_struct_t *mstp_port =
(struct mstp_port_struct_t *) poPort;
if (!mstp_port) {
return 0;
}
/* poSharedData = (SHARED_MSTP_DATA *) mstp_port->UserData;
if(!poSharedData)
{
return 0;
}
*/
return mstp_port->This_Station;
}
/* This parameter represents the value of the Max_Info_Frames property of */
/* the node's Device object. The value of Max_Info_Frames specifies the */
/* maximum number of information frames the node may send before it must */
/* pass the token. Max_Info_Frames may have different values on different */
/* nodes. This may be used to allocate more or less of the available link */
/* bandwidth to particular nodes. If Max_Info_Frames is not writable in a */
/* node, its value shall be 1. */
void dlmstp_set_max_info_frames(
void *poPort,
uint8_t max_info_frames)
{
/* SHARED_MSTP_DATA * poSharedData; */
struct mstp_port_struct_t *mstp_port =
(struct mstp_port_struct_t *) poPort;
if (!mstp_port) {
return;
}
/*
poSharedData = (SHARED_MSTP_DATA *) mstp_port->UserData;
if(!poSharedData)
{
return;
}
*/
if (max_info_frames >= 1) {
mstp_port->Nmax_info_frames = max_info_frames;
/* FIXME: implement your data storage */
/* I2C_Write_Byte(
EEPROM_DEVICE_ADDRESS,
(uint8_t)max_info_frames,
EEPROM_MSTP_MAX_INFO_FRAMES_ADDR); */
}
return;
}
uint8_t dlmstp_max_info_frames(
void *poPort)
{
/* SHARED_MSTP_DATA * poSharedData; */
struct mstp_port_struct_t *mstp_port =
(struct mstp_port_struct_t *) poPort;
if (!mstp_port) {
return 0;
}
/*
poSharedData = (SHARED_MSTP_DATA *) mstp_port->UserData;
if(!poSharedData)
{
return 0;
}
*/
return mstp_port->Nmax_info_frames;
}
/* This parameter represents the value of the Max_Master property of the */
/* node's Device object. The value of Max_Master specifies the highest */
/* allowable address for master nodes. The value of Max_Master shall be */
/* less than or equal to 127. If Max_Master is not writable in a node, */
/* its value shall be 127. */
void dlmstp_set_max_master(
void *poPort,
uint8_t max_master)
{
/* SHARED_MSTP_DATA * poSharedData; */
struct mstp_port_struct_t *mstp_port =
(struct mstp_port_struct_t *) poPort;
if (!mstp_port) {
return;
}
/*
poSharedData = (SHARED_MSTP_DATA *) mstp_port->UserData;
if(!poSharedData)
{
return;
}
*/
if (max_master <= 127) {
if (mstp_port->This_Station <= max_master) {
mstp_port->Nmax_master = max_master;
/* FIXME: implement your data storage */
/* I2C_Write_Byte(
EEPROM_DEVICE_ADDRESS,
max_master,
EEPROM_MSTP_MAX_MASTER_ADDR); */
}
}
return;
}
uint8_t dlmstp_max_master(
void *poPort)
{
/* SHARED_MSTP_DATA * poSharedData; */
struct mstp_port_struct_t *mstp_port =
(struct mstp_port_struct_t *) poPort;
if (!mstp_port) {
return 0;
}
/*
poSharedData = (SHARED_MSTP_DATA *) mstp_port->UserData;
if(!poSharedData)
{
return 0;
}
*/
return mstp_port->Nmax_master;
}
/* RS485 Baud Rate 9600, 19200, 38400, 57600, 115200 */
void dlmstp_set_baud_rate(
void *poPort,
uint32_t baud)
{
SHARED_MSTP_DATA *poSharedData;
struct mstp_port_struct_t *mstp_port =
(struct mstp_port_struct_t *) poPort;
if (!mstp_port) {
return;
}
poSharedData = (SHARED_MSTP_DATA *) mstp_port->UserData;
if (!poSharedData) {
return;
}
switch (baud) {
case 9600:
poSharedData->RS485_Baud = B9600;
break;
case 19200:
poSharedData->RS485_Baud = B19200;
break;
case 38400:
poSharedData->RS485_Baud = B38400;
break;
case 57600:
poSharedData->RS485_Baud = B57600;
break;
case 115200:
poSharedData->RS485_Baud = B115200;
break;
default:
break;
}
}
uint32_t dlmstp_baud_rate(
void *poPort)
{
SHARED_MSTP_DATA *poSharedData;
struct mstp_port_struct_t *mstp_port =
(struct mstp_port_struct_t *) poPort;
if (!mstp_port) {
return false;
}
poSharedData = (SHARED_MSTP_DATA *) mstp_port->UserData;
if (!poSharedData) {
return false;
}
switch (poSharedData->RS485_Baud) {
case B19200:
return 19200;
case B38400:
return 38400;
case B57600:
return 57600;
case B115200:
return 115200;
default:
case B9600:
return 9600;
}
}
void dlmstp_get_my_address(
void *poPort,
BACNET_ADDRESS * my_address)
{
int i = 0; /* counter */
SHARED_MSTP_DATA *poSharedData;
struct mstp_port_struct_t *mstp_port =
(struct mstp_port_struct_t *) poPort;
if (!mstp_port) {
return;
}
poSharedData = (SHARED_MSTP_DATA *) mstp_port->UserData;
if (!poSharedData) {
return;
}
my_address->mac_len = 1;
my_address->mac[0] = mstp_port->This_Station;
my_address->net = 0; /* local only, no routing */
my_address->len = 0;
for (i = 0; i < MAX_MAC_LEN; i++) {
my_address->adr[i] = 0;
}
return;
}
void dlmstp_get_broadcast_address(
BACNET_ADDRESS * dest)
{ /* destination address */
int i = 0; /* counter */
if (dest) {
dest->mac_len = 1;
dest->mac[0] = MSTP_BROADCAST_ADDRESS;
dest->net = BACNET_BROADCAST_NETWORK;
dest->len = 0; /* always zero when DNET is broadcast */
for (i = 0; i < MAX_MAC_LEN; i++) {
dest->adr[i] = 0;
}
}
return;
}
bool dlmstp_init(
void *poPort,
char *ifname)
{
unsigned long hThread = 0;
int rv = 0;
SHARED_MSTP_DATA *poSharedData;
struct mstp_port_struct_t *mstp_port =
(struct mstp_port_struct_t *) poPort;
if (!mstp_port) {
return false;
}
poSharedData = (SHARED_MSTP_DATA *) ((struct mstp_port_struct_t *)
mstp_port)->UserData;
if (!poSharedData) {
return false;
}
poSharedData->RS485_Port_Name = ifname;
/* initialize PDU queue */
Ringbuf_Init(&poSharedData->PDU_Queue,
(uint8_t *) & poSharedData->PDU_Buffer, sizeof(struct mstp_pdu_packet),
MSTP_PDU_PACKET_COUNT);
/* initialize packet queue */
poSharedData->Receive_Packet.ready = false;
poSharedData->Receive_Packet.pdu_len = 0;
rv = pthread_cond_init(&poSharedData->Receive_Packet_Flag, NULL);
if (rv != 0) {
fprintf(stderr,
"MS/TP Interface: %s\n cannot allocate PThread Condition.\n",
ifname);
exit(1);
}
rv = pthread_mutex_init(&poSharedData->Receive_Packet_Mutex, NULL);
if (rv != 0) {
fprintf(stderr,
"MS/TP Interface: %s\n cannot allocate PThread Mutex.\n", ifname);
exit(1);
}
struct termios newtio;
printf("RS485: Initializing %s", poSharedData->RS485_Port_Name);
/*
Open device for reading and writing.
Blocking mode - more CPU effecient
*/
poSharedData->RS485_Handle =
open(poSharedData->RS485_Port_Name,
O_RDWR | O_NOCTTY | O_NONBLOCK /*| O_NDELAY */ );
if (poSharedData->RS485_Handle < 0) {
perror(poSharedData->RS485_Port_Name);
exit(-1);
}
#if 0
/* non blocking for the read */
fcntl(poSharedData->RS485_Handle, F_SETFL, FNDELAY);
#else
/* efficient blocking for the read */
fcntl(poSharedData->RS485_Handle, F_SETFL, 0);
#endif
/* save current serial port settings */
tcgetattr(poSharedData->RS485_Handle, &poSharedData->RS485_oldtio);
/* clear struct for new port settings */
bzero(&newtio, sizeof(newtio));
/*
BAUDRATE: Set bps rate. You could also use cfsetispeed and cfsetospeed.
CRTSCTS : output hardware flow control (only used if the cable has
all necessary lines. See sect. 7 of Serial-HOWTO)
CLOCAL : local connection, no modem contol
CREAD : enable receiving characters
*/
newtio.c_cflag =
poSharedData->RS485_Baud | poSharedData->RS485MOD | CLOCAL | CREAD;
/* Raw input */
newtio.c_iflag = 0;
/* Raw output */
newtio.c_oflag = 0;
/* no processing */
newtio.c_lflag = 0;
/* activate the settings for the port after flushing I/O */
tcsetattr(poSharedData->RS485_Handle, TCSAFLUSH, &newtio);
/* flush any data waiting */
usleep(200000);
tcflush(poSharedData->RS485_Handle, TCIOFLUSH);
/* ringbuffer */
FIFO_Init(&poSharedData->Rx_FIFO, poSharedData->Rx_Buffer,
sizeof(poSharedData->Rx_Buffer));
printf("=success!\n");
mstp_port->InputBuffer = &poSharedData->RxBuffer[0];
mstp_port->InputBufferSize = sizeof(poSharedData->RxBuffer);
mstp_port->OutputBuffer = &poSharedData->TxBuffer[0];
mstp_port->OutputBufferSize = sizeof(poSharedData->TxBuffer);
gettimeofday(&poSharedData->start, NULL);
mstp_port->SilenceTimer = Timer_Silence;
mstp_port->SilenceTimerReset = Timer_Silence_Reset;
MSTP_Init(mstp_port);
#if PRINT_ENABLED
fprintf(stderr, "MS/TP MAC: %02X\n", mstp_port->This_Station);
fprintf(stderr, "MS/TP Max_Master: %02X\n", mstp_port->Nmax_master);
fprintf(stderr, "MS/TP Max_Info_Frames: %u\n",
mstp_port->Nmax_info_frames);
#endif
rv = pthread_create(&hThread, NULL, dlmstp_master_fsm_task, mstp_port);
if (rv != 0) {
fprintf(stderr, "Failed to start Master Node FSM task\n");
}
return true;
}
|
CaduceusInc/greykite | greykite/tests/algo/common/test_model_summary.py | <gh_stars>1000+
import numpy as np
import statsmodels.api as sm
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.ensemble import RandomForestRegressor
from sklearn.linear_model import ElasticNetCV
from sklearn.linear_model import LarsCV
from sklearn.linear_model import LassoCV
from sklearn.linear_model import LassoLarsCV
from sklearn.linear_model import RidgeCV
from sklearn.linear_model import SGDRegressor
from greykite.algo.common.model_summary import ModelSummary
from greykite.common.python_utils import assert_equal
def test_model_summary():
# sets up data
np.random.seed(1)
x = np.concatenate([np.ones([100, 2]), np.random.randn(100, 4)], axis=1)
beta = np.array([1, 1, 1, 1, 0, 0])
y = np.exp(np.matmul(x, beta))
pred_cols = ["Intercept",
"ct1",
"sin1_toy_yearly",
"y_lag7",
"ct1:sin1_toy_yearly",
"C(Q('events_Chinese New Year'), levels=['', 'event'])[T.event]"]
pred_category = {
"intercept": ["Intercept"],
"time_features": ["ct1", "ct1:sin1_toy_yearly"],
"event_features": ["C(Q('events_Chinese New Year'), levels=['', 'event'])[T.event]"],
"trend_features": ["ct1", "ct1:sin1_toy_yearly"],
"seasonality_features": ["sin1_toy_yearly", "ct1:sin1_toy_yearly"],
"lag_features": ["y_lag7"],
"regressor_features": [],
"interaction_features": ["ct1:sin1_toy_yearly"]
}
# fit algorithms
fit_algorithm_dict = {
"statsmodels_ols": sm.OLS,
"statsmodels_wls": sm.WLS,
"statsmodels_gls": sm.GLS,
"statsmodels_glm": sm.GLM,
"linear": sm.OLS,
"elastic_net": ElasticNetCV,
"ridge": RidgeCV,
"lasso": LassoCV,
"sgd": SGDRegressor,
"lars": LarsCV,
"lasso_lars": LassoLarsCV,
"rf": RandomForestRegressor,
"gradient_boosting": GradientBoostingRegressor}
default_fit_algorithm_params = {
"statsmodels_ols": dict(),
"statsmodels_wls": dict(),
"statsmodels_gls": dict(),
"statsmodels_glm": dict(family=sm.families.Gamma()),
"linear": dict(),
"elastic_net": dict(cv=5),
"ridge": dict(cv=5, alphas=np.logspace(-5, 5, 100)),
"lasso": dict(cv=5),
"sgd": dict(),
"lars": dict(cv=5),
"lasso_lars": dict(cv=5),
"rf": dict(n_estimators=100),
"gradient_boosting": dict()}
for fit_algorithm in fit_algorithm_dict:
params = default_fit_algorithm_params.get(fit_algorithm, {})
if "statsmodels" in fit_algorithm or fit_algorithm == "linear":
ml_model = fit_algorithm_dict[fit_algorithm](
endog=y,
exog=x,
**params)
ml_model = ml_model.fit()
ml_model.coef_ = ml_model.params
ml_model.intercept_ = 0
else:
ml_model = fit_algorithm_dict[fit_algorithm](**params)
ml_model.fit(x, y)
summary = ModelSummary(
x=x,
y=y,
pred_cols=pred_cols,
pred_category=pred_category,
fit_algorithm=fit_algorithm,
ml_model=ml_model)
summary.__str__()
if fit_algorithm == "linear":
assert_equal(summary.info_dict["reg_df"], np.trace(x @ np.linalg.pinv(x.T @ x) @ x.T))
|
RoBorregos/roborregos-web-dashboard | spec/features/user_can_create_service_app_spec.rb | <filename>spec/features/user_can_create_service_app_spec.rb
require 'rails_helper'
feature 'User can create service app' do
before :each do
@member = create :member
end
scenario 'and see all service apps' do
login_as @member
visit service_apps_path
expect(page).to have_content('Service Apps')
expect(page).to have_content('Registrar')
expect(page).not_to have_content('Access token:')
click_button 'Registrar'
fill_in 'service_app_name', with: 'New service'
fill_in 'service_app_description', with: 'Description for the new service'
click_button 'Guardar'
expect(page.current_path).to eq service_apps_path
expect(page).to have_content('New service')
expect(page).to have_content('Description for the new service')
expect(page).to have_content('Access token:')
end
end
|
henanewind/rpc | rpc-common/src/main/java/com/github/houbb/rpc/common/config/application/ApplicationConfig.java | package com.github.houbb.rpc.common.config.application;
/**
* 应用配置信息
* （1）服务的应用应该是一个单例。
* （2）对于用户可以不可见，直接根据 rpc.properties 设置。
* @author binbin.hou
* @since 0.0.6
*/
public interface ApplicationConfig {
/**
* @return 应用名称
* @since 0.0.6
*/
String name();
/**
* @return 环境名称
* dev test pre_prod prod
* @since 0.0.6
*/
String env();
}
|
threefoldtech/threefold-forums | db/migrate/20120519182212_create_last_read_posts.rb | # frozen_string_literal: true
class CreateLastReadPosts < ActiveRecord::Migration[4.2]
def change
create_table :last_read_posts do |t|
t.integer :user_id, null: false
t.integer :forum_thread_id, null: false
t.integer :post_number, null: false
t.timestamps null: false
end
add_index :last_read_posts, [:user_id, :forum_thread_id], unique: true
end
end
|
kagwicharles/Seniorproject-ui | node_modules/@iconify/icons-ic/twotone-cast-for-education.js | <filename>node_modules/@iconify/icons-ic/twotone-cast-for-education.js<gh_stars>0
var data = {
"body": "<path d=\"M21 3H3c-1.1 0-2 .9-2 2v3h2V5h18v14h-7v2h7c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM1 18v3h3c0-1.66-1.34-3-3-3zm0-4v2c2.76 0 5 2.24 5 5h2c0-3.87-3.13-7-7-7zm0-4v2a9 9 0 0 1 9 9h2c0-6.08-4.93-11-11-11zm10 1.09v2L14.5 15l3.5-1.91v-2L14.5 13L11 11.09zM14.5 6L9 9l5.5 3L20 9l-5.5-3z\" fill=\"currentColor\"/>",
"width": 24,
"height": 24
};
exports.__esModule = true;
exports.default = data;
|
andreyvit/pyjamas | library/pyjamas/ui/ButtonBase.py | <reponame>andreyvit/pyjamas<gh_stars>1-10
# Copyright 2006 <NAME> and contributors
# Copyright (C) 2009 <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.
from pyjamas import DOM
from pyjamas import Factory
from FocusWidget import FocusWidget
class ButtonBase(FocusWidget):
def __init__(self, element, **kwargs):
FocusWidget.__init__(self, element, **kwargs)
def getHTML(self):
return DOM.getInnerHTML(self.getElement())
def getText(self):
return DOM.getInnerText(self.getElement())
def setHTML(self, html):
DOM.setInnerHTML(self.getElement(), html)
def setText(self, text):
DOM.setInnerText(self.getElement(), text)
Factory.registerClass('pyjamas.ui.ButtonBase', ButtonBase)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.