repo_name
stringlengths
6
101
path
stringlengths
4
300
text
stringlengths
7
1.31M
PandaProgrammingHub/ls
app/services/schoolMasters/divisionFactory.js
<reponame>PandaProgrammingHub/ls angular.module('MyApp') .factory('divisionFactory', function($http) { return { getDivisionDetail: function() { return $http.get('/api/divisions'); } }; });
7aske/grain
src/test/java/com/_7aske/grain/http/json/JsonDeserializerTest.java
package com._7aske.grain.http.json; import org.junit.jupiter.api.Test; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNull; class JsonDeserializerTest { static class User { String username; @JsonIgnore String password; User manager; } @Test void test_deserialize() { User manager = new User(); manager.username = "manager"; manager.password = "<PASSWORD>"; User user = new User(); user.password = "<PASSWORD>"; user.username = "username"; user.manager = manager; JsonSerializer<User> deserializer = new JsonSerializer<>(User.class); JsonObject jsonObject = (JsonObject) deserializer.serialize(user); assertEquals("username", jsonObject.getString("username")); assertNull(jsonObject.get("password")); assertEquals(manager.username, jsonObject.getObject("manager").getString("username")); assertNull(jsonObject.getObject("manager").get("password")); assertNull(jsonObject.getObject("manager").get("manager")); } }
danieljurek/Sia-EventUI
cfg/distConstants.js
<filename>cfg/distConstants.js let baseConstants = require('./defaultConstants') const argv = require('minimist')(process.argv.slice(2)) let distConstants = Object.assign({}, baseConstants, { appEnv: 'dist', aadInstance: argv.aadInstance, aadTenant: argv.aadTenant, clientId: argv.clientId, baseUrl: argv.baseUrl, authRedirectUri: argv.authRedirectUri, authVersion: argv.authVersion }) module.exports = distConstants
waruqi/hikyuu
hikyuu_cpp/hikyuu/indicator/imp/Vigor.cpp
/* * Vigor.cpp * * Created on: 2013-4-12 * Author: fasiondog */ #include "Vigor.h" #include "../crt/EMA.h" #include "../crt/PRICELIST.h" #include "../crt/KDATA.h" #include "../crt/REF.h" namespace hku { Vigor::Vigor(): IndicatorImp("VIGOR", 1) { setParam<int>("n", 2); } Vigor::Vigor(const KData& kdata, int n): IndicatorImp() { size_t total = kdata.size(); _readyBuffer(total, 1); setParam<int>("n", n); if (n < 1) { HKU_ERROR("Invalide param[n] must >= 1 ! [Vigor::Vigor]"); return; } m_discard = 1; if (0 == total) { return; } PriceList tmp(total, Null<price_t>()); for (size_t i = 1; i < total; ++i) { tmp[i] = (kdata[i].closePrice - kdata[i-1].closePrice) * kdata[i].transCount; } Indicator ema = EMA(PRICELIST(tmp, 1), n); for (size_t i = 0; i < total; ++i) { _set(ema[i], i); } } Vigor::~Vigor() { } bool Vigor::check() { int n = getParam<int>("n"); if (n < 1) { HKU_ERROR("Invalide param[n] must >= 1 ! [Vigor::Vigor]"); return false; } return true; } void Vigor::_calculate(const Indicator& ind) { if (ind.getResultNumber() < 6) { HKU_ERROR("ind's result_num must > 6! [Vigor::_calculate]"); return; } size_t total = ind.size(); if (0 == total) { return; } int n = getParam<int>("n"); m_discard = 1 + ind.discard(); if (0 == total) { return; } PriceList tmp(total, Null<price_t>()); for (size_t i = m_discard; i < total; ++i) { //tmp[i] = (kdata[i].closePrice - kdata[i-1].closePrice) * kdata[i].transCount; tmp[i] = (ind.get(i,3) - ind.get(i-1,3)) * ind.get(i,5); } Indicator ema = EMA(PRICELIST(tmp, m_discard), n); for (size_t i = 0; i < total; ++i) { _set(ema[i], i); } } Indicator HKU_API VIGOR(const KData& data, int n) { return Indicator(IndicatorImpPtr(new Vigor(data, n))); } Indicator HKU_API VIGOR(int n) { IndicatorImpPtr p = make_shared<Vigor>(); p->setParam<int>("n", n); return Indicator(p); } Indicator HKU_API VIGOR(const Indicator& indicator, int n){ IndicatorImpPtr p = make_shared<Vigor>(); p->setParam<int>("n", n); p->calculate(indicator); return Indicator(p); } } /* namespace hku */
timami/PlaneSense
GoPositionalAudio/jsimplementation/node_modules/web-audio-engine/lib/api/index.js
"use strict"; module.exports = { AnalyserNode: require("./AnalyserNode"), AudioBuffer: require("./AudioBuffer"), AudioBufferSourceNode: require("./AudioBufferSourceNode"), AudioContext: require("./AudioContext"), AudioDestinationNode: require("./AudioDestinationNode"), AudioListener: require("./AudioListener"), AudioNode: require("./AudioNode"), AudioParam: require("./AudioParam"), BiquadFilterNode: require("./BiquadFilterNode"), ChannelMergerNode: require("./ChannelMergerNode"), ChannelSplitterNode: require("./ChannelSplitterNode"), ConvolverNode: require("./ConvolverNode"), DelayNode: require("./DelayNode"), DynamicsCompressorNode: require("./DynamicsCompressorNode"), EventTarget: require("./EventTarget"), GainNode: require("./GainNode"), IIRFilterNode: require("./IIRFilterNode"), OscillatorNode: require("./OscillatorNode"), PannerNode: require("./PannerNode"), PeriodicWave: require("./PeriodicWave"), ScriptProcessorNode: require("./ScriptProcessorNode"), SpatialListener: require("./SpatialListener"), SpatialPannerNode: require("./SpatialPannerNode"), StereoPannerNode: require("./StereoPannerNode"), WaveShaperNode: require("./WaveShaperNode") };
km-works/kmw-astgen
src/main/java/edu/rice/cs/plt/recur/ValueContinuation.java
<reponame>km-works/kmw-astgen /*BEGIN_COPYRIGHT_BLOCK* PLT Utilities BSD License Copyright (c) 2007-2010 JavaPLT group at Rice University All rights reserved. Developed by: Java Programming Languages Team Rice University http://www.cs.rice.edu/~javaplt/ Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. - Neither the name of the JavaPLT group, Rice University, nor the names of the library's 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 AND 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. *END_COPYRIGHT_BLOCK*/ package edu.rice.cs.plt.recur; import edu.rice.cs.plt.lambda.Lambda; /** A continuation that is resolved at creation time. */ public class ValueContinuation<T> implements Continuation<T> { private final T _val; /** Wrap the given value as a continuation. */ public ValueContinuation(T val) { _val = val; } /** Return the wrapped value. */ public T value() { return _val; } /** Always {@code true}. */ public boolean isResolved() { return true; } /** Throw an {@code IllegalStateException}, because this continuation is already resolved. */ public Continuation<T> step() { throw new IllegalStateException(); } /** Create a {@link ComposedContinuation} in terms of this object and {@code c}. */ public <R> Continuation<R> compose(Lambda<? super T, ? extends Continuation<? extends R>> c) { return new ComposedContinuation<T, R>(this, c); } /** Call the constructor (allows {@code T} to be inferred). */ public static <T> ValueContinuation<T> make(T val) { return new ValueContinuation<T>(val); } }
Tinkoff/neptune
selenium/src/main/java/ru/tinkoff/qa/neptune/selenium/HttpProxy.java
<filename>selenium/src/main/java/ru/tinkoff/qa/neptune/selenium/HttpProxy.java package ru.tinkoff.qa.neptune.selenium; import org.openqa.selenium.WebDriverException; import org.openqa.selenium.devtools.DevTools; import org.openqa.selenium.devtools.v102.network.Network; import org.openqa.selenium.devtools.v102.network.model.RequestWillBeSent; import org.openqa.selenium.devtools.v102.network.model.ResponseReceived; import ru.tinkoff.qa.neptune.selenium.functions.browser.proxy.HttpTraffic; import java.util.List; import java.util.Optional; import java.util.concurrent.CopyOnWriteArrayList; import static java.util.Optional.ofNullable; public class HttpProxy { private final DevTools devTools; private final List<RequestWillBeSent> requestList = new CopyOnWriteArrayList<>(); private final List<ResponseReceived> responseList = new CopyOnWriteArrayList<>(); private final List<HttpTraffic> httpTrafficList = new CopyOnWriteArrayList<>(); public HttpProxy(DevTools dt) { this.devTools = dt; devTools.send(Network.enable(Optional.empty(), Optional.empty(), Optional.empty())); } public void listen() { devTools.addListener(Network.requestWillBeSent(), requestList::add); devTools.addListener(Network.responseReceived(), responseList::add); } public void clearDump() { requestList.clear(); responseList.clear(); httpTrafficList.clear(); } public void disabledNetwork() { ofNullable(devTools.getCdpSession()) .ifPresent(cdp -> devTools.send(Network.disable())); } public List<HttpTraffic> getTraffic() { try { requestList.forEach(request -> { var httpTraffic = new HttpTraffic(); var response = responseList .stream() .filter(r -> r.getRequestId().toString().equals(request.getRequestId().toString())) .findFirst() .orElse(null); httpTraffic.setRequest(request) .setResponse(response); try { ofNullable(devTools) .map(DevTools::getCdpSession) .ifPresent(session -> httpTraffic.setBody(devTools.send(Network.getResponseBody(request.getRequestId())))); } catch (WebDriverException e) { e.printStackTrace(); } httpTrafficList.add(httpTraffic); }); } finally { requestList.clear(); responseList.clear(); } return httpTrafficList; } }
l-cdc/scala
src/compiler/scala/tools/nsc/typechecker/PatternTypers.scala
/* * Scala (https://www.scala-lang.org) * * Copyright EPFL and Lightbend, Inc. * * Licensed under Apache License 2.0 * (http://www.apache.org/licenses/LICENSE-2.0). * * See the NOTICE file distributed with this work for * additional information regarding copyright ownership. */ package scala package tools package nsc package typechecker import scala.collection.mutable import symtab.Flags import Mode._ /** * A pattern match such as: * * {{{ * x match { case Foo(a, b) => ...} * }}} * * Might match an instance of any of the following definitions of Foo. * Note the analogous treatment between case classes and unapplies. * * {{{ * case class Foo(xs: Int*) * case class Foo(a: Int, xs: Int*) * case class Foo(a: Int, b: Int) * case class Foo(a: Int, b: Int, xs: Int*) * * object Foo { def unapplySeq(x: Any): Option[Seq[Int]] } * object Foo { def unapplySeq(x: Any): Option[(Int, Seq[Int])] } * object Foo { def unapply(x: Any): Option[(Int, Int)] } * object Foo { def unapplySeq(x: Any): Option[(Int, Int, Seq[Int])] } * }}} */ trait PatternTypers { self: Analyzer => import global._ import definitions._ trait PatternTyper { self: Typer => import TyperErrorGen._ import infer._ // If the tree's symbol's type does not define an extractor, maybe the tree's type does. // this is the case when we encounter an arbitrary tree as the target of an unapply call // (rather than something that looks like a constructor call.) (for now, this only happens // due to wrapClassTagUnapply, but when we support parameterized extractors, it will become // more common place) private def hasUnapplyMember(tpe: Type): Boolean = reallyExists(unapplyMember(tpe)) private def hasUnapplyMember(sym: Symbol): Boolean = hasUnapplyMember(sym.tpe_*) // ad-hoc overloading resolution to deal with unapplies and case class constructors // If some but not all alternatives survive filtering the tree's symbol with `p`, // then update the tree's symbol and type to exclude the filtered out alternatives. private def inPlaceAdHocOverloadingResolution(fun: Tree)(p: Symbol => Boolean): Tree = fun.symbol filter p match { case sym if sym.exists && (sym ne fun.symbol) => fun setSymbol sym modifyType (tp => filterOverloadedAlts(tp)(p)) case _ => fun } private def filterOverloadedAlts(tpe: Type)(p: Symbol => Boolean): Type = tpe match { case OverloadedType(pre, alts) => overloadedType(pre, alts filter p) case tp => tp } def typedConstructorPattern(fun0: Tree, pt: Type): Tree = { // Do some ad-hoc overloading resolution and update the tree's symbol and type // do not update the symbol if the tree's symbol's type does not define an unapply member // (e.g. since it's some method that returns an object with an unapply member) val fun = inPlaceAdHocOverloadingResolution(fun0)(hasUnapplyMember) val canElide = treeInfo.isQualifierSafeToElide(fun) val caseClass = companionSymbolOf(fun.tpe.typeSymbol.sourceModule, context) val member = unapplyMember(fun.tpe) def resultType = (fun.tpe memberType member).finalResultType def isEmptyType = resultOfIsEmpty(resultType) def isOkay = ( resultType.isErroneous || (resultType <:< BooleanTpe) || (isEmptyType <:< BooleanTpe) || member.isMacro || member.isOverloaded // the whole overloading situation is over the rails ) // if we're already failing, no need to emit another error here if (fun.tpe.isErroneous) fun // Dueling test cases: pos/overloaded-unapply.scala, run/case-class-23.scala, pos/t5022.scala // A case class with 23+ params has no unapply method. // A case class constructor may be overloaded with unapply methods in the companion. // A case class maybe have its own custom unapply (so non-synthetic) scala/bug#11252 // Unapply methods aren't `isCaseApplyOrUnapply` in Scala 3 tasty/run/src-2/tastytest/TestColour.scala else if (canElide && caseClass.isCase && !member.isOverloaded && (member == NoSymbol || member.isSynthetic)) logResult(s"convertToCaseConstructor($fun, $caseClass, pt=$pt)")(convertToCaseConstructor(fun, caseClass, pt)) else if (!reallyExists(member)) CaseClassConstructorError(fun, s"${fun.symbol} is not a case class, nor does it have a valid unapply/unapplySeq member") else if (isOkay) fun else if (isEmptyType == NoType) CaseClassConstructorError(fun, s"an unapply result must have a member `def isEmpty: Boolean`") else CaseClassConstructorError(fun, s"an unapply result must have a member `def isEmpty: Boolean` (found: `def isEmpty: $isEmptyType`)") } def typedArgsForFormals(args: List[Tree], formals: List[Type], mode: Mode): List[Tree] = { def typedArgWithFormal(arg: Tree, pt: Type) = { if (isByNameParamType(pt)) typedArg(arg, mode, mode.onlySticky, dropByName(pt)) else typedArg(arg, mode, mode.onlySticky | BYVALmode, pt) } if (formals.isEmpty) Nil else { val lastFormal = formals.last val isRepeated = isRepeatedParamType(lastFormal) if (isRepeated) { val fixed = formals.init val elem = dropRepeated(lastFormal) val front = map2(args, fixed)(typedArgWithFormal) val rest = context withinStarPatterns (args drop front.length map (typedArgWithFormal(_, elem))) front ::: rest } else { map2(args, formals)(typedArgWithFormal) } } } private def boundedArrayType(bound: Type): Type = { val tparam = context.owner.freshExistential("", 0) setInfo (TypeBounds upper bound) newExistentialType(tparam :: Nil, arrayType(tparam.tpe_*)) } protected def typedStarInPattern(tree: Tree, mode: Mode, pt: Type) = { val Typed(expr, tpt) = tree: @unchecked val exprTyped = typed(expr, mode) val baseClass = exprTyped.tpe.typeSymbol match { case ArrayClass => ArrayClass case NothingClass => NothingClass case _ => SeqClass } val starType = baseClass match { case ArrayClass if isPrimitiveValueType(pt) || !isFullyDefined(pt) => arrayType(pt) case ArrayClass => boundedArrayType(pt) case _ => seqType(pt) } val exprAdapted = adapt(exprTyped, mode, starType) exprAdapted.tpe baseType baseClass match { case TypeRef(_, _, elemtp :: Nil) => treeCopy.Typed(tree, exprAdapted, tpt setType elemtp) setType elemtp case _ if baseClass eq NothingClass => exprAdapted case _ => setError(tree) } } protected def typedInPattern(tree: Typed, mode: Mode, pt: Type) = { val Typed(expr, tpt) = tree val tptTyped = typedType(tpt, mode) val tpe = tptTyped.tpe val exprTyped = typed(expr, mode, tpe.deconst) val extractor = extractorForUncheckedType(tpt.pos, tpe) val canRemedy = tpe match { case RefinedType(_, decls) if !decls.isEmpty => false case RefinedType(parents, _) if parents exists isUncheckable => false case _ => extractor.nonEmpty } val ownType = inferTypedPattern(tptTyped, tpe, pt, canRemedy) val treeTyped = treeCopy.Typed(tree, exprTyped, tptTyped) setType ownType extractor match { case EmptyTree => treeTyped case _ => wrapClassTagUnapply(treeTyped, extractor, tpe) } } private class VariantToSkolemMap extends VariancedTypeMap { private val skolemBuffer = mutable.ListBuffer[TypeSymbol]() // !!! FIXME - skipping this when variance.isInvariant allows unsoundness, see scala/bug#5189 // Test case which presently requires the exclusion is run/gadts.scala. def eligible(tparam: Symbol) = ( tparam.isTypeParameterOrSkolem && tparam.owner.isTerm && !variance.isInvariant ) def skolems = try skolemBuffer.toList finally skolemBuffer.clear() def apply(tp: Type): Type = mapOver(tp) match { case tp @ TypeRef(NoPrefix, tpSym, Nil) if eligible(tpSym) => val bounds = ( if (variance.isInvariant) tpSym.tpeHK.bounds else if (variance.isPositive) TypeBounds.upper(tpSym.tpeHK) else TypeBounds.lower(tpSym.tpeHK) ) // origin must be the type param so we can deskolemize val skolem = context.owner.newGADTSkolem(freshTypeName("?" + tpSym.name), tpSym, bounds) skolemBuffer += skolem logResult(s"Created gadt skolem $skolem: ${skolem.tpe_*} to stand in for $tpSym")(skolem.tpe_*) case tp1 => tp1 } } /* * To deal with the type slack between actual (run-time) types and statically known types, for each abstract type T, * reflect its variance as a skolem that is upper-bounded by T (covariant position), or lower-bounded by T (contravariant). * * Consider the following example: * * class AbsWrapperCov[+A] * case class Wrapper[B](x: Wrapped[B]) extends AbsWrapperCov[B] * * def unwrap[T](x: AbsWrapperCov[T]): Wrapped[T] = x match { * case Wrapper(wrapped) => // Wrapper's type parameter must not be assumed to be equal to T, it's *upper-bounded* by it * wrapped // : Wrapped[_ <: T] * } * * this method should type check if and only if Wrapped is covariant in its type parameter * * when inferring Wrapper's type parameter B from x's type AbsWrapperCov[T], * we must take into account that x's actual type is AbsWrapperCov[Tactual] forSome {type Tactual <: T} * as AbsWrapperCov is covariant in A -- in other words, we must not assume we know T exactly, all we know is its upper bound * * since method application is the only way to generate this slack between run-time and compile-time types (TODO: right!?), * we can simply replace skolems that represent method type parameters as seen from the method's body * by other skolems that are (upper/lower)-bounded by that type-parameter skolem * (depending on the variance position of the skolem in the statically assumed type of the scrutinee, pt) * * see test/files/../t5189*.scala */ private def convertToCaseConstructor(tree: Tree, caseClass: Symbol, ptIn: Type): Tree = { val variantToSkolem = new VariantToSkolemMap // `caseClassType` is the prefix from which we're seeing the constructor info, so it must be kind *. // Need the `initialize` call to make sure we see any type params. val caseClassType = caseClass.initialize.tpe_*.asSeenFrom(tree.tpe.prefix, caseClass.owner) assert(!caseClassType.isHigherKinded, s"Unexpected type constructor $caseClassType") // If the case class is polymorphic, need to capture those type params in the type that we relativize using asSeenFrom, // as they may also be sensitive to the prefix (see test/files/pos/t11103.scala). // Note that undetParams may thus be different from caseClass.typeParams. // (For a monomorphic case class, GenPolyType will not create/destruct a PolyType.) val (undetparams, caseConstructorType) = GenPolyType.unapply { val ctorUnderClassTypeParams = GenPolyType(caseClass.typeParams, caseClass.primaryConstructor.info) ctorUnderClassTypeParams.asSeenFrom(caseClassType, caseClass) }.get // println(s"convertToCaseConstructor(${tree.tpe}, $caseClass, $ptIn) // $caseClassType // ${caseConstructorType.typeParams.map(_.info)}") val tree1 = TypeTree(caseConstructorType) setOriginal tree // have to open up the existential and put the skolems in scope // can't simply package up pt in an ExistentialType, because that takes us back to square one (List[_ <: T] == List[T] due to covariance) val ptSafe = logResult(s"case constructor from (${tree.summaryString}, $caseClassType, $ptIn)")(variantToSkolem(ptIn)) val freeVars = variantToSkolem.skolems // use "tree" for the context, not context.tree: don't make another CaseDef context, // as instantiateTypeVar's bounds would end up there val ctorContext = context.makeNewScope(tree, context.owner) freeVars foreach ctorContext.scope.enter newTyper(ctorContext).infer.inferConstructorInstance(tree1, undetparams, ptSafe) // simplify types without losing safety, // so that we get rid of unnecessary type slack, and so that error messages don't unnecessarily refer to skolems val extrapolator = new ExistentialExtrapolation(freeVars) def extrapolate(tp: Type) = extrapolator extrapolate tp // once the containing CaseDef has been type checked (see typedCase), // tree1's remaining type-slack skolems will be deskolemized (to the method type parameter skolems) tree1 modifyType { case MethodType(ctorArgs, restpe) => // ctorArgs are actually in a covariant position, since this is the type of the subpatterns of the pattern represented by this Apply node ctorArgs foreach (_ modifyInfo extrapolate) copyMethodType(tree1.tpe, ctorArgs, extrapolate(restpe)) // no need to clone ctorArgs, this is OUR method type case tp => tp } } def doTypedUnapply(tree: Tree, funOrig: Tree, funOverloadResolved: Tree, args: List[Tree], mode: Mode, pt: Type): Tree = { def errorTree: Tree = treeCopy.Apply(tree, funOrig, args) setType ErrorType if (args.lengthCompare(MaxTupleArity) > 0) { TooManyArgsPatternError(funOverloadResolved); errorTree } else { val extractorPos = funOverloadResolved.pos val extractorTp = funOverloadResolved.tpe val unapplyMethod = unapplyMember(extractorTp) val unapplyType = extractorTp memberType unapplyMethod lazy val remedyUncheckedWithClassTag = extractorForUncheckedType(extractorPos, firstParamType(unapplyType)) def canRemedy = remedyUncheckedWithClassTag != EmptyTree val selectorDummySym = context.owner.newValue(nme.SELECTOR_DUMMY, extractorPos, Flags.SYNTHETIC) setInfo { if (isApplicableSafe(Nil, unapplyType, pt :: Nil, WildcardType)) pt else { def freshArgType(tp: Type): Type = tp match { case MethodType(param :: _, _) => param.tpe case PolyType(tparams, restpe) => createFromClonedSymbols(tparams, freshArgType(restpe))(genPolyType) case OverloadedType(_, _) => OverloadedUnapplyError(funOverloadResolved); ErrorType case _ => UnapplyWithSingleArgError(funOverloadResolved); ErrorType } val GenPolyType(freeVars, unappFormal) = freshArgType(unapplyType.skolemizeExistential(context.owner, tree)) val unapplyContext = context.makeNewScope(tree, context.owner) freeVars foreach unapplyContext.scope.enter val pattp = newTyper(unapplyContext).infer.inferTypedPattern(tree, unappFormal, pt, canRemedy) // turn any unresolved type variables in freevars into existential skolems val skolems = freeVars map (fv => unapplyContext.owner.newExistentialSkolem(fv, fv)) pattp.substSym(freeVars, skolems) } } // Clearing the type is necessary so that ref will be stabilized; see scala/bug#881. val selectUnapply = Select(funOverloadResolved.clearType(), unapplyMethod) // NOTE: The symbol of unapplyArgTree (`<unapply-selector>`) may be referenced in `fun1.tpe` // the pattern matcher deals with this in ExtractorCallRegular -- SI-6130 val unapplyArg = Ident(selectorDummySym) updateAttachment SubpatternsAttachment(args) // attachment is for quasiquotes val typedApplied = typedPos(extractorPos)(Apply(selectUnapply, unapplyArg :: Nil)) if (typedApplied.tpe.isErroneous || unapplyMethod.isMacro && !typedApplied.isInstanceOf[Apply]) { if (unapplyMethod.isMacro) { if (isBlackbox(unapplyMethod)) BlackboxExtractorExpansion(tree) else WrongShapeExtractorExpansion(tree) } errorTree } else { val unapplyArgTypeInferred = selectorDummySym.tpe_* // the union of the expected type and the inferred type of the argument to unapply val extractedTp = glb(ensureFullyDefined(pt) :: unapplyArgTypeInferred :: Nil) val formals = patmat.unapplyFormals(typedApplied, args)(context) val typedUnapply = UnApply(typedApplied, typedArgsForFormals(args, formals, mode)) setPos tree.pos setType extractedTp if (canRemedy && !(typedApplied.symbol.owner isNonBottomSubClass ClassTagClass)) wrapClassTagUnapply(typedUnapply, remedyUncheckedWithClassTag, extractedTp) else typedUnapply } } } def wrapClassTagUnapply(uncheckedPattern: Tree, classTagExtractor: Tree, pt: Type): Tree = { // TODO: disable when in unchecked match // we don't create a new Context for a Match, so find the CaseDef, // then go out one level and navigate back to the match that has this case val args = List(uncheckedPattern) val app = atPos(uncheckedPattern.pos)(Apply(classTagExtractor, args)) // must call doTypedUnapply directly, as otherwise we get undesirable rewrites // and re-typechecks of the target of the unapply call in PATTERNmode, // this breaks down when the classTagExtractor (which defines the unapply member) is not a simple reference to an object, // but an arbitrary tree as is the case here val res = doTypedUnapply(app, classTagExtractor, classTagExtractor, args, PATTERNmode, pt) log(sm""" |wrapClassTagUnapply { | pattern: $uncheckedPattern | extract: $classTagExtractor | pt: $pt | res: $res |}""".trim) res } // if there's a ClassTag that allows us to turn the unchecked type test for `pt` into a checked type test // return the corresponding extractor (an instance of ClassTag[`pt`]) def extractorForUncheckedType(pos: Position, pt: Type): Tree = { if (isPastTyper || (pt eq NoType)) EmptyTree else { pt match { case RefinedType(parents, decls) if !decls.isEmpty || (parents exists isUncheckable) => return EmptyTree case _ => } // only look at top-level type, can't (reliably) do anything about unchecked type args (in general) // but at least make a proper type before passing it elsewhere val pt1 = pt.dealiasWiden match { case tr @ TypeRef(pre, sym, args) if args.nonEmpty => copyTypeRef(tr, pre, sym, sym.typeParams map (_.tpeHK)) // replace actual type args with dummies case pt1 => pt1 } if (isCheckable(pt1)) EmptyTree else resolveClassTag(pos, pt1) match { case tree if unapplyMember(tree.tpe).exists => tree case _ => devWarning(s"Cannot create runtime type test for $pt1") ; EmptyTree } } } } }
janduracz/acumen-dev
src/main/scala/acumen/interpreters/enclosure/event/tree/EventTree.scala
<reponame>janduracz/acumen-dev package acumen.interpreters.enclosure.event.tree import acumen.interpreters.enclosure._ import acumen.interpreters.enclosure.HybridSystem import acumen.interpreters.enclosure.Types._ import acumen.interpreters.enclosure.Types.Event import acumen.interpreters.enclosure.Util._ import acumen.interpreters.enclosure.affine.UnivariateAffineEnclosure import acumen.interpreters.enclosure.affine.UnivariateAffineScalarEnclosure import acumen.interpreters.enclosure.ivp.IVPSolver import acumen.interpreters.enclosure.ivp.PicardSolver /** TODO add description */ // TODO add tests abstract class EventSequence { val enclosure: UnivariateAffineEnclosure val mayBeLast: Boolean def sigma: Mode def tau: Set[Mode] def prefixes: Seq[EventSequence] def subSequences: Set[EventSequence] val size: Int val domain: Interval def setMayBeLastTo(value: Boolean): EventSequence } /** TODO add description */ // TODO add tests case class EmptySequence( val initialMode: Mode, val enclosure: UnivariateAffineEnclosure, val mayBeLast: Boolean) extends EventSequence { def sigma = initialMode def tau = Set(initialMode) def prefixes = Seq() def subSequences = Set(this) val size = 0 val domain = enclosure.domain def setMayBeLastTo(value: Boolean) = if (mayBeLast == value) this else EmptySequence(initialMode, enclosure, value) } /** TODO add description */ // TODO add tests case class NonemptySequence( val lastEvent: Event, val enclosure: UnivariateAffineEnclosure, val mayBeLast: Boolean, val prefix: EventSequence) extends EventSequence { def sigma = prefix.sigma def tau = Set(lastEvent.tau) def prefixes = prefix +: prefix.prefixes def subSequences = prefix.subSequences + this val size = prefix.size + 1 val domain = prefix.domain def setMayBeLastTo(value: Boolean) = if (mayBeLast == value) this else NonemptySequence(lastEvent, enclosure, value, prefix) } /** TODO add description */ // TODO add tests case class EventTree( maximalSequences: Set[EventSequence], T: Interval, H: HybridSystem, S: UncertainState, delta: Double, m: Int, n: Int, degree: Int) { def sequences = maximalSequences.flatMap(_.subSequences) /** TODO add description */ // TODO add tests def size = maximalSequences.map(_.size).max /** * helper function for onlyUpdateAffectedVariables * determines if variable i is affected by event e, as defined by: * (i) the fields of e.sigma and e.tau affect i in the same way * (ii) the reset map of e is the identity on i and any variable that * depends on i within the field of e.tau (note that one needs * to chase this dependence through multiple applications of * the field) */ private def eventDoesNotAffectVariable(e: Event, name: VarName) = { val fieldsHaveSameEffect = H.fields(e.sigma).components(name) == H.fields(e.tau).components(name) val resetIsIdentityOnThisAndAllDependentVariables = (Set(name) ++ H.dependentVariables(H.fields(e.tau))(name)).forall(n => H.resets(e).components(n) == Variable(n)) fieldsHaveSameEffect && resetIsIdentityOnThisAndAllDependentVariables } /** * Uses components from previous enclosure in place * of current ones for variables not affected by the * event e. * * Implements the event-variable independence analysis * algorithm in 6.3. * * property: result should be equal at T.hi to previous * components for unaffected variables and to * current for affected ones, as given by * eventDoesNotAffectVariable. */ // TODO add tests private def onlyUpdateAffectedComponents( e: Event, previous: UnivariateAffineEnclosure, current: Box) = current.map { case (name, x) => { name -> { if (eventDoesNotAffectVariable(e, name)) previous(name)(T.high) else x } } } /** * Adds another event to the event sequences in the tree. */ def addLayer(ivpSolver: IVPSolver): EventTree = { def newSequences(v: EventSequence, o: Outcome) = { o.events.map { e => { if (H.resets(e)(H.guards(e).support(v.enclosure.range)) == Set(false)) println("\naddLayer: illegal reset!") require(H.guards(e)(v.enclosure.range) != Set(false), "Rand(Y(v)) \\/ C_e must be nonempty") if (o.isInstanceOf[MaybeOneOf] && H.domains(e.tau)(H.resets(e)(H.guards(e).support(v.enclosure.range))) == Set(false)) { /** * We have detected that the event sequence v cannot be followed * by e as the reset maps the previous state outside the support * of the domain invariant of the target mode of e. */ v.setMayBeLastTo(true) } else { require( H.domains(e.tau)(H.resets(e)(H.guards(e).support(v.enclosure.range))) != Set(false), "Reset " + H.resets(e) + "\nmust map contracted enclosure " + H.guards(e).support(v.enclosure.range) + "\ninto target domain " + H.domains(e.tau)) val A = H.domains(e.tau).support(H.resets(e)(H.guards(e).support(v.enclosure.range))) val N = ivpSolver.solveIVP(H.fields(e.tau), T, A, delta, m, n, degree)._1.range val lastEvent = e val affines = N val enclosure = UnivariateAffineEnclosure(v.domain, affines) val mayBeLast = false val prefix = v NonemptySequence(lastEvent, enclosure, mayBeLast, prefix).asInstanceOf[EventSequence] } } } } /** TODO add description */ val newMaximalSequences = { /** * This is the main event detection algorithm. */ def detectNextEvent( H: HybridSystem, T: Interval, q: Mode, Y: UnivariateAffineEnclosure): Outcome = { /** * This is likely where we get the issues with enclosures exploding from. The * events that are deemed possible are determined by evaluating the guard over * the range of the enclosure, rather than directly on the enclosure which is * a major source of imprecision! */ val events = H.events.filter(e => e.sigma == q && H.guards(e)(Y.range) != Set(false)) if (events.isEmpty) MaybeOneOf(events) else if (H.domains(q)(Y(Y.domain.high)) == Set(false)) CertainlyOneOf(events) else MaybeOneOf(events) } maximalSequences.flatMap { v => if (v.prefixes.exists { w => w.tau == v.tau && w.enclosure.contains(v.enclosure) }) { Set(v) } else { val mode = v.tau.head val enclosure = v.enclosure val decision = detectNextEvent(H, T, mode, enclosure) if (decision.events isEmpty) Set(v.setMayBeLastTo(true)) else decision match { case CertainlyOneOf(es) => newSequences(v, decision) case MaybeOneOf(es) => newSequences(v.setMayBeLastTo(true), decision) } } } } EventTree(newMaximalSequences, T, H, S, delta, m, n, degree) } /** TODO add description */ // TODO add tests def endTimeStates: Set[UncertainState] = { val mayBeLastSequences = maximalSequences.flatMap(v => (v +: v.prefixes).toSet).filter(v => v.mayBeLast) val mayBeLastStates = mayBeLastSequences.flatMap { v => { val modes = v.tau // FIXME evaluating at the enclosure's domain.high instead of T.high // the latter caused an assertion failure as enclosures were evaluated // outside their domain. E.g. and enclosure over [0,1.5] would be evaluated // at the point [3,3]. val initialCondition = v.enclosure.components.mapValues(e => e(e.domain.high)) modes.map(q => UncertainState(q, initialCondition)) } } val modewiseMayBeLastStates = (mayBeLastStates groupBy (_.mode)).mapValues(_.map(_.initialCondition)) modewiseMayBeLastStates.mapValues(xs => xs.tail.foldLeft(xs.head) { (res, x) => zipDefault(res, x, Interval.zero).mapValues { case (l, r) => l /\ r } }).map { case (q, b) => UncertainState(q, H.domains(q).support(b)) }.toSet } /** TODO add description */ // TODO add tests def enclosureUnion: UnivariateAffineEnclosure = { val sequences = maximalSequences.flatMap(v => (v +: v.prefixes).toSet) require(sequences.nonEmpty) val affs = sequences.tail.foldLeft(sequences.head.enclosure.components) { (res, v) => zipDefault(res, v.enclosure.components, UnivariateAffineScalarEnclosure( // FIXME for now.. not sure of correct choice of domain! sequences.head.enclosure.domain, 0)).mapValues { case (l, r) => l union r } } UnivariateAffineEnclosure(maximalSequences.head.domain, affs) } /** TODO add description */ // TODO add tests def unprunedEnclosures: Seq[UnivariateAffineEnclosure] = { val sequences = maximalSequences.flatMap(v => (v +: v.prefixes).toSet) sequences.map(_.enclosure).toSeq } /** * Takes the box-hull of enclosures for non-empty event sequences * and intersects with the target mode domain invariant. * * This has the effect of "shaving off" of the parts of enclosures that e.g. * in the bouncing ball example "dip below" the ground. */ def prunedEnclosures: Seq[UnivariateAffineEnclosure] = maximalSequences.head match { case EmptySequence(_, enclosure, _) => Seq(enclosure) case _ => val sequences = maximalSequences.flatMap(v => (v +: v.prefixes).toSet) sequences.map(s => s.tau.foldLeft(s.enclosure.range) { case (res, mode) => H.domains(mode).support(res) }).map(ran => UnivariateAffineEnclosure(T, ran)).toSeq } // StateEnclosure extraction methods /** TODO add description */ def stateEnclosure: StateEnclosure = StateEnclosure.union(sequences.map(s => new StateEnclosure(Map( s.tau.head -> Some(H.domains(s.tau.head).support(s.enclosure.range)))))) /** TODO add description */ def endTimeStateEnclosure = StateEnclosure.union(endTimeStates.map(s => new StateEnclosure(Map(s.mode -> Some(s.initialCondition))))) } object EventTree { /** TODO add description */ // TODO add tests def initialTree( T: Interval, H: HybridSystem, S: UncertainState, delta: Double, m: Int, n: Int, degree: Int, ivpSolver: IVPSolver) = { val mode = S.mode val (enclosure, _) = ivpSolver.solveIVP(H.fields(mode), T, S.initialCondition, delta, m, n, degree) val mayBeLast = false val sequences = Set(EmptySequence(mode, enclosure, mayBeLast).asInstanceOf[EventSequence]) EventTree(sequences, T, H, S, delta, m, n, degree) } }
javaduke/data-weave-intellij-plugin
data-weave-plugin/src/main/java/org/mule/tooling/lang/dw/spellchecker/WeaveSpellCheckerStrategy.java
<filename>data-weave-plugin/src/main/java/org/mule/tooling/lang/dw/spellchecker/WeaveSpellCheckerStrategy.java package org.mule.tooling.lang.dw.spellchecker; import com.intellij.psi.PsiElement; import com.intellij.spellchecker.tokenizer.SpellcheckingStrategy; import org.jetbrains.annotations.NotNull; import org.mule.tooling.lang.dw.WeaveLanguage; public class WeaveSpellCheckerStrategy extends SpellcheckingStrategy { @Override public boolean isMyContext(@NotNull PsiElement element) { return element.getLanguage() == WeaveLanguage.getInstance(); } }
binhdv37/nong-nghiep-v2
application/src/main/java/org/thingsboard/server/dft/services/baocaoTongHop/BcTongHopService.java
<filename>application/src/main/java/org/thingsboard/server/dft/services/baocaoTongHop/BcTongHopService.java<gh_stars>0 package org.thingsboard.server.dft.services.baocaoTongHop; import java.util.List; import java.util.UUID; public interface BcTongHopService { // tong so canh bao trong 1 khoang thoi gian cua 1 dam tom long countDamtomCanhbao(UUID damtomId, long startTs, long endTs); long countTenantActiveDamtomCanhBao(UUID tenantId, List<UUID> activeDamtomIdList, long startTs, long endTs); String getMailContentData(UUID tenantId, UUID damtomId, long startTs, long endTs); }
ga4gh-beacon/beacon-elixir
elixir_beacon/src/main/java/org/ega_archive/elixirbeacon/dto/BeaconRequest.java
package org.ega_archive.elixirbeacon.dto; import java.util.List; import lombok.AllArgsConstructor; import lombok.Builder; import lombok.Data; import lombok.NoArgsConstructor; @Data @Builder @AllArgsConstructor @NoArgsConstructor public class BeaconRequest { private String variantType; private String alternateBases; private String referenceBases; private String referenceName; private Integer start; private Integer startMin; private Integer startMax; private Integer end; private Integer endMin; private Integer endMax; private String mateName; private String assemblyId; private List<String> datasetIds; private String includeDatasetResponses; }
kas1e/Eldritch
Code/Libraries/UI/src/Actions/wbactionuishowhidewidget.h
<gh_stars>0 #ifndef WBACTIONUISHOWHIDEWIDGET_H #define WBACTIONUISHOWHIDEWIDGET_H #include "wbaction.h" class WBActionUIShowHideWidget : public WBAction { public: WBActionUIShowHideWidget(); virtual ~WBActionUIShowHideWidget(); DEFINE_WBACTION_FACTORY(UIShowHideWidget); virtual void InitializeFromDefinition(const SimpleString& DefinitionName); virtual void Execute(); private: HashedString m_ScreenName; // Config HashedString m_WidgetName; // Config bool m_Hidden; // Config bool m_SetDisabled; // Config: also set disabled if hiding, or set enabled if // showing }; #endif // WBACTIONUISHOWHIDEWIDGET_H
rillig/r4intellij
test/com/r4intellij/debugger/RForcedFunctionDebuggerHandlerTest.java
<reponame>rillig/r4intellij<gh_stars>100-1000 package com.r4intellij.debugger; import com.r4intellij.debugger.data.RLocation; import com.r4intellij.debugger.exception.RDebuggerException; import com.r4intellij.debugger.executor.RExecutionResult; import com.r4intellij.debugger.mock.MockRExecutor; import com.r4intellij.debugger.mock.MockRFunctionDebugger; import com.r4intellij.debugger.mock.MockRFunctionDebuggerFactory; import com.r4intellij.debugger.mock.MockROutputReceiver; import org.jetbrains.annotations.NotNull; import org.junit.Test; import java.util.Collections; import static org.junit.Assert.assertEquals; public class RForcedFunctionDebuggerHandlerTest { @Test public void stack1() throws RDebuggerException { /* def() { instruction1 } */ final String result = "[1] 1 2 3"; final Stack1RFunctionDebugger debugger = new Stack1RFunctionDebugger(); final MockRFunctionDebuggerFactory factory = new MockRFunctionDebuggerFactory(debugger); final MockROutputReceiver receiver = new MockROutputReceiver(); final RForcedFunctionDebuggerHandler handler = new RForcedFunctionDebuggerHandler( new IllegalRExecutor(), factory, receiver ); //noinspection StatementWithEmptyBody while (handler.advance()) { } assertEquals(1, debugger.getCounter()); assertEquals(1, factory.getCounter()); assertEquals(Collections.emptyList(), receiver.getOutputs()); assertEquals(Collections.emptyList(), receiver.getErrors()); assertEquals(result, handler.getResult()); } @Test public void stack21() throws RDebuggerException { /* def() { instruction1 abc() { instruction1 instruction2 } instruction2 } */ final String result = "[1] 1 2 3"; final MockRFunctionDebugger secondFunctionDebugger = new MockRFunctionDebugger("abc", 2, null); final MockRFunctionDebugger firstFunctionDebugger = new Stack211RFunctionDebugger(secondFunctionDebugger); final MockRFunctionDebuggerFactory factory = new MockRFunctionDebuggerFactory(firstFunctionDebugger); final MockROutputReceiver receiver = new MockROutputReceiver(); final RForcedFunctionDebuggerHandler handler = new RForcedFunctionDebuggerHandler( new IllegalRExecutor(), factory, receiver ); //noinspection StatementWithEmptyBody while (handler.advance()) { } assertEquals(2, secondFunctionDebugger.getCounter()); assertEquals(3, firstFunctionDebugger.getCounter()); assertEquals(1, factory.getCounter()); assertEquals(Collections.emptyList(), receiver.getOutputs()); assertEquals(Collections.emptyList(), receiver.getErrors()); assertEquals(result, handler.getResult()); } @Test public void stack22() throws RDebuggerException { /* def() { instruction1 abc() { instruction1 instruction2 } } */ final String result = "[1] 1 2 3"; final MockRFunctionDebugger secondFunctionDebugger = new Stack222RFunctionDebugger(); final MockRFunctionDebugger firstFunctionDebugger = new Stack221RFunctionDebugger(secondFunctionDebugger); final MockRFunctionDebuggerFactory factory = new MockRFunctionDebuggerFactory(firstFunctionDebugger); final MockROutputReceiver receiver = new MockROutputReceiver(); final RForcedFunctionDebuggerHandler handler = new RForcedFunctionDebuggerHandler( new IllegalRExecutor(), factory, receiver ); //noinspection StatementWithEmptyBody while (handler.advance()) { } assertEquals(2, secondFunctionDebugger.getCounter()); assertEquals(2, firstFunctionDebugger.getCounter()); assertEquals(1, factory.getCounter()); assertEquals(Collections.emptyList(), receiver.getOutputs()); assertEquals(Collections.emptyList(), receiver.getErrors()); assertEquals(result, handler.getResult()); } @Test public void stack3() throws RDebuggerException { /* def() { instruction1 abc() { instruction1 ghi() { instruction1 instruction2 } } instruction2 } */ final String result = "[1] 1 2 3"; final MockRFunctionDebugger thirdFunctionDebugger = new Stack33RFunctionDebugger(); final MockRFunctionDebugger secondFunctionDebugger = new Stack32RFunctionDebugger(thirdFunctionDebugger); final MockRFunctionDebugger firstFunctionDebugger = new Stack31RFunctionDebugger(secondFunctionDebugger); final MockRFunctionDebuggerFactory factory = new MockRFunctionDebuggerFactory(firstFunctionDebugger); final MockROutputReceiver receiver = new MockROutputReceiver(); final RForcedFunctionDebuggerHandler handler = new RForcedFunctionDebuggerHandler( new IllegalRExecutor(), factory, receiver ); //noinspection StatementWithEmptyBody while (handler.advance()) { } assertEquals(2, thirdFunctionDebugger.getCounter()); assertEquals(2, secondFunctionDebugger.getCounter()); assertEquals(3, firstFunctionDebugger.getCounter()); assertEquals(1, factory.getCounter()); assertEquals(Collections.emptyList(), receiver.getOutputs()); assertEquals(Collections.emptyList(), receiver.getErrors()); assertEquals(result, handler.getResult()); } private static class IllegalRExecutor extends MockRExecutor { @NotNull @Override protected RExecutionResult doExecute(@NotNull final String command) throws RDebuggerException { throw new IllegalStateException("DoExecute shouldn't be called"); } } private static class Stack1RFunctionDebugger extends MockRFunctionDebugger { public Stack1RFunctionDebugger() { super("", 1, null); } @NotNull @Override public RLocation getLocation() { throw new IllegalStateException("GetLocation shouldn't be called"); } @NotNull @Override public String getResult() { return "[1] 1 2 3"; } } private static class Stack211RFunctionDebugger extends MockRFunctionDebugger { @NotNull private final MockRFunctionDebugger myNextFunctionDebugger; public Stack211RFunctionDebugger(@NotNull final MockRFunctionDebugger debugger) { super("def", 3, null); myNextFunctionDebugger = debugger; } @NotNull @Override public RLocation getLocation() { throw new IllegalStateException("GetLocation shouldn't be called"); } @Override public void advance() throws RDebuggerException { super.advance(); if (getCounter() == 2) { assert getHandler() != null; getHandler().appendDebugger(myNextFunctionDebugger); } } @NotNull @Override public String getResult() { return "[1] 1 2 3"; } } private static class Stack221RFunctionDebugger extends MockRFunctionDebugger { @NotNull private final MockRFunctionDebugger myNextFunctionDebugger; public Stack221RFunctionDebugger(@NotNull final MockRFunctionDebugger debugger) { super("def", 2, null); myNextFunctionDebugger = debugger; } @NotNull @Override public RLocation getLocation() { throw new IllegalStateException("GetLocation shouldn't be called"); } @Override public void advance() throws RDebuggerException { super.advance(); if (getCounter() == 2) { assert getHandler() != null; myNextFunctionDebugger.setHandler(getHandler()); getHandler().appendDebugger(myNextFunctionDebugger); } } } private static class Stack222RFunctionDebugger extends MockRFunctionDebugger { public Stack222RFunctionDebugger() { super("abc", 2, null); } @NotNull @Override public RLocation getLocation() { throw new IllegalStateException("GetLocation shouldn't be called"); } @Override public void advance() throws RDebuggerException { super.advance(); if (getCounter() == 2) { assert getHandler() != null; getHandler().setDropFrames(2); } } @NotNull @Override public String getResult() { return "[1] 1 2 3"; } } private static class Stack31RFunctionDebugger extends MockRFunctionDebugger { @NotNull private final MockRFunctionDebugger myNextFunctionDebugger; public Stack31RFunctionDebugger(@NotNull final MockRFunctionDebugger nextFunctionDebugger) { super("def", 3, null); myNextFunctionDebugger = nextFunctionDebugger; } @Override public void advance() throws RDebuggerException { super.advance(); if (getCounter() == 2) { assert getHandler() != null; myNextFunctionDebugger.setHandler(getHandler()); getHandler().appendDebugger(myNextFunctionDebugger); } } @NotNull @Override public String getResult() { return "[1] 1 2 3"; } } private static class Stack32RFunctionDebugger extends MockRFunctionDebugger { @NotNull private final MockRFunctionDebugger myNextFunctionDebugger; public Stack32RFunctionDebugger(@NotNull final MockRFunctionDebugger nextFunctionDebugger) { super("abc", 2, null); myNextFunctionDebugger = nextFunctionDebugger; } @Override public void advance() throws RDebuggerException { super.advance(); if (getCounter() == 2) { assert getHandler() != null; myNextFunctionDebugger.setHandler(getHandler()); getHandler().appendDebugger(myNextFunctionDebugger); } } } private static class Stack33RFunctionDebugger extends MockRFunctionDebugger { public Stack33RFunctionDebugger() { super("ghi", 2, null); } @Override public void advance() throws RDebuggerException { super.advance(); if (getCounter() == 2) { assert getHandler() != null; getHandler().setDropFrames(2); } } } }
SimonCasteran/JobBoard
back/app.js
<filename>back/app.js const express = require ("express"); require("dotenv").config(); const app = express(); const connectTodatabase = require("./config/connectToDatabase") const bodyParser = require("body-parser"); const cors = require("cors") const port = process.env.PORT; const users = require("./controllers/users") const ads = require("./controllers/ads") const comp = require("./controllers/companies") const appl = require("./controllers/applications") const cookieParser = require('cookie-parser') app.use(cookieParser()) const auth = require('./middlewares/auth'); const admin = require('./middlewares/adminAuth') // connectTodatabase() app.use(bodyParser.json()); app.use(function(req, res, next) { res.header('Access-Control-Allow-Origin', "http://localhost:3000"); res.header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept"); res.header("Access-Control-Allow-Credentials", "true") next(); }); app.listen(port, () => console.log ("Server started on port "+port)); // Users routes app.post("/createUser", users.createUser); app.post("/login", users.verifyUser); app.get("/logout", users.logout) app.get("/getUser", auth, admin, users.getUser) app.get("/getSelfUser", auth, users.getSelfUser) app.get("/getAllUsers", auth, admin, users.getAllUsers) app.post("/updateUser", auth, admin, users.updateUser) app.post("/updateSelfUser", auth, users.updateSelfUser) app.post("/deleteUser", auth, admin, users.deleteUser) app.post("/deleteSelfUser", auth, users.deleteSelfUser) // Job ads routes app.post("/createAd", ads.createAd) app.post("/getAd", ads.getAd) app.post("/getAdsByCompanyId", ads.getAdsByCompanyId) app.post("/getAllAds", ads.getAllAds) app.post("/updateAd", auth, ads.updateAd) app.post("/deleteAd", auth, ads.deleteAd) // Companies CRUD app.post("/createCompany", comp.createCompany) app.post("/getCompany", comp.getCompany) app.get("/getAllCompanies", comp.getAllCompanies) app.post("/updateCompany", auth, comp.updateCompany) app.post("/deleteCompany", auth, comp.deleteCompany) // Applications CRUD app.post("/createApplication", appl.createApplication) app.get("/getApplication", auth, appl.getApplication) app.get("/getAllApplications", auth, appl.getAllApplications) app.get("/getUserApplications", auth, appl.getUserApplications) app.get("/getRecruiterApplications", auth, appl.getRecruiterApplications) app.post("/updateApplication", auth, appl.updateApplication) app.post("/deleteApplication", auth, appl.deleteApplication)
anubhavnandan/leetCode
14_Longest_Common_Prefix.cpp
<filename>14_Longest_Common_Prefix.cpp //C++ 11 #include<iostream> #include<bits/stdc++.h> using namespace std; class Solution { public: string longestCommonPrefix(vector<string>& strs) { string prefixHanger; int commonPrefixIndex=0; sort(strs.begin(),strs.end(),[] (const std::string& first, const std::string& second){ return first.size() < second.size(); }); for(int j=0; j<strs.size();j++){ if(strs[j]!=""){ for(int i=0; i<strs[j].length(); i++){ //cout<<strs[j][i]<<" "; if(j==0){ prefixHanger.push_back(strs[j][i]); commonPrefixIndex=i; }else if(prefixHanger[i]!=strs[j][i]){ (i-1)<commonPrefixIndex?commonPrefixIndex=(i-1):commonPrefixIndex; break; }else if((i<prefixHanger.length() && i==strs[j].length()-1)){ i<commonPrefixIndex?commonPrefixIndex=i:commonPrefixIndex; break; } } // cout<<endl; } else{ commonPrefixIndex=-1; break; } //cout<<commonPrefixIndex<<endl; } string out; for(int i=0; i<=commonPrefixIndex; i++){ out.insert(out.begin()+i,prefixHanger[i]); } return out; } }; int main(){ vector<string> v = { "flower","flawer","flvwer","flower"}; // vector<string> v = {"flower","flow","flight"}; //vector<string> v = {"dog","racecar","car"}; //vector<string> v = {"ab","a",""}; //vector<string> v = {"aaa","aa","aaa"}; // vector<string> v = { // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", // "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" // }; Solution Obj; cout<<Obj.longestCommonPrefix(v); return 0; }
fluffynukeit/mdsplus
xmdsshr/XmdsWidgetCallbacks.c
<filename>xmdsshr/XmdsWidgetCallbacks.c<gh_stars>10-100 /* Copyright (c) 2017, Massachusetts Institute of Technology All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* VAX/DEC CMS REPLACEMENT HISTORY, Element XMDSWIDGETCALLBACKS.C */ /* *12 3-OCT-1994 16:05:36 TWF "Unix" */ /* *11 3-OCT-1994 15:59:31 TWF "Unix" */ /* *10 22-FEB-1994 10:48:21 TWF "Take out NO_X_GLBS" */ /* *9 3-MAR-1993 16:13:05 JAS "use xmdsshr.h" */ /* *8 26-FEB-1993 11:37:15 JAS "port to decc" */ /* *7 8-JAN-1993 08:38:37 TWF "Remove call to acceptfocus" */ /* *6 17-SEP-1992 10:44:22 TWF "Remove setinputfocus call" */ /* *5 6-FEB-1992 11:40:34 TWF "Remove XmdsNapplyProc" */ /* *4 6-FEB-1992 11:20:49 TWF "Add XmdsNapplyProc to ApplyButton" */ /* *3 14-JAN-1992 16:41:38 TWF "Add Apply,Ok,Reset,Cancel callbacks" */ /* *2 14-JAN-1992 16:29:45 TWF "Add Apply,Ok,Reset,Cancel callbacks" */ /* *1 8-OCT-1991 13:33:44 TWF "Callback convenience routines" */ /* VAX/DEC CMS REPLACEMENT HISTORY, Element XMDSWIDGETCALLBACKS.C */ /*------------------------------------------------------------------------------ Name: XmdsWIDGETCALLBACKS Type: C function Author: <NAME> Date: 9-MAR-1990 Purpose: Generic callbacks which take a widget as the tag Use XmdsRegisterWidgetCallback to enable widgets to be tag argument. ------------------------------------------------------------------------------ Call sequence: void XmdsManageChildCallback(Widget w1,Widget *w2); void XmdsUnmanageChildCallback(Widget w1,Widget *w2); void XmdsDestroyWidgetCallback(Widget w1,Widget *w2); void XmdsRegisterWidgetCallback(Widget w1,Widget *w2); void XmdsRaiseWindow(Widget w); void XmdsManageWindow(Widget w); ------------------------------------------------------------------------------ Copyright (c) 1990 Property of Massachusetts Institute of Technology, Cambridge MA 02139. This program cannot be copied or distributed in any form for non-MIT use without specific written approval of MIT Plasma Fusion Center Management. --------------------------------------------------------------------------- Description: ------------------------------------------------------------------------------*/ #include <Xm/Xm.h> #include <xmdsshr.h> static Widget FindShellChild(Widget w) { Widget sc; for (sc = w; sc && !XtIsShell(XtParent(sc)); sc = XtParent(sc)) ; return sc; } void XmdsRaiseWindow(Widget w) { Widget shell; for (shell = w; shell && !XtIsShell(shell); shell = XtParent(shell)) ; if (shell) XtPopup(shell, XtGrabNone); } void XmdsManageWindow(Widget w) { if (!XtIsManaged(w)) XtManageChild(w); else XmdsRaiseWindow(w); } void XmdsManageChildCallback(Widget w1, Widget *w2) { XmdsManageWindow(*w2); } void XmdsUnmanageChildCallback(Widget w1, Widget *w2) { XtUnmanageChild(*w2); } void XmdsDestroyWidgetCallback(Widget w1, Widget *w2) { XtDestroyWidget(*w2); } void XmdsRegisterWidgetCallback(Widget w1, Widget *w2) { *w2 = w1; } #ifndef _NO_XDS extern void XmdsResetAllXds(Widget w); extern Boolean XmdsXdsAreValid(Widget w); extern Boolean XmdsApplyAllXds(Widget w); void XmdsResetCallback(Widget w) { XmdsResetAllXds(FindShellChild(w)); return; } void XmdsOkCallback(Widget w) { int XmdsApplyCallback(Widget w); if (XmdsApplyCallback(w)) XtDestroyWidget(FindShellChild(w)); } int XmdsApplyCallback(Widget w) { int status; Widget db = FindShellChild(w); if ((status = XmdsXdsAreValid(db))) status = XmdsApplyAllXds(db); return status; } #endif /* _NO_XDS */ void XmdsCancelCallback(Widget w) { XtDestroyWidget(FindShellChild(w)); }
abelidze/planer-server
app/src/main/java/com/skillmasters/server/http/response/ObjectResponse.java
<filename>app/src/main/java/com/skillmasters/server/http/response/ObjectResponse.java package com.skillmasters.server.http.response; import java.util.List; public class ObjectResponse extends Response<Object, ObjectResponse> { public ObjectResponse() { super(ObjectResponse.class); } }
dram/metasfresh
backend/de.metas.adempiere.adempiere/base/src/test/java/de/metas/process/ADProcessServiceTest.java
<reponame>dram/metasfresh /* * #%L * de.metas.adempiere.adempiere.base * %% * Copyright (C) 2021 metas GmbH * %% * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as * published by the Free Software Foundation, either version 2 of the * License, or (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public * License along with this program. If not, see * <http://www.gnu.org/licenses/gpl-2.0.html>. * #L% */ package de.metas.process; import com.google.common.collect.ImmutableList; import de.metas.document.references.zoom_into.CustomizedWindowInfo; import de.metas.document.references.zoom_into.CustomizedWindowInfoMap; import de.metas.i18n.ImmutableTranslatableString; import lombok.Builder; import lombok.NonNull; import org.adempiere.ad.element.api.AdTabId; import org.adempiere.ad.element.api.AdWindowId; import org.adempiere.ad.table.api.AdTableId; import org.adempiere.model.InterfaceWrapperHelper; import org.adempiere.test.AdempiereTestHelper; import org.adempiere.test.AdempiereTestWatcher; import org.assertj.core.api.Assertions; import org.compiere.model.I_AD_Table; import org.compiere.model.I_AD_Table_Process; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; import org.junit.jupiter.api.extension.ExtendWith; import javax.annotation.Nullable; @ExtendWith(AdempiereTestWatcher.class) class ADProcessServiceTest { private MockedCustomizedWindowInfoMapRepository customizedWindowInfoMapRepository; private ADProcessService adProcessService; private AdTableId adTableId; @BeforeEach void beforeEach() { AdempiereTestHelper.get().init(); this.customizedWindowInfoMapRepository = new MockedCustomizedWindowInfoMapRepository(); adProcessService = new ADProcessService(customizedWindowInfoMapRepository); adTableId = createTable("Test"); } @SuppressWarnings("SameParameterValue") private AdTableId createTable(final String tableName) { final I_AD_Table adTable = InterfaceWrapperHelper.newInstance(I_AD_Table.class); adTable.setTableName(tableName); InterfaceWrapperHelper.saveRecord(adTable); return AdTableId.ofRepoId(adTable.getAD_Table_ID()); } @Builder(builderMethodName = "relatedProcess", builderClassName = "$RelatedProcessBuilder") private void createRelatedProcess( @NonNull final AdProcessId processId, @Nullable final AdWindowId adWindowId, @Nullable final AdTabId adTabId) { final I_AD_Table_Process record = InterfaceWrapperHelper.newInstance(I_AD_Table_Process.class); record.setAD_Table_ID(adTableId.getRepoId()); record.setAD_Process_ID(processId.getRepoId()); record.setAD_Window_ID(AdWindowId.toRepoId(adWindowId)); record.setAD_Tab_ID(AdTabId.toRepoId(adTabId)); InterfaceWrapperHelper.saveRecord(record); } @Nested class getRelatedProcessDescriptors { @Test void relatedProcessAssignedOnTableLevel() { customizedWindowInfoMapRepository.set(CustomizedWindowInfoMap.empty()); relatedProcess().processId(AdProcessId.ofRepoId(1)).build(); Assertions.assertThat( adProcessService.getRelatedProcessDescriptors(adTableId, AdWindowId.ofRepoId(1), AdTabId.ofRepoId(11))) .hasSize(1) .element(0) .usingRecursiveComparison() .isEqualTo(RelatedProcessDescriptor.builder() .tableId(adTableId) .processId(AdProcessId.ofRepoId(1)) .windowId(null) .tabId(null) .displayPlace(RelatedProcessDescriptor.DisplayPlace.SingleDocumentActionsMenu) .build()); } @Test void relatedProcessAssignedOnWindowLevel() { customizedWindowInfoMapRepository.set(CustomizedWindowInfoMap.empty()); relatedProcess().processId(AdProcessId.ofRepoId(1)).adWindowId(AdWindowId.ofRepoId(1)).build(); Assertions.assertThat( adProcessService.getRelatedProcessDescriptors(adTableId, AdWindowId.ofRepoId(1), AdTabId.ofRepoId(11))) .hasSize(1) .element(0) .usingRecursiveComparison() .isEqualTo(RelatedProcessDescriptor.builder() .tableId(adTableId) .processId(AdProcessId.ofRepoId(1)) .windowId(AdWindowId.ofRepoId(1)) .tabId(null) .displayPlace(RelatedProcessDescriptor.DisplayPlace.SingleDocumentActionsMenu) .build()); } @Test void relatedProcessAssignedOnTabLevel() { customizedWindowInfoMapRepository.set(CustomizedWindowInfoMap.empty()); relatedProcess().processId(AdProcessId.ofRepoId(1)).adWindowId(AdWindowId.ofRepoId(1)).adTabId(AdTabId.ofRepoId(11)).build(); Assertions.assertThat( adProcessService.getRelatedProcessDescriptors(adTableId, AdWindowId.ofRepoId(1), AdTabId.ofRepoId(11))) .hasSize(1) .element(0) .usingRecursiveComparison() .isEqualTo(RelatedProcessDescriptor.builder() .tableId(adTableId) .processId(AdProcessId.ofRepoId(1)) .windowId(AdWindowId.ofRepoId(1)) .tabId(AdTabId.ofRepoId(11)) .displayPlace(RelatedProcessDescriptor.DisplayPlace.SingleDocumentActionsMenu) .build()); } @Test void inheritForBaseWindow() { customizedWindowInfoMapRepository.set(CustomizedWindowInfoMap.ofList( ImmutableList.of( CustomizedWindowInfo.builder() .customizationWindowCaption(ImmutableTranslatableString.builder().defaultValue("test").build()) .baseWindowId(AdWindowId.ofRepoId(1)) .customizationWindowId(AdWindowId.ofRepoId(2)) .build(), CustomizedWindowInfo.builder() .customizationWindowCaption(ImmutableTranslatableString.builder().defaultValue("test").build()) .baseWindowId(AdWindowId.ofRepoId(2)) .customizationWindowId(AdWindowId.ofRepoId(3)) .build() ))); System.out.println("CustomizedWindowInfoMap: " + customizedWindowInfoMapRepository.get()); relatedProcess().processId(AdProcessId.ofRepoId(1)).adWindowId(AdWindowId.ofRepoId(1)).build(); Assertions.assertThat( adProcessService.getRelatedProcessDescriptors(adTableId, AdWindowId.ofRepoId(2), AdTabId.ofRepoId(22))) .hasSize(1) .element(0) .usingRecursiveComparison() .isEqualTo(RelatedProcessDescriptor.builder() .tableId(adTableId) .processId(AdProcessId.ofRepoId(1)) .windowId(AdWindowId.ofRepoId(2)) .tabId(null) .displayPlace(RelatedProcessDescriptor.DisplayPlace.SingleDocumentActionsMenu) .build()); } } }
SchoolPower/SchoolPower-Backend
localization/test_localize.py
<gh_stars>1-10 import unittest from localize import get_equivalent_locale, use_localize class LocalizationTest(unittest.TestCase): def test_equivalent_locale(self): cases = [ ["zh", "zh-Hans"], ["zh_CN", "zh-Hans"], ["zh_TW", "zh-Hant"], ["zh_HK", "zh-Hans"], ["zh_MO", "zh-Hans"], ["zh-CN", "zh-Hans"], ["zh-TW", "zh-Hant"], ["zh-HK", "zh-Hans"], ["zh-MO", "zh-Hans"], ["zh-Hans", "zh-Hans"], ["zh_Hans", "zh-Hans"], ["zh-Hant", "zh-Hant"], ["zh_Hant", "zh-Hant"], ["zh-Hans-CN", "zh-Hans"], ["zh-Hans-HK", "zh-Hans"], ["zh-Hans-TW", "zh-Hans"], ["zh-Hant-TW", "zh-Hant"], ["zh-Hans_CN", "zh-Hans"], ["zh-Hans_HK", "zh-Hans"], ["zh-Hans_TW", "zh-Hans"], ["zh-Hant_TW", "zh-Hant"], ["zh-Hant_CN", "zh-Hant"], ] for case in cases: self.assertEqual(get_equivalent_locale(case[0]), case[1]) def test_localize(self): key = "Error.ConnectionTimedOut.Title" cases = [ [None, "Connection Timed Out"], ["", "Connection Timed Out"], ["fr", "Connection Timed Out"], ["en", "Connection Timed Out"], ["en_US", "Connection Timed Out"], ["en_UK", "Connection Timed Out"], ["zh-Hans", "连接超时"], ["zh-Hant", "連接超時"], ["zh_CN", "连接超时"], ["zh_TW", "連接超時"], ["ja", "接続がタイムアウトしました"], ["ja_JP", "接続がタイムアウトしました"], ] for case in cases: self.assertEqual(use_localize(case[0])(key), case[1]) if __name__ == '__main__': unittest.main()
kjh9267/BOJ_Python
DFS/2146.py
# https://www.acmicpc.net/problem/2146 import sys sys.setrecursionlimit(999999999) def dfs(x, y, cnt): if visited[y][x]: return visited[y][x] = True candi[cnt].append((x, y)) new_grid[y][x] = cnt for i, j in zip(dx, dy): xx = i + x yy = j + y if not (0 <= xx < N and 0 <= yy < N): continue if grid[yy][xx] == '0': continue dfs(xx,yy,cnt) def bfs(cnt): queue = __import__('collections').deque() visited = [[False for _ in range(N)] for __ in range(N)] for i in candi[cnt]: queue.append(i) visited[i[1]][i[0]] = True res = 0 while queue: size = len(queue) res += 1 for _ in range(size): cur = queue.popleft() for i, j in zip(dx, dy): x = cur[0] + i y = cur[1] + j if not (0 <= x < N and 0 <= y < N): continue if visited[y][x]: continue if new_grid[y][x] != cnt and new_grid[y][x] != 0: return res - 1 queue.append((x, y)) visited[y][x] = True if __name__ == '__main__': input = __import__('sys').stdin.readline N = int(input()) grid = [list(input().split()) for _ in range(N)] new_grid = [[0 for _ in range(N)] for __ in range(N)] candi = dict() dx = (1, 0, -1, 0) dy = (0, 1, 0, -1) res = float('inf') visited = [[False for _ in range(N)] for __ in range(N)] cnt = 0 for row in range(N): for col in range(N): if visited[row][col] or grid[row][col] == '0': continue cnt += 1 candi[cnt] = list() dfs(col, row, cnt) for i in candi.keys(): res = min(res, bfs(i)) print(res)
nrgxtra/advanced
Multidimentional Lists Exerscise/07. Bombs.py
<reponame>nrgxtra/advanced def check(row_idx, col_idx): existing = [] if row_idx - 1 >= 0 and col_idx - 1 >= 0: existing.append([row_idx - 1, col_idx - 1]) if row_idx - 1 >= 0: existing.append([row_idx - 1, col_idx]) if row_idx - 1 >= 0 and col_idx + 1 < len(matrix): existing.append([row_idx - 1, col_idx + 1]) if row_idx >= 0 and col_idx - 1 >= 0: existing.append([row_idx, col_idx - 1]) if row_idx >= 0 and col_idx + 1 < len(matrix): existing.append([row_idx, col_idx + 1]) if row_idx + 1 < len(matrix) and col_idx - 1 >= 0: existing.append([row_idx + 1, col_idx - 1]) if row_idx + 1 < len(matrix): existing.append([row_idx + 1, col_idx]) if row_idx + 1 < len(matrix) and col_idx + 1 < len(matrix): existing.append([row_idx + 1, col_idx + 1]) return existing rows_count = int(input()) matrix = [] for _ in range(rows_count): matrix.append([int(x) for x in input().split()]) explosion = [[int(x) for x in j.split(',')] for j in input().split()] dead_cells = [] for bomb in explosion: row_idx = bomb[0] col_idx = bomb[1] current_bomb = matrix[row_idx][col_idx] current_strength = matrix[row_idx][col_idx] if current_bomb > 0: matrix[row_idx][col_idx] = 0 existing_cells = check(row_idx, col_idx) for row in existing_cells: r_ind, c_ind = row current_cell = matrix[r_ind][c_ind] if current_cell > 0: matrix[r_ind][c_ind] -= current_strength alive = 0 alive_cells = [] for row in matrix: for el in row: if el > 0: alive += 1 alive_cells.append(el) sum_alive_cells = sum(alive_cells) print(f'Alive cells: {alive}') print(f'Sum: {sum_alive_cells}') new_matrix = [[str(x) for x in j] for j in matrix] [print(' '.join(row)) for row in new_matrix]
neume/docuko
app/models/data_model.rb
<reponame>neume/docuko class DataModel < ApplicationRecord belongs_to :created_by, class_name: 'User' belongs_to :office has_many :properties, class_name: 'ModelProperty', dependent: :destroy has_many :instances, dependent: :destroy has_many :documents, through: :instances has_many :templates, dependent: :destroy has_many :instance_properties, through: :instances, source: :properties accepts_nested_attributes_for :properties validate :no_duplicate_codes, on: :create validates :name, presence: true def no_duplicate_codes if properties.group_by(&:code).values.detect { |arr| arr.size > 1 } errors.add(:base, 'Field Code should be unique') end end end
drunkwater/leetcode
medium/python3/c0167_334_increasing-triplet-subsequence/00_leetcode_0167.py
<filename>medium/python3/c0167_334_increasing-triplet-subsequence/00_leetcode_0167.py # DRUNKWATER TEMPLATE(add description and prototypes) # Question Title and Description on leetcode.com # Function Declaration and Function Prototypes on leetcode.com #334. Increasing Triplet Subsequence #Given an unsorted array return whether an increasing subsequence of length 3 exists or not in the array. #Formally the function should: #Return true if there exists i, j, k #such that arr[i] < arr[j] < arr[k] given 0 ≤ i < j < k ≤ n-1 else return false. #Your algorithm should run in O(n) time complexity and O(1) space complexity. #Examples: #Given [1, 2, 3, 4, 5], #return true. #Given [5, 4, 3, 2, 1], #return false. #Credits: #Special thanks to @DjangoUnchained for adding this problem and creating all test cases. #class Solution: # def increasingTriplet(self, nums): # """ # :type nums: List[int] # :rtype: bool # """ # Time Is Money
seidu626/vumi
vumi/transports/telnet/__init__.py
"""Telnet server transport.""" from vumi.transports.telnet.telnet import (TelnetServerTransport, AddressedTelnetServerTransport) __all__ = ['TelnetServerTransport', 'AddressedTelnetServerTransport']
SCECcode/cvmhlabn
test/test_cvmhlabn_exec.h
<gh_stars>0 #ifndef TEST_CVMHLABN_EXEC_H #define TEST_CVMHLABN_EXEC_H int suite_cvmhlabn_exec(const char *xmldir); #endif
tamilselvansellamuthu/Insights
PlatformCommons/src/main/java/com/cognizant/devops/platformcommons/config/CorrelationConfig.java
/******************************************************************************* * Copyright 2017 Cognizant Technology Solutions * * 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.cognizant.devops.platformcommons.config; import java.io.Serializable; public class CorrelationConfig implements Serializable { private static final long serialVersionUID = -9222292318762382698L; private int correlationWindow = 48; private int correlationFrequency = 4; private int batchSize = 2000; public int getCorrelationWindow() { return correlationWindow; } public void setCorrelationWindow(int correlationWindow) { this.correlationWindow = correlationWindow; } public int getCorrelationFrequency() { return correlationFrequency; } public void setCorrelationFrequency(int correlationFrequency) { this.correlationFrequency = correlationFrequency; } public int getBatchSize() { return batchSize; } public void setBatchSize(int batchSize) { this.batchSize = batchSize; } }
josehu07/SplitFS
kernel/linux-5.4/sound/soc/intel/common/soc-acpi-intel-ehl-match.c
// SPDX-License-Identifier: GPL-2.0 /* * soc-apci-intel-ehl-match.c - tables and support for EHL ACPI enumeration. * * Copyright (c) 2019, Intel Corporation. * */ #include <sound/soc-acpi.h> #include <sound/soc-acpi-intel-match.h> struct snd_soc_acpi_mach snd_soc_acpi_intel_ehl_machines[] = { {}, }; EXPORT_SYMBOL_GPL(snd_soc_acpi_intel_ehl_machines); MODULE_LICENSE("GPL v2"); MODULE_DESCRIPTION("Intel Common ACPI Match module");
arielerv/hero-journey-be
src/openapi/index.js
const pkg = root_path('package.json'); const components = require('./components'); const publicApi = require('./publicApi'); const api = require('./api'); module.exports = { openapi: '3.0.2', info: {title: pkg.description, version: pkg.version}, servers: [{url: 'http://localhost:3001'}], paths: { '/ping': { get: { description: 'Endpoint ping', operationId: 'ping', security: [], responses: { 200: { description: 'Success', content: { 'application/json': { schema: { type: 'object', properties: {version: {type: 'string'}} } } } }, default: { description: 'Error', content: {'application/json': {schema: {$ref: '#/components/schemas/Error'}}} } } } }, '/ready': { get: { operationId: 'getStatus', security: [], responses: { 200: { description: 'Success', content: { 'application/json': { schema: { type: 'object', properties: { name: {type: 'string'}, status: {type: 'string'}, deps: { type: 'array', items: { type: 'object', properties: {} } } } } } } }, default: { description: 'Error', content: {'application/json': {schema: {$ref: '#/components/schemas/Error'}}} } } } }, '/health': { get: { operationId: 'getHealth', security: [], responses: { 200: { description: 'Success', content: { 'application/json': { schema: { type: 'object', properties: { name: {type: 'string'}, status: {type: 'string'} } } } } }, default: { description: 'Error', content: {'application/json': {schema: {$ref: '#/components/schemas/Error'}}} } } } }, ...publicApi, ...api }, components };
kozlov-a-d/html-template
assets/ds-kit/basis/resize.component.js
<gh_stars>0 /** * Компонент для отслеживания размеров при ресайзе и добавления функций по ресайзу * @method {{setFreezeTime, getScreenWidth, addMediaQuery, resizeForce, debug}} */ var resizeComponent = (function(){ var self = { screenWidth: window.innerWidth, queries: [], freezeTime: 100 }; /** * Заготовка для новых запросов, хранит настройки по умочанию, объединяется с новыми запросами * @type {{min: number, max: number, isEnter: boolean, onEnter: null, onEach: null}} */ var defaultQuery = { min: 0, max: 10000, isEnter: false, onEnter: null, onEach: null, onExit: null }; // PRIVATE ========================================================================================================= /** * установка минимального интервала между ресайзами * @param {*} time */ var setFreezeTime = function (time) { if ( typeof time !== 'number' && typeof time !== 'undefined'){ console.warn('resizeComponent: freezeTime type must be a number, now a ' + typeof time); } else { self.freezeTime = time; } }; /** * проверяем текущий размер экрана */ var checkScreen = function () { self.screenWidth = window.innerWidth; }; /** * выполняем медиа-запрос * @param {*} query */ var triggerQuery = function(query){ // проверяем разрешение if( query.min <= self.screenWidth && self.screenWidth <= query.max ){ // onEnter if( typeof query.onEnter === 'function' && !query.isEnter){ query.onEnter(); query.isEnter = true; } // onEach if( typeof query.onEach === 'function'){ query.onEach(); } } else { if(query.isEnter){ query.onExit(); } query.isEnter = false; } }; /** * проверяем корректность медиа-запроса * @param {*} query */ var validateQuery = function (query) { var validQuery = query; if ( typeof validQuery.min !== 'number' && typeof validQuery.min !== 'undefined'){ console.warn('resizeComponent: query.min type must be a number, now a ' + typeof validQuery.min); validQuery.min = defaultQuery.min; } if ( typeof validQuery.max !== 'number' && typeof validQuery.max !== 'undefined'){ console.warn('resizeComponent: query.max type must be a number, now a ' + typeof validQuery.min); validQuery.max = defaultQuery.max; } if ( typeof validQuery.onEnter !== 'function' && typeof validQuery.onEnter !== 'undefined' ){ console.warn('resizeComponent: query.onEnter type must be a function, now a ' + typeof validQuery.onEnter); validQuery.onEnter = null; } if ( typeof validQuery.onEach !== 'function' && typeof validQuery.onEach !== 'undefined' ){ console.warn('resizeComponent: query.onEach type must be a function, now a ' + typeof validQuery.onEach); validQuery.onEach = null; } if ( typeof validQuery.onExit !== 'function' && typeof validQuery.onExit !== 'undefined' ){ console.warn('resizeComponent: query.onEach type must be a function, now a ' + typeof validQuery.onExit); validQuery.onExit = null; } return validQuery; }; /** * добавляем новый медиа-запрос * @param {*} query */ var addQuery = function(query){ var newQuery = validateQuery(query); self.queries.push(newQuery); triggerQuery(newQuery); }; /** * перебираем все медиа-запросы при ресайзе, используется декоратор throttle */ var onResize = throttle(function(){ self.queries.forEach(function (item) { triggerQuery(item); }) }, self.freezeTime ); // INIT ============================================================================================================ // получаем текущий размер checkScreen(); // навешиваем обработчик window.addEventListener('resize', function() { checkScreen(); onResize(); }); // PUBLIC ========================================================================================================== return Object.freeze({ /** * Установка минимального интервала между ресайзами * @param {number} time */ setFreezeTime: function(time){ setFreezeTime(time); }, /** * Возвращает текущий размер экрана * @returns {number} */ getScreenWidth: function(){ checkScreen(); return screenWidth; }, /** * Добавляет новый медиа-запрос * @param {{min: number, max: number, onEnter: function, onEach: function, onExit: function}} query */ addMediaQuery: function(query){ addQuery(query); }, /** * Принудительно вызывает срабатывание актуальных колбэков */ resizeForce: function () { onResize(); }, /** * Выводит список текущих медаи-запросов */ debug: function () { console.log(self.queries); } }) }());
cflowe/ACE
TAO/tests/Bug_2683_Regression/client.cpp
<filename>TAO/tests/Bug_2683_Regression/client.cpp // $Id: client.cpp 91825 2010-09-17 09:10:22Z johnnyw $ #include "TestC.h" #include "ace/Get_Opt.h" #include "ace/Task.h" #include "ace/OS_NS_unistd.h" class Pinger : public ACE_Task_Base { private: const char * ior_; CORBA::ORB_var orb_; bool do_shutdown_; bool stop_; public: Pinger (CORBA::ORB_var &orb, const char *ior) : ior_ (ior), orb_(orb), do_shutdown_ (false), stop_ (false) { } int svc (void) { bool keep_going = true; while (keep_going && !this->stop_) { try { CORBA::Object_var tmp = this->orb_->string_to_object(this->ior_); Test::IORTable_Shutdown_Race_var target = Test::IORTable_Shutdown_Race::_narrow(tmp.in ()); if (CORBA::is_nil (target.in ())) ACE_ERROR_RETURN ((LM_DEBUG, "(%P|%t) Nil target reference <%s>\n", this->ior_), 1); target->ping(); if (this->do_shutdown_) { ACE_DEBUG ((LM_DEBUG,"(%P|%t) Calling shutdown\n")); this->do_shutdown_ = false; target->shutdown (); } } catch (CORBA::Exception &ex) { ACE_DEBUG ((LM_DEBUG, "(%P|%t) caught an exception - %C\n",ex._name())); keep_going = false; } } return 0; } void killit() { do_shutdown_ = true; } void stop () { stop_ = true; } }; int port = 0; ACE_TCHAR const * target_host = ACE_TEXT("localhost"); int parse_args (int argc, ACE_TCHAR *argv[]) { ACE_Get_Opt get_opts (argc, argv, ACE_TEXT("p:h:")); int c; while ((c = get_opts ()) != -1) switch (c) { case 'p': port = ACE_OS::atoi (get_opts.opt_arg ()); break; case 'h': target_host = get_opts.opt_arg (); break; case '?': default: ACE_ERROR_RETURN ((LM_ERROR, "usage: %s " "-p <server_port> " "\n", argv [0]), -1); } // Indicates successful parsing of the command line return 0; } int ACE_TMAIN(int argc, ACE_TCHAR *argv[]) { try { CORBA::ORB_var orb = CORBA::ORB_init (argc, argv); if (parse_args (argc, argv) != 0) return 1; char ior[100]; ACE_OS::sprintf (ior, "corbaloc::%s:%d/Racer", ACE_TEXT_ALWAYS_CHAR (target_host), port); Pinger pinger(orb, ior); ACE_OS::sleep (1); ACE_DEBUG ((LM_DEBUG,"(%P|%t) client - starting client threads\n")); pinger.activate (THR_NEW_LWP | THR_JOINABLE, 5); ACE_OS::sleep (1); ACE_DEBUG ((LM_DEBUG,"(%P|%t) client - All running, time to shutdown server\n")); pinger.killit(); ACE_OS::sleep (2); ACE_DEBUG ((LM_DEBUG,"(%P|%t) client - Stopping client threads\n")); pinger.stop (); pinger.wait(); ACE_DEBUG ((LM_DEBUG,"(%P|%t) client done\n")); } catch (CORBA::Exception &ex) { ACE_DEBUG ((LM_DEBUG,"Main caught %s\n",ex._name())); return 1; } return 0; }
fabri1983/signaling_server
src/main/java/org/fabri1983/signaling/configuration/HazelcastSignalingConfiguration.java
package org.fabri1983.signaling.configuration; import com.hazelcast.config.Config; import com.hazelcast.config.ReliableTopicConfig; import com.hazelcast.config.SerializerConfig; import com.hazelcast.core.Hazelcast; import com.hazelcast.core.HazelcastInstance; import com.hazelcast.topic.ITopic; import org.fabri1983.signaling.core.distributed.NextRTCDistributedEventBus; import org.fabri1983.signaling.core.distributed.serialization.NextRTCConversationWrapperSerializerV1; import org.fabri1983.signaling.core.distributed.serialization.NextRTCEventWrapperSerializerV1; import org.fabri1983.signaling.core.distributed.serialization.NextRTCMemberWrapperSerializerV1; import org.fabri1983.signaling.core.distributed.wrapper.NextRTCConversationWrapper; import org.fabri1983.signaling.core.distributed.wrapper.NextRTCEventWrapper; import org.fabri1983.signaling.core.distributed.wrapper.NextRTCMemberWrapper; import org.fabri1983.signaling.core.population.ConversationPopulation; import org.nextrtc.signalingserver.Names; import org.nextrtc.signalingserver.api.NextRTCEventBus; import org.nextrtc.signalingserver.repository.ConversationRepository; import org.nextrtc.signalingserver.repository.MemberRepository; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.context.annotation.Primary; import org.springframework.context.annotation.Profile; @Configuration @Profile( {"eventbus-hazelcast"} ) public class HazelcastSignalingConfiguration { private final String HZ_INSTANCE_NAME = "signaling-hzc"; private final String TOPIC_CONFIG_NAME = "signaling-hzc-topic"; @Bean public ReliableTopicConfig hazelCastTopicConfig() { // In the reliable topic, global order is always maintained ReliableTopicConfig topicConfig = new ReliableTopicConfig(TOPIC_CONFIG_NAME); return topicConfig; } @Bean(destroyMethod = "shutdown") public HazelcastInstance hazelCastInstance(ReliableTopicConfig hzcTopicConfig) { Config config = new Config(HZ_INSTANCE_NAME); config.addReliableTopicConfig(hzcTopicConfig); config.getNetworkConfig().getJoin().getMulticastConfig().setEnabled(true); registerSerializers(config); HazelcastInstance hzcInstance = Hazelcast.getOrCreateHazelcastInstance(config); return hzcInstance; } @Bean public ITopic<NextRTCEventWrapper> hazelCastTopic(HazelcastInstance hzcInstance) { return hzcInstance.getReliableTopic(TOPIC_CONFIG_NAME); } /** * Override bean definition from @{link org.nextrtc.signalingserver.api.NextRTCEventBus} so we can customize the event bus. * @return */ @Bean(name = Names.EVENT_BUS) @Primary public NextRTCEventBus eventBus(HazelcastInstance hazelcastInstance, ITopic<NextRTCEventWrapper> hzcTopic, ConversationPopulation population, ConversationRepository conversationRepository, MemberRepository members) { return new NextRTCDistributedEventBus(hazelcastInstance, hzcTopic, population, conversationRepository, members); } private void registerSerializers(Config config) { SerializerConfig eventSc = new SerializerConfig() .setImplementation(new NextRTCEventWrapperSerializerV1()) .setTypeClass(NextRTCEventWrapper.class); SerializerConfig memberSc = new SerializerConfig() .setImplementation(new NextRTCMemberWrapperSerializerV1()) .setTypeClass(NextRTCMemberWrapper.class); SerializerConfig conversationSc = new SerializerConfig() .setImplementation(new NextRTCConversationWrapperSerializerV1()) .setTypeClass(NextRTCConversationWrapper.class); config.getSerializationConfig().addSerializerConfig(eventSc); config.getSerializationConfig().addSerializerConfig(memberSc); config.getSerializationConfig().addSerializerConfig(conversationSc); } /** * This class serves the solely purpose of resolve circular bean reference creation, which happens * when two or more beans depend on each other. */ // @Configuration // public static class CircularBeanRefResolver { // // // Inject beans here // // @PostConstruct // public void circularBeanRefResolver() { // // set missing dependencies // } // } }
SteveSmith16384/ChronoCup
core/src/com/scs/splitscreenfps/game/systems/ql/recorddata/BulletFiredRecordData.java
package com.scs.splitscreenfps.game.systems.ql.recorddata; import com.badlogic.gdx.math.Vector3; public class BulletFiredRecordData extends AbstractRecordData { public int playerIdx; public Vector3 start; public Vector3 offset; public BulletFiredRecordData(int phase, float time, int _playerIdx, Vector3 _start, Vector3 _offset) { super(CMD_BULLET_FIRED, phase, time); playerIdx = _playerIdx; start = _start; offset = _offset; } }
sonylomo/Rocket.Chat.ReactNative
app/actions/sortPreferences.js
import * as types from './actionsTypes'; export function setAllPreferences(preferences) { return { type: types.SORT_PREFERENCES.SET_ALL, preferences }; } export function setPreference(preference) { return { type: types.SORT_PREFERENCES.SET, preference }; }
njhoffman/better-musician
src/components/DevTools/Launcher/Launcher.js
<filename>src/components/DevTools/Launcher/Launcher.js import React, { Component } from 'react'; import PropTypes from 'prop-types'; import shouldPureComponentUpdate from 'react-pure-render/function'; import * as themes from 'redux-devtools-themes'; import Button from 'devui/lib/Button'; import SegmentedControl from 'devui/lib/SegmentedControl'; import { withStyles } from '@material-ui/core'; import NewWindow from 'components/NewWindow'; import DevToolsChart from 'components/DevTools/Chart'; import { reducer as chartToolbarReducer } from 'components/DevTools/Chart/Toolbar'; import { init as initLog } from 'shared/logger'; const { info, warn } = initLog('custom-launcher'); const styles = (theme) => ({ container: { fontFamily: 'monaco, Consolas, Lucida Console, monospace', fontSize: '0.8em', position: 'relative', overflowY: 'hidden', height: '100%', direction: 'ltr', color: 'white' }, elements: { display: 'flex', justifyContent: 'space-evenly', overflowX: 'hidden', overflowY: 'auto', verticalAlign: 'middle', top: 30, height: '100%', alignItems: 'center' }, buttonActive: { backgroundColor: '#838184', color: '#0e0e0e' } }); class Launcher extends Component { static update = chartToolbarReducer static defaultProps = { devConfig: { showChart: false } }; static propTypes = { dispatch: PropTypes.func.isRequired, classes: PropTypes.instanceOf(Object).isRequired, devConfig: PropTypes.instanceOf(Object), computedStates: PropTypes.arrayOf(PropTypes.object).isRequired, actionsById: PropTypes.instanceOf(Object).isRequired, stagedActionIds: PropTypes.arrayOf(PropTypes.number).isRequired, skippedActionIds: PropTypes.arrayOf(PropTypes.number).isRequired, monitorState: PropTypes.shape({ initialScrollTop: PropTypes.number, consecutiveToggleStartId: PropTypes.number }).isRequired, theme: PropTypes.oneOfType([ PropTypes.object, PropTypes.string ]) }; static defaultProps = { theme: 'twilight' }; shouldComponentUpdate = shouldPureComponentUpdate; constructor(props) { super(props); const { devConfig } = props; this.getRef = this.getRef.bind(this); this.toggleChart = this.toggleChart.bind(this); this.popupUnload = this.popupUnload.bind(this); this.state = { showChart : devConfig && devConfig.showChart }; } getTheme() { const { theme } = this.props; if (typeof theme !== 'string') { return theme; } if (typeof themes[theme] !== 'undefined') { return themes[theme]; } warn(`DevTools theme ${theme} not found, defaulting to nicinabox`); return themes.nicinabox; } getRef(node) { this.node = node; } toggleChart() { this.setState(state => ({ ...state, showChart: !state.showChart })); } popupUnload() { info('popup unloading...'); this.setState(state => ({ ...state, showChart: false })); } render() { const theme = this.getTheme(); const { classes: { container, elements } } = this.props; const { showChart } = this.state; const winOptions = { menubar: 'no', location: 'no', resizable: 'yes', scrollbars: 'no', statusbar: 'no', toolbar: 'no', width: 1000, height: 1200, left: 3500, top: 50, margin: 0 }; return ( <div className={container} style={{ backgroundColor: theme.base01 }}> <div className={elements} style={{ backgroundColor: theme.base01 }} ref={this.getRef}> <Button theme={theme}>Actions</Button> <Button theme={theme}>Fixtures</Button> <SegmentedControl theme={theme} values={['Chart']} onClick={this.toggleChart} selected={showChart ? 'Chart' : ''} /> </div> {showChart && ( <NewWindow title='DevTools Chart' features={winOptions} onUnload={this.popupUnload}> <DevToolsChart {...this.props} /> </NewWindow> )} </div> ); } } export default withStyles(styles)(Launcher);
hakujitsu/tp
src/test/java/seedu/address/model/sale/UniqueSaleListTest.java
<reponame>hakujitsu/tp<filename>src/test/java/seedu/address/model/sale/UniqueSaleListTest.java package seedu.address.model.sale; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertTrue; import static seedu.address.testutil.Assert.assertThrows; import static seedu.address.testutil.sale.TypicalSales.APPLE; import static seedu.address.testutil.sale.TypicalSales.BALL; import java.math.BigDecimal; import java.time.Month; import java.time.Year; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.List; import org.junit.jupiter.api.Test; import seedu.address.model.sale.exceptions.DuplicateSaleException; import seedu.address.model.sale.exceptions.SaleNotFoundException; import seedu.address.testutil.sale.SaleBuilder; public class UniqueSaleListTest { private final UniqueSaleList uniqueSaleList = new UniqueSaleList(); @Test public void contains_nullSale_throwsNullPointerException() { assertThrows(NullPointerException.class, () -> uniqueSaleList.contains(null)); } @Test public void contains_saleNotInList_returnsFalse() { assertFalse(uniqueSaleList.contains(APPLE)); } @Test public void contains_saleInList_returnsTrue() { uniqueSaleList.add(APPLE); assertTrue(uniqueSaleList.contains(APPLE)); } @Test public void add_nullSale_throwsNullPointerException() { assertThrows(NullPointerException.class, () -> uniqueSaleList.add(null)); } @Test public void add_duplicateSale_throwsDuplicateSaleException() { Month month = APPLE.getMonth(); Year year = APPLE.getYear(); List<Sale> oldMonthlySaleList = new ArrayList<>(uniqueSaleList.getMonthlySaleList(month, year)); uniqueSaleList.add(APPLE); oldMonthlySaleList.add(APPLE); assertEquals(oldMonthlySaleList, uniqueSaleList.getMonthlySaleList(month, year)); assertThrows(DuplicateSaleException.class, () -> uniqueSaleList.add(APPLE)); } @Test public void setSale_nullTargetSale_throwsNullPointerException() { assertThrows(NullPointerException.class, () -> uniqueSaleList.setSale(null, APPLE)); } @Test public void setSale_nullEditedSale_throwsNullPointerException() { assertThrows(NullPointerException.class, () -> uniqueSaleList.setSale(APPLE, null)); } @Test public void setSale_targetSaleNotInList_throwsSaleNotFoundException() { assertThrows(SaleNotFoundException.class, () -> uniqueSaleList.setSale(APPLE, APPLE)); } @Test public void setSale_editedSaleIsSameSale_success() { Month month = APPLE.getMonth(); Year year = APPLE.getYear(); uniqueSaleList.add(APPLE); List<Sale> oldMonthlySaleList = new ArrayList<>(uniqueSaleList.getMonthlySaleList(month, year)); uniqueSaleList.setSale(APPLE, APPLE); UniqueSaleList expectedUniqueSaleList = new UniqueSaleList(); expectedUniqueSaleList.add(APPLE); assertEquals(expectedUniqueSaleList, uniqueSaleList); assertEquals(oldMonthlySaleList, uniqueSaleList.getMonthlySaleList(month, year)); } @Test public void setSale_editedSaleHasSameIdentity_success() { uniqueSaleList.add(APPLE); Sale editedApple = new SaleBuilder(APPLE).withUnitPrice(new BigDecimal("5.60")).withQuantity(20).build(); uniqueSaleList.setSale(APPLE, editedApple); UniqueSaleList expectedUniqueSaleList = new UniqueSaleList(); expectedUniqueSaleList.add(editedApple); assertEquals(expectedUniqueSaleList, uniqueSaleList); } @Test public void setSale_editedSaleHasDifferentIdentity_success() { uniqueSaleList.add(APPLE); uniqueSaleList.setSale(APPLE, BALL); UniqueSaleList expectedUniqueSaleList = new UniqueSaleList(); expectedUniqueSaleList.add(BALL); assertEquals(expectedUniqueSaleList, uniqueSaleList); } @Test public void setSale_editedSaleHasNonUniqueIdentity_throwsDuplicatePersonException() { uniqueSaleList.add(APPLE); uniqueSaleList.add(BALL); assertThrows(DuplicateSaleException.class, () -> uniqueSaleList.setSale(APPLE, BALL)); } @Test public void remove_nullSale_throwsNullPointerException() { assertThrows(NullPointerException.class, () -> uniqueSaleList.remove(null)); } @Test public void remove_saleDoesNotExist_throwsSaleNotFoundException() { assertThrows(SaleNotFoundException.class, () -> uniqueSaleList.remove(APPLE)); } @Test public void remove_existingSale_removesSale() { Month month = APPLE.getMonth(); Year year = APPLE.getYear(); uniqueSaleList.add(APPLE); uniqueSaleList.remove(APPLE); UniqueSaleList expectedUniqueSaleList = new UniqueSaleList(); assertEquals(expectedUniqueSaleList, uniqueSaleList); assertEquals(Collections.emptyList(), uniqueSaleList.getMonthlySaleList(month, year)); } @Test public void setSales_nullUniqueSaleList_throwsNullPointerException() { assertThrows(NullPointerException.class, () -> uniqueSaleList.setSales((UniqueSaleList) null)); } @Test public void setSales_uniqueSaleList_replacesOwnListWithProvidedUniqueSaleList() { uniqueSaleList.add(APPLE); UniqueSaleList expectedUniqueSaleList = new UniqueSaleList(); expectedUniqueSaleList.add(BALL); uniqueSaleList.setSales(expectedUniqueSaleList); assertEquals(expectedUniqueSaleList, uniqueSaleList); } @Test public void setSales_nullList_throwsNullPointerException() { assertThrows(NullPointerException.class, () -> uniqueSaleList.setSales((List<Sale>) null)); } @Test public void setSales_list_replacesOwnListWithProvidedList() { uniqueSaleList.add(APPLE); List<Sale> saleList = Collections.singletonList(BALL); uniqueSaleList.setSales(saleList); UniqueSaleList expectedUniqueSaleList = new UniqueSaleList(); expectedUniqueSaleList.add(BALL); assertEquals(expectedUniqueSaleList, uniqueSaleList); } @Test public void setSales_listWithDuplicateSales_throwsDuplicateSaleException() { List<Sale> listWithDuplicateSales = Arrays.asList(APPLE, APPLE); assertThrows(DuplicateSaleException.class, () -> uniqueSaleList.setSales(listWithDuplicateSales)); } @Test public void asUnmodifiableObservableList_modifyList_throwsUnsupportedOperationException() { assertThrows(UnsupportedOperationException.class, () -> uniqueSaleList.asUnmodifiableObservableList().remove(0)); } }
ArrogantWombatics/openbsd-src
lib/libradius/radius_local.h
/* $OpenBSD: radius_local.h,v 1.1 2015/07/20 23:52:29 yasuoka Exp $ */ /*- * Copyright (c) 2009 Internet Initiative Japan 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 THE AUTHOR 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 AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #ifndef RADIUS_LOCAL_H #define RADIUS_LOCAL_H #ifndef countof #define countof(x) (sizeof(x)/sizeof((x)[0])) #endif typedef struct _RADIUS_PACKET_DATA { uint8_t code; uint8_t id; uint16_t length; uint8_t authenticator[16]; char attributes[0]; } RADIUS_PACKET_DATA; #pragma pack(1) typedef struct _RADIUS_ATTRIBUTE { uint8_t type; uint8_t length; char data[0]; uint32_t vendor; uint8_t vtype; uint8_t vlength; char vdata[0]; } RADIUS_ATTRIBUTE; #pragma pack() struct _RADIUS_PACKET { RADIUS_PACKET_DATA *pdata; size_t capacity; const RADIUS_PACKET *request; }; #define RADIUS_PACKET_CAPACITY_INITIAL 64 #define RADIUS_PACKET_CAPACITY_INCREMENT 64 #define ATTRS_BEGIN(pdata) ((RADIUS_ATTRIBUTE*)pdata->attributes) #define ATTRS_END(pdata) \ ((RADIUS_ATTRIBUTE*)(((char*)pdata) + ntohs(pdata->length))) #define ATTRS_NEXT(x) ((RADIUS_ATTRIBUTE*)(((char*)x) + x->length)) /* * must be expression rather than statement * to be used in third expression of for statement. */ #define ATTRS_ADVANCE(x) (x = ATTRS_NEXT(x)) int radius_ensure_add_capacity(RADIUS_PACKET * packet, size_t capacity); #define ROUNDUP(a, b) ((((a) + (b) - 1) / (b)) * (b)) #define MINIMUM(a, b) (((a) < (b))? (a) : (b)) #endif /* RADIUS_LOCAL_H */
leongold/ovirt-engine
backend/manager/modules/dal/src/test/java/org/ovirt/engine/core/dao/gluster/StoageDeviceDaoTest.java
<gh_stars>1-10 package org.ovirt.engine.core.dao.gluster; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; import java.util.List; import org.junit.Test; import org.ovirt.engine.core.common.businessentities.gluster.StorageDevice; import org.ovirt.engine.core.compat.Guid; import org.ovirt.engine.core.dao.BaseDaoTestCase; import org.ovirt.engine.core.dao.FixturesTool; public class StoageDeviceDaoTest extends BaseDaoTestCase { private static final Guid NEW_STORAGE_DEVICE_ID = new Guid("00000000-0000-0000-0000-000000000003"); private static final Guid EXISTING_STORAGE_DEVICE_ID_1 = new Guid("00000000-0000-0000-0000-000000000001"); private static final Guid EXISTING_STORAGE_DEVICE_ID_2 = new Guid("00000000-0000-0000-0000-000000000002"); private static final Guid NON_EXISTING_STORAGE_DEVICE_ID = new Guid("00000000-0000-0000-0000-000000000000"); private StorageDeviceDao dao; private StorageDevice getStorageDevice() { StorageDevice storageDevice = new StorageDevice(); storageDevice.setId(NEW_STORAGE_DEVICE_ID); storageDevice.setCanCreateBrick(true); storageDevice.setDescription("Test Device"); storageDevice.setDevPath("/dev/sdc"); storageDevice.setDevType("SCSI"); storageDevice.setDevUuid("ocIYJv-Ej8x-vDPm-kcGr-sHqy-jjeo-Jt2hTj"); storageDevice.setName("sdc"); storageDevice.setSize(10000L); storageDevice.setVdsId(FixturesTool.GLUSTER_BRICK_SERVER1); return storageDevice; } @Override public void setUp() throws Exception { super.setUp(); dao = dbFacade.getStorageDeviceDao(); } @Test public void testGetById(){ StorageDevice storageDevice = dao.get(EXISTING_STORAGE_DEVICE_ID_1); assertNotNull("Failed to retrive storage device", storageDevice); assertEquals("Failed to retrive corrective storage device", EXISTING_STORAGE_DEVICE_ID_1, storageDevice.getId()); storageDevice = dao.get(NON_EXISTING_STORAGE_DEVICE_ID); assertNull(storageDevice); } @Test public void testSave() { StorageDevice storageDevice = getStorageDevice(); dao.save(storageDevice); StorageDevice storageDeviceFromDB = dao.get(storageDevice.getId()); assertEquals("Storage device is not saved correctly", storageDevice, storageDeviceFromDB); } @Test public void testGetStorageDevicesInHost() { List<StorageDevice> storageDevices = dao.getStorageDevicesInHost(FixturesTool.GLUSTER_BRICK_SERVER1); assertEquals("Fails to retrive all the storage devices for host", 2, storageDevices.size()); } @Test public void testRemove() { StorageDevice storageDevice = dao.get(EXISTING_STORAGE_DEVICE_ID_2); assertNotNull("storage device doesn't exists", storageDevice); dao.remove(EXISTING_STORAGE_DEVICE_ID_2); storageDevice = dao.get(EXISTING_STORAGE_DEVICE_ID_2); assertNull("Failed to remove storage device", storageDevice); } @Test public void testUpdateStorageDevice() { StorageDevice storageDevice = dao.get(EXISTING_STORAGE_DEVICE_ID_2); assertNotNull("storage device doesn't exists", storageDevice); storageDevice.setSize(1234567L); storageDevice.setMountPoint("/gluster-bricks/brick1"); storageDevice.setFsType("xfs"); dao.update(storageDevice); StorageDevice storageDeviceFromDB = dao.get(EXISTING_STORAGE_DEVICE_ID_2); assertEquals("Failed to update Storage Device", storageDevice, storageDeviceFromDB); } @Test public void updateIsFreeFlag() { StorageDevice storageDevice = dao.get(EXISTING_STORAGE_DEVICE_ID_2); assertNotNull("storage device doesn't exists", storageDevice); dao.updateIsFreeFlag(EXISTING_STORAGE_DEVICE_ID_2, false); storageDevice = dao.get(EXISTING_STORAGE_DEVICE_ID_2); assertFalse("canCreateBrick is not updated", storageDevice.getCanCreateBrick()); dao.updateIsFreeFlag(EXISTING_STORAGE_DEVICE_ID_2, true); storageDevice = dao.get(EXISTING_STORAGE_DEVICE_ID_2); assertTrue("canCreateBrick is not updated", storageDevice.getCanCreateBrick()); } }
shre2398/openvino
inference-engine/src/vpu/common/src/ngraph/transformations/dynamic_to_static_shape_reduce.cpp
// Copyright (C) 2020 Intel Corporation // SPDX-License-Identifier: Apache-2.0 // #include "vpu/ngraph/transformations/dynamic_to_static_shape_reduce.hpp" #include "vpu/ngraph/operations/dynamic_shape_resolver.hpp" #include <vpu/utils/error.hpp> #include "ngraph/graph_util.hpp" #include "ngraph/opsets/opset3.hpp" #include <memory> #include <numeric> #include <ngraph/validation_util.hpp> namespace vpu { void dynamicToStaticShapeReduce(std::shared_ptr<ngraph::Node> target) { const auto dsr = ngraph::as_type_ptr<ngraph::vpu::op::DynamicShapeResolver>(target->input_value(0).get_node_shared_ptr()); VPU_THROW_UNLESS(dsr, "DynamicToStaticShape transformation for {} of type {} expects {} as input with index {}", target->get_friendly_name(), target->get_type_info(), ngraph::vpu::op::DynamicShapeResolver::type_info, 0); VPU_THROW_UNLESS(std::dynamic_pointer_cast<ngraph::op::util::ArithmeticReductionKeepDims>(target) || std::dynamic_pointer_cast<ngraph::op::util::LogicalReductionKeepDims>(target), "dynamicToStaticShapeReduce transformation expects arithmetic or logical reduction, but it got {} node of type {}", target->get_friendly_name(), target->get_type_info()); const auto axes_const_node = ngraph::as_type_ptr<ngraph::opset3::Constant>(target->input_value(1).get_node_shared_ptr()); VPU_THROW_UNLESS(axes_const_node, "dynamicToStaticShapeReduce transformation for {} of type {} expects {} as input with index {}, but it has {} node of type {} instead", target->get_friendly_name(), target->get_type_info(), ngraph::opset3::Constant::type_info, 1, target->input_value(1).get_node_shared_ptr()->get_friendly_name(), target->input_value(1).get_node_shared_ptr()->get_type_info()); const auto axes = axes_const_node->cast_vector<int64_t>(); const auto data_rank = target->get_input_partial_shape(0).rank(); VPU_THROW_UNLESS(data_rank.is_static(), "dynamicToStaticShapeReduce transformation for {} doesn't support dynamic rank", target); const auto data_rank_value = data_rank.get_length(); bool keep_dims = false; if (const auto arithmetic_reduce = std::dynamic_pointer_cast<ngraph::op::util::ArithmeticReductionKeepDims>(target)) { keep_dims = arithmetic_reduce->get_keep_dims(); } else if (const auto logical_reduce = std::dynamic_pointer_cast<ngraph::op::util::LogicalReductionKeepDims>(target)) { keep_dims = logical_reduce->get_keep_dims(); } // assertion earlier excluded other variants const auto data_shape = dsr->input_value(1); ngraph::Output<ngraph::Node> output_shape; if (keep_dims) { output_shape = std::make_shared<ngraph::opset3::ScatterElementsUpdate>( data_shape, ngraph::opset3::Constant::create(ngraph::element::i64, {axes.size()}, axes), ngraph::opset3::Constant::create(ngraph::element::i64, {axes.size()}, std::vector<int64_t>(axes.size(), 1)), ngraph::opset3::Constant::create(ngraph::element::i64, {1}, {0})); } else { std::vector<int64_t> range(data_rank_value); std::iota(range.begin(), range.end(), 0); std::vector<int64_t> indices; std::copy_if(range.cbegin(), range.cend(), std::back_inserter(indices), [&axes](int64_t i) { return std::find(axes.cbegin(), axes.cend(), i) == axes.cend(); }); output_shape = std::make_shared<ngraph::opset3::Gather>( data_shape, ngraph::opset3::Constant::create(ngraph::element::i64, {indices.size()}, indices), ngraph::opset3::Constant::create(ngraph::element::i64, {1}, {0})); } const auto copied = target->clone_with_new_inputs(target->input_values()); auto outDSR = std::make_shared<ngraph::vpu::op::DynamicShapeResolver>(copied, output_shape); outDSR->set_friendly_name(target->get_friendly_name()); ngraph::replace_node(target, std::move(outDSR)); } } // namespace vpu
PlayFab/XPlatCSdk
test/TestApp/AutoGenTests/AutoGenAnalyticsTests.cpp
#include "TestAppPch.h" #include "TestContext.h" #include "TestApp.h" #include "AutoGenAnalyticsTests.h" #include "XAsyncHelper.h" #include "playfab/PFAuthentication.h" namespace PlayFabUnit { using namespace PlayFab::Wrappers; AutoGenAnalyticsTests::AnalyticsTestData AutoGenAnalyticsTests::testData; void AutoGenAnalyticsTests::Log(std::stringstream& ss) { TestApp::LogPut(ss.str().c_str()); ss.str(std::string()); ss.clear(); } HRESULT AutoGenAnalyticsTests::LogHR(HRESULT hr) { if (TestApp::ShouldTrace(PFTestTraceLevel::Information)) { TestApp::Log("Result: 0x%0.8x", hr); } return hr; } void AutoGenAnalyticsTests::AddTests() { // Generated tests AddTest("TestAnalyticsClientReportDeviceInfo", &AutoGenAnalyticsTests::TestAnalyticsClientReportDeviceInfo); #if HC_PLATFORM != HC_PLATFORM_GDK AddTest("TestAnalyticsGetDetails", &AutoGenAnalyticsTests::TestAnalyticsGetDetails); #endif #if HC_PLATFORM != HC_PLATFORM_GDK AddTest("TestAnalyticsGetLimits", &AutoGenAnalyticsTests::TestAnalyticsGetLimits); #endif #if HC_PLATFORM != HC_PLATFORM_GDK AddTest("TestAnalyticsGetOperationStatus", &AutoGenAnalyticsTests::TestAnalyticsGetOperationStatus); #endif #if HC_PLATFORM != HC_PLATFORM_GDK AddTest("TestAnalyticsGetPendingOperations", &AutoGenAnalyticsTests::TestAnalyticsGetPendingOperations); #endif #if HC_PLATFORM != HC_PLATFORM_GDK AddTest("TestAnalyticsSetPerformance", &AutoGenAnalyticsTests::TestAnalyticsSetPerformance); #endif #if HC_PLATFORM != HC_PLATFORM_GDK AddTest("TestAnalyticsSetStorageRetention", &AutoGenAnalyticsTests::TestAnalyticsSetStorageRetention); #endif } void AutoGenAnalyticsTests::ClassSetUp() { HRESULT hr = PFAdminInitialize(testTitleData.titleId.data(), testTitleData.developerSecretKey.data(), testTitleData.connectionString.data(), nullptr, &stateHandle); assert(SUCCEEDED(hr)); if (SUCCEEDED(hr)) { PFAuthenticationLoginWithCustomIDRequest request{}; request.customId = "CustomId"; request.createAccount = true; PFGetPlayerCombinedInfoRequestParams combinedInfoRequestParams{}; combinedInfoRequestParams.getCharacterInventories = true; combinedInfoRequestParams.getCharacterList = true; combinedInfoRequestParams.getPlayerProfile = true; combinedInfoRequestParams.getPlayerStatistics = true; combinedInfoRequestParams.getTitleData = true; combinedInfoRequestParams.getUserAccountInfo = true; combinedInfoRequestParams.getUserData = true; combinedInfoRequestParams.getUserInventory = true; combinedInfoRequestParams.getUserReadOnlyData = true; combinedInfoRequestParams.getUserVirtualCurrency = true; request.infoRequestParameters = &combinedInfoRequestParams; XAsyncBlock async{}; hr = PFAuthenticationClientLoginWithCustomIDAsync(stateHandle, &request, &async); assert(SUCCEEDED(hr)); if (SUCCEEDED(hr)) { // Synchronously wait for login to complete hr = XAsyncGetStatus(&async, true); assert(SUCCEEDED(hr)); if (SUCCEEDED(hr)) { hr = PFAuthenticationClientLoginGetResult(&async, &titlePlayerHandle); assert(SUCCEEDED(hr) && titlePlayerHandle); hr = PFTitlePlayerGetEntityHandle(titlePlayerHandle, &entityHandle); assert(SUCCEEDED(hr) && entityHandle); } } request.customId = "CustomId2"; async = {}; hr = PFAuthenticationClientLoginWithCustomIDAsync(stateHandle, &request, &async); assert(SUCCEEDED(hr)); if (SUCCEEDED(hr)) { // Synchronously what for login to complete hr = XAsyncGetStatus(&async, true); assert(SUCCEEDED(hr)); if (SUCCEEDED(hr)) { hr = PFAuthenticationClientLoginGetResult(&async, &titlePlayerHandle2); assert(SUCCEEDED(hr) && titlePlayerHandle2); hr = PFTitlePlayerGetEntityHandle(titlePlayerHandle2, &entityHandle2); assert(SUCCEEDED(hr) && entityHandle2); } } PFAuthenticationGetEntityTokenRequest titleTokenRequest{}; async = {}; hr = PFAuthenticationGetEntityTokenAsync(stateHandle, &titleTokenRequest, &async); assert(SUCCEEDED(hr)); if (SUCCEEDED(hr)) { // Synchronously wait for login to complete hr = XAsyncGetStatus(&async, true); assert(SUCCEEDED(hr)); if (SUCCEEDED(hr)) { hr = PFAuthenticationGetEntityTokenGetResult(&async, &titleEntityHandle); assert(SUCCEEDED(hr)); } } } } void AutoGenAnalyticsTests::ClassTearDown() { PFTitlePlayerCloseHandle(titlePlayerHandle); PFEntityCloseHandle(entityHandle); PFEntityCloseHandle(titleEntityHandle); XAsyncBlock async{}; HRESULT hr = PFUninitializeAsync(stateHandle, &async); assert(SUCCEEDED(hr)); hr = XAsyncGetStatus(&async, true); assert(SUCCEEDED(hr)); UNREFERENCED_PARAMETER(hr); } void AutoGenAnalyticsTests::SetUp(TestContext& testContext) { if (!entityHandle) { testContext.Skip("Skipping test because login failed"); } } #pragma region ClientReportDeviceInfo void AutoGenAnalyticsTests::TestAnalyticsClientReportDeviceInfo(TestContext& testContext) { auto async = std::make_unique<XAsyncHelper<XAsyncResult>>(testContext); PFAnalyticsDeviceInfoRequestWrapper<> request; FillClientReportDeviceInfoRequest(request); LogDeviceInfoRequest(&request.Model(), "TestAnalyticsClientReportDeviceInfo"); HRESULT hr = PFAnalyticsClientReportDeviceInfoAsync(titlePlayerHandle, &request.Model(), &async->asyncBlock); if (FAILED(hr)) { testContext.Fail("PFAnalyticsAnalyticsClientReportDeviceInfoAsync", hr); return; } async.release(); } #pragma endregion #pragma region GetDetails #if HC_PLATFORM != HC_PLATFORM_GDK void AutoGenAnalyticsTests::TestAnalyticsGetDetails(TestContext& testContext) { struct GetDetailsResultHolderStruct : public InsightsGetDetailsResponseHolder { HRESULT Get(XAsyncBlock* async) override { size_t requiredBufferSize; RETURN_IF_FAILED(LogHR(PFAnalyticsGetDetailsGetResultSize(async, &requiredBufferSize))); resultBuffer.resize(requiredBufferSize); RETURN_IF_FAILED(LogHR(PFAnalyticsGetDetailsGetResult(async, resultBuffer.size(), resultBuffer.data(), &result, nullptr))); LogInsightsGetDetailsResponse(result); return S_OK; } HRESULT Validate() override { return ValidateGetDetailsResponse(result); } }; auto async = std::make_unique<XAsyncHelper<GetDetailsResultHolderStruct>>(testContext); PFAnalyticsInsightsEmptyRequestWrapper<> request; FillGetDetailsRequest(request); LogInsightsEmptyRequest(&request.Model(), "TestAnalyticsGetDetails"); HRESULT hr = PFAnalyticsGetDetailsAsync(entityHandle, &request.Model(), &async->asyncBlock); if (FAILED(hr)) { testContext.Fail("PFAnalyticsAnalyticsGetDetailsAsync", hr); return; } async.release(); } #endif #pragma endregion #pragma region GetLimits #if HC_PLATFORM != HC_PLATFORM_GDK void AutoGenAnalyticsTests::TestAnalyticsGetLimits(TestContext& testContext) { struct GetLimitsResultHolderStruct : public InsightsGetLimitsResponseHolder { HRESULT Get(XAsyncBlock* async) override { size_t requiredBufferSize; RETURN_IF_FAILED(LogHR(PFAnalyticsGetLimitsGetResultSize(async, &requiredBufferSize))); resultBuffer.resize(requiredBufferSize); RETURN_IF_FAILED(LogHR(PFAnalyticsGetLimitsGetResult(async, resultBuffer.size(), resultBuffer.data(), &result, nullptr))); LogInsightsGetLimitsResponse(result); return S_OK; } HRESULT Validate() override { return ValidateGetLimitsResponse(result); } }; auto async = std::make_unique<XAsyncHelper<GetLimitsResultHolderStruct>>(testContext); PFAnalyticsInsightsEmptyRequestWrapper<> request; FillGetLimitsRequest(request); LogInsightsEmptyRequest(&request.Model(), "TestAnalyticsGetLimits"); HRESULT hr = PFAnalyticsGetLimitsAsync(entityHandle, &request.Model(), &async->asyncBlock); if (FAILED(hr)) { testContext.Fail("PFAnalyticsAnalyticsGetLimitsAsync", hr); return; } async.release(); } #endif #pragma endregion #pragma region GetOperationStatus #if HC_PLATFORM != HC_PLATFORM_GDK void AutoGenAnalyticsTests::TestAnalyticsGetOperationStatus(TestContext& testContext) { struct GetOperationStatusResultHolderStruct : public InsightsGetOperationStatusResponseHolder { HRESULT Get(XAsyncBlock* async) override { size_t requiredBufferSize; RETURN_IF_FAILED(LogHR(PFAnalyticsGetOperationStatusGetResultSize(async, &requiredBufferSize))); resultBuffer.resize(requiredBufferSize); RETURN_IF_FAILED(LogHR(PFAnalyticsGetOperationStatusGetResult(async, resultBuffer.size(), resultBuffer.data(), &result, nullptr))); LogInsightsGetOperationStatusResponse(result); return S_OK; } HRESULT Validate() override { return ValidateGetOperationStatusResponse(result); } }; auto async = std::make_unique<XAsyncHelper<GetOperationStatusResultHolderStruct>>(testContext); PFAnalyticsInsightsGetOperationStatusRequestWrapper<> request; FillGetOperationStatusRequest(request); LogInsightsGetOperationStatusRequest(&request.Model(), "TestAnalyticsGetOperationStatus"); HRESULT hr = PFAnalyticsGetOperationStatusAsync(entityHandle, &request.Model(), &async->asyncBlock); if (FAILED(hr)) { testContext.Fail("PFAnalyticsAnalyticsGetOperationStatusAsync", hr); return; } async.release(); } #endif #pragma endregion #pragma region GetPendingOperations #if HC_PLATFORM != HC_PLATFORM_GDK void AutoGenAnalyticsTests::TestAnalyticsGetPendingOperations(TestContext& testContext) { struct GetPendingOperationsResultHolderStruct : public InsightsGetPendingOperationsResponseHolder { HRESULT Get(XAsyncBlock* async) override { size_t requiredBufferSize; RETURN_IF_FAILED(LogHR(PFAnalyticsGetPendingOperationsGetResultSize(async, &requiredBufferSize))); resultBuffer.resize(requiredBufferSize); RETURN_IF_FAILED(LogHR(PFAnalyticsGetPendingOperationsGetResult(async, resultBuffer.size(), resultBuffer.data(), &result, nullptr))); LogInsightsGetPendingOperationsResponse(result); return S_OK; } HRESULT Validate() override { return ValidateGetPendingOperationsResponse(result); } }; auto async = std::make_unique<XAsyncHelper<GetPendingOperationsResultHolderStruct>>(testContext); PFAnalyticsInsightsGetPendingOperationsRequestWrapper<> request; FillGetPendingOperationsRequest(request); LogInsightsGetPendingOperationsRequest(&request.Model(), "TestAnalyticsGetPendingOperations"); HRESULT hr = PFAnalyticsGetPendingOperationsAsync(entityHandle, &request.Model(), &async->asyncBlock); if (FAILED(hr)) { testContext.Fail("PFAnalyticsAnalyticsGetPendingOperationsAsync", hr); return; } async.release(); } #endif #pragma endregion #pragma region SetPerformance #if HC_PLATFORM != HC_PLATFORM_GDK void AutoGenAnalyticsTests::TestAnalyticsSetPerformance(TestContext& testContext) { struct SetPerformanceResultHolderStruct : public InsightsOperationResponseHolder { HRESULT Get(XAsyncBlock* async) override { size_t requiredBufferSize; RETURN_IF_FAILED(LogHR(PFAnalyticsSetPerformanceGetResultSize(async, &requiredBufferSize))); resultBuffer.resize(requiredBufferSize); RETURN_IF_FAILED(LogHR(PFAnalyticsSetPerformanceGetResult(async, resultBuffer.size(), resultBuffer.data(), &result, nullptr))); LogInsightsOperationResponse(result); return S_OK; } HRESULT Validate() override { return ValidateSetPerformanceResponse(result); } }; auto async = std::make_unique<XAsyncHelper<SetPerformanceResultHolderStruct>>(testContext); PFAnalyticsInsightsSetPerformanceRequestWrapper<> request; FillSetPerformanceRequest(request); LogInsightsSetPerformanceRequest(&request.Model(), "TestAnalyticsSetPerformance"); HRESULT hr = PFAnalyticsSetPerformanceAsync(entityHandle, &request.Model(), &async->asyncBlock); if (FAILED(hr)) { testContext.Fail("PFAnalyticsAnalyticsSetPerformanceAsync", hr); return; } async.release(); } #endif #pragma endregion #pragma region SetStorageRetention #if HC_PLATFORM != HC_PLATFORM_GDK void AutoGenAnalyticsTests::TestAnalyticsSetStorageRetention(TestContext& testContext) { struct SetStorageRetentionResultHolderStruct : public InsightsOperationResponseHolder { HRESULT Get(XAsyncBlock* async) override { size_t requiredBufferSize; RETURN_IF_FAILED(LogHR(PFAnalyticsSetStorageRetentionGetResultSize(async, &requiredBufferSize))); resultBuffer.resize(requiredBufferSize); RETURN_IF_FAILED(LogHR(PFAnalyticsSetStorageRetentionGetResult(async, resultBuffer.size(), resultBuffer.data(), &result, nullptr))); LogInsightsOperationResponse(result); return S_OK; } HRESULT Validate() override { return ValidateSetStorageRetentionResponse(result); } }; auto async = std::make_unique<XAsyncHelper<SetStorageRetentionResultHolderStruct>>(testContext); PFAnalyticsInsightsSetStorageRetentionRequestWrapper<> request; FillSetStorageRetentionRequest(request); LogInsightsSetStorageRetentionRequest(&request.Model(), "TestAnalyticsSetStorageRetention"); HRESULT hr = PFAnalyticsSetStorageRetentionAsync(entityHandle, &request.Model(), &async->asyncBlock); if (FAILED(hr)) { testContext.Fail("PFAnalyticsAnalyticsSetStorageRetentionAsync", hr); return; } async.release(); } #endif #pragma endregion }
chrislcs/linear-vegetation-elements
Code/segmentation_pipeline.py
# -*- coding: utf-8 -*- """ @author: <NAME> """ import time import multiprocessing import pickle import pandas as pd import numpy as np from tqdm import tqdm from segmentation.regiongrowing import segment_object PROCESSES = multiprocessing.cpu_count() - 1 INPUT = '../Data/vegetation_dbscan.csv' OUTPUT = '../Data/segments.pkl' min_size = 5 rectangularity_limit = 0.55 alpha = 0.4 k_init = 10 max_dist_init = 15.0 knn = 8 max_dist = 5 point_cloud = pd.read_csv(INPUT) points = point_cloud[['X', 'Y']].values.copy() shift = np.min(points, axis=0) num_clusters = max(point_cloud['cluster']) inputs = point_cloud['cluster'].value_counts().index segments = [] pbar = tqdm(total=point_cloud['cluster'].count()) def run_segmentation(i): cluster = point_cloud.loc[point_cloud['cluster'] == i] cluster_points = cluster[['X', 'Y']].values.copy() cluster_points -= shift cluster_segments = segment_object(cluster_points, min_size, rectangularity_limit, alpha, k_init, max_dist_init, knn, max_dist) return cluster_segments def add_result(result): segments.extend(result) pbar.update(sum([len(r) for r in result])) def run_multi(): with multiprocessing.Pool(processes=PROCESSES) as p: for i in inputs: p.apply_async(run_segmentation, args=(i,), callback=add_result) p.close() p.join() pbar.close() if __name__ == '__main__': t = time.time() run_multi() print('Done! Time elapsed: %.2f' % (time.time() - t)) with open(OUTPUT, 'wb') as f: pickle.dump(segments, f)
Scottx86-64/dotfiles-1
source/pkgsrc/comms/lirc/patches/patch-daemons_hw__default.c
<gh_stars>1-10 $NetBSD: patch-daemons_hw__default.c,v 1.1 2020/03/15 21:08:41 tnn Exp $ Add a missing include. --- daemons/hw_default.c.orig 2011-03-25 22:28:18.000000000 +0000 +++ daemons/hw_default.c @@ -21,6 +21,7 @@ #include <limits.h> #include <signal.h> #include <sys/stat.h> +#include <sys/sysmacros.h> /* for major() */ #include <sys/types.h> #include <sys/ioctl.h> #include <sys/socket.h>
LLNL/devil_ray
src/dray/data_model/subpatch.hpp
<reponame>LLNL/devil_ray<filename>src/dray/data_model/subpatch.hpp // Copyright 2019 Lawrence Livermore National Security, LLC and other // Devil Ray Developers. See the top-level COPYRIGHT file for details. // // SPDX-License-Identifier: (BSD-3-Clause) #ifndef DRAY_SUBPATCH_HPP #define DRAY_SUBPATCH_HPP #include <dray/data_model/bernstein_basis.hpp> namespace dray { // SplitDepth == how many axes, starting from outermost, should be split. template <uint32 SplitDepth, typename Split1DMethod = DeCasteljau> struct SubPatch; // Base case. template <typename Split1DMethod> struct SubPatch<1u, Split1DMethod> { // Computes the Bernstein coefficients of a sub-patch by applying DeCasteljau twice. // If a non-negative argument to POrder is given, // that is used, else the argument to p_order is used. template <typename MultiArrayT, int32 POrder = -1> DRAY_EXEC static void sub_patch_inplace (MultiArrayT &elem_data, const Range *ref_box, uint32 p_order = 0) { const auto t1 = ref_box[0].max (); auto t0 = ref_box[0].min (); // Split left. if (t1 < 1.0) Split1DMethod::template split_inplace_left<MultiArrayT, POrder> (elem_data, t1, p_order); if (t1 > 0.0) t0 /= t1; // Split right. if (t0 > 0.0) Split1DMethod::template split_inplace_right<MultiArrayT, POrder> (elem_data, t0, p_order); } }; // Arbitrary number of splits. template <uint32 SplitDepth, typename Split1DMethod> struct SubPatch { // Computes the Bernstein coefficients of a sub-patch by applying DeCasteljau twice per axis. // If a non-negative argument to POrder is given, // that is used, else the argument to p_order is used. template <typename MultiArrayT, int32 POrder = -1> DRAY_EXEC static void sub_patch_inplace (MultiArrayT &elem_data, const Range *ref_box, uint32 p_order = 0) { using ComponentT = typename FirstComponent<MultiArrayT, SplitDepth - 1>::component_t; const auto t1 = ref_box[0].max (); auto t0 = ref_box[0].min (); // Split left (outer axis). if (t1 < 1.0) for (auto &coeff_list : elem_data.template components<SplitDepth - 1> ()) Split1DMethod::template split_inplace_left<ComponentT, POrder> (coeff_list, t1, p_order); if (t1 > 0.0) t0 /= t1; // Split right (outer axis). if (t0 > 0.0) for (auto &coeff_list : elem_data.template components<SplitDepth - 1> ()) Split1DMethod::template split_inplace_right<ComponentT, POrder> (coeff_list, t0, p_order); // Split left/right (each inner axis). SubPatch<SplitDepth - 1, Split1DMethod>::template sub_patch_inplace<MultiArrayT, POrder> ( elem_data, ref_box + 1, p_order); } }; } // namespace dray #endif // DRAY_SUBPATCH_HPP
ijhajj/JavaRepository
HelloWorld/src/designPatterns/Relationships.java
<filename>HelloWorld/src/designPatterns/Relationships.java package designPatterns; import java.util.List; import java.util.ArrayList; import org.javatuples.Triplet; public class Relationships { private List<Triplet<Person,Relationship,Person>> relations = new ArrayList<>(); public List<Triplet<Person, Relationship, Person>> getRelations() { return relations; } public void addParentAndChild(Person parent,Person child) { relations.add(new Triplet<>(parent,Relationship.PARENT,child)); relations.add(new Triplet<>(child,Relationship.CHILD,parent)); } }
wardat/apache-ant-1.6.2
src/main/org/apache/tools/ant/taskdefs/optional/j2ee/HotDeploymentTool.java
/* * Copyright 2002,2004 The Apache Software 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.apache.tools.ant.taskdefs.optional.j2ee; import org.apache.tools.ant.BuildException; /** * An interface for vendor-specific "hot" deployment tools. * * * @see org.apache.tools.ant.taskdefs.optional.j2ee.AbstractHotDeploymentTool * @see org.apache.tools.ant.taskdefs.optional.j2ee.ServerDeploy */ public interface HotDeploymentTool { /** The delete action String **/ public static final String ACTION_DELETE = "delete"; /** The deploy action String **/ public static final String ACTION_DEPLOY = "deploy"; /** The list action String **/ public static final String ACTION_LIST = "list"; /** The undeploy action String **/ public static final String ACTION_UNDEPLOY = "undeploy"; /** The update action String **/ public static final String ACTION_UPDATE = "update"; /** * Validates the passed in attributes. * @exception org.apache.tools.ant.BuildException if the attributes are invalid or incomplete. */ public void validateAttributes() throws BuildException; /** * Perform the actual deployment. * @exception org.apache.tools.ant.BuildException if the attributes are invalid or incomplete. */ public void deploy() throws BuildException; /** * Sets the parent task. * @param task A ServerDeploy object representing the parent task. */ public void setTask(ServerDeploy task); }
Integreat/integreat-webapp
src/modules/layout/components/__tests__/HeaderActionItemDropDown.spec.js
<reponame>Integreat/integreat-webapp // @flow import React from 'react' import { mount } from 'enzyme' import ClickOutsideHeaderDropDown, { DropDownContainer, HeaderActionItemDropDown } from '../HeaderActionItemDropDown' import fileMock from '../../../../__mocks__/fileMock' import brightTheme from '../../../theme/constants/theme' describe('HeaderActionItemDropDown', () => { const MockNode = () => <div>Here comes the DropDown</div> let wrapperComponent beforeEach(() => { wrapperComponent = mount(<ClickOutsideHeaderDropDown theme={brightTheme} iconSrc='/someImg' text='some text'> <MockNode /> </ClickOutsideHeaderDropDown>) }) it('should pass correct closeDropDown callback', () => { const component = wrapperComponent.find(HeaderActionItemDropDown) const instance = component.instance() const callback = wrapperComponent.find('MockNode').prop('closeDropDownCallback') expect(callback).toEqual(instance?.closeDropDown) }) describe('closeDropDown()', () => { it('should close DropDown if active', () => { const component = wrapperComponent.find(HeaderActionItemDropDown) component.setState({ dropDownActive: true }) const instance: any = component.instance() instance.closeDropDown() expect(instance.state.dropDownActive).toBe(false) }) it('shouldnt open DropDown if inactive', () => { const component = wrapperComponent.find(HeaderActionItemDropDown) const instance: any = component.instance() instance.closeDropDown() instance.closeDropDown() expect(instance.state.dropDownActive).toBe(false) }) }) describe('toggleDropDown()', () => { it('should close DropDown if active', () => { const component = wrapperComponent.find(HeaderActionItemDropDown) component.setState({ dropDownActive: true }) const instance: any = component.instance() instance.toggleDropDown() expect(instance.state.dropDownActive).toBe(false) }) it('should open DropDown if inactive', () => { const component = wrapperComponent.find(HeaderActionItemDropDown) const instance: any = component.instance() instance.toggleDropDown() expect(instance.state.dropDownActive).toBe(true) }) }) it('should toggle when user clicks on button', () => { const component = wrapperComponent.find(HeaderActionItemDropDown) const instance: any = component.instance() const onClick = component.find({ selector: 'button' }).prop('onClick') expect(onClick).toBe(instance.toggleDropDown) }) it('should call closeDropDown when handleClickOutside is called', () => { const component = wrapperComponent.find(HeaderActionItemDropDown) const instance: any = component.instance() instance.closeDropDown = jest.fn() instance.handleClickOutside() expect(instance.closeDropDown).toHaveBeenCalled() }) it('should be closed from the beginning', () => { const component = wrapperComponent.find(HeaderActionItemDropDown) const instance: any = component.instance() expect(instance.state.dropDownActive).toBe(false) }) it('should add class if active', () => { const component = mount(<HeaderActionItemDropDown theme={brightTheme} iconSrc={fileMock} text='some text'><MockNode /></HeaderActionItemDropDown>) expect(component.find(DropDownContainer).prop('active')).toBe(false) component.setState({ dropDownActive: true }) expect(component.find(DropDownContainer).prop('active')).toBe(true) }) })
rook2pawn/password-manager-baseweb
icons/scooter_foot_break_outlined/ScooterFootBreakOutlined.js
<reponame>rook2pawn/password-manager-baseweb import * as React from "react"; function SvgScooterFootBreakOutlined(props) { return ( <svg width={24} height={24} fill="none" xmlns="http://www.w3.org/2000/svg" {...props} > <path d="M14.5 8c-3.07 0-5.64 2.14-6.32 5H6.14c.71-3.97 4.19-7 8.36-7 2.02 0 3.98.73 5.53 2.04l1.94-2.28A11.53 11.53 0 0014.5 3C8.67 3 3.85 7.37 3.11 13H0v3h8.18c.68 2.86 3.25 5 6.32 5 3.58 0 6.5-2.92 6.5-6.5S18.08 8 14.5 8zm0 10c-1.93 0-3.5-1.57-3.5-3.5s1.57-3.5 3.5-3.5 3.5 1.57 3.5 3.5-1.57 3.5-3.5 3.5z" fill="currentColor" /> </svg> ); } export default SvgScooterFootBreakOutlined;
rikhuijzer/u-can-act
config/application.rb
require_relative 'boot' require 'rails/all' # Require the gems listed in Gemfile, including any gems # you've limited to :test, :development, or :production. Bundler.require(*Rails.groups) Mongo::Logger.logger.level = ::Logger::INFO module Vsv class Application < Rails::Application # Initialize configuration defaults for originally generated Rails version. config.load_defaults 6.1 # Application configuration can go into files in config/initializers # -- all .rb files in that directory are automatically loaded after loading # the framework and any gems in your application. Rails.application.routes.default_url_options[:host] = ENV['HOST_URL'] config.time_zone = 'Amsterdam' config.i18n.load_path += Dir[Rails.root.join('config', 'locales', '**', '*.{rb,yml}').to_s] config.i18n.default_locale = :nl config.i18n.available_locales = [:nl, :en] # Rails 6 optimization. # See https://edgeguides.rubyonrails.org/upgrading_ruby_on_rails.html#config-add-autoload-paths-to-load-path config.add_autoload_paths_to_load_path = false config.middleware.use I18n::JS::Middleware config.active_job.queue_adapter = :delayed_job # Enable react addons config.react.addons = true config.generators do |g| # Set basic DBMS as main database g.orm :active_record # set rspec as the testframework g.test_framework :rspec, fixture: true # Define the factories of factory bot (model mock) g.fixture_replacement :factory_bot, dir: 'spec/factories' # Generate specs for helpers and views g.view_specs true g.helper_specs true # Don't generate stylesheets and javascript g.stylesheets = false g.javascripts = false g.helper = false end end end
Cinegy/Cinecoder.Samples
common/conio.h
#ifdef _WIN32 #include <conio.h> #else /** Linux (POSIX) implementation of _kbhit(). <NAME>, <EMAIL> */ #include <stdio.h> #include <sys/select.h> #include <termios.h> //#include <stropts.h> //#include <asm/ioctls.h> #include <sys/ioctl.h> #include <unistd.h> inline int _kbhit() { static const int STDIN = 0; static bool initialized = false; if (! initialized) { // Use termios to turn off line buffering termios term; tcgetattr(STDIN, &term); term.c_lflag &= ~ICANON; tcsetattr(STDIN, TCSANOW, &term); setbuf(stdin, NULL); initialized = true; } int bytesWaiting = 0; ioctl(STDIN, FIONREAD, &bytesWaiting); return bytesWaiting; } int inline _getch() { struct termios oldt, newt; int ch; tcgetattr( STDIN_FILENO, &oldt ); newt = oldt; newt.c_lflag &= ~( ICANON | ECHO ); tcsetattr( STDIN_FILENO, TCSANOW, &newt ); ch = getchar(); tcsetattr( STDIN_FILENO, TCSANOW, &oldt ); return ch; } #endif
zenofewords/thebrushstash
thebrushstash/models.py
<reponame>zenofewords/thebrushstash<gh_stars>0 from django.db import models from django.utils.translation import get_language from thebrushstash.mixins import ( LinkedMixin, PublishedMixin, TimeStampMixin, ) class Country(PublishedMixin): name = models.CharField(max_length=500) name_cro = models.CharField(max_length=500, blank=True) slug = models.CharField(max_length=500) shipping_cost = models.DecimalField( verbose_name='Shipping cost', max_digits=14, decimal_places=2, blank=False, null=True, ) class Meta: verbose_name = 'Country' verbose_name_plural = 'Countries' ordering = ('slug', ) def __str__(self): language = get_language() if language == 'hr': return self.name_cro return self.name class ExchangeRate(TimeStampMixin): currency = models.CharField(max_length=10) currency_code = models.CharField(max_length=10) state_iso = models.CharField(max_length=10) buying_rate = models.DecimalField(max_digits=10, decimal_places=8) middle_rate = models.DecimalField(max_digits=10, decimal_places=8) selling_rate = models.DecimalField(max_digits=10, decimal_places=8) added_value = models.DecimalField( max_digits=5, decimal_places=2, help_text='The percentage added when converting from HRK' ) class Meta: verbose_name = 'Exchange rate' verbose_name_plural = 'Exchange rates' def __str__(self): return '1 {} equals {} HRK'.format(self.currency, self.middle_rate) class TestImage(PublishedMixin): name = models.CharField(max_length=500) def __str__(self): return self.name class CreditCardLogo(LinkedMixin, PublishedMixin): pass class NavigationItem(LinkedMixin, PublishedMixin): name_cro = models.CharField(max_length=500, blank=True) class FooterItem(LinkedMixin, PublishedMixin): name_cro = models.CharField(max_length=500, blank=True) class FooterShareLink(LinkedMixin, PublishedMixin): name_cro = models.CharField(max_length=500, blank=True) class Region(PublishedMixin): name = models.CharField(max_length=10) language = models.CharField(max_length=10) currency = models.CharField(max_length=10) ordering = models.IntegerField(default=0, blank=True) class Meta: verbose_name = 'Region' verbose_name_plural = 'Regions' ordering = ('-ordering', ) def __str__(self): return self.name class StaticPageContent(models.Model): title = models.CharField(max_length=1000) title_cro = models.CharField(max_length=1000) slug = models.CharField(max_length=100) content = models.TextField(max_length=30000) content_cro = models.TextField(max_length=30000) class Meta: verbose_name = 'Static page content' verbose_name_plural = 'Static pages content' def __str__(self): return self.title class Setting(models.Model): name = models.CharField(max_length=50) value = models.DecimalField(max_digits=14, decimal_places=2) class Meta: verbose_name = 'Setting' verbose_name_plural = 'Settings' def __str__(self): return '{} - {}'.format(self.name, self.value) class QandAPair(models.Model): question = models.TextField(max_length=2000) question_cro = models.TextField(max_length=2000) answer = models.TextField(max_length=5000) answer_cro = models.TextField(max_length=5000) ordering = models.IntegerField( default=0, blank=True, help_text='If set to 0, items are ordered by creation date' ) class Meta: verbose_name = 'Question and answer pair' verbose_name = 'Question and answer pair' ordering = ('-ordering', ) def __str__(self): return self.question[:50]
chgogos/oop
uml/composition1.cpp
// HAS-A relationship (composition) #include <iostream> class B { private: int data[100]; public: B() { std::cout << "Object of class B at memory " << this << " having size " << sizeof(*this) << " created" << std::endl; } ~B() { std::cout << "Object of class B at memory " << this << " having size " << sizeof(*this) << " destroyed" << std::endl; } }; class A { private: int x; B b; // composition (strong containment) public: A() { std::cout << "Object of class A at memory " << this << " having size " << sizeof(*this) << " created" << std::endl; } ~A() { std::cout << "Object of class A at memory " << this << " having size " << sizeof(*this) << " destroyed" << std::endl; } }; int main() { A obj1; A obj2; return 0; } /* Object of class B at memory 0x7afc74 having size 400 created Object of class A at memory 0x7afc70 having size 404 created Object of class B at memory 0x7afad4 having size 400 created Object of class A at memory 0x7afad0 having size 404 created Object of class A at memory 0x7afad0 having size 404 destroyed Object of class B at memory 0x7afad4 having size 400 destroyed Object of class A at memory 0x7afc70 having size 404 destroyed Object of class B at memory 0x7afc74 having size 400 destroyed */
urbanjost/M_CLI2
docs/doxygen_out/html/search/all_12.js
var searchData= [ ['unnamed_148',['unnamed',['../namespacem__cli2.html#a5b03781cb432174f4ee8d734ecbb9604',1,'m_cli2']]], ['unquote_149',['unquote',['../namespacem__cli2.html#a150f312a9f4ec6dd58afb58a9a68f26a',1,'m_cli2']]], ['update_150',['update',['../namespacem__cli2.html#a160d56bc4a10faef7e8a8a4f04f4dadb',1,'m_cli2']]], ['upper_151',['upper',['../namespacem__cli2.html#aefaf1e255615ab6ebc1e19fddd795fb8',1,'m_cli2']]] ];
yehzu/vespa
searchlib/src/vespa/searchlib/queryeval/ranksearch.h
// Copyright 2017 Yahoo Holdings. Licensed under the terms of the Apache 2.0 license. See LICENSE in the project root. #pragma once #include "multisearch.h" namespace search::queryeval { /** * A simple implementation of the Rank search operation. **/ class RankSearch : public MultiSearch { protected: void doSeek(uint32_t docid) override; /** * Create a new Rank Search with the given children. A non-strict Rank has * no strictness assumptions about its children. * * @param children the search objects we are rank'ing **/ RankSearch(const Children & children) : MultiSearch(children) { } public: // Caller takes ownership of the returned SearchIterator. static SearchIterator *create(const Children &children, bool strict); }; }
mohdab98/cmps252_hw4.2
src/cmps252/HW4_2/UnitTesting/record_1931.java
package cmps252.HW4_2.UnitTesting; import static org.junit.jupiter.api.Assertions.*; import java.io.FileNotFoundException; import java.util.List; import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Tag; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import cmps252.HW4_2.Customer; import cmps252.HW4_2.FileParser; @Tag("4") class Record_1931 { private static List<Customer> customers; @BeforeAll public static void init() throws FileNotFoundException { customers = FileParser.getCustomers(Configuration.CSV_File); } @Test @DisplayName("Record 1931: FirstName is Sylvester") void FirstNameOfRecord1931() { assertEquals("Sylvester", customers.get(1930).getFirstName()); } @Test @DisplayName("Record 1931: LastName is Hilu") void LastNameOfRecord1931() { assertEquals("Hilu", customers.get(1930).getLastName()); } @Test @DisplayName("Record 1931: Company is Hopkins, Stephen P Esq") void CompanyOfRecord1931() { assertEquals("Hopkins, Stephen P Esq", customers.get(1930).getCompany()); } @Test @DisplayName("Record 1931: Address is 311 Market St") void AddressOfRecord1931() { assertEquals("311 Market St", customers.get(1930).getAddress()); } @Test @DisplayName("Record 1931: City is Kingston") void CityOfRecord1931() { assertEquals("Kingston", customers.get(1930).getCity()); } @Test @DisplayName("Record 1931: County is Luzerne") void CountyOfRecord1931() { assertEquals("Luzerne", customers.get(1930).getCounty()); } @Test @DisplayName("Record 1931: State is PA") void StateOfRecord1931() { assertEquals("PA", customers.get(1930).getState()); } @Test @DisplayName("Record 1931: ZIP is 18704") void ZIPOfRecord1931() { assertEquals("18704", customers.get(1930).getZIP()); } @Test @DisplayName("Record 1931: Phone is 570-283-5211") void PhoneOfRecord1931() { assertEquals("570-283-5211", customers.get(1930).getPhone()); } @Test @DisplayName("Record 1931: Fax is 570-283-2417") void FaxOfRecord1931() { assertEquals("570-283-2417", customers.get(1930).getFax()); } @Test @DisplayName("Record 1931: Email is <EMAIL>") void EmailOfRecord1931() { assertEquals("<EMAIL>", customers.get(1930).getEmail()); } @Test @DisplayName("Record 1931: Web is http://www.sylvesterhilu.com") void WebOfRecord1931() { assertEquals("http://www.sylvesterhilu.com", customers.get(1930).getWeb()); } }
tienpham/oci-go-sdk
analytics/work_request_action_result.go
<filename>analytics/work_request_action_result.go<gh_stars>0 // Copyright (c) 2016, 2018, 2019, Oracle and/or its affiliates. All rights reserved. // Code generated. DO NOT EDIT. // Analytics API // // Analytics API. // package analytics // WorkRequestActionResultEnum Enum with underlying type: string type WorkRequestActionResultEnum string // Set of constants representing the allowable values for WorkRequestActionResultEnum const ( WorkRequestActionResultCompartmentChanged WorkRequestActionResultEnum = "COMPARTMENT_CHANGED" WorkRequestActionResultCreated WorkRequestActionResultEnum = "CREATED" WorkRequestActionResultDeleted WorkRequestActionResultEnum = "DELETED" WorkRequestActionResultStarted WorkRequestActionResultEnum = "STARTED" WorkRequestActionResultStopped WorkRequestActionResultEnum = "STOPPED" WorkRequestActionResultScaled WorkRequestActionResultEnum = "SCALED" WorkRequestActionResultNone WorkRequestActionResultEnum = "NONE" ) var mappingWorkRequestActionResult = map[string]WorkRequestActionResultEnum{ "COMPARTMENT_CHANGED": WorkRequestActionResultCompartmentChanged, "CREATED": WorkRequestActionResultCreated, "DELETED": WorkRequestActionResultDeleted, "STARTED": WorkRequestActionResultStarted, "STOPPED": WorkRequestActionResultStopped, "SCALED": WorkRequestActionResultScaled, "NONE": WorkRequestActionResultNone, } // GetWorkRequestActionResultEnumValues Enumerates the set of values for WorkRequestActionResultEnum func GetWorkRequestActionResultEnumValues() []WorkRequestActionResultEnum { values := make([]WorkRequestActionResultEnum, 0) for _, v := range mappingWorkRequestActionResult { values = append(values, v) } return values }
HappyRay/samza
samza-core/src/main/java/org/apache/samza/util/Util.java
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ package org.apache.samza.util; import java.net.Inet4Address; import java.net.InetAddress; import java.net.NetworkInterface; import java.net.SocketException; import java.net.UnknownHostException; import java.util.Collections; import java.util.List; import java.util.Optional; import java.util.stream.Collectors; import com.google.common.collect.Lists; import org.apache.samza.SamzaException; import org.apache.samza.config.ApplicationConfig; import org.apache.samza.config.Config; import org.apache.samza.config.TaskConfig; import org.slf4j.Logger; import org.slf4j.LoggerFactory; public class Util { private static final Logger LOG = LoggerFactory.getLogger(Util.class); static final String FALLBACK_VERSION = "0.0.1"; /** * Make an environment variable string safe to pass. */ public static String envVarEscape(String str) { return str.replace("\"", "\\\"").replace("'", "\\'"); } public static String getSamzaVersion() { return Optional.ofNullable(Util.class.getPackage().getImplementationVersion()).orElseGet(() -> { LOG.warn("Unable to find implementation samza version in jar's meta info. Defaulting to {}", FALLBACK_VERSION); return FALLBACK_VERSION; }); } public static String getTaskClassVersion(Config config) { try { Optional<String> appClass = Optional.ofNullable(new ApplicationConfig(config).getAppClass()); if (appClass.isPresent()) { return Optional.ofNullable(Class.forName(appClass.get()).getPackage().getImplementationVersion()) .orElse(FALLBACK_VERSION); } else { Optional<String> taskClass = new TaskConfig(config).getTaskClass(); if (taskClass.isPresent()) { return Optional.ofNullable(Class.forName(taskClass.get()).getPackage().getImplementationVersion()) .orElse(FALLBACK_VERSION); } else { LOG.warn("Unable to find app class or task class. Defaulting to {}", FALLBACK_VERSION); return FALLBACK_VERSION; } } } catch (Exception e) { LOG.warn(String.format("Ran into exception while trying to get version of app or task. Defaulting to %s", FALLBACK_VERSION), e); return FALLBACK_VERSION; } } /** * Returns the the first host address which is not the loopback address, or {@link InetAddress#getLocalHost} as a * fallback. * * @return the {@link InetAddress} which represents the localhost */ public static InetAddress getLocalHost() { try { return doGetLocalHost(); } catch (Exception e) { throw new SamzaException("Error while getting localhost", e); } } private static InetAddress doGetLocalHost() throws UnknownHostException, SocketException { InetAddress localHost = InetAddress.getLocalHost(); if (localHost.isLoopbackAddress()) { LOG.debug("Hostname {} resolves to a loopback address, trying to resolve an external IP address.", localHost.getHostName()); List<NetworkInterface> networkInterfaces; if (System.getProperty("os.name").startsWith("Windows")) { networkInterfaces = Collections.list(NetworkInterface.getNetworkInterfaces()); } else { networkInterfaces = Lists.reverse(Collections.list(NetworkInterface.getNetworkInterfaces())); } for (NetworkInterface networkInterface : networkInterfaces) { List<InetAddress> addresses = Collections.list(networkInterface.getInetAddresses()) .stream() .filter(address -> !(address.isLinkLocalAddress() || address.isLoopbackAddress())) .collect(Collectors.toList()); if (!addresses.isEmpty()) { InetAddress address = addresses.stream() .filter(addr -> addr instanceof Inet4Address) .findFirst() .orElseGet(() -> addresses.get(0)); LOG.debug("Found an external IP address {} which represents the localhost.", address.getHostAddress()); return InetAddress.getByAddress(address.getAddress()); } } } return localHost; } }
Be-poz/atdd-subway-fare
src/main/java/wooteco/subway/path/domain/fare/DistanceFareRule.java
<filename>src/main/java/wooteco/subway/path/domain/fare/DistanceFareRule.java package wooteco.subway.path.domain.fare; import java.util.Arrays; import java.util.function.Predicate; public enum DistanceFareRule { BASIC_DISTANCE(distance -> false, 0, 1, 1250, 0), MIDDLE_DISTANCE(distance -> distance > 10 && distance <= 50, 10, 5, 1250, 100), LONG_DISTANCE(distance -> distance > 50, 50, 8, 2050, 100); private final Predicate<Integer> figureOutRule; private final int subtractFormulaValue; private final int divideFormulaValue; private final int defaultFare; private final int fareForDistanceFormulaValue; DistanceFareRule(Predicate<Integer> figureOutRule, int subtractFormulaValue, int divideFormulaValue, int defaultFare, int fareForDistanceFormulaValue) { this.figureOutRule = figureOutRule; this.subtractFormulaValue = subtractFormulaValue; this.divideFormulaValue = divideFormulaValue; this.defaultFare = defaultFare; this.fareForDistanceFormulaValue = fareForDistanceFormulaValue; } public static int calculateFee(int distance) { DistanceFareRule findDistanceRule = findDistanceRule(distance); return additionalDistanceFee(findDistanceRule, distance); } public static DistanceFareRule findDistanceRule(int distance) { return Arrays.stream(DistanceFareRule.values()) .filter(value -> value.figureOutRule.test(distance)) .findAny() .orElse(BASIC_DISTANCE); } public static int additionalDistanceFee(DistanceFareRule rule, int distance) { return rule.defaultFare + (int) Math.ceil((double) (distance - rule.subtractFormulaValue) / rule.divideFormulaValue) * rule.fareForDistanceFormulaValue; } }
phatblat/macOSPrivateFrameworks
PrivateFrameworks/ACDEClient/ACCTicketManagerProtocol-Protocol.h
<filename>PrivateFrameworks/ACDEClient/ACCTicketManagerProtocol-Protocol.h // // Generated by class-dump 3.5 (64 bit). // // class-dump is Copyright (C) 1997-1998, 2000-2001, 2004-2013 by <NAME>. // #import "NSObject.h" @class ACFMessage, ACFPrincipal, NSData, NSDictionary, NSNumber, NSString; @protocol ACCTicketManagerProtocol <NSObject> - (void)updateContextWithClientSecretIfAny:(id <ACCAuthContextProtocol>)arg1; - (NSString *)serviceTicketStringWithRequest:(ACFMessage *)arg1 ssoToken:(id <ACCSSOTokenProtocol>)arg2; - (id <ACCAuthContextProtocol>)changePasswordContextWithRequest:(ACFMessage *)arg1 oldPassword:(NSString *)arg2 newPassword:(NSString *)arg3; - (id <ACCSSOTokenProtocol>)fetchSSOTokenForPrincipal:(ACFPrincipal *)arg1 agedLessThan:(double)arg2; - (id <ACCSSOTokenProtocol>)fetchSSOTokenForPrincipal:(ACFPrincipal *)arg1; - (BOOL)storeSSOToken:(id <ACCSSOTokenProtocol>)arg1; - (id <ACCSSOTokenProtocol>)createSSOTokenWithContent:(NSData *)arg1 context:(id <ACCAuthContextProtocol>)arg2; - (NSData *)decryptEncryptedContent:(NSData *)arg1 withHmac:(NSString *)arg2 context:(id <ACCAuthContextProtocol>)arg3; - (id <ACCAuthContextProtocol>)authContextWithRequest:(ACFMessage *)arg1 sessionToken:(NSString *)arg2; - (id <ACCAuthContextProtocol>)authContextWithRequest:(ACFMessage *)arg1 keyCode:(NSString *)arg2 authenticationType:(NSNumber *)arg3; - (id <ACCAuthContextProtocol>)authContextWithRequest:(ACFMessage *)arg1; - (NSDictionary *)envelopeWithContext:(id <ACCAuthContextProtocol>)arg1; - (void)uninstallPublicKeyForRealm:(NSString *)arg1; - (BOOL)installCertificateWithString:(NSString *)arg1 version:(NSString *)arg2 forRealm:(NSString *)arg3; @end

Dataset Card for "starcoderdata_0.001"

More Information needed

Downloads last month
0
Edit dataset card