repo_name stringlengths 6 101 | path stringlengths 4 300 | text stringlengths 7 1.31M |
|---|---|---|
sinhdev/python-demo | data-structure-algorithms/set/e03-set-operations.py | my_set = {1, 2, 3, 4}
my_set_2 = {3, 4, 5, 6}
print(my_set.union(my_set_2), '----------', my_set | my_set_2)
print(my_set.intersection(my_set_2), '----------', my_set & my_set_2)
print(my_set.difference(my_set_2), '----------', my_set - my_set_2)
print(my_set.symmetric_difference(my_set_2), '----------', my_set ^ my_set_2)
my_set.clear()
print(my_set) |
bieao-coding/craneWebReact | src/pages/Company/models/company.js | /*eslint-disable*/
import { getCompanies,addCompany, getCompanyById,editCompany} from '../service/companyService';
export default{
namespace: 'company',
state: {
list: [],
total: 0,
workPageNumber:0,
buildPageNumber:0,
supervisionPageNumber:0,
propertyPageNumber:0
},
effects: {
*fetch({payload,callback}, { call, put }) {
const response = yield call(getCompanies,payload);
if(response && callback) callback(response.data)
},
*getEdit({ payload,callback }, { call, put }) {
const response = yield call(getCompanyById, payload);
if (callback && !!response) callback(response.data);
},
*add({ payload,callback }, { call }) {
const response = yield call(addCompany, payload);
if (callback) callback(response);
},
*edit({ payload,callback }, { call }) {
const response = yield call(editCompany, payload);
if (callback) callback(response);
},
*setPage({ payload }, { call, put }){
yield put({
type: 'modify',
payload: payload,
});
},
},
reducers: {
getList(state, { payload }) {
return {
...state,
...payload,
};
},
modify(state, { payload }) {
return {
...state,
...payload,
};
}
},
};
|
ziransun/wpt | workers/interfaces/WorkerGlobalScope/close/incoming-message.js | <filename>workers/interfaces/WorkerGlobalScope/close/incoming-message.js<gh_stars>1000+
onmessage = function(e) {
postMessage(1);
throw new Error();
}
close(); |
rbshadow/Python_URI | Beginner/URI_1050.py | <filename>Beginner/URI_1050.py
def math():
put = int(input())
if put == 61:
print('Brasilia')
elif put == 71:
print('Salvador')
elif put == 11:
print('Sao Paulo')
elif put == 21:
print('Rio de Janeiro')
elif put == 32:
print('Juiz de Fora')
elif put == 19:
print('Campinas')
elif put == 27:
print('Vitoria')
elif put == 31:
print('<NAME>')
else:
print('DDD nao cadastrado')
if __name__ == '__main__':
math()
|
enfoTek/tomato.linksys.e2000.nvram-mod | tools-src/gnu/glibc/sysdeps/m68k/s_isnanl.c | <reponame>enfoTek/tomato.linksys.e2000.nvram-mod<gh_stars>10-100
/* Copyright (C) 1991, 1992, 1995, 1997 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C 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.
The GNU C 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 the GNU C Library; if not, write to the Free
Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307 USA. */
#include <math.h>
#include "ieee754.h"
#undef __isnanl
#undef isnanl
/* Return nonzero if VALUE is not a number. */
int
__isnanl (long double value)
{
union ieee854_long_double u;
u.d = value;
/* IEEE 854 NaN's have the maximum possible
exponent and a nonzero mantissa. In Motorola's
interpretation the integer bit is ignored. */
return ((u.ieee.exponent & 0x7fff) == 0x7fff &&
((u.ieee.mantissa0 & 0x7fffffff) != 0 || u.ieee.mantissa1 != 0));
}
weak_alias (__isnanl, isnanl);
|
GarryLau/DesignPatterns | Strategy/Collection .h | <reponame>GarryLau/DesignPatterns<gh_stars>0
#pragma once
#include <iostream>
#include "SortBehavior .h"
#include "SearchBehavior .h"
/* Context */
class Collection
{
public:
Collection() {
m_sort = nullptr;
m_search = nullptr;
}
void setSort(SortBehavior *sort) {
m_sort = sort;
}
void setSearch(SearchBehavior *search) {
m_search = search;
}
void runSort() {
m_sort->sort();
}
void runSearch() {
m_search->search();
}
private:
SortBehavior *m_sort;
SearchBehavior *m_search;
}; |
codacy-acme/spectrum | src/views/communityMembers/components/communityMembers.js | // @flow
import * as React from 'react';
import compose from 'recompose/compose';
import { connect } from 'react-redux';
import { withRouter } from 'react-router';
import { withApollo } from 'react-apollo';
import { Loading } from 'src/components/loading';
import GetMembers from './getMembers';
import queryString from 'query-string';
import { withCurrentUser } from 'src/components/withCurrentUser';
import {
SectionCard,
SectionTitle,
SectionCardFooter,
} from 'src/components/settingsViews/style';
import { Filters, Filter, FetchMore, Row } from '../style';
import { ListContainer } from 'src/components/listItems/style';
import ViewError from 'src/components/viewError';
import { UserListItem } from 'src/components/entities';
import { Notice } from 'src/components/listItems/style';
import type { Dispatch } from 'redux';
type Props = {
id: string,
client: Object,
currentUser: Object,
dispatch: Dispatch<Object>,
history: Object,
location: Object,
community: Object,
};
type State = {
filter: ?{
isMember?: boolean,
isModerator?: boolean,
isBlocked?: boolean,
isOwner?: boolean,
},
};
class CommunityMembers extends React.Component<Props, State> {
initialState = {
filter: { isMember: true, isBlocked: false },
};
state = this.initialState;
componentDidMount() {
const { filter } = queryString.parse(this.props.location.search);
if (!filter) return;
if (filter === 'team') {
return this.viewTeam();
}
}
viewMembers = () => {
return this.setState({
filter: { isMember: true, isBlocked: false },
});
};
viewTeam = () => {
return this.setState({
filter: { isModerator: true, isOwner: true },
});
};
generateUserProfile = communityMember => {
const { user } = communityMember;
return (
<React.Fragment>
<Row style={{ position: 'relative' }}>
<UserListItem
userObject={user}
key={user.id}
id={user.id}
name={user.name}
username={user.username}
description={user.description}
isCurrentUser={user.id === this.props.currentUser.id}
profilePhoto={user.profilePhoto}
avatarSize={40}
showHoverProfile={false}
messageButton={user.id !== this.props.currentUser.id}
/>
</Row>
</React.Fragment>
);
};
render() {
const { filter } = this.state;
const { id, community } = this.props;
return (
<SectionCard>
<SectionTitle>
Community Members · {community.metaData.members.toLocaleString()}
</SectionTitle>
<Filters>
<Filter
onClick={this.viewMembers}
active={filter && filter.isMember ? true : false}
>
Members
</Filter>
<Filter
onClick={this.viewTeam}
active={
filter && filter.isModerator && filter.isOwner ? true : false
}
>
Team
</Filter>
</Filters>
<GetMembers
filter={filter}
id={id}
render={({ isLoading, community, isFetchingMore, fetchMore }) => {
const members =
community &&
community.members &&
community.members.edges.map(member => member && member.node);
if (members && members.length > 0) {
return (
<ListContainer data-cy="community-settings-members-list">
{filter && filter.isBlocked && !community.isPrivate && (
<Notice>
<strong>A note about blocked users:</strong> Your
community is publicly viewable (except for private
channels). This means that a blocked user may be able to
see the content and conversations in your community.
However, they will be prevented from creating new
conversations, or leaving messages in existing
conversations.
</Notice>
)}
{members.map(communityMember => {
if (!communityMember) return null;
return this.generateUserProfile(communityMember);
})}
{community && community.members.pageInfo.hasNextPage && (
<SectionCardFooter>
<FetchMore
color={'brand.default'}
loading={isFetchingMore}
onClick={fetchMore}
>
{isFetchingMore ? 'Loading...' : 'Load more'}
</FetchMore>
</SectionCardFooter>
)}
</ListContainer>
);
}
if (isLoading) {
return <Loading />;
}
if (!members || members.length === 0) {
if (filter && filter.isBlocked) {
return (
<ViewError
emoji={' '}
heading={'No blocked members found'}
subheading={
'Nobody has been blocked yet - nice! When someone is blocked, they will appear here'
}
/>
);
}
if (filter && filter.isMember) {
return (
<ViewError
emoji={' '}
heading={'No members found'}
subheading={
"We couldn't find any members in your community. That's strange..."
}
/>
);
}
if (filter && filter.isModerator && filter.isOwner) {
return (
<ViewError
emoji={' '}
heading={'No team members found'}
subheading={
"You haven't added any team members to your community yet."
}
/>
);
}
}
return null;
}}
/>
</SectionCard>
);
}
}
export default compose(
withApollo,
withCurrentUser,
withRouter,
connect()
)(CommunityMembers);
|
bretlowery/snakr | snakr/utilities.py | <gh_stars>1-10
import hashlib
import random
import urllib
import secure.settings as settings
from django.core.validators import URLValidator
import json
import mimetypes
import urllib2
from snakr.ipaddr import IP
_URL_VALIDATOR = URLValidator()
class Utils:
def __init__(self):
return
@staticmethod
def get_encodedurl(myurl):
"""Returns an encoded version of the passed URL."""
return urllib.quote(myurl).encode('utf8').replace('%3A//','://')
@staticmethod
def get_decodedurl(myurl):
"""Returns an decoded version of the passed URL."""
return urllib.unquote(myurl.decode('utf8'))
@staticmethod
def get_longurlhash(myurl):
"""Returns a SHA1 hash of the quoted version of the passed URL."""
# it has to fit into a bigint on MySQL (max = 18446744073709551615), hence the 98-bit-shift
x = long(hashlib.sha1(urllib.quote(myurl).encode('utf8')).hexdigest(),16) >> 98
return x
@staticmethod
def get_shorturlhash(myurl):
"""Returns a SHA1 hash of the UNquoted version of the passed URL."""
# it has to fit into a bigint on MySQL (max = 18446744073709551615), hence the 98-bit-shift
x = long(hashlib.sha1(urllib.unquote(myurl).encode('utf8')).hexdigest(),16) >> 98
return x
@staticmethod
def get_hash(value):
"""Returns a SHA1 hash of the passed string as-encoded"""
# it has to fit into a bigint on MySQL (max = 18446744073709551615), hence the 98-bit-shift
if str == 'unknown':
x = 0
else:
x = long(hashlib.sha1(value).hexdigest(),16) >> 98
return x
@staticmethod
def get_shortpathcandidate(**kwargs):
digits_only = kwargs.pop("digits_only", False)
if digits_only:
import string
return ''.join(random.SystemRandom().choice(string.digits) for _ in range(
settings.SHORTURL_PATH_SIZE))
else:
return ''.join(random.SystemRandom().choice(settings.SHORTURL_PATH_ALPHABET) for _ in range(
settings.SHORTURL_PATH_SIZE))
@staticmethod
def is_url_valid(myurl):
rtn = True
try:
# workaroud for django 1.5.11 bug on %20 encoding causing urlvalidation to fail
valid = _URL_VALIDATOR(Utils.get_decodedurl(myurl.replace("%20","_")))
except:
rtn = False
pass
return rtn
@staticmethod
def get_json(request, key):
try:
json_data = json.loads(request.body)
except:
json_data = None
pass
try:
if json_data:
if json_data[key]:
return json_data[key]
except:
pass
return None
@staticmethod
def is_image(url):
try:
if mimetypes.guess_type(url)[0].split('/')[0] == 'image':
return True
except:
pass
return False
@staticmethod
def true_or_false(value):
def switch(x):
return {
str(value)[0:1].upper() in ['T','Y','1']: True,
str(value).upper() in ['TRUE','YES']: True,
}.get(x, False)
return switch(value)
@staticmethod
def get_meta(request, normalize):
#
# 1. User's IP address
#
x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
if x_forwarded_for:
ip_address = x_forwarded_for.split(',')[0]
else:
ip_address = request.META.get('REMOTE_ADDR', 'unknown')
#
# 2. User's geolocation
#
slatlong = request.META.get('HTTP_X_APPENGINE_CITYLATLONG', '0.0,0.0')
geo_lat = slatlong.split(',')[0]
geo_long = slatlong.split(',')[1]
geo_city = request.META.get('HTTP_X_APPENGINE_CITY', 'unknown')
geo_country = request.META.get('HTTP_X_APPENGINE_COUNTRY','unknown')
#
# 3. Relevant, useful http headers
#
http_host = request.META.get('HTTP_HOST','unknown')
http_useragent = request.META.get('HTTP_USER_AGENT', 'unknown')
http_referer = request.META.get('HTTP_REFERER','unknown')
if normalize:
return ip_address.lower(), geo_lat, geo_long, geo_city.lower(), geo_country.lower(), http_host.lower(), http_useragent.lower(), http_referer.lower()
else:
return ip_address, geo_lat, geo_long, geo_city, geo_country, http_host, http_useragent, http_referer
@staticmethod
def remove_nonascii(value):
if value is None:
return None
else:
return "".join(filter(lambda x: ord(x)<128, value))
@staticmethod
def url_exists(url):
rtn = False
try:
req = urllib2.Request(url)
req.add_header('User-Agent','Snakr URL Shortener Service (http://www.github.com/bretlowery/snakr) v%s' % settings.SNAKR_VERSION)
resp = urllib2.urlopen(req)
if resp.code in (200, 401):
rtn = True
except:
pass
return rtn
@staticmethod
def is_ip_valid(ip_address):
rtn = False
try:
ip = IP(ip_address)
if ip:
rtn = True
except:
pass
return rtn
#
# @staticmethod
# def get_geo_country_ordinal(geo_country):
# if geo_country == 'us':
# return 0
# else:
# return (1000 * ord(geo_country[0].lower())) + ord(geo_country[1].lower())
#
# @staticmethod
# def get_geo_city_ordinal(geo_city):
# c = geo_city.replace(' ','')
# def ggco_recurse(c, l, o):
# k = c[0:1]
# i = ord(k) - 96
# o = o + (i * 10**-l)
# l += 1
# if geo_country == 'us':
# return 0
# else:
# return
|
hermantai/sorno-py-scripts | scripts/tests/test_sorno_grepchunks.py | <reponame>hermantai/sorno-py-scripts
"""
Tests for sorno_grepchunks
Copyright 2016 <NAME>
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
from __future__ import print_function
from __future__ import absolute_import
from __future__ import division
from __future__ import unicode_literals
from mock import MagicMock
import re
import unittest
from sorno_grepchunks import GrepChunksApp
class AppTest(unittest.TestCase):
def setUp(self):
self.args = MagicMock
self.args.regex = "test_regex"
self.app = GrepChunksApp(self.args)
def test_feed_ThreeLinesNotMatch_OneChunk(self):
text = "apple\norange\nboy"
regex = re.compile("zzz")
for line in text.split('\n'):
self.assertIsNone(self.app._feed(line, regex))
self.assertEqual(
text.replace('\n', ''),
self.app._close_partial_chunk(),
)
def test_feed_ThreeLinesOneLineMatch_TwoChunks(self):
t1 = "apple"
t2 = "orange"
t3 = "boy"
regex = re.compile("orange")
self.assertIsNone(self.app._feed(t1, regex))
self.assertEqual("apple", self.app._feed(t2, regex))
self.assertIsNone(self.app._feed(t3, regex))
self.assertEqual("orangeboy", self.app._close_partial_chunk())
def test_grep_if_exists_RegexMatch(self):
t1 = "apple"
self.args.regex = "pp"
app = GrepChunksApp(self.args)
self.assertEqual(t1, app._grep_if_exists(t1))
def test_grep_if_exists_RegexNotMatch(self):
t1 = "apple"
self.args.regex = "aa"
app = GrepChunksApp(self.args)
self.assertIsNone(app._grep_if_exists(t1))
def test_grep_if_exists_MultiLineRegexMatch(self):
t1 = "ap\nple"
self.args.regex = "p.p"
app = GrepChunksApp(self.args)
self.assertEqual(t1, app._grep_if_exists(t1))
|
MarcosWinicyus/oop-cpp-studies | class_08_28/src/empresario.cc | #include "empresario.h"
Empresario::Empresario(Endereco *endereco) : Pessoa(endereco) {}
void Empresario::set_investimento(const double &investimento_inicial){
this->investimento_inicial = investimento_inicial;
}
double Empresario::get_investimento(){
return investimento_inicial;
}
|
ahahn-gbif/checklistbank | checklistbank-cli/src/main/java/org/gbif/checklistbank/cli/common/RabbitDatasetService.java | <reponame>ahahn-gbif/checklistbank<filename>checklistbank-cli/src/main/java/org/gbif/checklistbank/cli/common/RabbitDatasetService.java
package org.gbif.checklistbank.cli.common;
import org.gbif.checklistbank.config.GangliaConfiguration;
import org.gbif.checklistbank.logging.LogContext;
import org.gbif.common.messaging.api.messages.DatasetBasedMessage;
import org.gbif.common.messaging.config.MessagingConfiguration;
import java.io.IOException;
import java.util.Set;
import java.util.UUID;
import com.codahale.metrics.Counter;
import com.codahale.metrics.MetricRegistry;
import com.codahale.metrics.Timer;
import com.google.common.collect.Sets;
import com.google.inject.Module;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.Marker;
import org.slf4j.MarkerFactory;
public abstract class RabbitDatasetService<T extends DatasetBasedMessage> extends RabbitBaseService<T> {
private static final Logger LOG = LoggerFactory.getLogger(RabbitDatasetService.class);
private static final Marker DOI_SMTP = MarkerFactory.getMarker("SMTP");
private Timer timer;
private Counter succeeded;
private Counter failed;
protected Set<UUID> runningJobs = Sets.newHashSet();
private final String action;
public RabbitDatasetService(String queue, int poolSize, MessagingConfiguration mCfg, GangliaConfiguration gCfg, String action, Module... modules) {
super(queue, poolSize, mCfg, gCfg, modules);
this.action = action;
}
@Override
protected void initMetrics(MetricRegistry registry) {
super.initMetrics(registry);
timer = registry.timer(regName("time"));
succeeded = registry.counter(regName("succeeded"));
failed = registry.counter(regName("failed"));
}
@Override
public void handleMessage(T msg) {
final Timer.Context context = timer.time();
try {
LogContext.startDataset(msg.getDatasetUuid());
if (!ignore(msg)) {
if (runningJobs.contains(msg.getDatasetUuid())) {
LOG.warn("Dataset {} {} job already running. Ignore message", action, msg.getDatasetUuid());
} else {
runningJobs.add(msg.getDatasetUuid());
process(msg);
succeeded.inc();
runningJobs.remove(msg.getDatasetUuid());
}
}
} catch (Throwable e) {
runningJobs.remove(msg.getDatasetUuid());
LOG.error(DOI_SMTP, "Failed to {} dataset {}", action, msg.getDatasetUuid(), e);
failed(msg.getDatasetUuid());
failed.inc();
} finally {
context.stop();
LogContext.endDataset();
}
}
/**
* Implement this filter method to ignore messages.
* The default implementation accepts all incoming messages.
*
* @param msg the message to check
*
* @return true if the message should be ignored
*/
protected boolean ignore(T msg) {
return false;
}
/**
* Implement this to do the real work.
* The method is allowed to throw any exceptions which will be handled by this class.
* Basic ganglia timer and succeeded/failed counter are also implemented already.
*/
protected abstract void process(T msg) throws Exception;
/**
* Optional hook to implement when the message processing threw an exception.
*
* @param datasetKey the dataset being processed
*/
protected void failed(UUID datasetKey) {
}
protected void send(DatasetBasedMessage msg) throws IOException {
try {
LOG.info("Sending {} for dataset {}", msg.getClass().getSimpleName(), msg.getDatasetUuid());
publisher.send(msg);
} catch (IOException e) {
LOG.error("Could not send {} for dataset [{}]", msg.getClass().getSimpleName(), msg.getDatasetUuid(), e);
throw e;
}
}
}
|
jbrdl/mynewt-dw1000-core | hw/drivers/uwb/uwb_dw1000/src/dw1000_dev.c | <filename>hw/drivers/uwb/uwb_dw1000/src/dw1000_dev.c
/*
* Copyright 2018, Decawave Limited, All Rights Reserved
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
/**
* @file dw1000_dev.c
* @author <NAME>
* @date 2018
* @brief Device file
*
* @details This is the dev base class which utilises the functions to perform initialization and necessary configurations on device.
*
*/
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <os/os.h>
#include <hal/hal_spi.h>
#include <hal/hal_gpio.h>
#include <stats/stats.h>
#include <dw1000/dw1000_dev.h>
#include <dw1000/dw1000_regs.h>
#include <dw1000/dw1000_hal.h>
#include <dw1000/dw1000_phy.h>
#define DIAGMSG(s,u) printf(s,u)
#ifndef DIAGMSG
#define DIAGMSG(s,u)
#endif
//! Structure of DW1000 attributes.
typedef struct _dw1000_cmd{
uint32_t reg:6; //!< Indicates the register to be read or write into
uint32_t subindex:1; //!< Indicates offset address of the register
uint32_t operation:1; //!< Read or Write operation
uint32_t extended:1; //!< If subaddress is higher than 128
uint32_t subaddress:15; //!< Indicates subaddress of register
} dw1000_cmd_t;
/**
* API to perform dw1000_read from given address.
*
* @param inst Pointer to dw1000_dev_instance_t.
* @param reg Member of dw1000_cmd_t structure.
* @param subaddress Member of dw1000_cmd_t structure.
* @param buffer Result is stored in buffer.
* @param length Represents buffer length.
* @return struct uwb_dev_status
*/
struct uwb_dev_status
dw1000_read(dw1000_dev_instance_t * inst, uint16_t reg, uint16_t subaddress, uint8_t * buffer, uint16_t length)
{
assert(reg <= 0x3F); // Record number is limited to 6-bits.
assert((subaddress <= 0x7FFF) && ((subaddress + length) <= 0x7FFF)); // Index and sub-addressable area are limited to 15-bits.
dw1000_cmd_t cmd = {
.reg = reg,
.subindex = subaddress != 0,
.operation = 0, //Read
.extended = subaddress > 0x7F,
.subaddress = subaddress
};
uint8_t header[] = {
[0] = cmd.operation << 7 | cmd.subindex << 6 | cmd.reg,
[1] = cmd.extended << 7 | (uint8_t) (subaddress),
[2] = (uint8_t) (subaddress >> 7)
};
uint8_t len = cmd.subaddress?(cmd.extended?3:2):1;
/* Possible issue here when reading shorter amounts of data
* using the nonblocking read with double buffer. Asserts on
* mutex releases seen in calling function when reading frames of length 8 */
if (length < MYNEWT_VAL(DW1000_DEVICE_SPI_RD_MAX_NOBLOCK) ||
inst->uwb_dev.config.blocking_spi_transfers) {
hal_dw1000_read(inst, header, len, buffer, length);
} else {
hal_dw1000_read_noblock(inst, header, len, buffer, length);
}
return inst->uwb_dev.status;
}
/**
* API to performs dw1000_write into given address.
*
* @param inst Pointer to dw1000_dev_instance_t.
* @param reg Member of dw1000_cmd_t structure.
* @param subaddress Member of dw1000_cmd_t structure.
* @param buffer Result is stored in buffer.
* @param length Represents buffer length.
* @return struct uwb_dev_status
*/
struct uwb_dev_status
dw1000_write(dw1000_dev_instance_t * inst, uint16_t reg, uint16_t subaddress, uint8_t * buffer, uint16_t length)
{
assert(reg <= 0x3F); // Record number is limited to 6-bits.
assert((subaddress <= 0x7FFF) && ((subaddress + length) <= 0x7FFF)); // Index and sub-addressable area are limited to 15-bits.
dw1000_cmd_t cmd = {
.reg = reg,
.subindex = subaddress != 0,
.operation = 1, //Write
.extended = subaddress > 0x7F,
.subaddress = subaddress
};
uint8_t header[] = {
[0] = cmd.operation << 7 | cmd.subindex << 6 | cmd.reg,
[1] = cmd.extended << 7 | (uint8_t) (subaddress),
[2] = (uint8_t) (subaddress >> 7)
};
uint8_t len = cmd.subaddress?(cmd.extended?3:2):1;
/* Only use non-blocking write if the length of the write justifies it */
if (len+length < 4 || inst->uwb_dev.config.blocking_spi_transfers) {
hal_dw1000_write(inst, header, len, buffer, length);
} else {
hal_dw1000_write_noblock(inst, header, len, buffer, length);
}
return inst->uwb_dev.status;
}
/**
* API to read data from dw1000 register based on given parameters.
*
* @param inst Pointer to dw1000_dev_instance_t.
* @param reg Register from where data is read.
* @param subaddress Address where data is read.
* @param val value to be read.
* @param nbytes Length of data.
* @return buffer.value
*/
uint64_t
dw1000_read_reg(dw1000_dev_instance_t * inst, uint16_t reg, uint16_t subaddress, size_t nbytes)
{
union _buffer{
uint8_t array[sizeof(uint64_t)];
uint64_t value;
} __attribute__((__packed__, aligned (8))) buffer;
assert(reg <= 0x3F); // Record number is limited to 6-bits.
assert((subaddress <= 0x7FFF) && ((subaddress + nbytes) <= 0x7FFF)); // Index and sub-addressable area are limited to 15-bits.
assert(nbytes <= sizeof(uint64_t));
dw1000_cmd_t cmd = {
.reg = reg,
.subindex = subaddress != 0,
.operation = 0, //Read
.extended = subaddress > 0x7F,
.subaddress = subaddress
};
uint8_t header[] = {
[0] = cmd.operation << 7 | cmd.subindex << 6 | cmd.reg,
[1] = cmd.extended << 7 | (uint8_t) (subaddress),
[2] = (uint8_t) (subaddress >> 7)
};
uint8_t len = cmd.subaddress?(cmd.extended?3:2):1;
hal_dw1000_read(inst, header, len, buffer.array, nbytes); // result is stored in the buffer
return buffer.value;
}
/**
* API to write data into dw1000 register based on given parameters.
*
* @param inst Pointer to dw1000_dev_instance_t.
* @param reg Register from where data is written into.
* @param subaddress Address where writing of data begins.
* @param val Value to be written.
* @param nbytes Length of data.
* @return buffer.value
*/
void
dw1000_write_reg(dw1000_dev_instance_t * inst, uint16_t reg, uint16_t subaddress, uint64_t val, size_t nbytes)
{
union _buffer{
uint8_t array[sizeof(uint64_t)];
uint64_t value;
} __attribute__((__packed__)) buffer;
buffer.value = val;
assert(nbytes <= sizeof(uint64_t));
assert(reg <= 0x3F); // Record number is limited to 6-bits.
assert((subaddress <= 0x7FFF) && ((subaddress + nbytes) <= 0x7FFF)); // Index and sub-addressable area are limited to 15-bits.
dw1000_cmd_t cmd = {
.reg = reg,
.subindex = subaddress != 0,
.operation = 1, //Write
.extended = subaddress > 0x7F,
.subaddress = subaddress
};
uint8_t header[] = {
[0] = cmd.operation << 7 | cmd.subindex << 6 | cmd.reg,
[1] = cmd.extended << 7 | (uint8_t) (subaddress),
[2] = (uint8_t) (subaddress >> 7)
};
uint8_t len = cmd.subaddress?(cmd.extended?3:2):1;
hal_dw1000_write(inst, header, len, buffer.array, nbytes);
}
/**
* API to do softreset on dw1000 by writing data into PMSC_CTRL0_SOFTRESET_OFFSET.
*
* @param inst Pointer to dw1000_dev_instance_t.
* @return void
*/
void
dw1000_softreset(dw1000_dev_instance_t * inst)
{
// Set system clock to XTI
dw1000_phy_sysclk_XTAL(inst);
dw1000_write_reg(inst, PMSC_ID, PMSC_CTRL1_OFFSET, PMSC_CTRL1_PKTSEQ_DISABLE, sizeof(uint16_t)); // Disable PMSC ctrl of RF and RX clk blocks
dw1000_write_reg(inst, AON_ID, AON_WCFG_OFFSET, 0x0, sizeof(uint16_t)); // Clear any AON auto download bits (as reset will trigger AON download)
dw1000_write_reg(inst, AON_ID, AON_CFG0_OFFSET, 0x0, sizeof(uint8_t)); // Clear the wake-up configuration
// Uploads always-on (AON) data array and configuration
dw1000_write_reg(inst, AON_ID, AON_CTRL_OFFSET, 0x0, sizeof(uint8_t)); // Clear the register
dw1000_write_reg(inst, AON_ID, AON_CTRL_OFFSET, AON_CTRL_SAVE, sizeof(uint8_t));
dw1000_write_reg(inst, PMSC_ID, PMSC_CTRL0_SOFTRESET_OFFSET, PMSC_CTRL0_RESET_ALL, sizeof(uint8_t));// Reset HIF, TX, RX and PMSC
// DW1000 needs a 10us sleep to let clk PLL lock after reset - the PLL will automatically lock after the reset
os_cputime_delay_usecs(10);
dw1000_write_reg(inst, PMSC_ID, PMSC_CTRL0_SOFTRESET_OFFSET, PMSC_CTRL0_RESET_CLEAR, sizeof(uint8_t)); // Clear reset
}
/**
* API to configure dw1000.
*
* @param inst Pointer to dw1000_dev_instance_t.
* @returns OS_OK on success
*/
int
dw1000_dev_config(dw1000_dev_instance_t * inst)
{
int rc;
int timeout = 3;
retry:
inst->spi_settings.baudrate = MYNEWT_VAL(DW1000_DEVICE_BAUDRATE_LOW);
hal_dw1000_reset(inst);
rc = hal_spi_disable(inst->spi_num);
assert(rc == 0);
rc = hal_spi_config(inst->spi_num, &inst->spi_settings);
assert(rc == 0);
hal_spi_set_txrx_cb(inst->spi_num, hal_dw1000_spi_txrx_cb, (void*)inst);
rc = hal_spi_enable(inst->spi_num);
assert(rc == 0);
inst->uwb_dev.device_id = dw1000_read_reg(inst, DEV_ID_ID, 0, sizeof(uint32_t));
inst->uwb_dev.status.initialized = (inst->uwb_dev.device_id == DWT_DEVICE_ID);
if (!inst->uwb_dev.status.initialized && --timeout)
{
/* In case dw1000 was sleeping */
dw1000_dev_wakeup(inst);
goto retry;
}
if(!inst->uwb_dev.status.initialized)
{
return OS_TIMEOUT;
}
dw1000_phy_init(inst, NULL);
/* It's now safe to increase the SPI baudrate > 4M */
inst->spi_settings.baudrate = MYNEWT_VAL(DW1000_DEVICE_BAUDRATE_HIGH);
rc = hal_spi_disable(inst->spi_num);
assert(rc == 0);
rc = hal_spi_config(inst->spi_num, &inst->spi_settings);
assert(rc == 0);
rc = hal_spi_enable(inst->spi_num);
assert(rc == 0);
inst->uwb_dev.pan_id = MYNEWT_VAL(PANID);
inst->uwb_dev.uid = inst->part_id & 0xffff;
if (inst == hal_dw1000_inst(0)) {
#if MYNEWT_VAL(DW_DEVICE_ID_0)
inst->uwb_dev.uid = MYNEWT_VAL(DW_DEVICE_ID_0);
#endif
} else if (inst == hal_dw1000_inst(1)){
#if MYNEWT_VAL(DW_DEVICE_ID_1)
inst->uwb_dev.uid = MYNEWT_VAL(DW_DEVICE_ID_1);
#endif
} else if (inst == hal_dw1000_inst(2)){
#if MYNEWT_VAL(DW_DEVICE_ID_2)
inst->uwb_dev.uid = MYNEWT_VAL(DW_DEVICE_ID_2);
#endif
}
inst->uwb_dev.euid = (((uint64_t)inst->lot_id) << 32) + inst->part_id;
dw1000_set_panid(inst,inst->uwb_dev.pan_id);
dw1000_mac_init(inst, NULL);
return OS_OK;
}
/**
* API to free the acquired resources.
*
* @param inst Pointer to dw1000_dev_instance_t.
* @return void
*/
void
dw1000_dev_free(dw1000_dev_instance_t * inst){
assert(inst);
hal_spi_disable(inst->spi_num);
if (inst->uwb_dev.status.selfmalloc)
free(inst);
else
inst->uwb_dev.status.initialized = 0;
}
/**
* API to set the sleep counter to new value, this function programs the high 16-bits of the 28-bit counter.
*
* NOTE: this function needs to be run before dw1000_dev_configure_sleep, also the SPI freq has to be < 3MHz
*
* @param inst Pointer to dw1000_dev_instance_t.
* @param count Value of the sleep counter to program.
*
* @return void
*/
void
dw1000_dev_set_sleep_timer(dw1000_dev_instance_t * inst, uint16_t count)
{
dw1000_phy_sysclk_XTAL(inst); // Force system clock to be the 19.2 MHz XTI clock.
dw1000_write_reg(inst, AON_ID, AON_CFG1_OFFSET, 0x0, sizeof(uint8_t)); // Disable the sleep counter
dw1000_write_reg(inst, AON_ID, AON_CFG0_SLEEP_TIM_OFFSET, count, sizeof(uint16_t)); // Write new sleep counter
dw1000_write_reg(inst, AON_ID, AON_CFG1_OFFSET, AON_CFG1_SLEEP_CEN | AON_CFG1_LPOSC_CAL, sizeof(uint8_t)); // Enable the sleep counter
dw1000_write_reg(inst, AON_ID, AON_CTRL_OFFSET, AON_CTRL_UPL_CFG, sizeof(uint8_t)); // Upload array
dw1000_write_reg(inst, AON_ID, AON_CTRL_OFFSET, 0, sizeof(uint8_t)); // Upload array
dw1000_phy_sysclk_SEQ(inst); // The system clock will run off the 19.2 MHz XTI clock until the PLL is calibrated and locked
}
/**
* API to configure the device for both DEEP_SLEEP and SLEEP modes, and on-wake mode
* i.e., before entering the sleep, the device should be programmed for TX or RX, then upon "waking up" the TX/RX settings
* will be preserved and the device can immediately perform the desired action TX/RX.
*
* NOTE: e.g. Tag operation - after deep sleep, the device needs to just load the TX buffer and send the frame.
*
* @param inst Pointer to dw1000_dev_instance_t.
*
* @return void
*/
void
dw1000_dev_configure_sleep(dw1000_dev_instance_t * inst)
{
uint16_t reg = dw1000_read_reg(inst, AON_ID, AON_WCFG_OFFSET, sizeof(uint16_t));
reg |= AON_WCFG_ONW_L64P | AON_WCFG_ONW_LDC;
if (inst->uwb_dev.status.LDE_enabled)
reg |= AON_WCFG_ONW_LLDE;
else
reg &= ~AON_WCFG_ONW_LLDE;
if (inst->uwb_dev.status.LDO_enabled)
reg |= AON_WCFG_ONW_LLDO;
else
reg &= ~AON_WCFG_ONW_LLDO;
if (inst->uwb_dev.config.wakeup_rx_enable)
reg |= AON_WCFG_ONW_RX;
else
reg &= ~AON_WCFG_ONW_RX;
dw1000_write_reg(inst, AON_ID, AON_WCFG_OFFSET, reg, sizeof(uint16_t));
reg = dw1000_read_reg(inst, AON_ID, AON_CFG0_OFFSET, sizeof(uint16_t));
reg |= AON_CFG0_WAKE_SPI | AON_CFG0_WAKE_PIN;
inst->uwb_dev.status.sleep_enabled = inst->uwb_dev.config.sleep_enable;
if (inst->uwb_dev.status.sleep_enabled)
reg |= AON_CFG0_WAKE_CNT | AON_CFG0_SLEEP_EN;
else
reg &= ~(AON_CFG0_WAKE_CNT | AON_CFG0_SLEEP_EN);
dw1000_write_reg(inst, AON_ID, AON_CFG0_OFFSET, reg, sizeof(uint16_t));
}
/**
* API to enter device into sleep mode.
*
* @param inst Pointer to dw1000_dev_instance_t.
* @return struct uwb_dev_status
*/
struct uwb_dev_status
dw1000_dev_enter_sleep(dw1000_dev_instance_t * inst)
{
// Critical region, atomic lock with mutex
dpl_error_t err = dpl_mutex_pend(&inst->mutex, DPL_WAIT_FOREVER);
assert(err == DPL_OK);
/* Upload always on array configuration and enter sleep */
dw1000_write_reg(inst, AON_ID, AON_CTRL_OFFSET, 0x0, sizeof(uint16_t));
dw1000_write_reg(inst, AON_ID, AON_CTRL_OFFSET, AON_CTRL_SAVE, sizeof(uint16_t));
inst->uwb_dev.status.sleeping = 1;
// Critical region, unlock mutex
err = dpl_mutex_release(&inst->mutex);
assert(err == DPL_OK);
return inst->uwb_dev.status;
}
/**
* API to wakeup device from sleep to init.
*
* @param inst Pointer to dw1000_dev_instance_t.
* @return struct uwb_dev_status
*/
struct uwb_dev_status
dw1000_dev_wakeup(dw1000_dev_instance_t * inst)
{
int timeout=5;
uint32_t devid;
// Critical region, atomic lock with mutex
dpl_error_t err = dpl_mutex_pend(&inst->mutex, DPL_WAIT_FOREVER);
assert(err == DPL_OK);
devid = dw1000_read_reg(inst, DEV_ID_ID, 0, sizeof(uint32_t));
while (devid != 0xDECA0130 && --timeout)
{
hal_dw1000_wakeup(inst);
devid = dw1000_read_reg(inst, DEV_ID_ID, 0, sizeof(uint32_t));
}
inst->uwb_dev.status.sleeping = (devid != DWT_DEVICE_ID);
dw1000_write_reg(inst, SYS_STATUS_ID, 0, SYS_STATUS_SLP2INIT, sizeof(uint32_t));
dw1000_write_reg(inst, SYS_STATUS_ID, 0, SYS_STATUS_ALL_RX_ERR, sizeof(uint32_t));
/* Antenna delays lost in deep sleep ? */
dw1000_phy_set_rx_antennadelay(inst, inst->uwb_dev.rx_antenna_delay);
dw1000_phy_set_tx_antennadelay(inst, inst->uwb_dev.tx_antenna_delay);
// Critical region, unlock mutex
err = dpl_mutex_release(&inst->mutex);
assert(err == DPL_OK);
/* In case dw1000 was instructed to sleep directly after tx
* we may need to release the tx sem */
if(dpl_sem_get_count(&inst->tx_sem) == 0) {
dpl_sem_release(&inst->tx_sem);
}
return inst->uwb_dev.status;
}
/**
* API to set the auto TX to sleep bit. This means that after a frame
* transmission the device will enter deep sleep mode. The dev_configure_sleep() function
* needs to be called before this to configure the on-wake settings.
*
* NOTE: the IRQ line has to be low/inactive (i.e. no pending events)
*
* @param inst Pointer to dw1000_dev_instance_t.
* @param enable 1 to configure the device to enter deep sleep after TX, 0 to disables the configuration.
* @return struct uwb_dev_status
*/
struct uwb_dev_status
dw1000_dev_enter_sleep_after_tx(dw1000_dev_instance_t * inst, uint8_t enable)
{
inst->control.sleep_after_tx = enable;
uint32_t reg = dw1000_read_reg(inst, PMSC_ID, PMSC_CTRL1_OFFSET, sizeof(uint32_t));
if(inst->control.sleep_after_tx)
reg |= PMSC_CTRL1_ATXSLP;
else
reg &= ~(PMSC_CTRL1_ATXSLP);
dw1000_write_reg(inst, PMSC_ID, PMSC_CTRL1_OFFSET, reg, sizeof(uint32_t));
return inst->uwb_dev.status;
}
/**
* Sets the auto RX to sleep bit. This means that after a frame
* received the device will enter deep sleep mode. The dev_configure_sleep() function
* needs to be called before this to configure the on-wake settings.
*
* NOTE: the IRQ line has to be low/inactive (i.e. no pending events).
* @param inst Pointer to dw1000_dev_instance_t.
* @param enable 1 to configure the device to enter deep sleep after TX, 0 to disables the configuration
* @return struct uwb_dev_status
*/
struct uwb_dev_status
dw1000_dev_enter_sleep_after_rx(dw1000_dev_instance_t * inst, uint8_t enable)
{
inst->control.sleep_after_rx = enable;
uint32_t reg = dw1000_read_reg(inst, PMSC_ID, PMSC_CTRL1_OFFSET, sizeof(uint32_t));
if(inst->control.sleep_after_rx)
reg |= PMSC_CTRL1_ARXSLP;
else
reg &= ~(PMSC_CTRL1_ARXSLP);
dw1000_write_reg(inst, PMSC_ID, PMSC_CTRL1_OFFSET, reg, sizeof(uint32_t));
return inst->uwb_dev.status;
}
/*******************************************************/
inline static struct uwb_dev_status
uwb_dw1000_mac_config(struct uwb_dev *dev, struct uwb_dev_config *config)
{
return dw1000_mac_config((dw1000_dev_instance_t *)dev, config);
}
inline static void
uwb_dw1000_txrf_config(struct uwb_dev *dev, struct uwb_dev_txrf_config *config)
{
dw1000_phy_config_txrf((dw1000_dev_instance_t *)dev, config);
}
inline static void
uwb_dw1000_sleep_config(struct uwb_dev *dev)
{
dw1000_dev_configure_sleep((dw1000_dev_instance_t *)dev);
}
inline static struct uwb_dev_status
uwb_dw1000_enter_sleep(struct uwb_dev *dev)
{
return dw1000_dev_enter_sleep((dw1000_dev_instance_t *)dev);
}
inline static struct uwb_dev_status
uwb_dw1000_enter_sleep_after_tx(struct uwb_dev *dev, uint8_t enable)
{
return dw1000_dev_enter_sleep_after_tx((dw1000_dev_instance_t *)dev, enable);
}
inline static struct uwb_dev_status
uwb_dw1000_enter_sleep_after_rx(struct uwb_dev *dev, uint8_t enable)
{
return dw1000_dev_enter_sleep_after_rx((dw1000_dev_instance_t *)dev, enable);
}
inline static struct uwb_dev_status
uwb_dw1000_wakeup(struct uwb_dev *dev)
{
return dw1000_dev_wakeup((dw1000_dev_instance_t *)dev);
}
inline static struct uwb_dev_status
uwb_dw1000_set_dblrxbuf(struct uwb_dev *dev, bool enable)
{
return dw1000_set_dblrxbuff((dw1000_dev_instance_t *)dev, enable);
}
inline static struct uwb_dev_status
uwb_dw1000_set_rx_timeout(struct uwb_dev *dev, uint32_t timeout)
{
return dw1000_set_rx_timeout((dw1000_dev_instance_t *)dev, timeout);
}
inline static struct uwb_dev_status
uwb_dw1000_adj_rx_timeout(struct uwb_dev *dev, uint32_t timeout)
{
return dw1000_adj_rx_timeout((dw1000_dev_instance_t *)dev, timeout);
}
inline static struct uwb_dev_status
uwb_dw1000_set_delay_start(struct uwb_dev *dev, uint64_t dx_time)
{
return dw1000_set_delay_start((dw1000_dev_instance_t *)dev, dx_time);
}
inline static struct uwb_dev_status
uwb_dw1000_start_tx(struct uwb_dev *dev)
{
return dw1000_start_tx((dw1000_dev_instance_t *)dev);
}
inline static struct uwb_dev_status
uwb_dw1000_start_rx(struct uwb_dev *dev)
{
return dw1000_start_rx((dw1000_dev_instance_t *)dev);
}
inline static struct uwb_dev_status
uwb_dw1000_stop_rx(struct uwb_dev *dev)
{
return dw1000_stop_rx((dw1000_dev_instance_t *)dev);
}
inline static struct uwb_dev_status
uwb_dw1000_write_tx(struct uwb_dev* dev, uint8_t *tx_frame_bytes,
uint16_t tx_buffer_offset, uint16_t tx_frame_length)
{
return dw1000_write_tx((dw1000_dev_instance_t *)dev, tx_frame_bytes,
tx_buffer_offset, tx_frame_length);
}
inline static void
uwb_dw1000_write_tx_fctrl(struct uwb_dev* dev, uint16_t tx_frame_length,
uint16_t tx_buffer_offset)
{
dw1000_write_tx_fctrl((dw1000_dev_instance_t *)dev, tx_frame_length,
tx_buffer_offset);
}
inline static dpl_error_t
uwb_dw1000_hal_noblock_wait(struct uwb_dev* dev, dpl_time_t timeout)
{
return hal_dw1000_rw_noblock_wait((dw1000_dev_instance_t *)dev, timeout);
}
inline static struct uwb_dev_status
uwb_dw1000_set_wait4resp(struct uwb_dev *dev, bool enable)
{
return dw1000_set_wait4resp((dw1000_dev_instance_t *)dev, enable);
}
inline static struct uwb_dev_status
uwb_dw1000_set_wait4resp_delay(struct uwb_dev *dev, uint32_t delay)
{
return dw1000_set_wait4resp_delay((dw1000_dev_instance_t *)dev, delay);
}
inline static struct uwb_dev_status
uwb_dw1000_set_rxauto_disable(struct uwb_dev *dev, bool disable)
{
return dw1000_set_rxauto_disable((dw1000_dev_instance_t *)dev, disable);
}
inline static uint64_t
uwb_dw1000_read_systime(struct uwb_dev* dev)
{
return dw1000_read_systime((dw1000_dev_instance_t *)dev);
}
inline static uint32_t
uwb_dw1000_read_systime_lo32(struct uwb_dev* dev)
{
return dw1000_read_systime_lo((dw1000_dev_instance_t *)dev);
}
inline static uint64_t
uwb_dw1000_read_rxtime(struct uwb_dev* dev)
{
return dw1000_read_rxtime((dw1000_dev_instance_t *)dev);
}
inline static uint32_t
uwb_dw1000_read_rxtime_lo32(struct uwb_dev* dev)
{
return dw1000_read_rxtime_lo((dw1000_dev_instance_t *)dev);
}
inline static uint64_t
uwb_dw1000_read_txtime(struct uwb_dev* dev)
{
return dw1000_read_txtime((dw1000_dev_instance_t *)dev);
}
inline static uint32_t
uwb_dw1000_read_txtime_lo32(struct uwb_dev* dev)
{
return dw1000_read_txtime_lo((dw1000_dev_instance_t *)dev);
}
inline static uint16_t
uwb_dw1000_phy_frame_duration(struct uwb_dev* dev, uint16_t nlen)
{
return dw1000_phy_frame_duration(&dev->attrib, nlen);
}
inline static uint16_t
uwb_dw1000_phy_SHR_duration(struct uwb_dev* dev)
{
return dw1000_phy_SHR_duration(&dev->attrib);
}
inline static void
uwb_dw1000_phy_forcetrxoff(struct uwb_dev* dev)
{
return dw1000_phy_forcetrxoff((dw1000_dev_instance_t *)dev);
}
inline static void
uwb_dw1000_phy_rx_reset(struct uwb_dev* dev)
{
return dw1000_phy_rx_reset((dw1000_dev_instance_t *)dev);
}
inline static struct uwb_dev_status
uwb_dw1000_set_on_error_continue(struct uwb_dev * dev, bool enable)
{
return dw1000_set_on_error_continue((dw1000_dev_instance_t *)dev, enable);
}
inline static void
uwb_dw1000_set_panid(struct uwb_dev * dev, uint16_t pan_id)
{
return dw1000_set_panid((dw1000_dev_instance_t *)dev, pan_id);
}
inline static void
uwb_dw1000_set_uid(struct uwb_dev * dev, uint16_t uid)
{
return dw1000_set_address16((dw1000_dev_instance_t *)dev, uid);
}
inline static void
uwb_dw1000_set_euid(struct uwb_dev * dev, uint64_t euid)
{
return dw1000_set_eui((dw1000_dev_instance_t *)dev, euid);
}
static float
uwb_dw1000_calc_clock_offset_ratio(struct uwb_dev * dev, int32_t val, uwb_cr_types_t type)
{
if (type == UWB_CR_CARRIER_INTEGRATOR) {
return dw1000_calc_clock_offset_ratio((dw1000_dev_instance_t *)dev, val);
} else if (type == UWB_CR_RXTTCKO) {
return dw1000_calc_clock_offset_ratio_ttco((dw1000_dev_instance_t *)dev, val);
}
return 0.0f;
}
inline static float
uwb_dw1000_get_rssi(struct uwb_dev * dev)
{
return dw1000_get_rssi((dw1000_dev_instance_t *)dev);
}
inline static float
uwb_dw1000_get_fppl(struct uwb_dev * dev)
{
return dw1000_get_fppl((dw1000_dev_instance_t *)dev);
}
inline static float
uwb_dw1000_calc_rssi(struct uwb_dev * dev, struct uwb_dev_rxdiag * diag)
{
return dw1000_calc_rssi((dw1000_dev_instance_t *)dev, (struct _dw1000_dev_rxdiag_t*)diag);
}
inline static float
uwb_dw1000_calc_fppl(struct uwb_dev * dev, struct uwb_dev_rxdiag * diag)
{
return dw1000_calc_fppl((dw1000_dev_instance_t *)dev, (struct _dw1000_dev_rxdiag_t*)diag);
}
inline static float
uwb_dw1000_estimate_los(struct uwb_dev * dev, float rssi, float fppl)
{
return dw1000_estimate_los(rssi, fppl);
}
static const struct uwb_driver_funcs dw1000_uwb_funcs = {
.uf_mac_config = uwb_dw1000_mac_config,
.uf_txrf_config = uwb_dw1000_txrf_config,
.uf_sleep_config = uwb_dw1000_sleep_config,
.uf_enter_sleep = uwb_dw1000_enter_sleep,
.uf_enter_sleep_after_tx = uwb_dw1000_enter_sleep_after_tx,
.uf_enter_sleep_after_rx = uwb_dw1000_enter_sleep_after_rx,
.uf_wakeup = uwb_dw1000_wakeup,
.uf_set_dblrxbuf = uwb_dw1000_set_dblrxbuf,
.uf_set_rx_timeout = uwb_dw1000_set_rx_timeout,
.uf_adj_rx_timeout = uwb_dw1000_adj_rx_timeout,
.uf_set_delay_start = uwb_dw1000_set_delay_start,
.uf_start_tx = uwb_dw1000_start_tx,
.uf_start_rx = uwb_dw1000_start_rx,
.uf_stop_rx = uwb_dw1000_stop_rx,
.uf_write_tx = uwb_dw1000_write_tx,
.uf_write_tx_fctrl = uwb_dw1000_write_tx_fctrl,
.uf_hal_noblock_wait = uwb_dw1000_hal_noblock_wait,
.uf_set_wait4resp = uwb_dw1000_set_wait4resp,
.uf_set_wait4resp_delay = uwb_dw1000_set_wait4resp_delay,
.uf_set_rxauto_disable = uwb_dw1000_set_rxauto_disable,
.uf_read_systime = uwb_dw1000_read_systime,
.uf_read_systime_lo32 = uwb_dw1000_read_systime_lo32,
.uf_read_rxtime = uwb_dw1000_read_rxtime,
.uf_read_rxtime_lo32 = uwb_dw1000_read_rxtime_lo32,
.uf_read_txtime = uwb_dw1000_read_txtime,
.uf_read_txtime_lo32 = uwb_dw1000_read_txtime_lo32,
.uf_phy_frame_duration = uwb_dw1000_phy_frame_duration,
.uf_phy_SHR_duration = uwb_dw1000_phy_SHR_duration,
.uf_phy_forcetrxoff = uwb_dw1000_phy_forcetrxoff,
.uf_phy_rx_reset = uwb_dw1000_phy_rx_reset,
.uf_set_on_error_continue = uwb_dw1000_set_on_error_continue,
.uf_set_panid = uwb_dw1000_set_panid,
.uf_set_uid = uwb_dw1000_set_uid,
.uf_set_euid = uwb_dw1000_set_euid,
.uf_calc_clock_offset_ratio = uwb_dw1000_calc_clock_offset_ratio,
.uf_get_rssi = uwb_dw1000_get_rssi,
.uf_get_fppl = uwb_dw1000_get_fppl,
.uf_calc_rssi = uwb_dw1000_calc_rssi,
.uf_calc_fppl = uwb_dw1000_calc_fppl,
.uf_estimate_los = uwb_dw1000_estimate_los,
};
/**
* API to initialize a dw1000_dev_instance_t structure from the os device initialization callback.
*
* @param odev Pointer to struct os_dev.
* @param arg Argument to set as pointer to struct dw1000_dev_cfg.
* @return OS_OK on success
*/
int
dw1000_dev_init(struct os_dev *odev, void *arg)
{
#if MYNEWT_VAL(DW1000_PKG_INIT_LOG)
DIAGMSG("{\"utime\": %lu,\"msg\": \"dw1000_dev_init\"}\n",os_cputime_ticks_to_usecs(os_cputime_get32()));
#endif
/* TODO, replace with open anch close function pointers below */
OS_DEV_SETHANDLERS(odev, 0, 0);
struct dw1000_dev_cfg *cfg = (struct dw1000_dev_cfg*)arg;
struct uwb_dev *udev = (struct uwb_dev*)odev;
dw1000_dev_instance_t *inst = (dw1000_dev_instance_t *)odev;
if (inst == NULL) {
inst = (dw1000_dev_instance_t *) malloc(sizeof(dw1000_dev_instance_t));
assert(inst);
memset(inst,0,sizeof(dw1000_dev_instance_t));
inst->uwb_dev.status.selfmalloc = 1;
udev = (struct uwb_dev*)inst;
}
/* Setup common uwb interface */
udev->uw_funcs = &dw1000_uwb_funcs;
udev->rxdiag = (struct uwb_dev_rxdiag*)&inst->rxdiag;
udev->rxdiag->rxd_len = sizeof(inst->rxdiag);
#if MYNEWT_VAL(CIR_ENABLED)
udev->cir = (struct cir_instance*)inst->cir;
#endif
/* Check size requirements */
assert(sizeof(inst->rxdiag) <= MYNEWT_VAL(UWB_DEV_RXDIAG_MAXLEN));
inst->spi_sem = cfg->spi_sem;
inst->spi_num = cfg->spi_num;
dpl_error_t err = dpl_mutex_init(&inst->mutex);
assert(err == DPL_OK);
err = dpl_sem_init(&inst->tx_sem, 0x1);
assert(err == DPL_OK);
err = dpl_sem_init(&inst->spi_nb_sem, 0x1);
assert(err == DPL_OK);
SLIST_INIT(&inst->uwb_dev.interface_cbs);
return OS_OK;
}
|
willywsm1013/transformers-for-question-generation | question_generation/InferSent/eval.py | import sys
import numpy as np
import os
import re
import json
import logging
from models import InferSent
from tqdm import tqdm
import torch
from argparse import ArgumentParser
parser = ArgumentParser()
parser.add_argument('--golden', help='golden reference sentences')
parser.add_argument('--generated', help='generted sentences')
parser.add_argument('--output_file', help='output file', default=None)
args = parser.parse_args()
# setup logger
logger = logging.getLogger(__name__)
logging.basicConfig(format='%(asctime)s - %(levelname)s - %(name)s - %(message)s',
datefmt='%m/%d/%Y %H:%M:%S',
level=logging.INFO)
# load model
V = 2
MODEL_PATH = 'encoder/infersent%s.pkl' % V
params_model = {'bsize': 64, 'word_emb_dim': 300, 'enc_lstm_dim': 2048,
'pool_type': 'max', 'dpout_model': 0.0, 'version': V}
infersent = InferSent(params_model)
infersent.load_state_dict(torch.load(MODEL_PATH))
if torch.cuda.is_available():
infersent.cuda()
# set word vector
if V == 1:
W2V_PATH = 'Glove/glove.840B.300d.txt'
logger.info('Use Glove Embedding')
elif V ==2 :
W2V_PATH = 'fastText/crawl-300d-2M.vec'
logger.info('Use fastText Embedding')
else:
raise NotImplementedError
infersent.set_w2v_path(W2V_PATH)
# read data
refs = []
with open(args.golden, 'r') as f:
for line in f:
refs.append(line[:-1])
hyps = []
with open(args.generated, 'r') as f:
for line in f:
hyps.append(line[:-1])
# build voceb
infersent.build_vocab(refs+hyps, tokenize=True)
# get embeddings
refs_embeds = infersent.encode(refs, tokenize=True)
hyps_embeds = infersent.encode(hyps, tokenize=True)
# compute cosine similarity
refs_norm = np.linalg.norm(refs_embeds, ord=2, axis=1)
hyps_norm = np.linalg.norm(hyps_embeds, ord=2, axis=1)
cosine = np.sum((refs_embeds*hyps_embeds), axis=1)/refs_norm/hyps_norm
if args.output_file is not None:
with open(args.output_file, 'a') as f:
print(json.dumps({'embedding_cosin':float(np.mean(cosine))}), file=f)
else:
print ('%s,%f'%(sys.argv[1].split('/')[-2], np.mean(cosine)))
'''
# visualize importance
infersent.visualize('A man plays an instrument.', tokenize=True)
'''
|
kaustavha/cs_homeschool | Interviews/solid-fee-calculator-master/js-react/src/components/validSubmission.test.js | import validSubmission from './validSubmission';
import moment from 'moment';
describe("Valid Submission", () => {
const validSelections = [0, 1];
it('Can validate fields', () => {
const input = {
userType: 1,
itemType: 0,
price: 10,
endDate: moment().format("YYYY-MM-DD")
}
let isValid = validSubmission(input, validSelections).isValid;
expect(isValid).toBe(true);
})
it('Can validate fields and detect invalid userType', () => {
const input = {
userType: -1,
itemType: 0,
price: 10,
endDate: moment().format("YYYY-MM-DD")
}
let isValid = validSubmission(input, validSelections).isValid;
expect(isValid).toBe(false);
})
it('Can validate fields and detect invalid itemType', () => {
const input = {
userType: 1,
itemType: -1,
price: 10,
endDate: moment().format("YYYY-MM-DD")
}
let isValid = validSubmission(input, validSelections).isValid;
expect(isValid).toBe(false);
})
it('Can validate fields and detect invalid price', () => {
const input = {
userType: 1,
itemType: 0,
price: "a",
endDate: moment().format("YYYY-MM-DD")
}
let validity = validSubmission(input, validSelections);
expect(validity.isValid).toBe(false);
expect(validity.price).toBe(false);
})
it('Can validate fields and detect invalid date', () => {
const input = {
userType: 1,
itemType: 0,
price: 10,
endDate: "date"
}
let validity = validSubmission(input, validSelections);
expect(validity.isValid).toBe(false);
expect(validity.endDate).toBe(false);
})
})
|
maikroeder/websauna | websauna/system/http/utils.py | from sqlalchemy.orm import Session
from pyramid.interfaces import IRequest
from pyramid.registry import Registry
from pyramid.request import Request
from transaction import TransactionManager
from websauna.system.model.meta import create_dbsession, create_transaction_manager_aware_dbsession
from websauna.compat.typing import Optional
def make_routable_request(dbsession: Optional[Session], registry: Registry, path="/") -> IRequest:
"""Creates a dummy request that has route_url and other routing methods.
As this request does not get HTTP hostname and such stuff from WSGI environment, a configuration variable ``websauna.site_url`` is passed as the base URL.
See also :func:`make_dummy_request`.
:param dbsession: Use existing dbsession or set to ``None`` to generate a new dbsession and transaction manager. None that this TM is not the thread local transaction manager in ``transaction.mananger``.
"""
base_url = registry.settings.get("websauna.site_url", None)
# TODO: Honour request_factory here
request = Request.blank(path, base_url=base_url)
# TODO: do apply_request_extensions()?
request.registry = registry
request.user = None
request.view_name = ''
if dbsession:
# Use the provided dbsession for this request
request.dbsession = dbsession
else:
# Create a new dbsession and transaction manager for this request
tm = TransactionManager()
dbsession = create_dbsession(request.registry, tm)
request.dbsession = dbsession
request.tm = request.transaction_manager = tm
def terminate_session(request):
# Close db session at the end of the request and return the db connection back to the pool
dbsession.close()
request.add_finished_callback(terminate_session)
return request
|
WeixiZhu94/intel-opencl-runtime | opencl/test/unit_test/program/program_with_kernel_debug_tests.cpp | /*
* Copyright (C) 2018-2022 Intel Corporation
*
* SPDX-License-Identifier: MIT
*
*/
#include "shared/test/common/helpers/debug_manager_state_restore.h"
#include "shared/test/common/helpers/kernel_binary_helper.h"
#include "shared/test/common/helpers/kernel_filename_helper.h"
#include "shared/test/common/libult/global_environment.h"
#include "shared/test/common/mocks/mock_source_level_debugger.h"
#include "shared/test/common/test_macros/test.h"
#include "opencl/test/unit_test/fixtures/program_fixture.h"
#include "opencl/test/unit_test/mocks/mock_program.h"
#include "opencl/test/unit_test/program/program_from_binary.h"
#include "opencl/test/unit_test/program/program_tests.h"
#include "compiler_options.h"
#include "gmock/gmock.h"
#include <algorithm>
#include <memory>
#include <string>
#include <vector>
using namespace NEO;
TEST_F(ProgramTests, givenDeafultProgramObjectWhenKernelDebugEnabledIsQueriedThenFalseIsReturned) {
MockProgram program(pContext, false, toClDeviceVector(*pClDevice));
EXPECT_FALSE(program.isKernelDebugEnabled());
}
TEST_F(ProgramTests, givenProgramObjectWhenEnableKernelDebugIsCalledThenProgramHasKernelDebugEnabled) {
MockProgram program(pContext, false, toClDeviceVector(*pClDevice));
program.enableKernelDebug();
EXPECT_TRUE(program.isKernelDebugEnabled());
}
TEST(ProgramFromBinary, givenBinaryWithDebugDataWhenCreatingProgramFromBinaryThenDebugDataIsAvailable) {
if (!defaultHwInfo->capabilityTable.debuggerSupported) {
GTEST_SKIP();
}
std::string filePath;
retrieveBinaryKernelFilename(filePath, "-cl-kernel-debug-enable_", ".bin");
auto device = std::make_unique<MockClDevice>(MockDevice::createWithNewExecutionEnvironment<MockDevice>(nullptr));
auto program = std::make_unique<MockProgram>(toClDeviceVector(*device));
program->enableKernelDebug();
size_t binarySize = 0;
auto pBinary = loadDataFromFile(filePath.c_str(), binarySize);
cl_int retVal = program->createProgramFromBinary(pBinary.get(), binarySize, *device);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_NE(nullptr, program->getDebugData(device->getRootDeviceIndex()));
EXPECT_NE(0u, program->getDebugDataSize(device->getRootDeviceIndex()));
}
class ProgramWithKernelDebuggingTest : public ProgramFixture,
public ::testing::Test {
public:
void SetUp() override {
pDevice = static_cast<MockDevice *>(&mockContext.getDevice(0)->getDevice());
if (!pDevice->getHardwareInfo().capabilityTable.debuggerSupported) {
GTEST_SKIP();
}
std::string filename;
std::string kernelOption(CompilerOptions::debugKernelEnable);
KernelFilenameHelper::getKernelFilenameFromInternalOption(kernelOption, filename);
kbHelper = std::make_unique<KernelBinaryHelper>(filename, false);
CreateProgramWithSource(
&mockContext,
"copybuffer.cl");
pProgram->enableKernelDebug();
}
void TearDown() override {
ProgramFixture::TearDown();
}
std::unique_ptr<KernelBinaryHelper> kbHelper;
MockUnrestrictiveContext mockContext;
MockDevice *pDevice = nullptr;
};
TEST_F(ProgramWithKernelDebuggingTest, givenEnabledKernelDebugWhenProgramIsCompiledThenInternalOptionsIncludeDebugFlag) {
std::string receivedInternalOptions;
auto debugVars = NEO::getFclDebugVars();
debugVars.receivedInternalOptionsOutput = &receivedInternalOptions;
gEnvironment->fclPushDebugVars(debugVars);
cl_int retVal = pProgram->compile(pProgram->getDevices(), nullptr,
0, nullptr, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_TRUE(CompilerOptions::contains(receivedInternalOptions, CompilerOptions::debugKernelEnable)) << receivedInternalOptions;
gEnvironment->fclPopDebugVars();
}
TEST_F(ProgramWithKernelDebuggingTest, givenEnabledKernelDebugWhenProgramIsCompiledThenInternalOptionsIncludeDashGFlag) {
cl_int retVal = pProgram->compile(pProgram->getDevices(), nullptr,
0, nullptr, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_THAT(pProgram->getOptions(), ::testing::HasSubstr("-g"));
}
TEST_F(ProgramWithKernelDebuggingTest, givenEnabledKernelDebugAndOptDisabledWhenProgramIsCompiledThenOptionsIncludeClOptDisableFlag) {
MockActiveSourceLevelDebugger *sourceLevelDebugger = new MockActiveSourceLevelDebugger;
sourceLevelDebugger->isOptDisabled = true;
pDevice->executionEnvironment->rootDeviceEnvironments[pDevice->getRootDeviceIndex()]->debugger.reset(sourceLevelDebugger);
cl_int retVal = pProgram->compile(pProgram->getDevices(), nullptr,
0, nullptr, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_THAT(pProgram->getOptions(), ::testing::HasSubstr(CompilerOptions::optDisable.data()));
}
TEST_F(ProgramWithKernelDebuggingTest, GivenDebugVarDebuggerOptDisableZeroWhenOptDisableIsTrueFromDebuggerThenOptDisableIsNotAdded) {
DebugManagerStateRestore dgbRestorer;
NEO::DebugManager.flags.DebuggerOptDisable.set(0);
MockActiveSourceLevelDebugger *sourceLevelDebugger = new MockActiveSourceLevelDebugger;
sourceLevelDebugger->isOptDisabled = true;
pDevice->executionEnvironment->rootDeviceEnvironments[pDevice->getRootDeviceIndex()]->debugger.reset(sourceLevelDebugger);
cl_int retVal = pProgram->compile(pProgram->getDevices(), nullptr,
0, nullptr, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_THAT(pProgram->getOptions(), ::testing::Not(::testing::HasSubstr(CompilerOptions::optDisable.data())));
}
TEST_F(ProgramWithKernelDebuggingTest, GivenDebugVarDebuggerOptDisableOneWhenOptDisableIsFalseFromDebuggerThenOptDisableIsAdded) {
DebugManagerStateRestore dgbRestorer;
NEO::DebugManager.flags.DebuggerOptDisable.set(1);
MockActiveSourceLevelDebugger *sourceLevelDebugger = new MockActiveSourceLevelDebugger;
sourceLevelDebugger->isOptDisabled = false;
pDevice->executionEnvironment->rootDeviceEnvironments[pDevice->getRootDeviceIndex()]->debugger.reset(sourceLevelDebugger);
cl_int retVal = pProgram->compile(pProgram->getDevices(), nullptr,
0, nullptr, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_THAT(pProgram->getOptions(), ::testing::HasSubstr(CompilerOptions::optDisable.data()));
}
TEST_F(ProgramWithKernelDebuggingTest, givenEnabledKernelDebugWhenProgramIsCompiledThenOptionsStartsWithDashSFilename) {
MockActiveSourceLevelDebugger *sourceLevelDebugger = new MockActiveSourceLevelDebugger;
sourceLevelDebugger->sourceCodeFilename = "debugFileName";
pDevice->executionEnvironment->rootDeviceEnvironments[pDevice->getRootDeviceIndex()]->debugger.reset(sourceLevelDebugger);
cl_int retVal = pProgram->compile(pProgram->getDevices(), nullptr,
0, nullptr, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_THAT(pProgram->getOptions(), ::testing::StartsWith("-s debugFileName"));
}
TEST_F(ProgramWithKernelDebuggingTest, givenEnabledKernelDebugWhenProgramIsCompiledWithCmCOptionThenDashSFilenameIsNotPrepended) {
MockActiveSourceLevelDebugger *sourceLevelDebugger = new MockActiveSourceLevelDebugger;
sourceLevelDebugger->sourceCodeFilename = "debugFileName";
pDevice->executionEnvironment->rootDeviceEnvironments[pDevice->getRootDeviceIndex()]->debugger.reset(sourceLevelDebugger);
char options[] = "-cmc -cl-opt-disable";
cl_int retVal = pProgram->compile(pProgram->getDevices(), options,
0, nullptr, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_THAT(pProgram->getOptions(), ::testing::Not(::testing::StartsWith("-s debugFileName")));
EXPECT_THAT(pProgram->getOptions(), ::testing::HasSubstr(CompilerOptions::optDisable.data()));
}
TEST_F(ProgramWithKernelDebuggingTest, givenEnabledKernelDebugWhenProgramIsBuiltThenInternalOptionsIncludeDebugFlag) {
std::string receivedInternalOptions;
auto debugVars = NEO::getFclDebugVars();
debugVars.receivedInternalOptionsOutput = &receivedInternalOptions;
gEnvironment->fclPushDebugVars(debugVars);
cl_int retVal = pProgram->build(pProgram->getDevices(), nullptr, false);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_TRUE(CompilerOptions::contains(receivedInternalOptions, CompilerOptions::debugKernelEnable)) << receivedInternalOptions;
gEnvironment->fclPopDebugVars();
}
TEST_F(ProgramWithKernelDebuggingTest, givenEnabledKernelDebugWhenProgramIsBuiltThenOptionsIncludeDashGFlag) {
cl_int retVal = pProgram->build(pProgram->getDevices(), nullptr, false);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_THAT(pProgram->getOptions(), ::testing::HasSubstr("-g"));
}
TEST_F(ProgramWithKernelDebuggingTest, givenEnabledKernelDebugAndOptDisabledWhenProgramIsBuiltThenOptionsIncludeClOptDisableFlag) {
MockActiveSourceLevelDebugger *sourceLevelDebugger = new MockActiveSourceLevelDebugger;
sourceLevelDebugger->isOptDisabled = true;
pDevice->executionEnvironment->rootDeviceEnvironments[pDevice->getRootDeviceIndex()]->debugger.reset(sourceLevelDebugger);
cl_int retVal = pProgram->build(pProgram->getDevices(), nullptr, false);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_THAT(pProgram->getOptions(), ::testing::HasSubstr(CompilerOptions::optDisable.data()));
}
TEST_F(ProgramWithKernelDebuggingTest, givenEnabledKernelDebugWhenProgramIsBuiltThenOptionsStartsWithDashSFilename) {
MockActiveSourceLevelDebugger *sourceLevelDebugger = new MockActiveSourceLevelDebugger;
sourceLevelDebugger->sourceCodeFilename = "debugFileName";
pDevice->executionEnvironment->rootDeviceEnvironments[pDevice->getRootDeviceIndex()]->debugger.reset(sourceLevelDebugger);
cl_int retVal = pProgram->build(pProgram->getDevices(), nullptr, false);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_THAT(pProgram->getOptions(), ::testing::StartsWith("-s debugFileName"));
}
TEST_F(ProgramWithKernelDebuggingTest, givenEnabledKernelDebugWhenProgramIsBuiltWithCmCOptionThenDashSFilenameIsNotPrepended) {
MockActiveSourceLevelDebugger *sourceLevelDebugger = new MockActiveSourceLevelDebugger;
sourceLevelDebugger->sourceCodeFilename = "debugFileName";
pDevice->executionEnvironment->rootDeviceEnvironments[pDevice->getRootDeviceIndex()]->debugger.reset(sourceLevelDebugger);
char options[] = "-cmc -cl-opt-disable";
cl_int retVal = pProgram->build(pProgram->getDevices(), options, false);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_THAT(pProgram->getOptions(), ::testing::Not(::testing::StartsWith("-s debugFileName")));
}
TEST_F(ProgramWithKernelDebuggingTest, givenEnabledKernelDebugWhenProgramIsLinkedThenKernelDebugOptionsAreAppended) {
MockActiveSourceLevelDebugger *sourceLevelDebugger = new MockActiveSourceLevelDebugger;
pDevice->executionEnvironment->rootDeviceEnvironments[pDevice->getRootDeviceIndex()]->debugger.reset(sourceLevelDebugger);
cl_int retVal = pProgram->compile(pProgram->getDevices(), nullptr, 0, nullptr, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
auto program = std::unique_ptr<MockProgramAppendKernelDebugOptions>(new MockProgramAppendKernelDebugOptions(&mockContext, false, mockContext.getDevices()));
program->enableKernelDebug();
cl_program clProgramToLink = pProgram;
retVal = program->link(pProgram->getDevices(), nullptr, 1, &clProgramToLink);
EXPECT_EQ(CL_SUCCESS, retVal);
EXPECT_EQ(static_cast<unsigned int>(mockContext.getRootDeviceIndices().size()), program->appendKernelDebugOptionsCalled);
}
TEST_F(ProgramWithKernelDebuggingTest, givenEnabledKernelDebugWhenProgramIsBuiltThenDebuggerIsNotifiedWithKernelDebugData) {
const size_t rootDeviceIndicesSize = mockContext.getRootDeviceIndices().size();
std::vector<MockSourceLevelDebugger *> sourceLevelDebugger(rootDeviceIndicesSize, nullptr);
size_t i = 0;
for (auto &rootDeviceIndex : mockContext.getRootDeviceIndices()) {
sourceLevelDebugger[i] = new MockSourceLevelDebugger(nullptr);
sourceLevelDebugger[i]->setActive(true);
pDevice->executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]->debugger.reset(sourceLevelDebugger[i]);
i++;
}
cl_int retVal = pProgram->build(pProgram->getDevices(), nullptr, false);
EXPECT_EQ(CL_SUCCESS, retVal);
for (auto &el : sourceLevelDebugger) {
EXPECT_EQ(1u, el->isOptimizationDisabledCalled);
EXPECT_EQ(false, el->isOptimizationDisabledResult);
EXPECT_EQ(1u, el->notifySourceCodeCalled);
EXPECT_EQ(false, el->notifySourceCodeResult);
EXPECT_EQ(1u, el->notifyKernelDebugDataCalled);
}
}
TEST_F(ProgramWithKernelDebuggingTest, givenEnabledKernelDebugWhenProgramIsLinkedThenDebuggerIsNotifiedWithKernelDebugData) {
const size_t rootDeviceIndicesSize = mockContext.getRootDeviceIndices().size();
std::vector<MockSourceLevelDebugger *> sourceLevelDebugger(rootDeviceIndicesSize, nullptr);
size_t i = 0;
for (auto &rootDeviceIndex : mockContext.getRootDeviceIndices()) {
sourceLevelDebugger[i] = new MockSourceLevelDebugger(nullptr);
sourceLevelDebugger[i]->setActive(true);
pDevice->executionEnvironment->rootDeviceEnvironments[rootDeviceIndex]->debugger.reset(sourceLevelDebugger[i]);
i++;
}
cl_int retVal = pProgram->compile(pProgram->getDevices(), nullptr,
0, nullptr, nullptr);
EXPECT_EQ(CL_SUCCESS, retVal);
cl_program program = pProgram;
retVal = pProgram->link(pProgram->getDevices(), nullptr,
1, &program);
EXPECT_EQ(CL_SUCCESS, retVal);
for (auto &el : sourceLevelDebugger) {
EXPECT_EQ(2u, el->isOptimizationDisabledCalled);
EXPECT_EQ(false, el->isOptimizationDisabledResult);
EXPECT_EQ(1u, el->notifySourceCodeCalled);
EXPECT_EQ(false, el->notifySourceCodeResult);
EXPECT_EQ(1u, el->notifyKernelDebugDataCalled);
}
}
TEST_F(ProgramWithKernelDebuggingTest, givenProgramWithKernelDebugEnabledWhenBuiltThenPatchTokenAllocateSipSurfaceHasSizeGreaterThanZero) {
auto retVal = pProgram->build(pProgram->getDevices(), CompilerOptions::debugKernelEnable.data(), false);
EXPECT_EQ(CL_SUCCESS, retVal);
auto kernelInfo = pProgram->getKernelInfo("CopyBuffer", pDevice->getRootDeviceIndex());
EXPECT_NE(0u, kernelInfo->kernelDescriptor.kernelAttributes.perThreadSystemThreadSurfaceSize);
}
TEST_F(ProgramWithKernelDebuggingTest, givenGtpinInitializedWhenCreatingProgramFromBinaryThenDebugDataIsAvailable) {
bool gtpinInitializedBackup = NEO::isGTPinInitialized;
NEO::isGTPinInitialized = true;
auto retVal = pProgram->build(pProgram->getDevices(), CompilerOptions::debugKernelEnable.data(), false);
EXPECT_EQ(CL_SUCCESS, retVal);
auto kernelInfo = pProgram->getKernelInfo("CopyBuffer", pDevice->getRootDeviceIndex());
EXPECT_NE(kernelInfo->debugData.vIsa, nullptr);
EXPECT_NE(0u, kernelInfo->debugData.vIsaSize);
NEO::isGTPinInitialized = gtpinInitializedBackup;
}
TEST_F(ProgramWithKernelDebuggingTest, givenGtpinNotInitializedWhenCreatingProgramFromBinaryThenDebugDataINullptr) {
bool gtpinInitializedBackup = NEO::isGTPinInitialized;
NEO::isGTPinInitialized = false;
pProgram->kernelDebugEnabled = false;
auto retVal = pProgram->build(pProgram->getDevices(), CompilerOptions::debugKernelEnable.data(), false);
EXPECT_EQ(CL_SUCCESS, retVal);
auto kernelInfo = pProgram->getKernelInfo("CopyBuffer", pDevice->getRootDeviceIndex());
EXPECT_EQ(kernelInfo->debugData.vIsa, nullptr);
EXPECT_EQ(0u, kernelInfo->debugData.vIsaSize);
NEO::isGTPinInitialized = gtpinInitializedBackup;
}
TEST_F(ProgramWithKernelDebuggingTest, givenKernelDebugEnabledWhenProgramIsBuiltThenDebugDataIsStored) {
auto retVal = pProgram->build(pProgram->getDevices(), nullptr, false);
EXPECT_EQ(CL_SUCCESS, retVal);
auto debugData = pProgram->getDebugData(pDevice->getRootDeviceIndex());
EXPECT_NE(nullptr, debugData);
EXPECT_NE(0u, pProgram->getDebugDataSize(pDevice->getRootDeviceIndex()));
}
TEST_F(ProgramWithKernelDebuggingTest, givenProgramWithKernelDebugEnabledWhenProcessDebugDataIsCalledThenKernelInfosAreFilledWithDebugData) {
auto retVal = pProgram->build(pProgram->getDevices(), nullptr, false);
EXPECT_EQ(CL_SUCCESS, retVal);
pProgram->processDebugData(pDevice->getRootDeviceIndex());
auto kernelInfo = pProgram->getKernelInfo("CopyBuffer", pDevice->getRootDeviceIndex());
EXPECT_NE(0u, kernelInfo->debugData.vIsaSize);
EXPECT_NE(nullptr, kernelInfo->debugData.vIsa);
}
|
felixWackernagel/sidekick-ui | sample/src/main/java/de/wackernagel/android/example/sidekick/ColorsActivity.java | package de.wackernagel.android.example.sidekick;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
public class ColorsActivity extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView( R.layout.activity_colors );
}
}
|
giraffesnn/best-practices-of-c | src/foobar/include/foobar_macros.h | <filename>src/foobar/include/foobar_macros.h
/**
* @file foobar_macros.h
* @author <NAME> (https://github.com/VincentWei)
* @date 2021/09/18
* @brief Some useful macros of FooBar.
*
* Copyright (C) 2021 FMSoft <https://www.fmsoft.cn>
*
* This file is a part of FooBar, which contains the examples of my course:
* _the Best Practices of C Language_.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the “Software”), to
* deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom
* the Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
#ifndef FOOBAR_FOOBAR_MACROS_H
#define FOOBAR_FOOBAR_MACROS_H
#ifndef __has_declspec_attribute
#define __has_declspec_attribute(x) 0
#endif
#undef FOOBAR_EXPORT
#if defined(FOOBAR_NO_EXPORT)
#define FOOBAR_EXPORT
#elif defined(WIN32) || defined(_WIN32) || \
defined(__CC_ARM) || defined(__ARMCC__) || \
(__has_declspec_attribute(dllimport) && __has_declspec_attribute(dllexport))
#if BUILDING_FooBar
#define FOOBAR_EXPORT __declspec(dllexport)
#else
#define FOOBAR_EXPORT __declspec(dllimport)
#endif /* BUILDING_FooBar */
#elif defined(__GNUC__)
#define FOOBAR_EXPORT __attribute__((visibility("default")))
#else /* !defined(FOOBAR_NO_EXPORT) */
#define FOOBAR_EXPORT
#endif /* defined(FOOBAR_NO_EXPORT) */
#if !defined(FOOBAR_INLINE)
#if defined(__cplusplus)
#define FOOBAR_INLINE static inline
#elif defined(__GNUC__)
#define FOOBAR_INLINE static __inline__
#else
#define FOOBAR_INLINE static
#endif
#endif /* !defined(FOOBAR_INLINE) */
#ifndef __has_extension
#define __has_extension(x) 0
#endif
#if __has_extension(enumerator_attributes) && \
__has_extension(attribute_unavailable_with_message)
#define FOOBAR_C_DEPRECATED(message) __attribute__((deprecated(message)))
#else
#define FOOBAR_C_DEPRECATED(message)
#endif
#ifndef __has_attribute
#define __has_attribute(x) 0
#endif
#if __has_attribute(unavailable)
#define FOOBAR_UNAVAILABLE __attribute__((unavailable))
#else
#define FOOBAR_UNAVAILABLE
#endif
#ifdef __cplusplus
#define FOOBAR_EXTERN_C_BEGIN extern "C" {
#define FOOBAR_EXTERN_C_END }
#else
#define FOOBAR_EXTERN_C_BEGIN
#define FOOBAR_EXTERN_C_END
#endif
#define FOOBAR_TABLESIZE(table) (sizeof(table)/sizeof(table[0]))
#endif /* FOOBAR_FOOBAR_MACROS_H */
|
engines/Ax | packages/src/ax-appkit/extension/lib/text.js | ax.extension.lib.text = {};
|
abhi1625/human-detection-perception-module | docs/html/classcpp_1_1ast_1_1_typedef.js | <reponame>abhi1625/human-detection-perception-module
var classcpp_1_1ast_1_1_typedef =
[
[ "__init__", "classcpp_1_1ast_1_1_typedef_af3275d2390190a074de470c1424e05e0.html#af3275d2390190a074de470c1424e05e0", null ],
[ "__str__", "classcpp_1_1ast_1_1_typedef_a451920900affc5f12e38ab8fbf5e3dea.html#a451920900affc5f12e38ab8fbf5e3dea", null ],
[ "IsDefinition", "classcpp_1_1ast_1_1_typedef_a103bf391e665884bfbfd20fc5e6d1a19.html#a103bf391e665884bfbfd20fc5e6d1a19", null ],
[ "IsExportable", "classcpp_1_1ast_1_1_typedef_adee58e4674b049d8e4435b5b6ad8e1d4.html#adee58e4674b049d8e4435b5b6ad8e1d4", null ],
[ "Requires", "classcpp_1_1ast_1_1_typedef_aa9f65f4a97ba340f2c9ebc5e7ce27e8c.html#aa9f65f4a97ba340f2c9ebc5e7ce27e8c", null ],
[ "alias", "classcpp_1_1ast_1_1_typedef_a3187a504dfbefe50b866b44902823c30.html#a3187a504dfbefe50b866b44902823c30", null ]
]; |
jcnaud/snippet | languages/python3/pytest/mymodule.py | #!/usr/bin/env python
# coding: utf-8
import requests
class MyModule(object):
def __init__(self):
pass
def format_message(self, message):
return message+"_format"
def get_url_code(self):
r = requests.get('http://www.example.comdfgfdd/')
return r.status_code |
CGCL-codes/VulDeePecker | CWE-119/source_files/79466/CWE134_Uncontrolled_Format_String__char_console_printf_54c.c | <reponame>CGCL-codes/VulDeePecker<filename>CWE-119/source_files/79466/CWE134_Uncontrolled_Format_String__char_console_printf_54c.c
/* TEMPLATE GENERATED TESTCASE FILE
Filename: CWE134_Uncontrolled_Format_String__char_console_printf_54c.c
Label Definition File: CWE134_Uncontrolled_Format_String.label.xml
Template File: sources-sinks-54c.tmpl.c
*/
/*
* @description
* CWE: 134 Uncontrolled Format String
* BadSource: console Read input from the console
* GoodSource: Copy a fixed string into data
* Sinks: printf
* GoodSink: printf with "%s" as the first argument and data as the second
* BadSink : printf with only data as an argument
* Flow Variant: 54 Data flow: data passed as an argument from one function through three others to a fifth; all five functions are in different source files
*
* */
#include "std_testcase.h"
#ifndef _WIN32
#include <wchar.h>
#endif
#ifndef OMITBAD
/* bad function declaration */
void CWE134_Uncontrolled_Format_String__char_console_printf_54d_badSink(char * data);
void CWE134_Uncontrolled_Format_String__char_console_printf_54c_badSink(char * data)
{
CWE134_Uncontrolled_Format_String__char_console_printf_54d_badSink(data);
}
#endif /* OMITBAD */
#ifndef OMITGOOD
/* goodG2B uses the GoodSource with the BadSink */
void CWE134_Uncontrolled_Format_String__char_console_printf_54d_goodG2BSink(char * data);
void CWE134_Uncontrolled_Format_String__char_console_printf_54c_goodG2BSink(char * data)
{
CWE134_Uncontrolled_Format_String__char_console_printf_54d_goodG2BSink(data);
}
/* goodB2G uses the BadSource with the GoodSink */
void CWE134_Uncontrolled_Format_String__char_console_printf_54d_goodB2GSink(char * data);
void CWE134_Uncontrolled_Format_String__char_console_printf_54c_goodB2GSink(char * data)
{
CWE134_Uncontrolled_Format_String__char_console_printf_54d_goodB2GSink(data);
}
#endif /* OMITGOOD */
|
jjiege/odoo | addons/web/static/src/js/tools/test_menus.js | <filename>addons/web/static/src/js/tools/test_menus.js
(function (exports) {
/**
* The purpose of this test is to click on every installed App and then
* open each view. On each view, click on each filter.
*/
"use strict";
var clientActionCount = 0;
var viewUpdateCount = 0;
var testedApps;
var testedMenus;
function createWebClientHooks() {
var AbstractController = odoo.__DEBUG__.services['web.AbstractController'];
var Discuss = odoo.__DEBUG__.services['mail.Discuss'];
var WebClient = odoo.__DEBUG__.services["web.WebClient"];
WebClient.include({
current_action_updated : function (action, controller) {
this._super(action, controller);
clientActionCount++;
},
});
AbstractController.include({
start: function(){
this.$el.attr('data-view-type', this.viewType);
return this._super();
},
update: function(params, options) {
return this._super(params, options).then(function (){
viewUpdateCount++;
});
},
});
if (Discuss) {
Discuss.include({
_fetchAndRenderThread: function() {
return this._super().then(function (){
viewUpdateCount++;
});
},
});
}
}
function clickEverywhere(){
setTimeout(_clickEverywhere, 1000);
}
// Main function that starts orchestration of tests
function _clickEverywhere(){
console.log("Starting ClickEverywhere test");
var startTime = performance.now()
createWebClientHooks();
testedApps = [];
testedMenus = [];
var isEnterprise = odoo.session_info.server_version_info[5] === 'e';
// finding applications menus
var $listOfAppMenuItems;
if (isEnterprise) {
console.log("Odoo flavor: Enterprise")
var $homeMenu = $("nav.o_main_navbar > a.o_menu_toggle.fa-th");
$homeMenu.click()
$listOfAppMenuItems = $(".o_app, .o_menuitem")
} else {
console.log("Odoo flavor: Community")
$listOfAppMenuItems = $('a.o_app');
}
console.log('Found ', $listOfAppMenuItems.length, 'apps to test');
var testDef = $.when();
testDef = chainDeferred($listOfAppMenuItems, testDef, testApp);
return testDef.then(function() {
console.log("Successfully tested ", testedApps.length, " apps");
console.log("Successfully tested ", testedMenus.length - testedApps.length, " menus");
console.log("ok");
}).always(function() {
console.log("Test took ", (performance.now() - startTime)/1000, " seconds");
}).fail(function () {
console.error("Error !")
});
}
/**
* Test an "App" menu item by orchestrating the following actions:
* 1 - clicking on its menuItem
* 2 - clicking on each view
* 3 - clicking on each menu
* 3.1 - clicking on each view
* @param {DomElement} element: the App menu item
* @returns {Deferred}
*/
function testApp(element){
console.log("Testing app menu:", element.dataset.menuXmlid);
if (testedApps.indexOf(element.dataset.menuXmlid) >= 0) return $.Deferred().resolve(); // Another infinite loop protection
testedApps.push(element.dataset.menuXmlid);
return testMenuItem(element).then(function () {
var $subMenuItems;
$subMenuItems = $('.o_menu_entry_lvl_1, .o_menu_entry_lvl_2, .o_menu_entry_lvl_3, .o_menu_entry_lvl_4');
var testMenuDef = $.when();
testMenuDef = chainDeferred($subMenuItems, testMenuDef, testMenuItem);
return testMenuDef;
}).then(function(){
// no effect in community
var $homeMenu = $("nav.o_main_navbar > a.o_menu_toggle.fa-th");
$homeMenu.click();
});
}
/**
* Test a menu item by:
* 1 - clikcing on the menuItem
* 2 - Orchestrate the view switch
*
* @param {DomElement} element: the menu item
* @returns {Deferred}
*/
function testMenuItem(element){
if (testedMenus.indexOf(element.dataset.menuXmlid) >= 0) return $.Deferred().resolve(); // Avoid infinite loop
console.log("Testing menu", element.innerText.trim(), " ", element.dataset.menuXmlid);
testedMenus.push(element.dataset.menuXmlid);
var startActionCount = clientActionCount;
element.click();
var isModal = false;
return waitForCondition(function() {
// sometimes, the app is just a modal that needs to be closed
var $modal = $('.modal[role="dialog"][open="open"]');
if ($modal.length > 0) {
$modal.modal('hide');
isModal = true;
return true;
};
return startActionCount != clientActionCount;
}).then(function() {
if (!isModal) {
return testFilters();
}
}).then(function () {
if (!isModal) {
return testViews();
}
}).fail(function() {
console.error("Error while testing", element);
});
};
/**
* Orchestrate the test of views
* This function finds the buttons that permit to switch views and orchestrate
* the click on each of them
*/
function testViews() {
var $switches = $("nav.o_cp_switch_buttons > button:not(.active):visible");
var testSwitchDef = $.when();
// chainDeferred($switches, testSwitchDef, testViewSwitch # FIXME
_.each($switches, function(switchButton) {
testSwitchDef = testSwitchDef.then(function () {
// get the view view-type data attribute
return testViewSwitch(switchButton.dataset.viewType);
});
});
return testSwitchDef;
}
/**
* Test a view button
* @param {string} viewType: a string for the view type to test (list, kanban ...)
* @returns {Deferred} a deferred that wait for the view to be loaded
*/
function testViewSwitch(viewType){
console.log("Testing view switch: ", viewType);
// timeout to avoid click debounce
setTimeout(function() {
var $element = $("nav.o_cp_switch_buttons > button[data-view-type=" + viewType + "]");
console.log('Clicking on: ', $element[0].dataset.viewType, ' view switcher');
$element.click();
},250);
var waitViewSwitch = waitForCondition(function(){
return $('.o_content > .o_view_controller').data('view-type') === viewType;
});
return waitViewSwitch.then(function() {
return testFilters();
});
}
/**
* Test filters
* Click on each filter in the control pannel
*/
function testFilters() {
var filterDef = $.when();
// var $filters = $('div.o_control_panel div.btn-group.o_dropdown > ul.o_filters_menu > li:not(.o_add_custom_filter)');
var $filters = $('.o_filters_menu > .o_menu_item')
console.log("Testing " + $filters.length + " filters");
var filter_ids = _.compact(_.map($filters, function(f) { return f.dataset.id}));
_.each(filter_ids, function(filter_id){
filterDef = filterDef.then(function(){
var currentViewCount = viewUpdateCount;
var $filter = $('.o_menu_item[data-id="' + filter_id + '"] a');
// with some customized search views, the filter cannot be found
if ($filter[0] === undefined) {
console.warn('Filter with ID ', filter_id , 'cannot be found');
return $.Deferred().resolve();
};
console.log('Clicking on filter "', $filter.text().trim(), '"');
$filter[0].click();
setTimeout(function() {
var $filterOption = $('.o_menu_item .o_item_option[data-item_id="' + filter_id + '"]:not(.selected) a');
// In case the filter is a date filter, we need to click on the first filter option (like 'today','This week' ...)
if ($filterOption.length > 0) {
console.log('Clicking on filter option "', $filterOption[0], '"');
$filterOption[0].click();
console.log('And now on filter again');
$filter = $('.o_menu_item[data-id="' + filter_id + '"] a');
$filter[0].click(); // To avoid that the next view fold the options
}
}, 250);
return waitForCondition(function() {
return currentViewCount !== viewUpdateCount;
});
});
});
return filterDef;
}
// utility functions
/**
* Wait a certain amount of time for a condition to occur
* @param stopCondition: a function that returns a boolean
* @returns {Deferred} that is rejected if the timeout is exceeded
*/
function waitForCondition(stopCondition) {
var def = $.Deferred();
var interval = 250;
var timeLimit = 15000;
function checkCondition() {
if (stopCondition()) {
def.resolve();
} else {
timeLimit -= interval;
if (timeLimit > 0) {
// recursive call until the resolve or the timeout
setTimeout(checkCondition, interval);
} else {
console.error("Timeout exceeded", stopCondition);
def.reject();
}
}
}
setTimeout(checkCondition, interval);
return def;
};
/**
* chain deferred actions
* @param $elements: a list of jquery elements to be passed as arg to the function
* @param deferred: the deferred on which other deferreds will be chained
* @param f: the function to be deferred
* @returns : the chained deferred
*/
function chainDeferred($elements, deferred, f) {
_.each($elements, function(el) {
deferred = deferred.then(function () {
return f(el);
});
});
return deferred;
}
exports.clickEverywhere = clickEverywhere;
})(window);
|
CherylFrankenfield/newrelic-diagnostics-cli | config/config.go | <gh_stars>0
package config
import (
"encoding/json"
"flag"
"fmt"
"os"
"path/filepath"
"strings"
)
//Verbosity is the current log level
type Verbosity int
const (
//Info indicates normal logging level
Info Verbosity = iota
//Verbose indicates additional logging (for troubleshooting the app)
Verbose
)
//userFlags is a struct containing the commandline arguments passed in at runtime
type userFlags struct {
Verbose bool
Interactive bool
Quiet bool
VeryQuiet bool
Help bool
Version bool
SkipVersionCheck bool
YesToAll bool
ShowOverrideHelp bool
UsageOptOut bool
Proxy string
ProxyUser string
ProxyPassword string
Tasks string
AttachmentKey string
ConfigFile string
Override string
OutputPath string
Filter string
FileUpload string
BrowserURL string
AttachmentEndpoint string
Suites string
InNewRelicCLI bool
}
type ConfigFlag struct {
Name string `json:"name"`
Value interface{} `json:"value"`
}
//MarshalJSON - custom JSON marshaling for this task, we'll strip out the passphrase to keep it only in memory, not on disk
func (f userFlags) MarshalJSON() ([]byte, error) {
proxySpecified := false
if f.Proxy != "" || f.ProxyPassword != "" || f.ProxyUser != "" {
proxySpecified = true
}
return json.Marshal(&struct {
Verbose bool
Quiet bool
VeryQuiet bool
YesToAll bool
ShowOverrideHelp bool
ProxySpecified bool
SkipVersionCheck bool
Tasks string
AttachmentKey string
ConfigFile string
Override string
OutputPath string
Filter string
BrowserURL string
Suites string
}{
Verbose: f.Verbose,
Quiet: f.Quiet,
VeryQuiet: f.VeryQuiet,
YesToAll: f.YesToAll,
ShowOverrideHelp: f.ShowOverrideHelp,
ProxySpecified: proxySpecified,
SkipVersionCheck: f.SkipVersionCheck,
Tasks: f.Tasks,
AttachmentKey: f.AttachmentKey,
ConfigFile: f.ConfigFile,
Override: f.Override,
OutputPath: f.OutputPath,
Filter: f.Filter,
BrowserURL: f.BrowserURL,
Suites: f.Suites,
})
}
//LogLevel is the current log level for output to the screen
var LogLevel Verbosity
//Flags story configuration information
var Flags = userFlags{}
// Version of the application
var Version string
// UsageEndpoint is the haberdasher endpoint to which usage statistics are sent
var UsageEndpoint string
// AttachmentEndpoint is the haberdasher endpoint to which attachments are sent
var AttachmentEndpoint string
// HaberdasherURL is the base url for the Haberdasher service
var HaberdasherURL string
// BuildTimestamp stores when the build was done
var BuildTimestamp string
func ParseFlags() {
// declaring the cmd arg Flags
//
// Define short option with no description, then long option with description
// FOR EXAMPLE:
// "v", false, ""
// "verbose", false, "Display verbose logging during check execution. Off by default"
defaultString := ""
flag.BoolVar(&Flags.Verbose, "v", false, "alias for -verbose")
flag.BoolVar(&Flags.Verbose, "verbose", false, "Display verbose logging during check execution. Off by default")
flag.BoolVar(&Flags.Version, "version", false, "Display current program version. Take precedence over -no-version-check")
flag.BoolVar(&Flags.SkipVersionCheck, "skip-version-check", false, "Skips the automatic check for a newer version of the application.")
flag.StringVar(&Flags.Tasks, "t", defaultString, "alias for -tasks")
flag.StringVar(&Flags.Tasks, "tasks", defaultString, "Specific {name of task} - could be comma separated list and/or contain a wildcard (*)")
flag.StringVar(&Flags.Suites, "s", defaultString, "alias for -suites")
flag.StringVar(&Flags.Suites, "suites", defaultString, "Specific {name of task suite} - could be comma separated list. If you do '-h suites' it will list all diagnostic task suites that can be run.")
flag.StringVar(&Flags.AttachmentKey, "a", defaultString, "alias for -attachment-key")
flag.StringVar(&Flags.AttachmentKey, "attachment-key", defaultString, "Attachment key for automatic upload to a support ticket (get key from an existing ticket).")
flag.BoolVar(&Flags.Help, "h", false, "alias for -help")
flag.BoolVar(&Flags.Help, "help", false, "Displays full list of command line options. If you do '-h tasks' it will list all tasks that can be run.")
flag.StringVar(&Flags.ConfigFile, "c", defaultString, "alias for -config-file")
flag.StringVar(&Flags.ConfigFile, "config-file", defaultString, "Override default config file location. Can be used to specify either a folder to search in addition to the default folders or a specific config file")
flag.StringVar(&Flags.Proxy, "p", defaultString, "alias for -proxy")
flag.StringVar(&Flags.Proxy, "proxy", defaultString, "Proxy should be in the format http(s)://proxyIp:proxyPort Not necessary in most cases… will override config file if used)")
flag.StringVar(&Flags.ProxyUser, "proxy-user", defaultString, "Proxy username, if necessary")
flag.StringVar(&Flags.ProxyPassword, "proxy-pw", defaultString, "Proxy pasword, if necessary")
flag.StringVar(&Flags.Override, "o", defaultString, "alias for -override")
flag.StringVar(&Flags.Override, "override", defaultString, "Specify overrides for detected values. Format <Identifier>.<property>=<value> - example '-o Base/Config/Validate.agentLanguage=PHP'")
flag.StringVar(&Flags.OutputPath, "output-path", filepath.FromSlash("./"), "Output directory for results. Files will be named 'nrdiag-output.json and nrdiag-output.zip.")
flag.BoolVar(&Flags.YesToAll, "y", false, "alias for -yes")
flag.BoolVar(&Flags.YesToAll, "yes", false, "Say 'yes' to any prompt that comes up while running.")
flag.StringVar(&Flags.Filter, "filter", "success,warning,failure,error,info", "Filter results based on status. Accepted values: Success, Warning, Failure, Error, None or Info. Multiple values can be provided in commma separated list. e.g: \"Success,Warning,Failure\"")
flag.BoolVar(&Flags.Quiet, "q", false, "Quiet ouput; only prints the high level results and not the explainatory output. Suppresses file addition warnings if '-y' is also used. Does not contradict '-v'")
flag.BoolVar(&Flags.VeryQuiet, "qq", false, "Very quiet ouput; only prints a single summary line for output (implies '-q'). Suppresses file addition warnings if '-y' is also used. Does not contradict '-v'. Inclusion filters are ignored.")
flag.StringVar(&Flags.FileUpload, "file-upload", defaultString, "File to upload to support ticket, requires running with '-a' option")
flag.StringVar(&Flags.BrowserURL, "browser-url", defaultString, "Specify a URL to check for the presence of a New Relic Browser agent")
flag.BoolVar(&Flags.UsageOptOut, "usage-opt-out", false, "Decline to send anonymous New Relic Diagnostic tool usage data to New Relic for this run")
//if first arg looks like it was build with `go build`, then we are testing against Haberdasher staging or localhost endpoint
if strings.Contains(os.Args[0], "newrelic-diagnostics-cli") {
flag.StringVar(&Flags.AttachmentEndpoint, "attachment-endpoint", defaultString, "The endpoint to send attachments to. (NR ONLY)")
}
flag.Parse()
// Bail early if bad length attachment key provided.
if Flags.AttachmentKey != "" && len(Flags.AttachmentKey) < 32 {
fmt.Printf("Invalid attachment key '%s' length: %d\n", Flags.AttachmentKey, len(Flags.AttachmentKey))
fmt.Println("The 32 character Diagnostics CLI Attachment Key can be found upper-right of your ticket on support.newrelic.com")
os.Exit(1)
}
if Flags.VeryQuiet {
Flags.Quiet = true
//pseudo-filter to force everything to display
Flags.Filter = ""
}
//This has to be in the config init otherwise you don't get logs as expected
if Flags.Verbose {
LogLevel = Verbose
} else {
LogLevel = Info
}
if Flags.BrowserURL != "" {
Flags.Override = "Browser/Agent/GetSource.url=" + Flags.BrowserURL + "," + Flags.Override
Flags.Tasks = "Browser/Agent/Detect," + Flags.Tasks
}
Flags.InNewRelicCLI = (os.Getenv("NEWRELIC_CLI_SUBPROCESS") != "")
}
// UsagePayload gathers and sanitizes user command line input
// A map with string keys and interface values is returned
// The interface values will contain either a boolean or a string
func (f userFlags) UsagePayload() []ConfigFlag {
return []ConfigFlag{
ConfigFlag{Name: "verbose", Value: f.Verbose},
ConfigFlag{Name: "interactive", Value: f.Interactive},
ConfigFlag{Name: "quiet", Value: f.Quiet},
ConfigFlag{Name: "veryQuiet", Value: f.VeryQuiet},
ConfigFlag{Name: "help", Value: f.Help},
ConfigFlag{Name: "version", Value: f.Version},
ConfigFlag{Name: "yesToAll", Value: f.YesToAll},
ConfigFlag{Name: "showOverrideHelp", Value: f.ShowOverrideHelp},
ConfigFlag{Name: "proxy", Value: boolifyFlag(f.Proxy)},
ConfigFlag{Name: "proxyUser", Value: boolifyFlag(f.ProxyUser)},
ConfigFlag{Name: "proxyPassword", Value: boolifyFlag(f.ProxyPassword)},
ConfigFlag{Name: "tasks", Value: f.Tasks},
ConfigFlag{Name: "attachmentKey", Value: f.AttachmentKey},
ConfigFlag{Name: "configFile", Value: boolifyFlag(f.ConfigFile)},
ConfigFlag{Name: "override", Value: boolifyFlag(f.Override)},
ConfigFlag{Name: "outputPath", Value: boolifyFlag(f.OutputPath)},
ConfigFlag{Name: "filter", Value: f.Filter},
ConfigFlag{Name: "fileUpload", Value: boolifyFlag(f.FileUpload)},
ConfigFlag{Name: "browserURL", Value: boolifyFlag(f.BrowserURL)},
ConfigFlag{Name: "attachmentEndpoint", Value: boolifyFlag(f.AttachmentEndpoint)},
ConfigFlag{Name: "suites", Value: f.Suites},
}
}
// boolifyFlag is a helper function for falsey/truthy conversion of UserFlag strings
func boolifyFlag(inputFlag string) bool {
if inputFlag == "" {
return false
}
return true
}
// IsForcedTask returns true if the supplied task (identifier) was supplied in the
// -t command line argument.
func (f userFlags) IsForcedTask(identifier string) bool {
identifiers := strings.Split(f.Tasks, ",")
for _, ident := range identifiers {
trimmedIdentifer := strings.TrimSpace(ident)
if strings.ToLower(identifier) == strings.ToLower(trimmedIdentifer) {
return true
}
}
return false
}
|
fabriziogiudici/thesefoolishthings-src | modules/examples/Data/src/main/java/it/tidalwave/thesefoolishthings/examples/person/Person.java | /*
* *********************************************************************************************************************
*
* TheseFoolishThings: Miscellaneous utilities
* http://tidalwave.it/projects/thesefoolishthings
*
* Copyright (C) 2009 - 2021 by Tidalwave s.a.s. (http://tidalwave.it)
*
* *********************************************************************************************************************
*
* 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.
*
* *********************************************************************************************************************
*
* git clone https://bitbucket.org/tidalwave/thesefoolishthings-src
* git clone https://github.com/tidalwave-it/thesefoolishthings-src
*
* *********************************************************************************************************************
*/
package it.tidalwave.thesefoolishthings.examples.person;
import javax.annotation.Nonnull;
import javax.annotation.concurrent.Immutable;
import java.util.UUID;
import it.tidalwave.util.Id;
import lombok.AllArgsConstructor;
import lombok.Getter;
/***********************************************************************************************************************
*
* @author <NAME>
*
**********************************************************************************************************************/
@Immutable @AllArgsConstructor @Getter
public class Person
{
@Nonnull
public static Person prototype()
{
return new Person("", "");
}
public Person (@Nonnull final String firstName, @Nonnull final String lastName)
{
this(Id.of(UUID.randomUUID().toString()), firstName, lastName);
}
final Id id;
@Nonnull
final String firstName;
@Nonnull
final String lastName;
@Override @Nonnull
public String toString()
{
return firstName + " " + lastName;
}
}
|
christophe-rannou/ovh-api-services | src/api/me/order/me-order.v7.service.js | <reponame>christophe-rannou/ovh-api-services
angular.module('ovh-api-services').service('OvhApiMeOrderV7', (apiv7) => {
const userOrderEndpoint = apiv7('/me/order/:orderId', {
orderId: '@orderId',
});
return userOrderEndpoint;
});
|
Madrapps/dagger-plugin | src/test/testData/component/InterfaceOrAbstract/ClassComponentWithModuleFullAnnotation.java | <filename>src/test/testData/component/InterfaceOrAbstract/ClassComponentWithModuleFullAnnotation.java
import assets.EmptyModuleOne;
@<error descr="@Component may only be applied to an interface or abstract class">dagger.Component</error>(modules = {EmptyModuleOne.class})
public class ClassComponentWithModuleFullAnnotation {
}
|
uporabnik1/VoltaDiscord-Musicbot | VoltaDiscordUkazi/commands/spletisce.js | exports.run = async(client, message) => {
message.channel.send({
embed: {
title: 'Naša spletna stran:',
description: `
https://voltamedia.tk/
`,
color: 'ORANGE'
}
})
} |
daiyi/trustroots | modules/tags/server/models/tag.server.model.js | <gh_stars>0
'use strict';
/**
* Module dependencies.
*/
var path = require('path'),
config = require(path.resolve('./config/config')),
mongoose = require('mongoose'),
mongoosePaginate = require('mongoose-paginate'),
uniqueValidation = require('mongoose-beautiful-unique-validation'),
integerValidator = require('mongoose-integer'),
urlslugs = require('mongoose-url-slugs'),
randomColor = require('randomcolor'),
speakingurl = require('speakingurl'),
validator = require('validator'),
Schema = mongoose.Schema;
/**
* Return random dark hex color without leading `#`
*/
function randomHex() {
return randomColor({
luminosity: 'dark',
format: 'hex'
}).substr(1);
}
/**
* A Validation function for `TagSchema.label`
* - should contain at least one a-zA-Z character
* - not in list of illegal labels
* - not begin or end with "."
*/
var validateLabel = function(label) {
return (label &&
label.match(/[a-z]/) && // Should have at least one a-zA-Z (non case-insensitive regex)
config.illegalStrings.indexOf(label.trim().toLowerCase()) < 0 &&
label.charAt(0) !== '.' && // Don't start with `.`
label.slice(-1) !== '.' // Don't end with `.`
);
};
/**
* Validation function for `TagSchema.attribution_url`
* @link https://www.npmjs.com/package/validator#validators
*/
var validateURL = function(url) {
return !url || validator.isURL(url, {
protocols: ['http', 'https'],
require_tld: true,
require_protocol: true,
require_valid_protocol: true,
allow_underscores: false,
allow_trailing_dot: false,
allow_protocol_relative_urls: false
});
};
/**
* Validation function for `TagSchema.image_UUID`
* Uses UUID version v4
* @link https://en.wikipedia.org/wiki/Universally_unique_identifier#Variants_and_Versions
* @link https://www.npmjs.com/package/validator#validators
*/
var validateUUID = function(uuid) {
return !uuid || validator.isUUID(uuid, 4);
};
/**
* Tag Schema
*/
var TagSchema = new Schema({
label: {
type: String,
minlength: 2,
maxlength: 255,
trim: true,
required: true,
unique: 'Tag exists already.',
validate: [validateLabel, 'Please fill a valid name.']
},
labelHistory: {
type: [String]
},
slugHistory: {
type: [String]
},
synonyms: {
type: [String]
},
tribe: {
type: Boolean,
default: false,
required: true
},
color: {
type: String,
minlength: 6,
maxlength: 6,
required: true,
default: randomHex
},
count: {
type: Number,
integer: true,
min: 0,
default: 0,
required: true
},
created: {
type: Date,
default: Date.now,
required: true
},
modified: {
type: Date
},
public: {
type: Boolean,
default: true,
required: true
},
image_UUID: {
type: String,
validate: [validateUUID, 'Please use valid UUID.']
},
attribution: {
type: String,
minlength: 3,
maxlength: 255
},
attribution_url: {
type: String,
minlength: 12,
trim: true,
validate: [validateURL, 'Please fill a valid URL.']
},
description: {
type: String,
trim: true
}
});
/**
* Inserts `slug` field to schema and automatically generates unique slug from `label` field.
* @link https://www.npmjs.com/package/mongoose-url-slugs
*
* Uses `speakingurl` package to generate slugs.
* @link https://npmjs.org/package/speakingurl
* @link https://github.com/mindblaze/mongoose-url-slugs/issues/17
*/
TagSchema.plugin(urlslugs('label', {
field: 'slug',
generator: function(string) {
return speakingurl(string, {
separator: '-', // char that replaces the whitespaces
maintainCase: false, // maintain case (true, convert all chars to lower case (false)
truncate: 255 // trim to max length ({number}), don't truncate (0)
});
}
}));
/**
* Make sure unique fields yeld verbal errors
* @link https://www.npmjs.com/package/mongoose-beautiful-unique-validation
*/
TagSchema.plugin(uniqueValidation);
/**
* Validate Integers
* @link https://www.npmjs.com/package/mongoose-integer
*/
TagSchema.plugin(integerValidator);
/**
* Indexing
*/
TagSchema.index({ slug: 1, label: 1 });
/**
* Pagination (together with `paginate-express`)
*/
TagSchema.plugin(mongoosePaginate);
mongoose.model('Tag', TagSchema);
|
strataproject/strata | src/components/animatedMobileMenu/MenuToggle.css.js | <filename>src/components/animatedMobileMenu/MenuToggle.css.js
import styled from 'styled-components'
export const MenuToggleButton = styled.button`
outline: none;
border: none;
-webkit-user-select: none;
-moz-user-select: none;
-ms-user-select: none;
cursor: pointer;
line-height: 0px;
width: 43px;
height: 43px;
border-radius: 50%;
background: transparent;
padding: 0px;
margin-top: -3px;
`
|
gis-zhang/zgis | Gruntfile.js | <gh_stars>0
/**
* Created by Administrator on 2015/10/23.
*/
module.exports = function(grunt) {
grunt.file.defaultEncoding = 'utf-8';
grunt.initConfig({
concat: {
dist: {
src: ['src/zmap/framework/base/*.js',
'src/zmap/framework/*.js',
'src/zmap/config/**/*.js',
'src/zmap/core/config/*.js',
'src/zmap/core/geometry/*.js',
'src/zmap/core/feature/*.js',
'src/zmap/core/crs/*.js',
'src/zmap/core/interface/*.js',
'src/zmap/core/popup/*.js',
'src/zmap/core/symbol/*.js',
'src/zmap/core/graphic/*.js',
'src/zmap/core/layer/*.js',
'src/zmap/core/scene/*.js',
'src/zmap/core/*.js',
'src/zmap/component/**/*.js'],
dest: 'dist/zmap-release.js'
},
//mapViewDist: {
// src: ['src/cdc/*.js'],
// dest: 'dist/mapview-release.js'
//},
threeLib: {
src: ['src/lib/threejs_new2/three.js',
'src/lib/threejs/ConvexGeometry.js',
//'src/lib/threebsp/ThreeBSP.js',
'src/lib/threebsp/index.js',
'src/lib/threejs-ext/loaders/DDSLoader.js',
'src/lib/threejs-ext/loaders/MTLLoader.js',
'src/lib/threejs-ext/loaders/OBJLoader.js',
'src/lib/threejs-ext/shaders/SSAOShader.js',
'src/lib/threejs-ext/shaders/CopyShader.js',
'src/lib/threejs-ext/shaders/SMAAShader.js',
'src/lib/threejs-ext/postprocessing/EffectComposer.js',
'src/lib/threejs-ext/postprocessing/RenderPass.js',
'src/lib/threejs-ext/postprocessing/ShaderPass.js',
'src/lib/threejs-ext/postprocessing/MaskPass.js',
'src/lib/threejs-ext/postprocessing/SSAOPass.js',
'src/lib/threejs-ext/postprocessing/SMAAPass.js'],
dest: 'dist/three-lib.js'
},
zmap_all_in_one: {
src: [ 'src/lib/stats.min.js',
'dist/three-lib.js',
'src/lib/jszip/zip/jszip.min.js',
'src/lib/jszip/zipu/jszip-utils.js',
'dist/zmap-release.js'//,
//'dist/mapview-release.js'
],
dest: 'dist/zmap_all_in_one.js'
},
css: {
//src: ['src/zmap/css/*.css', 'src/cdc/css/*.css'],
src: ['src/zmap/css/*.css'],
dest: 'dist/zmap.css'
}
},
uglify: {
beautify: {
//����ascii�����dz����ã���ֹ���������������
ascii_only: true
},
//build: {
// src: 'dist/zmap-release.js',
// dest: 'dist/zmap-release.min.js'
//}
buildZMap: {
src: 'dist/zmap-release.js',
dest: 'dist/zmap-release.min.js'
},
//buildMapView: {
// src: 'dist/mapview-release.js',
// dest: 'dist/mapview-release.min.js'
//},
buildAllInOne: {
src: 'dist/zmap_all_in_one.js',
dest: 'dist/zmap_all_in_one.min.js'
}
},
watch: {
files: ['<%= concat.dist.src %>'],
tasks: ['concat']
}
});
grunt.loadNpmTasks('grunt-contrib-concat');
grunt.loadNpmTasks('grunt-contrib-uglify');
grunt.loadNpmTasks('grunt-contrib-watch');
grunt.registerTask('default', ['concat', 'uglify']);
//grunt.registerTask('default', ['concat']);
grunt.registerTask('buildZMap', ['uglify:buildZMap']);
//grunt.registerTask('buildMapView', ['uglify:buildMapView']);
};
|
nbur4556/issue_reporter | cypress/integration/navigation.spec.js | describe('Url Navigation Authorized', () => {
afterEach(() => cy.logout());
// Should equal root url
it('visit landing url', () => {
cy.visit('/');
cy.url().should('eq', Cypress.config().baseUrl + '/');
})
// Should equal workbench url
it('visit workbench url', () => {
cy.login().then(() => {
cy.visit('/workbench');
cy.url().should('eq', Cypress.config().baseUrl + '/workbench');
})
});
});
describe('Url Navigation Unauthorized', () => {
beforeEach(() => cy.logout());
// All should equal base url
it('attempt visit workbench url', () => {
cy.visit('/workbench');
cy.url().should('eq', Cypress.config().baseUrl + '/');
});
});
describe('Link Navigation', () => {
beforeEach(() => cy.login());
afterEach(() => cy.logout());
it('dashboard logout link', () => {
cy.visit('/workbench');
cy.get('button[data-cy="logoutButton"]').click();
cy.url().should('eq', Cypress.config().baseUrl + '/');
});
}); |
rnpoddor/metadata.js | src/widgets/wnd_obj.js | /**
* Форма абстрактного объекта данных {{#crossLink "DataObj"}}{{/crossLink}}, в том числе, записей регистров
*
* © <NAME> http://www.oknosoft.ru 2014-2016
*
* @module metadata
* @submodule wnd_obj
*/
/**
* ### Форма объекта данных
* По умолчанию, форма строится автоматически по описанию метаданных.<br />
* Метод можно переопределить для конкретного менеджера
*
* @method form_obj
* @for DataManager
* @param pwnd {dhtmlXWindows} - указатель на родительскую форму
* @param attr {Object|DataObj|String} - параметры инициализации формы
*/
DataManager.prototype.form_obj = function(pwnd, attr){
var _mgr = this,
_meta = _mgr.metadata(),
o = attr.o,
wnd, options, created, create_id, _title;
/**
* ПриСозданииНаСервере - инициализация при создании формы, до чтения объекта
*/
function frm_create(){
if(created)
return;
// создаём и настраиваем окно формы
if((pwnd instanceof dhtmlXLayoutCell || pwnd instanceof dhtmlXSideBarCell || pwnd instanceof dhtmlXCarouselCell)
&& (attr.bind_pwnd || attr.Приклеить)) {
// форма объекта приклеена к области контента или другой форме
if(typeof pwnd.close == "function")
pwnd.close(true);
wnd = pwnd;
wnd.close = function (on_create) {
var _wnd = wnd || pwnd;
if(on_create || check_modified()){
if(_wnd){
// выгружаем попапы
if(_wnd.elmnts)
["vault", "vault_pop"].forEach(function (elm) {
if (_wnd.elmnts[elm] && _wnd.elmnts[elm].unload)
_wnd.elmnts[elm].unload();
});
// информируем мир о закрытии формы
if(_mgr && _mgr.class_name)
$p.eve.callEvent("frm_close", [_mgr.class_name, (o && o._obj ? o.ref : "")]);
if(_wnd.conf){
_wnd.detachToolbar();
_wnd.detachStatusBar();
_wnd.conf.unloading = true;
_wnd.detachObject(true);
}
}
frm_unload(on_create);
}
};
wnd.elmnts = {grids: {}};
}else{
// форма в модальном диалоге
options = {
name: 'wnd_obj_' + _mgr.class_name,
wnd: {
top: 80 + Math.random()*40,
left: 120 + Math.random()*80,
width: 700,
height: 400,
modal: true,
center: false,
pwnd: pwnd,
allow_close: true,
allow_minmax: true,
on_close: frm_close,
caption: (_meta.obj_presentation || _meta.synonym)
}
};
wnd = $p.iface.dat_blank(null, options.wnd);
}
if(!wnd.ref)
wnd.__define({
/**
* Возвращает ссылку текущего объекта
*/
ref: {
get: function(){
return o ? o.ref : $p.utils.blank.guid;
},
enumerable: false,
configurable: true
},
/**
* Обновляет текст заголовка формы
*/
set_text: {
value: function(force) {
if(attr && attr.set_text || wnd && wnd.setText){
var title = o.presentation;
if(!title)
return;
if(o instanceof CatObj){
title = (_meta.obj_presentation || _meta.synonym) + ': ' + title;
}
if(force || _title !== title){
_title = title;
attr.set_text ? attr.set_text(title) : wnd.setText(title);
}
}
},
enumerable: false,
configurable: true
}
});
/**
* Закладки: шапка и табличные части
*/
wnd.elmnts.frm_tabs = wnd.attachTabbar({
arrows_mode: "auto",
offsets: {
top: 0,
right: 0,
bottom: 0,
left: 0
}
});
wnd.elmnts.frm_tabs.addTab('tab_header',' Реквизиты ', null, null, true);
wnd.elmnts.tabs = {'tab_header': wnd.elmnts.frm_tabs.cells('tab_header')};
// панель инструментов формы
wnd.elmnts.frm_toolbar = wnd.attachToolbar();
wnd.elmnts.frm_toolbar.setIconsPath(dhtmlx.image_path + 'dhxtoolbar' + dhtmlx.skin_suffix());
wnd.elmnts.frm_toolbar.loadStruct(attr.toolbar_struct || $p.injected_data["toolbar_obj.xml"], function(){
// если мы приклеены к ячейке, сдвигаем toolbar на 4px
// if(wnd === pwnd)
// this.cont.style.top = "4px";
this.addSpacer("btn_unpost");
this.attachEvent("onclick", attr.toolbar_click || toolbar_click);
// учтём права для каждой роли на каждый объект
var _acl = $p.current_user.get_acl(_mgr.class_name);
if(_mgr instanceof DocManager && _acl.indexOf("p") != -1){
this.enableItem("btn_post");
if(!attr.toolbar_struct)
this.setItemText("btn_save_close", "<b>Провести и закрыть</b>");
}else
this.hideItem("btn_post");
if(_mgr instanceof DocManager && _acl.indexOf("o") != -1)
this.enableItem("btn_unpost");
else
this.hideItem("btn_unpost");
if(_acl.indexOf("e") == -1){
this.hideItem("btn_save_close");
this.disableItem("btn_save");
}
if(attr.on_select)
this.setItemText("btn_save_close", "Записать и выбрать");
// для ссылочных типов
if(_mgr instanceof CatManager || _mgr instanceof DocManager){
// добавляем команды печати
_mgr.printing_plates().then(function (pp) {
for(var pid in pp)
wnd.elmnts.frm_toolbar.addListOption("bs_print", pid, "~", "button", pp[pid].toString());
});
// попап для присоединенных файлов
wnd.elmnts.vault_pop = new dhtmlXPopup({
toolbar: this,
id: "btn_files"
});
wnd.elmnts.vault_pop.attachEvent("onShow", show_vault);
}else
this.disableItem("bs_print");
// кнопка закрытия для приклеенной формы
if(wnd != pwnd){
this.hideItem("btn_close");
}
});
created = true;
}
/**
* Наблюдатель за изменением объекта
* Пока здесь только установка заголовка формы
* @param changes
*/
function listener(obj, fields) {
if(wnd && wnd.set_text && ((obj === o) || (obj._owner && obj._owner._owner === o))){
wnd.set_text();
}
}
/**
* ПриЧтенииНаСервере - инициализация при чтении объекта
*/
function frm_fill(){
if(!created){
clearTimeout(create_id);
frm_create();
}
/**
* Устанавливаем текст заголовка формы
*/
wnd.set_text();
if(!attr.hide_header && wnd.showHeader){
wnd.showHeader();
}
/**
* закладки табличных частей
*/
if(attr.draw_tabular_sections)
attr.draw_tabular_sections(o, wnd, tabular_init);
else if(!o.is_folder){
if(_meta.form && _meta.form.obj && _meta.form.obj.tabular_sections_order)
_meta.form.obj.tabular_sections_order.forEach(function (ts) {
tabular_init(ts);
});
else
for(var ts in _meta.tabular_sections){
if(ts==="extra_fields")
continue;
if(o[ts] instanceof TabularSection){
// настройка табличной части
tabular_init(ts);
}
}
}
/**
* закладка шапка
*/
if(attr.draw_pg_header)
attr.draw_pg_header(o, wnd);
else{
// учтём права для каждой роли на каждый объект
var _acl = $p.current_user.get_acl(_mgr.class_name);
wnd.elmnts.pg_header = wnd.elmnts.tabs.tab_header.attachHeadFields({
obj: o,
pwnd: wnd,
read_only: _acl.indexOf("e") == -1
});
wnd.attachEvent("onResizeFinish", function(win){
wnd.elmnts.pg_header.enableAutoHeight(false, wnd.elmnts.tabs.tab_header._getHeight()-20, true);
});
}
/**
* начинаем следить за объектом
*/
_mgr.on({
update: listener,
rows: listener,
});
return {wnd: wnd, o: o};
}
/**
* обработчик нажатия кнопок командных панелей
*/
function toolbar_click(btn_id){
if(btn_id=="btn_save_close"){
save("close");
}
else if(btn_id=="btn_save"){
save("save");
}
else if(btn_id=="btn_post"){
save("post");
}
else if(btn_id=="btn_unpost"){
save("unpost");
}
else if(btn_id=="btn_close"){
wnd.close();
}
else if(btn_id=="btn_go_connection"){
go_connection();
}
else if(btn_id.substr(0,4)=="prn_"){
_mgr.print(o, btn_id, wnd);
}
else if(btn_id=="btn_import"){
_mgr.import(null, o);
}
else if(btn_id=="btn_export"){
_mgr.export({items: [o], pwnd: wnd, obj: true} );
}
}
/**
* показывает список связанных документов
*/
function go_connection(){
$p.msg.show_not_implemented();
}
/**
* создаёт и показывает диалог присоединенных файлов
*/
function show_vault(){
if (!wnd.elmnts.vault) {
wnd.elmnts.vault = wnd.elmnts.vault_pop.attachVault(400, 250, {
_obj: o,
buttonClear: false,
autoStart: true,
filesLimit: 10,
mode: "pouch"
});
wnd.elmnts.vault.conf.wnd = wnd;
}
}
/**
* настройка (инициализация) табличной части
*/
function tabular_init(name, toolbar_struct, footer){
// с помощью метода ts_captions(), выясняем, надо ли добавлять данную ТЧ и формируем описание колонок табчасти
if(!_md.ts_captions(_mgr.class_name, name))
return;
// закладка табов табличной части
wnd.elmnts.frm_tabs.addTab('tab_'+name, ' '+_meta.tabular_sections[name].synonym+' ');
wnd.elmnts.tabs['tab_'+name] = wnd.elmnts.frm_tabs.cells('tab_'+name);
// учтём права для каждой роли на каждый объект
var _acl = $p.current_user.get_acl(_mgr.class_name);
wnd.elmnts.grids[name] = wnd.elmnts.tabs['tab_'+name].attachTabular({
obj: o,
ts: name,
pwnd: wnd,
read_only: _acl.indexOf("e") == -1,
toolbar_struct,
footer
});
if(_acl.indexOf("e") == -1){
var tabular = wnd.elmnts.tabs['tab_'+name].getAttachedToolbar();
tabular.disableItem("btn_add");
tabular.disableItem("btn_delete");
}
}
/**
* действия при записи файла
* @param action
*/
function save(action){
wnd.progressOn();
var post;
if(o instanceof DocObj){
if(action == "post")
post = true;
else if(action == "unpost")
post = false;
else if(action == "close"){
if($p.current_user.get_acl(_mgr.class_name).indexOf("p") != -1)
post = true;
}
}
o.save(post)
.then(function(){
wnd.progressOff();
if(action == "close"){
if(attr.on_select)
attr.on_select(o);
wnd.close();
}else
wnd.set_text();
})
.catch(function(err){
wnd.progressOff();
if(err instanceof Error)
$p.record_log(err);
});
}
/**
* освобождает переменные после закрытия формы
*/
function frm_unload(on_create){
if(attr && attr.on_close && !on_create){
attr.on_close();
}
if(!on_create){
if(_mgr){
_mgr.off('update', listener);
_mgr.off('rows', listener);
}
if(wnd){
delete wnd.ref;
delete wnd.set_text;
}
_mgr = wnd = o = _meta = options = pwnd = attr = null;
}
}
/**
* Задаёт вопрос о записи изменений и делает откат при необходимости
*/
function check_modified() {
if(o && o._modified && !wnd.close_confirmed){
dhtmlx.confirm({
title: o.presentation,
text: $p.msg.modified_close,
cancel: $p.msg.cancel,
callback: function(btn) {
if(btn){
wnd.close_confirmed = true;
// закрыть изменённый без сохранения - значит прочитать его из pouchdb
if(o._manager.cachable == "ram"){
this.close && this.close();
}
else{
if(o.is_new()){
o.unload();
this.close && this.close();
}
else{
setTimeout(o.load.bind(o), 100);
this.close && this.close();
}
}
}
}.bind(wnd)
});
return false;
}
return true;
}
function frm_close(wnd){
if(check_modified()){
setTimeout(frm_unload);
// выгружаем попапы
if(wnd && wnd.elmnts)
["vault", "vault_pop"].forEach(function (elm) {
if (wnd.elmnts[elm] && wnd.elmnts[elm].unload)
wnd.elmnts[elm].unload();
});
// информируем мир о закрытии формы
if(_mgr && _mgr.class_name)
$p.eve.callEvent("frm_close", [_mgr.class_name, (o && o._obj ? o.ref : "")]);
return true;
}
}
// (пере)создаём статическую часть формы
create_id = setTimeout(frm_create);
// читаем объект из локального SQL или получаем с сервера
if($p.utils.is_data_obj(o)){
if(o.is_new() && attr.on_select){
return _mgr.create({}, true)
.then(function (tObj) {
o = tObj;
tObj = null;
return frm_fill();
});
}
else if(o.is_new() && !o.empty()){
return o.load()
.then(frm_fill);
}else
return Promise.resolve(frm_fill());
}
else{
pwnd && pwnd.progressOn && pwnd.progressOn();
return _mgr.get(attr.hasOwnProperty("ref") ? attr.ref : attr, true, true)
.then(function(tObj){
o = tObj;
tObj = null;
if(pwnd && pwnd.progressOff)
pwnd.progressOff();
return frm_fill();
})
.catch(function (err) {
if(pwnd && pwnd.progressOff)
pwnd.progressOff();
wnd.close();
$p.record_log(err);
});
}
};
/**
* ### Форма объекта данных
* По умолчанию, форма строится автоматически по описанию метаданных.<br />
* Метод можно переопределить для конкретного менеджера
*
* @method form_obj
* @for DataObj
* @param pwnd {dhtmlXWindows} - указатель на родительскую форму
* @param attr {Object} - параметры инициализации формы
*/
DataObj.prototype.form_obj = function (pwnd, attr) {
if(!attr)
attr = {};
attr.o = this;
return this._manager.form_obj(pwnd, attr);
};
|
ch1huizong/learning | lang/py/cookbook/v2/source/cb2_2_23_sol_1.py | try:
from msvcrt import getch
except ImportError:
''' we're not on Windows, so we try the Unix-like approach '''
def getch():
import sys, tty, termios
fd = sys.stdin.fileno()
old_settings = termios.tcgetattr(fd)
try:
tty.setraw(fd)
ch = sys.stdin.read(1)
finally:
termios.tcsetattr(fd, termios.TCSADRAIN, old_settings)
return ch
|
sawthiriaung/MyLanguage2 | MvvmTestAbank/app/src/main/java/com/nmh/speaktotext/mvvmtestabank/ui/repo/RepoItemViewModel.java | <reponame>sawthiriaung/MyLanguage2
package com.nmh.speaktotext.mvvmtestabank.ui.repo;
import android.databinding.ObservableField;
import com.nmh.speaktotext.mvvmtestabank.model.Repository;
public class RepoItemViewModel {
public final ObservableField<String> name ;
public final ObservableField<String> realname ;
private final Repository repo;
public RepoItemViewModel(Repository repository) {
this.repo =repository;
name = new ObservableField<>(repo.getName());
realname = new ObservableField<>(repo.getRealname());
}
}
|
timfel/netbeans | java/maven/src/org/netbeans/modules/maven/actions/OpenPOMAction.java | /*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.netbeans.modules.maven.actions;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.List;
import org.netbeans.api.actions.Openable;
import org.netbeans.modules.maven.NbMavenProjectImpl;
import org.openide.awt.ActionID;
import org.openide.awt.ActionReference;
import org.openide.awt.ActionRegistration;
import org.openide.awt.Actions;
import org.openide.filesystems.FileObject;
import org.openide.filesystems.FileUtil;
import org.openide.loaders.DataObject;
import org.openide.loaders.DataObjectNotFoundException;
import org.openide.util.ContextAwareAction;
import org.openide.util.NbBundle.Messages;
@ActionID(category=OpenPOMAction.CATEGORY, id=OpenPOMAction.ID)
@ActionRegistration(displayName="#BTN_open_pom")
@ActionReference(path="Projects/org-netbeans-modules-maven/Actions", position=1650, separatorAfter=1655)
@Messages("BTN_open_pom=Open POM")
public class OpenPOMAction implements ActionListener {
static final String CATEGORY = "Project";
static final String ID = "org.netbeans.modules.maven.actions.openpom";
public static ContextAwareAction instance() {
return (ContextAwareAction) Actions.forID(CATEGORY, ID);
}
private final List<NbMavenProjectImpl> projects;
public OpenPOMAction(List<NbMavenProjectImpl> projects) {
this.projects = projects;
}
@Override public void actionPerformed(ActionEvent e) {
for (NbMavenProjectImpl project : projects) {
FileObject pom = FileUtil.toFileObject(project.getPOMFile());
if (pom != null) {
DataObject d;
try {
d = DataObject.find(pom);
} catch (DataObjectNotFoundException x) {
continue;
}
Openable o = d.getLookup().lookup(Openable.class);
if (o != null) {
o.open();
}
}
}
}
}
|
fermi-lat/pyBurstAnalysisGUI | python/GtBurst/interactivePlots.py | import math
import numpy as np
from GtBurst.my_fits_io import pyfits
import matplotlib.pyplot as plt
plt.ion()
from tkinter import *
import time
import threading
from GtBurst import dataHandling
#This function goes from names like NAI_00 to names like n0
def transformGBMdetname(name):
translations = {'NAI_00': 'n0',
'NAI_01': 'n1',
'NAI_02': 'n2',
'NAI_03': 'n3',
'NAI_04': 'n4',
'NAI_05': 'n5',
'NAI_06': 'n6',
'NAI_07': 'n7',
'NAI_08': 'n8',
'NAI_09': 'n9',
'NAI_10': 'na',
'NAI_11': 'nb',
'BGO_00': 'b0',
'BGO_01': 'b1'}
if(name in list(translations.keys())):
return translations[name]
else:
return name
pass
def getInteractiveFigureFromCSPEC(cspecfile,**kwargs):
trigTime = dataHandling.getTriggerTime(cspecfile)
f = pyfits.open(cspecfile)
if('DETNAM' in list(f['SPECTRUM'].header.keys())):
detector = transformGBMdetname(f['SPECTRUM'].header['DETNAM'])
elif('LLECUT' in list(f['SPECTRUM'].header.keys())):
detector = "LAT"
elif('TELESCOP' in list(f['SPECTRUM'].keys())):
detector = f['SPECTRUM'].header['TELESCOP']
else:
detector = 'Unknown'
pass
s = f['SPECTRUM']
d = s.data[(s.data.field('QUALITY')==0)]
#Avoid overflow and underflow channels
counts = d.field('COUNTS')[:,3:126]
met = d.field('TIME')-trigTime
exposure = d.field('EXPOSURE')
N = len(met)
LC = np.zeros(N)
for i in range(N):
LC[i]=counts[i].sum()
mask = (exposure > 0)
LC[mask] /= exposure[mask]
kwargs['xlabel'] = "Time since trigger"
kwargs['ylabel'] = "Counts/s"
kwargs['xoffset'] = trigTime
kwargs['title'] = detector
interactiveFigure = InteractiveFigure(met,LC,**kwargs)
f.close()
return interactiveFigure
pass
class InteractiveFigure(object):
def __init__(self,x,y,**kwargs):
self.xlabel = ''
self.ylabel = ''
self.title = ''
self.selectBackground = True
self.selectSource = True
self.xoffset = 0
self.figure = None
for key in list(kwargs.keys()):
if key.lower()=="xlabel": self.xlabel = kwargs[key]
elif key.lower()=="ylabel": self.ylabel = kwargs[key]
elif key.lower()=="title" : self.title = kwargs[key]
elif key.lower()=="selectbackground": self.selectBackground = bool(kwargs[key])
elif key.lower()=="selectsource": self.selectSource = bool(kwargs[key])
elif key.lower()=="xoffset": self.xoffset = kwargs[key]
elif key.lower()=="figure" : self.figure = kwargs[key]
self.x = x
self.y = y
if(self.figure is None):
self.figure = plt.figure()
self.figure.canvas.mpl_connect('close_event', self.closing)
self.figureIsMine = True
else:
#Clean the figure
self.figure.clear()
self.figureIsMine = False
pass
self.subfigure = self.figure.add_subplot(1,1,1,xlabel=self.xlabel,ylabel=self.ylabel)
self.subfigure.text(0.05, 0.9,'%s' %(self.title),
horizontalalignment='left',
verticalalignment='top',
transform = self.subfigure.transAxes)
self.clearButton = self.figure.text(0.9, 0.15,'Clear',
horizontalalignment='left',
verticalalignment='top',
backgroundcolor='red',
color='white',weight='bold',
picker=20)
self.doneButton = self.figure.text(0.9, 0.05,'Done',
horizontalalignment='left',
verticalalignment='bottom',
backgroundcolor='green',
color='white',weight='bold',
picker=20)
self.backgroundBounds = []
self.sourceBounds = []
self.sourceFillers = []
self.backgroundFillers = []
self.locking = False
self.curXdata = 'safetynet'
self.curYdata = 'safetynet'
pass
def plot(self):
self.subfigure.step(self.x,self.y,where='post')
pass
def bind(self):
self.cids = []
self.cids.append(self.figure.canvas.mpl_connect('button_press_event', self.clickPress))
self.cids.append(self.figure.canvas.mpl_connect('button_release_event', self.clickRelease))
self.cids.append(self.figure.canvas.mpl_connect('motion_notify_event',self.drawLineUnderCursor))
self.cids.append(self.figure.canvas.mpl_connect('pick_event', self.onPick))
def unbind(self):
for cid in self.cids:
self.figure.canvas.mpl_disconnect(cid)
pass
def activate(self):
self.plot()
self.figure.canvas.draw()
self.transitoryLines = []
self.lines = []
self.bind()
pass
def onPick(self,event):
#If the user clicked on one of the texts, do the corresponding
#action
if(event.mouseevent.button!=1 or not self.isNormalMode(event)):
#Do nothing
return
pass
if(event.artist==self.clearButton):
#clear
#print 'RESET SELECTION'
NB = len(self.backgroundBounds)
for x in range(NB):
self.backgroundBounds.pop()
NS = len(self.sourceBounds)
for x in range(NS):
self.sourceBounds.pop()
NOB = len(self.backgroundFillers)
for i in range(NOB):
self.backgroundFillers[i].remove()
for i in range(NOB):
self.backgroundFillers.pop()
NOS = len(self.sourceFillers)
for i in range(NOS):
self.sourceFillers[i].remove()
for i in range(NOS):
self.sourceFillers.pop()
#Suspend the binding for a second
self.unbind()
if(len(self.subfigure.lines)!=0):
self.delLines(self.lines)
self.delLines(self.transitoryLines)
pass
self.bind()
self.figure.canvas.draw()
elif(event.artist==self.doneButton):
#exit
self.unbind()
self.cleanClose()
pass
def delLines(self,lines):
for ll in lines:
self.subfigure.lines.remove(ll)
for i in range(len(lines)):
lines.pop()
self.figure.canvas.draw()
def isNormalMode(self,event):
if(len(self.figure.axes)>0):
ax = self.figure.axes[0]
navmode = ax.get_navigate_mode()
if(navmode is None):
return True
else:
return False
else:
#This can happen when I'm closing the window
return False
def drawLineUnderCursor(self,event):
#I want to draw the line only when I am in normal mode
#(no zoom/pan)
if(event.xdata is None or event.ydata is None or not self.isNormalMode(event)):
#Mouse outside figure or mode not normal
self.delLines(self.transitoryLines)
return
pass
self.delLines(self.transitoryLines)
self.transitoryLines.append(self.drawVerticalLine(event.xdata))
pass
def drawVerticalLine(self,x):
line = self.subfigure.axvline(x,linestyle="--")
self.figure.canvas.draw()
return line
pass
def drawIntervals(self,fillers,bounds,facecolor):
n = len(bounds)
if n<2 or n%2!=0:
#nothing to do!
return None
pass
self.delLines(self.lines)
#This is to avoid a change in the y scale in the figure
oldlim = self.figure.axes[0].get_ylim()
#Order the bounds
#Order the bounds
tstarts = list(bounds[::2])
tstops = list(bounds[1::2])
#Remember: this method is called to add one interval per time
newTstart = tstarts.pop(-1)
newTstop = tstops.pop(-1)
newInterval = dataHandling.TimeInterval(newTstart,newTstop,True)
oldIntervals = [dataHandling.TimeInterval(x[0],x[1],True) for x in zip(tstarts,tstops)]
#Verify if the new interval overlap with the old ones
merged = False
while(1==1):
for interval in oldIntervals:
if(interval.overlapsWith(newInterval)):
#merge them
newInterval.merge(interval)
merged = True
#Remove the old interval from the list, and break
#(to continue the while loop)
oldIntervals.pop(oldIntervals.index(interval))
break
pass
pass
if(merged):
#Continue the while loop
merged = False
continue
else:
#I finished the list of intervals without doing any merger,
#I can stop
break
pass
oldIntervals.append(newInterval)
#Sort the intervals (which are non-overlapping at this point)
sortedIntervals = sorted(oldIntervals,key=lambda x:x.tstart)
nFillers = len(fillers)
#Reset the fillers
for i in range(nFillers):
fillers[i].remove()
for i in range(nFillers):
fillers.pop()
pass
#Create the new fillers and approximate the boundaries to the closest bins
j = 0
nIntervals = int(math.floor(n/2.))
for interval in sortedIntervals:
x1 = interval.tstart-self.xoffset
x2 = interval.tstop-self.xoffset
#Approximate the boundaries to the closest external bins
indmin = max(0,np.searchsorted(self.x,x1,side='right')-1)
indmax = min(len(self.x)-1,np.searchsorted(self.x,x2,side='left'))
thisx = self.x[indmin:indmax+1]
thisy = self.y[indmin:indmax+1]
thisFiller = self.subfigure.fill_between(self.steppify(thisx),
self.steppify(thisy,False)*0,
self.steppify(thisy,False),facecolor=facecolor)
fillers.append(thisFiller)
interval.tstart = min(self.x[indmin:indmax+1])+self.xoffset
interval.tstop = max(self.x[indmin:indmax+1])+self.xoffset
j += 2
pass
self.figure.axes[0].set_ylim(oldlim)
self.figure.canvas.draw()
#update bounds
nBounds = len(bounds)
for i in range(nBounds):
bounds.pop()
for interval in sortedIntervals:
bounds.extend([interval.tstart,interval.tstop])
pass
def steppify(self,arr,isX=True):
"""
Converts an array to double-length for step plotting
"""
if isX:
newarr = np.array(list(zip(arr[:-1],arr[1:]))).ravel()
else:
newarr = np.array(list(zip(arr[:-1],arr[:-1]))).ravel()
return newarr
def printHelp(self):
pass
# print '\n SELECT TIME INTERVALS '
# print '-------------------------------------------------------\n'
# if(self.selectBackground):
# print ' z + click select background intervals'
# if(self.selectSource):
# print ' x + click select signal intervals'
# print ' c + click reset all selections'
# print ' w + click PRINT the selected intervals'
# print ' q + click SAVE the intervals and EXIT\n'
# print '-------------------------------------------------------\n'
# print ' Other keys: '
# print ' s save the canvas (use extension for defining the file format)'
# print ' p zoom/pam mode'
# print ' x Constrain pan/zoom to x axis (hold the x)'
# print ' y Constrain pan/zoom to y axis (hold the y)'
# print ' o zoom to rectangular'
# print ' f Toggle fullscreen'
# print ' g grid on/off'
# print ' h or r reset the plot scale'
# print ' L or k Toggle x axis scale (log/linear)'
# print ' l Toggle y axis scale (log/linear)'
# print ' TIP: to zoom use the right mouse button in zoom mode (press p)!\n'
pass
def clickPress(self,event):
if not self.isNormalMode(event):
#Ignore event if we are not in normal mode
return
if(event.xdata is None or event.ydata is None):
self.delLines(self.transitoryLines)
self.curXdata = 'safetynet'
self.curYdata = 'safetynet'
else:
self.curXdata = event.xdata
self.curYdata = event.ydata
pass
def clickRelease(self,event):
#print 'button=%d, x=%d, y=%d, xdata=%f, ydata=%f'%(event.button, event.x, event.y, event.xdata, event.ydata)
#print 'press', event.key
if not self.isNormalMode(event):
#Ignore event if we are not in normal mode
return
#Tolerance
tol = 2.0
if(event.xdata is not None and self.curXdata is not None):
deltax = abs(event.xdata-self.curXdata)
else:
deltax = 1e9
pass
if(event.ydata is not None and self.curYdata is not None):
deltay = abs(event.ydata-self.curYdata)
else:
deltay = 1e9
pass
if ( deltax <= tol and deltay <= tol
and self.selectBackground and event.button==1):
self.lines.append(self.drawVerticalLine(event.xdata))
#Find the closest bin
self.backgroundBounds.append(event.xdata+self.xoffset)
self.drawIntervals(self.backgroundFillers,self.backgroundBounds,'yellow')
elif (deltax <= tol and deltay <= tol
and self.selectSource and event.button==1):
self.lines.append(self.drawVerticalLine(event.xdata))
self.sourceBounds.append(event.xdata+self.xoffset)
self.drawIntervals(self.sourceFillers,self.sourceBounds,'red')
self.figure.canvas.draw()
pass
def cleanClose(self):
#Close the window
if(self.figureIsMine):
self.figure.close()
else:
#Do nothing
pass
#self.figure.clear()
#self.figure.canvas.draw()
pass
if(self.locking):
#This will stop the event loop and allow the calling program to continue
self.figure.canvas.stop_event_loop()
pass
def onselect(self,xmin, xmax):
Xmin = xmin
Xmax = xmax
return Xmin,Xmax
pass
def wait(self):
#This will wait until the window is closed
self.locking = True
self.figure.canvas.start_event_loop(0)
return
pass
pass
def writeAsciiFile(bounds,outfile):
nb = len(bounds)
j = 0
txt = ''
for i in range(int(math.floor(nb/2))):
txt += '%.20f %.20f\n' %(bounds[j],bounds[j+1])
j += 2
pass
fout = open(outfile,'w+')
fout.write(txt)
fout.close()
pass
|
gavin2lee/incubator-gl | mnisqm/mnisqm-pc/src/app/common/countTo/count-to.js | <reponame>gavin2lee/incubator-gl
var countTo = angular.module('countTo', [])
.directive('countTo', ['$timeout', function ($timeout) {
return {
replace: false,
scope: true,
link: function (scope, element, attrs) {
var e = element[0];
var num, refreshInterval, duration, steps, step, countTo, value, increment, scale = 1, exp = 0;
var calculate = function () {
var offset = (attrs.countTo + '').indexOf('.');
if(offset > -1) {
exp = (attrs.countTo + '').length - offset - 1;
}
for(i = exp; i > 0; i--) {
scale *= 10;
}
refreshInterval = 30;
step = 0;
scope.timoutId = null;
countTo = parseInt(attrs.countTo * scale) || 0;
scope.value = parseInt(attrs.value * scale, 10) || 0;
duration = (parseFloat(attrs.duration) * 1000) || 0;
steps = Math.ceil(duration / refreshInterval);
increment = ((countTo - scope.value) / steps);
num = scope.value;
}
var tick = function () {
scope.timoutId = $timeout(function () {
num += increment;
step++;
if (step >= steps) {
$timeout.cancel(scope.timoutId);
num = countTo;
e.textContent = (countTo / scale).toFixed(exp);
} else {
e.textContent = (Math.round(num) / scale).toFixed(exp);
tick();
}
}, refreshInterval);
}
var start = function () {
if (scope.timoutId) {
$timeout.cancel(scope.timoutId);
}
calculate();
tick();
}
attrs.$observe('countTo', function (val) {
if (val) {
start();
}
});
attrs.$observe('value', function (val) {
start();
});
return true;
}
}
}]); |
MirrorYu/eagleeye | eagleeye/common/EagleeyeThreadPool.h | <reponame>MirrorYu/eagleeye
#ifndef _EAGLEEYE_THREADPOOL_H_
#define _EAGLEEYE_THREADPOOL_H_
#include "eagleeye/common/EagleeyeMacro.h"
#include <functional>
#include <condition_variable> // NOLINT(build/c++11)
#include <mutex> // NOLINT(build/c++11)
#include <thread> // NOLINT(build/c++11)
#include <vector>
#include <atomic>
#include "eagleeye/basic/count_down_latch.h"
namespace eagleeye{
class ThreadPool {
public:
ThreadPool(const int thread_count,
const CPUAffinityPolicy affinity_policy);
~ThreadPool();
void Init();
void Run(const std::function<void(const int64_t)> &func,
const int64_t iterations);
int getThreadsNum();
void Compute1D(const std::function<void(int64_t /* start */,
int64_t /* end */,
int64_t /* step */)> &func,
int64_t start,
int64_t end,
int64_t step,
int64_t tile_size = 0,
int cost_per_item = -1);
void Compute2D(const std::function<void(int64_t /* start */,
int64_t /* end */,
int64_t /* step */,
int64_t /* start */,
int64_t /* end */,
int64_t /* step */)> &func,
int64_t start0,
int64_t end0,
int64_t step0,
int64_t start1,
int64_t end1,
int64_t step1,
int64_t tile_size0 = 0,
int64_t tile_size1 = 0,
int cost_per_item = -1);
void Compute3D(const std::function<void(int64_t /* start */,
int64_t /* end */,
int64_t /* step */,
int64_t /* start */,
int64_t /* end */,
int64_t /* step */,
int64_t /* start */,
int64_t /* end */,
int64_t /* step */)> &func,
int64_t start0,
int64_t end0,
int64_t step0,
int64_t start1,
int64_t end1,
int64_t step1,
int64_t start2,
int64_t end2,
int64_t step2,
int64_t tile_size0 = 0,
int64_t tile_size1 = 0,
int64_t tile_size2 = 0,
int cost_per_item = -1);
private:
void Destroy();
void ThreadLoop(size_t tid);
void ThreadRun(size_t tid);
std::atomic<int> event_;
CountDownLatch count_down_latch_;
std::mutex event_mutex_;
std::condition_variable event_cond_;
std::mutex run_mutex_;
struct ThreadInfo {
std::atomic<int64_t> range_start;
std::atomic<int64_t> range_end;
std::atomic<int64_t> range_len;
uintptr_t func;
std::vector<size_t> cpu_cores;
};
std::vector<ThreadInfo> thread_infos_;
std::vector<std::thread> threads_;
std::vector<float> cpu_max_freqs_;
int64_t default_tile_count_;
};
}
#endif |
jimmyis/DomenoWallet | src/api/filestorage.js | // file storage
var Promise = require('es6-promise').Promise
var Base64 = require('js-base64').Base64
export const FILE_STORAGE_DIR = 'stellar'
export function initFileStorage(){
return new Promise((resolve,reject) => {
window.requestFileSystem(LocalFileSystem.PERSISTENT, 0, fs=>{
if (!cordova.file) {
return reject('Could not write on device storage');
}
fs.root.getDirectory(FILE_STORAGE_DIR,{create: true}, dir=>{
resolve({fs,dir})
},err=>{
console.error('-----------create dir error')
console.error(err)
reject(err)
})
}, err=>{
console.error('get fs error')
console.error(err)
reject(err);
});
});
}
// delete file
export function deleteFile(file){
return initFileStorage().then(({fs,dir})=>{
return new Promise((resolve,reject)=>{
dir.getFile(file,{create:false},fileEntry=>{
fileEntry.remove(()=>{
resolve()
})
},error=>{
reject(error)
})
});
});
}
// read file into string
export function readFile(file){
return initFileStorage().then(({fs,dir})=>{
return new Promise((resolve,reject)=>{
dir.getFile(file,{ create: true, exclusive: false }, fileEntry=>{
fileEntry.file(file=>{
let reader = new FileReader()
reader.onloadend = (e)=>{
let result = e.target.result
result = Base64.decode(result)
resolve(result)
}
reader.onerror = reject
reader.readAsText(file)
},error=>{
reject(error)
})
},error=>{
console.log(error)
reject(error)
})
});
});
}
// save file content
export function saveFile(file,value){
return initFileStorage().then(({fs,dir})=>{
console.log('save -- file -- ')
console.log(dir)
console.log(file)
return new Promise((resolve,reject)=>{
dir.getFile(file, {create: true, exclusive: true},
fileEntry => {
fileEntry.createWriter(fileWriter=>{
fileWriter.onwriteend = e => {
resolve(e)
}
fileWriter.onerror = reject
if(typeof value === 'object'){
value = JSON.stringify(value)
}
console.log('file write ok')
console.log(file)
console.log(value)
//做base64处理
value = Base64.encode(value)
fileWriter.write(value)
},error=>{
console.error('file write error')
console.error(error)
reject(error)
});//end of fileEntry.createWriter
},
error => {
console.error('get file error')
console.log(dir)
console.log(file)
console.log(value)
console.error(error)
reject(error)
})//end of dir.getFile
});
})
}
|
YouCruit/onfido-api | onfido/src/main/java/com/youcruit/onfido/api/report/ReportId.java | <filename>onfido/src/main/java/com/youcruit/onfido/api/report/ReportId.java
package com.youcruit.onfido.api.report;
import com.youcruit.onfido.api.common.OnfidoId;
public class ReportId extends OnfidoId {
public ReportId(String id) {
super(id);
}
}
|
yangjunjiao/NetmfSTM32 | third party/matrixssl-3-3-open/ParseCertsTest/parseCerts.cpp | #include "stdafx.h"
#include "parseCerts.h"
#include <string.h>
static char* delimiterCertificate = "CERTIFICATE-----";
static char* delimiterKey = "KEY-----";
CertStorage certStorage;
/*
char* eliminateSpecialCharacters(char* in)
{
while (*in == '\x0d' || *in == '\x0a' || *in == '\x09'
|| *in == ' ') {
in++;
}
return in;
}
char* eliminateSpecialCharactersEnd(char* in)
{
do
{
in--;
}
while(*in == '\x0d' || *in == '\x0a' || *in == '\x09'
|| *in == ' ');
return ++in;
}
*/
/**
@ remarks: out has to be freed
**/
int32 parseBase64Encoded(const unsigned char *in, int32 len,
unsigned char **out, int32 *outlen)
{
int32 result = PS_FAILURE;
*out = (unsigned char *) psMalloc(NULL, len);
*outlen = len;
result = psBase64decode(in, len, *out, (uint32*)outlen);
return result;
}
int32 getData(const unsigned char *in, uint32 len, unsigned char **out, int32 *outlen, const char* delimiter)
{
char* start;
char* end;
char* endNext;
int32 currentLength;
int i = 0;
while (i++ < len) {
if (((start = strstr((char*)in, "-----BEGIN")) != NULL) &&
((start = strstr((char*)in, delimiter)) != NULL) &&
((end = strstr(start, "-----END")) != NULL) &&
((endNext = strstr(end,delimiter)) != NULL)) {
start += strlen(delimiter);
//start = eliminateSpecialCharacters(start);
//end = eliminateSpecialCharactersEnd(end);
currentLength = (int32)(end - start);
return parseBase64Encoded((unsigned char*) start, currentLength, out, outlen);
/*
while (*end == '\x0d' || *end == '\x0a' || *end == '\x09'
|| *end == ' ') {
end++;
}
len -= (int32)((unsigned char*)end - in);*/
}
}
return PS_FAILURE;
}
int32 parseServerCert(const unsigned char *in, uint32 len)
{
int32 result = PS_SUCCESS;
result = getData(in, len, &certStorage.certBuf, &certStorage.certLen, delimiterCertificate);
if (result == PS_FAILURE)
{
printf("Parse cert error!\n");
}
result = getData(in, len, &certStorage.privBuf, &certStorage.privLen, delimiterKey);
if (result == PS_FAILURE)
{
printf("Parse key error!\n");
}
return result;
}
int32 parseClientCA(const unsigned char *in, uint32 len)
{
int32 result = PS_SUCCESS;
result = getData(in, len, &certStorage.trustedCABuf, &certStorage.trustedCALen, delimiterCertificate);
if (result == PS_FAILURE)
{
printf("Parse cert error!\n");
}
return result;
}
int32 LoadRsaKeys(sslKeys_t * keys)
{
if (matrixSslLoadRsaKeysMem(keys, certStorage.certBuf, certStorage.certLen,
certStorage.privBuf, certStorage.privLen, certStorage.trustedCABuf, certStorage.trustedCALen) < 0) {
return PS_FAILURE;
}
return PS_SUCCESS;
} |
ZouTrankil/game-server | game-ai/src/main/java/com/jzy/game/ai/nav/node/NodeData.java | package com.jzy.game.ai.nav.node;
import java.util.HashMap;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.alibaba.fastjson.JSON;
import com.jzy.game.ai.nav.NavMeshData;
import com.jzy.game.engine.math.Vector3;
/**
* navmesh寻路三角形网格数据 <br>
* 依次三个顶点确定一个三角形
*
* @author JiangZhiYong
*
*/
public class NodeData extends NavMeshData {
private static final Logger LOGGER = LoggerFactory.getLogger(NodeData.class);
private static final long serialVersionUID = 1L;
/** 阻挡顶点序号 */
private int[] blockTriangles;
/** 阻挡坐标 */
private Vector3[] blockVertices;
/**
* 数据检测，客户端的顶点坐标和三角形数据有可能是重复的
* <br>
* TODO 小三角形合并成大三角形或多边形；判断顶点是否在寻路层中，寻路层中的顶点不能作为路径点；两点所连线段是否穿过阻挡区，不穿过，直接获取坐标点
*/
public void check(int scale) {
super.check(scale);
amendmentSameVector(blockTriangles, blockVertices);
scaleVector(blockVertices, scale);
}
public int[] getBlockTriangles() {
return blockTriangles;
}
public void setBlockTriangles(int[] blockTriangles) {
this.blockTriangles = blockTriangles;
}
public Vector3[] getBlockVertices() {
return blockVertices;
}
public void setBlockVertices(Vector3[] blockVertices) {
this.blockVertices = blockVertices;
}
@Override
public String toString() {
return JSON.toJSONString(this);
}
}
|
vandelay87/akli | src/components/heading/heading.js | import React from 'react'
import PropTypes from 'prop-types'
import styled, { css } from 'styled-components'
import { robotoRegular } from '../../styles/fonts'
import { below } from '../../styles/breakpoints'
const Heading = ({ title, size, align }) => (
<StyledHeading as={`h${size}`} align={align} size={size}>
{title}
</StyledHeading>
)
const fontSize = ['6rem', '3.75rem', '3rem', '2.125rem', '1.5rem', '1.25rem']
const fontWeight = ['300', '300', '400', '400', '400', '500']
const lineHeight = ['6rem', '3.75rem', '3.125rem', '2.5rem', '2rem', '2rem']
const letterSpacing = [
'-.01562em',
'-0.0083333333em',
'nornal',
'.0073529412em',
'normal',
'.0125em',
]
const StyledHeading = styled.h1`
${robotoRegular}
font-size: ${({ size }) => fontSize[size - 1]};
-moz-osx-font-smoothing: grayscale;
-webkit-font-smoothing: antialiased;
font-weight: ${({ size }) => fontWeight[size - 1]};
line-height: ${({ size }) => lineHeight[size - 1]};
letter-spacing: ${({ size }) => letterSpacing[size - 1]};
text-align: ${({ align }) => align};
${({ size }) =>
size === 1 &&
css`
${below.mobile`
font-size: 4.5rem;
line-height: 4.5rem;
letter-spacing: -0.0083333333em;
word-break: break-word;
`}
${below.smallMobile`
font-size: 3.75rem;
`}
`}
`
Heading.propTypes = {
title: PropTypes.string.isRequired,
size: PropTypes.number,
align: PropTypes.string,
}
Heading.defaultProps = {
size: 1,
align: 'initial',
}
export default Heading
|
anightrabbit/learn-react | flux-blog/src/views/traveller/index.js | import React from 'react';
import {
Layout
} from 'antd';
import { Container } from 'flux/utils';
import CardGridList from '../../components/traveller/CardGridList';
import { fetchTravellerListData } from '../../flux/actions';
import { travellerListStore } from '../../flux/stores';
const getStores = () => [travellerListStore];
const calculateState = () => travellerListStore.getState();
const Traveller = (props) => {
return <Layout>
<CardGridList count={4} {...props} loadData={fetchTravellerListData} />
</Layout>;
}
export default Container.createFunctional(Traveller, getStores, calculateState); |
Hendrikto/jena | jena-core/src/test/java/org/apache/jena/rdfxml/xmlinput/SAX2RDFTest.java | /*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.jena.rdfxml.xmlinput;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.Vector;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParserFactory;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import org.apache.jena.rdf.model.Model ;
import org.apache.jena.rdf.model.ModelFactory ;
import org.apache.jena.rdf.model.RDFErrorHandler ;
import org.apache.jena.rdf.model.RDFReaderI ;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
import org.xml.sax.XMLReader;
public class SAX2RDFTest extends TestCase {
protected static Logger logger = LoggerFactory.getLogger( SAX2RDFTest.class );
static final private String all[] = {
"arp/dom/domtest.rdf",
//"abbreviated/collection.rdf",
"abbreviated/container.rdf",
"abbreviated/cookup.rdf", "abbreviated/daml.rdf",
"abbreviated/namespaces.rdf", "abbreviated/reification.rdf",
"abbreviated/relative-uris.rdf", "arp/comments/test01.rdf",
"arp/comments/test02.rdf", "arp/comments/test03.rdf",
"arp/comments/test04.rdf", "arp/comments/test05.rdf",
"arp/comments/test06.rdf", "arp/comments/test07.rdf",
"arp/comments/test08.rdf", "arp/comments/test09.rdf",
"arp/comments/test10.rdf", "arp/comments/test11.rdf",
"arp/comments/test12.rdf", "arp/comments/test13.rdf",
"arp/error-msgs/test01.rdf", "arp/error-msgs/test02.rdf",
"arp/error-msgs/test03.rdf", "arp/error-msgs/test04.rdf",
"arp/error-msgs/test05.rdf",
// "arp/error-msgs/testutf8.rdf",
"arp/i18n/eq-bug73_0.rdf", "arp/i18n/eq-bug73_1.rdf",
"arp/i18n/eq-bug73_2.rdf", "arp/i18n/i18nID.rdf",
"arp/i18n/t9000.rdf", "arp/Manifest.rdf",
"arp/parsetype/bug68_0.rdf", "arp/qname-in-ID/bug74_0.rdf",
"arp/rdf-nnn/bad-bug67_0.rdf", "arp/rdf-nnn/bad-bug67_1.rdf",
"arp/rdf-nnn/bad-bug67_2.rdf", "arp/rdf-nnn/bad-bug67_3.rdf",
"arp/rdf-nnn/bad-bug67_4.rdf", "arp/rdf-nnn/bad-bug67_5.rdf",
"arp/rdf-nnn/bad-bug67_6.rdf", "arp/rdf-nnn/bad-bug67_7.rdf",
"arp/rdf-nnn/bad-bug67_8.rdf", "arp/rdf-nnn/bad-bug67_9.rdf",
"arp/relative-namespaces/bad-bug50_0.rdf",
"arp/rfc2396-issue/bug51_0.rdf", "arp/rfc2396-issue/fileURI.rdf",
// "arp/scope/test01.rdf",
"arp/scope/test02.rdf", "arp/scope/test03.rdf",
"arp/scope/test04.rdf", "arp/scope/test05.rdf",
"arp/syntax-errors/error001.rdf", "arp/syntax-errors/error002.rdf",
"arp/syntax-errors/error003.rdf", "arp/xml-literals/reported1.rdf",
"arp/xml-literals/reported2.rdf", "arp/xml-literals/reported3.rdf",
"arp/xmlns/bad01.rdf", "arp/xmlns/food.rdf",
"arp/xmlns/test01.rdf", "arp/xmlns/test02.rdf",
"arp/xmlns/test03.rdf", "arp/xmlns/wine.rdf",
"ontology/daml/Axioms/test.rdf",
"ontology/daml/ClassExpression/test-boolean.rdf",
"ontology/daml/ClassExpression/test-enum.rdf",
"ontology/daml/ClassExpression/test-restriction.rdf",
"ontology/daml/ClassExpression/test.rdf",
"ontology/daml/list-syntax/test-proptypes.rdf",
"ontology/daml/list-syntax/test.rdf",
"ontology/daml/Ontology/test.rdf",
"ontology/daml/Property/test.rdf", "ontology/list0.rdf",
"ontology/list1.rdf", "ontology/list2.rdf", "ontology/list3.rdf",
"ontology/list4.rdf", "ontology/list5.rdf",
"ontology/owl/Axioms/test.rdf",
"ontology/owl/ClassExpression/test-boolean.rdf",
"ontology/owl/ClassExpression/test-enum.rdf",
"ontology/owl/ClassExpression/test-restriction.rdf",
"ontology/owl/ClassExpression/test.rdf",
"ontology/owl/list-syntax/test-proptypes.rdf",
"ontology/owl/list-syntax/test-with-import.rdf",
"ontology/owl/list-syntax/test.rdf",
"ontology/owl/Ontology/test.rdf", "ontology/owl/Property/test.rdf",
"ontology/rdfs/ClassExpression/test.rdf",
"ontology/rdfs/list-syntax/test.rdf",
"ontology/rdfs/Ontology/test.rdf",
"ontology/rdfs/Property/test.rdf", "ontology/relativenames.rdf",
"ontology/testImport5/ont-policy.rdf",
"RDQL/model5.rdf", "RDQL/vc-db-1.rdf", "RDQL/vc-db-2.rdf",
"RDQL/vc-db-3.rdf", "reasoners/bugs/sbug.rdf",
"reasoners/owl/consistentData.rdf",
"reasoners/owl/inconsistent1.rdf",
"reasoners/owl/inconsistent2.rdf",
"reasoners/owl/inconsistent3.rdf",
"reasoners/owl/inconsistent4.rdf",
"reasoners/owl/inconsistent5.rdf", "reasoners/rdfs/data1.rdf",
"reasoners/rdfs/data2.rdf", "reasoners/rdfs/data3.rdf",
"reasoners/rdfs/dataRDFS12.rdf",
"reasoners/rdfs/manifest-nodirect-noresource.rdf",
"reasoners/rdfs/manifest-nodirect.rdf",
"reasoners/rdfs/manifest-rdfs12.rdf",
"reasoners/rdfs/manifest-simple.rdf",
"reasoners/rdfs/manifest-standard.rdf",
"reasoners/rdfs/manifest.rdf", "reasoners/rdfs/result1.rdf",
"reasoners/rdfs/result10.rdf",
"reasoners/rdfs/result11-noresource.rdf",
"reasoners/rdfs/result11.rdf",
"reasoners/rdfs/result12-noresource.rdf",
"reasoners/rdfs/result12.rdf",
"reasoners/rdfs/result13-noresource.rdf",
"reasoners/rdfs/result13.rdf", "reasoners/rdfs/result14.rdf",
"reasoners/rdfs/result15.rdf",
"reasoners/rdfs/result16-noresource.rdf",
"reasoners/rdfs/result16.rdf", "reasoners/rdfs/result17.rdf",
"reasoners/rdfs/result18-simple.rdf",
"reasoners/rdfs/result18.rdf",
"reasoners/rdfs/result19-nodirect.rdf",
"reasoners/rdfs/result19.rdf", "reasoners/rdfs/result2.rdf",
"reasoners/rdfs/result20-nodirect.rdf",
"reasoners/rdfs/result20.rdf", "reasoners/rdfs/result3.rdf",
"reasoners/rdfs/result4.rdf", "reasoners/rdfs/result7.rdf",
"reasoners/rdfs/result8.rdf", "reasoners/rdfs/result9.rdf",
"reasoners/rdfs/resultRDFS12.rdf", "reasoners/rdfs/tbox1.rdf",
"reasoners/rdfs/timing-data.rdf", "reasoners/rdfs/timing-tbox.rdf",
"reasoners/transitive/data1.rdf",
"reasoners/transitive/data11.rdf",
"reasoners/transitive/data2.rdf", "reasoners/transitive/data3.rdf",
"reasoners/transitive/data6.rdf", "reasoners/transitive/data8.rdf",
"reasoners/transitive/data9.rdf", "reasoners/transitive/empty.rdf",
"reasoners/transitive/manifest.rdf",
"reasoners/transitive/result11.rdf",
"reasoners/transitive/result2.rdf",
"reasoners/transitive/result4.rdf",
"reasoners/transitive/result5.rdf",
"reasoners/transitive/result6.rdf",
"reasoners/transitive/tbox1.rdf", "reasoners/transitive/tbox7.rdf",
"wg/AllDifferent/conclusions001.rdf",
"wg/AllDifferent/Manifest001.rdf",
"wg/AllDifferent/premises001.rdf",
"wg/allValuesFrom/conclusions001.rdf",
"wg/allValuesFrom/Manifest001.rdf",
"wg/allValuesFrom/Manifest002.rdf",
"wg/allValuesFrom/nonconclusions002.rdf",
"wg/allValuesFrom/premises001.rdf",
"wg/allValuesFrom/premises002.rdf", "wg/amp-in-url/test001.rdf",
"wg/AnnotationProperty/conclusions002.rdf",
"wg/AnnotationProperty/consistent003.rdf",
"wg/AnnotationProperty/consistent004.rdf",
"wg/AnnotationProperty/Manifest001.rdf",
"wg/AnnotationProperty/Manifest002.rdf",
"wg/AnnotationProperty/Manifest003.rdf",
"wg/AnnotationProperty/Manifest004.rdf",
"wg/AnnotationProperty/nonconclusions001.rdf",
"wg/AnnotationProperty/premises001.rdf",
"wg/AnnotationProperty/premises002.rdf",
"wg/backwardCompatibleWith/consistent001.rdf",
"wg/backwardCompatibleWith/consistent002.rdf",
"wg/backwardCompatibleWith/Manifest001.rdf",
"wg/backwardCompatibleWith/Manifest002.rdf",
"wg/cardinality/conclusions001-mod.rdf",
"wg/cardinality/conclusions001.rdf",
"wg/cardinality/conclusions002-mod.rdf",
"wg/cardinality/conclusions002.rdf",
"wg/cardinality/conclusions003-mod.rdf",
"wg/cardinality/conclusions003.rdf",
"wg/cardinality/conclusions004-mod.rdf",
"wg/cardinality/conclusions004.rdf",
"wg/cardinality/conclusions005-mod.rdf",
"wg/cardinality/conclusions005.rdf",
"wg/cardinality/conclusions006-mod.rdf",
"wg/cardinality/conclusions006.rdf",
"wg/cardinality/Manifest001-mod.rdf",
"wg/cardinality/Manifest001.rdf",
"wg/cardinality/Manifest002-mod.rdf",
"wg/cardinality/Manifest002.rdf",
"wg/cardinality/Manifest003-mod.rdf",
"wg/cardinality/Manifest003.rdf",
"wg/cardinality/Manifest004-mod.rdf",
"wg/cardinality/Manifest004.rdf",
"wg/cardinality/Manifest005-mod.rdf",
"wg/cardinality/Manifest005.rdf",
"wg/cardinality/Manifest006-mod.rdf",
"wg/cardinality/Manifest006.rdf",
"wg/cardinality/premises001-mod.rdf",
"wg/cardinality/premises001.rdf",
"wg/cardinality/premises002-mod.rdf",
"wg/cardinality/premises002.rdf",
"wg/cardinality/premises003-mod.rdf",
"wg/cardinality/premises003.rdf",
"wg/cardinality/premises004-mod.rdf",
"wg/cardinality/premises004.rdf",
"wg/cardinality/premises005-mod.rdf",
"wg/cardinality/premises005.rdf",
"wg/cardinality/premises006-mod.rdf",
"wg/cardinality/premises006.rdf", "wg/Class/conclusions001.rdf",
"wg/Class/conclusions002.rdf", "wg/Class/conclusions003.rdf",
"wg/Class/conclusions006.rdf", "wg/Class/Manifest001.rdf",
"wg/Class/Manifest002.rdf", "wg/Class/Manifest003.rdf",
"wg/Class/Manifest004.rdf", "wg/Class/Manifest005.rdf",
"wg/Class/Manifest006.rdf", "wg/Class/nonconclusions004.rdf",
"wg/Class/nonconclusions005.rdf", "wg/Class/premises002.rdf",
"wg/Class/premises003.rdf", "wg/Class/premises004.rdf",
"wg/Class/premises005.rdf", "wg/Class/premises006.rdf",
"wg/complementOf/conclusions001.rdf",
"wg/complementOf/Manifest001.rdf",
"wg/complementOf/premises001.rdf",
"wg/DatatypeProperty/consistent001.rdf",
"wg/DatatypeProperty/Manifest001.rdf", "wg/datatypes/test001.rdf",
"wg/datatypes/test002.rdf",
"wg/description-logic/conclusions001.rdf",
"wg/description-logic/conclusions002.rdf",
"wg/description-logic/conclusions003.rdf",
"wg/description-logic/conclusions004.rdf",
"wg/description-logic/conclusions007.rdf",
"wg/description-logic/conclusions008.rdf",
"wg/description-logic/conclusions010.rdf",
"wg/description-logic/conclusions011.rdf",
"wg/description-logic/conclusions012.rdf",
"wg/description-logic/conclusions013.rdf",
"wg/description-logic/conclusions014.rdf",
"wg/description-logic/conclusions015.rdf",
"wg/description-logic/conclusions017.rdf",
"wg/description-logic/conclusions019.rdf",
"wg/description-logic/conclusions022.rdf",
"wg/description-logic/conclusions023.rdf",
"wg/description-logic/conclusions026.rdf",
"wg/description-logic/conclusions027.rdf",
"wg/description-logic/conclusions029.rdf",
"wg/description-logic/conclusions030.rdf",
"wg/description-logic/conclusions032.rdf",
"wg/description-logic/conclusions033.rdf",
"wg/description-logic/conclusions101.rdf",
"wg/description-logic/conclusions102.rdf",
"wg/description-logic/conclusions103.rdf",
"wg/description-logic/conclusions104.rdf",
"wg/description-logic/conclusions105.rdf",
"wg/description-logic/conclusions106.rdf",
"wg/description-logic/conclusions107.rdf",
"wg/description-logic/conclusions108.rdf",
"wg/description-logic/conclusions109.rdf",
"wg/description-logic/conclusions110.rdf",
"wg/description-logic/conclusions111.rdf",
"wg/description-logic/conclusions201.rdf",
"wg/description-logic/conclusions202.rdf",
"wg/description-logic/conclusions203.rdf",
"wg/description-logic/conclusions204.rdf",
"wg/description-logic/conclusions205.rdf",
"wg/description-logic/conclusions206.rdf",
"wg/description-logic/conclusions207.rdf",
"wg/description-logic/conclusions208.rdf",
"wg/description-logic/conclusions661.rdf",
"wg/description-logic/conclusions662.rdf",
"wg/description-logic/conclusions663.rdf",
"wg/description-logic/conclusions664.rdf",
"wg/description-logic/conclusions665.rdf",
"wg/description-logic/conclusions667.rdf",
"wg/description-logic/conclusions901.rdf",
"wg/description-logic/conclusions903.rdf",
"wg/description-logic/conclusions905.rdf",
"wg/description-logic/consistent005.rdf",
"wg/description-logic/consistent006.rdf",
"wg/description-logic/consistent009.rdf",
"wg/description-logic/consistent016.rdf",
"wg/description-logic/consistent018.rdf",
"wg/description-logic/consistent020.rdf",
"wg/description-logic/consistent021.rdf",
"wg/description-logic/consistent024.rdf",
"wg/description-logic/consistent025.rdf",
"wg/description-logic/consistent028.rdf",
"wg/description-logic/consistent031.rdf",
"wg/description-logic/consistent034.rdf",
"wg/description-logic/consistent501.rdf",
"wg/description-logic/consistent503.rdf",
"wg/description-logic/consistent605.rdf",
"wg/description-logic/consistent606.rdf",
"wg/description-logic/consistent609.rdf",
"wg/description-logic/consistent616.rdf",
"wg/description-logic/consistent624.rdf",
"wg/description-logic/consistent625.rdf",
"wg/description-logic/consistent628.rdf",
"wg/description-logic/consistent631.rdf",
"wg/description-logic/consistent634.rdf",
"wg/description-logic/consistent905.rdf",
"wg/description-logic/consistent906.rdf",
"wg/description-logic/consistent907.rdf",
"wg/description-logic/consistent908.rdf",
"wg/description-logic/inconsistent001.rdf",
"wg/description-logic/inconsistent002.rdf",
"wg/description-logic/inconsistent003.rdf",
"wg/description-logic/inconsistent004.rdf",
"wg/description-logic/inconsistent007.rdf",
"wg/description-logic/inconsistent008.rdf",
"wg/description-logic/inconsistent010.rdf",
"wg/description-logic/inconsistent011.rdf",
"wg/description-logic/inconsistent012.rdf",
"wg/description-logic/inconsistent013.rdf",
"wg/description-logic/inconsistent014.rdf",
"wg/description-logic/inconsistent015.rdf",
"wg/description-logic/inconsistent017.rdf",
"wg/description-logic/inconsistent019.rdf",
"wg/description-logic/inconsistent022.rdf",
"wg/description-logic/inconsistent023.rdf",
"wg/description-logic/inconsistent026.rdf",
"wg/description-logic/inconsistent027.rdf",
"wg/description-logic/inconsistent029.rdf",
"wg/description-logic/inconsistent030.rdf",
"wg/description-logic/inconsistent032.rdf",
"wg/description-logic/inconsistent033.rdf",
"wg/description-logic/inconsistent035.rdf",
"wg/description-logic/inconsistent040.rdf",
"wg/description-logic/inconsistent101.rdf",
"wg/description-logic/inconsistent102.rdf",
"wg/description-logic/inconsistent103.rdf",
"wg/description-logic/inconsistent104.rdf",
"wg/description-logic/inconsistent105.rdf",
"wg/description-logic/inconsistent106.rdf",
"wg/description-logic/inconsistent107.rdf",
"wg/description-logic/inconsistent108.rdf",
"wg/description-logic/inconsistent109.rdf",
"wg/description-logic/inconsistent110.rdf",
"wg/description-logic/inconsistent111.rdf",
"wg/description-logic/inconsistent502.rdf",
"wg/description-logic/inconsistent504.rdf",
"wg/description-logic/inconsistent601.rdf",
"wg/description-logic/inconsistent602.rdf",
"wg/description-logic/inconsistent603.rdf",
"wg/description-logic/inconsistent604.rdf",
"wg/description-logic/inconsistent608.rdf",
"wg/description-logic/inconsistent610.rdf",
"wg/description-logic/inconsistent611.rdf",
"wg/description-logic/inconsistent612.rdf",
"wg/description-logic/inconsistent613.rdf",
"wg/description-logic/inconsistent614.rdf",
"wg/description-logic/inconsistent615.rdf",
"wg/description-logic/inconsistent617.rdf",
"wg/description-logic/inconsistent623.rdf",
"wg/description-logic/inconsistent626.rdf",
"wg/description-logic/inconsistent627.rdf",
"wg/description-logic/inconsistent629.rdf",
"wg/description-logic/inconsistent630.rdf",
"wg/description-logic/inconsistent632.rdf",
"wg/description-logic/inconsistent633.rdf",
"wg/description-logic/inconsistent641.rdf",
"wg/description-logic/inconsistent642.rdf",
"wg/description-logic/inconsistent643.rdf",
"wg/description-logic/inconsistent644.rdf",
"wg/description-logic/inconsistent646.rdf",
"wg/description-logic/inconsistent650.rdf",
"wg/description-logic/inconsistent909.rdf",
"wg/description-logic/inconsistent910.rdf",
"wg/description-logic/Manifest001.rdf",
"wg/description-logic/Manifest002.rdf",
"wg/description-logic/Manifest003.rdf",
"wg/description-logic/Manifest004.rdf",
"wg/description-logic/Manifest005.rdf",
"wg/description-logic/Manifest006.rdf",
"wg/description-logic/Manifest007.rdf",
"wg/description-logic/Manifest008.rdf",
"wg/description-logic/Manifest009.rdf",
"wg/description-logic/Manifest010.rdf",
"wg/description-logic/Manifest011.rdf",
"wg/description-logic/Manifest012.rdf",
"wg/description-logic/Manifest013.rdf",
"wg/description-logic/Manifest014.rdf",
"wg/description-logic/Manifest015.rdf",
"wg/description-logic/Manifest016.rdf",
"wg/description-logic/Manifest017.rdf",
"wg/description-logic/Manifest018.rdf",
"wg/description-logic/Manifest019.rdf",
"wg/description-logic/Manifest020.rdf",
"wg/description-logic/Manifest021.rdf",
"wg/description-logic/Manifest022.rdf",
"wg/description-logic/Manifest023.rdf",
"wg/description-logic/Manifest024.rdf",
"wg/description-logic/Manifest025.rdf",
"wg/description-logic/Manifest026.rdf",
"wg/description-logic/Manifest027.rdf",
"wg/description-logic/Manifest028.rdf",
"wg/description-logic/Manifest029.rdf",
"wg/description-logic/Manifest030.rdf",
"wg/description-logic/Manifest031.rdf",
"wg/description-logic/Manifest032.rdf",
"wg/description-logic/Manifest033.rdf",
"wg/description-logic/Manifest034.rdf",
"wg/description-logic/Manifest035.rdf",
"wg/description-logic/Manifest040.rdf",
"wg/description-logic/Manifest101.rdf",
"wg/description-logic/Manifest102.rdf",
"wg/description-logic/Manifest103.rdf",
"wg/description-logic/Manifest104.rdf",
"wg/description-logic/Manifest105.rdf",
"wg/description-logic/Manifest106.rdf",
"wg/description-logic/Manifest107.rdf",
"wg/description-logic/Manifest108.rdf",
"wg/description-logic/Manifest109.rdf",
"wg/description-logic/Manifest110.rdf",
"wg/description-logic/Manifest111.rdf",
"wg/description-logic/Manifest201.rdf",
"wg/description-logic/Manifest202.rdf",
"wg/description-logic/Manifest203.rdf",
"wg/description-logic/Manifest204.rdf",
"wg/description-logic/Manifest205.rdf",
"wg/description-logic/Manifest206.rdf",
"wg/description-logic/Manifest207.rdf",
"wg/description-logic/Manifest208.rdf",
"wg/description-logic/Manifest209.rdf",
"wg/description-logic/Manifest501.rdf",
"wg/description-logic/Manifest502.rdf",
"wg/description-logic/Manifest503.rdf",
"wg/description-logic/Manifest504.rdf",
"wg/description-logic/Manifest601.rdf",
"wg/description-logic/Manifest602.rdf",
"wg/description-logic/Manifest603.rdf",
"wg/description-logic/Manifest604.rdf",
"wg/description-logic/Manifest605.rdf",
"wg/description-logic/Manifest606.rdf",
"wg/description-logic/Manifest608.rdf",
"wg/description-logic/Manifest609.rdf",
"wg/description-logic/Manifest610.rdf",
"wg/description-logic/Manifest611.rdf",
"wg/description-logic/Manifest612.rdf",
"wg/description-logic/Manifest613.rdf",
"wg/description-logic/Manifest614.rdf",
"wg/description-logic/Manifest615.rdf",
"wg/description-logic/Manifest616.rdf",
"wg/description-logic/Manifest617.rdf",
"wg/description-logic/Manifest623.rdf",
"wg/description-logic/Manifest624.rdf",
"wg/description-logic/Manifest625.rdf",
"wg/description-logic/Manifest626.rdf",
"wg/description-logic/Manifest627.rdf",
"wg/description-logic/Manifest628.rdf",
"wg/description-logic/Manifest629.rdf",
"wg/description-logic/Manifest630.rdf",
"wg/description-logic/Manifest631.rdf",
"wg/description-logic/Manifest632.rdf",
"wg/description-logic/Manifest633.rdf",
"wg/description-logic/Manifest634.rdf",
"wg/description-logic/Manifest641.rdf",
"wg/description-logic/Manifest642.rdf",
"wg/description-logic/Manifest643.rdf",
"wg/description-logic/Manifest644.rdf",
"wg/description-logic/Manifest646.rdf",
"wg/description-logic/Manifest650.rdf",
"wg/description-logic/Manifest661.rdf",
"wg/description-logic/Manifest662.rdf",
"wg/description-logic/Manifest663.rdf",
"wg/description-logic/Manifest664.rdf",
"wg/description-logic/Manifest665.rdf",
"wg/description-logic/Manifest667.rdf",
"wg/description-logic/Manifest901.rdf",
"wg/description-logic/Manifest902.rdf",
"wg/description-logic/Manifest903.rdf",
"wg/description-logic/Manifest904.rdf",
"wg/description-logic/Manifest905.rdf",
"wg/description-logic/Manifest906.rdf",
"wg/description-logic/Manifest907.rdf",
"wg/description-logic/Manifest908.rdf",
"wg/description-logic/Manifest909.rdf",
"wg/description-logic/Manifest910.rdf",
"wg/description-logic/nonconclusions005.rdf",
"wg/description-logic/nonconclusions006.rdf",
"wg/description-logic/nonconclusions009.rdf",
"wg/description-logic/nonconclusions016.rdf",
"wg/description-logic/nonconclusions018.rdf",
"wg/description-logic/nonconclusions020.rdf",
"wg/description-logic/nonconclusions021.rdf",
"wg/description-logic/nonconclusions024.rdf",
"wg/description-logic/nonconclusions025.rdf",
"wg/description-logic/nonconclusions028.rdf",
"wg/description-logic/nonconclusions031.rdf",
"wg/description-logic/nonconclusions034.rdf",
"wg/description-logic/nonconclusions209.rdf",
"wg/description-logic/nonconclusions902.rdf",
"wg/description-logic/nonconclusions904.rdf",
"wg/description-logic/premises001.rdf",
"wg/description-logic/premises002.rdf",
"wg/description-logic/premises003.rdf",
"wg/description-logic/premises004.rdf",
"wg/description-logic/premises005.rdf",
"wg/description-logic/premises006.rdf",
"wg/description-logic/premises007.rdf",
"wg/description-logic/premises008.rdf",
"wg/description-logic/premises009.rdf",
"wg/description-logic/premises010.rdf",
"wg/description-logic/premises011.rdf",
"wg/description-logic/premises012.rdf",
"wg/description-logic/premises013.rdf",
"wg/description-logic/premises014.rdf",
"wg/description-logic/premises015.rdf",
"wg/description-logic/premises016.rdf",
"wg/description-logic/premises017.rdf",
"wg/description-logic/premises018.rdf",
"wg/description-logic/premises019.rdf",
"wg/description-logic/premises020.rdf",
"wg/description-logic/premises021.rdf",
"wg/description-logic/premises022.rdf",
"wg/description-logic/premises023.rdf",
"wg/description-logic/premises024.rdf",
"wg/description-logic/premises025.rdf",
"wg/description-logic/premises026.rdf",
"wg/description-logic/premises027.rdf",
"wg/description-logic/premises028.rdf",
"wg/description-logic/premises029.rdf",
"wg/description-logic/premises030.rdf",
"wg/description-logic/premises031.rdf",
"wg/description-logic/premises032.rdf",
"wg/description-logic/premises033.rdf",
"wg/description-logic/premises034.rdf",
"wg/description-logic/premises101.rdf",
"wg/description-logic/premises102.rdf",
"wg/description-logic/premises103.rdf",
"wg/description-logic/premises104.rdf",
"wg/description-logic/premises105.rdf",
"wg/description-logic/premises106.rdf",
"wg/description-logic/premises107.rdf",
"wg/description-logic/premises108.rdf",
"wg/description-logic/premises109.rdf",
"wg/description-logic/premises110.rdf",
"wg/description-logic/premises111.rdf",
"wg/description-logic/premises201.rdf",
"wg/description-logic/premises202.rdf",
"wg/description-logic/premises203.rdf",
"wg/description-logic/premises204.rdf",
"wg/description-logic/premises205.rdf",
"wg/description-logic/premises206.rdf",
"wg/description-logic/premises207.rdf",
"wg/description-logic/premises208.rdf",
"wg/description-logic/premises209.rdf",
"wg/description-logic/premises661.rdf",
"wg/description-logic/premises662.rdf",
"wg/description-logic/premises663.rdf",
"wg/description-logic/premises664.rdf",
"wg/description-logic/premises665.rdf",
"wg/description-logic/premises667.rdf",
"wg/description-logic/premises901.rdf",
"wg/description-logic/premises902.rdf",
"wg/description-logic/premises903.rdf",
"wg/description-logic/premises904.rdf",
"wg/description-logic/premises905.rdf",
"wg/differentFrom/conclusions001.rdf",
"wg/differentFrom/conclusions002.rdf",
"wg/differentFrom/Manifest001.rdf",
"wg/differentFrom/Manifest002.rdf",
"wg/differentFrom/premises001.rdf",
"wg/differentFrom/premises002.rdf",
"wg/disjointWith/conclusions001.rdf",
"wg/disjointWith/conclusions002.rdf",
"wg/disjointWith/consistent003.rdf",
"wg/disjointWith/consistent004.rdf",
"wg/disjointWith/consistent005.rdf",
"wg/disjointWith/consistent006.rdf",
"wg/disjointWith/consistent007.rdf",
"wg/disjointWith/consistent008.rdf",
"wg/disjointWith/consistent009.rdf",
"wg/disjointWith/inconsistent010.rdf",
"wg/disjointWith/Manifest001.rdf",
"wg/disjointWith/Manifest002.rdf",
"wg/disjointWith/Manifest003.rdf",
"wg/disjointWith/Manifest004.rdf",
"wg/disjointWith/Manifest005.rdf",
"wg/disjointWith/Manifest006.rdf",
"wg/disjointWith/Manifest007.rdf",
"wg/disjointWith/Manifest008.rdf",
"wg/disjointWith/Manifest009.rdf",
"wg/disjointWith/Manifest010.rdf",
"wg/disjointWith/premises001.rdf",
"wg/disjointWith/premises002.rdf",
"wg/distinctMembers/conclusions001.rdf",
"wg/distinctMembers/Manifest001.rdf",
"wg/distinctMembers/premises001.rdf", "wg/empty.rdf",
"wg/equivalentClass/conclusions001.rdf",
"wg/equivalentClass/conclusions002.rdf",
"wg/equivalentClass/conclusions003.rdf",
"wg/equivalentClass/conclusions004.rdf",
"wg/equivalentClass/conclusions006.rdf",
"wg/equivalentClass/conclusions007.rdf",
"wg/equivalentClass/consistent009.rdf",
"wg/equivalentClass/Manifest001.rdf",
"wg/equivalentClass/Manifest002.rdf",
"wg/equivalentClass/Manifest003.rdf",
"wg/equivalentClass/Manifest004.rdf",
"wg/equivalentClass/Manifest005.rdf",
"wg/equivalentClass/Manifest006.rdf",
"wg/equivalentClass/Manifest007.rdf",
"wg/equivalentClass/Manifest008.rdf",
"wg/equivalentClass/Manifest009.rdf",
"wg/equivalentClass/nonconclusions005.rdf",
"wg/equivalentClass/nonconclusions008.rdf",
"wg/equivalentClass/premises001.rdf",
"wg/equivalentClass/premises002.rdf",
"wg/equivalentClass/premises003.rdf",
"wg/equivalentClass/premises004.rdf",
"wg/equivalentClass/premises005.rdf",
"wg/equivalentClass/premises006.rdf",
"wg/equivalentClass/premises007.rdf",
"wg/equivalentClass/premises008.rdf",
"wg/equivalentProperty/conclusions001.rdf",
"wg/equivalentProperty/conclusions002.rdf",
"wg/equivalentProperty/conclusions003.rdf",
"wg/equivalentProperty/conclusions004.rdf",
"wg/equivalentProperty/conclusions005.rdf",
"wg/equivalentProperty/conclusions006.rdf",
"wg/equivalentProperty/Manifest001.rdf",
"wg/equivalentProperty/Manifest002.rdf",
"wg/equivalentProperty/Manifest003.rdf",
"wg/equivalentProperty/Manifest004.rdf",
"wg/equivalentProperty/Manifest005.rdf",
"wg/equivalentProperty/Manifest006.rdf",
"wg/equivalentProperty/premises001.rdf",
"wg/equivalentProperty/premises002.rdf",
"wg/equivalentProperty/premises003.rdf",
"wg/equivalentProperty/premises004.rdf",
"wg/equivalentProperty/premises005.rdf",
"wg/equivalentProperty/premises006.rdf",
"wg/extra-credit/conclusions002.rdf",
"wg/extra-credit/conclusions003.rdf",
"wg/extra-credit/conclusions004.rdf",
"wg/extra-credit/Manifest002.rdf",
"wg/extra-credit/Manifest003.rdf",
"wg/extra-credit/Manifest004.rdf",
"wg/extra-credit/premises002.rdf",
"wg/extra-credit/premises003.rdf",
"wg/extra-credit/premises004.rdf", "wg/false.rdf",
"wg/FunctionalProperty/conclusions001.rdf",
"wg/FunctionalProperty/conclusions002.rdf",
"wg/FunctionalProperty/conclusions003.rdf",
"wg/FunctionalProperty/conclusions004.rdf",
"wg/FunctionalProperty/conclusions005-mod.rdf",
"wg/FunctionalProperty/conclusions005.rdf",
"wg/FunctionalProperty/Manifest001.rdf",
"wg/FunctionalProperty/Manifest002.rdf",
"wg/FunctionalProperty/Manifest003.rdf",
"wg/FunctionalProperty/Manifest004.rdf",
"wg/FunctionalProperty/Manifest005-mod.rdf",
"wg/FunctionalProperty/Manifest005.rdf",
"wg/FunctionalProperty/nonconclusions004.rdf",
"wg/FunctionalProperty/premises001.rdf",
"wg/FunctionalProperty/premises002.rdf",
"wg/FunctionalProperty/premises003.rdf",
"wg/FunctionalProperty/premises004.rdf",
"wg/FunctionalProperty/premises005-mod.rdf",
"wg/FunctionalProperty/premises005.rdf", "wg/I3.2/bad001.rdf",
"wg/I3.2/bad002.rdf", "wg/I3.2/bad003.rdf",
"wg/I3.2/Manifest001.rdf", "wg/I3.2/Manifest002.rdf",
"wg/I3.2/Manifest003.rdf", "wg/I3.4/bad001.rdf",
"wg/I3.4/Manifest001.rdf", "wg/I4.1/bad001.rdf",
"wg/I4.1/Manifest001.rdf", "wg/I4.5/conclusions001.rdf",
"wg/I4.5/inconsistent002.rdf", "wg/I4.5/Manifest001.rdf",
"wg/I4.5/Manifest002.rdf", "wg/I4.5/premises001.rdf",
"wg/I4.6/bad006.rdf", "wg/I4.6/bad007.rdf", "wg/I4.6/bad008.rdf",
"wg/I4.6/conclusions003.rdf", "wg/I4.6/conclusions004.rdf",
"wg/I4.6/Manifest003.rdf", "wg/I4.6/Manifest004.rdf",
"wg/I4.6/Manifest005.rdf", "wg/I4.6/Manifest006.rdf",
"wg/I4.6/Manifest007.rdf", "wg/I4.6/Manifest008.rdf",
"wg/I4.6/nonconclusions004.rdf", "wg/I4.6/nonconclusions005.rdf",
"wg/I4.6/premises003.rdf", "wg/I4.6/premises004.rdf",
"wg/I4.6/premises005.rdf", "wg/I5.1/conclusions001.rdf",
"wg/I5.1/consistent010.rdf", "wg/I5.1/Manifest001.rdf",
"wg/I5.1/Manifest010.rdf", "wg/I5.1/premises001.rdf",
"wg/I5.2/conclusions002.rdf", "wg/I5.2/conclusions004.rdf",
"wg/I5.2/conclusions006.rdf", "wg/I5.2/consistent001.rdf",
"wg/I5.2/consistent003.rdf", "wg/I5.2/consistent005.rdf",
"wg/I5.2/consistent010.rdf", "wg/I5.2/consistent011.rdf",
"wg/I5.2/Manifest001.rdf", "wg/I5.2/Manifest002.rdf",
"wg/I5.2/Manifest003.rdf", "wg/I5.2/Manifest004.rdf",
"wg/I5.2/Manifest005.rdf", "wg/I5.2/Manifest006.rdf",
"wg/I5.2/Manifest010.rdf", "wg/I5.2/Manifest011.rdf",
"wg/I5.2/premises002.rdf", "wg/I5.2/premises004.rdf",
"wg/I5.2/premises006.rdf", "wg/I5.21/bad001.rdf",
"wg/I5.21/conclusions002.rdf", "wg/I5.21/Manifest001.rdf",
"wg/I5.21/Manifest002.rdf", "wg/I5.21/premises002.rdf",
"wg/I5.24/conclusions001.rdf", "wg/I5.24/conclusions002-mod.rdf",
"wg/I5.24/conclusions002.rdf", "wg/I5.24/conclusions003-mod.rdf",
"wg/I5.24/conclusions003.rdf", "wg/I5.24/conclusions004.rdf",
"wg/I5.24/Manifest001.rdf", "wg/I5.24/Manifest002-mod.rdf",
"wg/I5.24/Manifest002.rdf", "wg/I5.24/Manifest003-mod.rdf",
"wg/I5.24/Manifest003.rdf", "wg/I5.24/Manifest004-mod.rdf",
"wg/I5.24/Manifest004.rdf", "wg/I5.24/premises001.rdf",
"wg/I5.24/premises002-mod.rdf", "wg/I5.24/premises002.rdf",
"wg/I5.24/premises003-mod.rdf", "wg/I5.24/premises003.rdf",
"wg/I5.24/premises004-mod.rdf", "wg/I5.24/premises004.rdf",
"wg/I5.26/conclusions009.rdf", "wg/I5.26/conclusions010.rdf",
"wg/I5.26/consistent001.rdf", "wg/I5.26/consistent002.rdf",
"wg/I5.26/consistent003.rdf", "wg/I5.26/consistent004.rdf",
"wg/I5.26/consistent005.rdf", "wg/I5.26/consistent006.rdf",
"wg/I5.26/consistent007.rdf", "wg/I5.26/Manifest001.rdf",
"wg/I5.26/Manifest002.rdf", "wg/I5.26/Manifest003.rdf",
"wg/I5.26/Manifest004.rdf", "wg/I5.26/Manifest005.rdf",
"wg/I5.26/Manifest006.rdf", "wg/I5.26/Manifest007.rdf",
"wg/I5.26/Manifest009.rdf", "wg/I5.26/Manifest010.rdf",
"wg/I5.26/premises009.rdf", "wg/I5.26/premises010.rdf",
"wg/I5.3/conclusions014.rdf", "wg/I5.3/conclusions015.rdf",
"wg/I5.3/consistent005.rdf", "wg/I5.3/consistent006.rdf",
"wg/I5.3/consistent007.rdf", "wg/I5.3/consistent008.rdf",
"wg/I5.3/consistent009.rdf", "wg/I5.3/consistent010.rdf",
"wg/I5.3/consistent011.rdf", "wg/I5.3/Manifest005.rdf",
"wg/I5.3/Manifest006.rdf", "wg/I5.3/Manifest007.rdf",
"wg/I5.3/Manifest008.rdf", "wg/I5.3/Manifest009.rdf",
"wg/I5.3/Manifest010.rdf", "wg/I5.3/Manifest011.rdf",
"wg/I5.3/Manifest014.rdf", "wg/I5.3/Manifest015.rdf",
"wg/I5.3/premises014.rdf", "wg/I5.3/premises015.rdf",
"wg/I5.5/conclusions001.rdf", "wg/I5.5/conclusions002.rdf",
"wg/I5.5/conclusions005.rdf", "wg/I5.5/inconsistent003.rdf",
"wg/I5.5/inconsistent004.rdf", "wg/I5.5/Manifest001.rdf",
"wg/I5.5/Manifest002.rdf", "wg/I5.5/Manifest003.rdf",
"wg/I5.5/Manifest004.rdf", "wg/I5.5/Manifest005.rdf",
"wg/I5.5/Manifest006.rdf", "wg/I5.5/Manifest007.rdf",
"wg/I5.5/nonconclusions006.rdf", "wg/I5.5/nonconclusions007.rdf",
"wg/I5.5/premises001.rdf", "wg/I5.5/premises002.rdf",
"wg/I5.5/premises005.rdf", "wg/I5.5/premises006.rdf",
"wg/I5.5/premises007.rdf", "wg/I5.8/conclusions004.rdf",
"wg/I5.8/conclusions006.rdf", "wg/I5.8/conclusions008.rdf",
"wg/I5.8/conclusions009.rdf", "wg/I5.8/conclusions010.rdf",
"wg/I5.8/conclusions011.rdf", "wg/I5.8/conclusions017.rdf",
"wg/I5.8/consistent002.rdf", "wg/I5.8/consistent012.rdf",
"wg/I5.8/consistent013.rdf", "wg/I5.8/consistent014.rdf",
"wg/I5.8/consistent015.rdf", "wg/I5.8/consistent016.rdf",
"wg/I5.8/inconsistent001.rdf", "wg/I5.8/inconsistent003.rdf",
"wg/I5.8/Manifest001.rdf", "wg/I5.8/Manifest002.rdf",
"wg/I5.8/Manifest003.rdf", "wg/I5.8/Manifest004.rdf",
"wg/I5.8/Manifest005.rdf", "wg/I5.8/Manifest006.rdf",
"wg/I5.8/Manifest007.rdf", "wg/I5.8/Manifest008.rdf",
"wg/I5.8/Manifest009.rdf", "wg/I5.8/Manifest010.rdf",
"wg/I5.8/Manifest011.rdf", "wg/I5.8/Manifest012.rdf",
"wg/I5.8/Manifest013.rdf", "wg/I5.8/Manifest014.rdf",
"wg/I5.8/Manifest015.rdf", "wg/I5.8/Manifest016.rdf",
"wg/I5.8/Manifest017.rdf", "wg/I5.8/nonconclusions005.rdf",
"wg/I5.8/nonconclusions007.rdf", "wg/I5.8/premises004.rdf",
"wg/I5.8/premises005.rdf", "wg/I5.8/premises006.rdf",
"wg/I5.8/premises007.rdf", "wg/I5.8/premises008.rdf",
"wg/I5.8/premises009.rdf", "wg/I5.8/premises010.rdf",
"wg/I5.8/premises011.rdf", "wg/I5.8/premises017.rdf",
"wg/I6.1/consistent001.rdf", "wg/I6.1/Manifest001.rdf",
"wg/imports/conclusions001.rdf", "wg/imports/conclusions002.rdf",
"wg/imports/conclusions003.rdf", "wg/imports/conclusions010.rdf",
"wg/imports/conclusions011.rdf", "wg/imports/consistent012.rdf",
"wg/imports/imports004.rdf", "wg/imports/imports005.rdf",
"wg/imports/imports006.rdf", "wg/imports/imports007.rdf",
"wg/imports/imports008.rdf", "wg/imports/imports013.rdf",
"wg/imports/imports014.rdf", "wg/imports/main004.rdf",
"wg/imports/main005.rdf", "wg/imports/main006.rdf",
"wg/imports/main007.rdf", "wg/imports/main008.rdf",
"wg/imports/main013.rdf", "wg/imports/main014.rdf",
"wg/imports/Manifest001.rdf", "wg/imports/Manifest002.rdf",
"wg/imports/Manifest003.rdf", "wg/imports/Manifest004.rdf",
"wg/imports/Manifest005.rdf", "wg/imports/Manifest006.rdf",
"wg/imports/Manifest007.rdf", "wg/imports/Manifest008.rdf",
"wg/imports/Manifest010.rdf", "wg/imports/Manifest011.rdf",
"wg/imports/Manifest012.rdf", "wg/imports/Manifest013.rdf",
"wg/imports/Manifest014.rdf", "wg/imports/nonconclusions002.rdf",
"wg/imports/premises001.rdf", "wg/imports/premises002.rdf",
"wg/imports/premises003.rdf", "wg/imports/premises011.rdf",
"wg/imports/support001-A.rdf", "wg/imports/support002-A.rdf",
"wg/imports/support003-A.rdf", "wg/imports/support003-B.rdf",
"wg/imports/support011-A.rdf",
"wg/intersectionOf/conclusions001.rdf",
"wg/intersectionOf/Manifest001.rdf",
"wg/intersectionOf/premises001.rdf",
"wg/InverseFunctionalProperty/conclusions001.rdf",
"wg/InverseFunctionalProperty/conclusions002.rdf",
"wg/InverseFunctionalProperty/conclusions003.rdf",
"wg/InverseFunctionalProperty/conclusions004.rdf",
"wg/InverseFunctionalProperty/Manifest001.rdf",
"wg/InverseFunctionalProperty/Manifest002.rdf",
"wg/InverseFunctionalProperty/Manifest003.rdf",
"wg/InverseFunctionalProperty/Manifest004.rdf",
"wg/InverseFunctionalProperty/nonconclusions004.rdf",
"wg/InverseFunctionalProperty/premises001.rdf",
"wg/InverseFunctionalProperty/premises002.rdf",
"wg/InverseFunctionalProperty/premises003.rdf",
"wg/InverseFunctionalProperty/premises004.rdf",
"wg/inverseOf/conclusions001.rdf", "wg/inverseOf/Manifest001.rdf",
"wg/inverseOf/premises001.rdf", "wg/localtests/conclusions001.rdf",
"wg/localtests/conclusions002.rdf",
"wg/localtests/conclusions003.rdf",
"wg/localtests/conclusions004.rdf",
"wg/localtests/conclusions005.rdf",
"wg/localtests/conclusions006.rdf",
"wg/localtests/conclusionsRestriction001.rdf",
"wg/localtests/conclusionsSubclass001.rdf",
"wg/localtests/Manifest001.rdf", "wg/localtests/Manifest002.rdf",
"wg/localtests/Manifest003.rdf", "wg/localtests/Manifest004.rdf",
"wg/localtests/Manifest005.rdf", "wg/localtests/Manifest006.rdf",
"wg/localtests/ManifestRestriction001.rdf",
"wg/localtests/ManifestSubclass001.rdf",
"wg/localtests/premises001.rdf", "wg/localtests/premises003.rdf",
"wg/localtests/premises004.rdf", "wg/localtests/premises005.rdf",
"wg/localtests/premises006.rdf",
"wg/localtests/premisesRestriction001.rdf",
"wg/localtests/premisesSubclass001.rdf", "wg/Manifest-extra.rdf",
"wg/Manifest-wrong.rdf", "wg/Manifest.rdf",
"wg/maxCardinality/inconsistent001.rdf",
"wg/maxCardinality/inconsistent002.rdf",
"wg/maxCardinality/Manifest001.rdf",
"wg/maxCardinality/Manifest002.rdf",
"wg/miscellaneous/conclusions010.rdf",
"wg/miscellaneous/conclusions011.rdf",
"wg/miscellaneous/consistent001.rdf",
"wg/miscellaneous/consistent002.rdf",
"wg/miscellaneous/consistent102.rdf",
"wg/miscellaneous/consistent103.rdf",
"wg/miscellaneous/consistent201.rdf",
"wg/miscellaneous/consistent202.rdf",
"wg/miscellaneous/consistent205.rdf",
"wg/miscellaneous/consistent303.rdf",
"wg/miscellaneous/example001.rdf",
"wg/miscellaneous/example002.rdf",
"wg/miscellaneous/inconsistent203.rdf",
"wg/miscellaneous/inconsistent204.rdf",
"wg/miscellaneous/Manifest001.rdf",
"wg/miscellaneous/Manifest002.rdf",
"wg/miscellaneous/Manifest010.rdf",
"wg/miscellaneous/Manifest011.rdf",
"wg/miscellaneous/Manifest102.rdf",
"wg/miscellaneous/Manifest103.rdf",
"wg/miscellaneous/Manifest201.rdf",
"wg/miscellaneous/Manifest202.rdf",
"wg/miscellaneous/Manifest203.rdf",
"wg/miscellaneous/Manifest204.rdf",
"wg/miscellaneous/Manifest205.rdf",
"wg/miscellaneous/Manifest301.rdf",
"wg/miscellaneous/Manifest302.rdf",
"wg/miscellaneous/Manifest303.rdf",
"wg/miscellaneous/nonconclusions301.rdf",
"wg/miscellaneous/nonconclusions302.rdf",
"wg/miscellaneous/old-consistent001.rdf",
"wg/miscellaneous/old-consistent002.rdf",
"wg/miscellaneous/premises010.rdf",
"wg/miscellaneous/premises011.rdf",
"wg/miscellaneous/premises301.rdf",
"wg/miscellaneous/premises302.rdf",
"wg/Nothing/conclusions002.rdf", "wg/Nothing/inconsistent001.rdf",
"wg/Nothing/Manifest001.rdf", "wg/Nothing/Manifest002.rdf",
"wg/Nothing/premises002.rdf", "wg/oneOf/conclusions002.rdf",
"wg/oneOf/conclusions003.rdf", "wg/oneOf/conclusions004.rdf",
"wg/oneOf/consistent001.rdf", "wg/oneOf/Manifest001.rdf",
"wg/oneOf/Manifest002.rdf", "wg/oneOf/Manifest003.rdf",
"wg/oneOf/Manifest004.rdf", "wg/oneOf/premises002.rdf",
"wg/oneOf/premises003.rdf", "wg/oneOf/premises004.rdf",
"wg/Ontology/conclusions001.rdf", "wg/Ontology/conclusions004.rdf",
"wg/Ontology/Manifest001.rdf", "wg/Ontology/Manifest003.rdf",
"wg/Ontology/Manifest004.rdf", "wg/Ontology/nonconclusions003.rdf",
"wg/Ontology/premises001.rdf", "wg/Ontology/premises003.rdf",
"wg/Ontology/premises004.rdf", "wg/OWLManifest.rdf",
"wg/rdf-charmod-literals/error001.rdf",
"wg/rdf-charmod-literals/error002.rdf",
"wg/rdf-charmod-literals/test001.rdf",
"wg/rdf-charmod-uris/error001.rdf",
"wg/rdf-charmod-uris/Manifest.rdf",
"wg/rdf-charmod-uris/test001.rdf",
"wg/rdf-charmod-uris/test002.rdf",
"wg/rdf-containers-syntax-vs-schema/error001.rdf",
"wg/rdf-containers-syntax-vs-schema/error002.rdf",
"wg/rdf-containers-syntax-vs-schema/test001.rdf",
"wg/rdf-containers-syntax-vs-schema/test002.rdf",
"wg/rdf-containers-syntax-vs-schema/test003.rdf",
"wg/rdf-containers-syntax-vs-schema/test004.rdf",
"wg/rdf-containers-syntax-vs-schema/test005.rdf",
"wg/rdf-containers-syntax-vs-schema/test006.rdf",
"wg/rdf-containers-syntax-vs-schema/test007.rdf",
"wg/rdf-containers-syntax-vs-schema/test008.rdf",
"wg/rdf-ns-prefix-confusion/error0001.rdf",
"wg/rdf-ns-prefix-confusion/error0002.rdf",
"wg/rdf-ns-prefix-confusion/error0003.rdf",
"wg/rdf-ns-prefix-confusion/error0004.rdf",
"wg/rdf-ns-prefix-confusion/error0005.rdf",
"wg/rdf-ns-prefix-confusion/error0006.rdf",
"wg/rdf-ns-prefix-confusion/error0007.rdf",
"wg/rdf-ns-prefix-confusion/error0008.rdf",
"wg/rdf-ns-prefix-confusion/error0009.rdf",
"wg/rdf-ns-prefix-confusion/test0001.rdf",
"wg/rdf-ns-prefix-confusion/test0002.rdf",
"wg/rdf-ns-prefix-confusion/test0003.rdf",
"wg/rdf-ns-prefix-confusion/test0004.rdf",
"wg/rdf-ns-prefix-confusion/test0005.rdf",
"wg/rdf-ns-prefix-confusion/test0006.rdf",
"wg/rdf-ns-prefix-confusion/test0007.rdf",
"wg/rdf-ns-prefix-confusion/test0008.rdf",
"wg/rdf-ns-prefix-confusion/test0009.rdf",
"wg/rdf-ns-prefix-confusion/test0010.rdf",
"wg/rdf-ns-prefix-confusion/test0011.rdf",
"wg/rdf-ns-prefix-confusion/test0012.rdf",
"wg/rdf-ns-prefix-confusion/test0013.rdf",
"wg/rdf-ns-prefix-confusion/test0014.rdf",
"wg/rdfms-abouteach/error001.rdf",
"wg/rdfms-abouteach/error002.rdf",
"wg/rdfms-difference-between-ID-and-about/error1.rdf",
"wg/rdfms-difference-between-ID-and-about/test1.rdf",
"wg/rdfms-difference-between-ID-and-about/test2.rdf",
"wg/rdfms-difference-between-ID-and-about/test3.rdf",
"wg/rdfms-duplicate-member-props/test001.rdf",
"wg/rdfms-empty-property-elements/error001.rdf",
"wg/rdfms-empty-property-elements/error002.rdf",
"wg/rdfms-empty-property-elements/error003.rdf",
"wg/rdfms-empty-property-elements/test001.rdf",
"wg/rdfms-empty-property-elements/test002.rdf",
"wg/rdfms-empty-property-elements/test003.rdf",
"wg/rdfms-empty-property-elements/test004.rdf",
"wg/rdfms-empty-property-elements/test005.rdf",
"wg/rdfms-empty-property-elements/test006.rdf",
"wg/rdfms-empty-property-elements/test007.rdf",
"wg/rdfms-empty-property-elements/test008.rdf",
"wg/rdfms-empty-property-elements/test009.rdf",
"wg/rdfms-empty-property-elements/test010.rdf",
"wg/rdfms-empty-property-elements/test011.rdf",
"wg/rdfms-empty-property-elements/test012.rdf",
"wg/rdfms-empty-property-elements/test013.rdf",
"wg/rdfms-empty-property-elements/test014.rdf",
"wg/rdfms-empty-property-elements/test015.rdf",
"wg/rdfms-empty-property-elements/test016.rdf",
"wg/rdfms-empty-property-elements/test017.rdf",
"wg/rdfms-identity-anon-resources/test001.rdf",
"wg/rdfms-identity-anon-resources/test002.rdf",
"wg/rdfms-identity-anon-resources/test003.rdf",
"wg/rdfms-identity-anon-resources/test004.rdf",
"wg/rdfms-identity-anon-resources/test005.rdf",
"wg/rdfms-literal-is-xml-structure/test001.rdf",
"wg/rdfms-literal-is-xml-structure/test002.rdf",
"wg/rdfms-literal-is-xml-structure/test003.rdf",
"wg/rdfms-literal-is-xml-structure/test004.rdf",
"wg/rdfms-literal-is-xml-structure/test005.rdf",
// "wg/rdfms-nested-bagIDs/test001.rdf",
"wg/rdfms-nested-bagIDs/test002.rdf",
// "wg/rdfms-nested-bagIDs/test003.rdf",
"wg/rdfms-nested-bagIDs/test004.rdf",
"wg/rdfms-nested-bagIDs/test005.rdf",
"wg/rdfms-nested-bagIDs/test006.rdf",
"wg/rdfms-nested-bagIDs/test007.rdf",
"wg/rdfms-nested-bagIDs/test008.rdf",
"wg/rdfms-nested-bagIDs/test009.rdf",
"wg/rdfms-nested-bagIDs/test010.rdf",
"wg/rdfms-nested-bagIDs/test011.rdf",
"wg/rdfms-nested-bagIDs/test012.rdf",
"wg/rdfms-not-id-and-resource-attr/test001.rdf",
"wg/rdfms-not-id-and-resource-attr/test002.rdf",
"wg/rdfms-not-id-and-resource-attr/test003.rdf",
"wg/rdfms-not-id-and-resource-attr/test004.rdf",
"wg/rdfms-not-id-and-resource-attr/test005.rdf",
"wg/rdfms-para196/test001.rdf", "wg/rdfms-parseType/error001.rdf",
"wg/rdfms-parseType/error002.rdf",
"wg/rdfms-parseType/error003.rdf", "wg/rdfms-rdf-id/error001.rdf",
"wg/rdfms-rdf-id/error002.rdf", "wg/rdfms-rdf-id/error003.rdf",
"wg/rdfms-rdf-id/error004.rdf", "wg/rdfms-rdf-id/error005.rdf",
"wg/rdfms-rdf-id/error006.rdf", "wg/rdfms-rdf-id/error007.rdf",
"wg/rdfms-rdf-names-use/error-001.rdf",
"wg/rdfms-rdf-names-use/error-002.rdf",
"wg/rdfms-rdf-names-use/error-003.rdf",
"wg/rdfms-rdf-names-use/error-004.rdf",
"wg/rdfms-rdf-names-use/error-005.rdf",
"wg/rdfms-rdf-names-use/error-006.rdf",
"wg/rdfms-rdf-names-use/error-007.rdf",
"wg/rdfms-rdf-names-use/error-008.rdf",
"wg/rdfms-rdf-names-use/error-009.rdf",
"wg/rdfms-rdf-names-use/error-010.rdf",
"wg/rdfms-rdf-names-use/error-011.rdf",
"wg/rdfms-rdf-names-use/error-012.rdf",
"wg/rdfms-rdf-names-use/error-013.rdf",
"wg/rdfms-rdf-names-use/error-014.rdf",
"wg/rdfms-rdf-names-use/error-015.rdf",
"wg/rdfms-rdf-names-use/error-016.rdf",
"wg/rdfms-rdf-names-use/error-017.rdf",
"wg/rdfms-rdf-names-use/error-018.rdf",
"wg/rdfms-rdf-names-use/error-019.rdf",
"wg/rdfms-rdf-names-use/error-020.rdf",
"wg/rdfms-rdf-names-use/test-001.rdf",
"wg/rdfms-rdf-names-use/test-002.rdf",
"wg/rdfms-rdf-names-use/test-003.rdf",
"wg/rdfms-rdf-names-use/test-004.rdf",
"wg/rdfms-rdf-names-use/test-005.rdf",
"wg/rdfms-rdf-names-use/test-006.rdf",
"wg/rdfms-rdf-names-use/test-007.rdf",
"wg/rdfms-rdf-names-use/test-008.rdf",
"wg/rdfms-rdf-names-use/test-009.rdf",
"wg/rdfms-rdf-names-use/test-010.rdf",
"wg/rdfms-rdf-names-use/test-011.rdf",
"wg/rdfms-rdf-names-use/test-012.rdf",
"wg/rdfms-rdf-names-use/test-013.rdf",
"wg/rdfms-rdf-names-use/test-014.rdf",
"wg/rdfms-rdf-names-use/test-015.rdf",
"wg/rdfms-rdf-names-use/test-016.rdf",
"wg/rdfms-rdf-names-use/test-017.rdf",
"wg/rdfms-rdf-names-use/test-018.rdf",
"wg/rdfms-rdf-names-use/test-019.rdf",
"wg/rdfms-rdf-names-use/test-020.rdf",
"wg/rdfms-rdf-names-use/test-021.rdf",
"wg/rdfms-rdf-names-use/test-022.rdf",
"wg/rdfms-rdf-names-use/test-023.rdf",
"wg/rdfms-rdf-names-use/test-024.rdf",
"wg/rdfms-rdf-names-use/test-025.rdf",
"wg/rdfms-rdf-names-use/test-026.rdf",
"wg/rdfms-rdf-names-use/test-027.rdf",
"wg/rdfms-rdf-names-use/test-028.rdf",
"wg/rdfms-rdf-names-use/test-029.rdf",
"wg/rdfms-rdf-names-use/test-030.rdf",
"wg/rdfms-rdf-names-use/test-031.rdf",
"wg/rdfms-rdf-names-use/test-032.rdf",
"wg/rdfms-rdf-names-use/test-033.rdf",
"wg/rdfms-rdf-names-use/test-034.rdf",
"wg/rdfms-rdf-names-use/test-035.rdf",
"wg/rdfms-rdf-names-use/test-036.rdf",
"wg/rdfms-rdf-names-use/test-037.rdf",
"wg/rdfms-rdf-names-use/warn-001.rdf",
"wg/rdfms-rdf-names-use/warn-002.rdf",
"wg/rdfms-rdf-names-use/warn-003.rdf",
"wg/rdfms-reification-required/test001.rdf",
"wg/rdfms-seq-representation/test001.rdf",
"wg/rdfms-syntax-incomplete/error001.rdf",
"wg/rdfms-syntax-incomplete/error002.rdf",
"wg/rdfms-syntax-incomplete/error003.rdf",
"wg/rdfms-syntax-incomplete/error004.rdf",
"wg/rdfms-syntax-incomplete/error005.rdf",
"wg/rdfms-syntax-incomplete/error006.rdf",
"wg/rdfms-syntax-incomplete/test001.rdf",
"wg/rdfms-syntax-incomplete/test002.rdf",
"wg/rdfms-syntax-incomplete/test003.rdf",
"wg/rdfms-syntax-incomplete/test004.rdf",
"wg/rdfms-uri-substructure/test001.rdf",
"wg/rdfms-xml-literal-namespaces/test001.rdf",
"wg/rdfms-xml-literal-namespaces/test002.rdf",
"wg/rdfms-xmllang/test001.rdf", "wg/rdfms-xmllang/test002.rdf",
"wg/rdfms-xmllang/test003.rdf", "wg/rdfms-xmllang/test004.rdf",
"wg/rdfms-xmllang/test005.rdf", "wg/rdfms-xmllang/test006.rdf",
"wg/rdfs-container-membership-superProperty/not1C.rdf",
"wg/rdfs-container-membership-superProperty/not1P.rdf",
"wg/rdfs-domain-and-range/nonconclusions005.rdf",
"wg/rdfs-domain-and-range/nonconclusions006.rdf",
"wg/rdfs-domain-and-range/premises005.rdf",
"wg/rdfs-domain-and-range/premises006.rdf",
"wg/rdfs-domain-and-range/test001.rdf",
"wg/rdfs-domain-and-range/test002.rdf",
"wg/rdfs-domain-and-range/test003.rdf",
"wg/rdfs-domain-and-range/test004.rdf",
"wg/rdfs-no-cycles-in-subClassOf/test001.rdf",
"wg/rdfs-no-cycles-in-subPropertyOf/test001.rdf",
"wg/Restriction/conclusions006.rdf",
"wg/Restriction/consistent003.rdf",
"wg/Restriction/consistent004.rdf",
"wg/Restriction/inconsistent001.rdf",
"wg/Restriction/inconsistent002.rdf",
"wg/Restriction/Manifest001.rdf", "wg/Restriction/Manifest002.rdf",
"wg/Restriction/Manifest003.rdf", "wg/Restriction/Manifest004.rdf",
"wg/Restriction/Manifest005.rdf", "wg/Restriction/Manifest006.rdf",
"wg/Restriction/nonconclusions005.rdf",
"wg/Restriction/premises005.rdf", "wg/Restriction/premises006.rdf",
"wg/sameAs/conclusions001.rdf", "wg/sameAs/Manifest001.rdf",
"wg/sameAs/premises001.rdf",
"wg/someValuesFrom/conclusions001.rdf",
"wg/someValuesFrom/conclusions003.rdf",
"wg/someValuesFrom/Manifest001.rdf",
"wg/someValuesFrom/Manifest002.rdf",
"wg/someValuesFrom/Manifest003.rdf",
"wg/someValuesFrom/nonconclusions002.rdf",
"wg/someValuesFrom/premises001.rdf",
"wg/someValuesFrom/premises002.rdf",
"wg/someValuesFrom/premises003.rdf",
"wg/SymmetricProperty/conclusions001.rdf",
"wg/SymmetricProperty/conclusions002.rdf",
"wg/SymmetricProperty/conclusions003.rdf",
"wg/SymmetricProperty/Manifest001.rdf",
"wg/SymmetricProperty/Manifest002.rdf",
"wg/SymmetricProperty/Manifest003.rdf",
"wg/SymmetricProperty/premises001.rdf",
"wg/SymmetricProperty/premises002.rdf",
"wg/SymmetricProperty/premises003.rdf", "wg/testOntology.rdf",
"wg/Thing/consistent004.rdf", "wg/Thing/inconsistent003.rdf",
"wg/Thing/inconsistent005.rdf", "wg/Thing/Manifest003.rdf",
"wg/Thing/Manifest004.rdf", "wg/Thing/Manifest005.rdf",
"wg/TransitiveProperty/conclusions001.rdf",
"wg/TransitiveProperty/conclusions002.rdf",
"wg/TransitiveProperty/Manifest001.rdf",
"wg/TransitiveProperty/Manifest002.rdf",
"wg/TransitiveProperty/premises001.rdf",
"wg/TransitiveProperty/premises002.rdf",
"wg/unionOf/conclusions001.rdf", "wg/unionOf/conclusions002.rdf",
"wg/unionOf/conclusions003.rdf", "wg/unionOf/conclusions004.rdf",
"wg/unionOf/Manifest001.rdf", "wg/unionOf/Manifest002.rdf",
"wg/unionOf/Manifest003.rdf", "wg/unionOf/Manifest004.rdf",
"wg/unionOf/premises001.rdf", "wg/unionOf/premises002.rdf",
"wg/unionOf/premises003.rdf", "wg/unionOf/premises004.rdf",
"wg/unrecognised-xml-attributes/test001.rdf",
"wg/unrecognised-xml-attributes/test002.rdf",
"arp/dom/domtest.rdf",
//"wg/xmlbase/error001.rdf", "wg/xmlbase/test001.rdf",
"wg/xmlbase/test002.rdf", "wg/xmlbase/test003.rdf",
"wg/xmlbase/test004.rdf", "wg/xmlbase/test005.rdf",
"wg/xmlbase/test006.rdf", "wg/xmlbase/test007.rdf",
"wg/xmlbase/test008.rdf", "wg/xmlbase/test009.rdf",
"wg/xmlbase/test010.rdf", "wg/xmlbase/test011.rdf",
"wg/xmlbase/test012.rdf", "wg/xmlbase/test013.rdf",
"wg/xmlbase/test014.rdf", "wg/xmlbase/test015.rdf",
"wg/xmlbase/test016.rdf",
};
static class RDFEHArray implements RDFErrorHandler {
Vector<String> v = new Vector<>();
/*
* (non-Javadoc)
*
* @see org.apache.jena.rdf.model.RDFErrorHandler#warning(java.lang.Exception)
*/
@Override
public void warning(Exception e) {
s("W", e);
}
/*
* (non-Javadoc)
*
* @see org.apache.jena.rdf.model.RDFErrorHandler#error(java.lang.Exception)
*/
@Override
public void error(Exception e) {
s("E", e);
}
/*
* (non-Javadoc)
*
* @see org.apache.jena.rdf.model.RDFErrorHandler.errorError(java.lang.Exception)
*/
@Override
public void fatalError(Exception e) {
s("F", e);
}
private void s(String s, Exception e) {
String msg = s + e.getMessage();
if (!v.contains(msg))
v.add(msg);
}
}
static public TestSuite suite() {
TestSuite s = new TestSuite("SAX2RDF");
// s.addTestSuite(PushMePullYouTest.class);
s.addTestSuite(SAX2RDFMoreTests.class);
//for (int j=0; j<20; j++)
for (int i = 0; i < all.length; i += 25) {
// String nm = all[i];
//if (all[i].indexOf("premises663")==-1)
// continue;
if (all[i].startsWith("wg/")) {
addTests(s, "wg/", ARPTests.wgTestDir.toString(),
all[i].substring(3));
} else if (all[i].startsWith("arp/")) {
addTests(s,"arp/", ARPTests.arpTestDir
.toString(), all[i].substring(4));
} else {
addTests(s,"", "http://example.org/", all[i]);
}
}
// s.addTest(new
// SAX2RDFTest("wg/",ARPTests.wgTestDir.toString(),"Manifest.rdf"));
return s;
}
static private void addTests(TestSuite s, String dir, String base, String file){
TestCase tc = new SAX2RDFTest(dir,base,file);
tc.setName("SAX "+tc.getName());
s.addTest(tc);
tc = new DOM2RDFTest(dir,base,file);
tc.setName("DOM "+tc.getName());
s.addTest(tc);
}
//final private String dir;
final String base;
final private String file;
SAX2RDFTest(String dir, String base0, String file) {
super(file);
//this.dir = dir;
this.base = base0 + file;
this.file = "testing/" + dir + file;
//System.err.println(base+" + "+this.file);
}
@Override
public void runTest() throws Exception {
//System.err.println(base+" + "+this.file);
Model m = ModelFactory.createDefaultModel();
Model m2 = ModelFactory.createDefaultModel();
RDFEHArray eh = new RDFEHArray();
try ( InputStream in = new FileInputStream(file) ) {
RDFReaderI w = m.getReader();
w.setErrorHandler(eh);
w.read(m, in, base);
}
RDFEHArray eh2 = new RDFEHArray();
try ( InputStream in = new FileInputStream(file) ) {
/*
* w = m.getReader(); w.setErrorHandler(eh2); w.read(m2,in,base);
* in.close();
*/
loadXMLModel(m2, in, eh2);
}
/*
* System.out.println("Normal:"); m.write(System.out,"N-TRIPLE");
*
* System.out.println("New:"); m2.write(System.out,"N-TRIPLE");
*/
if (eh.v.size() == 0)
assertTrue("Not isomorphic", m.isIsomorphicWith(m2));
if (eh.v.size() != eh2.v.size()) {
for (int i = 0; i < eh.v.size(); i++)
System.err.println(eh.v.get(i));
System.err.println("---");
for (int i = 0; i < eh2.v.size(); i++)
System.err.println(eh2.v.get(i));
}
assertEquals("Different number of errors", eh.v.size(), eh2.v.size());
Object a[] = eh.v.toArray();
Object a2[] = eh2.v.toArray();
Arrays.sort(a);
Arrays.sort(a2);
for (int i = 0; i < eh.v.size(); i++) {
assertEquals("Error " + i + " different.", a[i], a2[i]);
}
}
void loadXMLModel(Model m2, InputStream in, RDFEHArray eh2) throws SAXException, IOException, ParserConfigurationException {
XMLReader saxParser = SAXParserFactory.newInstance().newSAXParser().getXMLReader();
SAX2Model handler = SAX2Model.create(base, m2);
SAX2RDF.installHandlers(saxParser, handler);
handler.setErrorHandler(eh2);
InputSource ins = new InputSource(in);
ins.setSystemId(base);
try {
try {
saxParser.parse(ins);
} finally {
handler.close();
}
} catch (SAXParseException e) {
// already reported, leave it be.
}
}
}
|
lveay2/algorithm-solutions | src/main/java/lintcode/system_design/mini_cassandra/Column.java | <filename>src/main/java/lintcode/system_design/mini_cassandra/Column.java<gh_stars>0
package lintcode.system_design.mini_cassandra;
public class Column {
public int key;
public String value;
public Column(int key, String value) {
this.key = key;
this.value = value;
}
@Override
public String toString() {
return "(" + key + ", \"" + value + "\")";
}
}
|
ivadasz/DragonFlyBSD | contrib/groff/src/devices/grohtml/html.h | // -*- C++ -*-
/* Copyright (C) 2000, 2001, 2002, 2004, 2009
Free Software Foundation, Inc.
Written by <NAME> (<EMAIL>)
This file is part of groff.
groff is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation, either version 3 of the License, or
(at your option) any later version.
groff is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#if !defined(HTML_H)
# define HTML_H
/*
* class and structure needed to buffer words
*/
struct word {
char *s;
word *next;
word (const char *w, int n);
~word ();
};
class word_list {
public:
word_list ();
int flush (FILE *f);
void add_word (const char *s, int n);
int get_length (void);
private:
int length;
word *head;
word *tail;
};
class simple_output {
public:
simple_output(FILE *, int max_line_length);
simple_output &put_string(const char *, int);
simple_output &put_string(const char *s);
simple_output &put_string(const string &s);
simple_output &put_troffps_char (const char *s);
simple_output &put_translated_string(const char *s);
simple_output &put_number(int);
simple_output &put_float(double);
simple_output &put_symbol(const char *);
simple_output &put_literal_symbol(const char *);
simple_output &set_fixed_point(int);
simple_output &simple_comment(const char *);
simple_output &begin_comment(const char *);
simple_output &comment_arg(const char *);
simple_output &end_comment();
simple_output &set_file(FILE *);
simple_output &include_file(FILE *);
simple_output ©_file(FILE *);
simple_output &end_line();
simple_output &put_raw_char(char);
simple_output &special(const char *);
simple_output &enable_newlines(int);
simple_output &check_newline(int n);
simple_output &nl(void);
simple_output &force_nl(void);
simple_output &space_or_newline (void);
simple_output &begin_tag (void);
FILE *get_file();
private:
FILE *fp;
int max_line_length; // not including newline
int col;
int fixed_point;
int newlines; // can we issue newlines automatically?
word_list last_word;
void flush_last_word (void);
int check_space (const char *s, int n);
};
inline FILE *simple_output::get_file()
{
return fp;
}
#endif
|
juseongkr/BOJ | acmicpc/1251.py | s, r = input(), '~'
for i in range(0, len(s)-2):
for j in range(i+1, len(s)-1):
r = min(r, s[i::-1]+s[j:i:-1]+s[:j:-1])
print(r)
|
KakeruMizuno/RDM-waterbutler | tests/providers/googlecloud/fixtures/folders.py | <gh_stars>10-100
import os
import pytest
from waterbutler.core.path import WaterButlerPath
@pytest.fixture()
def folder_wb_path():
return WaterButlerPath('/xml-api/folder-1/')
@pytest.fixture()
def folder_name():
return 'folder-1'
@pytest.fixture()
def folder_obj_name():
return 'xml-api/folder-1/'
@pytest.fixture()
def meta_folder_raw():
with open(os.path.join(os.path.dirname(__file__), 'metadata/folder-raw.json'), 'r') as fp:
return fp.read()
@pytest.fixture()
def meta_folder_parsed():
with open(os.path.join(os.path.dirname(__file__), 'metadata/folder-parsed.json'), 'r') as fp:
return fp.read()
@pytest.fixture()
def meta_folder_resp_headers_raw():
with open(os.path.join(os.path.dirname(__file__), 'resp_headers/folder-raw.json'), 'r') as fp:
return fp.read()
|
nikhilg85/peerhuntr | QuastionMasterDaoImpl.java | package com.infodart.peerhuntr.jpa.dao.impl.basedao;
import java.util.ArrayList;
import java.util.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.orm.hibernate5.HibernateTemplate;
public class QuastionMasterDaoImpl {
}
|
tonioshikanlu/tubman-hack | sources/androidx/core/app/ActivityRecreator.java | <gh_stars>1-10
package androidx.core.app;
import android.app.Activity;
import android.app.Application;
import android.content.res.Configuration;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Looper;
import android.util.Log;
import androidx.annotation.NonNull;
import androidx.annotation.RestrictTo;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.List;
@RestrictTo({RestrictTo.Scope.LIBRARY})
public final class ActivityRecreator {
private static final String LOG_TAG = "ActivityRecreator";
public static final Class<?> activityThreadClass;
private static final Handler mainHandler = new Handler(Looper.getMainLooper());
public static final Field mainThreadField = getMainThreadField();
public static final Method performStopActivity2ParamsMethod;
public static final Method performStopActivity3ParamsMethod;
public static final Method requestRelaunchActivityMethod;
public static final Field tokenField = getTokenField();
public static final class LifecycleCheckCallbacks implements Application.ActivityLifecycleCallbacks {
public Object currentlyRecreatingToken;
private Activity mActivity;
private boolean mDestroyed = false;
private final int mRecreatingHashCode;
private boolean mStarted = false;
private boolean mStopQueued = false;
public LifecycleCheckCallbacks(@NonNull Activity activity) {
this.mActivity = activity;
this.mRecreatingHashCode = activity.hashCode();
}
public void onActivityCreated(Activity activity, Bundle bundle) {
}
public void onActivityDestroyed(Activity activity) {
if (this.mActivity == activity) {
this.mActivity = null;
this.mDestroyed = true;
}
}
public void onActivityPaused(Activity activity) {
if (this.mDestroyed && !this.mStopQueued && !this.mStarted && ActivityRecreator.queueOnStopIfNecessary(this.currentlyRecreatingToken, this.mRecreatingHashCode, activity)) {
this.mStopQueued = true;
this.currentlyRecreatingToken = null;
}
}
public void onActivityResumed(Activity activity) {
}
public void onActivitySaveInstanceState(Activity activity, Bundle bundle) {
}
public void onActivityStarted(Activity activity) {
if (this.mActivity == activity) {
this.mStarted = true;
}
}
public void onActivityStopped(Activity activity) {
}
}
static {
Class<?> activityThreadClass2 = getActivityThreadClass();
activityThreadClass = activityThreadClass2;
performStopActivity3ParamsMethod = getPerformStopActivity3Params(activityThreadClass2);
performStopActivity2ParamsMethod = getPerformStopActivity2Params(activityThreadClass2);
requestRelaunchActivityMethod = getRequestRelaunchActivityMethod(activityThreadClass2);
}
private ActivityRecreator() {
}
private static Class<?> getActivityThreadClass() {
try {
return Class.forName("android.app.ActivityThread");
} catch (Throwable unused) {
return null;
}
}
private static Field getMainThreadField() {
try {
Field declaredField = Activity.class.getDeclaredField("mMainThread");
declaredField.setAccessible(true);
return declaredField;
} catch (Throwable unused) {
return null;
}
}
private static Method getPerformStopActivity2Params(Class<?> cls) {
if (cls == null) {
return null;
}
try {
Method declaredMethod = cls.getDeclaredMethod("performStopActivity", new Class[]{IBinder.class, Boolean.TYPE});
declaredMethod.setAccessible(true);
return declaredMethod;
} catch (Throwable unused) {
return null;
}
}
private static Method getPerformStopActivity3Params(Class<?> cls) {
if (cls == null) {
return null;
}
try {
Method declaredMethod = cls.getDeclaredMethod("performStopActivity", new Class[]{IBinder.class, Boolean.TYPE, String.class});
declaredMethod.setAccessible(true);
return declaredMethod;
} catch (Throwable unused) {
return null;
}
}
private static Method getRequestRelaunchActivityMethod(Class<?> cls) {
if (needsRelaunchCall() && cls != null) {
try {
Class cls2 = Boolean.TYPE;
Method declaredMethod = cls.getDeclaredMethod("requestRelaunchActivity", new Class[]{IBinder.class, List.class, List.class, Integer.TYPE, cls2, Configuration.class, Configuration.class, cls2, cls2});
declaredMethod.setAccessible(true);
return declaredMethod;
} catch (Throwable unused) {
}
}
return null;
}
private static Field getTokenField() {
try {
Field declaredField = Activity.class.getDeclaredField("mToken");
declaredField.setAccessible(true);
return declaredField;
} catch (Throwable unused) {
return null;
}
}
private static boolean needsRelaunchCall() {
int i2 = Build.VERSION.SDK_INT;
return i2 == 26 || i2 == 27;
}
public static boolean queueOnStopIfNecessary(Object obj, int i2, Activity activity) {
try {
final Object obj2 = tokenField.get(activity);
if (obj2 == obj) {
if (activity.hashCode() == i2) {
final Object obj3 = mainThreadField.get(activity);
mainHandler.postAtFrontOfQueue(new Runnable() {
public void run() {
Boolean bool = Boolean.FALSE;
try {
Method method = ActivityRecreator.performStopActivity3ParamsMethod;
if (method != null) {
method.invoke(obj3, new Object[]{obj2, bool, "AppCompat recreation"});
return;
}
ActivityRecreator.performStopActivity2ParamsMethod.invoke(obj3, new Object[]{obj2, bool});
} catch (RuntimeException e2) {
if (e2.getClass() == RuntimeException.class && e2.getMessage() != null && e2.getMessage().startsWith("Unable to stop")) {
throw e2;
}
} catch (Throwable th) {
Log.e(ActivityRecreator.LOG_TAG, "Exception while invoking performStopActivity", th);
}
}
});
return true;
}
}
return false;
} catch (Throwable th) {
Log.e(LOG_TAG, "Exception while fetching field values", th);
return false;
}
}
public static boolean recreate(@NonNull Activity activity) {
Object obj;
final Application application;
final LifecycleCheckCallbacks lifecycleCheckCallbacks;
if (Build.VERSION.SDK_INT >= 28) {
activity.recreate();
return true;
} else if (needsRelaunchCall() && requestRelaunchActivityMethod == null) {
return false;
} else {
if (performStopActivity2ParamsMethod == null && performStopActivity3ParamsMethod == null) {
return false;
}
try {
final Object obj2 = tokenField.get(activity);
if (obj2 == null || (obj = mainThreadField.get(activity)) == null) {
return false;
}
application = activity.getApplication();
lifecycleCheckCallbacks = new LifecycleCheckCallbacks(activity);
application.registerActivityLifecycleCallbacks(lifecycleCheckCallbacks);
Handler handler = mainHandler;
handler.post(new Runnable() {
public void run() {
LifecycleCheckCallbacks.this.currentlyRecreatingToken = obj2;
}
});
if (needsRelaunchCall()) {
Method method = requestRelaunchActivityMethod;
Boolean bool = Boolean.FALSE;
method.invoke(obj, new Object[]{obj2, null, null, 0, bool, null, null, bool, bool});
} else {
activity.recreate();
}
handler.post(new Runnable() {
public void run() {
application.unregisterActivityLifecycleCallbacks(lifecycleCheckCallbacks);
}
});
return true;
} catch (Throwable unused) {
return false;
}
}
}
}
|
oneybee/datavisual-react-refactor | src/components/Page01/block/Page01/index.js | <gh_stars>0
import React from 'react';
import styled, { css } from 'styled-components';
import Title from './Title';
import Charts from './Charts';
import Pie from './Pie';
import TextLabel from './TextLabel';
import Dot from './Dot';
import CenterWrapper from './CenterWrapper';
const Page01 = styled.div`
padding: 0 20px;
`;
Page01.Title = Title;
Page01.Charts = Charts;
Page01.Pie = Pie;
Page01.TextLabel = TextLabel;
Page01.Dot = Dot;
Page01.CenterWrapper = CenterWrapper;
export default Page01; |
jonathannewman/pcore-java | src/main/java/com/puppet/pcore/Default.java | package com.puppet.pcore;
/**
* The class that represents a default instance (the Symbol :default in Ruby).
*/
public class Default {
public static final Default SINGLETON = new Default();
private Default() {
}
}
|
anandchouhan/nomo | app/controllers/communities_controller.rb | class CommunitiesController < ApplicationController
def new
@community = Community.new
end
def create
@community = Community.create(community_params)
if @community.save
redirect_back(fallback_location: root_path, notice: "Community was successfully created.")
end
end
private
def community_params
params.require(:community).permit(:name, :description, :user_id, :privacy)
end
end
|
pfeairheller/canis | pkg/framework/context/grpc.go | /*
Copyright Scoir Inc. All Rights Reserved.
SPDX-License-Identifier: Apache-2.0
*/
package context
import (
"github.com/pkg/errors"
"google.golang.org/grpc"
api "github.com/scoir/canis/pkg/apiserver/api/protogen"
)
func (r *Provider) GetAPIAdminClient() (api.AdminClient, error) {
ep, err := r.conf.Endpoint("api.grpc")
if err != nil {
return nil, err
}
cc, err := grpc.Dial(ep.Address(), grpc.WithInsecure())
if err != nil {
return nil, errors.Wrap(err, "failed to dial grpc for api client")
}
cl := api.NewAdminClient(cc)
return cl, nil
}
|
cestlascorpion/Leetcode-Go | solution/1732.LargestAltitude.go | package solution
func LargestAltitude(gain []int) int {
altitude := 0
cursor := 0
for _, delta := range gain {
cursor += delta
if cursor > altitude {
altitude = cursor
}
}
return altitude
}
|
mongodb/dsi | test_lib/fixture_files.py | <gh_stars>1-10
"""
Implementation of FixtureFiles class.
"""
import json
import os
import json_diff
import yaml
from mock import patch
import dsi.common.whereami as whereami
class FixtureFiles:
def repo_root_file_path(self, *args):
"""
Return the absolute path of a file at `file_path` with respect to the repo root.
:param str file_path: The name of the file path.
:rtype: str.
"""
return whereami.dsi_repo_path(*args)
def fixture_file_path(self, *args):
return os.path.join(whereami.dsi_repo_path("dsi", "tests", "unittest-files"), *args)
def load_json_file(self, *args):
"""
Convenience method to load a json file from the fixture directory.
:param str filename: The name of the file path.
:return: A dict representing a json file.
"""
with open(self.fixture_file_path(*args)) as json_file:
return json.load(json_file)
def load_yaml_file(self, *args):
"""
Convenience method to load a yaml file from the fixture directory.
:param str filename: The name of the file path.
:return: A dict representing a yaml file.
"""
with open(self.fixture_file_path(*args)) as yaml_file:
return yaml.load(yaml_file)
def json_files_equal(self, path1, path2):
"""
Check whether the JSON files at paths `path1` and `path2` inside the fixture directory are
equal.
:param str path1: The name of a json file.
:param str path2: The name of another json file.
"""
json1, json2 = (self.load_json_file(path) for path in (path1, path2))
return json1 == json2
def yaml_files_equal(self, path1, path2):
"""
Check whether the YAML files at paths `path1` and `path2` inside the fixture directory are
equal.
:param str path1: The name of a yaml file.
:param str path2: The name of another yaml file.
"""
yaml1, yaml2 = (self.load_yaml_file(path) for path in (path1, path2))
return yaml1 == yaml2
def assert_json_files_equal(self, test_case, expect, actual):
"""
Pretty-print a json diff report if contents if expect != actual.
:param unittest.TestCase test_case: The test case to use.
:param IO expect: expected json file IO.
:param IO actual: actual json file IO.
"""
expect = self.fixture_file_path(expect)
actual = self.fixture_file_path(actual)
with open(expect) as file_handle_expect, open(actual) as file_handle_actual:
diff = json_diff.Comparator(file_handle_expect, file_handle_actual)
diff_res = diff.compare_dicts()
outs = str(json_diff.HTMLFormatter(diff_res))
with open(actual) as file_handle:
result_perf_json = json.load(file_handle)
with open(expect) as file_handle:
expected_perf_json = json.load(file_handle)
# pylint: disable=invalid-name
test_case.maxDiff = None
test_case.assertEqual(result_perf_json, expected_perf_json, outs)
def load_config_dict(module):
"""
Load ConfigDict for the given module with id checks mocked out.
:param str module: Name of module for ConfigDict.
"""
# pylint: disable=import-outside-toplevel
from dsi.common.config import ConfigDict
with patch("dsi.common.config.ConfigDict.assert_valid_ids") as mock_assert_valid_ids:
conf = ConfigDict(module)
conf.load()
mock_assert_valid_ids.assert_called_once()
return conf
|
dodo0101/PIPE | pipe-core/src/main/java/uk/ac/imperial/pipe/models/petrinet/name/PetriNetFileName.java | package uk.ac.imperial.pipe.models.petrinet.name;
import org.apache.commons.io.FilenameUtils;
import java.io.File;
/**
* Represents a saved file that a Petri net belongs to
*/
public final class PetriNetFileName implements PetriNetName {
/**
* File that this name should represent
*/
private File file;
/**
*
* @param file file where the Petri net is located and thus its name should represent this
*/
public PetriNetFileName(File file) {
this.file = file;
}
/**
*
* @return absolute path to the Petri net file
*/
public String getPath() {
return file.getAbsolutePath();
}
/**
*
* @return file name minus the path of the Petri net file
*/
@Override
public String getName() {
return FilenameUtils.removeExtension(file.getName());
}
/**
* Visit a name
* @param visitor to be visited
*/
@Override
public void visit(NameVisitor visitor) {
if (visitor instanceof FileNameVisitor) {
((FileNameVisitor) visitor).visit(this);
}
}
/**
*
* @return actual file that represents where this Petri net is saved
*/
public File getFile() {
return file;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof PetriNetFileName)) {
return false;
}
PetriNetFileName that = (PetriNetFileName) o;
if (!file.equals(that.file)) {
return false;
}
return true;
}
@Override
public int hashCode() {
return file.hashCode();
}
}
|
Suti1977/MySAM | MyServices/MyTaskedResource.h | <filename>MyServices/MyTaskedResource.h
//------------------------------------------------------------------------------
// Task-al tamogatott eroforras modul (MyRM resze)
//
// File: MyTaskedResource.h
//------------------------------------------------------------------------------
#ifndef MYTASKEDRESOURCE_H_
#define MYTASKEDRESOURCE_H_
#include "MyRM.h"
#include "MyCommon.h"
//------------------------------------------------------------------------------
//Eroforras inditasat eloiro esemeny flag
#define MyTASKEDRESOURCE_EVENT__START_REQUEST BIT(30)
//Eroforras leallitasat kero esemeny flag
#define MyTASKEDRESOURCE_EVENT__STOP_REQUEST BIT(31)
//------------------------------------------------------------------------------
//Az eroforrast vezerlo valtozok halmaza
typedef struct
{
//A taszknak kuldott eventek
EventBits_t events;
//true, ha a loop azert fut, mert az applikacio altal megadott idozites
//letelt.
bool timed;
//A ciklusnak erre az esemenyre kell varnia. Ezt a loop-ban, vagy a Starting
//funkciokban is modosithatja az applikacio
EventBits_t waitedEvents;
//A varakozasi ido tick-ben
uint32_t waitTime;
//Feladat kesz jelzes. Azoknal az eroforrasoknal, melyek elinditasa utan
//azok mukodese egy ido utan befejezodik, ott ezen a flagen keresztul tudja
//jelezni azt a start vagy loop callbackban futtatott kod.
//Hatasara a manager fele RESOURCE_DONE allapot kerul jelzesre, es az
//eroforras ujra a start feltetelre fog varni.
bool done;
//leallitasi kerelem aktiv jelzes az eroforrasra
bool resourceStopRequest;
//Az applikacio jelezheti, hogy nem szabad az eroforrast leallitani.
//Ez akkor fontos, ha olyan folyamatot futtatunk, melynek mindenkepen vegig
//kell tudni futnia.
bool prohibitStop;
//Az eroforras mukodik jelzes. Alapertelmezesben ez ben van allitva, de van
//lehetoseg a startFunc() callbackben a flaget torolni. Igy a loop funkcio
//ugy indul el, hogy az eroforras manager fele nem jelez "elindult"
//allapotot.
//A loop-ban igy van lehetoseg az eroforarst inditani, majd ha kesz, akkor
//a flaget true-ba allitani, mely hatasara a manager fele "elindult" jelzest
//kuld.
//Az applikacio a loop-bol kilepve jelezheti, ha elindult az eroforras.
bool run;
//Az aktualis tick ido. CSAK A LOOP callbackben hasznalhato!!!!
uint64_t time;
} taskedRsource_control_t;
//------------------------------------------------------------------------------
//Az eroforras inicializalasakor meghivodo callback definicioja
typedef status_t taskedResourceInitFunc_t(void* callbackData);
//Az eroforras inditasi kerelmekor hivott callback rutin definicioja
typedef void taskedResourceStartReqFunc_t(void* callbackData);
//Az eroforras leallitasi kerelmenel hivott callback rutin definicioja
typedef void taskedResourceStopReqFunc_t(void* callbackData);
//Az eroforras elinditasara, a taszkban meghivodo rutin
typedef status_t taskedResourceStartFunc_t(void* callbackData,
taskedRsource_control_t* control);
//Az eroforras leallitasi kerelme utan a taszkban meghivodo rutin
typedef status_t taskedResourceStopFunc_t(void* callbackData);
//Hiba eseten, a taszkbol hivott callback definicioja
typedef void taskedResourceErrorFunc_t(void* callbackData, status_t errorCode);
//Eroforrast futtato callback definicioja
typedef status_t taskedResourceLoopFunc_t(void* callbackData,
taskedRsource_control_t* control);
//------------------------------------------------------------------------------
//Taszkal rendelkezo eroforras inicializalasanal hasznalt struktura.
typedef struct
{
//Az eroforras neve. Ugyan ezt hasznalja a letrehozott taszk nevenek is.
const char* name;
//Az eroforrast futtato taszk prioritasa
uint32_t taskPriority;
//Az eroforrast futtato taszk szamara allokalt taszk merete
uint32_t taskStackSize;
//Az eroforras callbckjai szamara atadott tetszoleges parameter
void* callbackData;
//Az eroforras inicializalasakor meghivodo callback definicioja
taskedResourceInitFunc_t* initFunc;
//Az eroforras inditasi kerelmekor hivott callback rutin definicioja
taskedResourceStartReqFunc_t* startRequestFunc;
//Az eroforras leallitasi kerelmenel hivott callback rutin definicioja
taskedResourceStopReqFunc_t* stopRequestFunc;
//Az eroforras elinditasara, a taszkban meghivodo rutin
taskedResourceStartFunc_t* startFunc;
//Az eroforras leallitasi kerelme utan a taszkban meghivodo rutin
taskedResourceStopFunc_t* stopFunc;
//Hiba eseten, a taszkbol hivott callback definicioja
taskedResourceErrorFunc_t* errorFunc;
//Eroforrast futtato callback definicioja
taskedResourceLoopFunc_t* loopFunc;
} taskedResource_config_t;
//------------------------------------------------------------------------------
//Eroforras bovitmeny valtozoi.
typedef struct
{
//Az eroforrast futtato taszk handlere
TaskHandle_t taskHandle;
//Az eroforras mukodeset befolyasolo esemeny flagek csoprtja
//EventGroupHandle_t events;
//letrehozaskor kapott konfiguracio
taskedResource_config_t cfg;
} taskedResourceExtension_t;
//------------------------------------------------------------------------------
//Taszkal tamogatott eroforras letrehozasa
void MyTaskedResource_create(resource_t* resource,
taskedResourceExtension_t* ext,
const taskedResource_config_t* cfg);
////A taszkkal bovitett eroforrashoz tartozo esemenymezo handlerenek lekerdezese
//static inline
//EventGroupHandle_t MyTaskedResource_getEventHandler(resource_t* resource)
//{
// return ((taskedResourceExtension_t*)resource->ext)->events;
//}
//A taszkkal bovitett eroforrashoz taszk handlerenek lekerdezese
//A taszkkal bovitett eroforrashoz tartozo taszk handlerenek lekerdezese
static inline
TaskHandle_t MyTaskedResource_getTaskHandler(resource_t* resource)
{
return ((taskedResourceExtension_t*)resource->ext)->taskHandle;
}
//A taszkkal bovitett eroforras taszkjanak esemeny(notify) kuldese
static inline
void MyTaskedResource_setEvent(resource_t* resource, uint32_t event)
{
//xEventGroupSetBits(((taskedResourceExtension_t*)resource->ext)->events,
// event);
xTaskNotify(MyTaskedResource_getTaskHandler(resource), event, eSetBits);
}
//A taszkkal bovitett eroforras taszkjanak esemeny(notify) kuldese megszakitasbol
static inline
void MyTaskedResource_setEventFromIsr(resource_t* resource, uint32_t event)
{
BaseType_t higherPriorityTaskWoken=pdFALSE;
//xEventGroupSetBits(((taskedResourceExtension_t*)resource->ext)->events,
// event);
xTaskNotifyFromISR(MyTaskedResource_getTaskHandler(resource),
event,
eSetBits,
&higherPriorityTaskWoken);
portYIELD_FROM_ISR(higherPriorityTaskWoken)
}
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
#endif //MYTASKEDRESOURCE_H_
|
VastoLorde95/Competitive-Programming | Codeforces/149 Division 2/Problem C/C.cc | #include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<map>
#include<set>
#include<vector>
#include<utility>
#include<queue>
#include<stack>
#define sd(x) scanf("%d",&x)
#define sd2(x,y) scanf("%d%d",&x,&y)
#define sd3(x,y,z) scanf("%d%d%d",&x,&y,&z)
#define fi first
#define se second
#define pb(x) push_back(x)
#define mp(x,y) make_pair(x,y)
#define _ ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
using namespace std;
int x1, x2, Y1, y2, n, r, a, b;
set<pair<int, int> > nodes;
map<pair<int, int>, int> visited;
map<pair<int, int>, vector<pair<int, int> > > adj;
void bfs(pair<int, int> cur, pair<int, int> target){
int d;
queue<pair<pair<int, int>, int> > q;
q.push(mp(cur,0));
while(!q.empty()){
cur = q.front().fi; d = q.front().se; q.pop();
// cout << "Currently at " << cur.fi << ", " << cur.se << endl;
if(visited.find(cur) != visited.end()) continue;
visited[cur] = d;
if(cur == target) return;
for(int i = 0; i < adj[cur].size(); i++){
if(visited.find(adj[cur][i]) == visited.end()){
q.push(mp(adj[cur][i], d+1));
}
}
}
return;
}
int main(){
sd2(x1, Y1);
sd2(x2, y2);
sd(n);
for(int i = 0; i < n; i++){
sd3(r,a,b);
for(int i = a; i <= b; i++){
nodes.insert(mp(r,i));
}
}
for(set<pair<int, int> >::iterator it = nodes.begin(); it != nodes.end(); it++){
pair<int, int> p = *it;
int x = p.fi, y = p.se;
if(nodes.find(mp(x-1,y-1)) != nodes.end()) adj[p].pb(mp(x-1, y-1));
if(nodes.find(mp(x-1,y)) != nodes.end()) adj[p].pb(mp(x-1, y));
if(nodes.find(mp(x-1,y+1)) != nodes.end()) adj[p].pb(mp(x-1, y+1));
if(nodes.find(mp(x,y-1)) != nodes.end()) adj[p].pb(mp(x, y-1));
if(nodes.find(mp(x,y+1)) != nodes.end()) adj[p].pb(mp(x, y+1));
if(nodes.find(mp(x+1,y-1)) != nodes.end()) adj[p].pb(mp(x+1, y-1));
if(nodes.find(mp(x+1,y)) != nodes.end()) adj[p].pb(mp(x+1, y));
if(nodes.find(mp(x+1,y+1)) != nodes.end()) adj[p].pb(mp(x+1, y+1));
}
bfs(mp(x1,Y1), mp(x2,y2));
if(visited.find(mp(x2,y2)) != visited.end()) printf("%d\n", visited[mp(x2,y2)]);
else printf("-1\n");
return 0;
}
|
bloxlink/heroicons | packages/vue-heroicons/components/HeroIconCake.js | import Vue from 'vue'
export default Vue.extend({
name: 'HeroIconCake',
functional: true,
props: {
size: { type: Number, default: 0 },
},
render (createElement, context) {
const data = { ...context.data }
if (context.props.size) {
data.attrs.width = context.props.size
data.attrs.height = context.props.size
}
data.attrs = {
...data.attrs,
viewBox: `0 0 24 24`,
xmlns: 'http://www.w3.org/2000/svg',
fill: 'none',
stroke: 'currentColor',
}
if (!data.domProps) data.domProps = {}
data.domProps.innerHTML = '<path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M21 15.546c-.523 0-1.046.151-1.5.454a2.704 2.704 0 01-3 0 2.704 2.704 0 00-3 0 2.704 2.704 0 01-3 0 2.704 2.704 0 00-3 0 2.704 2.704 0 01-3 0 2.701 2.701 0 00-1.5-.454M9 6v2m3-2v2m3-2v2M9 3h.01M12 3h.01M15 3h.01M21 21v-7a2 2 0 00-2-2H5a2 2 0 00-2 2v7h18zm-3-9v-2a2 2 0 00-2-2H8a2 2 0 00-2 2v2h12z"/>'
return createElement('svg', data)
},
})
|
smith750/kc | coeus-impl/src/main/java/org/kuali/kra/irb/actions/reviewcomments/ProtocolAddReviewAttachmentEvent.java | <reponame>smith750/kc
/*
* Copyright 2005-2014 The Kuali Foundation
*
* Licensed under the Educational Community 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.opensource.org/licenses/ecl1.php
*
* 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.kuali.kra.irb.actions.reviewcomments;
import org.kuali.kra.irb.ProtocolDocument;
import org.kuali.kra.irb.onlinereview.ProtocolReviewAttachment;
import org.kuali.kra.protocol.actions.reviewcomments.ProtocolAddReviewAttachmentEventBase;
/**
*
* This class is validate the new review attachment when 'add' is clicked
*/
@SuppressWarnings("unchecked")
public class ProtocolAddReviewAttachmentEvent extends ProtocolAddReviewAttachmentEventBase<ProtocolReviewAttachment> {
public ProtocolAddReviewAttachmentEvent(ProtocolDocument document, String propertyName, ProtocolReviewAttachment reviewAttachment) {
super(document, propertyName, reviewAttachment);
}
@Override
protected ProtocolAddReviewAttachmentRule getNewProtocolAddReviewAttachmentRuleInstancehook() {
return new ProtocolAddReviewAttachmentRule();
}
}
|
LinFeng1997/my-leetcode | src/search/451.frequencySort.js | <reponame>LinFeng1997/my-leetcode<filename>src/search/451.frequencySort.js<gh_stars>1-10
/**
* @param {string} s
* @return {string}
*/
var frequencySort = function (s) {
let arr = s.split('');
let map = getMap(s);
let rst = '';
Array.from(map.entries()).sort((a, b) => b[1] - a[1]).forEach(item => {
rst += item[0].repeat(item[1]);
});
return rst;
};
function getMap(arr, map = new Map()) {
for (let i = 0; i < arr.length; i++) {
let item = arr[i];
if (!map.has(item)) {
map.set(item, 1);
} else {
map.set(item, map.get(item) + 1);
}
}
return map;
}
module.exports = frequencySort; |
liorheber/retable | stories/components/number_selector.js | import React, { Fragment } from "react";
import { withStyles } from "material-ui/styles";
import { FormControlLabel } from "material-ui/Form";
import MobileStepper from "material-ui/MobileStepper";
import IconButton from "material-ui/IconButton";
import Remove from "@material-ui/icons/Remove";
import Add from "@material-ui/icons/Add";
import Typography from "material-ui/Typography";
const style = {
iconSize: {
width: "20px",
height: "20px",
},
icon: {
fontSize: "18px"
},
progress: {
width: "75%"
},
root: {
justifyContent: "space-between",
padding: "8px 0",
width: "100%",
background: "transparent",
marginRight: "8px"
}
};
const NumberSelector = ({ size, increase, decrease, classes, label }) => (
<div style={{ display: "flex", alignItems: "center" }}>
<MobileStepper
variant="progress"
steps={6}
position="static"
activeStep={size}
className={classes.root}
classes={{ progress: classes.progress }}
nextButton={
<IconButton
size="small"
onClick={increase}
disabled={size === 5}
className={classes.iconSize}
>
<Add className={classes.icon}/>
</IconButton>
}
backButton={
<IconButton
size="small"
onClick={decrease}
disabled={size === 0}
className={classes.iconSize}
>
<Remove className={classes.icon}/>
</IconButton>
}
/>
<Typography>{label}</Typography>
</div>
);
export default withStyles(style)(NumberSelector);
|
qwer81526973/Rxjava | src/test/java/rx/schedulers/AbstractSchedulerConcurrencyTests.java | <gh_stars>1-10
/**
* Copyright 2014 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package rx.schedulers;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import java.util.Queue;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import org.junit.Test;
import rx.Observable;
import rx.Observable.OnSubscribe;
import rx.Scheduler;
import rx.Scheduler.Worker;
import rx.Subscriber;
import rx.Subscription;
import rx.functions.Action0;
import rx.functions.Action1;
import rx.functions.Func1;
import rx.subscriptions.Subscriptions;
/**
* Base tests for schedulers that involve threads (concurrency).
*
* These can only run on Schedulers that launch threads since they expect async/concurrent behavior.
*
* The Current/Immediate schedulers will not work with these tests.
*/
public abstract class AbstractSchedulerConcurrencyTests extends AbstractSchedulerTests {
/**
* Bug report: https://github.com/ReactiveX/RxJava/issues/431
* @throws InterruptedException if a wait is interrupted
*/
@Test
public final void testUnSubscribeForScheduler() throws InterruptedException {
final AtomicInteger countReceived = new AtomicInteger();
final AtomicInteger countGenerated = new AtomicInteger();
final CountDownLatch latch = new CountDownLatch(1);
Observable.interval(50, TimeUnit.MILLISECONDS)
.map(new Func1<Long, Long>() {
@Override
public Long call(Long aLong) {
countGenerated.incrementAndGet();
return aLong;
}
})
.subscribeOn(getScheduler())
.observeOn(getScheduler())
.subscribe(new Subscriber<Long>() {
@Override
public void onCompleted() {
System.out.println("--- completed");
}
@Override
public void onError(Throwable e) {
System.out.println("--- onError");
}
@Override
public void onNext(Long args) {
if (countReceived.incrementAndGet() == 2) {
unsubscribe();
latch.countDown();
}
System.out.println("==> Received " + args);
}
});
latch.await(1000, TimeUnit.MILLISECONDS);
System.out.println("----------- it thinks it is finished ------------------ ");
Thread.sleep(100);
assertEquals(2, countGenerated.get());
}
@Test
public void testUnsubscribeRecursiveScheduleFromOutside() throws InterruptedException {
final CountDownLatch latch = new CountDownLatch(1);
final CountDownLatch unsubscribeLatch = new CountDownLatch(1);
final AtomicInteger counter = new AtomicInteger();
final Worker inner = getScheduler().createWorker();
try {
inner.schedule(new Action0() {
@Override
public void call() {
inner.schedule(new Action0() {
int i;
@Override
public void call() {
System.out.println("Run: " + i++);
if (i == 10) {
latch.countDown();
try {
// wait for unsubscribe to finish so we are not racing it
unsubscribeLatch.await();
} catch (InterruptedException e) {
// we expect the countDown if unsubscribe is not working
// or to be interrupted if unsubscribe is successful since
// the unsubscribe will interrupt it as it is calling Future.cancel(true)
// so we will ignore the stacktrace
}
}
counter.incrementAndGet();
inner.schedule(this);
}
});
}
});
latch.await();
inner.unsubscribe();
unsubscribeLatch.countDown();
Thread.sleep(200); // let time pass to see if the scheduler is still doing work
assertEquals(10, counter.get());
} finally {
inner.unsubscribe();
}
}
@Test
public void testUnsubscribeRecursiveScheduleFromInside() throws InterruptedException {
final CountDownLatch unsubscribeLatch = new CountDownLatch(1);
final AtomicInteger counter = new AtomicInteger();
final Worker inner = getScheduler().createWorker();
try {
inner.schedule(new Action0() {
@Override
public void call() {
inner.schedule(new Action0() {
int i;
@Override
public void call() {
System.out.println("Run: " + i++);
if (i == 10) {
inner.unsubscribe();
}
counter.incrementAndGet();
inner.schedule(this);
}
});
}
});
unsubscribeLatch.countDown();
Thread.sleep(200); // let time pass to see if the scheduler is still doing work
assertEquals(10, counter.get());
} finally {
inner.unsubscribe();
}
}
@Test
public void testUnsubscribeRecursiveScheduleWithDelay() throws InterruptedException {
final CountDownLatch latch = new CountDownLatch(1);
final CountDownLatch unsubscribeLatch = new CountDownLatch(1);
final AtomicInteger counter = new AtomicInteger();
final Worker inner = getScheduler().createWorker();
try {
inner.schedule(new Action0() {
@Override
public void call() {
inner.schedule(new Action0() {
long i = 1L;
@Override
public void call() {
if (i++ == 10) {
latch.countDown();
try {
// wait for unsubscribe to finish so we are not racing it
unsubscribeLatch.await();
} catch (InterruptedException e) {
// we expect the countDown if unsubscribe is not working
// or to be interrupted if unsubscribe is successful since
// the unsubscribe will interrupt it as it is calling Future.cancel(true)
// so we will ignore the stacktrace
}
}
counter.incrementAndGet();
inner.schedule(this, 10, TimeUnit.MILLISECONDS);
}
}, 10, TimeUnit.MILLISECONDS);
}
});
latch.await();
inner.unsubscribe();
unsubscribeLatch.countDown();
Thread.sleep(200); // let time pass to see if the scheduler is still doing work
assertEquals(10, counter.get());
} finally {
inner.unsubscribe();
}
}
@Test
public void recursionFromOuterActionAndUnsubscribeInside() throws InterruptedException {
final CountDownLatch latch = new CountDownLatch(1);
final Worker inner = getScheduler().createWorker();
try {
inner.schedule(new Action0() {
int i;
@Override
public void call() {
i++;
if (i % 100000 == 0) {
System.out.println(i + " Total Memory: " + Runtime.getRuntime().totalMemory() + " Free: " + Runtime.getRuntime().freeMemory());
}
if (i < 1000000L) {
inner.schedule(this);
} else {
latch.countDown();
}
}
});
latch.await();
} finally {
inner.unsubscribe();
}
}
@Test
public void testRecursion() throws InterruptedException {
final CountDownLatch latch = new CountDownLatch(1);
final Worker inner = getScheduler().createWorker();
try {
inner.schedule(new Action0() {
private long i;
@Override
public void call() {
i++;
if (i % 100000 == 0) {
System.out.println(i + " Total Memory: " + Runtime.getRuntime().totalMemory() + " Free: " + Runtime.getRuntime().freeMemory());
}
if (i < 1000000L) {
inner.schedule(this);
} else {
latch.countDown();
}
}
});
latch.await();
} finally {
inner.unsubscribe();
}
}
@Test
public void testRecursionAndOuterUnsubscribe() throws InterruptedException {
// use latches instead of Thread.sleep
final CountDownLatch latch = new CountDownLatch(10);
final CountDownLatch completionLatch = new CountDownLatch(1);
final Worker inner = getScheduler().createWorker();
try {
Observable<Integer> obs = Observable.unsafeCreate(new OnSubscribe<Integer>() {
@Override
public void call(final Subscriber<? super Integer> observer) {
inner.schedule(new Action0() {
@Override
public void call() {
observer.onNext(42);
latch.countDown();
// this will recursively schedule this task for execution again
inner.schedule(this);
}
});
observer.add(Subscriptions.create(new Action0() {
@Override
public void call() {
inner.unsubscribe();
observer.onCompleted();
completionLatch.countDown();
}
}));
}
});
final AtomicInteger count = new AtomicInteger();
final AtomicBoolean completed = new AtomicBoolean(false);
Subscription subscribe = obs.subscribe(new Subscriber<Integer>() {
@Override
public void onCompleted() {
System.out.println("Completed");
completed.set(true);
}
@Override
public void onError(Throwable e) {
System.out.println("Error");
}
@Override
public void onNext(Integer args) {
count.incrementAndGet();
System.out.println(args);
}
});
if (!latch.await(5000, TimeUnit.MILLISECONDS)) {
fail("Timed out waiting on onNext latch");
}
// now unsubscribe and ensure it stops the recursive loop
subscribe.unsubscribe();
System.out.println("unsubscribe");
if (!completionLatch.await(5000, TimeUnit.MILLISECONDS)) {
fail("Timed out waiting on completion latch");
}
// the count can be 10 or higher due to thread scheduling of the unsubscribe vs the scheduler looping to emit the count
assertTrue(count.get() >= 10);
assertTrue(completed.get());
} finally {
inner.unsubscribe();
}
}
@Test
public final void testSubscribeWithScheduler() throws InterruptedException {
final Scheduler scheduler = getScheduler();
final AtomicInteger count = new AtomicInteger();
Observable<Integer> o1 = Observable.<Integer> just(1, 2, 3, 4, 5);
o1.subscribe(new Action1<Integer>() {
@Override
public void call(Integer t) {
System.out.println("Thread: " + Thread.currentThread().getName());
System.out.println("t: " + t);
count.incrementAndGet();
}
});
// the above should be blocking so we should see a count of 5
assertEquals(5, count.get());
count.set(0);
// now we'll subscribe with a scheduler and it should be async
final String currentThreadName = Thread.currentThread().getName();
// latches for deterministically controlling the test below across threads
final CountDownLatch latch = new CountDownLatch(5);
final CountDownLatch first = new CountDownLatch(1);
o1.subscribeOn(scheduler).subscribe(new Action1<Integer>() {
@Override
public void call(Integer t) {
try {
// we block the first one so we can assert this executes asynchronously with a count
first.await(1000, TimeUnit.SECONDS);
} catch (InterruptedException e) {
throw new RuntimeException("The latch should have released if we are async.", e);
}
assertFalse(Thread.currentThread().getName().equals(currentThreadName));
System.out.println("Thread: " + Thread.currentThread().getName());
System.out.println("t: " + t);
count.incrementAndGet();
latch.countDown();
}
});
// assert we are async
assertEquals(0, count.get());
// release the latch so it can go forward
first.countDown();
// wait for all 5 responses
latch.await();
assertEquals(5, count.get());
}
@Test
public void workerUnderConcurrentUnsubscribeShouldNotAllowLaterTasksToRunDueToUnsubscriptionRace() {
Scheduler scheduler = getScheduler();
for (int i = 0; i < 1000; i++) {
Worker worker = scheduler.createWorker();
final Queue<Integer> q = new ConcurrentLinkedQueue<Integer>();
Action0 action1 = new Action0() {
@Override
public void call() {
q.add(1);
}
};
Action0 action2 = new Action0() {
@Override
public void call() {
q.add(2);
}
};
worker.schedule(action1);
worker.schedule(action2);
worker.unsubscribe();
if (q.size() == 1 && q.poll() == 2) {
//expect a queue of 1,2 or 1. If queue is just 2 then we have a problem!
fail("wrong order on loop " + i);
}
}
}
}
|
johncoleman83/bootcampschool-low_level_programming | 0x1C-binary_trees/8-binary_tree_postorder.c | <reponame>johncoleman83/bootcampschool-low_level_programming
#include "binary_trees.h"
/**
* binary_tree_postorder - traverses binary tree with postorder algorithm
* @tree: root of binary tree to traverse
* @func: pointer to function to use on each integer
*/
void binary_tree_postorder(const binary_tree_t *tree, void (*func)(int))
{
if (tree && func)
{
binary_tree_postorder(tree->left, func);
binary_tree_postorder(tree->right, func);
func(tree->n);
}
}
|
ckamtsikis/cmssw | Validation/RecoMuon/test/muonReleaseValidation_cfg.py | #import FWCore.ParameterSet.Config as cms
process = cms.Process("TkVal")
process.load("FWCore.MessageService.MessageLogger_cfi")
### standard includes
process.load('Configuration/StandardSequences/GeometryPilot2_cff')
process.load("Configuration.StandardSequences.RawToDigi_cff")
process.load("Configuration.EventContent.EventContent_cff")
process.load("Configuration.StandardSequences.Reconstruction_cff")
process.load("Configuration.StandardSequences.MagneticField_cff")
process.load("SimGeneral.MixingModule.mixNoPU_cfi")
### conditions
process.load("Configuration.StandardSequences.FrontierConditions_GlobalTag_cff")
#process.GlobalTag.globaltag = 'STARTUP_V1::All'
process.GlobalTag.globaltag = 'GLOBALTAG::All'
process.maxEvents = cms.untracked.PSet(
input = cms.untracked.int32(NEVENT)
)
process.source = source
### validation-specific includes
#process.load("SimTracker.TrackAssociatorProducers.trackAssociatorByChi2_cfi")
process.load("SimTracker.TrackAssociatorProducers.trackAssociatorByHits_cfi")
process.load("Validation.RecoTrack.cuts_cff")
process.load("Validation.RecoMuon.MuonTrackValidator_cff")
process.load("SimGeneral.TrackingAnalysis.trackingParticles_cfi")
process.load('Configuration.StandardSequences.EndOfProcess_cff')
process.load("Validation.RecoMuon.muonValidation_cff")
process.load("Validation.RecoMuon.muonValidationHLT_cff")
process.endjob_step = cms.Path(process.endOfProcess)
process.load("DQMServices.Components.EDMtoMEConverter_cff")
process.load("Validation.Configuration.postValidation_cff")
process.load("HLTriggerOffline.Muon.HLTMuonPostVal_cff")
process.cutsRecoTracks.algorithm = cms.string('ALGORITHM')
process.cutsRecoTracks.quality = cms.string('QUALITY')
process.muonTrackValidator.associators = ['trackAssociatorByHits']
process.muonTrackValidator.label = ['TRACKS']
if (process.muonTrackValidator.label[0] == 'generalTracks'):
process.muonTrackValidator.UseAssociators = cms.bool(True)
else:
process.muonTrackValidator.UseAssociators = cms.bool(True)
######
#process.source = cms.Source("PoolSource",
# fileNames = cms.untracked.vstring (
# FILENAMES
# )
#)
#process.extend("RelValTTbar_cff")
process.options = cms.untracked.PSet(
wantSummary = cms.untracked.bool(True)
)
process.digi2track = cms.Sequence(process.siPixelDigis
*process.SiStripRawToDigis
*(process.trackerlocalreco
+process.muonlocalreco)
*(process.ckftracks
*process.muonreco_plus_isolation)
*process.cutsRecoTracks
##process.cutsTPEffic*process.cutsTPFake* these modules are now useless
*process.trackAssociatorByHits
*process.muonTrackValidator
*process.recoMuonValidation
*process.recoMuonValidationHLT_seq
# *process.endOfProcess
)
#redo also tracking particles
process.digi2track_and_TP = cms.Sequence(process.mix
*process.trackingParticles
*process.siPixelDigis
*process.SiStripRawToDigis
*(process.trackerlocalreco
+process.muonlocalreco)
*(process.ckftracks
*process.muonreco_plus_isolation)
*process.cutsRecoTracks
##process.cutsTPEffic*process.cutsTPFake* these modules are now useless
*process.trackAssociatorByHits
*process.muonTrackValidator
*process.recoMuonValidation
*process.recoMuonValidationHLT_seq
# *process.endOfProcess
)
process.re_tracking = cms.Sequence(process.siPixelRecHits
*process.siStripMatchedRecHits
*(process.ckftracks
*process.muonreco_plus_isolation)
*process.cutsRecoTracks
##process.cutsTPEffic*process.cutsTPFake* these modules are now useless
*process.trackAssociatorByHits
*process.muonTrackValidator
*process.recoMuonValidation
*process.recoMuonValidationHLT_seq
# *process.endOfProcess
)
process.re_tracking_and_TP = cms.Sequence(process.mix
*process.trackingParticles
*process.siPixelRecHits
*process.siStripMatchedRecHits
*(process.ckftracks
*process.muonreco_plus_isolation)
*process.cutsRecoTracks
##process.cutsTPEffic*process.cutsTPFake* these modules are now useless
*process.trackAssociatorByHits
*process.muonTrackValidator
*process.recoMuonValidation
*process.recoMuonValidationHLT_seq
# *process.endOfProcess
)
if (process.muonTrackValidator.label[0] == 'generalTracks'):
process.only_validation = cms.Sequence(##process.cutsTPEffic*process.cutsTPFake* these modules are now useless
process.trackAssociatorByHits
*process.muonTrackValidator
*process.recoMuonValidation
*process.recoMuonValidationHLT_seq
# *process.endOfProcess
)
else:
process.only_validation = cms.Sequence(process.cutsRecoTracks
##process.cutsTPEffic*process.cutsTPFake* these modules are now useless
*process.trackAssociatorByHits
*process.muonTrackValidator
*process.recoMuonValidation
*process.recoMuonValidationHLT_seq
# *process.endOfProcess
)
if (process.muonTrackValidator.label[0] == 'generalTracks'):
process.only_validation_and_TP = cms.Sequence(process.mix
*process.trackingParticles
*process.trackAssociatorByHits
*process.muonTrackValidator
*process.recoMuonValidation
*process.recoMuonValidationHLT_seq
# *process.endOfProcess
)
else:
process.only_validation_and_TP = cms.Sequence(process.mix
*process.trackingParticles
*process.cutsRecoTracks
*process.trackAssociatorByHits
*process.muonTrackValidator
*process.recoMuonValidation
*process.recoMuonValidationHLT_seq
# *process.endOfProcess
)
### customized versoin of the OutputModule
### it save the mininal information which is necessary to perform tracking validation (tracks, tracking particles,
### digiSimLink,etc..)
process.customEventContent = cms.PSet(
outputCommands = cms.untracked.vstring('drop *')
)
process.customEventContent.outputCommands.extend(process.RecoTrackerRECO.outputCommands)
process.customEventContent.outputCommands.extend(process.BeamSpotRECO.outputCommands)
process.customEventContent.outputCommands.extend(process.SimGeneralFEVTDEBUG.outputCommands)
process.customEventContent.outputCommands.extend(process.RecoLocalTrackerRECO.outputCommands)
process.customEventContent.outputCommands.append('keep *_simSiStripDigis_*_*')
process.customEventContent.outputCommands.append('keep *_simSiPixelDigis_*_*')
process.customEventContent.outputCommands.append('drop SiStripDigiedmDetSetVector_simSiStripDigis_*_*')
process.customEventContent.outputCommands.append('drop PixelDigiedmDetSetVector_simSiPixelDigis_*_*')
process.OUTPUT = cms.OutputModule("PoolOutputModule",
process.customEventContent,
fileName = cms.untracked.string('fullOutput.SAMPLE.root')
)
process.VALOUTPUT = cms.OutputModule("PoolOutputModule",
outputCommands = cms.untracked.vstring('drop *', "keep *_MEtoEDMConverter_*_*"),
fileName = cms.untracked.string('output.SAMPLE.root')
)
ValidationSequence="SEQUENCE"
if ValidationSequence=="harvesting":
process.dqmSaver.convention = 'Offline'
process.dqmSaver.saveByRun = cms.untracked.int32(-1)
process.dqmSaver.saveAtJobEnd = cms.untracked.bool(True)
process.dqmSaver.forceRunNumber = cms.untracked.int32(1)
process.dqmSaver.workflow = "/GLOBALTAG/SAMPLE/Validation"
process.DQMStore.verbose=3
process.options = cms.untracked.PSet(
fileMode = cms.untracked.string('FULLMERGE')
)
for filter in (getattr(process,f) for f in process.filters_()):
if hasattr(filter,"outputFile"):
filter.outputFile=""
process.harvesting= cms.Sequence(
process.EDMtoMEConverter
*process.postValidation
+process.HLTMuonPostVal
*process.dqmSaver)
### final path and endPath
process.p = cms.Path(process.SEQUENCE)
if ValidationSequence!="harvesting":
process.outpath = cms.EndPath(process.VALOUTPUT)
if ValidationSequence!="harvesting":
process.schedule = cms.Schedule(
process.p,
process.endjob_step,
process.outpath
)
else:
process.schedule = cms.Schedule(
process.p
)
|
lukeburns/client | src/sidebar/store/create-store.js | /* global process */
import * as redux from 'redux';
import thunk from 'redux-thunk';
import immutable from '../util/immutable';
import { createReducer, bindSelectors } from './util';
/**
* Helper that strips the first argument from a function type.
*
* @template F
* @typedef {F extends (x: any, ...args: infer P) => infer R ? (...args: P) => R : never} OmitFirstArg
*/
/**
* Helper that converts an object of selector functions, which take a `state`
* parameter plus zero or more arguments, into selector methods, with no `state` parameter.
*
* @template T
* @typedef {{ [K in keyof T]: OmitFirstArg<T[K]> }} SelectorMethods
*/
/**
* Map of action name to reducer function.
*
* @template State
* @typedef {{ [action: string]: (s: State, action: any) => Partial<State> }} Reducers
*/
/**
* Configuration for a store module.
*
* @template State
* @template {object} Actions
* @template {object} Selectors
* @template {object} RootSelectors
* @typedef Module
* @prop {(...args: any[]) => State} init -
* Function that returns the initial state for the module
* @prop {string} namespace -
* The key under which this module's state will live in the store's root state
* @prop {Reducers<State>} update -
* Map of action types to "reducer" functions that process an action and return
* the changes to the state
* @prop {Actions} actions
* Object containing action creator functions
* @prop {Selectors} selectors
* Object containing selector functions
* @prop {RootSelectors} [rootSelectors]
*/
/**
* Replace a type `T` with `Fallback` if `T` is `any`.
*
* Based on https://stackoverflow.com/a/61626123/434243.
*
* @template T
* @template Fallback
* @typedef {0 extends (1 & T) ? Fallback : T} DefaultIfAny
*/
/**
* Helper for getting the type of store produced by `createStore` when
* passed a given module.
*
* To get the type for a store created from several modules, use `&`:
*
* `StoreFromModule<firstModule> & StoreFromModule<secondModule>`
*
* @template T
* @typedef {T extends Module<any, infer Actions, infer Selectors, infer RootSelectors> ?
* Store<Actions,Selectors,DefaultIfAny<RootSelectors,{}>> : never} StoreFromModule
*/
/**
* Redux store augmented with methods to dispatch actions and select state.
*
* @template {object} Actions
* @template {object} Selectors
* @template {object} RootSelectors
* @typedef {redux.Store &
* Actions &
* SelectorMethods<Selectors> &
* SelectorMethods<RootSelectors>} Store
*/
/**
* Create a Redux store from a set of _modules_.
*
* Each module defines the logic related to a particular piece of the application
* state, including:
*
* - The initial value of that state
* - The _actions_ that can change that state
* - The _selectors_ for reading that state or computing things
* from that state.
*
* On top of the standard Redux store methods, the returned store also exposes
* each action and selector from the input modules as a method which operates on
* the store.
*
* @param {Module<any,any,any,any>[]} modules
* @param {any[]} [initArgs] - Arguments to pass to each state module's `init` function
* @param {any[]} [middleware] - List of additional Redux middlewares to use
* @return Store<any,any,any>
*/
export default function createStore(modules, initArgs = [], middleware = []) {
// Create the initial state and state update function.
// Namespaced objects for initial states.
const initialState = {};
/**
* Namespaced reducers from each module.
* @type {import("redux").ReducersMapObject} allReducers
*/
const allReducers = {};
// Namespaced selectors from each module.
const allSelectors = {};
// Iterate over each module and prep each module's:
// 1. state
// 2. reducers
// 3. selectors
//
modules.forEach(module => {
if (module.namespace) {
initialState[module.namespace] = module.init(...initArgs);
allReducers[module.namespace] = createReducer(module.update);
allSelectors[module.namespace] = {
selectors: module.selectors,
rootSelectors: module.rootSelectors || {},
};
} else {
console.warn('Store module does not specify a namespace', module);
}
});
const defaultMiddleware = [
// The `thunk` middleware handles actions which are functions.
// This is used to implement actions which have side effects or are
// asynchronous (see https://github.com/gaearon/redux-thunk#motivation)
thunk,
];
const enhancer = redux.applyMiddleware(...defaultMiddleware, ...middleware);
// Create the combined reducer from the reducers for each module.
let reducer = redux.combineReducers(allReducers);
// In debug builds, freeze the new state after each action to catch any attempts
// to mutate it, which indicates a bug since it is supposed to be immutable.
if (process.env.NODE_ENV !== 'production') {
const originalReducer = reducer;
reducer = (state, action) => immutable(originalReducer(state, action));
}
// Create the store.
const store = redux.createStore(reducer, initialState, enhancer);
// Add actions and selectors as methods to the store.
const actions = Object.assign({}, ...modules.map(m => m.actions));
const boundActions = redux.bindActionCreators(actions, store.dispatch);
const boundSelectors = bindSelectors(allSelectors, store.getState);
Object.assign(store, boundActions, boundSelectors);
return store;
}
/**
* Helper to validate a store module configuration before it is passed to
* `createStore`.
*
* @template State
* @template Actions
* @template Selectors
* @template RootSelectors
* @param {Module<State,Actions,Selectors,RootSelectors>} config
* @return {Module<State,Actions,Selectors,RootSelectors>}
*/
export function storeModule(config) {
// This helper doesn't currently do anything at runtime. It does ensure more
// helpful error messages when typechecking if there is something incorrect
// in the configuration.
return config;
}
|
pChocz/squash-rest-api | src/main/java/com/pj/squashrestapp/dbinit/jsondto/JsonVerificationToken.java | <gh_stars>1-10
package com.pj.squashrestapp.dbinit.jsondto;
import static com.fasterxml.jackson.annotation.JsonInclude.Include.NON_NULL;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.pj.squashrestapp.util.GeneralUtil;
import java.time.LocalDateTime;
import java.util.UUID;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@JsonInclude(NON_NULL)
public class JsonVerificationToken {
@JsonFormat(pattern = GeneralUtil.DATE_TIME_FORMAT)
private LocalDateTime expirationDateTime;
private UUID playerUuid;
private UUID token;
}
|
antonmedv/year | packages/1994/09/05/index.js | <filename>packages/1994/09/05/index.js
module.exports = new Date(1994, 8, 5)
|
takumiao13/my-manga | lib/start.js | <gh_stars>1-10
const chalk = require('chalk');
const open = require('open');
const os = require('os');
const defaultGateway = require('default-gateway');
const address = require('address');
const { log, error } = require('./logger');
const fs = require('fs-extra');
const pathFn = require('path');
const { createIndex, dropIndex } = require('./indexing');
const App = require('../server');
async function start(args = {}, callback) {
const { isElectron, index } = args;
const appMode = process.env.APP_MODE;
const port = args.port || process.env.PORT;
const appData = args.appData || process.env.APP_DATA || process.cwd();
const settingsPath = pathFn.join(appData, 'settings.json');
if (!fs.pathExistsSync(settingsPath)) {
error('my manga cannot find settings in --app-data or $APP_DATA please check it');
return;
}
const options = {
host: isElectron ? 'localhost' : getHost()
};
if (port) options.port = port;
if (isElectron) options.isElectron = isElectron;
options.settingsPath = settingsPath;
const baseDir = (!appMode || appMode === 'prod')
? appData
: pathFn.join(appData, `.${appMode}`);
options.dataDir = pathFn.join(baseDir, 'data');
options.cacheDir = pathFn.join(baseDir, 'cache');
const app = new App(options);
await app.setup();
// TODO: Support persistence laster
// create index
const repos = app.service.repo.list();
const createIndexPromiseInterator = repos.map(repo => {
const { baseDir } = app.service.repo.get(repo.dirId);
return createIndex(app, { dir: baseDir });
});
await Promise.all(createIndexPromiseInterator);
app.start(() => {
const { host, port, server: { protocol } } = app.config();
const localURL = `${protocol}://localhost:${chalk.green(port)}`
const networkURL = `${protocol}://${host}:${chalk.green(port)}`;
log('');
log(`APP_MODE: ${appMode || 'prod'}`)
log(`${chalk.yellow('App running at:')}`);
log(`- Network: ${networkURL}`);
log(`- Local: ${localURL}`);
log('Hit CTRL-C to stop the server');
if (args.open) open(networkURL); // Open browser
callback && callback(null, app)
});
return app;
};
function getHost() {
const result = defaultGateway.v4.sync();
const host = address.ip(result && result.interface);
return host;
}
module.exports = start; |
Vizir/entria-components | src/components/content/ContentBody.js | import React from 'react';
import PropTypes from 'prop-types';
import styled from 'styled-components';
import { VIEWPORT } from '../Responsive';
const Wrapper = styled.div`
padding: 20px;
@media(min-width: ${VIEWPORT.MEDIUM}px) {
padding: 40px;
}
`;
const ContentBody = ({ style, children }) =>
<Wrapper style={style}>
{children}
</Wrapper>;
ContentBody.defaultProps = {
style: {},
};
ContentBody.propTypes = {
style: PropTypes.object,
};
export default ContentBody;
|
Communote/communote-server | communote/core/src/main/java/com/communote/server/core/mail/messages/user/InviteUserToBlogMailMessage.java | package com.communote.server.core.mail.messages.user;
import java.util.Map;
import com.communote.server.api.ServiceLocator;
import com.communote.server.api.core.application.CommunoteRuntime;
import com.communote.server.api.core.config.type.ClientProperty;
import com.communote.server.core.blog.export.PermalinkGenerationManagement;
import com.communote.server.core.mail.messages.MailModelPlaceholderConstants;
import com.communote.server.core.mail.messages.SecurityCodeMailMessage;
import com.communote.server.model.blog.Blog;
import com.communote.server.model.user.User;
import com.communote.server.model.user.security.InviteUserToBlogSecurityCode;
/**
* Mail Message to invite user to a blog.
*
* @author Communote GmbH - <a href="http://www.communote.com/">http://www.communote.com/</a>
*/
public class InviteUserToBlogMailMessage extends SecurityCodeMailMessage {
private final User inviter;
private final Blog blog;
private String localizedBlogTitle;
private InviteUserToBlogSecurityCode code;
/**
* Instantiates a new invite user to blog mail message.
*
* @param template
* the template
* @param inviter
* the inviter
* @param blog
* the blog
* @param receiver
* the receiver
*/
protected InviteUserToBlogMailMessage(String template, User inviter, User receiver, Blog blog) {
super(template, receiver.getLanguageLocale(), receiver);
this.blog = blog;
this.localizedBlogTitle = blog.getTitle();
this.inviter = inviter;
}
/**
* Instantiates a new mail message.
*
* @param inviter
* the inviter
* @param blog
* the blog
* @param code
* the code
* @param receiver
* the receiver
*/
public InviteUserToBlogMailMessage(User inviter, User receiver, Blog blog,
InviteUserToBlogSecurityCode code) {
this("mail.message.user.invite-user-to-blog", inviter, receiver, blog);
this.setCode(code);
this.localizedBlogTitle = blog.getTitle();
}
/**
* Gets the code.
*
* @return the code
*/
public InviteUserToBlogSecurityCode getCode() {
return code;
}
/**
* {@inheritDoc}
*
* @see com.communote.server.core.mail.messages.MailMessage#getLinkPrefix()
*/
@Override
public String getLinkPrefix() {
return "/user/confirm.do";
}
@Override
public void prepareModel(Map<String, Object> model) {
model.put(MailModelPlaceholderConstants.BLOG_TITLE, this.localizedBlogTitle);
model.put(MailModelPlaceholderConstants.USER, inviter);
boolean renderLink = CommunoteRuntime
.getInstance()
.getConfigurationManager()
.getClientConfigurationProperties()
.getProperty(ClientProperty.INVITATION_RENDER_BLOG_PERMALINK,
ClientProperty.DEFAULT_INVITATION_RENDER_BLOG_PERMALINK);
model.put(MailModelPlaceholderConstants.RENDER_BLOG_PERMA_LINK, renderLink);
model.put(MailModelPlaceholderConstants.PERMA_LINK_BLOG,
ServiceLocator.instance().getService(PermalinkGenerationManagement.class)
.getBlogLink(blog.getNameIdentifier(), true));
if (code != null) {
model.put(MailModelPlaceholderConstants.CONFIRMATION_LINK,
getSecurityCodeConfirmationLink(code));
}
}
/**
* Sets the code.
*
* @param code
* the new code
*/
public void setCode(InviteUserToBlogSecurityCode code) {
this.code = code;
}
}
|
shsmith11/romanceWeb | src/main/java/data/ServerResponces.java | package data;
public enum ServerResponces {
}
|
felipezago/ControleEstoque | Controller/pesquisa_servico.py | <reponame>felipezago/ControleEstoque
from PyQt5.QtWidgets import QMessageBox, QTableWidgetItem, QMainWindow
from PyQt5.QtCore import Qt
from Model.Servicos import Servicos
from PyQt5 import QtGui
from PyQt5 import QtCore
class EventFilter(QtCore.QObject):
def __init__(self, parent=None):
QtCore.QObject.__init__(self, parent)
def eventFilter(self, obj, event):
if event.type() == QtCore.QEvent.ActivationChange:
if self.parent().isActiveWindow():
if obj.adicionando:
obj.dados_tabela()
return QtCore.QObject.eventFilter(self, obj, event)
class PesquisaServico(QMainWindow):
def __init__(self, parent=None):
super(PesquisaServico, self).__init__(parent)
from View.pesquisa_servicos import Ui_Frame
self.ui = Ui_Frame()
self.ui.setupUi(self)
self.dialogs = list()
self.tamanho_tela = self.size()
self.setFixedSize(self.tamanho_tela)
self.setWindowIcon(QtGui.QIcon("Imagens/logo_fzr.png"))
self.servico_selecionado = Servicos()
self.linha_selecionada = None
self.filtrado = False
self.adicionando = False
self.tela_venda = parent
self.setWindowModality(QtCore.Qt.ApplicationModal)
self.installEventFilter(EventFilter(self))
# ação dos botoes
self.ui.bt_refresh.clicked.connect(self.dados_tabela)
self.ui.bt_selecionar.clicked.connect(self.sair)
self.ui.bt_inserir.clicked.connect(self.add)
# ação da busca
self.ui.bt_busca_servicos.clicked.connect(self.buscar)
self.ui.tx_busca_servicos.returnPressed.connect(self.buscar)
# signals
self.ui.tb_servicos.cellClicked.connect(self.linha_clicada)
self.ui.tb_servicos.cellDoubleClicked.connect(self.linha_clicada)
self.ui.tx_busca_servicos.textChanged.connect(self.formatar_texto)
self.ui.cb_servicos.currentIndexChanged.connect(self.limpa_campo_busca)
for i in range(0, 3):
self.ui.tb_servicos.horizontalHeaderItem(i).setTextAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.ui.tb_servicos.setColumnWidth(0, 30)
self.ui.tb_servicos.setColumnWidth(1, 250)
self.ui.tb_servicos.setColumnWidth(2, 100)
self.preenche_combo()
self.dados_tabela()
def add(self):
from Controller.cadastro_servicos import CadastroServicos
from Funcoes.utils import exec_app
self.adicionando = True
c_serv = CadastroServicos()
exec_app(c_serv)
self.dialogs.append(c_serv)
def limpa_campo_busca(self):
self.ui.tx_busca_servicos.setText("")
def resizeEvent(self, a0):
self.setFixedSize(self.tamanho_tela)
def formatar_texto(self):
texto = self.ui.tx_busca_servicos.text()
tamanho = len(texto)
if self.ui.cb_servicos.currentIndex() == 0:
if not texto[tamanho - 1:tamanho].isnumeric():
self.ui.tx_busca_servicos.setText(texto[:tamanho - 1])
if self.ui.cb_servicos.currentIndex() in (2, 3, 4):
if not texto[tamanho - 1:tamanho].isnumeric():
if texto[tamanho - 1:tamanho] != '.':
self.ui.tx_busca_servicos.setText(texto[:tamanho - 1])
if texto.count(".") > 1 and texto[tamanho - 1:tamanho] == '.':
self.ui.tx_busca_servicos.setText(texto[:tamanho - 1])
def preenche_combo(self):
self.ui.cb_servicos.clear()
self.ui.cb_servicos.addItem("ID")
self.ui.cb_servicos.addItem("DESCRIÇÃO")
self.ui.cb_servicos.addItem("PREÇO >")
self.ui.cb_servicos.addItem("PREÇO <")
self.ui.cb_servicos.addItem("PREÇO =")
def sair(self):
self.close()
def closeEvent(self, event: QtGui.QCloseEvent):
if self.servico_selecionado.id is not None:
self.tela_venda.codigo_item = self.servico_selecionado.id
self.tela_venda.ui.tx_busca_item.setText(f"{self.tela_venda.codigo_item}")
self.tela_venda.ui.tx_busca_item.setFocus()
self.tela_venda.recebeu_codigo_item = True
else:
box = QMessageBox()
box.setIcon(QMessageBox.Question)
box.setWindowTitle('Sair?')
box.setText('Tem certeza que deseja sair sem informar o código?')
box.setStandardButtons(QMessageBox.Yes | QMessageBox.No)
button_sim = box.button(QMessageBox.Yes)
button_sim.setText('Sim')
button_nao = box.button(QMessageBox.No)
button_nao.setText('Não')
box.exec_()
if box.clickedButton() == button_sim:
event.accept()
else:
event.ignore()
def buscar(self):
self.ui.tb_servicos.clearContents()
self.ui.tb_servicos.setRowCount(0)
serv = Servicos()
dados = ""
if self.ui.cb_servicos.currentIndex() == 1:
serv.descricao = self.ui.tx_busca_servicos.text()
if serv.descricao:
dados = Servicos.get_servicos_by_desc(serv.descricao.upper())
else:
QMessageBox.warning(self, "Atenção!", "Favor informar algum valor!")
self.dados_tabela()
return
elif self.ui.cb_servicos.currentIndex() == 0:
if self.ui.tx_busca_servicos.text():
serv.id = int(self.ui.tx_busca_servicos.text())
dados = serv.get_servico_by_id()
else:
QMessageBox.warning(self, "Atenção!", "Favor informar algum valor!")
self.dados_tabela()
return
else:
texto = self.ui.tx_busca_servicos.text()
if texto:
if texto.count('.') >= 1:
indice_ponto = texto.find('.')
if texto[indice_ponto + 1:indice_ponto + 2] == '0':
self.ui.tx_busca_servicos.setText(texto[:indice_ponto])
serv.preco = float(self.ui.tx_busca_servicos.text())
if self.ui.cb_servicos.currentIndex() == 2:
dados = serv.get_servico_by_preco(">=")
elif self.ui.cb_servicos.currentIndex() == 3:
dados = serv.get_servico_by_preco("<=")
elif self.ui.cb_servicos.currentIndex() == 4:
dados = serv.get_servico_by_preco("=")
else:
QMessageBox.warning(self, "Atenção!", "Favor informar algum valor!")
self.dados_tabela()
return
if dados:
self.filtrado = True
self.ui.bt_refresh.setEnabled(True)
if type(dados) == list:
for i, linha in enumerate(dados):
item_id = QTableWidgetItem(str(linha[0]))
item_id.setTextAlignment(Qt.AlignLeft | Qt.AlignVCenter)
item_desc = QTableWidgetItem(linha[1])
item_desc.setTextAlignment(Qt.AlignLeft | Qt.AlignVCenter)
item_preco = QTableWidgetItem(str(linha[2]))
item_preco.setTextAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.ui.tb_servicos.insertRow(i)
for c in range(0, 3):
item = str(linha[c])
self.ui.tb_servicos.setItem(i, c, QTableWidgetItem(item))
else:
self.ui.tb_servicos.insertRow(0)
for c in range(0, 3):
item = str(dados[c])
self.ui.tb_servicos.setItem(0, c, QTableWidgetItem(item))
else:
QMessageBox.warning(self, "Erro", "Não foi encontrado nenhum registro!")
self.ui.tx_busca_servicos.setText("")
self.dados_tabela()
self.ui.tb_servicos.selectRow(0)
def linha_clicada(self):
tb = self.ui.tb_servicos
self.linha_selecionada = tb.currentRow()
self.servico_selecionado.id = int(tb.item(tb.currentRow(), 0).text())
c = self.servico_selecionado.get_servico_by_id()
self.servico_selecionado.descricao = c[1]
self.servico_selecionado.preco = c[2]
def dados_tabela(self):
self.servico_selecionado.id = None
self.ui.tx_busca_servicos.setText("")
if self.adicionando and not self.filtrado:
novo_serv = Servicos()
novo_id = novo_serv.ultimo_servico()
novo_serv.id = novo_id[0][0]
novo_serv.get_servico_by_id()
novo_serv.descricao = novo_serv.get_servico_by_id()[1]
novo_serv.preco = novo_serv.get_servico_by_id()[2]
item_id = QTableWidgetItem(str(novo_serv.id))
item_id.setTextAlignment(Qt.AlignLeft | Qt.AlignVCenter)
item_desc = QTableWidgetItem(novo_serv.descricao)
item_desc.setTextAlignment(Qt.AlignLeft | Qt.AlignVCenter)
item_preco = QTableWidgetItem(str(novo_serv.preco))
item_preco.setTextAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.ui.tb_servicos.insertRow(self.ui.tb_servicos.rowCount())
self.ui.tb_servicos.setItem(self.ui.tb_servicos.rowCount() - 1, 0, item_id)
self.ui.tb_servicos.setItem(self.ui.tb_servicos.rowCount() - 1, 1, item_desc)
self.ui.tb_servicos.setItem(self.ui.tb_servicos.rowCount() - 1, 2, item_preco)
self.ui.tb_servicos.selectRow(self.ui.tb_servicos.rowCount() - 1)
self.adicionando = False
else:
self.filtrado = False
self.ui.bt_refresh.setEnabled(False)
self.ui.tb_servicos.clearContents()
self.ui.tb_servicos.setRowCount(0)
dados = Servicos.get_todos_servicos()
for i, linha in enumerate(dados):
item_id = QTableWidgetItem(str(linha[0]))
item_id.setTextAlignment(Qt.AlignLeft | Qt.AlignVCenter)
item_desc = QTableWidgetItem(str(linha[1]))
item_desc.setTextAlignment(Qt.AlignLeft | Qt.AlignVCenter)
item_preco = QTableWidgetItem(str(linha[2]))
item_preco.setTextAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.ui.tb_servicos.insertRow(i)
for c in range(0, 3):
item = str(linha[c])
self.ui.tb_servicos.setItem(i, c, QTableWidgetItem(item))
if self.adicionando:
self.ui.tb_servicos.selectRow(self.ui.tb_servicos.rowCount() - 1)
self.adicionando = False
|
Vladislav-Zolotaryov/L2J_Levelless_Custom | L2J_Server/java/com/l2jserver/gameserver/network/serverpackets/ExFishingStart.java | /*
* This program is free software: you can redistribute it and/or modify it under
* the terms of the GNU General Public License as published by the Free Software
* Foundation, either version 3 of the License, or (at your option) any later
* version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License along with
* this program. If not, see <http://www.gnu.org/licenses/>.
*/
package com.l2jserver.gameserver.network.serverpackets;
import com.l2jserver.gameserver.model.actor.L2Character;
/**
* Format (ch)ddddd
* @author -Wooden-
*
*/
public class ExFishingStart extends L2GameServerPacket
{
private static final String _S__FE_13_EXFISHINGSTART = "[S] FE:1e ExFishingStart";
private L2Character _activeChar;
private int _x,_y,_z, _fishType;
private boolean _isNightLure;
public ExFishingStart(L2Character character, int fishType, int x, int y,int z, boolean isNightLure)
{
_activeChar = character;
_fishType = fishType;
_x = x;
_y = y;
_z = z;
_isNightLure = isNightLure;
}
/* (non-Javadoc)
* @see com.l2jserver.gameserver.serverpackets.ServerBasePacket#writeImpl()
*/
@Override
protected void writeImpl()
{
writeC(0xfe);
writeH(0x1e);
writeD(_activeChar.getObjectId());
writeD(_fishType); // fish type
writeD(_x); // x position
writeD(_y); // y position
writeD(_z); // z position
writeC(_isNightLure ? 0x01 : 0x00); // night lure
writeC(0x00); //show fish rank result button
}
/* (non-Javadoc)
* @see com.l2jserver.gameserver.BasePacket#getType()
*/
@Override
public String getType()
{
return _S__FE_13_EXFISHINGSTART;
}
} |
Drew138/v_website | backend/backend/validators.py | <reponame>Drew138/v_website
from django.core.validators import RegexValidator
PHONE_REGEX = r"^\d{7}$"
CELPHONE_REGEX = r"^\d{10}$"
# https://www.regextester.com/108138
NIT_REGEX = r"^[0-9]+-{1}[0-9]{1}$"
# https://www.regextester.com/111017
ADDRESS_REGEX = \
r"^(Autopista|Avenida|Avenida Calle|" \
r"Avenida Carrera|Avenida|Carrera|" \
r"Calle|Carrera|Circunvalar|Diagonal|" \
r"Kilometro|Transversal|AUTOP|AV|AC|" \
r"AK|CL|KR|CCV|DG|KM|TV)(\s)?([a-zA-Z]" \
r"{0,15}|[0-9]{1,3})(\s)?[a-zA-Z]?(\s)?" \
r"(bis)?(\s)?(Este|Norte|Occidente|Oeste" \
r"|Sur)?(\s)?(#(\s)?[0-9]{1,2}(\s)?" \
r"[a-zA-Z]?(\s)?(bis)?(\s)?(Este|Norte|" \
r"Occidente|Oeste|Sur)?(\s)?(-)?(\s)?[0-9]" \
r"{1,3}(\s)?(Este|Norte|Occidente|Oeste|" \
r"Sur)?)?((\s)?(Agrupación|Altillo|Apar" \
r"tamento|Apartamento Sótano|Barrio|" \
r"Bloque|Bodega|Cabecera Municipal|" \
r"Callejón|Camino|Carretera|Casa|Caserio|" \
r"Célula|Centro|Centro Comercial|Centro " \
r"Urbano|Circular|Condominio|Conjunto|" \
r"Consultorio|Corregimiento|Deposito|Deposito |" \
r"Sótano|Edificio|Entrada|Esquina|Etapa|" \
r"Finca|Garaje|Garaje Sótano|Grada|Inferior|" \
r"Inspección de Policia|Interior|Kilometro|" \
r"Local|Local Mezzanine|Local Sótano|Lote|" \
r"Manzana|Manzanita|Mejora|Mezzanine|Módulo|" \
r"Municipio|Núcleo|Oficina|Oficina Sótano|" \
r"Parcela|Parcelación|Pasaje|Penthouse|" \
r"Piso|Porteria|Predio|Principal|Puente|" \
r"Quebrada|Salon|Sector|Semisótano|Suite|" \
r"Supermanzana|Terraza|Torre|Troncal|" \
r"Unidad|Urbanización|Vereda|Via|Zona|" \
r"AGN|AL|APTO|AS|BR|BL|BG|CM|CLJ|CN|CT|" \
r"CA|CAS|CEL|CE|CECO|CEUR|CIR|CDM|CONJ|CS|" \
r"CO|DP|DS|ED|EN|ESQ|ET|FCA|GJ|GS|GR|INF|" \
r"IP|IN|KM|LC|LM|LS|LT|MZ|MZTA|MJ|MN|MD|" \
r"MUN|NCO|OF|OS|PA|PCN|PSJ|PH|PI|PT|PD|" \
r"PPAL|PN|QDA|SA|SEC|SS|SU|SMZ|TZ|TO|TRL|" \
r"UN|URB|VDA|VIA|ZN)?(\s)?[1-9][0-9]{0,3})*$"
PHONE_MESSAGE = \
"El número de teléfono debe " \
"ser ingresado en el formato: " \
"xxxxxxx."
CELPHONE_MESSAGE = \
"El número de celular debe " \
"ser ingresado en el formato: " \
"xxxxxxxxxx."
NIT_MESSAGE = \
"El número NIT debe ser " \
"ingresado en el formato: " \
"xxxxxxxxx-x"
ADDRESS_MESSAGE = \
"La dirección ingresada " \
"debe ser valida para Colombia" \
PHONE_REGEX_VALIDATOR = RegexValidator(
regex=PHONE_REGEX,
message=PHONE_MESSAGE)
CELPHONE_REGEX_VALIDATOR = RegexValidator(
regex=CELPHONE_REGEX,
message=CELPHONE_MESSAGE)
NIT_REGEX_VALIDATOR = RegexValidator(
regex=NIT_REGEX,
message=NIT_MESSAGE
)
ADDRESS_REGEX_VALIDATOR = RegexValidator(
regex=ADDRESS_REGEX,
message=ADDRESS_MESSAGE)
|
jenkinsci/sonar-gerrit-plugin | src/test/java/org/jenkinsci/plugins/sonargerrit/ConfigRoundTripTest.java | package org.jenkinsci.plugins.sonargerrit;
import hudson.model.FreeStyleProject;
import hudson.util.Secret;
import java.util.UUID;
import org.jenkinsci.plugins.sonargerrit.gerrit.GerritAuthenticationConfig;
import org.jenkinsci.plugins.sonargerrit.gerrit.ScoreConfig;
import org.jenkinsci.plugins.sonargerrit.sonar.preview_mode_analysis.PreviewModeAnalysisStrategy;
import org.jenkinsci.plugins.sonargerrit.sonar.preview_mode_analysis.SubJobConfig;
import org.jenkinsci.plugins.sonargerrit.test_infrastructure.jenkins.EnableJenkinsRule;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.jvnet.hudson.test.JenkinsRule;
/** @author <NAME> */
@EnableJenkinsRule
class ConfigRoundTripTest {
@Test
@DisplayName("351.vb_8d85df69260")
void test1(JenkinsRule jenkinsRule) throws Exception {
FreeStyleProject project = jenkinsRule.createFreeStyleProject();
SonarToGerritPublisher before = new SonarToGerritPublisher();
project.getPublishersList().add(before);
before.getInspectionConfig().setSonarQubeInstallationName(UUID.randomUUID().toString());
before.getInspectionConfig().setBaseConfig(new SubJobConfig());
before.getInspectionConfig().getBaseConfig().setAutoMatch(true);
before.getInspectionConfig().getBaseConfig().setProjectPath("foo");
before.getInspectionConfig().getBaseConfig().setSonarReportPath("bar");
before.getReviewConfig().getIssueFilterConfig().setChangedLinesOnly(true);
before.getReviewConfig().getIssueFilterConfig().setNewIssuesOnly(true);
before.getReviewConfig().getIssueFilterConfig().setSeverity("BLOCKER");
before.setScoreConfig(new ScoreConfig());
before.getScoreConfig().getIssueFilterConfig().setChangedLinesOnly(true);
before.getScoreConfig().getIssueFilterConfig().setNewIssuesOnly(true);
before.getScoreConfig().getIssueFilterConfig().setSeverity("BLOCKER");
before.getScoreConfig().setNoIssuesScore(20);
before.getScoreConfig().setIssuesScore(-20);
before.getScoreConfig().setCategory("Foo-Label");
before.getNotificationConfig().setNoIssuesNotificationRecipient("foo");
before.getNotificationConfig().setCommentedIssuesNotificationRecipient("bar");
before.getNotificationConfig().setNegativeScoreNotificationRecipient("baz");
GerritAuthenticationConfig authenticationConfig = new GerritAuthenticationConfig();
authenticationConfig.setUsername("john.doe");
authenticationConfig.setSecretPassword(Secret.fromString("secret"));
before.setAuthConfig(authenticationConfig);
jenkinsRule.submit(
jenkinsRule.createWebClient().getPage(project, "configure").getFormByName("config"));
SonarToGerritPublisher after = project.getPublishersList().get(SonarToGerritPublisher.class);
jenkinsRule.assertEqualBeans(
before,
after,
String.join(
",",
"inspectionConfig.sonarQubeInstallationName",
"inspectionConfig.baseConfig.autoMatch",
"inspectionConfig.baseConfig.projectPath",
"inspectionConfig.baseConfig.sonarReportPath",
"reviewConfig.issueFilterConfig.changedLinesOnly",
"reviewConfig.issueFilterConfig.newIssuesOnly",
"reviewConfig.issueFilterConfig.severity",
"scoreConfig.issueFilterConfig.changedLinesOnly",
"scoreConfig.issueFilterConfig.newIssuesOnly",
"scoreConfig.issueFilterConfig.severity",
"scoreConfig.noIssuesScore",
"scoreConfig.issuesScore",
"scoreConfig.category",
"notificationConfig.noIssuesNotificationRecipient",
"notificationConfig.commentedIssuesNotificationRecipient",
"notificationConfig.negativeScoreNotificationRecipient",
"authConfig.username",
"authConfig.secretPassword"));
}
@Test
@DisplayName("353.v20e9cff705d1")
void test2(JenkinsRule jenkinsRule) throws Exception {
FreeStyleProject project = jenkinsRule.createFreeStyleProject();
SonarToGerritPublisher before = new SonarToGerritPublisher();
project.getPublishersList().add(before);
before.getInspectionConfig().setSonarQubeInstallationName(UUID.randomUUID().toString());
before.getInspectionConfig().setBaseConfig(new SubJobConfig());
before.getInspectionConfig().getBaseConfig().setAutoMatch(true);
before.getInspectionConfig().getBaseConfig().setProjectPath("foo");
before.getInspectionConfig().getBaseConfig().setSonarReportPath("bar");
before.getReviewConfig().getIssueFilterConfig().setChangedLinesOnly(true);
before.getReviewConfig().getIssueFilterConfig().setNewIssuesOnly(true);
before.getReviewConfig().getIssueFilterConfig().setSeverity("BLOCKER");
before.setScoreConfig(new ScoreConfig());
before.getScoreConfig().getIssueFilterConfig().setChangedLinesOnly(true);
before.getScoreConfig().getIssueFilterConfig().setNewIssuesOnly(true);
before.getScoreConfig().getIssueFilterConfig().setSeverity("BLOCKER");
before.getScoreConfig().setNoIssuesScore(20);
before.getScoreConfig().setIssuesScore(-20);
before.getScoreConfig().setCategory("Foo-Label");
before.getNotificationConfig().setNoIssuesNotificationRecipient("foo");
before.getNotificationConfig().setCommentedIssuesNotificationRecipient("bar");
before.getNotificationConfig().setNegativeScoreNotificationRecipient("baz");
GerritAuthenticationConfig authenticationConfig = new GerritAuthenticationConfig();
authenticationConfig.setHttpCredentialsId(UUID.randomUUID().toString());
before.setAuthConfig(authenticationConfig);
jenkinsRule.submit(
jenkinsRule.createWebClient().getPage(project, "configure").getFormByName("config"));
SonarToGerritPublisher after = project.getPublishersList().get(SonarToGerritPublisher.class);
jenkinsRule.assertEqualBeans(
before,
after,
String.join(
",",
"inspectionConfig.sonarQubeInstallationName",
"inspectionConfig.baseConfig.autoMatch",
"inspectionConfig.baseConfig.projectPath",
"inspectionConfig.baseConfig.sonarReportPath",
"reviewConfig.issueFilterConfig.changedLinesOnly",
"reviewConfig.issueFilterConfig.newIssuesOnly",
"reviewConfig.issueFilterConfig.severity",
"scoreConfig.issueFilterConfig.changedLinesOnly",
"scoreConfig.issueFilterConfig.newIssuesOnly",
"scoreConfig.issueFilterConfig.severity",
"scoreConfig.noIssuesScore",
"scoreConfig.issuesScore",
"scoreConfig.category",
"notificationConfig.noIssuesNotificationRecipient",
"notificationConfig.commentedIssuesNotificationRecipient",
"notificationConfig.negativeScoreNotificationRecipient",
"authConfig.httpCredentialsId"));
}
@Test
@DisplayName("361.v3f45367a_71da_")
void test3(JenkinsRule jenkinsRule) throws Exception {
FreeStyleProject project = jenkinsRule.createFreeStyleProject();
SonarToGerritPublisher before = new SonarToGerritPublisher();
project.getPublishersList().add(before);
before.getInspectionConfig().setSonarQubeInstallationName(UUID.randomUUID().toString());
PreviewModeAnalysisStrategy previewModeAnalysisStrategy = new PreviewModeAnalysisStrategy();
before.getInspectionConfig().setAnalysisStrategy(previewModeAnalysisStrategy);
previewModeAnalysisStrategy.setBaseConfig(new SubJobConfig());
previewModeAnalysisStrategy.getBaseConfig().setAutoMatch(true);
previewModeAnalysisStrategy.getBaseConfig().setProjectPath("foo");
previewModeAnalysisStrategy.getBaseConfig().setSonarReportPath("bar");
before.getReviewConfig().getIssueFilterConfig().setChangedLinesOnly(true);
before.getReviewConfig().getIssueFilterConfig().setNewIssuesOnly(true);
before.getReviewConfig().getIssueFilterConfig().setSeverity("BLOCKER");
before.setScoreConfig(new ScoreConfig());
before.getScoreConfig().getIssueFilterConfig().setChangedLinesOnly(true);
before.getScoreConfig().getIssueFilterConfig().setNewIssuesOnly(true);
before.getScoreConfig().getIssueFilterConfig().setSeverity("BLOCKER");
before.getScoreConfig().setNoIssuesScore(20);
before.getScoreConfig().setIssuesScore(-20);
before.getScoreConfig().setCategory("Foo-Label");
before.getNotificationConfig().setNoIssuesNotificationRecipient("foo");
before.getNotificationConfig().setCommentedIssuesNotificationRecipient("bar");
before.getNotificationConfig().setNegativeScoreNotificationRecipient("baz");
GerritAuthenticationConfig authenticationConfig = new GerritAuthenticationConfig();
authenticationConfig.setHttpCredentialsId(UUID.randomUUID().toString());
before.setAuthConfig(authenticationConfig);
jenkinsRule.submit(
jenkinsRule.createWebClient().getPage(project, "configure").getFormByName("config"));
SonarToGerritPublisher after = project.getPublishersList().get(SonarToGerritPublisher.class);
jenkinsRule.assertEqualBeans(
before,
after,
String.join(
",",
"inspectionConfig.sonarQubeInstallationName",
"inspectionConfig.analysisStrategy.baseConfig.autoMatch",
"inspectionConfig.analysisStrategy.baseConfig.projectPath",
"inspectionConfig.analysisStrategy.baseConfig.sonarReportPath",
"reviewConfig.issueFilterConfig.changedLinesOnly",
"reviewConfig.issueFilterConfig.newIssuesOnly",
"reviewConfig.issueFilterConfig.severity",
"scoreConfig.issueFilterConfig.changedLinesOnly",
"scoreConfig.issueFilterConfig.newIssuesOnly",
"scoreConfig.issueFilterConfig.severity",
"scoreConfig.noIssuesScore",
"scoreConfig.issuesScore",
"scoreConfig.category",
"notificationConfig.noIssuesNotificationRecipient",
"notificationConfig.commentedIssuesNotificationRecipient",
"notificationConfig.negativeScoreNotificationRecipient",
"authConfig.httpCredentialsId"));
}
@Test
@DisplayName("next")
void test4(JenkinsRule jenkinsRule) throws Exception {
FreeStyleProject project = jenkinsRule.createFreeStyleProject();
SonarToGerritPublisher before = new SonarToGerritPublisher();
project.getPublishersList().add(before);
PreviewModeAnalysisStrategy previewModeAnalysisStrategy = new PreviewModeAnalysisStrategy();
before.getInspectionConfig().setAnalysisStrategy(previewModeAnalysisStrategy);
previewModeAnalysisStrategy.setSonarQubeInstallationName(UUID.randomUUID().toString());
previewModeAnalysisStrategy.setBaseConfig(new SubJobConfig());
previewModeAnalysisStrategy.getBaseConfig().setAutoMatch(true);
previewModeAnalysisStrategy.getBaseConfig().setProjectPath("foo");
previewModeAnalysisStrategy.getBaseConfig().setSonarReportPath("bar");
before.getReviewConfig().getIssueFilterConfig().setChangedLinesOnly(true);
before.getReviewConfig().getIssueFilterConfig().setNewIssuesOnly(true);
before.getReviewConfig().getIssueFilterConfig().setSeverity("BLOCKER");
before.setScoreConfig(new ScoreConfig());
before.getScoreConfig().getIssueFilterConfig().setChangedLinesOnly(true);
before.getScoreConfig().getIssueFilterConfig().setNewIssuesOnly(true);
before.getScoreConfig().getIssueFilterConfig().setSeverity("BLOCKER");
before.getScoreConfig().setNoIssuesScore(20);
before.getScoreConfig().setIssuesScore(-20);
before.getScoreConfig().setCategory("Foo-Label");
before.getNotificationConfig().setNoIssuesNotificationRecipient("foo");
before.getNotificationConfig().setCommentedIssuesNotificationRecipient("bar");
before.getNotificationConfig().setNegativeScoreNotificationRecipient("baz");
GerritAuthenticationConfig authenticationConfig = new GerritAuthenticationConfig();
authenticationConfig.setHttpCredentialsId(UUID.randomUUID().toString());
before.setAuthConfig(authenticationConfig);
jenkinsRule.submit(
jenkinsRule.createWebClient().getPage(project, "configure").getFormByName("config"));
SonarToGerritPublisher after = project.getPublishersList().get(SonarToGerritPublisher.class);
jenkinsRule.assertEqualBeans(
before,
after,
String.join(
",",
"inspectionConfig.analysisStrategy.sonarQubeInstallationName",
"inspectionConfig.analysisStrategy.baseConfig.autoMatch",
"inspectionConfig.analysisStrategy.baseConfig.projectPath",
"inspectionConfig.analysisStrategy.baseConfig.sonarReportPath",
"reviewConfig.issueFilterConfig.changedLinesOnly",
"reviewConfig.issueFilterConfig.newIssuesOnly",
"reviewConfig.issueFilterConfig.severity",
"scoreConfig.issueFilterConfig.changedLinesOnly",
"scoreConfig.issueFilterConfig.newIssuesOnly",
"scoreConfig.issueFilterConfig.severity",
"scoreConfig.noIssuesScore",
"scoreConfig.issuesScore",
"scoreConfig.category",
"notificationConfig.noIssuesNotificationRecipient",
"notificationConfig.commentedIssuesNotificationRecipient",
"notificationConfig.negativeScoreNotificationRecipient",
"authConfig.httpCredentialsId"));
}
}
|
dkvasnicka/twterm | lib/twterm/notification_backend/tmux_backend.rb | require 'shellwords'
require 'twterm/notification_backend/abstract_notification_backend'
module Twterm
module NotificationBackend
class TmuxBackend < AbstractNotificationBackend
# @param [Twterm::Event::Notification::AbstractNotification] notification notification to display in tmux status line
# @return [void]
def notify(notification)
`tmux set-option display-time 3000`
`tmux set-option message-style fg=black,bg=green`
`tmux display #{Shellwords.escape(" [twterm] #{notification.fallback.gsub("\n", ' ')}")}`
end
end
end
end
|
ibtihajbahaa/ibi1 | main/plugins/org.talend.dataprofiler.core/src/org/talend/dataprofiler/core/migration/impl/SoundexIndicatorQueryTask.java | // ============================================================================
//
// Copyright (C) 2006-2016 Talend Inc. - www.talend.com
//
// This source code is available under agreement available at
// %InstallDIR%\features\org.talend.rcp.branding.%PRODUCTNAME%\%PRODUCTNAME%license.txt
//
// You should have received a copy of the agreement
// along with this program; if not, write to Talend SA
// 9 rue Pages 92150 Suresnes, France
//
// ============================================================================
package org.talend.dataprofiler.core.migration.impl;
import java.util.Date;
import org.talend.dataprofiler.core.migration.AbstractWorksapceUpdateTask;
import org.talend.dataprofiler.core.migration.helper.TalendDefinitionFileUpdate;
/**
* DOC bZhou class global comment. Detailled comment
*/
public class SoundexIndicatorQueryTask extends AbstractWorksapceUpdateTask {
private final String oldSoundexQuery = "ORDER BY d,c DESC"; //$NON-NLS-1$
private final String newSoundexQuery = "ORDER BY d DESC,c DESC"; //$NON-NLS-1$
private final String oldPSoundexQuery = "ORDER BY COUNT(DISTINCT <%=__COLUMN_NAMES__%>) , COUNT(*) DESC"; //$NON-NLS-1$
private final String newPSoundexQuery = "ORDER BY COUNT(DISTINCT <%=__COLUMN_NAMES__%>) DESC , COUNT(*) DESC"; //$NON-NLS-1$
/*
* (non-Javadoc)
*
* @see org.talend.dataprofiler.core.migration.AMigrationTask#doExecute()
*/
@Override
protected boolean doExecute() throws Exception {
TalendDefinitionFileUpdate talendDefinitionFileUpdate = new TalendDefinitionFileUpdate();
talendDefinitionFileUpdate.add(this.oldSoundexQuery, this.newSoundexQuery);
talendDefinitionFileUpdate.add(this.oldPSoundexQuery, this.newPSoundexQuery);
return talendDefinitionFileUpdate.replace(this.getClass().getName());
}
/*
* (non-Javadoc)
*
* @see org.talend.dataprofiler.core.migration.IWorkspaceMigrationTask#getMigrationTaskType()
*/
public MigrationTaskType getMigrationTaskType() {
return MigrationTaskType.FILE;
}
/*
* (non-Javadoc)
*
* @see org.talend.dataprofiler.core.migration.IWorkspaceMigrationTask#getOrder()
*/
public Date getOrder() {
return createDate(2009, 10, 23);
}
}
|
Billybob/tailwindcss-vue | src/utils/plugins.js |
import { extendDefaultTheme, setThemeKey } from './theme.js';
export const setComponentTheme = (Vue, args, themeName) => {
const extend = extendDefaultTheme(args.theme || {}, themeName);
setThemeKey(themeName, extend);
};
export const installComponents = function(Vue, args, components) {
components.forEach(component => {
setComponentTheme(Vue, args, component.name);
Vue.component(component.name, component);
});
};
export const registerComponentProgrammatic = (Vue, property, component) => {
if (!Vue.prototype.$tailwindVue) Vue.prototype.$tailwindVue = {};
Vue.prototype.$tailwindVue[property] = component;
};
|
ctoesca/turbine-topvision | dist/lib/crudServices/TserviceCommand.js | <filename>dist/lib/crudServices/TserviceCommand.js
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const turbine = require("turbine");
var TcrudServiceBase = turbine.TcrudServiceBase;
class TserviceCommand extends TcrudServiceBase {
constructor(config) {
super(config);
}
search(opt) {
return super.search(opt);
}
save(obj, opt) {
return super.save(obj, opt)
.then((result) => {
app.ClusterManager.getClient().publish("savePlugin", JSON.stringify(result));
return result;
});
}
}
exports.TserviceCommand = TserviceCommand;
//# sourceMappingURL=TserviceCommand.js.map |
yimiqidage/study-by-boot | src/main/java/com/test/io/buffer/TestBufferedReader.java | package com.test.io.buffer;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
public class TestBufferedReader {
/**
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
read_better();
read_best();
}
/**
* 整行读取：BufferedReader的方法。方便，简单。
* @throws FileNotFoundException
*/
public static void read_best() throws IOException {
FileReader fr = new FileReader("D:\\demo.txt");
BufferedReader br = new BufferedReader(fr);
String line = null;
while((line=br.readLine())!=null){
System.out.println(line);
}
br.close();
}
/**
* 使用读取的缓冲区的方式：比使用fileReader.read(char[]ch) 好一点
* @throws IOException
*/
public static void read_better() throws IOException {
FileReader fr = new FileReader("D:\\demo.txt");
BufferedReader br = new BufferedReader(fr);
char [] ch = new char[1024];
int num = 0;
while((num=br.read(ch))!=-1){
System.out.println(new String(ch,0,num));
}
br.close();
}
}
|
SDurand7/AVLIT-Engine | Core/Base/include/SceneBVHNode.hpp | #pragma once
#include <vector>
#include <string>
#include <Core/Base/include/Types.hpp>
#include <Core/Base/include/AABB.hpp>
namespace AVLIT {
class SceneBVHNode {
public:
SceneBVHNode() = delete;
SceneBVHNode(SceneObject *object);
SceneBVHNode(SceneBVHNode &&node);
AVLIT_API inline const std::string &name() const;
AVLIT_API inline int childrenCount() const;
inline const AABB &aabb() const;
inline SceneObject *sceneObject() const;
inline void rotate(const Mat3 &trf, const Vec3 ¢er);
inline void scale(const Mat3 &trf);
inline void translate(const Vec3 &translation);
void addChild(SceneBVHNode *child);
AVLIT_API SceneBVHNode *parent() const;
AVLIT_API void removeChild(SceneBVHNode *child);
AVLIT_API void transferTo(SceneBVHNode *newParent);
AVLIT_API SceneBVHNode *child(int i) const;
void updateAABB();
void updateParentsAABBs();
private:
std::vector<SceneBVHNode *> m_children;
SceneBVHNode *m_parent = nullptr;
SceneObject *m_sceneObject;
AABB m_aabb;
};
} // namespace AVLIT
#include <Core/Base/inline/SceneBVHNode.inl> |
bugvm/robovm | Binding/apple/src/main/java/com/bugvm/apple/assetslibrary/ALAsset.java | <gh_stars>10-100
/*
* Copyright (C) 2013-2015 RoboVM AB
*
* 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.bugvm.apple.assetslibrary;
/*<imports>*/
import java.io.*;
import java.nio.*;
import java.util.*;
import com.bugvm.objc.*;
import com.bugvm.objc.annotation.*;
import com.bugvm.objc.block.*;
import com.bugvm.rt.*;
import com.bugvm.rt.annotation.*;
import com.bugvm.rt.bro.*;
import com.bugvm.rt.bro.annotation.*;
import com.bugvm.rt.bro.ptr.*;
import com.bugvm.apple.foundation.*;
import com.bugvm.apple.coregraphics.*;
import com.bugvm.apple.imageio.*;
/*</imports>*/
/*<javadoc>*/
/**
* @since Available in iOS 4.0 and later.
* @deprecated Deprecated in iOS 9.0.
*/
@Deprecated
/*</javadoc>*/
/*<annotations>*/@Library("AssetsLibrary") @NativeClass/*</annotations>*/
/*<visibility>*/public/*</visibility>*/ class /*<name>*/ALAsset/*</name>*/
extends /*<extends>*/NSObject/*</extends>*/
/*<implements>*//*</implements>*/ {
/*<ptr>*/public static class ALAssetPtr extends Ptr<ALAsset, ALAssetPtr> {}/*</ptr>*/
/*<bind>*/static { ObjCRuntime.bind(ALAsset.class); }/*</bind>*/
/*<constants>*//*</constants>*/
/*<constructors>*/
public ALAsset() {}
protected ALAsset(SkipInit skipInit) { super(skipInit); }
/*</constructors>*/
/*<properties>*/
/**
* @since Available in iOS 5.0 and later.
* @deprecated Deprecated in iOS 9.0.
*/
@Deprecated
@Property(selector = "originalAsset")
public native ALAsset getOriginalAsset();
/**
* @since Available in iOS 5.0 and later.
* @deprecated Deprecated in iOS 9.0.
*/
@Deprecated
@Property(selector = "isEditable")
public native boolean isEditable();
/*</properties>*/
/*<members>*//*</members>*/
/* Convenience methods */
public ALAssetType getType() {
NSString val = getPropertyValue(ALAssetProperty.Type, NSString.class);
if (val != null) {
return ALAssetType.valueOf(val);
}
return null;
}
@WeaklyLinked
public com.bugvm.apple.corelocation.CLLocation getLocation() {
com.bugvm.apple.corelocation.CLLocation val = getPropertyValue(ALAssetProperty.Location, com.bugvm.apple.corelocation.CLLocation.class);
if (val != null) {
return val;
}
return null;
}
public double getDuration() {
NSNumber val = getPropertyValue(ALAssetProperty.Duration, NSNumber.class);
if (val != null) {
return val.doubleValue();
}
return 0;
}
@WeaklyLinked
public CGImagePropertyOrientation getOrientation() {
NSNumber val = getPropertyValue(ALAssetProperty.Orientation, NSNumber.class);
if (val != null) {
return CGImagePropertyOrientation.valueOf(val.longValue());
}
return null;
}
public NSDate getDate() {
NSDate val = getPropertyValue(ALAssetProperty.Date, NSDate.class);
if (val != null) {
return val;
}
return null;
}
@SuppressWarnings("unchecked")
public List<String> getRepresentations() {
NSArray<NSString> val = getPropertyValue(ALAssetProperty.Representations, NSArray.class);
if (val != null) {
return val.asStringList();
}
return null;
}
@SuppressWarnings("unchecked")
public Map<String, NSURL> getURLs() {
NSDictionary<NSString, NSURL> val = getPropertyValue(ALAssetProperty.URLs, NSDictionary.class);
if (val != null) {
return val.asStringMap();
}
return null;
}
public NSURL getAssetURL() {
NSURL val = getPropertyValue(ALAssetProperty.AssetURL, NSURL.class);
if (val != null) {
return val;
}
return null;
}
@SuppressWarnings("unchecked")
private <T> T getPropertyValue(ALAssetProperty property, Class<T> type) {
NSObject val = getValue(property);
if (val != null && val.equals(getInvalidProperty())) {
return null;
}
return (T) val;
}
/*<methods>*/
/**
* @since Available in iOS 4.0 and later.
* @deprecated Deprecated in iOS 9.0.
*/
@Deprecated
@GlobalValue(symbol="ALErrorInvalidProperty", optional=true)
public static native NSString getInvalidProperty();
/**
* @since Available in iOS 4.0 and later.
* @deprecated Deprecated in iOS 9.0.
*/
@Deprecated
@Method(selector = "valueForProperty:")
public native NSObject getValue(ALAssetProperty property);
/**
* @since Available in iOS 4.0 and later.
* @deprecated Deprecated in iOS 9.0.
*/
@Deprecated
@Method(selector = "defaultRepresentation")
public native ALAssetRepresentation getDefaultRepresentation();
/**
* @since Available in iOS 4.0 and later.
* @deprecated Deprecated in iOS 9.0.
*/
@Deprecated
@Method(selector = "representationForUTI:")
public native ALAssetRepresentation getRepresentation(String representationUTI);
/**
* @since Available in iOS 4.0 and later.
* @deprecated Deprecated in iOS 9.0.
*/
@Deprecated
@WeaklyLinked
@Method(selector = "thumbnail")
public native CGImage getThumbnail();
/**
* @since Available in iOS 5.0 and later.
* @deprecated Deprecated in iOS 9.0.
*/
@Deprecated
@WeaklyLinked
@Method(selector = "aspectRatioThumbnail")
public native CGImage getAspectRatioThumbnail();
/**
* @since Available in iOS 5.0 and later.
* @deprecated Deprecated in iOS 9.0.
*/
@Deprecated
@WeaklyLinked
@Method(selector = "writeModifiedImageDataToSavedPhotosAlbum:metadata:completionBlock:")
public native void writeModifiedImageData(NSData imageData, CGImageProperties metadata, @Block VoidBlock2<NSURL, NSError> completionBlock);
/**
* @since Available in iOS 5.0 and later.
* @deprecated Deprecated in iOS 9.0.
*/
@Deprecated
@Method(selector = "writeModifiedVideoAtPathToSavedPhotosAlbum:completionBlock:")
public native void writeModifiedVideo(NSURL videoPathURL, @Block VoidBlock2<NSURL, NSError> completionBlock);
/**
* @since Available in iOS 5.0 and later.
* @deprecated Deprecated in iOS 9.0.
*/
@Deprecated
@WeaklyLinked
@Method(selector = "setImageData:metadata:completionBlock:")
public native void setImageData(NSData imageData, CGImageProperties metadata, @Block VoidBlock2<NSURL, NSError> completionBlock);
/**
* @since Available in iOS 5.0 and later.
* @deprecated Deprecated in iOS 9.0.
*/
@Deprecated
@Method(selector = "setVideoAtPath:completionBlock:")
public native void setVideo(NSURL videoPathURL, @Block VoidBlock2<NSURL, NSError> completionBlock);
/*</methods>*/
}
|
sohero-0406/platform | web/src/main/java/com/jeesite/modules/common/dao/CommonAssessmentStuDao.java | <filename>web/src/main/java/com/jeesite/modules/common/dao/CommonAssessmentStuDao.java
/**
* Copyright (c) 2013-Now http://jeesite.com All rights reserved.
*/
package com.jeesite.modules.common.dao;
import com.jeesite.common.dao.CrudDao;
import com.jeesite.common.mybatis.annotation.MyBatisDao;
import com.jeesite.modules.common.entity.CommonAssessmentStu;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* 考核学生表DAO接口
* @author mayuhu
* @version 2019-08-05
*/
@MyBatisDao
public interface CommonAssessmentStuDao extends CrudDao<CommonAssessmentStu> {
Long findAssessmentStuListByConditionCount(CommonAssessmentStu commonAssessmentStu);
List<CommonAssessmentStu> findAssessmentStuListByCondition(CommonAssessmentStu commonAssessmentStu);
Long findAssessmentStuListByConditionAndSchoolIdCount(@Param("commonAssessmentStu") CommonAssessmentStu commonAssessmentStu, @Param("schoolId") String schoolId);
List<CommonAssessmentStu> findAssessmentStuListByConditionAndSchoolId(@Param("commonAssessmentStu") CommonAssessmentStu commonAssessmentStu, @Param("schoolId") String schoolId);
List<String> loadDateList(String schoolId, String assessmentName);
List<String> loadTimeList(String schoolId, String assessmentName, String assessmentDate);
List<CommonAssessmentStu> findAssessmentStuListInAssessment(CommonAssessmentStu commonAssessmentStu);
} |
anji-plus/appsp | java/sp-auth/src/main/java/com/anji/sp/model/po/SpRoleMenuPO.java | <reponame>anji-plus/appsp
package com.anji.sp.model.po;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;
import java.io.Serializable;
/**
* 角色与菜单对应关系PO
*
* @author kean 2020-06-27
*/
@Data
@TableName("sp_role_menu")
@ApiModel("角色与菜单对应关系PO")
public class SpRoleMenuPO implements Serializable {
@ApiModelProperty("id")
@TableId(value = "id", type = IdType.INPUT)
private Long id;
@ApiModelProperty("角色id")
private Long roleId;
@ApiModelProperty("菜单id")
private Long menuId;
public SpRoleMenuPO() {
}
} |
atul-vyshnav/2021_IBM_Code_Challenge_StockIT | src/StockIT-v1-release_source_from_JADX/sources/com/google/android/gms/common/api/internal/DataHolderResult.java | package com.google.android.gms.common.api.internal;
import com.google.android.gms.common.api.Releasable;
import com.google.android.gms.common.api.Result;
import com.google.android.gms.common.api.Status;
import com.google.android.gms.common.data.DataHolder;
public class DataHolderResult implements Releasable, Result {
protected final DataHolder mDataHolder;
protected final Status mStatus;
protected DataHolderResult(DataHolder dataHolder) {
this(dataHolder, new Status(dataHolder.getStatusCode()));
}
protected DataHolderResult(DataHolder dataHolder, Status status) {
this.mStatus = status;
this.mDataHolder = dataHolder;
}
public Status getStatus() {
return this.mStatus;
}
public void release() {
DataHolder dataHolder = this.mDataHolder;
if (dataHolder != null) {
dataHolder.close();
}
}
}
|
linewx/Derecho | database/src/main/java/com/cloudrain/dercho/database/Database.java | package com.cloudrain.dercho.database;
import java.sql.*;
import java.util.Date;
/**
* Created by lugan on 5/17/2016.
*/
public class Database {
public static void main(String... argv) {
System.out.println("-------- PostgreSQL "
+ "JDBC Connection Testing ------------");
try {
Class.forName("org.postgresql.Driver");
} catch (ClassNotFoundException e) {
System.out.println("Where is your PostgreSQL JDBC Driver? "
+ "Include in your library path!");
e.printStackTrace();
return;
}
System.out.println("PostgreSQL JDBC Driver Registered!");
Connection conn = null;
try {
conn = DriverManager.getConnection(
"jdbc:postgresql://127.0.0.1:5434/test", "postgres",
"admin");
// 开时时间
Long begin = new Date().getTime();
// sql前缀
String SQL = "INSERT INTO Employees (id, first, last, age) " +
"VALUES(?, ?, ?, ?)";
try {
conn.setAutoCommit(false);
PreparedStatement pstmt = conn.prepareStatement(SQL);
for (int i = 1; i <= 100; i++) {
for (int j = 1; j <= 10000; j++) {
pstmt.setInt( 1, 400 );
pstmt.setString( 2, "Pappu" );
pstmt.setString( 3, "Singh" );
pstmt.setInt( 4, 33 );
pstmt.addBatch();
}
pstmt.executeBatch();
conn.commit();
}
pstmt.close();
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
// 结束时间
Long end = new Date().getTime();
// 耗时
System.out.println("cast : " + (end - begin) / 1000 + " ms");
} catch (SQLException e) {
System.out.println("Connection Failed! Check output console");
e.printStackTrace();
return;
}
if (conn != null) {
System.out.println("You made it, take control your database now!");
} else {
System.out.println("Failed to make connection!");
}
}
}
|
Sadikortaoglan/Hrms | HrmsCF/src/main/java/com/sadik/hrmscf/business/config/AppConfig.java | package com.sadik.hrmscf.business.config;
import com.cloudinary.Cloudinary;
import com.cloudinary.utils.ObjectUtils;
import org.modelmapper.ModelMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AppConfig {
@Bean
public ModelMapper modelMapper(){
return new ModelMapper();
}
public static Cloudinary cloudinary = new Cloudinary(ObjectUtils.asMap(
"cloud_name", "sadikortaoglan",
"api_key", "428171714582625",
"api_secret", "<KEY>"));
}
|
gupadhyaya/blockatlas | platform/harmony/stake.go | package harmony
import (
"github.com/trustwallet/blockatlas/pkg/blockatlas"
"github.com/trustwallet/blockatlas/pkg/errors"
"github.com/trustwallet/blockatlas/pkg/logger"
services "github.com/trustwallet/blockatlas/services/assets"
)
func (p *Platform) GetValidators() (blockatlas.ValidatorPage, error) {
results := make(blockatlas.ValidatorPage, 0)
validators, err := p.client.GetValidators()
if err != nil {
return results, err
}
apr, err := p.client.GetAPR()
if err != nil {
apr = Annual
}
for _, v := range validators.Validators {
if val, ok := normalizeValidator(v, apr); ok {
results = append(results, val)
}
}
return results, nil
}
func (p *Platform) GetDetails() blockatlas.StakingDetails {
apr, err := p.client.GetAPR()
if err != nil {
apr = Annual
}
return getDetails(apr)
}
func (p *Platform) GetDelegations(address string) (blockatlas.DelegationsPage, error) {
delegations, err := p.client.GetDelegations(address)
if err != nil {
return nil, err
}
validators, err := services.GetValidatorsMap(p)
if err != nil {
return nil, err
}
return NormalizeDelegations(delegations.List, validators), nil
}
func (p *Platform) UndelegatedBalance(address string) (string, error) {
balance, err := p.client.GetBalance(address)
if err != nil {
return "0", err
}
return balance, nil
}
func NormalizeDelegations(delegations []Delegation, validators blockatlas.ValidatorMap) []blockatlas.Delegation {
results := make([]blockatlas.Delegation, 0)
for _, v := range delegations {
validator, ok := validators[v.ValidatorAddress]
if !ok {
logger.Error(errors.E("Validator not found", errors.Params{"address": v.ValidatorAddress, "platform": "harmony", "delegation": v.DelegatorAddress}))
continue
}
delegation := blockatlas.Delegation{
Delegator: validator,
Value: v.Amount.String(),
Status: blockatlas.DelegationStatusActive,
}
results = append(results, delegation)
}
return results
}
func getDetails(apr float64) blockatlas.StakingDetails {
return blockatlas.StakingDetails{
Reward: blockatlas.StakingReward{Annual: apr},
MinimumAmount: blockatlas.Amount("0"),
LockTime: 0,
Type: blockatlas.DelegationTypeDelegate,
}
}
func normalizeValidator(v Validator, apr float64) (validator blockatlas.Validator, ok bool) {
return blockatlas.Validator{
Status: true,
ID: v.Address,
Details: getDetails(apr),
}, true
}
|
EdwardPrentice/teku | util/src/testFixtures/java/tech/pegasys/teku/util/EventSink.java | <gh_stars>1-10
/*
* Copyright 2020 ConsenSys AG.
*
* 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 tech.pegasys.teku.util;
import com.google.common.eventbus.EventBus;
import com.google.common.eventbus.Subscribe;
import java.util.ArrayList;
import java.util.List;
public class EventSink<T> {
private final List<T> events = new ArrayList<>();
private final Class<T> eventType;
private EventSink(final Class<T> eventType) {
this.eventType = eventType;
}
public static <T> List<T> capture(final EventBus eventBus, Class<T> eventType) {
final EventSink<T> eventSink = new EventSink<>(eventType);
eventBus.register(eventSink);
return eventSink.events;
}
@Subscribe
public void onEvent(final Object event) {
if (eventType.isInstance(event)) {
events.add(eventType.cast(event));
}
}
}
|
yolo3a525/AiwSM | src/main/java/com/aiw/bdzb/mapper/SenceMapper.java | <filename>src/main/java/com/aiw/bdzb/mapper/SenceMapper.java
package com.aiw.bdzb.mapper;
import com.aiw.base.mapper.BaseMapper;
import com.aiw.bdzb.entity.Sence;
/**
* 说明：bdzb.scene
* 创建人：aiw
* 创建时间：2017-10-23
*/
public interface SenceMapper extends BaseMapper<Sence> {
}
|
ms140569/loki | cmd/import.go | package cmd
import (
"encoding/csv"
"errors"
"fmt"
"io"
"io/ioutil"
"loki/config"
"loki/log"
"loki/record"
pb "loki/storage"
"loki/subcommand"
"loki/utils"
"os"
"strings"
"time"
)
// Import lets you import Keepass CSV export files into the Loki store.
// Example:
// loki import ~/prj/golang/src/loki/data/import/keepass-export.csv
func Import(cfg config.Configuration, subcommand subcommand.Subcommand, args ...string) error {
if len(args) > 1 {
return errors.New("Too many arguments given")
}
filename := args[0]
log.Info("File to import: " + filename)
data, err := ioutil.ReadFile(filename)
if err != nil {
return err
}
/*
0 -> Group
1 -> Title
2 -> Username
3 -> Password
4 -> URL
5 -> Notes
*/
var records = make(map[string]pb.Record)
r := csv.NewReader(strings.NewReader(string(data)))
skipped := false
for {
record, err := r.Read()
if err == io.EOF {
break
}
if err != nil {
log.Fatal("%v", err)
}
// Skip the first line
if !skipped {
skipped = true
continue
}
group := record[0]
title := record[1]
username := record[2]
password := record[3]
url := record[4]
notes := record[5]
log.Info("--------------------------------")
log.Info("Group -> " + group)
log.Info("Title -> " + title)
log.Info("Username -> " + username)
log.Info("Password -> " + password)
log.Info("URL -> " + url)
log.Info("Notes -> " + notes)
filename := groupAndTitleToFilename(group, title)
// create one tags entry with the date of today to indicate this
// entry to be created by import
t := time.Now()
nowAsString := fmt.Sprintf("%d-%02d-%02d", t.Year(), t.Month(), t.Day())
tags := make([]string, 0)
tags = append(tags, "imported-"+nowAsString)
records[filename] = pb.Record{Title: title, Account: username, Password: password, Tags: tags, Url: url, Notes: notes}
}
cnt := len(records)
if cnt > 0 {
log.Info("\nImporting %d records\n", cnt)
key, _ := utils.GetMasterkey(true)
for filename, rec := range records {
utils.CreateLeadingDirectories(filename)
err := record.WriteRecord(filename, cfg.Generation, key, rec)
if err != nil {
return err
}
}
utils.SetupKeyAgent(key)
}
return nil
}
func groupAndTitleToFilename(group string, title string) string {
if group == "Root" {
return utils.NormalizePath(title)
}
dir := strings.TrimPrefix(group, "Root/")
return utils.NormalizePath(dir + string(os.PathSeparator) + title)
}
|
wkjandroid/Cm | app/src/main/java/com/example/administra/cm/activity/UploadActivity.java | package com.example.administra.cm.activity;
import android.Manifest;
import android.app.ProgressDialog;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.os.Build;
import android.os.Environment;
import android.provider.MediaStore;
import android.support.annotation.NonNull;
import android.support.v4.app.ActivityCompat;
import android.support.v4.content.ContextCompat;
import android.support.v4.content.FileProvider;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.Button;
import android.widget.ImageView;
import android.widget.Toast;
import com.example.administra.cm.util.FileDownloadAndUpload;
import com.example.administra.cm.po.MyApplication;
import com.example.administra.cm.R;
import com.example.administra.cm.po.CmFile;
import com.google.gson.Gson;
import org.litepal.LitePal;
import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import okhttp3.Call;
import okhttp3.Response;
public class UploadActivity extends AppCompatActivity implements View.OnClickListener{
private Uri imageUri=null;
String realpath="";
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.upload);
LitePal.getDatabase();
Button register=(Button)findViewById(R.id.register_button);
Button login=(Button)findViewById(R.id.login_button);
Button button=(Button)findViewById(R.id.select_button);
button.setOnClickListener(UploadActivity.this);
Button uploadImage=(Button)findViewById(R.id.upload_photo);
uploadImage.setOnClickListener(UploadActivity.this);
Button takeBtn=(Button)findViewById(R.id.take_photo);
takeBtn.setOnClickListener(UploadActivity.this);
if (ContextCompat.checkSelfPermission(UploadActivity.this, Manifest.permission.INTERNET)!= PackageManager.PERMISSION_GRANTED){
ActivityCompat.requestPermissions(UploadActivity.this,new String[]{Manifest.permission.INTERNET},1);
}
register.setOnClickListener(UploadActivity.this);
login.setOnClickListener(UploadActivity.this);
}
public void onClick(View view){
switch (view.getId()){
case R.id.upload_photo:
final ProgressDialog uploadDialog = new ProgressDialog(UploadActivity.this);
uploadDialog.setMessage("正在上传...");
uploadDialog.show();
Gson gson=new Gson();
CmFile cmFile=new CmFile();
File uploadfile = new File(realpath);
if (uploadfile.exists()){
try {
InputStream in = new FileInputStream(uploadfile);
BufferedInputStream is = new BufferedInputStream(in);
byte[] b = new byte[is.available()];
is.read(b);
cmFile.setFile(b);
cmFile.setIntention(1);
cmFile.setId(MyApplication.getUser().getUid());
System.out.println("hello"+"开始上传"+MyApplication.getUser().getUid());
}catch (Exception e){
}
String uploadUrl="http://172.16.31.10/CommentPrj/FileManagerServlet";
new FileDownloadAndUpload().uploadFile("cmfile",gson.toJson(cmFile), uploadUrl,new okhttp3.Callback() {
@Override
public void onFailure(Call call, IOException e) {
}
@Override
public void onResponse(Call call, Response response) throws IOException {
String responseData = response.body().string();
uploadDialog.cancel();
//System.out.println(responseData);
}
});
}
break;
case R.id.select_button:
Intent selectImage=new Intent(Intent.ACTION_PICK);
selectImage.setType("image/*");
startActivityForResult(selectImage,1);
break;
case R.id.take_photo:
File file=new File(Environment.getExternalStorageDirectory(),"output_image.jpg");
if (file.exists()){
file.delete();
try {
file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
}
if (Build.VERSION.SDK_INT>=24){
imageUri= FileProvider.getUriForFile(UploadActivity.this,"com.example.administra.cm.FileProvider",
file);
}else {
imageUri=Uri.fromFile(file);
}
Intent takephotoIntent=new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
takephotoIntent.putExtra(MediaStore.EXTRA_OUTPUT,imageUri);
startActivityForResult(takephotoIntent,3);
break;
default:
break;
}
}
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
if (requestCode== 1){
Uri uri=data.getData();
Cursor cursor=getContentResolver().query(uri,new String[]{MediaStore.Images.Media.DATA},
null,null,null);
if (cursor!=null){
int index = cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
cursor.moveToFirst();
String path = cursor.getString(index);
if (path.endsWith("jpg") || path.endsWith("png")||
path.endsWith("PNG")||path.endsWith("JPG")||
path.endsWith("bmp")||path.endsWith("gif")){
try {
realpath=path;
Bitmap bitmap = BitmapFactory.decodeStream(getContentResolver().openInputStream(uri));
ImageView imageView=(ImageView)findViewById(R.id.imag_view);
imageView.setImageBitmap(bitmap);
}catch (Exception e){
}
}
}
}
if (requestCode==3)
{ Bitmap bitmap=null;
try {
bitmap = getSmallBitmap(imageUri.getPath());
OutputStream baos = new FileOutputStream(imageUri.getPath());
bitmap.compress(Bitmap.CompressFormat.JPEG, 40, baos);
baos.flush();
baos.close();
}catch (Exception e){
}
realpath=imageUri.getPath();
ImageView imageView=(ImageView)findViewById(R.id.imag_view);
imageView.setImageBitmap(bitmap);
}
}
public static Bitmap getSmallBitmap(String filePath) {
final BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
BitmapFactory.decodeFile(filePath, options);
options.inSampleSize = calculateInSampleSize(options, 480, 800);
options.inJustDecodeBounds = false;
return BitmapFactory.decodeFile(filePath, options);
}
public static int calculateInSampleSize(BitmapFactory.Options options,int reqWidth, int reqHeight) {
final int height = options.outHeight;
final int width = options.outWidth;
int inSampleSize = 1;
if (height > reqHeight || width > reqWidth) {
final int heightRatio = Math.round((float) height/ (float) reqHeight);
final int widthRatio = Math.round((float) width / (float) reqWidth);
inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;
}
return inSampleSize;
}
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
switch (requestCode){
case 1:
if (grantResults.length>0 && grantResults[0]!=PackageManager.PERMISSION_GRANTED){
Toast.makeText(UploadActivity.this,"请求被拒绝，请开启权限!!!",Toast.LENGTH_SHORT).show();
}
break;
}
}
}
|
Mateus-A-Soares/orange-talents-03-template-ecommerce | src/main/java/br/com/zupacademy/mateus/mercadolivre/categoria/CategoriaResponse.java | <reponame>Mateus-A-Soares/orange-talents-03-template-ecommerce<gh_stars>0
package br.com.zupacademy.mateus.mercadolivre.categoria;
/**
*
* Classe modelo que encapsula os dados a serem enviados sobre categorias pela API
*
* @author <NAME>
*/
public class CategoriaResponse {
private Long id;
private Long categoriaMaeId;
private String nome;
/**
* Instância o objeto e popula com os dados encapsulados na categoria recebida.
*
* @param categoria categoria encapsulando os dados do registro.
*/
public CategoriaResponse(Categoria categoria) {
this.id = categoria.getId();
this.nome = categoria.getNome();
Categoria categoriaMae = categoria.getCategoriaMae();
if(categoriaMae != null)
this.categoriaMaeId = categoria.getCategoriaMae().getId();
}
public Long getId() {
return id;
}
public String getNome() {
return nome;
}
public Long getCategoriaMaeId() {
return categoriaMaeId;
}
}
|
lakodali/osc-core | osc-domain/src/main/java/org/osc/core/broker/model/entities/job/JobRecord.java | /*******************************************************************************
* Copyright (c) Intel Corporation
* Copyright (c) 2017
*
* 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.osc.core.broker.model.entities.job;
import java.util.Date;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.EnumType;
import javax.persistence.Enumerated;
import javax.persistence.FetchType;
import javax.persistence.OneToMany;
import javax.persistence.Table;
import org.osc.core.broker.model.entities.BaseEntity;
import org.osc.core.common.job.JobState;
import org.osc.core.common.job.JobStatus;
@Entity
@Table(name = "JOB")
public class JobRecord extends BaseEntity {
private static final long serialVersionUID = 1L;
@Column(name = "name", nullable = false)
private String name;
@Column(name = "failure_reason")
private String failureReason;
@Column(name = "state")
@Enumerated(EnumType.STRING)
private JobState state;
@Column(name = "status")
@Enumerated(EnumType.STRING)
private JobStatus status;
@Column(name = "queued_timestamp")
private Date queuedTimestamp;
@Column(name = "started_timestamp")
private Date startedTimestamp;
@Column(name = "completed_timestamp")
private Date completedTimestamp;
@Column(name = "submitted_by")
private String submittedBy;
@OneToMany(targetEntity = TaskRecord.class, mappedBy = "job", fetch = FetchType.LAZY, cascade = CascadeType.ALL)
private Set<TaskRecord> tasks = new HashSet<TaskRecord>();
@OneToMany(targetEntity = JobObject.class, mappedBy = "job", fetch = FetchType.LAZY, cascade = CascadeType.ALL)
private Set<JobObject> objects = new HashSet<JobObject>();
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
public Set<TaskRecord> getTasks() {
return this.tasks;
}
public JobState getState() {
return this.state;
}
public void setState(JobState state) {
this.state = state;
}
public JobStatus getStatus() {
return this.status;
}
public void setStatus(JobStatus status) {
this.status = status;
}
public Date getQueuedTimestamp() {
return this.queuedTimestamp;
}
public void setQueuedTimestamp(Date queuedTimestamp) {
this.queuedTimestamp = queuedTimestamp;
}
public Date getStartedTimestamp() {
return this.startedTimestamp;
}
public void setStartedTimestamp(Date startedTimestamp) {
this.startedTimestamp = startedTimestamp;
}
public Date getCompletedTimestamp() {
return this.completedTimestamp;
}
public void setCompletedTimestamp(Date date) {
this.completedTimestamp = date;
}
public String getSubmittedBy() {
return this.submittedBy;
}
public void setSubmittedBy(String submittedBy) {
this.submittedBy = submittedBy;
}
public String getFailureReason() {
return this.failureReason;
}
public void setFailureReason(String failureReason) {
this.failureReason = failureReason;
}
public Set<JobObject> getObjects() {
return this.objects;
}
public void addObject(JobObject object) {
this.objects.add(object);
}
@Override
public String toString() {
return "JobRecord [state=" + this.state + ", status=" + this.status + ", getId()=" + getId() + ", getName()=" + getName()
+ "]";
}
} |
minisu/cloudrunner-go | cloudzap/level.go | package cloudzap
import "go.uber.org/zap/zapcore"
// LevelToSeverity converts a zapcore.Level to its corresponding Cloud Logging severity level.
// See: https://cloud.google.com/logging/docs/reference/v2/rest/v2/LogEntry#logseverity.
func LevelToSeverity(l zapcore.Level) string {
switch l {
case zapcore.DebugLevel:
return "DEBUG"
case zapcore.InfoLevel:
return "INFO"
case zapcore.WarnLevel:
return "WARNING"
case zapcore.ErrorLevel:
return "ERROR"
case zapcore.DPanicLevel:
return "CRITICAL"
case zapcore.PanicLevel:
return "ALERT"
case zapcore.FatalLevel:
return "EMERGENCY"
default:
return "DEFAULT"
}
}
|
FRC4188/2020_InfiniteRecharge | src/main/java/frc/robot/commands/intake/SpinJustIntake.java | package frc.robot.commands.intake;
import edu.wpi.first.wpilibj2.command.CommandBase;
import frc.robot.subsystems.Intake;
public class SpinJustIntake extends CommandBase {
private final Intake intake;
private final double percent;
/**
* Constructs new SpinJustIntake command to spin just the intake motors a given percentage.
*
* @param intake - Intake subsystem to use.
* @param percent - percent output to command motors.
*/
public SpinJustIntake(Intake intake, double percent) {
this.percent = percent;
this.intake = intake;
}
@Override
public void initialize() {
}
@Override
public void execute() {
intake.spinIntake(percent);
}
@Override
public void end(boolean interrupted) {
intake.spinIntake(0);
}
@Override
public boolean isFinished() {
return false;
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.