blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 3
264
| content_id
stringlengths 40
40
| detected_licenses
sequencelengths 0
85
| license_type
stringclasses 2
values | repo_name
stringlengths 5
140
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringclasses 986
values | visit_date
timestamp[us] | revision_date
timestamp[us] | committer_date
timestamp[us] | github_id
int64 3.89k
681M
⌀ | star_events_count
int64 0
209k
| fork_events_count
int64 0
110k
| gha_license_id
stringclasses 23
values | gha_event_created_at
timestamp[us] | gha_created_at
timestamp[us] | gha_language
stringclasses 145
values | src_encoding
stringclasses 34
values | language
stringclasses 1
value | is_vendor
bool 1
class | is_generated
bool 2
classes | length_bytes
int64 3
10.4M
| extension
stringclasses 122
values | content
stringlengths 3
10.4M
| authors
sequencelengths 1
1
| author_id
stringlengths 0
158
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
b521e051770e08146dfc8864494616a29ea338d6 | c3294a4006b658a9859372dd566715880b0f5e90 | /practice/interactivepractice.cpp | 81267d78ba08ac62c3ed0abfaabd81c79e02d06d | [] | no_license | Manzood/Google-Code-Jam | 0dc5259046cb6d982de9018c2be00a690b568b5b | 999aa12ced1857fe0ba312edd11fae3e95ed8964 | refs/heads/master | 2022-05-26T08:17:29.294220 | 2022-05-14T19:00:11 | 2022-05-14T19:00:11 | 253,270,078 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 300 | cpp | #include<cstdio>
#include<iostream>
#include<algorithm>
#include<vector>
#include<set>
using namespace std;
int main () {
int t;
cin>>t;
while (t--) {
int a,b;
cin>>a>>b;
int low=a,high=b;
bool found=false;
while(!found) {
q=low+high;
q/=2;
cout<<q<<endl;
if (q==)
}
}
} | [
"[email protected]"
] | |
c5983fdbfef172bb674b78256aec203580ab359a | f14626611951a4f11a84cd71f5a2161cd144a53a | /Server/GameServer/App/StateAI/StateImpl/FightStateImpl.cpp | 5f44828bc08190710169b85fca7ab7249a485736 | [] | no_license | Deadmanovi4/mmo-resourse | 045616f9be76f3b9cd4a39605accd2afa8099297 | 1c310e15147ae775a59626aa5b5587c6895014de | refs/heads/master | 2021-05-29T06:14:28.650762 | 2015-06-18T01:16:43 | 2015-06-18T01:16:43 | null | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 8,446 | cpp | ///
/// @file FightStateImpl.cpp
///
#include "stdafx.h"
#include "CycleState/CycleStateImpl.h"
#include "FightStateImpl.h"
#include "../AIEventSender.h"
#include "../BaseAI.h"
#include "../Helper/FightObj.h"
#include "../MonsterAI.h"
#include "../../Monster.h"
namespace StateAI
{
bool FightStateBase::SearchEnemy( BaseType::EntityType *entity )
{
AIState *search_action = entity->GetState( ST_SEARCH );
assert( search_action );
search_action->Execute( entity );
return false;
}
bool FightStateBase::CheckCycleState( BaseType::EntityType *entity )
{
AIState *cycle_action = entity->GetState( ST_CYCLE );
CycleStateExecutor cycleExecutor;
if( cycleExecutor.Execute( cycle_action, entity ) )
{
return true;
}
return false;
}
IMPL_LIFE_POLICY_FUNC( FightStateNormal, AIState );
static std::vector<CMonster::tagSkillRecord> &GetSkillList( CMonster *monster, int type )
{
if( type == SKILLTYPE_BASE )
{
return monster->GetBaseSkillList();
}
else if( type == SKILLTYPE_NORMAL )
{
return monster->GetSkillList();
}
else
{
return monster->GetCycleSkillList();
}
}
FightStateNormal::FightStateNormal( MachineType *machine ) : FightStateBase( machine )
{
}
FightStateNormal::~FightStateNormal()
{
}
void FightStateNormal::Enter( BaseType::EntityType *entity, const AITransition &tran )
{
ClearSelSkill();
// record the enter fight position.
MonsterAI *monsterAI = static_cast<MonsterAI*>( entity );
monsterAI->GetFightObj().EnterFight();
// on fight script
CMonster *monster = dynamic_cast<CMonster*>( entity->GetOwner() );
if( monster != NULL )
{
entity->RunScript( monster->GetFightScriptName().c_str() );
}
m_NormalSkillTimeStamp = 0;
}
void FightStateNormal::ClearSelSkill()
{
memset( &m_SelSkill, 0, sizeof( m_SelSkill ) );
}
void FightStateNormal::ReceiveEvent( BaseType::EntityType *entity, const BaseType::EventType &ev )
{
if( ev.Type() == ET_HURT )
{
}
else if( ev.Type() == ET_KILL )
{
entity->ChangeState( ST_DEAD );
}
else if( ev.Type() == ET_USESKILLEND )
{
entity->Resume( 0 );
}
}
void FightStateNormal::Execute( BaseType::EntityType *entity )
{
// search enemy first
SearchEnemy( entity );
// check cycle action
if( CheckCycleState( entity ) )
{
return ;
}
// can return peace ?
MonsterAI *monsterAI = static_cast<MonsterAI*>( entity );
if( monsterAI->GetFightObj().CheckReturnPeace() )
{
// return peace
return ;
}
// attack the target
CMoveShape *target = entity->GetTarget();
if( target == NULL )
{
// return peace ?
monsterAI->GetFightObj().LoseTarget();
entity->Resume( OPER_FAILED_TIME );
return ;
}
Attack( entity, target );
}
void FightStateNormal::Attack( BaseType::EntityType *entity, CMoveShape *target )
{
CMonster *monster= static_cast<CMonster*>( entity->GetOwner() );
long targetDis = monster->RealDistance( target );
if( m_SelSkill.id == 0 )
{
// search one skill to attack
if( !SearchSkill( monster, targetDis ) )
{
entity->Resume( OPER_FAILED_TIME );
return ;
}
}
// we assume we have one skill to attack the target
if( !GetInst(SkillAttribute).IsExist(m_SelSkill.id , m_SelSkill.level) )
{
// error
entity->Resume( OPER_FAILED_TIME );
ClearSelSkill();
return ;
}
float minAtkDis = (float)monster->GetSkillValue( m_SelSkill.id , m_SelSkill.level , "MinAtkDistance" );
float maxAtkDis = (float)monster->GetSkillValue( m_SelSkill.id , m_SelSkill.level , "MaxAtkDistance" );
bool used = false;
// we assume the target is still in the track range.
if( targetDis > maxAtkDis )
{
entity->Move( target->GetTileX(), target->GetTileY() );
}
else if( targetDis < minAtkDis )
{
long dir = GetLineDir( target->GetTileX(), target->GetTileY(),
monster->GetTileX(), monster->GetTileY() );
entity->Move( dir );
}
else
{
// in the attack range
if( static_cast<MonsterAI*>( entity )->BeginSkill( m_SelSkill.id, m_SelSkill.level,
target->GetTileX(), target->GetTileY(), target ) )
{
// use this skill ok, clear the selection.
OnSkillUsed( monster );
used = true;
}
}
// clear the selected skill if it's not a cycle skill
if( !used && m_SelSkill.type != SKILLTYPE_CYCLE )
{
ClearSelSkill();
}
}
void FightStateNormal::OnSkillUsed( CMonster *monster )
{
std::vector<CMonster::tagSkillRecord> &skillList = GetSkillList( monster, m_SelSkill.type );
CMonster::tagSkillRecord &record = skillList[m_SelSkill.index];
record.dwCoolDownTime = timeGetTime() + record.dwCool;
ClearSelSkill();
}
bool FightStateNormal::SearchSkill( CMonster *monster, long dis )
{
// 选择周期技能
if( SearchSkill( SKILLTYPE_CYCLE, monster, dis ) )
{
return true;
}
unsigned long thisTime = timeGetTime();
if( thisTime > m_NormalSkillTimeStamp )
{
m_NormalSkillTimeStamp = thisTime + monster->GetSkillSpace();
int proportion = monster->GetSkillProportion();
if( random( 100 ) < proportion )
{
// 选择普通技能
if( SearchSkill( SKILLTYPE_NORMAL, monster, dis ) )
{
return true;
}
}
}
// 选择基本技能
return SearchSkill( SKILLTYPE_BASE, monster, dis );
}
bool FightStateNormal::SearchSkill( int type, CMonster *monster, long dis )
{
std::vector<CMonster::tagSkillRecord> &skillList = GetSkillList( monster, type );
if( skillList.size() == 0 )
{
return false;
}
unsigned long thisTime = timeGetTime();
std::vector<SkillInfo> selSkillList;
for( size_t i = 0; i < skillList.size(); ++ i )
{
if( skillList[i].dwCoolDownTime > thisTime )
{
continue;
}
if( !CheckSkill( monster, skillList[i].wID, skillList[i].wLevel, type, dis ) )
{
continue;
}
SkillInfo info;
info.id = skillList[i].wID;
info.level = skillList[i].wLevel;
info.index = (long)i;
info.type = type;
selSkillList.push_back( info );
}
if( selSkillList.size() == 0 )
{
return false;
}
size_t i = random( (int)selSkillList.size() );
m_SelSkill = selSkillList[i];
return true;
}
bool FightStateNormal::CheckSkill( CMonster *monster, int id, int lvl, int type, long dis )
{
CNewSkill *skillProperty = CNewSkillFactory::QueryNewSkillProperty( id );
if( skillProperty == NULL )
{
return false;
}
if( !monster->GetUseRabbSkill() && skillProperty->GetUseType() == SKILL_TYPE_MAGIC )
{
return false;
}
if( !monster->GetUseFightSkill() && skillProperty->GetUseType() == SKILL_TYPE_PHYSICAL )
{
return false;
}
/*
list<long> buffID = skillProperty->GetStaticParam( lvl )->lBuffID;
for( list<long>::iterator it = buffID.begin(); it != buffID.end(); ++it )
{
map<long, stModuParam*>::iterator bt = monster->GetBuff().find( *it );
if( bt == monster->GetBuff().end() ) // ??????????????????????
{
continue;
}
else
{
return false;
}
}
list<long> debuffID = skillProperty->GetStaticParam( lvl )->lNBuffID;
for( list<long>::iterator it = debuffID.begin(); it != debuffID.end(); ++it )
{
map<long, stModuParam*>::iterator bt = monster->GetBuff().find( *it );
if( bt != monster->GetBuff().end() )
{
continue;
}
else
{
return false;
}
}
*/
return true;
}
}
| [
"[email protected]"
] | |
4792fb4ecc3de13f68d9862778e78daa697f6be2 | f33d9f95e3870cfdd8a36f4a130f9a753a457b5c | /ComputeHomeTuples.h | c4922465e13693f78dc3599b3d5e329ac77db2e5 | [] | no_license | aar2163/NAMD-energy | b8733f1b7d1fbd39f8724ebeaa7bb82f7a822f1c | 3823103970df4c063d4c9cec38dca7c649964bb8 | refs/heads/master | 2016-09-06T16:09:33.409987 | 2015-04-30T18:03:18 | 2015-04-30T18:03:18 | 34,535,542 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 15,027 | h | /**
*** Copyright (c) 1995, 1996, 1997, 1998, 1999, 2000 by
*** The Board of Trustees of the University of Illinois.
*** All rights reserved.
**/
#ifndef COMPUTEHOMETUPLES_H
#define COMPUTEHOMETUPLES_H
#include "NamdTypes.h"
#include "common.h"
#include "structures.h"
#include "Compute.h"
#include "HomePatch.h"
#include "Box.h"
#include "OwnerBox.h"
#include "UniqueSet.h"
#include "Node.h"
#include "SimParameters.h"
#include "PatchMap.inl"
#include "AtomMap.h"
#include "ComputeHomeTuples.h"
#include "PatchMgr.h"
#include "HomePatchList.h"
#include "Molecule.h"
#include "Parameters.h"
#include "ReductionMgr.h"
#include "UniqueSet.h"
#include "UniqueSetIter.h"
#include "Priorities.h"
#include "LdbCoordinator.h"
class TuplePatchElem {
public:
PatchID patchID;
Patch *p;
Box<Patch,CompAtom> *positionBox;
Box<Patch,CompAtom> *avgPositionBox;
Box<Patch,Results> *forceBox;
CompAtom *x;
CompAtomExt *xExt;
CompAtom *x_avg;
Results *r;
Force *f;
Force *af;
int hash() const { return patchID; }
TuplePatchElem(PatchID pid = -1) {
patchID = pid;
p = NULL;
positionBox = NULL;
avgPositionBox = NULL;
forceBox = NULL;
x = NULL;
xExt = NULL;
x_avg = NULL;
r = NULL;
f = NULL;
af = NULL;
}
TuplePatchElem(Patch *p_param, Compute *cid) {
patchID = p_param->getPatchID();
p = p_param;
positionBox = p_param->registerPositionPickup(cid);
avgPositionBox = p_param->registerAvgPositionPickup(cid);
forceBox = p_param->registerForceDeposit(cid);
x = NULL;
xExt = NULL;
x_avg = NULL;
r = NULL;
f = NULL;
af = NULL;
}
~TuplePatchElem() {};
int operator==(const TuplePatchElem &elem) const {
return (elem.patchID == patchID);
}
int operator<(const TuplePatchElem &elem) const {
return (patchID < elem.patchID);
}
};
typedef UniqueSet<TuplePatchElem> TuplePatchList;
typedef UniqueSetIter<TuplePatchElem> TuplePatchListIter;
class AtomMap;
class ReductionMgr;
#ifdef MEM_OPT_VERSION
template <class T> struct ElemTraits {
typedef AtomSignature signature;
static signature* get_sig_pointer(Molecule *mol) { return mol->atomSigPool; }
static int get_sig_id(const CompAtomExt &a) { return a.sigId; }
};
template <> struct ElemTraits <ExclElem> {
typedef ExclusionSignature signature;
static signature* get_sig_pointer(Molecule *mol) { return mol->exclSigPool; }
static int get_sig_id(const CompAtomExt &a) { return a.exclId; }
};
#endif
template <class T, class S, class P> class ComputeHomeTuples : public Compute {
protected:
virtual void loadTuples(void) {
int numTuples;
#ifdef MEM_OPT_VERSION
typename ElemTraits<T>::signature *allSigs;
#else
int32 **tuplesByAtom;
/* const (need to propagate const) */ S *tupleStructs;
#endif
const P *tupleValues;
Node *node = Node::Object();
#ifdef MEM_OPT_VERSION
allSigs = ElemTraits<T>::get_sig_pointer(node->molecule);
#else
T::getMoleculePointers(node->molecule,
&numTuples, &tuplesByAtom, &tupleStructs);
#endif
T::getParameterPointers(node->parameters, &tupleValues);
tupleList.resize(0);
LocalID aid[T::size];
const int lesOn = node->simParameters->lesOn;
Real invLesFactor = lesOn ?
1.0/node->simParameters->lesFactor :
1.0;
// cycle through each patch and gather all tuples
TuplePatchListIter ai(tuplePatchList);
for ( ai = ai.begin(); ai != ai.end(); ai++ )
{
// CompAtom *atom = (*ai).x;
Patch *patch = (*ai).p;
int numAtoms = patch->getNumAtoms();
CompAtomExt *atomExt = (*ai).xExt; //patch->getCompAtomExtInfo();
// cycle through each atom in the patch and load up tuples
for (int j=0; j < numAtoms; j++)
{
/* cycle through each tuple */
#ifdef MEM_OPT_VERSION
typename ElemTraits<T>::signature *thisAtomSig =
&allSigs[ElemTraits<T>::get_sig_id(atomExt[j])];
TupleSignature *allTuples;
T::getTupleInfo(thisAtomSig, &numTuples, &allTuples);
for(int k=0; k<numTuples; k++) {
T t(atomExt[j].id, &allTuples[k], tupleValues);
#else
/* get list of all tuples for the atom */
int32 *curTuple = tuplesByAtom[atomExt[j].id];
for( ; *curTuple != -1; ++curTuple) {
T t(&tupleStructs[*curTuple],tupleValues);
#endif
register int i;
aid[0] = atomMap->localID(t.atomID[0]);
int homepatch = aid[0].pid;
int samepatch = 1;
int has_les = lesOn && node->molecule->get_fep_type(t.atomID[0]);
for (i=1; i < T::size; i++) {
aid[i] = atomMap->localID(t.atomID[i]);
samepatch = samepatch && ( homepatch == aid[i].pid );
has_les |= lesOn && node->molecule->get_fep_type(t.atomID[i]);
}
if ( samepatch ) continue;
t.scale = has_les ? invLesFactor : 1;
for (i=1; i < T::size; i++) {
homepatch = patchMap->downstream(homepatch,aid[i].pid);
}
if ( homepatch != notUsed && isBasePatch[homepatch] ) {
TuplePatchElem *p;
for (i=0; i < T::size; i++) {
t.p[i] = p = tuplePatchList.find(TuplePatchElem(aid[i].pid));
if ( ! p ) {
#ifdef MEM_OPT_VERSION
iout << iWARN << "Tuple with atoms ";
#else
iout << iWARN << "Tuple " << *curTuple << " with atoms ";
#endif
int erri;
for( erri = 0; erri < T::size; erri++ ) {
iout << t.atomID[erri] << "(" << aid[erri].pid << ") ";
}
iout << "missing patch " << aid[i].pid << "\n" << endi;
break;
}
t.localIndex[i] = aid[i].index;
}
if ( ! p ) continue;
#ifdef MEM_OPT_VERSION
//avoid adding Tuples whose atoms are all fixed
if(node->simParameters->fixedAtomsOn &&
!node->simParameters->fixedAtomsForces) {
int allfixed = 1;
for(i=0; i<T::size; i++){
CompAtomExt *one = &(t.p[i]->xExt[aid[i].index]);
allfixed = allfixed & one->atomFixed;
}
if(!allfixed) tupleList.add(t);
}else{
tupleList.add(t);
}
#else
tupleList.add(t);
#endif
}
}
}
}
}
int doLoadTuples;
protected:
ResizeArray<T> tupleList;
TuplePatchList tuplePatchList;
PatchMap *patchMap;
AtomMap *atomMap;
SubmitReduction *reduction;
int accelMDdoDihe;
SubmitReduction *pressureProfileReduction;
BigReal *pressureProfileData;
int pressureProfileSlabs;
char *isBasePatch;
ComputeHomeTuples(ComputeID c) : Compute(c) {
patchMap = PatchMap::Object();
atomMap = AtomMap::Object();
reduction = ReductionMgr::Object()->willSubmit(REDUCTIONS_BASIC);
SimParameters *params = Node::Object()->simParameters;
accelMDdoDihe=false;
if (params->accelMDOn) {
if (params->accelMDdihe || params->accelMDdual) accelMDdoDihe=true;
}
if (params->pressureProfileOn) {
pressureProfileSlabs = T::pressureProfileSlabs =
params->pressureProfileSlabs;
int n = T::pressureProfileAtomTypes = params->pressureProfileAtomTypes;
pressureProfileReduction = ReductionMgr::Object()->willSubmit(
REDUCTIONS_PPROF_BONDED, 3*pressureProfileSlabs*((n*(n+1))/2));
int numAtomTypePairs = n*n;
pressureProfileData = new BigReal[3*pressureProfileSlabs*numAtomTypePairs];
} else {
pressureProfileReduction = NULL;
pressureProfileData = NULL;
}
doLoadTuples = false;
isBasePatch = 0;
}
ComputeHomeTuples(ComputeID c, PatchIDList &pids) : Compute(c) {
patchMap = PatchMap::Object();
atomMap = AtomMap::Object();
reduction = ReductionMgr::Object()->willSubmit(REDUCTIONS_BASIC);
SimParameters *params = Node::Object()->simParameters;
accelMDdoDihe=false;
if (params->accelMDOn) {
if (params->accelMDdihe || params->accelMDdual) accelMDdoDihe=true;
}
if (params->pressureProfileOn) {
pressureProfileSlabs = T::pressureProfileSlabs =
params->pressureProfileSlabs;
int n = T::pressureProfileAtomTypes = params->pressureProfileAtomTypes;
pressureProfileReduction = ReductionMgr::Object()->willSubmit(
REDUCTIONS_PPROF_BONDED, 3*pressureProfileSlabs*((n*(n+1))/2));
int numAtomTypePairs = n*n;
pressureProfileData = new BigReal[3*pressureProfileSlabs*numAtomTypePairs];
} else {
pressureProfileReduction = NULL;
pressureProfileData = NULL;
}
doLoadTuples = false;
int nPatches = patchMap->numPatches();
isBasePatch = new char[nPatches];
int i;
for (i=0; i<nPatches; ++i) { isBasePatch[i] = 0; }
for (i=0; i<pids.size(); ++i) { isBasePatch[pids[i]] = 1; }
}
public:
virtual ~ComputeHomeTuples() {
delete reduction;
delete [] isBasePatch;
delete pressureProfileReduction;
delete pressureProfileData;
}
//======================================================================
// initialize() - Method is invoked only the first time
// atom maps, patchmaps etc are ready and we are about to start computations
//======================================================================
virtual void initialize(void) {
// Start with empty list
tuplePatchList.clear();
int nPatches = patchMap->numPatches();
int pid;
for (pid=0; pid<nPatches; ++pid) {
if ( isBasePatch[pid] ) {
Patch *patch = patchMap->patch(pid);
tuplePatchList.add(TuplePatchElem(patch, this));
}
}
// Gather all proxy patches (neighbors, that is)
PatchID neighbors[PatchMap::MaxOneOrTwoAway];
for (pid=0; pid<nPatches; ++pid) if ( isBasePatch[pid] ) {
int numNeighbors = patchMap->upstreamNeighbors(pid,neighbors);
for ( int i = 0; i < numNeighbors; ++i ) {
if ( ! tuplePatchList.find(TuplePatchElem(neighbors[i])) ) {
Patch *patch = patchMap->patch(neighbors[i]);
tuplePatchList.add(TuplePatchElem(patch, this));
}
}
}
setNumPatches(tuplePatchList.size());
doLoadTuples = true;
basePriority = COMPUTE_PROXY_PRIORITY; // no patch dependence
}
//======================================================================
// atomUpdate() - Method is invoked after anytime that atoms have been
// changed in patches used by this Compute object.
//======================================================================
void atomUpdate(void) {
doLoadTuples = true;
}
//-------------------------------------------------------------------
// Routine which is called by enqueued work msg. It wraps
// actualy Force computation with the apparatus needed
// to get access to atom positions, return forces etc.
//-------------------------------------------------------------------
virtual void doWork(void) {
LdbCoordinator::Object()->startWork(ldObjHandle);
// Open Boxes - register that we are using Positions
// and will be depositing Forces.
UniqueSetIter<TuplePatchElem> ap(tuplePatchList);
for (ap = ap.begin(); ap != ap.end(); ap++) {
ap->x = ap->positionBox->open();
ap->xExt = ap->p->getCompAtomExtInfo();
if ( ap->p->flags.doMolly ) ap->x_avg = ap->avgPositionBox->open();
ap->r = ap->forceBox->open();
ap->f = ap->r->f[Results::normal];
if (accelMDdoDihe) ap->af = ap->r->f[Results::amdf]; // for dihedral-only or dual-boost accelMD
}
BigReal reductionData[T::reductionDataSize];
int tupleCount = 0;
int numAtomTypes = T::pressureProfileAtomTypes;
int numAtomTypePairs = numAtomTypes*numAtomTypes;
for ( int i = 0; i < T::reductionDataSize; ++i ) reductionData[i] = 0;
if (pressureProfileData) {
memset(pressureProfileData, 0, 3*pressureProfileSlabs*numAtomTypePairs*sizeof(BigReal));
// Silly variable hiding of the previous iterator
UniqueSetIter<TuplePatchElem> newap(tuplePatchList);
newap = newap.begin();
const Lattice &lattice = newap->p->lattice;
T::pressureProfileThickness = lattice.c().z / pressureProfileSlabs;
T::pressureProfileMin = lattice.origin().z - 0.5*lattice.c().z;
}
if ( ! Node::Object()->simParameters->commOnly ) {
if ( doLoadTuples ) {
loadTuples();
doLoadTuples = false;
}
// take triplet and pass with tuple info to force eval
T *al = tupleList.begin();
const int ntuple = tupleList.size();
for (int i=0; i<ntuple; ++i) {
al[i].computeForce(reductionData, pressureProfileData);
}
tupleCount += ntuple;
}
LdbCoordinator::Object()->endWork(ldObjHandle);
T::submitReductionData(reductionData,reduction);
reduction->item(T::reductionChecksumLabel) += (BigReal)tupleCount;
reduction->submit();
if (pressureProfileReduction) {
// For ease of calculation we stored interactions between types
// i and j in (ni+j). For efficiency now we coalesce the
// cross interactions so that just i<=j are stored.
const int arraysize = 3*pressureProfileSlabs;
const BigReal *data = pressureProfileData;
for (int i=0; i<numAtomTypes; i++) {
for (int j=0; j<numAtomTypes; j++) {
int ii=i;
int jj=j;
if (ii > jj) { int tmp=ii; ii=jj; jj=tmp; }
const int reductionOffset =
(ii*numAtomTypes - (ii*(ii+1))/2 + jj)*arraysize;
for (int k=0; k<arraysize; k++) {
pressureProfileReduction->item(reductionOffset+k) += data[k];
}
data += arraysize;
}
}
pressureProfileReduction->submit();
}
// Close boxes - i.e. signal we are done with Positions and
// AtomProperties and that we are depositing Forces
for (ap = ap.begin(); ap != ap.end(); ap++) {
ap->positionBox->close(&(ap->x));
if ( ap->p->flags.doMolly ) ap->avgPositionBox->close(&(ap->x_avg));
ap->forceBox->close(&(ap->r));
}
}
};
#endif
| [
"[email protected]"
] | |
7d76b5b66e34a15ef4da672084f1d62ed9e95cda | 9804d481c4b819b8caf4566d9a6d66914475d6f7 | /algo/001_heap_sort.cpp | bd76a87c6e353909504e894119362bcc5994c94f | [] | no_license | ginigit/job_hunting | e479d673dc8353fbd31c6252fb162028bd9e69d2 | 12244fe960ce929e3fdd3743326e3fd74fdc108c | refs/heads/master | 2020-11-25T20:50:33.871063 | 2020-02-23T15:09:39 | 2020-02-23T15:09:39 | 228,839,833 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,419 | cpp |
/*
* 001.堆排序
* max_heapify: 对a[i]建堆: 在a[i]、a[left]、a[right]，找出最大者，交换a[i]和a[largest]
* 令i = largest，继续对a[i]建堆: 递归或非递归，直到a[i] >= a[left] 且 a[i] >= a[right]
* build_max_heap: 从后往前，依次对a[i]建堆，使数组任意节点均满足最大堆的性质
* heap_sort: 交换a[0]和a[len-1]，len=len-1，再对a[0]建堆
* 基本思路: 首先调整元素位置使之满足最大堆的性质，然后将堆首元素(最大值)移动到堆尾
* 时间复杂度粗略计算:
* T.max_heapify = 完全二叉树，沿根至叶子的简单路径下溯 = O(logn)
* T.build_max_heap = n/2 * T.max_heapify = O(nlogn)
* T.heap_sort = T.build_max_heap + n * T.max_heapify = O(nlogn)
* 时间复杂度精细计算:
* T.max_heapify = O(logn)
* T.build_max_heap = 1*(h-1) + 2*(h-2) + 4*(h-3) + ... + 2^(h-2)*1 + 2^(h-1)*0 = O(n)
* T.heap_sort = 2^(h-1)*(h-1) + 2^(h-2)*(h-2) + ... + 2*1 + 1*0 = O(nlogn)
* 空间复杂度:
* S.heap_sort = O(1)
*/
#include <vector>
using namespace std;
void max_heapify(vector<int>& vec, int i, int end)
{
int largest = i;
int left = 2 * i + 1;
if (left <= end && vec[largest] < vec[left])
{
largest = left;
}
int right = left + 1;
if (right <= end && vec[largest] < vec[right])
{
largest = right;
}
if (largest != i)
{
std::swap(vec[i], vec[largest]);
i = largest;
max_heapify(vec, i, end);
}
}
void max_heapify_non_recursive(vector<int>& vec, int i, int end)
{
int left = 2 * i + 1;
while (left <= end)
{
int largest = i;
if (vec[largest] < vec[left])
{
largest = left;
}
int right = left + 1;
if (right <= end && vec[largest] < vec[right])
{
largest = right;
}
if (largest == i)
{
break;
}
std::swap(vec[i], vec[largest]);
i = largest;
left = 2 * i + 1;
}
}
void build_max_heap(vector<int>& vec, int len)
{
for (int i = len / 2 - 1; i >= 0; --i)
{
max_heapify(vec, i, len - 1);
}
}
void heap_sort(vector<int>& vec, int len)
{
build_max_heap(vec, len);
for (int i = len - 1; i > 0; --i)
{
std::swap(vec[0], vec[i]);
max_heapify(vec, 0, i - 1);
}
}
| [
"[email protected]"
] | |
2e315460f8e4f8d60d776200ec23402f8b98b05d | 5ed2c620083bfdacd3a2cd69e68401f6e4519152 | /Algorithms/POJ/p1045/p1045/Source.cpp | 0e6b7e169fd850778b27c85e5a49db4b8498a5be | [] | no_license | plinx/CodePractices | 03a4179a8bbb9653a40faf683676bc884b72bf75 | 966af4bf2bd5e69d7e5cfbe8ed67c13addcb61b9 | refs/heads/master | 2021-01-01T05:40:02.159404 | 2015-08-30T20:16:44 | 2015-08-30T20:16:44 | 33,318,262 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 785 | cpp | #include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;
int main()
{
float Vs, R, C;
int num;
float w;
cin >> Vs >> R >> C >> num;
for (int i = 0; i < num; i++)
{
cin >> w;
cout << fixed << setprecision(3) << Vs * R * C * w * sqrt(1 / (R*R * C*C * w*w + 1)) << endl;
}
return 0;
}
/*
V1 = Vs*cos(wt), V2 = Vr*cos(wt+q)
V2 = i*R = R*C* d(V1-V2)/dt
=> Vr*cos(wt+q) = R*C* d(V1-V2)/dt
d(cos(wt))/dt = -w * sin(wt)
=> Vr*cos(wt+q) = R*C*w (Vr*sin(wt+q) - Vs*sin(wt))
let wt+q = 0 (wt = -q)
=> Vr = R*C*w*Vs*sin(q)
let wt = 0
=> Vr*cos(q) = R*C*w*Vr*sin(q)
cot(q) = R*C*w
cos^2(q)/sin^2(q) = (R*C*w)^2
cos^2(q)/sin^2(q) + 1 = (R*C*w)^2 + 1
=> 1/sin^2(q) = (R*C*w)^2 + 1
=> sin(q) = sqrt(1/((R*C*w)^2 +1 ))
=> Vr = R*C*w*Vs* sqrt(1/((R*C*w)^2 + 1))
*/
| [
"[email protected]"
] | |
03d04c3987777ab663f05418ab1a282f701648e8 | fe5fc3924369302457db912d6751e3fe37691074 | /src/train.h | 410e3931e650ecda842cf1a0fb78810662da6fbb | [] | no_license | nyBball/Silhouette-based-Skeleton-tracking | 3f2afdd8bbe2f8e8c104fcf9e2e266be2cdfccc3 | 59ffd6ffa330b1ba6b0a7e50181c165e8221b20a | refs/heads/master | 2021-09-08T12:13:34.447204 | 2018-03-09T14:28:48 | 2018-03-09T14:28:48 | 108,844,123 | 3 | 3 | null | null | null | null | GB18030 | C++ | false | false | 13,948 | h | //random fern training algorithm
#ifndef RF_TRAIN
#define RF_TRAIN
#include "sample.h"
extern char DataPath[300];
namespace random_ferns
{
const int random_fern_T = 10;
const int random_fern_K = 200;
const float random_fern_beta = 1000.0f;
template<typename Sample>
class RFTrain
{
public:
vector<Sample> samples_;
vector<vector<RFSampleVecNode>> sample_vectors_;
vector<vector<vector<ohday::Vector2f>>> fern_feature_indices_;
vector<vector<vector<float>>> fern_feature_threshold_;
vector<vector<vector<ohday::VectorNf>>> forward_function_;
public:
RFTrain()
{
sample_vectors_.resize(random_fern_T);
fern_feature_indices_.resize(random_fern_T);
fern_feature_threshold_.resize(random_fern_T);
forward_function_.resize(random_fern_T);
for (int i_t = 0; i_t < random_fern_T; i_t++)
{
fern_feature_indices_[i_t].resize(random_fern_K);
fern_feature_threshold_[i_t].resize(random_fern_K);
forward_function_[i_t].resize(random_fern_K);
for (int i_k = 0; i_k < random_fern_K; i_k++)
{
fern_feature_indices_[i_t][i_k].resize(random_fern_Q);
fern_feature_threshold_[i_t][i_k].resize(random_fern_Q);
int num_status = pow(float(2), random_fern_Q);
forward_function_[i_t][i_k].resize(num_status);
}
}
}
~RFTrain()
{
}
virtual void SetSamples()
{
}
virtual vector<RFSampleVecNode>GenerateRandomVector()
{
vector<RFSampleVecNode> t;
return t;
}
void Train(char* ImgFolder, char* ImgType)
{
int num_status = pow(float(2), random_fern_Q);
vector<int> status_omega;
status_omega.resize(num_status);
vector<ohday::VectorNf> status_param_delta;
status_param_delta.resize(num_status);
int numParams = samples_[0].initial_params_.params_.dims;//length of regression target parameters
for (int i = 0; i < num_status; i++)
{
status_param_delta[i].resize(numParams);//32*42
}
for (int i_t = 0; i_t < random_fern_T; i_t++)
{
for (int i_k = 0; i_k < random_fern_K; i_k++)
{
int num_status = pow(float(2), random_fern_Q);
forward_function_[i_t][i_k].resize(num_status);
for (int i_status = 0; i_status < num_status; i_status++)
{
forward_function_[i_t][i_k][i_status].resize(numParams);
}
}
}
cv::Mat img;
//outer layer
for (int i_t = 0; i_t < random_fern_T; i_t++)
{
printf("T %d begins...\n", i_t);
// 1. Generate random 3D vectors
sample_vectors_[i_t] = GenerateRandomVector();//随机产生了每个joint的偏移量
// 2. Sampling
int numSample = samples_.size();//sample指train文件夹里的样本
int current_index = -1;
for (int i_s = 0; i_s < numSample; i_s++)
{
if (samples_[i_s].destination_index_ != current_index)
{
current_index = samples_[i_s].destination_index_;//train里的下标
char image_name[300];
strcpy_s(image_name, ImgFolder);
char idx_name[100];
sprintf_s(idx_name, "/%d", current_index);
strcat_s(image_name, idx_name);
strcat_s(image_name, ImgType);
img.release();
img = cv::imread(image_name, CV_LOAD_IMAGE_GRAYSCALE | CV_LOAD_IMAGE_ANYDEPTH);
}
samples_[i_s].Sampling(img, sample_vectors_[i_t]);//对每个剪影及随机产生的joint偏移量进行采样，numSample个sample共用一个偏移
SET_FONT_YELLOW;
printf("Sampling of NO.%d out of %d samples. t = %d .\n", i_s + 1, numSample, i_t);
SET_FONT_WHITE;
}
printf("Sampling done\n");
// 3. Calculate cov paras
//a. get feature_map
int numFeature = samples_[0].features_.size();
vector<ohday::VectorNf> feature_map;
feature_map.resize(numFeature);
for (int i_p = 0; i_p < numFeature; i_p++)
{
feature_map[i_p] = ohday::VectorNf(numSample);
for (int i_s = 0; i_s < numSample; i_s++)
{
feature_map[i_p][i_s] = samples_[i_s].features_[i_p];
}
}
printf("Got feature map\n");
// b. count feature cov and para(a.variance() + b.variance() - 2*cov(a,b))
vector<float> feature_variance;
vector<vector<float>> feature_para;
feature_variance.resize(numFeature);
feature_para.resize(numFeature);
//#pragma omp parallel for
for (int i_p = 0; i_p < numFeature; i_p++)
{
feature_variance[i_p] = feature_map[i_p].variance();
}
printf("Got feature variance\n");
//#pragma omp parallel for
for (int i_p = 0; i_p < numFeature - 1; i_p++)
{
feature_para[i_p].resize(numFeature);
for (int j_p = i_p + 1; j_p < numFeature; j_p++)
{
feature_para[i_p][j_p] = feature_variance[i_p] + feature_variance[j_p] - 2 * feature_map[i_p].cov(feature_map[j_p]);
}
}
printf("Got feature cov\n");
// 4. inner loop
ohday::RandomDevice random_device;
for (int i_k = 0; i_k < random_fern_K; i_k++)
{
printf("\tK %d begins\n", i_k);
for (int i_f = 0; i_f < random_fern_Q; i_f++)
{
// a. Generate random vector and project , get vector_Y
ohday::VectorNf random_Y = random_device.GetVectorN(numParams, -1, 1);
float y_length = random_Y.length();
ohday::VectorNf vector_Y(numSample);
//#pragma omp parallel for
for (int i_s = 0; i_s < numSample; i_s++)
{
ohday::VectorNf delta_param = samples_[i_s].GetParamDelta();
vector_Y[i_s] = delta_param.cross(random_Y) / y_length;//根据随机投影将42维降至一维
}
float variance_Y = vector_Y.variance();
// b. Calculate Y_cov
vector<float> Y_cov;
Y_cov.resize(numFeature);
//#pragma omp parallel for
for (int i_p = 0; i_p < numFeature; i_p++)
{
Y_cov[i_p] = feature_map[i_p].cov(vector_Y);//feature_map某一个特征的所有样本与随机投影后所有样本的cov
}
// c. Get fern feature_delta and threshold
int i_max = 0, j_max = 0;
float coff_max = -1000000.0f;
for (int i_p = 0; i_p < numFeature - 1; i_p++)
{
for (int j_p = i_p + 1; j_p < numFeature; j_p++)
{
bool is_calced = false;
for (int i_ff = 0; i_ff < random_fern_Q; i_ff++)
{
if (int(fern_feature_indices_[i_t][i_k][i_ff].x) == i_p && int(fern_feature_indices_[i_t][i_k][i_ff].y) == j_p)
{
is_calced = true;
break;
}
}
if (is_calced)
continue;
float f_numerator = Y_cov[i_p] - Y_cov[j_p];
float f_denominator = sqrt(feature_para[i_p][j_p] * variance_Y);
float f_fraction = 0.0f;
if (f_denominator != 0.0f)
f_fraction = f_numerator / f_denominator;
if (f_fraction > coff_max)
{
coff_max = f_fraction;
i_max = i_p;
j_max = j_p;
}
}
}//至此选出了两个维度特征表示所有的特征，最大化与delta_param的关系
float min_delta_feature = 1000000.0f;
float max_delta_feature = -1000000.0f;
for (int i_s = 0; i_s < samples_.size(); i_s++)
{
float current_delta_feature = samples_[i_s].features_[i_max] - samples_[i_s].features_[j_max];
if (current_delta_feature > max_delta_feature)
max_delta_feature = current_delta_feature;
if (current_delta_feature < min_delta_feature)
min_delta_feature = current_delta_feature;//选出了所有样本这两个维度特征的最大值和最小值
}
fern_feature_indices_[i_t][i_k][i_f] = ohday::Vector2f(i_max, j_max);// i_max, j_max是选出来的代表特征的系数
//CITE BY CHENG: Considering entropy decrease would be appropriate
fern_feature_threshold_[i_t][i_k][i_f] = random_device.GetFloatLine(min_delta_feature, max_delta_feature);
}
// d. Classify every samples using these ferns
for (int i_s = 0; i_s < samples_.size(); i_s++)
{
samples_[i_s].SetStatus(fern_feature_indices_[i_t][i_k], fern_feature_threshold_[i_t][i_k]);//将一个sample分类成5个0或1
}
// e. make statistics for each status and get forward function
for (int i_status = 0; i_status < num_status; i_status++)
{
status_omega[i_status] = 0;
for (int i_d = 0; i_d < numParams; i_d++)
status_param_delta[i_status][i_d] = 0.0f;
}
for (int i_s = 0; i_s < samples_.size(); i_s++)
{
int current_status = samples_[i_s].GetStatus();
status_omega[current_status] ++;
ohday::VectorNf current_param_delta = samples_[i_s].GetParamDelta();
for (int i_d = 0; i_d < numParams; i_d++)
{
status_param_delta[current_status][i_d] = status_param_delta[current_status][i_d] + current_param_delta[i_d];
}
}//所有样本_param_delta相加并归类到32个状态中的current_status中
for (int i_status = 0; i_status < num_status; i_status++)
{
if (status_omega[i_status] != 0)
{
float para = 1.0f / ((1 + random_fern_beta / status_omega[i_status]) * status_omega[i_status]);
for (int i_d = 0; i_d < numParams; i_d++)
{
forward_function_[i_t][i_k][i_status][i_d] = status_param_delta[i_status][i_d] * para;//Cao 2013 公式10
}
}
}
// f. samples update
for (int i_s = 0; i_s < samples_.size(); i_s++)
{
int current_status = samples_[i_s].GetStatus();
samples_[i_s].UpdateParam(forward_function_[i_t][i_k][current_status]);
}
}
}
}
void SaveResult(const char* file_name)
{
ofstream save_file(file_name);
//num outer layer
save_file << random_fern_T << endl;
//num inner layer
save_file << random_fern_K << endl;
//num of random fern bits
save_file << random_fern_Q << endl;
//num of sampling vectors
int numVec = sample_vectors_[0].size();
save_file << numVec << endl;
//num of params
int numParams = samples_[0].initial_params_.params_.dims;
save_file << numParams << endl;
// save sampling vector2f
for (int i_t = 0; i_t < random_fern_T; i_t++)
{
for (int i_v = 0; i_v < sample_vectors_[i_t].size(); i_v++)
{
save_file << sample_vectors_[i_t][i_v].index << ' ' << sample_vectors_[i_t][i_v].angle << ' ';
}
save_file << endl;
}
save_file << endl;
// save useful delta_feature and fern thread int each loop
for (int i_t = 0; i_t < random_fern_T; i_t++)
{
for (int i_k = 0; i_k < random_fern_K; i_k++)
{
for (int i_f = 0; i_f < random_fern_Q; i_f++)
{
save_file << int(fern_feature_indices_[i_t][i_k][i_f].x) << ' ' << int(fern_feature_indices_[i_t][i_k][i_f].y) << ' ' << fern_feature_threshold_[i_t][i_k][i_f] << ' ';
}
}
save_file << endl;
}
save_file << endl;
// save useful forward_fuction for each status int each loop
for (int i_t = 0; i_t < random_fern_T; i_t++)
{
for (int i_k = 0; i_k < random_fern_K; i_k++)
{
for (int i_status = 0; i_status < int(pow(2.0, random_fern_Q)); i_status++)
{
for (int i_d = 0; i_d < numParams; i_d++)
{
save_file << forward_function_[i_t][i_k][i_status][i_d] << ' ';
}
}
}
save_file << endl;
}
save_file << endl;
save_file.close();
}
};
/*-----------------Specified Task-------------------*/
class RFTrainBodyJoints :public RFTrain<RFSample_BodyJoints>
{
public:
RFTrainBodyJoints()
{
numIni_ = 6; //modify this!!!
}
~RFTrainBodyJoints()
{
}
public:
int numIni_;
virtual void SetSamples()
{
//load samples'indices
char samplePath[300];
strcpy_s(samplePath, DataPath);
strcat_s(samplePath, "record.txt");
ifstream ifs(samplePath);
//number of training data
int num_data;
ifs >> num_data;
//indices for training data
vector<int> indices_data;
for (int i = 0; i<num_data; i++)
{
int tmp_index;
ifs >> tmp_index;
indices_data.push_back(tmp_index);
}
ifs.close();
//for every training data, load its initial joints for constrcting training pair
for (int i = 0; i < num_data; i++)//num_data,测试画图时更改
{
//load destination parameters
RFSample_BodyJoints new_sample;
char pose_name[300];
strcpy_s(pose_name, DataPath);
char tmp[100];
sprintf_s(tmp, "Train/%d.txt", indices_data[i]);
strcat_s(pose_name, tmp);
new_sample.destination_index_ = indices_data[i];
new_sample.destination_params_.Read(pose_name);
new_sample.destination_params_.Joints2Param();
ohday::RandomDevice rd;
for (int j = 0; j<numIni_; j++)
{
char ini_pose_name[300];
strcpy_s(ini_pose_name, DataPath);
char tmp[100];
sprintf_s(tmp, "Train/%d_%d.txt", indices_data[i], j + 1);
strcat_s(ini_pose_name, tmp);
new_sample.initial_index_ = 0; //no use here
new_sample.initial_params_.Read(ini_pose_name);
new_sample.initial_params_.Joints2Param();
new_sample.current_params_ = new_sample.initial_params_;
samples_.push_back(new_sample);
}
SET_FONT_YELLOW;
printf("Get %d samples\n", samples_.size());
SET_FONT_WHITE;
}
}
virtual vector<RFSampleVecNode>GenerateRandomVector()
{
//modified
char pathStandardSkeleton[300];
strcpy_s(pathStandardSkeleton, DataPath);
char tmp[100] = "Train/1.txt";//,标准骨架格式
strcat_s(pathStandardSkeleton, tmp);
ohday::RandomDevice random_device;
RFBodyJoints standard_joints;
standard_joints.Read(pathStandardSkeleton);
standard_joints.Joints2Param();
ohday::VectorNf standard_landmarks = standard_joints.Param2Landmarks();
//角度随机生成
int numVec = 200;
int numLandmarks = (standard_landmarks.dims) / 2;
ohday::VectorNf dir = random_device.GetVectorN(numVec, 0, 2 * ohday::ohday_pi);
vector<RFSampleVecNode>res;
res.resize(numVec);
for (int i = 0; i < numVec; i++)
{
res[i].angle = dir[i];
res[i].index = i%numLandmarks;
}
return res;
}
};
}
#endif //RF_TRAIN | [
"[email protected]"
] | |
573c43fc69477d3c74eb78f09a6b97617244a843 | 5a60d60fca2c2b8b44d602aca7016afb625bc628 | /aws-cpp-sdk-waf-regional/include/aws/waf-regional/model/ListTagsForResourceResult.h | 2d257a08956fecbcdcbb33d586d48052035a5ff0 | [
"Apache-2.0",
"MIT",
"JSON"
] | permissive | yuatpocketgems/aws-sdk-cpp | afaa0bb91b75082b63236cfc0126225c12771ed0 | a0dcbc69c6000577ff0e8171de998ccdc2159c88 | refs/heads/master | 2023-01-23T10:03:50.077672 | 2023-01-04T22:42:53 | 2023-01-04T22:42:53 | 134,497,260 | 0 | 1 | null | 2018-05-23T01:47:14 | 2018-05-23T01:47:14 | null | UTF-8 | C++ | false | false | 2,677 | h | /**
* Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
* SPDX-License-Identifier: Apache-2.0.
*/
#pragma once
#include <aws/waf-regional/WAFRegional_EXPORTS.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/waf-regional/model/TagInfoForResource.h>
#include <utility>
namespace Aws
{
template<typename RESULT_TYPE>
class AmazonWebServiceResult;
namespace Utils
{
namespace Json
{
class JsonValue;
} // namespace Json
} // namespace Utils
namespace WAFRegional
{
namespace Model
{
class ListTagsForResourceResult
{
public:
AWS_WAFREGIONAL_API ListTagsForResourceResult();
AWS_WAFREGIONAL_API ListTagsForResourceResult(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
AWS_WAFREGIONAL_API ListTagsForResourceResult& operator=(const Aws::AmazonWebServiceResult<Aws::Utils::Json::JsonValue>& result);
/**
* <p/>
*/
inline const Aws::String& GetNextMarker() const{ return m_nextMarker; }
/**
* <p/>
*/
inline void SetNextMarker(const Aws::String& value) { m_nextMarker = value; }
/**
* <p/>
*/
inline void SetNextMarker(Aws::String&& value) { m_nextMarker = std::move(value); }
/**
* <p/>
*/
inline void SetNextMarker(const char* value) { m_nextMarker.assign(value); }
/**
* <p/>
*/
inline ListTagsForResourceResult& WithNextMarker(const Aws::String& value) { SetNextMarker(value); return *this;}
/**
* <p/>
*/
inline ListTagsForResourceResult& WithNextMarker(Aws::String&& value) { SetNextMarker(std::move(value)); return *this;}
/**
* <p/>
*/
inline ListTagsForResourceResult& WithNextMarker(const char* value) { SetNextMarker(value); return *this;}
/**
* <p/>
*/
inline const TagInfoForResource& GetTagInfoForResource() const{ return m_tagInfoForResource; }
/**
* <p/>
*/
inline void SetTagInfoForResource(const TagInfoForResource& value) { m_tagInfoForResource = value; }
/**
* <p/>
*/
inline void SetTagInfoForResource(TagInfoForResource&& value) { m_tagInfoForResource = std::move(value); }
/**
* <p/>
*/
inline ListTagsForResourceResult& WithTagInfoForResource(const TagInfoForResource& value) { SetTagInfoForResource(value); return *this;}
/**
* <p/>
*/
inline ListTagsForResourceResult& WithTagInfoForResource(TagInfoForResource&& value) { SetTagInfoForResource(std::move(value)); return *this;}
private:
Aws::String m_nextMarker;
TagInfoForResource m_tagInfoForResource;
};
} // namespace Model
} // namespace WAFRegional
} // namespace Aws
| [
"[email protected]"
] | |
7476dd655f6da044512926d177dd53b3cadaf965 | 27c0eb9959ab2444aed7f36135fa283b2d53056b | /Tools/src/RobotCtrl/src/ListCtrlEx.cpp | 1a8cd1ca485687d575521ee5776319e4d13b9d07 | [] | no_license | zhanglq79/GameLib | 0fc2e017b0d38eaadb2ef94e659e4493d94ab3b2 | b2f08b909d112b2f4a57ff40c357f6b7b5ec379f | refs/heads/master | 2021-06-17T06:34:06.868057 | 2017-06-05T05:25:17 | 2017-06-05T05:25:17 | null | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 1,125 | cpp | // E:\GitHub\GameLib\Tools\src\RobotCtrl\src\ListCtrlEx.cpp : 实现文件
//
#include "stdafx.h"
#include "RobotCtrl.h"
#include "ListBoxEx.h"
#include "DlgRobotCtrl.h"
// CListCtrlEx
IMPLEMENT_DYNAMIC(CListBoxEx, CListBox)
CListBoxEx::CListBoxEx()
{
}
CListBoxEx::~CListBoxEx()
{
}
BEGIN_MESSAGE_MAP(CListBoxEx, CListBox)
ON_WM_RBUTTONDOWN()
END_MESSAGE_MAP()
// CListCtrlEx 消息处理程序
void CListBoxEx::OnRButtonDown(UINT nFlags, CPoint point)
{
POINT pt;
GetCursorPos(&pt);
int nCount = GetCount();
ScreenToClient(&pt);
//实现右键点击选中目标
for (int i = 0; i < nCount; i++)
{
CRect rc;
GetItemRect(i, &rc);
if (rc.PtInRect(pt))
{
SetCurSel(i);
CMenu temp, *pSubMenu;
temp.LoadMenu(IDR_MENU_ROBOT_SERVER);
pSubMenu = temp.GetSubMenu(0);
ClientToScreen(&pt);
pSubMenu->TrackPopupMenu(TPM_LEFTALIGN | TPM_LEFTBUTTON | TPM_RIGHTBUTTON, pt.x, pt.y, GetParent());
CDlgRobotCtrl* pDlg = dynamic_cast<CDlgRobotCtrl*>(GetParent());
if (pDlg)
{
pDlg->OnSelchangeListCtrlServer();
}
break;
}
}
CListBox::OnRButtonDown(nFlags, point);
} | [
"[email protected]"
] | |
d067193cbcf01da0ec49ac77dde78482108ce571 | 5d6d9b2f1192b214b23e745a96e69e6d80bae1d3 | /Grokking the Coding Interview/TreeDepthFirstSearch/Tree-Diameter.cpp | cc4e4b1bf48ec0a68161cf0d63b0d135710fc808 | [] | no_license | sunyw99/Educative | 3b137f6e28ef3a8ae68b817871d1ab1077f832e0 | c4038b19154154e131f6af1b75ab8be35e8579b9 | refs/heads/main | 2023-08-01T04:25:05.721302 | 2021-09-23T17:39:10 | 2021-09-23T17:39:10 | 407,059,034 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,636 | cpp | using namespace std;
#include <algorithm>
#include <iostream>
#include <vector>
class TreeNode {
public:
int val = 0;
TreeNode* left;
TreeNode* right;
TreeNode(int x) {
val = x;
left = right = nullptr;
}
};
class TreeDiameter {
public:
static int findDiameter(TreeNode* root) {
int treeDiameter = 0;
// TODO: Write your code here
currentHeight(root, treeDiameter);
return treeDiameter;
}
private:
static int currentHeight(TreeNode* root, int& treeDiameter) {
if (root == nullptr)
return 0;
int leftHeight = currentHeight(root->left, treeDiameter);
int rightHeight = currentHeight(root->right, treeDiameter);
if (leftHeight != 0 && rightHeight != 0) {
treeDiameter = max(treeDiameter, leftHeight + rightHeight + 1);
}
return max(leftHeight, rightHeight) + 1;
}
};
int main(int argc, char* argv[]) {
TreeNode* root = new TreeNode(1);
root->left = new TreeNode(2);
root->right = new TreeNode(3);
root->left->left = new TreeNode(4);
root->right->left = new TreeNode(5);
root->right->right = new TreeNode(6);
cout << "Tree Diameter: " << TreeDiameter::findDiameter(root) << endl;
root->left->left = nullptr;
root->right->left->left = new TreeNode(7);
root->right->left->right = new TreeNode(8);
root->right->right->left = new TreeNode(9);
root->right->left->right->left = new TreeNode(10);
root->right->right->left->left = new TreeNode(11);
cout << "Tree Diameter: " << TreeDiameter::findDiameter(root) << endl;
}
| [
"[email protected]"
] | |
ed157beeb7cd45497307c9a80c1bcef8ea7be156 | b36762050a703bb8f3bf90e7aed3b81fc8097352 | /src/leveldb/helpers/memenv/memenv_test.cc | 1fe0a1c49544c73bd8a09260137332f2c23c3709 | [] | no_license | stevekimdev1/CENTERCOIN | 151fbfd01266b9c1cd9d48e4561ee03ba239a98c | ab16868615f19117a502c7bf54c2e4884a6870e6 | refs/heads/master | 2022-10-21T16:48:02.460944 | 2022-10-07T09:25:53 | 2022-10-07T09:25:53 | 149,549,401 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 129 | cc | version https://git-lfs.github.com/spec/v1
oid sha256:a069e253d6eefc55913895ff28e3e2ba50d427bd6051224fe7435061837512a4
size 6868
| [
"[email protected]"
] | |
f4b309120bdf092bb23d05769363b8ead3ba7c52 | ddc2bfc3e1d587ceef787a861dc69a929132cb2e | /cp/TFCMNT.CP | 33d5fc44b41bfe17a65ae75cc4c8088a7e5d1d74 | [] | no_license | bigwood177/smcSource | d01f46418e571486fc76b03894e2ff084e95d36d | 35c7250973a93a6e30498dd87cb805762bc91528 | refs/heads/master | 2023-03-15T10:08:52.898056 | 2021-03-10T12:50:43 | 2021-03-10T12:50:43 | 283,564,655 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,397 | cp | ;TFCMNT.CP
; COP TABLE MAINTENANCE
; QUOTE EX. PC DESCRIPTIONS
;
RECORD COPTBL
.INCLUDE 'DEF:RD182A.DEF'
RECORD CHANNEL
CHN182 ,D2
RECORD PRINT
TITLE ,A*, 'QE PC DESCRIPTIONS'
HD ,A6, 'NO HDR'
LG ,A9, 'NO LEGEND'
PLINE ,A80
PRNTON ,D1
LINCNT ,D2,60
PGCNT ,D6
LPSW ,D2
SPLFIL ,A14
RPTNUM ,D3
PRTTYP ,A1
PRTCTL ,D3,080
LPARG ,D1
PRNTSW ,D1
PRTCTR ,D1
RECORD HD1
,A*, ' PC DESCRIPTION '
RECORD VARS
ALPHA ,A12
OPNOK ,D1
BLANKS ,A30
PC ,D2
DESC ,A30
LOC ,A20
ST_DPT ,D2
EN_DPT ,D2
PGM ,D1
ROW ,D2
ENTRY ,A30
INXCTL ,D1
READ ,D1,0
WRITE ,D1,1
STORE ,D1,2
DELETE ,D1,3
LOKCTL ,D1
WHATNO ,D2
SELECT ,D1
CNGCTL ,D1
I ,D3
SWITCH ,D1
V ,D1
PROC
XCALL TERID (V)
XCALL OUTPT (1,1,2,'QE PC DESCRIPTIONS',1)
CALL OPENS
IF (.NOT. OPNOK) GOTO CLOSE
MENU,
XCALL OUTPT (1,1,2,'QE PC DESCRIPTIONS',1)
XCALL OUTPT (3,9,0,'PLEASE SELECT APPLICATION',1)
XCALL OUTPT (5,15,0,'1. TABLE MAINTENANCE',1)
XCALL OUTPT (6,15,0,'2. PRINT TABLE',1)
MINPUT,
XCALL INPUT (3,36,1,1,'#E',ENTRY,INXCTL,1)
GOTO (MINPUT,ENDOFF), INXCTL
PGM = ENTRY(1,1)
GOTO (DISPLA,PRINT_TABLE),PGM
GOTO MINPUT
DISPLA,
CLEAR CNGCTL
XCALL OUTPT (1,1,2,'QE PC DESCRIPTIONS',1)
XCALL OUTPT ( 4,4,0,'1. PC #',1)
XCALL OUTPT ( 6,4,0,'2. DESCRIPTION',1)
PC,
XCALL INPUT (4,24,02,00,'#E',ENTRY,INXCTL,1)
GOTO (DISPLA,MENU),INXCTL
PC = ENTRY(1,2)
CLEAR TBL_KEY
TBL_KEY(1,2) = 'FC'
FC_PC = PC
XCALL ISIO (CHN182,COPTBL,TBL_KEY,READ,LOKCTL)
IF (LOKCTL .EQ. 0)
BEGIN
SELECT = 2
CALL DSPREC
GOTO ANYCNG
END
SELECT = 1 ;ADD MODE
CLEAR COPTBL
FC_PC = PC
DESC,
XCALL INPUT (6,24,30,00,'AE',ENTRY,INXCTL,1)
GOTO (DISPLA,MENU),INXCTL
FC_DESC = ENTRY(1,30)
GOTO (ANYCNG),CNGCTL
ANYCNG,
XCALL OUTPT (24,1,1,'FIELD # TO CHANGE <TAB> = DELETE',1)
XCALL INPUT (24,20,02,00,'#T',ENTRY,INXCTL,1)
IF (INXCTL .EQ. 3)
BEGIN
XCALL OUTPT (24,1,1,'DELETE, ARE YOU SURE ?',1)
XCALL INPUT (24,24,01,01,'YN',ENTRY,INXCTL,1)
GOTO (ANYCNG),INXCTL-1
XCALL ISIO (CHN182,COPTBL,TBL_KEY,DELETE,LOKCTL)
GOTO DISPLA
END
WHATNO = ENTRY(1,2)
IF (WHATNO .EQ. 0)
THEN CLEAR CNGCTL
ELSE CNGCTL = 1
GOTO (PROCES,CNGBR),CNGCTL+1
CNGBR,
GOTO (PC, DESC),WHATNO
GOTO ANYCNG
PROCES,
CASE SELECT OF
BEGINCASE
1: BEGIN
TBLCOD = 'FC'
FC_PC = PC
XCALL ISIO (CHN182,COPTBL,TBL_KEY,STORE,LOKCTL)
END
2: XCALL ISIO (CHN182,COPTBL,TBL_KEY,WRITE,LOKCTL)
ENDCASE
GOTO DISPLA
ENDOFF,
CALL CLOSE
XCALL PGCHN ('CP:TBLMNU',1)
STOP
DSPREC, ;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; DISPLAY RECORD
;;;;;;;;;;;;;;;;;;;;;;;;;;;;
XCALL OUTPT (4,24,1,FC_PC,1)
XCALL OUTPT (6,24,1,FC_DESC,1)
RETURN
;-----------------------------------
;===================================================================
PRINT_TABLE,
;===================================================================
LINCNT = 66
PGCNT = 0
PDISP,
CNGCTL =
XCALL OUTPT (1,1,2,'PRINT WORK ORDER DEPARTMENTS TABLE',1)
XCALL OUTPT (4,4,0,'1. STARTING PC',1)
XCALL OUTPT (6,4,0,'2. ENDING PC',1)
ST_DPT,
XCALL INPUT (4,27,02,00,'#E',ENTRY,INXCTL,1)
GOTO (PDISP,PDONE),INXCTL
ST_DPT = ENTRY(1,2)
IF (ST_DPT .EQ. 0)
BEGIN
EN_DPT = 99
XCALL OUTPT (4,25,1,'ALL',1)
XCALL OUTPT (6,25,1,' ',1)
GOTO P_ANY
END
GOTO (P_ANY),CNGCTL
EN_DPT,
XCALL INPUT (6,25,02,00,'# ',ENTRY,INXCTL,1)
GOTO (PDISP),INXCTL
EN_DPT = ENTRY(1,2)
IF (EN_DPT .EQ. 0)
BEGIN
EN_DPT = ST_DPT
ENTRY(1,2) = EN_DPT, 'ZX'
XCALL OUTPT (6,25,0,ENTRY(1,2),1)
END
P_ANY,
XCALL ANYCN(CNGCTL,WHATNO)
GOTO (P_PRINT,P_CNGBR),CNGCTL + 1
P_CNGBR,
GOTO (ST_DPT,EN_DPT),WHATNO
GOTO P_ANY
P_PRINT,
CLEAR TBL_KEY
TBLCOD = 'FC'
FC_PC = ST_DPT
FIND (CHN182,COPTBL,TBL_KEY)[ERR=PLOOP]
PLOOP,
XCALL IOS (CHN182,COPTBL,READ,LOKCTL)
IF (LOKCTL .NE. 0) GOTO EOF
IF (TBLCOD .NE. 'FC') GOTO EOF
IF (FC_PC .LT. ST_DPT) GOTO PLOOP
IF (FC_PC .GT. EN_DPT) GOTO EOF
PLINE (2,3) = TBLKEY(1,2) ;FC_PC
PLINE (7,36) = FC_DESC
; PC DESCRIPTION
; AA AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
;123456789012345678901234567890123456789012345678901234567890
; 1 2 3 4 5
CALL PRINT
GOTO PLOOP
EOF,
IF (PRNTON.EQ.1) XCALL LPOFF(LPSW,SPLFIL,PGCNT)
PRNTON = 0
PDONE,
GOTO MENU
PRINT, ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
IF (PRNTON .EQ. 0) CALL PRNTON
XCALL LPOUT(LINCNT,PGCNT,PLINE,TITLE,HD1,HD,HD
& ,LG,LG,LG,0,080,PRTCTL,0,LPSW,RPTNUM,PRTTYP)
RETURN
;-------------------------------------------------------------
PRNTON,
SPLFIL (5,6) = 'EF'
LPSW = 1 ;PRINT,SPOOL, OR DISPLAY
XCALL LPON (LPSW,SPLFIL)
IF (LPSW.EQ.0) GOTO ENDOFF
LPARG = 2
IF (LPSW.EQ.2) LPARG = 4
XCALL WATE (LPARG,V)
PRNTON = 1
RETURN
;-------------------------------------------------------------
;===================================================================
OPENS, ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
CLEAR OPNOK
SWITCH = 5
XCALL FILES (1,'SU',182,SWITCH)
IF (SWITCH .EQ. 9) RETURN
CHN182 = 1
OPNOK = 1
RETURN
;----------------------------------------------------
CLOSE,
CLOSE CHN182
RETURN
;----------------------------------------------------
| [
"[email protected]"
] | |
e6b75c315887c3222ebfc04cb283d07512700e20 | d6b4bdf418ae6ab89b721a79f198de812311c783 | /emr/include/tencentcloud/emr/v20190103/model/DescribeInstancesListRequest.h | ca762155c9f1cb760cf8cab708622847912e0e87 | [
"Apache-2.0"
] | permissive | TencentCloud/tencentcloud-sdk-cpp-intl-en | d0781d461e84eb81775c2145bacae13084561c15 | d403a6b1cf3456322bbdfb462b63e77b1e71f3dc | refs/heads/master | 2023-08-21T12:29:54.125071 | 2023-08-21T01:12:39 | 2023-08-21T01:12:39 | 277,769,407 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 10,604 | h | /*
* Copyright (c) 2017-2019 THL A29 Limited, a Tencent company. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef TENCENTCLOUD_EMR_V20190103_MODEL_DESCRIBEINSTANCESLISTREQUEST_H_
#define TENCENTCLOUD_EMR_V20190103_MODEL_DESCRIBEINSTANCESLISTREQUEST_H_
#include <string>
#include <vector>
#include <map>
#include <tencentcloud/core/AbstractModel.h>
#include <tencentcloud/emr/v20190103/model/Filters.h>
namespace TencentCloud
{
namespace Emr
{
namespace V20190103
{
namespace Model
{
/**
* DescribeInstancesList request structure.
*/
class DescribeInstancesListRequest : public AbstractModel
{
public:
DescribeInstancesListRequest();
~DescribeInstancesListRequest() = default;
std::string ToJsonString() const;
/**
* 获取Cluster filtering policy. Valid values: <li>clusterList: Queries the list of clusters excluding terminated ones.</li><li>monitorManage: Queries the list of clusters excluding those terminated, under creation and not successfully created.</li><li>cloudHardwareManage/componentManage: Two reserved values, which have the same implications as those of `monitorManage`.</li>
* @return DisplayStrategy Cluster filtering policy. Valid values: <li>clusterList: Queries the list of clusters excluding terminated ones.</li><li>monitorManage: Queries the list of clusters excluding those terminated, under creation and not successfully created.</li><li>cloudHardwareManage/componentManage: Two reserved values, which have the same implications as those of `monitorManage`.</li>
*
*/
std::string GetDisplayStrategy() const;
/**
* 设置Cluster filtering policy. Valid values: <li>clusterList: Queries the list of clusters excluding terminated ones.</li><li>monitorManage: Queries the list of clusters excluding those terminated, under creation and not successfully created.</li><li>cloudHardwareManage/componentManage: Two reserved values, which have the same implications as those of `monitorManage`.</li>
* @param _displayStrategy Cluster filtering policy. Valid values: <li>clusterList: Queries the list of clusters excluding terminated ones.</li><li>monitorManage: Queries the list of clusters excluding those terminated, under creation and not successfully created.</li><li>cloudHardwareManage/componentManage: Two reserved values, which have the same implications as those of `monitorManage`.</li>
*
*/
void SetDisplayStrategy(const std::string& _displayStrategy);
/**
* 判断参数 DisplayStrategy 是否已赋值
* @return DisplayStrategy 是否已赋值
*
*/
bool DisplayStrategyHasBeenSet() const;
/**
* 获取Page number. Default value: `0`, indicating the first page.
* @return Offset Page number. Default value: `0`, indicating the first page.
*
*/
uint64_t GetOffset() const;
/**
* 设置Page number. Default value: `0`, indicating the first page.
* @param _offset Page number. Default value: `0`, indicating the first page.
*
*/
void SetOffset(const uint64_t& _offset);
/**
* 判断参数 Offset 是否已赋值
* @return Offset 是否已赋值
*
*/
bool OffsetHasBeenSet() const;
/**
* 获取Number of returned results per page. Default value: `10`; maximum value: `100`.
* @return Limit Number of returned results per page. Default value: `10`; maximum value: `100`.
*
*/
uint64_t GetLimit() const;
/**
* 设置Number of returned results per page. Default value: `10`; maximum value: `100`.
* @param _limit Number of returned results per page. Default value: `10`; maximum value: `100`.
*
*/
void SetLimit(const uint64_t& _limit);
/**
* 判断参数 Limit 是否已赋值
* @return Limit 是否已赋值
*
*/
bool LimitHasBeenSet() const;
/**
* 获取Sorting field. Valid values: <li>clusterId: Sorting by instance ID. </li><li>addTime: Sorting by instance creation time.</li><li>status: Sorting by instance status code.</li>
* @return OrderField Sorting field. Valid values: <li>clusterId: Sorting by instance ID. </li><li>addTime: Sorting by instance creation time.</li><li>status: Sorting by instance status code.</li>
*
*/
std::string GetOrderField() const;
/**
* 设置Sorting field. Valid values: <li>clusterId: Sorting by instance ID. </li><li>addTime: Sorting by instance creation time.</li><li>status: Sorting by instance status code.</li>
* @param _orderField Sorting field. Valid values: <li>clusterId: Sorting by instance ID. </li><li>addTime: Sorting by instance creation time.</li><li>status: Sorting by instance status code.</li>
*
*/
void SetOrderField(const std::string& _orderField);
/**
* 判断参数 OrderField 是否已赋值
* @return OrderField 是否已赋值
*
*/
bool OrderFieldHasBeenSet() const;
/**
* 获取Sort ascending or descending based on `OrderField`. Valid values:<li>0: Descending.</li><li>1: Ascending.</li>Default value: `0`.
* @return Asc Sort ascending or descending based on `OrderField`. Valid values:<li>0: Descending.</li><li>1: Ascending.</li>Default value: `0`.
*
*/
int64_t GetAsc() const;
/**
* 设置Sort ascending or descending based on `OrderField`. Valid values:<li>0: Descending.</li><li>1: Ascending.</li>Default value: `0`.
* @param _asc Sort ascending or descending based on `OrderField`. Valid values:<li>0: Descending.</li><li>1: Ascending.</li>Default value: `0`.
*
*/
void SetAsc(const int64_t& _asc);
/**
* 判断参数 Asc 是否已赋值
* @return Asc 是否已赋值
*
*/
bool AscHasBeenSet() const;
/**
* 获取Custom query
* @return Filters Custom query
*
*/
std::vector<Filters> GetFilters() const;
/**
* 设置Custom query
* @param _filters Custom query
*
*/
void SetFilters(const std::vector<Filters>& _filters);
/**
* 判断参数 Filters 是否已赋值
* @return Filters 是否已赋值
*
*/
bool FiltersHasBeenSet() const;
private:
/**
* Cluster filtering policy. Valid values: <li>clusterList: Queries the list of clusters excluding terminated ones.</li><li>monitorManage: Queries the list of clusters excluding those terminated, under creation and not successfully created.</li><li>cloudHardwareManage/componentManage: Two reserved values, which have the same implications as those of `monitorManage`.</li>
*/
std::string m_displayStrategy;
bool m_displayStrategyHasBeenSet;
/**
* Page number. Default value: `0`, indicating the first page.
*/
uint64_t m_offset;
bool m_offsetHasBeenSet;
/**
* Number of returned results per page. Default value: `10`; maximum value: `100`.
*/
uint64_t m_limit;
bool m_limitHasBeenSet;
/**
* Sorting field. Valid values: <li>clusterId: Sorting by instance ID. </li><li>addTime: Sorting by instance creation time.</li><li>status: Sorting by instance status code.</li>
*/
std::string m_orderField;
bool m_orderFieldHasBeenSet;
/**
* Sort ascending or descending based on `OrderField`. Valid values:<li>0: Descending.</li><li>1: Ascending.</li>Default value: `0`.
*/
int64_t m_asc;
bool m_ascHasBeenSet;
/**
* Custom query
*/
std::vector<Filters> m_filters;
bool m_filtersHasBeenSet;
};
}
}
}
}
#endif // !TENCENTCLOUD_EMR_V20190103_MODEL_DESCRIBEINSTANCESLISTREQUEST_H_
| [
"[email protected]"
] | |
03ccaa6bbe5551e9e2bbf878642fefdeecff9045 | 8162021ab7a31ca00f1c9d0431896f11d0a7be92 | /Code/solver/src/Sudoku.cpp | 45aa74d7dc67a380510493b9a3de40822136dfd2 | [] | no_license | Dwarf0/MySudoku | 145a489d75770cf8bcc087d00e12ac57a2816075 | 28fc152d2d830d1ffaab0aa6adb49801f09f3ffb | refs/heads/master | 2023-02-09T07:11:52.513973 | 2021-01-05T02:39:18 | 2021-01-05T02:39:18 | 318,874,876 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,687 | cpp | #include <QFile>
#include <QTextStream>
#include "Sudoku.h"
Sudoku::Sudoku()
{
_initMode = false;
for (int i = 0; i < SUDOKU_SIZE; ++i) {
for (int j = 0; j < SUDOKU_SIZE; ++j) {
_values[i][j] = new SudokuCell(i, j);
#ifdef _DEBUG
_solutionValues[i][j] = new SudokuCell(i, j);
#endif
}
}
}
Sudoku::Sudoku(const Sudoku * sudoku)
{
_initMode = false;
for (int i = 0; i < SUDOKU_SIZE; ++i) {
for (int j = 0; j < SUDOKU_SIZE; ++j) {
_values[i][j] = new SudokuCell(sudoku->_values[i][j]);
#ifdef _DEBUG
_solutionValues[i][j] = new SudokuCell(sudoku->_solutionValues[i][j]);
#endif
}
}
}
Sudoku::~Sudoku() {
for (int i = 0; i < SUDOKU_SIZE; ++i) {
for (int j = 0; j < SUDOKU_SIZE; ++j) {
delete _values[i][j];
#ifdef _DEBUG
delete _solutionValues[i][j];
#endif
}
}
}
Sudoku& Sudoku::operator=(const Sudoku& other)
{
for (int i = 0; i < SUDOKU_SIZE; ++i) {
for (int j = 0; j < SUDOKU_SIZE; ++j) {
if (other.isCellInitialValue(i, j)) {
setCellInitialValue(i, j, other.getCellValue(i, j));
} else {
setCellPossibleValues(i, j, other.getCellPossibleValues(i, j));
setCellValue(i, j, other.getCellValue(i, j));
}
}
}
return *this;
}
bool Sudoku::operator==(const Sudoku & other)
{
for (int i = 0; i < SUDOKU_SIZE; ++i) {
for (int j = 0; j < SUDOKU_SIZE; ++j) {
if (getCellValue(i, j) != other.getCellValue(i, j)) {
return false;
}
}
}
return true;
}
bool Sudoku::isFilled() const
{
for (int i = 0; i < SUDOKU_SIZE; ++i) {
for (int j = 0; j < SUDOKU_SIZE; ++j) {
if (getCellValue(i, j) == 0) {
return false;
}
}
}
return true;
}
bool Sudoku::isValid() const
{
for (int i = 0; i < SUDOKU_SIZE; ++i) {
for (int j = 0; j < SUDOKU_SIZE; ++j) {
if (!isCellValid(i, j)) {
return false;
}
}
}
return true;
}
bool Sudoku::isCellValid(int r, int c) const
{
return _values[r][c]->isValid();
}
void Sudoku::setCellValue(int r, int c, int val)
{
if (_initMode) {
_values[r][c]->setInitialValue(val);
}
else {
/// TODO : faire un chek de isInitialValue avant et mettre un warning si on tente de modifier une valeur initiale ?
_values[r][c]->setValue(val);
}
updateValidity();
}
void Sudoku::setCellPossibleValues(int r, int c, QSet<int> possibleValues)
{
if (!isCellInitialValue(r, c))
_values[r][c]->setPossibleValues(possibleValues);
else {
QString mess = QString("Cell at (%1,%2) holds initial value - Unable to set possible value.")
.arg(QString::number(r), QString::number(c));
qWarning(mess.toStdString().c_str());
}
#ifdef _DEBUG
checkForFilterError();
#endif
}
int Sudoku::loadFromCsv(QString csvPath)
{
// Check file existence
QFile csv(csvPath);
if (!csv.exists()) {
std::cout << "Sudoku loading error: csv file not found at " << csvPath.toStdString() << std::endl;
return 1;
}
csv.open(QFile::ReadOnly);
QTextStream textStream(&csv);
QString line;
int rowIndex = 0;
int values[SUDOKU_SIZE][SUDOKU_SIZE];
while (textStream.readLineInto(&line)) {
if (line.isEmpty()) {
continue;
}
// Check number of columns
QStringList splitted = line.split(";");
if (splitted.size() != SUDOKU_SIZE) {
std::cout
<< "Sudoku loading error: "
<< "wrong number of values at row " << rowIndex
<< " of csv file " << csvPath.toStdString()
<< std::endl;
csv.close();
reset();
return 2;
}
bool ok = true;
for (int colIndex = 0; colIndex < splitted.size(); ++colIndex) {
int val = splitted[colIndex].toInt(&ok);
// Check values
if (!ok || val < 0 || val > 9) {
std::cout
<< "Sudoku loading error: "
<< "csv value " << splitted[colIndex].toStdString()
<< " at row " << rowIndex
<< " of csv file " << csvPath.toStdString()
<< " could not be converted to int"
<< std::endl;
csv.close();
return 3;
}
values[rowIndex][colIndex] = val;
}
rowIndex++;
}
csv.close();
// here, csv is valid and its values are loaded in the variable "values"
reset();
enableInitMode();
for (int i = 0; i < SUDOKU_SIZE; ++i) {
for (int j = 0; j < SUDOKU_SIZE; ++j) {
setCellValue(i, j, values[i][j]);
}
}
disableInitMode();
updateValidity();
#ifdef _DEBUG
QString solution = csvPath.left(csvPath.lastIndexOf('.')) + "_solution.csv";
QFile csvSolution(solution);
csvSolution.open(QFile::ReadOnly);
QTextStream solTextStream(&csvSolution);
rowIndex = 0;
while (solTextStream.readLineInto(&line)) {
if (line.isEmpty()) {
continue;
}
bool ok = true;
QStringList splitted = line.split(";");
for (int colIndex = 0; colIndex < splitted.size(); ++colIndex) {
int val = splitted[colIndex].toInt(&ok);
_solutionValues[rowIndex][colIndex]->setInitialValue(val);
}
rowIndex++;
}
csvSolution.close();
#endif
return 0;
}
void Sudoku::autofill()
{
for (int i = 0; i < SUDOKU_SIZE; ++i) {
for (int j = 0; j < SUDOKU_SIZE; ++j) {
QSet<int> values = getCellPossibleValues(i, j);
if (values.size() == 1) {
setCellValue(i, j, *values.begin());
}
}
}
}
void Sudoku::reset()
{
for (int i = 0; i < SUDOKU_SIZE; ++i) {
for (int j = 0; j < SUDOKU_SIZE; ++j) {
_values[i][j]->reset();
}
}
}
void Sudoku::clean()
{
for (int i = 0; i < SUDOKU_SIZE; ++i) {
for (int j = 0; j < SUDOKU_SIZE; ++j) {
if (!_values[i][j]->isInitialValue())
setCellValue(i, j, 0);
}
}
}
void Sudoku::setCellInitialValue(int r, int c, int val)
{
_values[r][c]->setInitialValue(val);
}
void Sudoku::updateValidity()
{
for (int i_cell = 0; i_cell < SUDOKU_SIZE * SUDOKU_SIZE; ++i_cell) {
int row = i_cell / SUDOKU_SIZE;
int col = i_cell % SUDOKU_SIZE;
int value = getCellValue(row, col);
bool valid = true;
if (value == 0) {
continue;
}
for (int i = 0; i < SUDOKU_SIZE; ++i) {
bool alreadyOnRow = getCellValue(row, i) == value && i != col;
bool alreadyOnCol = getCellValue(i, col) == value && i != row;
int squareRow = (row / 3) * 3 + i % 3;
int squareCol = (col / 3) * 3 + i / 3;
bool alreadyOnSquare = (getCellValue(squareRow, squareCol) == value) && !(squareRow == row && squareCol == col);
if (alreadyOnRow || alreadyOnCol || alreadyOnSquare) {
valid = false;
break;
}
}
setCellValid(row, col, valid);
}
}
QString Sudoku::toString() const
{
QString str;
for (int i = 0; i < SUDOKU_SIZE; i++) {
QStringList l;
for (int j = 0; j < SUDOKU_SIZE; j++) {
l.append(QString::number(getCellValue(i, j)));
}
str.append(l.join(";"));
str.append("\n");
}
return str.left(str.size() - 1);
}
void Sudoku::print() const
{
QString topSep = "|-----------------|"; // ┌┬┐ ╔╦╗
QString sep = "|-+-+-+-+-+-+-+-+-|"; // ├┼┤ ╠╬╣
QString botSep = "|-----------------|"; // └┴┘ ╚╩╝
QString str = toString(); // | ║
str.replace(';', '|');
str.replace('\n', "|\n" + sep + "\n|");
str = '|' + str + '|';
std::cout << topSep.toStdString() << std::endl;
std::cout << str.toStdString() << std::endl;
std::cout << botSep.toStdString() << std::endl;
}
#ifdef _DEBUG
void Sudoku::checkForFilterError()
{
for (int i = 0; i < SUDOKU_SIZE; ++i) {
for (int j = 0; j < SUDOKU_SIZE; ++j) {
bool solutionPresent = false;
int sol = _solutionValues[i][j]->getValue();
if (! sol) {
// case where solution's value couldn't be loaded
continue;
}
foreach(int val, getCellPossibleValues(i, j)) {
solutionPresent |= sol == val;
}
if (!solutionPresent) {
QString mess = QString("Correct value %1 disappeared from possible value of cell (%2;%3) !")
.arg(QString::number(sol), QString::number(i), QString::number(j));
qWarning(mess.toStdString().c_str());
}
}
}
}
#endif
| [
"[email protected]"
] | |
cc5cba74c22d7876e3fb8abeac8712e71b5024ff | ba9322f7db02d797f6984298d892f74768193dcf | /emr/include/alibabacloud/emr/model/GetLogDownloadUrlRequest.h | 8df0e21724744bcc9377bd919df1238580840f6b | [
"Apache-2.0"
] | permissive | sdk-team/aliyun-openapi-cpp-sdk | e27f91996b3bad9226c86f74475b5a1a91806861 | a27fc0000a2b061cd10df09cbe4fff9db4a7c707 | refs/heads/master | 2022-08-21T18:25:53.080066 | 2022-07-25T10:01:05 | 2022-07-25T10:01:05 | 183,356,893 | 3 | 0 | null | 2019-04-25T04:34:29 | 2019-04-25T04:34:28 | null | UTF-8 | C++ | false | false | 2,068 | h | /*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_EMR_MODEL_GETLOGDOWNLOADURLREQUEST_H_
#define ALIBABACLOUD_EMR_MODEL_GETLOGDOWNLOADURLREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/emr/EmrExport.h>
namespace AlibabaCloud
{
namespace Emr
{
namespace Model
{
class ALIBABACLOUD_EMR_EXPORT GetLogDownloadUrlRequest : public RpcServiceRequest
{
public:
GetLogDownloadUrlRequest();
~GetLogDownloadUrlRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getHostName()const;
void setHostName(const std::string& hostName);
std::string getLogstoreName()const;
void setLogstoreName(const std::string& logstoreName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getClusterId()const;
void setClusterId(const std::string& clusterId);
std::string getLogFileName()const;
void setLogFileName(const std::string& logFileName);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
long resourceOwnerId_;
std::string hostName_;
std::string logstoreName_;
std::string regionId_;
std::string clusterId_;
std::string logFileName_;
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_EMR_MODEL_GETLOGDOWNLOADURLREQUEST_H_ | [
"[email protected]"
] | |
6e0d4d326cd4d005fb52dd12bc2b3033d3cd8aff | 208a3711fb5cc55aa0aa0a5de818fc65745999bc | /leetcode/leetcode_515.cc | 845eb511a756c70a593d505887c4e05f7df5c530 | [] | no_license | zeroli/playground | 380542c13fb7f5a59ef9075dbfbb0606a6321ee1 | 808e91cfd5ca081b4cb7f9816744c4b8176772fc | refs/heads/master | 2022-09-18T06:53:15.209170 | 2022-08-22T23:54:04 | 2022-08-22T23:54:04 | 204,423,544 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,624 | cc | /*
515. Find Largest Value in Each Tree Row
Medium
https://leetcode.com/problems/find-largest-value-in-each-tree-row/
You need to find the largest value in each row of a binary tree.
Example:
Input:
1
/ \
3 2
/ \ \
5 3 9
Output: [1, 3, 9]
*/
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
vector<int> res;
vector<int> largestValues(TreeNode* root) {
if (not root) return res;
levelTraverse(root, 0);
}
void levelTraverse(TreeNode* root, int depth) {
if (not root) return;
if (depth >= res.size()) {
res.push_back(root->val);
} else {
if (res[depth] < root->val) {
res[depth] = root->val;
}
}
levelTraverse(root->left, depth+1);
levelTraverse(root->right, depth+1);
}
vector<int> largestValues1(TreeNode* root) {
vector<int> res;
if (not root) return res;
queue<TreeNode*> q;
q.push(root);
while (!q.empty()) {
int sz = (int)q.size();
int maxval = INT_MIN;
for (int i = 0; i < sz; i++) {
TreeNode* p = q.front();
maxval = max(p->val, maxval);
q.pop();
if (p->left) q.push(p->left);
if (p->right) q.push(p->right);
}
res.push_back(maxval);
}
return res;
}
};
| [
"[email protected]"
] | |
1235c8dd6bca2574c8ed1ca3bfb7cc8e6a04c637 | 0eff74b05b60098333ad66cf801bdd93becc9ea4 | /second/download/squid/gumtree/squid_repos_function_4550_squid-3.1.23.cpp | 59088cc13ac20a0a32539f6c0f6d479fcd8baf94 | [] | no_license | niuxu18/logTracker-old | 97543445ea7e414ed40bdc681239365d33418975 | f2b060f13a0295387fe02187543db124916eb446 | refs/heads/master | 2021-09-13T21:39:37.686481 | 2017-12-11T03:36:34 | 2017-12-11T03:36:34 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 92 | cpp | tlv *
storeSwapMetaBuild(StoreEntry * e)
{
fatal ("Not implemented");
return NULL;
} | [
"[email protected]"
] | |
24442e564397d354cb5fb688aa825a4694b2dcdc | 7bcfcdff01e677a8d0def1df44728556b49dad78 | /LockNFC_fw/os/hal/hal_lld.cpp | 11eeddf0f77489d21a90b60757b962c290ffe25b | [] | no_license | Kreyl/LockNFC | e7de1e2eca47ddd5e6c5157df042bf878f2faf67 | 5b14d9f851b480a3fdf982428f6e6d173538af70 | refs/heads/master | 2021-01-10T16:52:09.792844 | 2018-09-05T20:06:49 | 2018-09-05T20:06:49 | 48,121,018 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,161 | cpp | /*
ChibiOS/RT - Copyright (C) 2006-2013 Giovanni Di Sirio
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.
*/
/**
* @file STM32F4xx/hal_lld.c
* @brief STM32F4xx/STM32F2xx HAL subsystem low level driver source.
*
* @addtogroup HAL
* @{
*/
/* TODO: LSEBYP like in F3.*/
#include "ch.h"
#include "hal.h"
#include "clocking.h"
/*===========================================================================*/
/* Driver local definitions. */
/*===========================================================================*/
/*===========================================================================*/
/* Driver exported variables. */
/*===========================================================================*/
/*===========================================================================*/
/* Driver local variables and types. */
/*===========================================================================*/
/*===========================================================================*/
/* Driver local functions. */
/*===========================================================================*/
/**
* @brief Initializes the backup domain.
*/
static void hal_lld_backup_domain_init(void) {
/* Backup domain access enabled and left open.*/
PWR->CR |= PWR_CR_DBP;
/* Reset BKP domain if different clock source selected.*/
// if ((RCC->BDCR & STM32_RTCSEL_MASK) != STM32_RTCSEL) {
// /* Backup domain reset.*/
// RCC->BDCR = RCC_BDCR_BDRST;
// RCC->BDCR = 0;
// }
/* If enabled then the LSE is started.*/
#if STM32_LSE_ENABLED
RCC->BDCR |= RCC_BDCR_LSEON;
while ((RCC->BDCR & RCC_BDCR_LSERDY) == 0)
; /* Waits until LSE is stable. */
#endif
#if STM32_RTCSEL != STM32_RTCSEL_NOCLOCK
/* If the backup domain hasn't been initialized yet then proceed with
initialization.*/
if ((RCC->BDCR & RCC_BDCR_RTCEN) == 0) {
/* Selects clock source.*/
RCC->BDCR |= STM32_RTCSEL;
/* RTC clock enabled.*/
RCC->BDCR |= RCC_BDCR_RTCEN;
}
#endif /* STM32_RTCSEL != STM32_RTCSEL_NOCLOCK */
}
/*===========================================================================*/
/* Driver interrupt handlers. */
/*===========================================================================*/
/*===========================================================================*/
/* Driver exported functions. */
/*===========================================================================*/
/**
* @brief Low level HAL driver initialization.
*
* @notapi
*/
void hal_lld_init(void) {
/* Reset of all peripherals. AHB3 is not reseted because it could have
been initialized in the board initialization file (board.c).*/
rccResetAHB1(~0);
rccResetAHB2(~0);
rccResetAHB3(~0);
rccResetAPB1(~RCC_APB1RSTR_PWRRST);
rccResetAPB2(~0);
/* SysTick initialization using the system clock.*/
Clk.InitSysTick();
/* DWT cycle counter enable.*/
SCS_DEMCR |= SCS_DEMCR_TRCENA;
DWT_CTRL |= DWT_CTRL_CYCCNTENA;
/* PWR clock enabled.*/
rccEnablePWRInterface(FALSE);
/* Initializes the backup domain.*/
hal_lld_backup_domain_init();
#if defined(STM32_DMA_REQUIRED)
dmaInit();
#endif
/* Programmable voltage detector enable.*/
#if STM32_PVD_ENABLE
PWR->CR |= PWR_CR_PVDE | (STM32_PLS & STM32_PLS_MASK);
#endif /* STM32_PVD_ENABLE */
}
/** @} */
| [
"[email protected]"
] | |
a0d764d36e3557be156ddcc0c2bfbe0709d717c2 | 22212b6400346c5ec3f5927703ad912566d3474f | /src/Frameworks/PythonFramework/PythonScriptModule.cpp | c81d6528a24e2583d3e82b4dd9a33b1370f50a76 | [
"LicenseRef-scancode-unknown-license-reference",
"MIT"
] | permissive | irov/Mengine | 673a9f35ab10ac93d42301bc34514a852c0f150d | 8118e4a4a066ffba82bda1f668c1e7a528b6b717 | refs/heads/master | 2023-09-04T03:19:23.686213 | 2023-09-03T16:05:24 | 2023-09-03T16:05:24 | 41,422,567 | 46 | 17 | MIT | 2022-09-26T18:41:33 | 2015-08-26T11:44:35 | C++ | UTF-8 | C++ | false | false | 2,936 | cpp | #include "PythonScriptModule.h"
#include "Kernel/Eventable.h"
#include "Kernel/Logger.h"
namespace Mengine
{
//////////////////////////////////////////////////////////////////////////
PythonScriptModule::PythonScriptModule()
{
}
//////////////////////////////////////////////////////////////////////////
PythonScriptModule::~PythonScriptModule()
{
}
//////////////////////////////////////////////////////////////////////////
bool PythonScriptModule::initialize( const pybind::module & _module )
{
m_module = _module;
return true;
}
//////////////////////////////////////////////////////////////////////////
void PythonScriptModule::finalize()
{
m_module = nullptr;
}
//////////////////////////////////////////////////////////////////////////
bool PythonScriptModule::onInitialize( const ConstString & _method )
{
#if defined(MENGINE_DEBUG)
//FixMe python2.7 don't support non native string key
if( m_module.has_attr( _method.c_str() ) == false )
{
LOGGER_ERROR( "module '%s' invalid has initializer '%s'"
, m_module.repr().c_str()
, _method.c_str()
);
return false;
}
#endif
pybind::object module_function = m_module.get_attr( _method.c_str() );
pybind::object py_result = module_function.call();
#if defined(MENGINE_DEBUG)
if( py_result.is_invalid() == true )
{
LOGGER_ERROR( "module '%s' invalid call initializer '%s'"
, m_module.repr().c_str()
, _method.c_str()
);
return false;
}
if( py_result.is_bool() == false )
{
LOGGER_ERROR( "module '%s' invalid call initializer '%s' need return bool [True|False] but return is '%s'"
, m_module.repr().c_str()
, _method.c_str()
, py_result.repr().c_str()
);
return false;
}
#endif
bool successful = py_result.extract();
return successful;
}
//////////////////////////////////////////////////////////////////////////
bool PythonScriptModule::onFinalize( const ConstString & _method )
{
#if defined(MENGINE_DEBUG)
if( m_module.has_attr( _method.c_str() ) == false )
{
LOGGER_ERROR( "invalid has finalizer '%s'"
, _method.c_str()
);
return false;
}
#endif
pybind::object module_function = m_module.get_attr( _method.c_str() );
module_function.call();
return true;
}
//////////////////////////////////////////////////////////////////////////
const pybind::module & PythonScriptModule::getModule() const
{
return m_module;
}
//////////////////////////////////////////////////////////////////////////
} | [
"[email protected]"
] | |
d0b290e99ecf12574a30e9b980cf234b8d13799b | 1d20cdc10cb2ef2ffc4974e6cf6cfff2649f525c | /Project1/History.h | 9b73792e942656ea36943aabe3ad5cfb4ad5a932 | [] | no_license | UCLA-Cobular/CS32-Projects | 91df07fdcb9271cb27d2c87c127352f96ef81785 | b8d6a6a6bf9e85c39d9f26e1e58758c3fdb3f957 | refs/heads/main | 2023-03-17T21:23:42.318497 | 2021-03-12T06:36:36 | 2021-03-12T06:36:36 | 328,281,704 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 357 | h | //
// Created by jdc10 on 1/9/2021.
//
#ifndef PROJECT1_HISTORY_H
#define PROJECT1_HISTORY_H
#include "globals.h"
class History {
public:
History(int nRows, int nCols);
bool record(int r, int c);
void display() const;
private:
int m_nRows;
int m_nCols;
char history_data[MAXROWS][MAXCOLS]{};
};
#endif //PROJECT1_HISTORY_H
| [
"[email protected]"
] | |
b47e87d9a0f21ebfd9cc349892e0cf6dfc9fbf95 | 390b896ede4a0759552f868431fe8841bb4bf4e7 | /omnetpp/src/qtenv/moc_highlighteritemdelegate.cpp | b9b44a11147a4f526e632641c71ac486f1eb0848 | [] | no_license | posacz/Dioxide | 1fb2ec145b15b6922c686ca6cb19df8092730c72 | 003cd5e7653e2f1709003af00ff5d8d6f02c57b4 | refs/heads/main | 2023-03-31T06:10:37.173295 | 2021-04-14T18:20:08 | 2021-04-14T18:20:08 | 357,947,903 | 0 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 5,121 | cpp | /****************************************************************************
** Meta object code from reading C++ file 'highlighteritemdelegate.h'
**
** Created by: The Qt Meta Object Compiler version 67 (Qt 5.12.9)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
#include "highlighteritemdelegate.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'highlighteritemdelegate.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.12.9. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif
QT_BEGIN_MOC_NAMESPACE
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
struct qt_meta_stringdata_omnetpp__qtenv__HighlighterItemDelegate_t {
QByteArrayData data[4];
char stringdata0[71];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
qptrdiff(offsetof(qt_meta_stringdata_omnetpp__qtenv__HighlighterItemDelegate_t, stringdata0) + ofs \
- idx * sizeof(QByteArrayData)) \
)
static const qt_meta_stringdata_omnetpp__qtenv__HighlighterItemDelegate_t qt_meta_stringdata_omnetpp__qtenv__HighlighterItemDelegate = {
{
QT_MOC_LITERAL(0, 0, 39), // "omnetpp::qtenv::HighlighterIt..."
QT_MOC_LITERAL(1, 40, 13), // "editorCreated"
QT_MOC_LITERAL(2, 54, 0), // ""
QT_MOC_LITERAL(3, 55, 15) // "editorDestroyed"
},
"omnetpp::qtenv::HighlighterItemDelegate\0"
"editorCreated\0\0editorDestroyed"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_omnetpp__qtenv__HighlighterItemDelegate[] = {
// content:
8, // revision
0, // classname
0, 0, // classinfo
2, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
2, // signalCount
// signals: name, argc, parameters, tag, flags
1, 0, 24, 2, 0x06 /* Public */,
3, 0, 25, 2, 0x06 /* Public */,
// signals: parameters
QMetaType::Void,
QMetaType::Void,
0 // eod
};
void omnetpp::qtenv::HighlighterItemDelegate::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
auto *_t = static_cast<HighlighterItemDelegate *>(_o);
Q_UNUSED(_t)
switch (_id) {
case 0: _t->editorCreated(); break;
case 1: _t->editorDestroyed(); break;
default: ;
}
} else if (_c == QMetaObject::IndexOfMethod) {
int *result = reinterpret_cast<int *>(_a[0]);
{
using _t = void (HighlighterItemDelegate::*)() const;
if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&HighlighterItemDelegate::editorCreated)) {
*result = 0;
return;
}
}
{
using _t = void (HighlighterItemDelegate::*)() const;
if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&HighlighterItemDelegate::editorDestroyed)) {
*result = 1;
return;
}
}
}
Q_UNUSED(_a);
}
QT_INIT_METAOBJECT const QMetaObject omnetpp::qtenv::HighlighterItemDelegate::staticMetaObject = { {
&QStyledItemDelegate::staticMetaObject,
qt_meta_stringdata_omnetpp__qtenv__HighlighterItemDelegate.data,
qt_meta_data_omnetpp__qtenv__HighlighterItemDelegate,
qt_static_metacall,
nullptr,
nullptr
} };
const QMetaObject *omnetpp::qtenv::HighlighterItemDelegate::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *omnetpp::qtenv::HighlighterItemDelegate::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_meta_stringdata_omnetpp__qtenv__HighlighterItemDelegate.stringdata0))
return static_cast<void*>(this);
return QStyledItemDelegate::qt_metacast(_clname);
}
int omnetpp::qtenv::HighlighterItemDelegate::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QStyledItemDelegate::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 2)
qt_static_metacall(this, _c, _id, _a);
_id -= 2;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 2)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 2;
}
return _id;
}
// SIGNAL 0
void omnetpp::qtenv::HighlighterItemDelegate::editorCreated()const
{
QMetaObject::activate(const_cast< omnetpp::qtenv::HighlighterItemDelegate *>(this), &staticMetaObject, 0, nullptr);
}
// SIGNAL 1
void omnetpp::qtenv::HighlighterItemDelegate::editorDestroyed()const
{
QMetaObject::activate(const_cast< omnetpp::qtenv::HighlighterItemDelegate *>(this), &staticMetaObject, 1, nullptr);
}
QT_WARNING_POP
QT_END_MOC_NAMESPACE
| [
"posacz"
] | posacz |
4ee3542ec707c7ed908bf52282ef2db138f17236 | e4babee60000e6dadb0800f73d9da83c4cce7ee2 | /jni/core/Vector2.cpp | c8693c3a470d3810b2fb1ff22486a75ccaceb5b4 | [] | no_license | amuTBKT/Asteroids | 14b232bcff6f2377a690b480ecb189cd1f5a8927 | 285e4fb1a9817eaf9e6035759ce346c1ad980cb8 | refs/heads/master | 2021-01-22T12:07:54.541164 | 2014-11-06T17:17:40 | 2014-11-06T17:17:40 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,976 | cpp | /*
* Vector2.cpp
*
* Created on: Oct 3, 2014
* Author: amu
*/
#include "Vector2.h"
//// constructors ////
Vector2::Vector2(float m = 0, float n = 0):x(m), y(n){}
Vector2::Vector2():x(0), y(0){}
Vector2::Vector2(const Vector2& v){ // copy constructor
x = v.x;
y = v.y;
}
//////////////////////
//// getters and setters ////
void Vector2::set(float m, float n){
x = m;
y = n;
}
void Vector2::setX(float m){
x = m;
}
void Vector2::setY(float n){
y = n;
}
void Vector2::setLength(float length){
float angle = getAngle() * M_PI / 180;
x = cosf(angle) * length;
y = sinf(angle) * length;
}
void Vector2::setAngle(float angle){
float length = getLength();
angle *= M_PI / 180;
x = cosf(angle) * length;
y = sinf(angle) * length;
}
float Vector2::getX(){
return x;
}
float Vector2::getY(){
return y;
}
float Vector2::getLength(){
return sqrtf(getLengthSQR());
}
float Vector2::getLengthSQR(){
return *this * *this;
}
float Vector2::getAngle(){
return atan2(y, x) * 180 / M_PI;
}
/////////////////////////////
//// methods ////
Vector2& Vector2::operator =(const Vector2& v){
x = v.x;
y = v.y;
return *this;
}
Vector2 Vector2::operator +(const Vector2& v){
return Vector2(x + v.x, y + v.y);
}
Vector2& Vector2::operator +=(const Vector2& v){
x += v.x;
y += v.y;
return *this;
}
Vector2 Vector2::operator -(const Vector2& v){
return Vector2(x - v.x, y - v.y);
}
Vector2& Vector2::operator -=(const Vector2& v){
x -= v.x;
y -= v.y;
return *this;
}
Vector2 Vector2::operator *(float c){
return Vector2(x * c, y * c);
}
Vector2& Vector2::operator *=(float c){
x *= c;
y *= c;
return *this;
}
Vector2 Vector2::operator /(float c){
//if (c == 0) throw (1 / c);
return Vector2(x / c, y / c);
}
Vector2& Vector2::operator /=(float c){
x /= c;
y /= c;
return *this;
}
bool Vector2::operator ==(const Vector2& v){
return (x == v.x && y == v.y);
}
bool Vector2::operator !=(const Vector2& v){
return (x != v.x && y != v.y);
}
float Vector2::operator *(const Vector2& v){
return (x * v.x + y * v.y);
}
void Vector2::truncate(float limit){
float length = getLength();
length = fminf(length, limit);
setLength(length);
}
void Vector2::reverse(){
*this *= -1;
}
void Vector2::rotate(float dA){
float angle = getAngle();
setAngle(angle + dA);
}
//Vector2 Vector2::reflect(const Vector2& normal){
// Vector2 tmp(normal);
// tmp.normalize();
// tmp = *this - tmp * 2 * (tmp * *this);
// tmp.normalize();
// return tmp;
//}
void Vector2::normalize(){
if (getLength() == 0){
x = 1;
y = 0;
}
else {
*this /= getLength();
}
}
bool Vector2::isNormalized(){
return getLength() == 1;
}
float Vector2::angleBetween(const Vector2 v){
Vector2 tmp1 = Vector2(*this);
tmp1.normalize();
Vector2 tmp2 = Vector2(v);
tmp2.normalize();
return acosf(tmp1 * tmp2) * 180 / M_PI;
}
float Vector2::distanceBetween(const Vector2 v){
Vector2 tmp = Vector2(*this);
tmp -= v;
return tmp.getLength();
}
/////////////////
| [
"[email protected]"
] | |
d513a5be725e02ad6b4b0e971f218b29f856dd4f | 5bc04daeef5284871264a7446aadf7552ec0d195 | /OpenTimer/ot/shell/obselete.cpp | 935af4e9fc28301b138d3a135ad8db6294ad62ea | [
"MIT"
] | permissive | Ace-Ma/LSOracle | a8fd7efe8927f8154ea37407bac727e409098ed5 | 6e940906303ef6c2c6b96352f44206567fdd50d3 | refs/heads/master | 2020-07-23T15:36:18.224385 | 2019-08-16T15:58:33 | 2019-08-16T15:58:33 | 207,612,130 | 0 | 0 | MIT | 2019-09-10T16:42:43 | 2019-09-10T16:42:43 | null | UTF-8 | C++ | false | false | 1,949 | cpp | #include <ot/shell/shell.hpp>
namespace ot {
// Procedure: exec_ops
void Shell::_exec_ops() {
OT_LOGW(std::quoted("exec_ops"), " is obselete and has no effect");
}
// Procedure: init_timer
void Shell::_init_timer() {
OT_LOGW(std::quoted("init_timer"), " is obselete and has no effect");
}
// Procedure: set_early_celllib_fpath
void Shell::_set_early_celllib_fpath() {
OT_LOGW(
std::quoted("set_early_celllib_fpath"), " is obselete; use ", std::quoted("read_celllib")
);
if(std::filesystem::path path; _is >> path) {
_timer.read_celllib(std::move(path), MIN);
}
}
// Procedure: set_late_celllib_fpath
void Shell::_set_late_celllib_fpath() {
OT_LOGW(
std::quoted("set_late_celllib_fpath"), " is obselete; use ", std::quoted("read_celllib")
);
if(std::filesystem::path path; _is >> path) {
_timer.read_celllib(std::move(path), MAX);
}
}
// Procedure: set_verilog_fpath
void Shell::_set_verilog_fpath() {
OT_LOGW(
std::quoted("set_verilog_fpath"), " is obselete; use ", std::quoted("read_verilog")
);
if(std::filesystem::path path; _is >> path) {
_timer.read_verilog(std::move(path));
}
}
// Procedure: set_spef_fpath
void Shell::_set_spef_fpath() {
OT_LOGW(
std::quoted("set_spef_fpath"), " is obselete; use ", std::quoted("read_spef")
);
if(std::filesystem::path path; _is >> path) {
_timer.read_spef(std::move(path));
}
}
// Procedure: set_timing_fpath
void Shell::_set_timing_fpath() {
OT_LOGW(
std::quoted("set_timing_fpath"), " is obselete; use ", std::quoted("read_timing")
);
if(std::filesystem::path path; _is >> path) {
_timer.read_timing(std::move(path));
}
}
// Procedure: report_timer
void Shell::_report_timer() {
OT_LOGW(
std::quoted("report_timer"), " is obselete; use ", std::quoted("dump_timer")
);
_timer.dump_timer(_os);
}
}; // end of namespace ot. -----------------------------------------------------------------------
| [
"[email protected]"
] | |
34ccbe15caa6d8dc0003d68ce865f4bd4ecbaa4c | 8cf763c4c29db100d15f2560953c6e6cbe7a5fd4 | /src/qt/qtbase/src/corelib/io/qlockfile.cpp | c25650743089343465f17f60511b18efaac2f673 | [
"LGPL-2.0-or-later",
"LGPL-2.1-only",
"GFDL-1.3-only",
"Qt-LGPL-exception-1.1",
"LicenseRef-scancode-digia-qt-commercial",
"LGPL-3.0-only",
"GPL-3.0-only",
"LicenseRef-scancode-digia-qt-preview",
"LGPL-2.1-or-later",
"GPL-1.0-or-later",
"LicenseRef-scancode-unknown-license-reference",
"GPL-2.0-only",
"BSD-3-Clause"
] | permissive | chihlee/phantomjs | 69d6bbbf1c9199a78e82ae44af072aca19c139c3 | 644e0b3a6c9c16bcc6f7ce2c24274bf7d764f53c | refs/heads/master | 2021-01-19T13:49:41.265514 | 2018-06-15T22:48:11 | 2018-06-15T22:48:11 | 82,420,380 | 0 | 0 | BSD-3-Clause | 2018-06-15T22:48:12 | 2017-02-18T22:34:48 | C++ | UTF-8 | C++ | false | false | 12,107 | cpp | /****************************************************************************
**
** Copyright (C) 2013 David Faure <[email protected]>
** Contact: http://www.qt-project.org/legal
**
** This file is part of the QtCore module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL21$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Digia. For licensing terms and
** conditions see http://qt.digia.com/licensing. For further information
** use the contact form at http://qt.digia.com/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 or version 3 as published by the Free
** Software Foundation and appearing in the file LICENSE.LGPLv21 and
** LICENSE.LGPLv3 included in the packaging of this file. Please review the
** following information to ensure the GNU Lesser General Public License
** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Digia gives you certain additional
** rights. These rights are described in the Digia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qlockfile.h"
#include "qlockfile_p.h"
#include <QtCore/qthread.h>
#include <QtCore/qelapsedtimer.h>
#include <QtCore/qdatetime.h>
QT_BEGIN_NAMESPACE
/*!
\class QLockFile
\inmodule QtCore
\brief The QLockFile class provides locking between processes using a file.
\since 5.1
A lock file can be used to prevent multiple processes from accessing concurrently
the same resource. For instance, a configuration file on disk, or a socket, a port,
a region of shared memory...
Serialization is only guaranteed if all processes that access the shared resource
use QLockFile, with the same file path.
QLockFile supports two use cases:
to protect a resource for a short-term operation (e.g. verifying if a configuration
file has changed before saving new settings), and for long-lived protection of a
resource (e.g. a document opened by a user in an editor) for an indefinite amount of time.
When protecting for a short-term operation, it is acceptable to call lock() and wait
until any running operation finishes.
When protecting a resource over a long time, however, the application should always
call setStaleLockTime(0) and then tryLock() with a short timeout, in order to
warn the user that the resource is locked.
If the process holding the lock crashes, the lock file stays on disk and can prevent
any other process from accessing the shared resource, ever. For this reason, QLockFile
tries to detect such a "stale" lock file, based on the process ID written into the file,
and (in case that process ID got reused meanwhile), on the last modification time of
the lock file (30s by default, for the use case of a short-lived operation).
If the lock file is found to be stale, it will be deleted.
For the use case of protecting a resource over a long time, you should therefore call
setStaleLockTime(0), and when tryLock() returns LockFailedError, inform the user
that the document is locked, possibly using getLockInfo() for more details.
*/
/*!
\enum QLockFile::LockError
This enum describes the result of the last call to lock() or tryLock().
\value NoError The lock was acquired successfully.
\value LockFailedError The lock could not be acquired because another process holds it.
\value PermissionError The lock file could not be created, for lack of permissions
in the parent directory.
\value UnknownError Another error happened, for instance a full partition
prevented writing out the lock file.
*/
/*!
Constructs a new lock file object.
The object is created in an unlocked state.
When calling lock() or tryLock(), a lock file named \a fileName will be created,
if it doesn't already exist.
\sa lock(), unlock()
*/
QLockFile::QLockFile(const QString &fileName)
: d_ptr(new QLockFilePrivate(fileName))
{
}
/*!
Destroys the lock file object.
If the lock was acquired, this will release the lock, by deleting the lock file.
*/
QLockFile::~QLockFile()
{
unlock();
}
/*!
Sets \a staleLockTime to be the time in milliseconds after which
a lock file is considered stale.
The default value is 30000, i.e. 30 seconds.
If your application typically keeps the file locked for more than 30 seconds
(for instance while saving megabytes of data for 2 minutes), you should set
a bigger value using setStaleLockTime().
The value of \a staleLockTime is used by lock() and tryLock() in order
to determine when an existing lock file is considered stale, i.e. left over
by a crashed process. This is useful for the case where the PID got reused
meanwhile, so the only way to detect a stale lock file is by the fact that
it has been around for a long time.
\sa staleLockTime()
*/
void QLockFile::setStaleLockTime(int staleLockTime)
{
Q_D(QLockFile);
d->staleLockTime = staleLockTime;
}
/*!
Returns the time in milliseconds after which
a lock file is considered stale.
\sa setStaleLockTime()
*/
int QLockFile::staleLockTime() const
{
Q_D(const QLockFile);
return d->staleLockTime;
}
/*!
Returns \c true if the lock was acquired by this QLockFile instance,
otherwise returns \c false.
\sa lock(), unlock(), tryLock()
*/
bool QLockFile::isLocked() const
{
Q_D(const QLockFile);
return d->isLocked;
}
/*!
Creates the lock file.
If another process (or another thread) has created the lock file already,
this function will block until that process (or thread) releases it.
Calling this function multiple times on the same lock from the same
thread without unlocking first is not allowed. This function will
\e dead-lock when the file is locked recursively.
Returns \c true if the lock was acquired, false if it could not be acquired
due to an unrecoverable error, such as no permissions in the parent directory.
\sa unlock(), tryLock()
*/
bool QLockFile::lock()
{
return tryLock(-1);
}
/*!
Attempts to create the lock file. This function returns \c true if the
lock was obtained; otherwise it returns \c false. If another process (or
another thread) has created the lock file already, this function will
wait for at most \a timeout milliseconds for the lock file to become
available.
Note: Passing a negative number as the \a timeout is equivalent to
calling lock(), i.e. this function will wait forever until the lock
file can be locked if \a timeout is negative.
If the lock was obtained, it must be released with unlock()
before another process (or thread) can successfully lock it.
Calling this function multiple times on the same lock from the same
thread without unlocking first is not allowed, this function will
\e always return false when attempting to lock the file recursively.
\sa lock(), unlock()
*/
bool QLockFile::tryLock(int timeout)
{
Q_D(QLockFile);
QElapsedTimer timer;
if (timeout > 0)
timer.start();
int sleepTime = 100;
forever {
d->lockError = d->tryLock_sys();
switch (d->lockError) {
case NoError:
d->isLocked = true;
return true;
case PermissionError:
case UnknownError:
return false;
case LockFailedError:
if (!d->isLocked && d->isApparentlyStale()) {
// Stale lock from another thread/process
// Ensure two processes don't remove it at the same time
QLockFile rmlock(d->fileName + QStringLiteral(".rmlock"));
if (rmlock.tryLock()) {
if (d->isApparentlyStale() && d->removeStaleLock())
continue;
}
}
break;
}
if (timeout == 0 || (timeout > 0 && timer.hasExpired(timeout)))
return false;
QThread::msleep(sleepTime);
if (sleepTime < 5 * 1000)
sleepTime *= 2;
}
// not reached
return false;
}
/*!
\fn void QLockFile::unlock()
Releases the lock, by deleting the lock file.
Calling unlock() without locking the file first, does nothing.
\sa lock(), tryLock()
*/
/*!
Retrieves information about the current owner of the lock file.
If tryLock() returns \c false, and error() returns LockFailedError,
this function can be called to find out more information about the existing
lock file:
\list
\li the PID of the application (returned in \a pid)
\li the \a hostname it's running on (useful in case of networked filesystems),
\li the name of the application which created it (returned in \a appname),
\endlist
Note that tryLock() automatically deleted the file if there is no
running application with this PID, so LockFailedError can only happen if there is
an application with this PID (it could be unrelated though).
This can be used to inform users about the existing lock file and give them
the choice to delete it. After removing the file using removeStaleLockFile(),
the application can call tryLock() again.
This function returns \c true if the information could be successfully retrieved, false
if the lock file doesn't exist or doesn't contain the expected data.
This can happen if the lock file was deleted between the time where tryLock() failed
and the call to this function. Simply call tryLock() again if this happens.
*/
bool QLockFile::getLockInfo(qint64 *pid, QString *hostname, QString *appname) const
{
Q_D(const QLockFile);
return d->getLockInfo(pid, hostname, appname);
}
bool QLockFilePrivate::getLockInfo(qint64 *pid, QString *hostname, QString *appname) const
{
QFile reader(fileName);
if (!reader.open(QIODevice::ReadOnly))
return false;
QByteArray pidLine = reader.readLine();
pidLine.chop(1);
QByteArray appNameLine = reader.readLine();
appNameLine.chop(1);
QByteArray hostNameLine = reader.readLine();
hostNameLine.chop(1);
if (pidLine.isEmpty())
return false;
qint64 thePid = pidLine.toLongLong();
if (pid)
*pid = thePid;
if (appname)
*appname = QString::fromUtf8(appNameLine);
if (hostname)
*hostname = QString::fromUtf8(hostNameLine);
return thePid > 0;
}
/*!
Attempts to forcefully remove an existing lock file.
Calling this is not recommended when protecting a short-lived operation: QLockFile
already takes care of removing lock files after they are older than staleLockTime().
This method should only be called when protecting a resource for a long time, i.e.
with staleLockTime(0), and after tryLock() returned LockFailedError, and the user
agreed on removing the lock file.
Returns \c true on success, false if the lock file couldn't be removed. This happens
on Windows, when the application owning the lock is still running.
*/
bool QLockFile::removeStaleLockFile()
{
Q_D(QLockFile);
if (d->isLocked) {
qWarning("removeStaleLockFile can only be called when not holding the lock");
return false;
}
return d->removeStaleLock();
}
/*!
Returns the lock file error status.
If tryLock() returns \c false, this function can be called to find out
the reason why the locking failed.
*/
QLockFile::LockError QLockFile::error() const
{
Q_D(const QLockFile);
return d->lockError;
}
QT_END_NAMESPACE
| [
"[email protected]"
] | |
5018f3fa3829719cd56124fa7fe388671d3f31ae | 62a7d30053e7640ef770e041f65b249d101c9757 | /2018牛客网暑期ACM多校训练营（第六场)/A.cpp | 99c603d20451a04fc4b66f351ba083de09787130 | [] | no_license | wcysai/Calabash | 66e0137fd59d5f909e4a0cab940e3e464e0641d0 | 9527fa7ffa7e30e245c2d224bb2fb77a03600ac2 | refs/heads/master | 2022-05-15T13:11:31.904976 | 2022-04-11T01:22:50 | 2022-04-11T01:22:50 | 148,618,062 | 76 | 16 | null | 2019-11-07T05:27:40 | 2018-09-13T09:53:04 | C++ | UTF-8 | C++ | false | false | 1,203 | cpp | #include <bits/stdc++.h>
using namespace std;
#ifdef __LOCAL_DEBUG__
# define _debug(fmt, ...) fprintf(stderr, "\033[94m%s: " fmt "\n\033[0m", \
__func__, ##__VA_ARGS__)
#else
# define _debug(...) ((void) 0)
#endif
#define rep(i, n) for (int i=0; i<(n); i++)
#define Rep(i, n) for (int i=1; i<=(n); i++)
#define range(x) (x).begin(), (x).end()
typedef long long LL;
typedef unsigned long long ULL;
int n;
typedef pair<int, vector<int>> piv;
piv s[1 << 15];
void compete(piv& l, piv& r) {
if (l.second.back() < r.second.back()) swap(l, r);
l.second.erase(lower_bound(range(l.second), r.second.back()));
}
int main() {
int T; scanf("%d", &T);
for (int t = 1; t <= T; t++) {
scanf("%d", &n);
rep (i, 1 << n) s[i].second.assign(n, 0);
rep (i, 1 << n) {
s[i].first = i;
rep (j, n)
scanf("%d", &(s[i].second[j]));
}
rep (i, 1 << n) sort(range(s[i].second));
for (int ss = 1; ss < (1 << n); ss <<= 1) {
for (int i = 0; i < (1 << n); i += ss << 1 ) {
// _debug("i=%d, ss=%d", i, ss);
// _debug("%d v. %d", i, i+ss);
compete(s[i], s[i+ss]);
}
}
printf("Case #%d: %d\n", t, s[0].first+1);
}
return 0;
}
| [
"[email protected]"
] | |
90241c670a37fa20d64f0739109350446bd9c1dd | 2c32342156c0bb00e3e1d1f2232935206283fd88 | /cam/src/motion/mvrgloco.cpp | a9b6085377ba3f73cfaa455be6512c7bd92597c9 | [] | no_license | infernuslord/DarkEngine | 537bed13fc601cd5a76d1a313ab4d43bb06a5249 | c8542d03825bc650bfd6944dc03da5b793c92c19 | refs/heads/master | 2021-07-15T02:56:19.428497 | 2017-10-20T19:37:57 | 2017-10-20T19:37:57 | 106,126,039 | 7 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 20,622 | cpp | // $Header: r:/t2repos/thief2/src/motion/mvrgloco.cpp,v 1.39 1999/08/05 17:09:46 Justin Exp $
// This is the maneuver builder/controller for solid ground locomotions -
// That is, one's in which the creature is affected by gravity and moving along
// the floor beneath its feet.
//
// XXX Need to add ability to check stride length and guesstimate end pos
//
// XXX end state stuff for maneuvers needs to be calculated. I think
// this should only have 2D position, since this faster to calculate and is
// all I think AI will really want anyway (yes?)
//
// XXX deal with case when no motion capture is found
//
// XXX apply gravity when a foot should be in contact with sground but isn't.
// This should help with recovering from miscalculations of end ground height
#include <mmanuver.h>
#include <mcoord.h>
#include <wrtype.h>
#include <portal.h>
#include <mvrutils.h>
#include <fastflts.h>
#include <mschbase.h>
#include <physcast.h>
#include <ghostmvr.h>
#include <fix.h>
#include <mprintf.h>
#include <config.h>
#include <cfgdbg.h>
#include <mschutil.h>
#include <rand.h>
#include <textarch.h>
#include <math.h> // until fastflts works
// must be last header
#include <dbmem.h>
class cGroundLocoManeuverFactory: public cManeuverFactory
{
public:
virtual cMotionPlan *CreatePlan(const cMotionSchema *pSchema,const sMcMotorState& motState, \
const sMcMoveState& moveState, const sMcMoveParams& params, IMotor *pMotor, cMotionCoordinator *pCoord);
virtual IManeuver *LoadManeuver(IMotor *pMotor,cMotionCoordinator *pCoord,ITagFile *pTagFile);
};
typedef struct
{
BOOL m_DoRotate;
BOOL m_UseBend;
BOOL m_IsBeingDeleted;
mxs_angvec m_NewDirection;
mxs_angvec m_ExpectedEndFacing;
mxs_vector m_ExpectedEndPos;
mxs_vector m_StrideXlat;
float m_ButtZOffset;
int m_MotionNum;
mps_motion_param m_MotionParam;
mxs_ang m_RotAng;
mxs_ang m_MotRotAng;
sMGaitSkillData *m_pGaitData;
int m_SchemaID;
BOOL m_FirstStride;
} sGroundLocoData;
class cGroundLocoManeuver: public cManeuver, private sGroundLocoData
{
public:
cGroundLocoManeuver(IMotor *pMotor, cMotionCoordinator *pCoord, const cMotionSchema *pSchema, const sMcMoveParams& params);
cGroundLocoManeuver(IMotor *pMotor, cMotionCoordinator *pCoord, ITagFile *pTagFile,BOOL *success);
~cGroundLocoManeuver();
////////
// Motion System Client Functions
////////
virtual void GetExpectedEndMoveState(sMcMoveState& moveState);
////////
// Motion Coordinator Functions
////////
virtual void Execute();
virtual void Save(ITagFile *pTagFile);
////////
// Motor Resolver Functions
////////
virtual void CalcEnvironmentEffect() {}
virtual void CalcCollisionResponse(const mxs_vector *pForces, const int nForces,\
const mxs_vector *pCurrentVel, mxs_vector *pNewVel) \
{ MvrCalcSlidingCollisionResponse(pForces,nForces,pCurrentVel,pNewVel,kMvrUCF_MaintainSpeed); }
virtual void NotifyAboutBeingStuck();
//
// Motion status notification functions
//
virtual void NotifyAboutFrameFlags(const int flags) { MvrProcessStandardFlags(m_pMotor,m_pCoord, flags); }
virtual void NotifyAboutMotionEnd(int motionNum, int frame, ulong flags);
private:
};
// XXX really want to return to stand position, but can't since end callback
// doesn't deal with more than one mo-cap in maneuver
inline void cGroundLocoManeuver::NotifyAboutBeingStuck()
{
// XXX HACK: only update the phys models if doing non-combat locomotion,
// since combat ones have the whole problem of being asked to go in
// wacky directions where butt precedes knees. KJ 2/98
m_pMotor->SetOrientation(&m_ExpectedEndFacing,m_UseBend);
}
cGroundLocoManeuverFactory g_GroundLocoManeuverFactory;
EXTERN cManeuverFactory *g_pGroundLocoManeuverFactory=&g_GroundLocoManeuverFactory;
cMotionPlan *cGroundLocoManeuverFactory::CreatePlan(const cMotionSchema *pSchema,const sMcMotorState& motState, \
const sMcMoveState& moveState, const sMcMoveParams& params, IMotor *pMotor, cMotionCoordinator *pCoord)
{
cGroundLocoManeuver *pMnvr;
sMcMoveParams usedParams=params;
if(!(params.mask&kMotParmFlag_Direction))
{
// being told to locomote, but not in any direction. Try to figure out
// what request means.
ConfigSpew("MnvrTrace",("Told to locomote, but not given a direction"));
if(params.mask&kMotParmFlag_Facing)
{
usedParams.direction=usedParams.facing;
usedParams.mask|=kMotParmFlag_Direction;
} else
{
// assume direction wants to be current direction
Assert_(pMotor);
const sMotorState *pState=pMotor->GetMotorState();
usedParams.direction=pState->facing;
usedParams.mask|=kMotParmFlag_Direction;
}
}
pMnvr = new cGroundLocoManeuver(pMotor, pCoord, pSchema, usedParams);
AssertMsg(pMnvr,"could not alloc maneuver");
cMotionPlan *pPlan= new cMotionPlan;
AssertMsg(pPlan,"could not alloc plan");
pPlan->Prepend(pMnvr);
return pPlan;
}
IManeuver *cGroundLocoManeuverFactory::LoadManeuver(IMotor *pMotor,cMotionCoordinator *pCoord,ITagFile *pTagFile)
{
BOOL success;
cGroundLocoManeuver *pMnvr=new cGroundLocoManeuver(pMotor,pCoord,pTagFile,&success);
if(!success)
{
delete pMnvr;
return NULL;
}
return pMnvr;
}
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
//// GroundLoco MANEUVER IMPLEMENTATION
//////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////
#define MAX_INTERESTED_MOTIONS 10
#include <locobase.h> // for footfall flags
cGroundLocoManeuver::cGroundLocoManeuver(IMotor *pMotor, cMotionCoordinator *pCoord, ITagFile *pTagFile,BOOL *success)
{
*success=TRUE;
ITagFile_Move(pTagFile,(char *)&m_AppData,sizeof(m_AppData));
ITagFile_Move(pTagFile,(char *)((sGroundLocoData *)this),sizeof(*((sGroundLocoData*)this)));
m_pMotor=pMotor;
m_pCoord=pCoord;
m_pGaitData=NULL;
Assert_(m_pMotor);
if(m_pMotor&&m_MotionNum!=-1)
{
m_MotionNum=m_pMotor->SwizzleMotion(m_MotionNum);
if(m_MotionNum==-1) // couldn't swizzle
*success=FALSE;
}
// check that motor is in same state we think we are
if(m_pMotor->GetCurrentMotion()!=m_MotionNum) // out of synch!
{
Warning(("cGroundLocoManuever: cannot load maneuver because creature is out of synch\n"));
m_MotionNum=-1;
*success=FALSE;
}
}
void cGroundLocoManeuver::Save(ITagFile *pTagFile)
{
// write app data (cManeuver stuff)
ITagFile_Move(pTagFile,(char *)&m_AppData,sizeof(m_AppData));
ITagFile_Move(pTagFile,(char *)((sGroundLocoData *)this),sizeof(*((sGroundLocoData *)this)) );
}
cGroundLocoManeuver::cGroundLocoManeuver(IMotor *pMotor, cMotionCoordinator *pCoord,\
const cMotionSchema *pSchema, const sMcMoveParams& params )
{
BOOL turning=FALSE;
int i;
float dist;
m_pMotor=pMotor;
m_pCoord=pCoord;
if(pSchema)
m_SchemaID=pSchema->GetSchemaID();
else
m_SchemaID=kMotSchemaID_Invalid;
m_IsBeingDeleted=FALSE;
sMcMotorState *pS=m_pCoord->GetInterMnvrState();
// check if just did this schema
if(pS->lastSchemaID!=m_SchemaID)
{
ConfigSpew("MnvrTrace",("starting to %d\n",m_SchemaID));
m_FirstStride=TRUE;
} else
{
ConfigSpew("MnvrTrace",("still %d-ing\n",m_SchemaID));
m_FirstStride=FALSE;
}
// Get skill and motor information
//
const sMotorState *pState=m_pMotor->GetMotorState();
Assert_(pSchema);
if(!MSchUGetGaitData(pSchema,&m_pGaitData))
{
m_pGaitData=NULL;
Assert_(FALSE);
}
float timeWarp=m_pGaitData->timeWarp;
float tw;
if(pSchema->GetTimeWarp(&tw))
timeWarp*=tw;
if(m_pGaitData->noise)
{
float noise=(2*m_pGaitData->noise*Rand())/RAND_MAX;
timeWarp=(1.0-m_pGaitData->noise+noise)*timeWarp; // since 0<=noise<=2*m_pGaitData->noise;
}
int off=-1;
// Decide whether or not to use turn
//
// XXX using mxs_ang instead of degrees for wrapping
// XXX this doesn't distinguish between starting with left or right foot in turn
// XXX get facing vs direction to work correctly
mxs_ang turnTol=degrees_to_fixang(m_pGaitData->turnTolerance);
mxs_ang adelta=pState->facing.tz-params.direction.tz;
mxs_ang minDelta=MX_ANG_PI,diff;
sMGaitTurn *pTurn=m_pGaitData->turns;
// check if delta outside turn tolerance
if(m_pGaitData->numTurns>0 && ((adelta<=MX_ANG_PI&&adelta>turnTol)||(adelta>=MX_ANG_PI&&adelta<2*MX_ANG_PI-turnTol)))
{
turning=TRUE;
for(i=0;i<m_pGaitData->numTurns;i++,pTurn++)
{
mxs_ang angle=degrees_to_fixang(pTurn->angle);
diff=angle-adelta;
if(diff>MX_ANG_PI)
diff=2*MX_ANG_PI-diff;
if(diff<=minDelta)
{
minDelta=diff;
off=pTurn->mot;
}
}
}
// Decide whether to do left or right stride, if not turning
//
if(!turning)
{
if(pState->contactFlags&LEFT_FOOT) // XXX this will only work for bipeds
{
off=m_pGaitData->rightStride;
} else
{
off=m_pGaitData->leftStride;
}
}
m_MotionNum=-1;
#ifdef NETWORK_LOCOS
if (IsRemoteGhost(pMotor->GetObjID()))
{
m_MotionNum = GetGhostMotionNumber();
#ifndef SHIP
if (config_is_defined("ghost_motion_spew"))
{
mprintf("Remote ghost %d playing schema %d, motion %d\n", pMotor->GetObjID(), m_SchemaID, m_MotionNum);
}
#endif
}
#endif
if (m_MotionNum==-1) // not a remoteghost, or remghost didnt want to deal
{
if(!pSchema->GetMotion(off,&m_MotionNum))
m_MotionNum=-1;
}
if(m_MotionNum==-1)
{
Warning(("GroundLocoManeuver: unable to find motion at offset %d\n",off));
}
if (IsLocalGhost(pMotor->GetObjID()))
{
#ifndef SHIP
if (config_is_defined("ghost_motion_spew"))
{
mprintf("rGloco: Local ghost %d informing remote about schema %d, motion %d\n",
pMotor->GetObjID(), m_SchemaID, m_MotionNum);
}
#endif
// this is actually going to be intercepted inside here, and we're
// going to do something tricky, which is why the reception of gloco
// maneuvers is still in the NETWORK_LOCOS up there...
GhostSendMoCap(pMotor->GetObjID(),m_SchemaID,m_MotionNum,TRUE);
}
mxs_vector xlat;
float duration;
sMotionPhys phys;
m_MotionParam.flags=NULL;
// if(!MvrGetRawMovement(m_pMotor,m_MotionNum, xlat, duration,m_ButtZOffset))
if(!MvrGetRawMovement(m_pMotor,m_MotionNum, phys))
{
// couldn't get motion capture. just rotate
m_DoRotate=TRUE;
m_NewDirection=params.direction;
mx_zero_vec(&m_StrideXlat);
m_RotAng=m_NewDirection.tz-pState->facing.tz;
m_UseBend=FALSE;
m_MotRotAng=0;
return;
}
xlat=phys.xlat;
m_MotRotAng=phys.endDir;
duration=phys.duration;
m_ButtZOffset=phys.buttZOffset;
m_DoRotate=TRUE;
float stretch=1.0;
if(pSchema->GetDistance(&dist))
{
if(phys.distance>0.1)
stretch=dist/phys.distance;
} else
{
pSchema->GetStretch(&stretch);
}
if(m_pGaitData->stretch!=1.0) // get multiplied by schema stretch
{
stretch*=m_pGaitData->stretch;
}
if(stretch!=1.0)
{
m_MotionParam.flags|=MP_STRETCH;
m_MotionParam.stretch=stretch;
mx_scaleeq_vec(&xlat,stretch);
} else
{
m_MotionParam.stretch=1.0;
}
// shrink motion xlat if desired 2D distance to travel is less
// than xlat
//
m_UseBend=!m_FirstStride; // never bend on first stride
// calc how much to shrink mocap, and scale xlat accordingly
if(params.mask&kMotParmFlag_Distance)
{
mxs_vector tmp;
float mag;
tmp.x=xlat.x;
tmp.y=xlat.y;
tmp.z=0;
ConfigSpew("MnvrTrace",("dist param %g\n",params.distance));
// check xlat big enough for this to matter
mag=mx_mag2_vec(&tmp);
if(mag>0.3)
{
float frac=(params.distance*params.distance)/mag;
if(frac<1.0) // shrink the motion
{
// take sqrt to get accurate frac
frac=sqrt(frac);
m_UseBend=FALSE; // since want to hit point exactly
ConfigSpew("MnvrTrace",("shrink %d by %g\n",m_MotionNum,frac));
mx_scaleeq_vec(&xlat,frac);
m_MotionParam.flags|=MP_STRETCH;
m_MotionParam.stretch*=frac;
}
}
}
m_NewDirection=params.direction;
// @TODO: modify desired direction of motion, due to
// physical constraints etc.
m_ExpectedEndFacing=m_NewDirection;
// Compute motion parameters and endpoints
//
mxs_matrix mat;
mxs_ang rot;
// if want to use bend,
// rotate xlat by facing/2, since motion bending will have this effect
// (which is different from rotating multiped and then doing motion.
// NOTE: this assumes that raw translation is along x-axis, so motion
// must be processed as a locomotion
m_RotAng=m_NewDirection.tz-pState->facing.tz-m_MotRotAng;
if(m_UseBend)
{
if(m_RotAng>MX_ANG_PI)
{
rot=2*MX_ANG_PI-((2*MX_ANG_PI-m_RotAng)/2);
} else
{
rot=m_RotAng/2;
}
} else
{
rot=m_RotAng;
}
mx_mk_rot_z_mat(&mat,pState->facing.tz+rot);
mx_mat_muleq_vec(&mat,&xlat);
// assume always timewarp, since noise always applied.
duration*=timeWarp;
m_MotionParam.flags|=MP_DURATION_SCALE;
m_MotionParam.duration_scalar=timeWarp;
// compute motion stretch and bend params
// XXX NOTE: this won't work properly if distance flag is also
// set!
if(params.mask&kMotParmFlag_ExactSpeed)
{
// stretch motion by fraction of distance it will cover by default vs
// distance that we want covered.
float desiredDist=params.exactSpeed*duration;
float actualDist=phys.distance;
float frac=(actualDist>0.1)?(desiredDist/actualDist):1.0;
mx_scale_vec(&m_StrideXlat,&xlat,frac);
m_MotionParam.flags|=MP_STRETCH;
m_MotionParam.stretch=frac;
} else
{
m_StrideXlat=xlat;
}
}
cGroundLocoManeuver::~cGroundLocoManeuver()
{
m_IsBeingDeleted=TRUE;
// Stop motion if one is playing
if(m_MotionNum>=0 && m_pMotor!= NULL)
m_pMotor->StopMotion(m_MotionNum);
}
void cGroundLocoManeuver::GetExpectedEndMoveState(sMcMoveState &moveState)
{
AssertMsg(FALSE,"GetExpectedEndMoveState not implemented for GroundLoco maneuver");
}
#define kVerticalTolerance 0.2 // feet
#define kGroundRaycastOffset 1.5 // feet
#define min(x,y) ((x)<(y)?(x):(y))
#define max(x,y) ((x)>(y)?(x):(y))
void cGroundLocoManeuver::Execute()
{
Assert_(m_pCoord);
sMcMotorState *pS=m_pCoord->GetInterMnvrState();
m_pCoord->ClearInterMnvrState();
pS->lastSchemaID=m_SchemaID;
if(m_DoRotate)
{
if(m_UseBend)
{
ConfigSpew("MnvrTrace",("bend %d\n",fixang_to_degrees(m_RotAng)));
m_MotionParam.flags|=MP_BEND;
if(m_RotAng>MX_ANG_PI)
{
m_MotionParam.bend=(mx_ang2rad(m_RotAng)-2*MX_REAL_PI)/2;
} else
{
m_MotionParam.bend=mx_ang2rad(m_RotAng/2);
}
} else
{
// with not-forward-facing motions
// NOTE: this assumes that direction of action in motion capture
// is along the x-axis
ConfigSpew("MnvrTrace",("rotate so dir %x\n",m_NewDirection.tz));
mxs_angvec dir=m_NewDirection;
dir.tz-=m_MotRotAng;
m_pMotor->SetOrientation(&dir,FALSE);
}
}
if(m_MotionNum<0)
{
sMcMoveState state;
// XXX need to rework this end state stuff
AssertMsg(m_pCoord,"No motion coordinator for maneuver!");
m_pCoord->NotifyAboutManeuverCompletion(this,state);
} else
{
// check ground height
Location curLoc=*m_pMotor->GetLocation();
mxs_vector newPos;
Location newLoc,hitLoc,fromLoc;
ObjID hitObj;
float offset;
mxs_real groundHeight;
BOOL foundGround;
float desiredZ=0;
// first, move to ground if not already grounded
// @TODO: enter into freefall instead.
if(MvrFindGroundHeight(m_pMotor->GetObjID(),&curLoc,&groundHeight,&hitObj))
{
mxs_vector buttPos;
MvrGetEndButtHeight(m_pMotor,m_MotionNum,&desiredZ);
desiredZ+=groundHeight;
if(fabs(desiredZ-curLoc.vec.z)>kVerticalTolerance)
{
mx_copy_vec(&buttPos,&curLoc.vec);
buttPos.z=desiredZ;
m_pMotor->SetPosition(&buttPos);
curLoc.vec.z=desiredZ;
}
}
// raycast to see if terrain in the way
// want to raycast from around knee height, so balconies work etc.
// NOTE: really don't want to be doing this at all anyway. (KJ 1/98)
// first find current ground height
fromLoc=curLoc;
if(MvrFindGroundHeight(m_pMotor->GetObjID(),&fromLoc,&groundHeight,&hitObj))
{
fromLoc.vec.z=groundHeight+kGroundRaycastOffset;
}
mx_add_vec(&newPos,(mxs_vector *)&fromLoc.vec,&m_StrideXlat);
MakeHintedLocationFromVector(&newLoc,&newPos,&curLoc);
if (PhysRaycast(fromLoc, newLoc, &hitLoc, &hitObj, 0.0) == kCollideNone)
{
// find ground height at end of stride
foundGround=MvrFindGroundHeight(m_pMotor->GetObjID(), &newLoc,&groundHeight,&hitObj);
} else
{
// find ground height at just before terrain collision
// XXX this should not really be fractional, but 'tis simpler
mx_interpolate_vec(&newLoc.vec,&curLoc.vec,&hitLoc.vec,0.95);
foundGround=MvrFindGroundHeight(m_pMotor->GetObjID(),&newLoc,&groundHeight,&hitObj);
}
// NOTE: this should work even though newPos.z isn't new butt
// height, since newpos term cancels out
mx_copy_vec(&m_ExpectedEndPos,&newPos);
if(foundGround)
{
offset=(groundHeight+m_ButtZOffset-(curLoc.vec.z+m_StrideXlat.z));
m_ExpectedEndPos.z=groundHeight+m_ButtZOffset;
} else
{
hitObj = OBJ_NULL;
offset=0;
m_ExpectedEndPos.z=curLoc.vec.z+m_StrideXlat.z;
}
// set the standing obj
MvrSetStandingObj(m_pMotor->GetObjID(), hitObj);
// and set its offset
if (!IsTextureObj(hitObj))
MvrSetStandingOffset(m_pMotor->GetObjID(), hitObj, &m_ExpectedEndPos);
else
{
mxs_vector offset = {0, 0, m_ButtZOffset};
MvrSetTerrStandingOffset(m_pMotor->GetObjID(), &offset);
}
// if(ffabsf(offset)>kVerticalTolerance)
if(fabs(offset)>kVerticalTolerance)
{
// XXX checking vertical tolereances
// should really happen at motion coordinator level, I think,
// since AI can force non-physical velocities also. Should be up
// to coordinator or cerebellum to decide to discard path because of
// ground height or passing through terrain. Doing it here for
// now, since there is currently no path checking
AssertMsg(m_pGaitData,"no gait data");
// truncate offset to max for gait
offset=min(offset,m_pGaitData->maxAscend);
offset=max(offset,m_pGaitData->maxDescend);
m_MotionParam.flags|=MP_VINC;
m_MotionParam.vinc=offset;
}
if(m_FirstStride)
m_pMotor->StartMotionWithParam(m_MotionNum,&m_MotionParam,kMotStartFlag_ForceBlend);
else
m_pMotor->StartMotionWithParam(m_MotionNum,&m_MotionParam);
}
}
// XXX need to rework this end state stuff
void cGroundLocoManeuver::NotifyAboutMotionEnd(int motionNum, int frame, ulong flags)
{
sMcMoveState state;
AssertMsg(m_pCoord,"No motion coordinator for maneuver!");
// only tell coordinator if maneuver not in middle of being deleted
if(!m_IsBeingDeleted&&motionNum==m_MotionNum)
{
mxs_vector diff,pos;
mxs_angvec ang;
// see if really ended up where thought it would
m_pMotor->GetTransform(&pos,&ang);
mx_sub_vec(&diff,&m_ExpectedEndPos,&pos);
diff.z=0;
if(config_is_defined("MnvrTrace"))
{
ConfigSpew("MnvrTrace",("delta %g, %g mag %g ang %d\n",diff.x,diff.y,mx_mag_vec(&diff),\
fixang_to_degrees(ang.tz-m_NewDirection.tz) ));
}
m_pCoord->NotifyAboutManeuverCompletion(this,state);
}
}
| [
"[email protected]"
] | |
e5acefc5c38b77ece6fcfd85caf4616979005e75 | 2e26ae5f12a22d8672cd6174ee2986a62df854a6 | /Library/Low-Power-master/Examples/powerDownWakePeriodic/powerDownWakePeriodic.ino | 6e0ea78dc2097922e2b4d8f6fcd3165fb4e66d38 | [] | no_license | UnHappyWolf/Electro_lock | 41c3075bd33e07015e01d2967aaa0111c1188889 | a55134d912f0f817d4289b7725cffdd335f1fc22 | refs/heads/master | 2023-03-16T19:54:36.889572 | 2018-05-28T20:53:47 | 2018-05-28T20:53:47 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 128 | ino | #include "LowPower.h"
void setup() {
}
void loop() {
delay(4000);
LowPower.powerDown(SLEEP_FOREVER, ADC_OFF, BOD_OFF);
}
| [
"[email protected]"
] | |
e75ff7b106f40b10a59d97b18eb5583d09b4f2c0 | 29542073b321149b205587bcf0f5c25cadb55137 | /src/FFmpegH264Source.cpp | 24736955e364871e77ffd572bf6032ef3ef05d23 | [] | no_license | all4loo/rtsp_stream | 849f0fa469c9e71d4a749eb03e6669798034903b | 802f2ec3f1f38842f16ba6e189a0d015eec50cfb | refs/heads/master | 2020-07-13T00:21:58.303252 | 2019-08-28T15:38:50 | 2019-08-28T15:38:50 | 204,945,769 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,085 | cpp | //
// FFmpegH264Source.cpp
// FFmpegRTSPServer
//
// Created by Mina Saad on 9/22/15.
// Copyright (c) 2015 Mina Saad. All rights reserved.
//
#include "FFmpegH264Source.h"
namespace MESAI
{
FFmpegH264Source * FFmpegH264Source::createNew(UsageEnvironment& env, FFmpegH264Encoder * E_Source) {
return new FFmpegH264Source(env, E_Source);
}
FFmpegH264Source::FFmpegH264Source(UsageEnvironment& env, FFmpegH264Encoder * E_Source) : FramedSource(env), Encoding_Source(E_Source)
{
m_eventTriggerId = envir().taskScheduler().createEventTrigger(FFmpegH264Source::deliverFrameStub);
std::function<void()> callback1 = std::bind(&FFmpegH264Source::onFrame,this);
Encoding_Source -> setCallbackFunctionFrameIsReady(callback1);
}
FFmpegH264Source::~FFmpegH264Source()
{
}
void FFmpegH264Source::doStopGettingFrames()
{
FramedSource::doStopGettingFrames();
}
void FFmpegH264Source::onFrame()
{
envir().taskScheduler().triggerEvent(m_eventTriggerId, this);
}
void FFmpegH264Source::doGetNextFrame()
{
deliverFrame();
}
void FFmpegH264Source::deliverFrame()
{
if (!isCurrentlyAwaitingData()) return; // we're not ready for the data yet
static uint8_t* newFrameDataStart;
static unsigned newFrameSize = 0;
/* get the data frame from the Encoding thread.. */
if (Encoding_Source->GetFrame(&newFrameDataStart, &newFrameSize)){
if (newFrameDataStart!=NULL) {
/* This should never happen, but check anyway.. */
if (newFrameSize > fMaxSize) {
fFrameSize = fMaxSize;
fNumTruncatedBytes = newFrameSize - fMaxSize;
} else {
fFrameSize = newFrameSize;
}
gettimeofday(&fPresentationTime, NULL);
memcpy(fTo, newFrameDataStart, fFrameSize);
//delete newFrameDataStart;
//newFrameSize = 0;
Encoding_Source->ReleaseFrame();
}
else {
fFrameSize=0;
fTo=NULL;
handleClosure(this);
}
}else
{
fFrameSize = 0;
}
if(fFrameSize>0)
FramedSource::afterGetting(this);
}
} | [
"[email protected]"
] | |
8464236d251cd8bff1f81d5331216f38f8ec2b35 | 07c86589e7fd1408df0b3d2886e7dabf9c61ce02 | /InvestmentManager/InvestDb.cpp | 30042956b73d19b35278f5f5b7f571905ffd6ff8 | [] | no_license | conanconan/InvestmentManager | 7130b0fba4b59069e2cea6a04357c6cadff325d4 | 49d25eed0a8ce99e34f8bdd06805de68c7cc2ad5 | refs/heads/master | 2020-12-30T14:13:50.864541 | 2017-08-12T10:08:23 | 2017-08-12T10:08:23 | 91,299,260 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,489 | cpp | #include "pch.h"
#include "InvestDb.h"
#include "Utility.h"
const std::wstring dayTableName(L"DailyInfo");
CInvestDb::CInvestDb(const std::experimental::filesystem::path& dbFilePath,
const std::map<std::wstring, std::vector<std::wstring>>& dbTable)
: CDbWrapper(dbFilePath, dbTable), m_filePath(dbFilePath), m_table(dbTable)
{
}
CInvestDb::~CInvestDb()
{
}
bool CInvestDb::QueryData(std::wstring dataId, boost::gregorian::date date, CDataItem& data)
{
CAutoLock lock(m_dbMutex);
std::wstringstream condition;
condition << L"id = '" << dataId.c_str() << "' and "
<< "date = '" << boost::gregorian::to_iso_wstring(date).c_str() << "'";
std::vector<std::vector<std::wstring>> queryData;
if (CDbWrapper::QueryData(dayTableName.c_str(), { L"*" }, condition.str(), queryData) &&
queryData.size() == 1)
{
auto& item = queryData[0];
data.date = item[0];
data.id = item[1];
data.name = item[2];
data.totalVolume = item[3];
data.openingPrice = item[4];
data.closingPrice = item[5];
data.dayHighPrice = item[6];
data.dayLowPrice = item[7];
return true;
}
return false;
}
bool CInvestDb::InsertData(CDataItem& data)
{
CAutoLock lock(m_dbMutex);
return CDbWrapper::InsertData(dayTableName.c_str(),
{ data.date, data.id, data.name, data.totalVolume,
data.openingPrice, data.closingPrice, data.dayHighPrice, data.dayLowPrice });
} | [
"[email protected]"
] | |
38de92e42f767a59f2daeb39d116133cde223d50 | ad0248bf3d3a24ca15a303e31ba53c210d90c448 | /Source/CatchMe/character/LuaAnimInstance.cpp | e6f9883e7fd74b0544113451122f1ac14a9db498 | [
"MIT"
] | permissive | quabqi/unreal.lua | 31822dc3cfc8c4e1869e958c714e8c97ac49f912 | 7702ac91f3fb7d29dea4bfb9d01e5b40e6956a68 | refs/heads/master | 2020-03-28T03:42:35.298417 | 2018-05-31T02:35:19 | 2018-05-31T02:35:19 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 467 | cpp | // Fill out your copyright notice in the Description page of Project Settings.
#include "LuaAnimInstance.h"
#include "tableutil.h"
ULuaAnimInstance::ULuaAnimInstance()
{
LuaCtor("character.animinstance", this);
}
void ULuaAnimInstance::NativeInitializeAnimation()
{
LuaCall("NativeInitializeAnimation", this);
}
void ULuaAnimInstance::NativeUpdateAnimation(float DeltaSeconds)
{
LuaCall("NativeUpdateAnimation", this, DeltaSeconds);
}
| [
"[email protected]"
] | |
c2c0cffd61656ae54051659e093d1319cdcf5796 | e65e6b345e98633cccc501ad0d6df9918b2aa25e | /Codechef/Long Challenge/18Oct/SURCHESS.cpp | 9adda68ec4d5e6bef3520b92a074a9ee6a8e35c5 | [] | no_license | wcysai/CodeLibrary | 6eb99df0232066cf06a9267bdcc39dc07f5aab29 | 6517cef736f1799b77646fe04fb280c9503d7238 | refs/heads/master | 2023-08-10T08:31:58.057363 | 2023-07-29T11:56:38 | 2023-07-29T11:56:38 | 134,228,833 | 5 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 2,272 | cpp | /*************************************************************************
> File Name: SURCHESS.cpp
> Author: Roundgod
> Mail: [email protected]
> Created Time: 2018-10-08 12:45:44
************************************************************************/
#pragma GCC optimize(3)
#include<bits/stdc++.h>
#define MAXN 205
#define INF 1000000000
#define MOD 1000000007
#define F first
#define S second
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
int N,M,Q,sum[4][MAXN][MAXN];
char str[MAXN][MAXN];
int need[MAXN];
int main()
{
scanf("%d%d",&N,&M);
for(int i=1;i<=N;i++) scanf("%s",str[i]+1);
for(int i=1;i<=N;i++)
for(int j=1;j<=M;j++)
{
sum[0][i][j]=sum[0][i][j-1]+(str[i][j]=='1'&&((i+j)&1));
sum[1][i][j]=sum[1][i][j-1]+(str[i][j]=='1'&&(!((i+j)&1)));
sum[2][i][j]=sum[2][i][j-1]+(str[i][j]=='0'&&((i+j)&1));
sum[3][i][j]=sum[3][i][j-1]+(str[i][j]=='0'&&(!((i+j)&1)));
}
for(int i=1;i<=N;i++)
for(int j=1;j<=M;j++)
for(int k=0;k<4;k++)
sum[k][i][j]+=sum[k][i-1][j];
for(int i=1;i<=200;i++) need[i]=INF;
for(int d=1;d<=min(N,M);d++)
for(int i=1;i+d-1<=N;i++)
for(int j=1;j+d-1<=M;j++)
{
int even,odd;
if(d&1)
{
if((i+j)&1) {even=d*d/2;odd=d*d-even;}
else {odd=d*d/2; even=d*d-odd;}
}
else {even=odd=d*d/2;}
int odd0=sum[0][i+d-1][j+d-1]-sum[0][i-1][j+d-1]-sum[0][i+d-1][j-1]+sum[0][i-1][j-1];
int even0=sum[1][i+d-1][j+d-1]-sum[1][i-1][j+d-1]-sum[1][i+d-1][j-1]+sum[1][i-1][j-1];
int odd1=sum[2][i+d-1][j+d-1]-sum[2][i-1][j+d-1]-sum[2][i+d-1][j-1]+sum[2][i-1][j-1];
int even1=sum[3][i+d-1][j+d-1]-sum[3][i-1][j+d-1]-sum[3][i+d-1][j-1]+sum[3][i-1][j-1];
need[d]=min(need[d],odd-odd0+even-even1);
need[d]=min(need[d],odd-odd1+even-even0);
}
scanf("%d",&Q);
for(int i=0;i<Q;i++)
{
int x;scanf("%d",&x);
for(int j=min(N,M);j>=1;j--)
if(need[j]<=x) {printf("%d\n",j); break;}
}
return 0;
}
| [
"[email protected]"
] | |
e3da893b15d7daec4cbfa2a94a69859dc6defa2c | 2639be0c4fd4b2e121cd32c95253332cb9a25ba5 | /parsec_arduino/src/servo_sweep.cpp | 90dbeca91b2b8c1887bc5b7493bc428419f6c1bd | [] | no_license | tony1213/parsec | 736215b59afb1cc0509d49d7cecb8c81cda20226 | dfd1c58b577b0e857fcb2a952e64a095c7da3679 | refs/heads/master | 2021-01-19T02:25:56.229414 | 2012-03-30T16:32:23 | 2012-03-30T16:32:23 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,115 | cpp | // Copyright 2011 Google Inc.
// Author: [email protected] (Wolfgang Hess)
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "servo_sweep.h"
#include <math.h>
bool ServoSweep::attached_ = false;
const int ServoSweep::kPrescaler = 8;
ServoSweep::ServoSweep(OnSignalCallback callback)
: increasing_duration_(0),
decreasing_duration_(0),
min_pwm_period_(0),
max_pwm_period_(0),
min_servo_pwm_period_(0),
max_servo_pwm_period_(0),
pwm_period_per_radian_(0),
min_servo_angle_(0.0f),
max_servo_angle_(0.0f),
increasing_phase_offset_(0),
decreasing_phase_offset_(0),
direction_(ANGLE_INCREASING),
on_signal_(callback) {}
void ServoSweep::Attach() {
// CHECK(!attached_);
attached_ = true;
// We use PWM pin 11, a.k.a. PB5, timer 1.
pinMode(11, OUTPUT);
// Prescaler 8 means the 16-bit timer can run for at most 32.768 ms before
// overflowing at 16 MHz.
unsigned long long frequency = F_CPU;
// Update the servo every 10 ms.
unsigned int max_timer_value = frequency * 10 / 1000 / kPrescaler - 1;
ICR1 = max_timer_value;
TCNT1 = 0;
// Initialize timer 1 Fast PWM with ICR1 as TOP (mode 14 = WGM13|WGM12|WGM11).
TCCR1B = _BV(CS11) | _BV(WGM13) | _BV(WGM12); // kPrescaler == 8.
TCCR1A = _BV(COM1A1) | _BV(WGM11); // Non-inverting mode.
}
void ServoSweep::UpdateMicroseconds(unsigned int pulse_width) {
unsigned long long frequency = F_CPU;
unsigned int time_value = frequency * pulse_width / 1000000ul / kPrescaler;
OCR1A = time_value;
}
void ServoSweep::SetParameters(
unsigned int min_pwm_period, unsigned int max_pwm_period,
float min_angle, float max_angle,
int increasing_phase_offset, int decreasing_phase_offset) {
// CHECK(min_angle >= 0);
// CHECK(max_angle >= min_angle);
min_servo_pwm_period_ = min_pwm_period;
max_servo_pwm_period_ = max_pwm_period;
min_servo_angle_ = min_angle;
max_servo_angle_ = max_angle;
increasing_phase_offset_ = increasing_phase_offset;
decreasing_phase_offset_ = decreasing_phase_offset;
pwm_period_per_radian_ = (max_servo_pwm_period_ - min_servo_pwm_period_) /
(max_servo_angle_ - min_servo_angle_);
// Move to the perpendicular position for a visual sanity check of the
// parameters.
unsigned int pwm_period =
min_servo_pwm_period_ - min_servo_angle_ * pwm_period_per_radian_;
UpdateMicroseconds(pwm_period);
}
void ServoSweep::SetProfile(float min_angle, float max_angle,
float increasing_duration, float decreasing_duration) {
increasing_duration_ = increasing_duration * 1e6;
decreasing_duration_ = decreasing_duration * 1e6;
// CHECK(max_angle >= min_angle);
// CHECK(min_angle >= min_servo_angle_);
// CHECK(max_angle <= max_servo_angle_);
min_pwm_period_ = (min_angle - min_servo_angle_) * pwm_period_per_radian_
+ min_servo_pwm_period_;
max_pwm_period_ = (max_angle - min_servo_angle_) * pwm_period_per_radian_
+ min_servo_pwm_period_;
if (min_pwm_period_ < min_servo_pwm_period_) {
min_pwm_period_ = min_servo_pwm_period_;
}
if (max_pwm_period_ > max_servo_pwm_period_) {
max_pwm_period_ = max_servo_pwm_period_;
}
}
float ServoSweep::Update() {
// Do nothing if tilting is disabled.
if (increasing_duration_ == 0 || decreasing_duration_ == 0) {
return 0.0f;
}
// Map the current time into the interval [0, period).
unsigned long long position =
micros() % (increasing_duration_ + decreasing_duration_);
if (position > increasing_duration_) {
position = increasing_duration_ + decreasing_duration_ - position;
SetDirection(ANGLE_DECREASING);
} else {
SetDirection(ANGLE_INCREASING);
}
unsigned long current_duration;
if (direction_ == ANGLE_INCREASING) {
current_duration = increasing_duration_;
} else {
current_duration = decreasing_duration_;
}
// Map the variable position into the interval [min_pwm_period_, max_pwm_period_).
unsigned int pwm_range = max_pwm_period_ - min_pwm_period_;
unsigned int pwm_period =
min_pwm_period_ + position * pwm_range / current_duration;
UpdateMicroseconds(pwm_period);
return static_cast<float>(pwm_period - min_servo_pwm_period_) / pwm_period_per_radian_ + min_servo_angle_;
}
int ServoSweep::GetPhaseOffset() {
if (direction_ == ANGLE_INCREASING) {
return increasing_phase_offset_;
}
return decreasing_phase_offset_;
}
void ServoSweep::SetDirection(ServoDirection new_direction) {
if (new_direction != direction_) {
direction_ = new_direction;
if (on_signal_) {
on_signal_(direction_);
}
}
}
| [
"[email protected]"
] | |
3e6df976df3602decce73916788a43e106f4b07c | 1ef14a2a52d6844bd931f80a556629f5f9c11349 | /goopdate/command_line_parser.cc | 66e9d3fa6bed99af015749e8b1330c759c72bfed | [
"Apache-2.0"
] | permissive | pauldotknopf/omaha | c61a58dee395a70e658f53a7b33cefab9fed5eb6 | 7f70869253aeebadb4f52db5306bde5571d71524 | refs/heads/master | 2020-04-11T12:21:03.800672 | 2011-08-17T01:07:48 | 2011-08-17T01:07:48 | 32,242,630 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 12,373 | cc | // Copyright 2008-2009 Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// ========================================================================
#include "omaha/goopdate/command_line_parser.h"
#include <shellapi.h>
#include "omaha/common/debug.h"
#include "omaha/common/error.h"
#include "omaha/common/logging.h"
namespace omaha {
namespace internal {
void CommandLineParserArgs::Reset() {
switch_arguments_.clear();
}
// Assumes switch_name is already lower case.
HRESULT CommandLineParserArgs::AddSwitch(const CString& switch_name) {
ASSERT1(CString(switch_name).MakeLower().Compare(switch_name) == 0);
if (switch_arguments_.find(switch_name) != switch_arguments_.end()) {
return E_INVALIDARG;
}
StringVector string_vector;
switch_arguments_[switch_name] = string_vector;
return S_OK;
}
// Assumes switch_name is already lower case.
HRESULT CommandLineParserArgs::AddSwitchArgument(const CString& switch_name,
const CString& value) {
ASSERT1(CString(switch_name).MakeLower().Compare(switch_name) == 0);
ASSERT1(!switch_name.IsEmpty());
if (switch_name.IsEmpty()) {
// We don't have a switch yet, so this is just a base argument.
// Example command line: "foo.exe myarg /someswitch"
// Here, myarg would be a base argument.
// TODO(omaha): base_args_.push_back(switch_name_str);
return E_INVALIDARG;
}
SwitchAndArgumentsMap::iterator iter = switch_arguments_.find(switch_name);
if (iter == switch_arguments_.end()) {
return E_UNEXPECTED;
}
(*iter).second.push_back(value);
return S_OK;
}
int CommandLineParserArgs::GetSwitchCount() const {
return switch_arguments_.size();
}
bool CommandLineParserArgs::HasSwitch(const CString& switch_name) const {
CString switch_name_lower = switch_name;
switch_name_lower.MakeLower();
return switch_arguments_.find(switch_name_lower) != switch_arguments_.end();
}
// The value at a particular index may change if switch_names are added
// since we're using a map underneath. But this keeps us from having to write
// an interator and expose it externally.
HRESULT CommandLineParserArgs::GetSwitchNameAtIndex(int index,
CString* name) const {
ASSERT1(name);
if (index >= static_cast<int>(switch_arguments_.size())) {
return E_INVALIDARG;
}
SwitchAndArgumentsMapIter iter = switch_arguments_.begin();
for (int i = 0; i < index; ++i) {
++iter;
}
*name = (*iter).first;
return S_OK;
}
HRESULT CommandLineParserArgs::GetSwitchArgumentCount(
const CString& switch_name, int* count) const {
ASSERT1(count);
CString switch_name_lower = switch_name;
switch_name_lower.MakeLower();
SwitchAndArgumentsMapIter iter = switch_arguments_.find(switch_name_lower);
if (iter == switch_arguments_.end()) {
return E_INVALIDARG;
}
*count = (*iter).second.size();
return S_OK;
}
HRESULT CommandLineParserArgs::GetSwitchArgumentValue(
const CString& switch_name,
int argument_index,
CString* argument_value) const {
ASSERT1(argument_value);
CString switch_name_lower = switch_name;
switch_name_lower.MakeLower();
int count = 0;
HRESULT hr = GetSwitchArgumentCount(switch_name_lower, &count);
if (FAILED(hr)) {
return hr;
}
if (argument_index >= count) {
return E_INVALIDARG;
}
SwitchAndArgumentsMapIter iter = switch_arguments_.find(switch_name_lower);
if (iter == switch_arguments_.end()) {
return E_INVALIDARG;
}
*argument_value = (*iter).second[argument_index];
return S_OK;
}
} // namespace internal
CommandLineParser::CommandLineParser() {
}
CommandLineParser::~CommandLineParser() {
}
HRESULT CommandLineParser::ParseFromString(const wchar_t* command_line) {
CString command_line_str(command_line);
command_line_str.Trim(_T(" "));
int argc = 0;
wchar_t** argv = ::CommandLineToArgvW(command_line_str, &argc);
if (!argv) {
return HRESULTFromLastError();
}
HRESULT hr = ParseFromArgv(argc, argv);
::LocalFree(argv);
return hr;
}
// TODO(Omaha): Move the rule parser into a separate class.
// TODO(Omaha): Fail the regular command parser if [/ switch is passed.
// ParseFromArgv parses either a rule or a command line.
//
// Rules have required and optional parameters. An example of a rule is:
// "gu.exe /install <extraargs> [/oem [/appargs <appargs> [/silent"
// This creates a rule for a command line that requires "/install" for the rule
// to match. The other parameters are optional, indicated by prefixes of "[/".
//
// Command lines do not use "[/", and use "/" for all parameters.
// A command line that looks like this:
// "gu.exe /install <extraargs> /oem /appargs <appargs>"
// will match the rule above.
HRESULT CommandLineParser::ParseFromArgv(int argc, wchar_t** argv) {
if (argc == 0 || !argv) {
return E_INVALIDARG;
}
CORE_LOG(L5, (_T("[CommandLineParser::ParseFromArgv][argc=%d]"), argc));
Reset();
if (argc == 1) {
// We only have the program name. So, we're done parsing.
ASSERT1(!IsSwitch(argv[0]));
return S_OK;
}
CString current_switch_name;
bool is_optional_switch = false;
// Start parsing at the first argument after the program name (index 1).
for (int i = 1; i < argc; ++i) {
HRESULT hr = S_OK;
CString token = argv[i];
token.Trim(_T(" "));
CORE_LOG(L5, (_T("[Parsing arg][i=%d][argv[i]=%s]"), i, token));
if (IsSwitch(token)) {
hr = StripSwitchNameFromArgv(token, ¤t_switch_name);
if (FAILED(hr)) {
return hr;
}
hr = AddSwitch(current_switch_name);
if (FAILED(hr)) {
CORE_LOG(LE, (_T("[AddSwitch failed][%s][0x%x]"),
current_switch_name, hr));
return hr;
}
is_optional_switch = false;
} else if (IsOptionalSwitch(token)) {
hr = StripOptionalSwitchNameFromArgv(token, ¤t_switch_name);
if (FAILED(hr)) {
return hr;
}
hr = AddOptionalSwitch(current_switch_name);
if (FAILED(hr)) {
CORE_LOG(LE, (_T("[AddOptionalSwitch failed][%s][0x%x]"),
current_switch_name, hr));
return hr;
}
is_optional_switch = true;
} else {
hr = is_optional_switch ?
AddOptionalSwitchArgument(current_switch_name, token) :
AddSwitchArgument(current_switch_name, token);
if (FAILED(hr)) {
CORE_LOG(LE, (_T("[Adding switch argument failed][%d][%s][%s][0x%x]"),
is_optional_switch, current_switch_name, token, hr));
return hr;
}
}
}
return S_OK;
}
bool CommandLineParser::IsSwitch(const CString& param) const {
// Switches must have a prefix (/) or (-), and at least one character.
if (param.GetLength() < 2) {
return false;
}
// All switches must start with / or -, and not contain any spaces.
// Since the argv parser strips out the enclosing quotes around an argument,
// we need to handle the following cases properly:
// * foo.exe /switch arg -- /switch is a switch, arg is an arg
// * foo.exe /switch "/x y" -- /switch is a switch, '/x y' is an arg and it
// will get here _without_ the quotes.
// If param_str starts with / and contains no spaces, then it's a switch.
return ((param[0] == _T('/')) || (param[0] == _T('-'))) &&
(param.Find(_T(" ")) == -1) &&
(param.Find(_T("%20")) == -1);
}
bool CommandLineParser::IsOptionalSwitch(const CString& param) const {
// Optional switches must have a prefix ([/) or ([-), and at least one
// character.
return param[0] == _T('[') && IsSwitch(param.Right(param.GetLength() - 1));
}
HRESULT CommandLineParser::StripSwitchNameFromArgv(const CString& param,
CString* switch_name) {
ASSERT1(switch_name);
if (!IsSwitch(param)) {
return E_INVALIDARG;
}
*switch_name = param.Right(param.GetLength() - 1);
switch_name->Trim(_T(" "));
switch_name->MakeLower();
return S_OK;
}
HRESULT CommandLineParser::StripOptionalSwitchNameFromArgv(const CString& param,
CString* name) {
ASSERT1(name);
if (!IsOptionalSwitch(param)) {
return E_INVALIDARG;
}
return StripSwitchNameFromArgv(param.Right(param.GetLength() - 1), name);
}
void CommandLineParser::Reset() {
required_args_.Reset();
optional_args_.Reset();
}
HRESULT CommandLineParser::AddSwitch(const CString& switch_name) {
ASSERT1(switch_name == CString(switch_name).MakeLower());
return required_args_.AddSwitch(switch_name);
}
HRESULT CommandLineParser::AddSwitchArgument(const CString& switch_name,
const CString& argument_value) {
ASSERT1(switch_name == CString(switch_name).MakeLower());
return required_args_.AddSwitchArgument(switch_name, argument_value);
}
int CommandLineParser::GetSwitchCount() const {
return required_args_.GetSwitchCount();
}
bool CommandLineParser::HasSwitch(const CString& switch_name) const {
return required_args_.HasSwitch(switch_name);
}
// The value at a particular index may change if switch_names are added
// since we're using a map underneath. But this keeps us from having to write
// an interator and expose it externally.
HRESULT CommandLineParser::GetSwitchNameAtIndex(int index,
CString* switch_name) const {
return required_args_.GetSwitchNameAtIndex(index, switch_name);
}
HRESULT CommandLineParser::GetSwitchArgumentCount(const CString& switch_name,
int* count) const {
return required_args_.GetSwitchArgumentCount(switch_name, count);
}
HRESULT CommandLineParser::GetSwitchArgumentValue(
const CString& switch_name,
int argument_index,
CString* argument_value) const {
return required_args_.GetSwitchArgumentValue(switch_name,
argument_index,
argument_value);
}
HRESULT CommandLineParser::AddOptionalSwitch(const CString& switch_name) {
ASSERT1(switch_name == CString(switch_name).MakeLower());
return optional_args_.AddSwitch(switch_name);
}
HRESULT CommandLineParser::AddOptionalSwitchArgument(const CString& switch_name,
const CString& value) {
ASSERT1(switch_name == CString(switch_name).MakeLower());
return optional_args_.AddSwitchArgument(switch_name, value);
}
int CommandLineParser::GetOptionalSwitchCount() const {
return optional_args_.GetSwitchCount();
}
bool CommandLineParser::HasOptionalSwitch(const CString& switch_name) const {
return optional_args_.HasSwitch(switch_name);
}
// The value at a particular index may change if switch_names are added
// since we're using a map underneath. But this keeps us from having to write
// an interator and expose it externally.
HRESULT CommandLineParser::GetOptionalSwitchNameAtIndex(int index,
CString* name) const {
return optional_args_.GetSwitchNameAtIndex(index, name);
}
HRESULT CommandLineParser::GetOptionalSwitchArgumentCount(const CString& name,
int* count) const {
return optional_args_.GetSwitchArgumentCount(name, count);
}
HRESULT CommandLineParser::GetOptionalSwitchArgumentValue(const CString& name,
int argument_index,
CString* val) const {
return optional_args_.GetSwitchArgumentValue(name,
argument_index,
val);
}
} // namespace omaha
| [
"[email protected]@e782f428-02b4-11de-a43f-ff96a2b7a9af"
] | [email protected]@e782f428-02b4-11de-a43f-ff96a2b7a9af |
7e64747de6dc7d823dc623fad8aa6b6d8245d892 | 0b8d0ced82feb7bfc6f9c16580bafb8ab7bc6728 | /src/structure/map/hash.h | 6518b40bc03217c4496c31324c268635225f6c71 | [] | no_license | IvanUkhov/software-engineering | c04373027bd1e0e15ef5ba91329546f8435fb7d7 | 3e0fc543d6aacf06650dfc237f621c66ac8eb450 | refs/heads/main | 2022-10-30T15:09:57.873837 | 2022-10-12T20:06:22 | 2022-10-12T20:06:22 | 111,704,226 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,453 | h | #ifndef STRUCTURE_MAP_HASH_H_
#define STRUCTURE_MAP_HASH_H_
#include <cstddef>
#include <functional>
#include <memory>
#include <vector>
namespace structure { namespace map {
const std::size_t kInitialBreadth = 1 << 7;
const double kResizeThreshold = 0.8;
template <typename K, typename V, typename H = std::hash<K>>
class Hash {
public:
Hash() : size_(0), nodes_(kInitialBreadth) {}
V* Get(K key) const;
void Set(K key, V value);
double Load() const {
return static_cast<double>(Size()) / Breadth();
}
std::size_t Breadth() const {
return nodes_.size();
}
std::size_t Size() const {
return size_;
}
private:
struct Node {
Node(K key, V value, std::size_t hash)
: key(std::move(key)), value(std::move(value)), hash(hash) {}
K key;
V value;
std::size_t hash;
std::unique_ptr<Node> next;
};
void Set(std::unique_ptr<Node> candidate);
bool ShouldResize() const {
return Load() > kResizeThreshold;
}
void Resize();
H hash_;
std::size_t size_;
std::vector<std::unique_ptr<Node>> nodes_;
};
template <typename K, typename V, typename H>
V* Hash<K, V, H>::Get(K key) const {
auto* current = &nodes_[hash_(key) % Breadth()];
while (*current) {
if ((*current)->key == key) return &(*current)->value;
current = &(*current)->next;
}
return nullptr;
}
template <typename K, typename V, typename H>
void Hash<K, V, H>::Set(K key, V value) {
if (ShouldResize()) Resize();
auto hash = hash_(key);
Set(std::unique_ptr<Node>(new Node(std::move(key), std::move(value), hash)));
}
template <typename K, typename V, typename H>
void Hash<K, V, H>::Set(std::unique_ptr<Node> candidate) {
using std::swap;
auto* current = &nodes_[candidate->hash % Breadth()];
while (*current) {
if ((*current)->key == candidate->key) {
swap(*current, candidate);
return;
}
current = &(*current)->next;
}
swap(*current, candidate);
++size_;
}
template <typename K, typename V, typename H>
void Hash<K, V, H>::Resize() {
auto breadth = Breadth();
std::vector<std::unique_ptr<Node>> nodes(2 * breadth);
std::swap(nodes, nodes_);
size_ = 0;
for (auto i = 0; i < breadth; ++i) {
while (nodes[i]) {
auto candidate = std::unique_ptr<Node>(nodes[i].release());
nodes[i].reset(candidate->next.release());
Set(std::move(candidate));
}
}
}
} } // namespace structure::map
#endif // STRUCTURE_MAP_HASH_H_
| [
"[email protected]"
] | |
6a6231ed53eb77a5b6856c26a9136cb5aee7e992 | 89ab9c481bb50fb4ac1d75ca5a356d0a0cc12fb7 | /scwin/StringLengthConverters.h | 0e459115bdc77a00d96a8fb49e8d2f81be7ce0c8 | [] | no_license | vze2rdgy/scwin | 7884ddcd7126ff4792d05752be2470a587006418 | 735ecaa75c3043e04d9f518394a69e0589a7e821 | refs/heads/master | 2021-08-03T07:10:30.833267 | 2021-08-02T03:20:22 | 2021-08-02T03:20:22 | 156,920,387 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,131 | h | #pragma once
using namespace Windows::UI::Xaml::Data;
namespace scwin
{
public ref class StringLengthVisibilityConverter sealed :
public IValueConverter
{
public:
StringLengthVisibilityConverter();
// Inherited via IValueConverter
virtual Platform::Object ^ Convert(Platform::Object ^value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^parameter, Platform::String ^language);
virtual Platform::Object ^ ConvertBack(Platform::Object ^value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^parameter, Platform::String ^language);
};
public ref class StringLengthEnableConverter sealed :
public IValueConverter
{
public:
StringLengthEnableConverter();
// Inherited via IValueConverter
virtual Platform::Object ^ Convert(Platform::Object ^value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^parameter, Platform::String ^language);
virtual Platform::Object ^ ConvertBack(Platform::Object ^value, Windows::UI::Xaml::Interop::TypeName targetType, Platform::Object ^parameter, Platform::String ^language);
};
}
| [
"[email protected]"
] | |
5aeb3e1d7e4ae4e83af662b60a99c606836afeff | 1e0d62ffb3063f7f22c36f2fd7624d03706d03c3 | /src/bloom.cpp | 2273f8c0fab44e0a6855bebd9991ca7fb2404c54 | [
"MIT"
] | permissive | tbcoin/PikachuCoin | 7aca26676c8d41a4d2716bc8c880c10d12f5fa48 | ccff085fe9a887e306f342e204f3a50c5cdf50e9 | refs/heads/master | 2020-04-06T04:52:30.345968 | 2014-02-15T15:09:22 | 2014-02-15T15:09:22 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,048 | cpp | // Copyright (c) 2012 The PikachuCoin developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include <math.h>
#include <stdlib.h>
#include "bloom.h"
#include "main.h"
#include "script.h"
#define LN2SQUARED 0.4804530139182014246671025263266649717305529515945455
#define LN2 0.6931471805599453094172321214581765680755001343602552
using namespace std;
static const unsigned char bit_mask[8] = {0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80};
CBloomFilter::CBloomFilter(unsigned int nElements, double nFPRate, unsigned int nTweakIn, unsigned char nFlagsIn) :
// The ideal size for a bloom filter with a given number of elements and false positive rate is:
// - nElements * log(fp rate) / ln(2)^2
// We ignore filter parameters which will create a bloom filter larger than the protocol limits
vData(min((unsigned int)(-1 / LN2SQUARED * nElements * log(nFPRate)), MAX_BLOOM_FILTER_SIZE * 8) / 8),
// The ideal number of hash functions is filter size * ln(2) / number of elements
// Again, we ignore filter parameters which will create a bloom filter with more hash functions than the protocol limits
// See http://en.wikipedia.org/wiki/Bloom_filter for an explanation of these formulas
isFull(false),
isEmpty(false),
nHashFuncs(min((unsigned int)(vData.size() * 8 / nElements * LN2), MAX_HASH_FUNCS)),
nTweak(nTweakIn),
nFlags(nFlagsIn)
{
}
inline unsigned int CBloomFilter::Hash(unsigned int nHashNum, const std::vector<unsigned char>& vDataToHash) const
{
// 0xFBA4C795 chosen as it guarantees a reasonable bit difference between nHashNum values.
return MurmurHash3(nHashNum * 0xFBA4C795 + nTweak, vDataToHash) % (vData.size() * 8);
}
void CBloomFilter::insert(const vector<unsigned char>& vKey)
{
if (isFull)
return;
for (unsigned int i = 0; i < nHashFuncs; i++)
{
unsigned int nIndex = Hash(i, vKey);
// Sets bit nIndex of vData
vData[nIndex >> 3] |= bit_mask[7 & nIndex];
}
isEmpty = false;
}
void CBloomFilter::insert(const COutPoint& outpoint)
{
CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
stream << outpoint;
vector<unsigned char> data(stream.begin(), stream.end());
insert(data);
}
void CBloomFilter::insert(const uint256& hash)
{
vector<unsigned char> data(hash.begin(), hash.end());
insert(data);
}
bool CBloomFilter::contains(const vector<unsigned char>& vKey) const
{
if (isFull)
return true;
if (isEmpty)
return false;
for (unsigned int i = 0; i < nHashFuncs; i++)
{
unsigned int nIndex = Hash(i, vKey);
// Checks bit nIndex of vData
if (!(vData[nIndex >> 3] & bit_mask[7 & nIndex]))
return false;
}
return true;
}
bool CBloomFilter::contains(const COutPoint& outpoint) const
{
CDataStream stream(SER_NETWORK, PROTOCOL_VERSION);
stream << outpoint;
vector<unsigned char> data(stream.begin(), stream.end());
return contains(data);
}
bool CBloomFilter::contains(const uint256& hash) const
{
vector<unsigned char> data(hash.begin(), hash.end());
return contains(data);
}
bool CBloomFilter::IsWithinSizeConstraints() const
{
return vData.size() <= MAX_BLOOM_FILTER_SIZE && nHashFuncs <= MAX_HASH_FUNCS;
}
bool CBloomFilter::IsRelevantAndUpdate(const CTransaction& tx, const uint256& hash)
{
bool fFound = false;
// Match if the filter contains the hash of tx
// for finding tx when they appear in a block
if (isFull)
return true;
if (isEmpty)
return false;
if (contains(hash))
fFound = true;
for (unsigned int i = 0; i < tx.vout.size(); i++)
{
const CTxOut& txout = tx.vout[i];
// Match if the filter contains any arbitrary script data element in any scriptPubKey in tx
// If this matches, also add the specific output that was matched.
// This means clients don't have to update the filter themselves when a new relevant tx
// is discovered in order to find spending transactions, which avoids round-tripping and race conditions.
CScript::const_iterator pc = txout.scriptPubKey.begin();
vector<unsigned char> data;
while (pc < txout.scriptPubKey.end())
{
opcodetype opcode;
if (!txout.scriptPubKey.GetOp(pc, opcode, data))
break;
if (data.size() != 0 && contains(data))
{
fFound = true;
if ((nFlags & BLOOM_UPDATE_MASK) == BLOOM_UPDATE_ALL)
insert(COutPoint(hash, i));
else if ((nFlags & BLOOM_UPDATE_MASK) == BLOOM_UPDATE_P2PUBKEY_ONLY)
{
txnouttype type;
vector<vector<unsigned char> > vSolutions;
if (Solver(txout.scriptPubKey, type, vSolutions) &&
(type == TX_PUBKEY || type == TX_MULTISIG))
insert(COutPoint(hash, i));
}
break;
}
}
}
if (fFound)
return true;
BOOST_FOREACH(const CTxIn& txin, tx.vin)
{
// Match if the filter contains an outpoint tx spends
if (contains(txin.prevout))
return true;
// Match if the filter contains any arbitrary script data element in any scriptSig in tx
CScript::const_iterator pc = txin.scriptSig.begin();
vector<unsigned char> data;
while (pc < txin.scriptSig.end())
{
opcodetype opcode;
if (!txin.scriptSig.GetOp(pc, opcode, data))
break;
if (data.size() != 0 && contains(data))
return true;
}
}
return false;
}
void CBloomFilter::UpdateEmptyFull()
{
bool full = true;
bool empty = true;
for (unsigned int i = 0; i < vData.size(); i++)
{
full &= vData[i] == 0xff;
empty &= vData[i] == 0;
}
isFull = full;
isEmpty = empty;
}
| [
"[email protected]"
] | |
92930d939c6dbfd77236de86c87d1853c7f7793f | 1d0097e25c983c764be6871c4e9d19acd83c9a6d | /llvm-3.2.src/lib/Target/Hexagon/HexagonInstrInfo.h | 2bb53f899ce1c6d8d197d116750667da4fd1b1b0 | [
"LicenseRef-scancode-unknown-license-reference",
"NCSA"
] | permissive | smowton/llpe | 16a695782bebbeadfd1abed770d0928e464edb39 | 8905aeda642c5d7e5cd3fb757c3e9897b62d0028 | refs/heads/master | 2022-03-11T23:08:18.465994 | 2020-09-16T07:49:12 | 2020-09-16T07:49:12 | 1,102,256 | 50 | 10 | NOASSERTION | 2020-09-16T07:49:13 | 2010-11-22T12:52:25 | C++ | UTF-8 | C++ | false | false | 8,453 | h | //===- HexagonInstrInfo.h - Hexagon Instruction Information -----*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file contains the Hexagon implementation of the TargetInstrInfo class.
//
//===----------------------------------------------------------------------===//
#ifndef HexagonINSTRUCTIONINFO_H
#define HexagonINSTRUCTIONINFO_H
#include "HexagonRegisterInfo.h"
#include "MCTargetDesc/HexagonBaseInfo.h"
#include "llvm/Target/TargetInstrInfo.h"
#include "llvm/Target/TargetFrameLowering.h"
#define GET_INSTRINFO_HEADER
#include "HexagonGenInstrInfo.inc"
namespace llvm {
class HexagonInstrInfo : public HexagonGenInstrInfo {
const HexagonRegisterInfo RI;
const HexagonSubtarget& Subtarget;
public:
explicit HexagonInstrInfo(HexagonSubtarget &ST);
/// getRegisterInfo - TargetInstrInfo is a superset of MRegister info. As
/// such, whenever a client has an instance of instruction info, it should
/// always be able to get register info as well (through this method).
///
virtual const HexagonRegisterInfo &getRegisterInfo() const { return RI; }
/// isLoadFromStackSlot - If the specified machine instruction is a direct
/// load from a stack slot, return the virtual or physical register number of
/// the destination along with the FrameIndex of the loaded stack slot. If
/// not, return 0. This predicate must return 0 if the instruction has
/// any side effects other than loading from the stack slot.
virtual unsigned isLoadFromStackSlot(const MachineInstr *MI,
int &FrameIndex) const;
/// isStoreToStackSlot - If the specified machine instruction is a direct
/// store to a stack slot, return the virtual or physical register number of
/// the source reg along with the FrameIndex of the loaded stack slot. If
/// not, return 0. This predicate must return 0 if the instruction has
/// any side effects other than storing to the stack slot.
virtual unsigned isStoreToStackSlot(const MachineInstr *MI,
int &FrameIndex) const;
virtual bool AnalyzeBranch(MachineBasicBlock &MBB,MachineBasicBlock *&TBB,
MachineBasicBlock *&FBB,
SmallVectorImpl<MachineOperand> &Cond,
bool AllowModify) const;
virtual unsigned RemoveBranch(MachineBasicBlock &MBB) const;
virtual unsigned InsertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
MachineBasicBlock *FBB,
const SmallVectorImpl<MachineOperand> &Cond,
DebugLoc DL) const;
virtual void copyPhysReg(MachineBasicBlock &MBB,
MachineBasicBlock::iterator I, DebugLoc DL,
unsigned DestReg, unsigned SrcReg,
bool KillSrc) const;
virtual void storeRegToStackSlot(MachineBasicBlock &MBB,
MachineBasicBlock::iterator MBBI,
unsigned SrcReg, bool isKill, int FrameIndex,
const TargetRegisterClass *RC,
const TargetRegisterInfo *TRI) const;
virtual void storeRegToAddr(MachineFunction &MF, unsigned SrcReg, bool isKill,
SmallVectorImpl<MachineOperand> &Addr,
const TargetRegisterClass *RC,
SmallVectorImpl<MachineInstr*> &NewMIs) const;
virtual void loadRegFromStackSlot(MachineBasicBlock &MBB,
MachineBasicBlock::iterator MBBI,
unsigned DestReg, int FrameIndex,
const TargetRegisterClass *RC,
const TargetRegisterInfo *TRI) const;
virtual void loadRegFromAddr(MachineFunction &MF, unsigned DestReg,
SmallVectorImpl<MachineOperand> &Addr,
const TargetRegisterClass *RC,
SmallVectorImpl<MachineInstr*> &NewMIs) const;
virtual MachineInstr* foldMemoryOperandImpl(MachineFunction &MF,
MachineInstr* MI,
const SmallVectorImpl<unsigned> &Ops,
int FrameIndex) const;
virtual MachineInstr* foldMemoryOperandImpl(MachineFunction &MF,
MachineInstr* MI,
const SmallVectorImpl<unsigned> &Ops,
MachineInstr* LoadMI) const {
return 0;
}
unsigned createVR(MachineFunction* MF, MVT VT) const;
virtual bool isPredicable(MachineInstr *MI) const;
virtual bool
PredicateInstruction(MachineInstr *MI,
const SmallVectorImpl<MachineOperand> &Cond) const;
virtual bool isProfitableToIfCvt(MachineBasicBlock &MBB, unsigned NumCycles,
unsigned ExtraPredCycles,
const BranchProbability &Probability) const;
virtual bool isProfitableToIfCvt(MachineBasicBlock &TMBB,
unsigned NumTCycles, unsigned ExtraTCycles,
MachineBasicBlock &FMBB,
unsigned NumFCycles, unsigned ExtraFCycles,
const BranchProbability &Probability) const;
virtual bool isPredicated(const MachineInstr *MI) const;
virtual bool DefinesPredicate(MachineInstr *MI,
std::vector<MachineOperand> &Pred) const;
virtual bool
SubsumesPredicate(const SmallVectorImpl<MachineOperand> &Pred1,
const SmallVectorImpl<MachineOperand> &Pred2) const;
virtual bool
ReverseBranchCondition(SmallVectorImpl<MachineOperand> &Cond) const;
virtual bool
isProfitableToDupForIfCvt(MachineBasicBlock &MBB,unsigned NumCycles,
const BranchProbability &Probability) const;
virtual DFAPacketizer*
CreateTargetScheduleState(const TargetMachine *TM,
const ScheduleDAG *DAG) const;
virtual bool isSchedulingBoundary(const MachineInstr *MI,
const MachineBasicBlock *MBB,
const MachineFunction &MF) const;
bool isValidOffset(const int Opcode, const int Offset) const;
bool isValidAutoIncImm(const EVT VT, const int Offset) const;
bool isMemOp(const MachineInstr *MI) const;
bool isSpillPredRegOp(const MachineInstr *MI) const;
bool isU6_3Immediate(const int value) const;
bool isU6_2Immediate(const int value) const;
bool isU6_1Immediate(const int value) const;
bool isU6_0Immediate(const int value) const;
bool isS4_3Immediate(const int value) const;
bool isS4_2Immediate(const int value) const;
bool isS4_1Immediate(const int value) const;
bool isS4_0Immediate(const int value) const;
bool isS12_Immediate(const int value) const;
bool isU6_Immediate(const int value) const;
bool isS8_Immediate(const int value) const;
bool isS6_Immediate(const int value) const;
bool isSaveCalleeSavedRegsCall(const MachineInstr* MI) const;
bool isConditionalTransfer(const MachineInstr* MI) const;
bool isConditionalALU32 (const MachineInstr* MI) const;
bool isConditionalLoad (const MachineInstr* MI) const;
bool isConditionalStore(const MachineInstr* MI) const;
bool isDeallocRet(const MachineInstr *MI) const;
unsigned getInvertedPredicatedOpcode(const int Opc) const;
bool isExtendable(const MachineInstr* MI) const;
bool isExtended(const MachineInstr* MI) const;
bool isPostIncrement(const MachineInstr* MI) const;
bool isNewValueStore(const MachineInstr* MI) const;
bool isNewValueJump(const MachineInstr* MI) const;
bool isNewValueJumpCandidate(const MachineInstr *MI) const;
unsigned getImmExtForm(const MachineInstr* MI) const;
unsigned getNormalBranchForm(const MachineInstr* MI) const;
private:
int getMatchingCondBranchOpcode(int Opc, bool sense) const;
};
}
#endif
| [
"[email protected]"
] | |
66d5f31e1da8d5a8cf12ac171a421f6155185da9 | 662e36112643697e4f40b036a91c37436e3256d0 | /map-structure/vi-map/test/test_map_consistency_check.cc | ea1e6f884143afdc369c5884eb59713044e4e917 | [
"Apache-2.0"
] | permissive | ethz-asl/maplab | ca9e2cacd2fbaf9dac22b455e24a179f8613729a | 0b4868efeb292851d71f98d31a1e6bb40ebb244b | refs/heads/master | 2023-08-28T16:19:16.241444 | 2023-06-18T21:36:18 | 2023-06-18T21:36:18 | 112,253,403 | 2,488 | 755 | Apache-2.0 | 2023-06-18T21:36:19 | 2017-11-27T21:58:23 | C++ | UTF-8 | C++ | false | false | 18,582 | cc | #include <algorithm>
#include <vector>
#include <Eigen/Core>
#include <aslam/cameras/random-camera-generator.h>
#include <aslam/common/memory.h>
#include <maplab-common/pose_types.h>
#include <maplab-common/test/testing-entrypoint.h>
#include <maplab-common/test/testing-predicates.h>
#include <posegraph/pose-graph.h>
#include <posegraph/vertex.h>
#include "vi-map/check-map-consistency.h"
#include "vi-map/vi-map.h"
namespace vi_map {
class MapConsistencyCheckTest : public ::testing::Test {
protected:
MapConsistencyCheckTest() {}
virtual void SetUp() {}
void createMissionWithExistingNCamera(
const vi_map::MissionId& mission_id, const aslam::SensorId& ncamera_id,
std::vector<pose_graph::VertexId>* vertex_ids,
const unsigned int num_vertices = kNumOfVertices);
void createMissionWithNewNCamera(
const vi_map::MissionId& mission_id,
std::vector<pose_graph::VertexId>* vertex_ids,
const unsigned int num_vertices = kNumOfVertices);
void populateVisualNFrameOfVertex(vi_map::Vertex* vertex_ptr);
void addVisualFrameToVertex(
const aslam::NCamera::Ptr& n_camera_ptr, vi_map::Vertex* vertex_ptr);
void addCommonLandmarkIds(
unsigned int count, const pose_graph::VertexId& vertex0_id,
const pose_graph::VertexId& vertex1_id);
void addInvalidEdge();
void addOrphanedTrajectory();
void addOrphanedVertex();
void addLandmarkAndVertexReference(
const vi_map::LandmarkId& global_landmark_id,
const pose_graph::VertexId& storing_vertex_id);
void addLoopClosureEdges();
std::vector<pose_graph::VertexId> vertex_ids_mission_1_;
std::vector<pose_graph::VertexId> vertex_ids_mission_2_;
VIMap map_;
vi_map::MissionId mission_id1_;
vi_map::MissionId mission_id2_;
static constexpr unsigned int kNumOfVertices = 4;
static constexpr unsigned int kNumCameras = 1;
static constexpr unsigned int kVisualFrameIndex = 0;
static constexpr unsigned int kNumOfKeypointsPerVertex = 500;
static constexpr int kDescriptorBytes = 48;
};
void MapConsistencyCheckTest::createMissionWithExistingNCamera(
const vi_map::MissionId& mission_id, const aslam::SensorId& ncamera_id,
std::vector<pose_graph::VertexId>* vertex_ids,
const unsigned int num_vertices) {
CHECK(map_.getSensorManager().hasSensor(ncamera_id));
CHECK_EQ(
map_.getSensorManager().getSensorType(ncamera_id),
vi_map::SensorType::kNCamera);
CHECK(mission_id.isValid());
CHECK_NOTNULL(vertex_ids)->clear();
// Retrieve the sensor from the sensor manager.
const aslam::NCamera::Ptr& ncamera_ptr =
map_.sensor_manager_.getSensorPtr<aslam::NCamera>(ncamera_id);
vi_map::MissionBaseFrame baseframe;
vi_map::MissionBaseFrameId baseframe_id;
aslam::generateId(&baseframe_id);
baseframe.setId(baseframe_id);
vi_map::VIMission* mission_ptr(new vi_map::VIMission);
mission_ptr->setId(mission_id);
mission_ptr->setBaseFrameId(baseframe_id);
map_.missions.emplace(
mission_ptr->id(), vi_map::VIMission::UniquePtr(mission_ptr));
map_.mission_base_frames.emplace(baseframe.id(), baseframe);
// Associate mission with ncamera.
map_.associateMissionNCamera(ncamera_ptr->getId(), mission_id);
if (num_vertices == 0u) {
return;
}
// Add vertices_
vertex_ids->resize(num_vertices);
// Create and add root vertex.
vi_map::Vertex::UniquePtr root_vertex =
aligned_unique<vi_map::Vertex>(ncamera_ptr);
populateVisualNFrameOfVertex(root_vertex.get());
const pose_graph::VertexId& root_vertex_id = root_vertex->id();
CHECK(root_vertex_id.isValid());
root_vertex->setMissionId(mission_id);
map_.addVertex(std::move(root_vertex));
mission_ptr->setRootVertexId(root_vertex_id);
// Save vertex id for external logic, not needed for map itself.
(*vertex_ids)[0] = root_vertex_id;
VLOG(3) << "Add root vertex " << root_vertex_id.hexString();
for (unsigned int i = 1; i < num_vertices; ++i) {
vi_map::Vertex::UniquePtr intermediate_vertex =
aligned_unique<vi_map::Vertex>(ncamera_ptr);
populateVisualNFrameOfVertex(intermediate_vertex.get());
const pose_graph::VertexId& intermediate_vertex_id =
intermediate_vertex->id();
CHECK(intermediate_vertex_id.isValid());
intermediate_vertex->setMissionId(mission_id);
map_.addVertex(std::move(intermediate_vertex));
(*vertex_ids)[i] = intermediate_vertex_id;
VLOG(3) << "Add vertex " << intermediate_vertex_id.hexString();
pose_graph::EdgeId edge_id;
generateId(&edge_id);
Eigen::Matrix<int64_t, 1, Eigen::Dynamic> imu_timestamps;
Eigen::Matrix<double, 6, Eigen::Dynamic> imu_data;
vi_map::Edge* edge(new vi_map::ViwlsEdge(
edge_id, (*vertex_ids)[i - 1], (*vertex_ids)[i], imu_timestamps,
imu_data));
map_.addEdge(vi_map::Edge::UniquePtr(edge));
addCommonLandmarkIds(5, (*vertex_ids)[i], (*vertex_ids)[i - 1]);
}
}
void MapConsistencyCheckTest::createMissionWithNewNCamera(
const vi_map::MissionId& mission_id,
std::vector<pose_graph::VertexId>* vertex_ids,
const unsigned int num_vertices) {
CHECK(mission_id.isValid());
CHECK_NOTNULL(vertex_ids)->clear();
// Add an NCamera.
static constexpr unsigned int kNumCamerasInMultiframeMission = 5;
aslam::NCamera::UniquePtr ncamera =
aslam::createUniqueTestNCamera(kNumCamerasInMultiframeMission);
const aslam::SensorId& ncamera_id = ncamera->getId();
map_.sensor_manager_.addSensorAsBase<aslam::NCamera>(std::move(ncamera));
CHECK(!ncamera);
createMissionWithExistingNCamera(
mission_id, ncamera_id, vertex_ids, num_vertices);
}
void MapConsistencyCheckTest::populateVisualNFrameOfVertex(
vi_map::Vertex* vertex_ptr) {
CHECK_NOTNULL(vertex_ptr);
aslam::VisualNFrame& nframe = vertex_ptr->getVisualNFrame();
const unsigned int num_frames = nframe.getNumFrames();
CHECK_EQ(nframe.getNumFrames(), num_frames);
for (unsigned int frame_idx = 0u; frame_idx < num_frames; ++frame_idx) {
aslam::VisualFrame::Ptr frame = nframe.getFrameShared(frame_idx);
Eigen::Matrix2Xd img_points_distorted;
Eigen::VectorXd uncertainties;
aslam::VisualFrame::DescriptorsT descriptors;
img_points_distorted.resize(Eigen::NoChange, kNumOfKeypointsPerVertex);
uncertainties.resize(kNumOfKeypointsPerVertex);
descriptors.resize(kDescriptorBytes, kNumOfKeypointsPerVertex);
frame->setKeypointMeasurements(img_points_distorted);
frame->setKeypointMeasurementUncertainties(uncertainties);
frame->setDescriptors(descriptors);
LOG(INFO) << "Add global landmark ids to frame: " << frame_idx;
for (unsigned int keypoint_idx = 0; keypoint_idx < kNumOfKeypointsPerVertex;
++keypoint_idx) {
vertex_ptr->addObservedLandmarkId(frame_idx, vi_map::LandmarkId());
}
}
}
void MapConsistencyCheckTest::addCommonLandmarkIds(
unsigned int count, const pose_graph::VertexId& vertex0_id,
const pose_graph::VertexId& vertex1_id) {
vi_map::Vertex& vertex0 = map_.getVertex(vertex0_id);
vi_map::Vertex& vertex1 = map_.getVertex(vertex1_id);
vi_map::LandmarkStore& landmark_store = vertex0.getLandmarks();
for (unsigned int i = 0; i < count; ++i) {
vi_map::LandmarkId landmark_id;
generateId(&landmark_id);
// Set every 10th GlobalLandmarkId in a vertex to a valid ID.
const unsigned int keypoint_index0 =
10 * vertex0.numValidObservedLandmarkIds(kVisualFrameIndex);
const unsigned int keypoint_index1 =
10 * vertex1.numValidObservedLandmarkIds(kVisualFrameIndex);
vi_map::Landmark landmark;
landmark.setId(landmark_id);
landmark.addObservation(vertex0_id, kVisualFrameIndex, keypoint_index0);
landmark.addObservation(vertex1_id, kVisualFrameIndex, keypoint_index1);
landmark_store.addLandmark(landmark);
CHECK_LT(
keypoint_index0, vertex1.observedLandmarkIdsSize(kVisualFrameIndex));
CHECK_LT(
keypoint_index1, vertex0.observedLandmarkIdsSize(kVisualFrameIndex));
vertex0.setObservedLandmarkId(
kVisualFrameIndex, keypoint_index0, landmark_id);
vertex1.setObservedLandmarkId(
kVisualFrameIndex, keypoint_index1, landmark_id);
map_.addLandmarkIndexReference(landmark_id, vertex0_id);
VLOG(3) << "Add landmark " << landmark_id.hexString() << " to "
<< vertex0_id.hexString() << " and " << vertex1_id.hexString()
<< " pos " << keypoint_index0 << " and " << keypoint_index1;
}
}
void MapConsistencyCheckTest::addLoopClosureEdges() {
aslam::generateId(&mission_id2_);
createMissionWithNewNCamera(mission_id2_, &vertex_ids_mission_2_);
constexpr double kSwitchVariable = 1.0;
constexpr double kSwitchVariableVariance = 1.0;
const aslam::TransformationCovariance kT_A_B_covariance =
aslam::TransformationCovariance::Identity();
for (const pose_graph::VertexId& source_vertex_id_mission_1 :
vertex_ids_mission_1_) {
for (const pose_graph::VertexId& destination_vertex_id_mission_1 :
vertex_ids_mission_1_) {
if (source_vertex_id_mission_1 == destination_vertex_id_mission_1) {
continue;
}
pose_graph::EdgeId edge_id;
aslam::generateId(&edge_id);
const aslam::Transformation T_G_I_source =
map_.getVertex_T_G_I(source_vertex_id_mission_1);
const aslam::Transformation T_G_I_dest =
map_.getVertex_T_G_I(destination_vertex_id_mission_1);
const aslam::Transformation T_A_B = T_G_I_source.inverse() * T_G_I_dest;
LoopClosureEdge::UniquePtr loop_closure_edge =
aligned_unique<LoopClosureEdge>(
edge_id, source_vertex_id_mission_1,
destination_vertex_id_mission_1, kSwitchVariable,
kSwitchVariableVariance, T_A_B, kT_A_B_covariance);
map_.addEdge(std::move(loop_closure_edge));
}
for (const pose_graph::VertexId& destination_vertex_id_mission_2 :
vertex_ids_mission_2_) {
pose_graph::EdgeId edge_id;
aslam::generateId(&edge_id);
const aslam::Transformation T_G_I_source =
map_.getVertex_T_G_I(source_vertex_id_mission_1);
const aslam::Transformation T_G_I_dest =
map_.getVertex_T_G_I(destination_vertex_id_mission_2);
const aslam::Transformation T_A_B = T_G_I_source.inverse() * T_G_I_dest;
LoopClosureEdge::UniquePtr loop_closure_edge =
aligned_unique<LoopClosureEdge>(
edge_id, source_vertex_id_mission_1,
destination_vertex_id_mission_2, kSwitchVariable,
kSwitchVariableVariance, T_A_B, kT_A_B_covariance);
map_.addEdge(std::move(loop_closure_edge));
}
}
for (const pose_graph::VertexId& source_vertex_id_mission_2 :
vertex_ids_mission_2_) {
for (const pose_graph::VertexId& destination_vertex_id_mission_2 :
vertex_ids_mission_2_) {
if (source_vertex_id_mission_2 == destination_vertex_id_mission_2) {
continue;
}
pose_graph::EdgeId edge_id;
aslam::generateId(&edge_id);
const aslam::Transformation T_G_I_source =
map_.getVertex_T_G_I(source_vertex_id_mission_2);
const aslam::Transformation T_G_I_dest =
map_.getVertex_T_G_I(destination_vertex_id_mission_2);
const aslam::Transformation T_A_B = T_G_I_source.inverse() * T_G_I_dest;
LoopClosureEdge::UniquePtr loop_closure_edge =
aligned_unique<LoopClosureEdge>(
edge_id, source_vertex_id_mission_2,
destination_vertex_id_mission_2, kSwitchVariable,
kSwitchVariableVariance, T_A_B, kT_A_B_covariance);
map_.addEdge(std::move(loop_closure_edge));
}
for (const pose_graph::VertexId& destination_vertex_id_mission_1 :
vertex_ids_mission_1_) {
pose_graph::EdgeId edge_id;
aslam::generateId(&edge_id);
const aslam::Transformation T_G_I_source =
map_.getVertex_T_G_I(source_vertex_id_mission_2);
const aslam::Transformation T_G_I_dest =
map_.getVertex_T_G_I(destination_vertex_id_mission_1);
const aslam::Transformation T_A_B = T_G_I_source.inverse() * T_G_I_dest;
LoopClosureEdge::UniquePtr loop_closure_edge =
aligned_unique<LoopClosureEdge>(
edge_id, source_vertex_id_mission_2,
destination_vertex_id_mission_1, kSwitchVariable,
kSwitchVariableVariance, T_A_B, kT_A_B_covariance);
map_.addEdge(std::move(loop_closure_edge));
}
}
}
// Orphaned since not connected to the graph already attached to mission_id.
void MapConsistencyCheckTest::addOrphanedTrajectory() {
aslam::NCamera::Ptr ncamera = map_.getMissionNCameraPtr(mission_id1_);
pose_graph::VertexId vertex_id_0;
pose_graph::VertexId vertex_id_1;
generateId(&vertex_id_0);
generateId(&vertex_id_1);
vi_map::Vertex* vertex_0(new vi_map::Vertex(ncamera));
vi_map::Vertex* vertex_1(new vi_map::Vertex(ncamera));
vertex_0->setId(vertex_id_0);
vertex_1->setId(vertex_id_1);
vertex_0->setMissionId(mission_id1_);
vertex_1->setMissionId(mission_id1_);
map_.addVertex(vi_map::Vertex::UniquePtr(vertex_0));
map_.addVertex(vi_map::Vertex::UniquePtr(vertex_1));
pose_graph::EdgeId edge_id;
generateId(&edge_id);
Eigen::Matrix<int64_t, 1, Eigen::Dynamic> imu_timestamps;
Eigen::Matrix<double, 6, Eigen::Dynamic> imu_data;
vi_map::Edge* edge(new vi_map::ViwlsEdge(
edge_id, vertex_id_0, vertex_id_1, imu_timestamps, imu_data));
map_.addEdge(vi_map::Edge::UniquePtr(edge));
}
// Orphaned since not connected to the graph already attached to mission_id.
void MapConsistencyCheckTest::addOrphanedVertex() {
aslam::NCamera::Ptr ncamera = map_.getMissionNCameraPtr(mission_id1_);
pose_graph::VertexId vertex_id;
generateId(&vertex_id);
vi_map::Vertex* vertex(new vi_map::Vertex(ncamera));
vertex->setId(vertex_id);
vertex->setMissionId(mission_id1_);
map_.addVertex(vi_map::Vertex::UniquePtr(vertex));
}
void MapConsistencyCheckTest::addInvalidEdge() {
pose_graph::EdgeId edge_id;
generateId(&edge_id);
Eigen::Matrix<int64_t, 1, Eigen::Dynamic> imu_timestamps;
Eigen::Matrix<double, 6, Eigen::Dynamic> imu_data;
vi_map::Edge* edge(new vi_map::ViwlsEdge(
edge_id, vertex_ids_mission_1_[2], vertex_ids_mission_1_[0],
imu_timestamps, imu_data));
map_.addEdge(vi_map::Edge::UniquePtr(edge));
}
void MapConsistencyCheckTest::addLandmarkAndVertexReference(
const vi_map::LandmarkId& landmark_id,
const pose_graph::VertexId& storing_vertex_id) {
map_.addLandmarkIndexReference(landmark_id, storing_vertex_id);
}
TEST_F(MapConsistencyCheckTest, mapConsistencyNoVertex) {
aslam::generateId(&mission_id1_);
createMissionWithNewNCamera(
mission_id1_, &vertex_ids_mission_1_, 0u /* num vertices */);
EXPECT_FALSE(vi_map::checkMapConsistency(map_));
}
TEST_F(MapConsistencyCheckTest, mapConsistencySingleVertex) {
aslam::generateId(&mission_id1_);
createMissionWithNewNCamera(
mission_id1_, &vertex_ids_mission_1_, 1u /* num vertices */);
EXPECT_TRUE(vi_map::checkMapConsistency(map_));
}
TEST_F(MapConsistencyCheckTest, mapConsistencyMultipleVertices) {
aslam::generateId(&mission_id1_);
createMissionWithNewNCamera(
mission_id1_, &vertex_ids_mission_1_, 5u /* num vertices */);
EXPECT_TRUE(vi_map::checkMapConsistency(map_));
}
TEST_F(MapConsistencyCheckTest, mapInconsistentMissingBackLink) {
aslam::generateId(&mission_id1_);
createMissionWithNewNCamera(mission_id1_, &vertex_ids_mission_1_);
vi_map::Vertex& vertex0 = map_.getVertex(vertex_ids_mission_1_[2]);
vi_map::LandmarkStore& landmark_store = vertex0.getLandmarks();
ASSERT_GT(landmark_store.size(), 0u);
vi_map::LandmarkId landmark_id;
generateId(&landmark_id);
vi_map::Landmark landmark;
landmark.setId(landmark_id);
landmark_store.addLandmark(landmark);
addLandmarkAndVertexReference(landmark_id, vertex_ids_mission_1_[2]);
const unsigned int keypoint_index =
vertex0.numValidObservedLandmarkIds(kVisualFrameIndex);
vertex0.setObservedLandmarkId(kVisualFrameIndex, keypoint_index, landmark_id);
EXPECT_FALSE(vi_map::checkMapConsistency(map_));
}
TEST_F(MapConsistencyCheckTest, mapInconsistentPosegraphInvalidEdge) {
aslam::generateId(&mission_id1_);
createMissionWithNewNCamera(mission_id1_, &vertex_ids_mission_1_);
addInvalidEdge();
EXPECT_FALSE(vi_map::checkMapConsistency(map_));
}
TEST_F(MapConsistencyCheckTest, mapInconsistentPosegraphOrphanedTrajectory) {
aslam::generateId(&mission_id1_);
createMissionWithNewNCamera(mission_id1_, &vertex_ids_mission_1_);
addOrphanedTrajectory();
EXPECT_FALSE(vi_map::checkMapConsistency(map_));
}
TEST_F(MapConsistencyCheckTest, mapInconsistentPosegraphOrphanedVertex) {
aslam::generateId(&mission_id1_);
createMissionWithNewNCamera(mission_id1_, &vertex_ids_mission_1_);
addOrphanedVertex();
EXPECT_FALSE(vi_map::checkMapConsistency(map_));
}
TEST_F(MapConsistencyCheckTest, mapMultiMissionDifferentNCamera) {
aslam::generateId(&mission_id1_);
createMissionWithNewNCamera(mission_id1_, &vertex_ids_mission_1_);
aslam::generateId(&mission_id2_);
createMissionWithNewNCamera(mission_id2_, &vertex_ids_mission_2_);
EXPECT_TRUE(vi_map::checkMapConsistency(map_));
}
TEST_F(MapConsistencyCheckTest, mapMultiMissionSameNCamera) {
aslam::generateId(&mission_id1_);
createMissionWithNewNCamera(mission_id1_, &vertex_ids_mission_1_);
const aslam::NCamera::Ptr ncamera_ptr =
map_.getMissionNCameraPtr(mission_id1_);
aslam::generateId(&mission_id2_);
createMissionWithExistingNCamera(
mission_id2_, ncamera_ptr->getId(), &vertex_ids_mission_2_);
EXPECT_TRUE(vi_map::checkMapConsistency(map_));
}
TEST_F(MapConsistencyCheckTest, mapMissionWithInconsistentPointersToNCamera) {
aslam::generateId(&mission_id1_);
createMissionWithNewNCamera(mission_id1_, &vertex_ids_mission_1_);
const aslam::NCamera::Ptr ncamera_copy_ptr =
aligned_shared<aslam::NCamera>(map_.getMissionNCamera(mission_id1_));
for (const pose_graph::VertexId& vertex_id : vertex_ids_mission_1_) {
map_.getVertex(vertex_id).getVisualNFrameShared()->setNCameras(
ncamera_copy_ptr);
}
EXPECT_FALSE(vi_map::checkMapConsistency(map_));
}
TEST_F(MapConsistencyCheckTest, MapConsistencyLoopClosureEdges) {
aslam::generateId(&mission_id1_);
createMissionWithNewNCamera(mission_id1_, &vertex_ids_mission_1_);
EXPECT_TRUE(vi_map::checkMapConsistency(map_));
addLoopClosureEdges();
EXPECT_TRUE(vi_map::checkMapConsistency(map_));
}
} // namespace vi_map
MAPLAB_UNITTEST_ENTRYPOINT
| [
"[email protected]"
] | |
cd18d87ef5360940943b64c329e0f2b8ca333856 | 093858c8a1ba13d532d6a1e53da5d512b3aeecd6 | /Code/Sandbox/Engine/container.cpp | 3b632645989278ad0601f21ecb1691c591a96fe0 | [] | no_license | aaronwhitesell/Sandbox | f941f5044631d5d4431159f74716f1eb61f5ee35 | 165bf831991533b83f8da67689541bcd46102217 | refs/heads/master | 2021-01-16T00:57:09.841602 | 2015-10-08T02:48:35 | 2015-10-08T02:48:35 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,216 | cpp | #include "container.h"
#include <SFML/Window/Event.hpp>
#include <SFML/Graphics/RenderStates.hpp>
#include <SFML/Graphics/RenderTarget.hpp>
namespace GUI
{
Container::Container()
: mChildren()
, mSelectedChild(-1)
{
}
void Container::pack(Component::Ptr component)
{
mChildren.push_back(component);
if (!hasSelection() && component->isSelectable())
select(mChildren.size() - 1);
}
bool Container::isSelectable() const
{
return false;
}
void Container::handleEvent(const sf::Event& event)
{
// If we have selected a child then give it events
if (hasSelection() && mChildren[mSelectedChild]->isActive())
{
mChildren[mSelectedChild]->handleEvent(event);
}
else if (event.type == sf::Event::KeyReleased)
{
if (event.key.code == sf::Keyboard::W || event.key.code == sf::Keyboard::Up)
{
selectPrevious();
}
else if (event.key.code == sf::Keyboard::S || event.key.code == sf::Keyboard::Down)
{
selectNext();
}
else if (event.key.code == sf::Keyboard::Return || event.key.code == sf::Keyboard::Space)
{
if (hasSelection())
mChildren[mSelectedChild]->activate();
}
}
}
void Container::draw(sf::RenderTarget& target, sf::RenderStates states) const
{
states.transform *= getTransform();
for (const Component::Ptr& child : mChildren)
target.draw(*child, states);
}
bool Container::hasSelection() const
{
return mSelectedChild >= 0;
}
void Container::select(std::size_t index)
{
if (mChildren[index]->isSelectable())
{
if (hasSelection())
mChildren[mSelectedChild]->deselect();
mChildren[index]->select();
mSelectedChild = index;
}
}
void Container::selectNext()
{
if (!hasSelection())
return;
// Search next component that is selectable, wrap around if necessary
int next = mSelectedChild;
do
next = (next + 1) % mChildren.size();
while (!mChildren[next]->isSelectable());
// Select that component
select(next);
}
void Container::selectPrevious()
{
if (!hasSelection())
return;
// Search previous component that is selectable, wrap around if necessary
int prev = mSelectedChild;
do
prev = (prev + mChildren.size() - 1) % mChildren.size();
while (!mChildren[prev]->isSelectable());
// Select that component
select(prev);
}
}
| [
"[email protected]"
] | |
4de7d68b535458be9f6f13ce0fdea98362094b30 | 893ee3fe9622a3a5d3f8b4e95f49ed4e76678d44 | /Tests/data_copy_no_lower_bound.cpp | 0ddd1270f04ea47c7c68fb3219006cf562b9b78d | [
"BSD-3-Clause",
"LicenseRef-scancode-unknown-license-reference",
"BSD-2-Clause"
] | permissive | OpenACCUserGroup/OpenACCV-V | 1789ddeed924353cd4a2e2ce7f9dd20b54a56f18 | 45355f784ddc12684915276c5fd7d1dd4b2d2052 | refs/heads/master | 2023-08-09T10:24:11.259348 | 2023-07-27T16:19:45 | 2023-07-27T16:19:45 | 94,044,279 | 23 | 13 | BSD-3-Clause | 2023-08-21T18:32:11 | 2017-06-12T01:43:05 | Fortran | UTF-8 | C++ | false | false | 1,046 | cpp | #include "acc_testsuite.h"
#ifndef T1
//T1:data,data-region,construct-independent,V:1.0-2.7
int test1(){
int err = 0;
srand(SEED);
real_t * a = new real_t[n];
real_t * b = new real_t[n];
real_t * c = new real_t[n];
for (int x = 0; x < n; ++x){
a[x] = rand() / (real_t)(RAND_MAX / 10);
b[x] = rand() / (real_t)(RAND_MAX / 10);
c[x] = 0.0;
}
#pragma acc data copyin(a[0:n], b[0:n]) copy(c[:n])
{
#pragma acc parallel
{
#pragma acc loop
for (int x = 0; x < n; ++x){
c[x] += a[x] + b[x];
}
}
}
for (int x = 0; x < n; ++x){
if (fabs(c[x] - (a[x] + b[x])) > PRECISION){
err += 1;
}
}
return err;
}
#endif
int main(){
int failcode = 0;
int failed;
#ifndef T1
failed = 0;
for (int x = 0; x < NUM_TEST_CALLS; ++x){
failed = failed + test1();
}
if (failed != 0){
failcode = failcode + (1 << 0);
}
#endif
return failcode;
}
| [
"[email protected]"
] | |
87604b99a1fc893a1166d8278fe68b345182dfec | 8ae31e5db1f7c25b6ce1c708655ab55c15dde14e | /比赛/学校/2019-11-8测试/source/PC36_HB_lcx/15.cpp | b133a684387b57ae1f647b48a61882c337dc6a69 | [] | no_license | LeverImmy/Codes | 99786afd826ae786b5024a3a73c8f92af09aae5d | ca28e61f55977e5b45d6731bc993c66e09f716a3 | refs/heads/master | 2020-09-03T13:00:29.025752 | 2019-12-16T12:11:23 | 2019-12-16T12:11:23 | 219,466,644 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,297 | cpp | #include<bits/stdc++.h>
#define int long long
#define INF 0x7ffffff
using namespace std;
inline int read() {
int x = 0, f = 1;
char c = getchar();
while(!isdigit(c)) {
if(c == '-') {
f = -1;
}
c = getchar();
}
while(isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
char z[1000001];
char x[1000001];
char y[1000001];
inline string ccc(char x[], char y[]) {
int lena = strlen(x), lenb = strlen(y);
reverse(x, x + lena);
reverse(y, y + lenb);
memset(z, '\000', sizeof(z));
int cnt = lena * lenb + 5;
for(int i = 0; i < lena; i++) {
for(int j = 0; j < lenb; j++) {
int xx = x[i] - '0', yy = y[j] - '0';
int zz = xx * yy;
z[i + j] += zz;
if(z[i + j] < '0') {
z[i + j] += '0';
}
while(z[i + j] >= 10 + '0') {
z[i + j] -= 10;
z[i + j + 1] += 1;
}
if(z[i + j + 1] < '0') {
z[i + j + 1] += '0';
}
}
}
while(z[cnt - 1] == '0' || z[cnt - 1] == '\000') {
z[cnt - 1] = '\000';
cnt--;
}
reverse(z, z + cnt);
return z;
}
signed main() {
freopen("15.in", "r", stdin);
freopen("15.out", "w", stdout);
while(cin >> x >> y) {
if(x[0] == 0 || y[0] == '0') {
cout << "0" << endl;
continue;
}
cout << ccc(x, y) << endl;
memset(x, '\000', sizeof(x));
memset(y, '\000', sizeof(y));
}
return 0;
}
| [
"[email protected]"
] | |
c739fd385eebadd8da8539ddc7121730f392bbfd | a1ae98986485273095456edddbca9e48b3a84321 | /Lista 3.1 - Ex6.cpp | 10754d26384645a45cd8a2c0ba037781d011c4e4 | [] | no_license | luizinbrzado/FATEC | bd3f6e379c6e55fdf43a071d75381f20633df2d3 | 3352739043db0f8f37f022fa3d9a9d7f748bfcf5 | refs/heads/main | 2023-05-25T13:41:26.849675 | 2021-06-11T21:31:37 | 2021-06-11T21:31:37 | 372,968,706 | 0 | 0 | null | null | null | null | ISO-8859-1 | C++ | false | false | 750 | cpp | /*Criar um algoritmo que leia os limites inferior e superior de um intervalo e imprima
todos os números pares no intervalo aberto e seu somatório. Suponha que os dados
digitados são para um intervalo crescente, ou seja, o primeiro valor é menor que o
segundo*/
#include <stdio.h>
#include <locale.h>
main() {
setlocale(LC_ALL, "");
int i, maior, menor, acum;
printf("Menor valor: ");
scanf("%d", &menor);
printf("Maior valor: ");
scanf("%d", &maior);
if(menor%2==0) {
for(i=menor; i<=maior; i+=2) {
printf("\n%d", i);
acum = acum + i;
}
}
else {
for(i=menor; i<=maior; i+=2) {
printf("\n%d", i+1);
acum = acum + i+1;
}
}
printf("\nO somatório dos valores pares do intervalo é %d", acum);
}
| [
"[email protected]"
] | |
4c5606b8b6bf6f80913347ca11d36f724cc9ab93 | 303618a190b1dbc9d61b0d5e3488ce7a8e907e1f | /drawLinePixel/src/ofApp.cpp | 913d7db739dc8ec2a74695885ed3a63666de8fb7 | [
"MIT"
] | permissive | Artrustee/ofcourse_homework | 511bfd2649b992baa52d632b1d9ac8350f39dfa1 | ddb875f71bf9680bb2d8fa9dc3a1db9ce6dbeb5d | refs/heads/master | 2016-09-01T09:50:15.254445 | 2015-10-30T01:31:21 | 2015-10-30T01:31:21 | 44,954,378 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,455 | cpp | #include "ofApp.h"
//--------------------------------------------------------------
void ofApp::setup(){
ofBackground(0);
ofSetCircleResolution(37);
}
//--------------------------------------------------------------
void ofApp::drawLinePixel(float X1, float Y1,float X2, float Y2, float linewidth,ofColor col){
float t;
pointX,pointY = 0;
// if slope does not exsists
if ( X1 == X2) {
pointX = X1;
for ( t = 0; t <= Y2; t++) {
pointY = pointY + Y1;
// ofSetColor(0);
// ofPoint(t,pointY);
ofSetColor(mycolor);
ofCircle(pointX, pointY,linewidth );
}
}
// the slope exsist
else {
float slopeK = ( Y2 - Y1 ) / ( X2- X1 );//calculate the slope
for ( t = X1; t <= X2; t++) {
pointX = t;
pointY = slopeK * (t - X1) + Y1;
// ofSetColor(0);
// drawImage1(X1, Y1, X2, Y2, 160, 200, 0);
ofSetColor(mycolor);
ofCircle(pointX, pointY,ofMap(ofNoise(t), X1, X2, 0.3, linewidth) );
// ofEllipse(pointX, pointY, ofMap(ofNoise(t+3), X1 , X2, 0.2, linewidth), ofMap(ofNoise(t), X1 , X2, 0.2, 23 * linewidth));
}
}
}
//--------------------------------------------------------------
void ofApp::Lissajous(){
for (float i = 0; i <= 6 * PI; i += PI/600) {
X1 = 350 * cos(ofMap(mouseX, ofGetWidth(), ofGetElapsedTimef(), 0.5, 3.5)* i + PI+mouseY)+ofGetWidth()/2;
Y1 = 350 * sin(2* i + PI+mouseX)+ofGetHeight()/2;
// Y1 = 350 * sin(ofMap(mouseX, ofGetWidth(), ofGetHeight(), 0.5, 4)* i + ofNoise(ofGetElapsedTimef()))+ofGetHeight()/2;
// Y1 = 350 * sin(2* i + ofGetElapsedTimef())+ofGetHeight()/2;
// X2 = 450 * cos(ofRandom(i*2)* acos(cos(i)) + PI)+ofGetWidth()/2;
// X2 = 450 * cos(4.3* i + PI+ mouseX)+ofGetWidth()/2;
// Y2 = 300 * sin(4.5* i + PI+ mouseY)+ofGetHeight()/2;
X2 = 450 * cos(4.3* i + PI+ mouseX)+ofGetWidth()/2;
Y2 = 300 * sin(4.5* i + PI+ mouseY)+ofGetHeight()/2;
// Y2 = 500 * tan(4.5* ofRandom(i) + PI)+ofGetHeight()/2;
// float hue = ofMap(sin(i*(2*PI/(ofGetWidth()/4))), -1, 1, 0, 255);
float hue = ofMap(6*sin(0.5*i), 0, 6, 0, 360);
mycolor.setHsb(hue, 255, 255);
mycolor.a = ofMap(i, 0, ofGetWidth(), 17, 220);
// ofSetColor(mycolor);
// ofLine(X1, Y1, X2, Y2);
// ofPixels_<ofLine(X1, Y1, X2, Y2)>();
drawLinePixel(X1, Y1, X2, Y2, 1.1,mycolor);
}
}
//--------------------------------------------------------------
//void ofApp::drawImage1(float ptX1,float ptY1,float ptX2,float ptY2,int hues,int saturation,int brightness){
// int w = ofGetWidth();
// int h = ofGetHeight();
// img.allocate(w, h, OF_IMAGE_COLOR_ALPHA);
// //img setting up
// for (int x = 0; x < w; x++){
// for (int y = 0; y < h; y++){
// if ( (x - ptX1)*(x - ptX2) > 0){
// brightness = 0; // means dont draw anything keep it black
// } else{
//
// if ((y - ptY1)*(y - ptY2) > 0){
// brightness = 0;
// }else{
// brightness = 225;
// }
// }
//
// hues = 160;
// saturation = 200;
//
//// saturation = ofMap(dist, 0, 150, 255, 0, true);
//
// ofColor pixCol(hues, saturation, brightness);
// pixCol.a = 170;
// img.setColor(x, y, pixCol);
// }
// }
// img.update();
//
//
//}
//-----------------------BACKUP------------------------------
//void ofApp::drawImage1(int w, int h){
// img.allocate(w, h, OF_IMAGE_COLOR_ALPHA);
// for (int x = 0; x < w; x++){
// for (int y = 0; y < h; y++){
//
// int red = x;
//
// int green = y;
//
// ofVec2f point, center;
//
// point.set(x, y);
// center.set(w*0.5,h*0.5);
// float dist = point.distance(center);
// int blue = ofMap(dist, 0, 150, 255, 0, true);
//
// ofColor pixCol(red, green, blue);
// pixCol.a = 170;
// img.setColor(x, y, pixCol);
// }
// }
// img.update();
//
//}
//--------------------------------------------------------------
void ofApp::update(){
}
//--------------------------------------------------------------
void ofApp::draw(){
// drawImage1(255,255,);
//
// img.draw(ofGetWidth()/2 -10,ofGetHeight()/2-20);
// drawImage1(10, 20,400,500,255,260,200);
// img.draw(ofGetWidth()/2 ,ofGetHeight()/2);
// creatImage(1024, 1024);
// //ofCircle(ofGetWidth()/2, ofGetHeight()/2, 200);
// drawLinePixel(10, 10, 500, 500,0.5);
// ofLine(10, 10, 500, 500);
Lissajous();
}
//--------------------------------------------------------------
void ofApp::creatImage(int w, int h){
// //Creating image
// //Allocate array for filling pixels data
// unsigned char * data = new unsigned char[w * h * 4];
//
// //Fill array for each pixel (x,y)
// for (int x = 0 ; x < h ;x++){
// for (int y = 0; y < w; y++) {
// //Compute preliminary values,
// //needed for our pixel color calculation:
//
// float time = ofGetElapsedTimef(); //1.Time from application start
//
// //2.Level of hyperbola value of x and y with
// //center in w/2 h/2
// float v = ( x - w/2) *( y-h/2);
//
// //3.Combining v with time for motion effect
// float u = v * 0.00025 +time; // 0.00025 was chosen empirically
//
// //4.Compute color components as periodical
// //funcion of u, and streched to [0..255]
// int red = ofMap(sin( u ), -1, 1, 0, 255);
// int green = ofMap(sin( u * 2), -1, 1, 1, 255);
// int blue = 255 - green;
// int alpha = 255;//just constant for simplicity
// //Fill array components for pixel (x,y):
// int index = 4 * (x + w * y);
// data[ index ] = red;
// data[ index + 1] = green;
// data[ index + 2] = blue;
// data[ index + 3] = alpha;
// }
// }
//
// //Load array to image
// // image.setFromPixels(data, w, h, OF_IMAGE_COLOR_ALPHA);
//
// //Aarray is not needed anymore, so clear memory
// delete [] data;
}
//------------------------BACKUP--------------------------------
//void ofApp::creatImage(int w, int h){
// // //Creating image
// //
// // //Allocate array for filling pixels data
// // unsigned char * data = new unsigned char[w * h * 4];
// //
// // //Fill array for each pixel (x,y)
// // for (int y = 0 ; y < h ;y++){
// // for (int x = 0; x < w; x++) {
// // //Compute preliminary values,
// // //needed for our pixel color calculation:
// //
// // float time = ofGetElapsedTimef(); //1.Time from application start
// //
// // //2.Level of hyperbola value of x and y with
// // //center in w/2 h/2
// // float v = ( x - w/2) *( y-h/2);
// //
// // //3.Combining v with time for motion effect
// // float u = v * 0.00025 +time; // 0.00025 was chosen empirically
// //
// // //4.Compute color components as periodical
// // //funcion of u, and streched to [0..255]
// // int red = ofMap(sin( u ), -1, 1, 0, 255);
// // int green = ofMap(sin( u * 2), -1, 1, 1, 255);
// // int blue = 255 - green;
// // int alpha = 255;//just constant for simplicity
// //
// // //Fill array components for pixel (x,y):
// // int index = 4 * (x + w * y);
// // data[ index ] = red;
// // data[ index + 1] = green;
// // data[ index + 2] = blue;
// // data[ index + 3] = alpha;
// // }
// // }
// //
// // //Load array to image
// // // image.setFromPixels(data, w, h, OF_IMAGE_COLOR_ALPHA);
// //
// // //Aarray is not needed anymore, so clear memory
// // delete [] data;
//}
//--------------------------------------------------------------
void ofApp::keyPressed(int key){
}
//--------------------------------------------------------------
void ofApp::keyReleased(int key){
}
//--------------------------------------------------------------
void ofApp::mouseMoved(int x, int y ){
}
//--------------------------------------------------------------
void ofApp::mouseDragged(int x, int y, int button){
}
//--------------------------------------------------------------
void ofApp::mousePressed(int x, int y, int button){
}
//--------------------------------------------------------------
void ofApp::mouseReleased(int x, int y, int button){
}
//--------------------------------------------------------------
void ofApp::windowResized(int w, int h){
}
//--------------------------------------------------------------
void ofApp::gotMessage(ofMessage msg){
}
//--------------------------------------------------------------
void ofApp::dragEvent(ofDragInfo dragInfo){
}
| [
"[email protected]"
] | |
b03f37c6977a2b8bb6e8771bae57abbd80545ab9 | 3467df0c3e53a300b87081adc945dbe62cec375d | /TACO-OGL-EGE/components/engine/core/core/h/FrameID.h | 81e8542f08de03ff83321821c5fd3c643b1bdc84 | [] | no_license | johnathontheriot/TACO-GE | c105b8b21de6b6c98e8c4b7cf8991d69c80957a9 | f837ea137f16b222233653a86ec796122d192c97 | refs/heads/master | 2021-01-15T08:37:26.840171 | 2018-01-06T03:41:38 | 2018-01-06T03:41:38 | 48,794,573 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 553 | h | #ifndef FRAME_ID_H
#define FRAME_ID_H
#include "ID.h"
#include <boost/functional/hash.hpp>
//not well defined
class FrameID : public ID{
public:
FrameID();
int getInstanceID() const;
std::string getNameID() const;
private:
static int _f_id;
protected:
int instance_id;
std::string name_id;
};
struct FrameIDHasher{
std::size_t operator()(const FrameID & fid) const{
std::size_t s = 0;
boost::hash_combine(s, boost::hash_value(fid.getInstanceID()));
boost::hash_combine(s, boost::hash_value(fid.getNameID()));
return s;
}
};
#endif | [
"[email protected]"
] | |
bda6e9dec0538c74b043cbff738721aa966ad009 | 6ff434614f9f8d5b1e0d1ca8a5d82efbf988c6bc | /leetcode/1-400/63.Unique-Path.cpp | e931965f2e55676040819f5939a62d35b17e1694 | [] | no_license | CaribouW/Coding | a0cce05165601b02651246e95c8344d876c435df | db496933e5c8ae4e14173c69774fd30857ceae0f | refs/heads/master | 2022-11-11T14:35:23.432713 | 2020-06-24T02:04:37 | 2020-06-24T02:04:37 | 121,954,178 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 722 | cpp | #include"header.h"
class Solution {
public:
int uniquePathsWithObstacles(vector<vector<int>>& mat) {
if(mat.empty() || mat[0].empty()) return 0;
int m = mat.size() , n = mat[0].size();
vector<vector<long long>> dp(m , vector<long long>(n));
dp[0][0] = mat[0][0] == 0;
for(int i = 1; i < m ; ++i) dp[i][0] = dp[i - 1][0] & (mat[i][0] == 0);
for(int i = 1; i < n ; ++i) dp[0][i] = dp[0][i - 1] & (mat[0][i] == 0);
for(int i = 1; i < m ; ++i){
for(int j = 1; j < n ; ++j){
dp[i][j] = (mat[i][j] == 1) ? 0 :
dp[i - 1][j] + dp[i][j - 1];
}
}
return dp[m - 1][n - 1];
}
}; | [
"[email protected]"
] | |
975c384770c77d7f88711d85751a803edf4f69c5 | b7f3edb5b7c62174bed808079c3b21fb9ea51d52 | /third_party/blink/renderer/bindings/tests/results/modules/v8_test_dictionary_2.cc | 58d3459c971afead6dd74f19c512ce2f81363cbe | [
"LGPL-2.0-or-later",
"GPL-1.0-or-later",
"MIT",
"Apache-2.0",
"LicenseRef-scancode-warranty-disclaimer",
"LGPL-2.1-only",
"GPL-2.0-only",
"LGPL-2.0-only",
"BSD-2-Clause",
"LicenseRef-scancode-other-copyleft",
"BSD-3-Clause"
] | permissive | otcshare/chromium-src | 26a7372773b53b236784c51677c566dc0ad839e4 | 64bee65c921db7e78e25d08f1e98da2668b57be5 | refs/heads/webml | 2023-03-21T03:20:15.377034 | 2020-11-16T01:40:14 | 2020-11-16T01:40:14 | 209,262,645 | 18 | 21 | BSD-3-Clause | 2023-03-23T06:20:07 | 2019-09-18T08:52:07 | null | UTF-8 | C++ | false | false | 5,881 | cc | // Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// This file has been auto-generated from the Jinja2 template
// third_party/blink/renderer/bindings/templates/dictionary_v8.cc.tmpl
// by the script code_generator_v8.py.
// DO NOT MODIFY!
// clang-format off
#include "third_party/blink/renderer/bindings/tests/results/modules/v8_test_dictionary_2.h"
#include "base/stl_util.h"
#include "third_party/blink/renderer/bindings/core/v8/idl_types.h"
#include "third_party/blink/renderer/bindings/core/v8/native_value_traits_impl.h"
#include "third_party/blink/renderer/bindings/core/v8/v8_test_dictionary.h"
#include "third_party/blink/renderer/platform/bindings/exception_state.h"
namespace blink {
static const base::span<const v8::Eternal<v8::Name>>
eternalV8TestDictionary2Keys(v8::Isolate* isolate) {
static const char* const kKeys[] = {
"defaultEmptyDictionary",
"defaultEmptyDictionaryForUnion",
};
return V8PerIsolateData::From(isolate)->FindOrCreateEternalNameCache(kKeys, kKeys);
}
void V8TestDictionary2::ToImpl(v8::Isolate* isolate, v8::Local<v8::Value> v8_value, TestDictionary2* impl, ExceptionState& exception_state) {
if (IsUndefinedOrNull(v8_value)) {
return;
}
if (!v8_value->IsObject()) {
exception_state.ThrowTypeError("cannot convert to dictionary.");
return;
}
v8::Local<v8::Object> v8Object = v8_value.As<v8::Object>();
ALLOW_UNUSED_LOCAL(v8Object);
const auto* keys = eternalV8TestDictionary2Keys(isolate).data();
v8::TryCatch block(isolate);
v8::Local<v8::Context> context = isolate->GetCurrentContext();
v8::Local<v8::Value> default_empty_dictionary_value;
if (!v8Object->Get(context, keys[0].Get(isolate)).ToLocal(&default_empty_dictionary_value)) {
exception_state.RethrowV8Exception(block.Exception());
return;
}
if (default_empty_dictionary_value.IsEmpty() || default_empty_dictionary_value->IsUndefined()) {
// Do nothing.
} else {
TestDictionary* default_empty_dictionary_cpp_value{ NativeValueTraits<TestDictionary>::NativeValue(isolate, default_empty_dictionary_value, exception_state) };
if (exception_state.HadException())
return;
impl->setDefaultEmptyDictionary(default_empty_dictionary_cpp_value);
}
v8::Local<v8::Value> default_empty_dictionary_for_union_value;
if (!v8Object->Get(context, keys[1].Get(isolate)).ToLocal(&default_empty_dictionary_for_union_value)) {
exception_state.RethrowV8Exception(block.Exception());
return;
}
if (default_empty_dictionary_for_union_value.IsEmpty() || default_empty_dictionary_for_union_value->IsUndefined()) {
// Do nothing.
} else {
TestDictionaryOrLong default_empty_dictionary_for_union_cpp_value;
V8TestDictionaryOrLong::ToImpl(isolate, default_empty_dictionary_for_union_value, default_empty_dictionary_for_union_cpp_value, UnionTypeConversionMode::kNotNullable, exception_state);
if (exception_state.HadException())
return;
impl->setDefaultEmptyDictionaryForUnion(default_empty_dictionary_for_union_cpp_value);
}
}
v8::Local<v8::Value> TestDictionary2::ToV8Impl(v8::Local<v8::Object> creationContext, v8::Isolate* isolate) const {
v8::Local<v8::Object> v8Object = v8::Object::New(isolate);
if (!toV8TestDictionary2(this, v8Object, creationContext, isolate))
return v8::Undefined(isolate);
return v8Object;
}
bool toV8TestDictionary2(const TestDictionary2* impl, v8::Local<v8::Object> dictionary, v8::Local<v8::Object> creationContext, v8::Isolate* isolate) {
const auto* keys = eternalV8TestDictionary2Keys(isolate).data();
v8::Local<v8::Context> context = isolate->GetCurrentContext();
auto create_property = [dictionary, context, keys, isolate](
size_t key_index, v8::Local<v8::Value> value) {
bool added_property;
v8::Local<v8::Name> key = keys[key_index].Get(isolate);
if (!dictionary->CreateDataProperty(context, key, value)
.To(&added_property)) {
return false;
}
return added_property;
};
v8::Local<v8::Value> default_empty_dictionary_value;
bool default_empty_dictionary_has_value_or_default = false;
if (impl->hasDefaultEmptyDictionary()) {
default_empty_dictionary_value = ToV8(impl->defaultEmptyDictionary(), creationContext, isolate);
default_empty_dictionary_has_value_or_default = true;
} else {
default_empty_dictionary_value = ToV8(MakeGarbageCollected<TestDictionary>(), creationContext, isolate);
default_empty_dictionary_has_value_or_default = true;
}
if (default_empty_dictionary_has_value_or_default &&
!create_property(0, default_empty_dictionary_value)) {
return false;
}
v8::Local<v8::Value> default_empty_dictionary_for_union_value;
bool default_empty_dictionary_for_union_has_value_or_default = false;
if (impl->hasDefaultEmptyDictionaryForUnion()) {
default_empty_dictionary_for_union_value = ToV8(impl->defaultEmptyDictionaryForUnion(), creationContext, isolate);
default_empty_dictionary_for_union_has_value_or_default = true;
} else {
default_empty_dictionary_for_union_value = ToV8(TestDictionaryOrLong::FromTestDictionary(MakeGarbageCollected<TestDictionary>()), creationContext, isolate);
default_empty_dictionary_for_union_has_value_or_default = true;
}
if (default_empty_dictionary_for_union_has_value_or_default &&
!create_property(1, default_empty_dictionary_for_union_value)) {
return false;
}
return true;
}
TestDictionary2* NativeValueTraits<TestDictionary2>::NativeValue(v8::Isolate* isolate, v8::Local<v8::Value> value, ExceptionState& exception_state) {
TestDictionary2* impl = MakeGarbageCollected<TestDictionary2>();
V8TestDictionary2::ToImpl(isolate, value, impl, exception_state);
return impl;
}
} // namespace blink
| [
"[email protected]"
] | |
0ea8d3e93290ce8d07287bb45e920e6facb09759 | 25ad1fafed62b18e6401b3d4a6b6717e1ced9850 | /main.cpp | c035335cbf9265768d0be56baae42331713c193b | [] | no_license | LcsTen/qml-validator | e8d9f8f37d5bc6e6a2ff8f41412fe6e838600c46 | 337be269945839e7b0223e4c00adcb8b8d3851e0 | refs/heads/master | 2023-04-15T10:46:47.574897 | 2021-04-28T14:51:14 | 2021-04-28T16:17:17 | 362,506,122 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,086 | cpp | #include <iostream>
#include <QQmlComponent>
#include <QQmlEngine>
#include <QCoreApplication>
std::ostream& operator<<(std::ostream& os, const QString s){
return os << s.toStdString();
}
int main(int argc, char** argv){
if(argc < 2){
std::cout << "Usage: qml-validator <qmlfile>" << std::endl;
return 1;
}
QCoreApplication app(argc, argv);
QQmlEngine engine;
QQmlComponent component(&engine);
QObject::connect(&component, &QQmlComponent::statusChanged,
[&component, argv](QQmlComponent::Status status){
if(status == QQmlComponent::Status::Null){
std::cout << "Component is Null." << std::endl;
}else if(status == QQmlComponent::Status::Ready){
// OK!
}else if(status == QQmlComponent::Status::Loading){
std::cout << "Component is Loading." << std::endl;
}else if(status == QQmlComponent::Status::Error){
std::cout << "Errors happened while loading " << argv[1]
<< ": " << std::endl;
for(QQmlError error : component.errors()){
std::cout << error.toString() << std::endl;
}
exit(1);
}
});
component.loadUrl(QUrl(argv[1]));
}
| [
"[email protected]"
] | |
71b1ec62a8ebbae8e10d8df1479c61fec8feac7e | cc0d70c2f617b3aeb495e96d24e7a0c2056971b4 | /project-01/uva-11062/main.cpp | 7c0b5ac71dd46dabb7be4a827d652b393003d88f | [] | no_license | Torogeldiev-T/auca-alg-2021 | 5061b49472c2cbd3811ffdb1921ddfd4732b30e2 | 549386143ab161d9f44dbd5b84726bb7785369c3 | refs/heads/main | 2023-04-27T08:43:50.079952 | 2021-05-24T15:33:22 | 2021-05-24T15:33:22 | 328,555,500 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,005 | cpp | #include <iostream>
#include <set>
#include <cctype>
#include <string>
#include <algorithm>
using namespace std;
int main()
{
set<string> r;
string finalw = "";
string w = "";
for (string s; cin >> s;)
{
int b = 0;
int a = 0;
for (int i = 0; i < s.size(); i++)
{
if (isalpha(s[i]))
{
w += tolower(s[i]);
}
else if (s[i] == '-')
{
if (i + 1 >= s.size())
{
b = 1;
break;
}
else
{
w += s[i];
}
}
else
{
r.insert(w);
w.clear();
a = 1;
}
}
if (b)
{
continue;
}
r.insert(w);
w.clear();
}
r.erase("");
for (auto e : r)
{
cout << e << endl;
}
} | [
"[email protected]"
] | |
85244bc72b69e578d713057df6c5ab8d810ee949 | d0ecb5695223c1c8866d7aa551ae0ffadb2a829d | /Utilities/esUtil_win.cpp | 788685599e787c44e2b11225a68036893d3e0cb3 | [] | no_license | HyperdiXx/OPenGL | 5f2b5e5473d5c4367956164c8b916ad6b8a90fb8 | 20d0b6b007aeb12c242a82d8e9738794f652d25b | refs/heads/master | 2020-03-21T21:12:02.131702 | 2019-01-28T22:36:38 | 2019-01-28T22:36:38 | 139,051,436 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,345 | cpp | #include "stdafx.h"
// use preprocesor to skip file for the Android build (to avoid linking windows libs)
#ifdef _WIN32
//////////////////////////////////////////////////////////////////////////////////////////////
#include <windows.h>
#include "esUtil.h"
// Main window procedure
LRESULT WINAPI ESWindowProc ( HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
LRESULT lRet = 1;
switch (uMsg)
{
case WM_CREATE:
break;
case WM_PAINT:
{
ESContext *esContext = (ESContext*)(LONG_PTR) GetWindowLongPtr ( hWnd, GWL_USERDATA );
if ( esContext && esContext->drawFunc )
esContext->drawFunc ( esContext );
ValidateRect( esContext->hWnd, NULL );
}
break;
case WM_DESTROY:
PostQuitMessage(0);
break;
case WM_KEYDOWN:
{
ESContext *esContext = (ESContext*)(LONG_PTR) GetWindowLongPtr ( hWnd, GWL_USERDATA );
if ( esContext && esContext->keyFunc )
esContext->keyFunc ( esContext, (unsigned char) wParam, true );
}
break;
case WM_KEYUP:
{
ESContext *esContext = (ESContext*)(LONG_PTR) GetWindowLongPtr ( hWnd, GWL_USERDATA );
if ( esContext && esContext->keyFunc )
esContext->keyFunc ( esContext, (unsigned char) wParam, false );
}
break;
default:
lRet = DefWindowProc (hWnd, uMsg, wParam, lParam);
break;
}
return lRet;
}
// Create Win32 instance and window
GLboolean WinCreate ( ESContext *esContext, const char *title )
{
WNDCLASS wndclass = {0};
DWORD wStyle = 0;
RECT windowRect;
HINSTANCE hInstance = GetModuleHandle(NULL);
wndclass.style = CS_OWNDC;
wndclass.lpfnWndProc = (WNDPROC)ESWindowProc;
wndclass.hInstance = hInstance;
wndclass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
wndclass.lpszClassName = "opengles2.0";
if (!RegisterClass (&wndclass) )
return FALSE;
wStyle = WS_VISIBLE | WS_POPUP | WS_BORDER | WS_SYSMENU | WS_CAPTION;
// Adjust the window rectangle so that the client area has
// the correct number of pixels
windowRect.left = 0;
windowRect.top = 0;
windowRect.right = esContext->width;
windowRect.bottom = esContext->height;
AdjustWindowRect ( &windowRect, wStyle, FALSE );
esContext->hWnd = CreateWindow(
"opengles2.0",
title,
wStyle,
0,
0,
windowRect.right - windowRect.left,
windowRect.bottom - windowRect.top,
NULL,
NULL,
hInstance,
NULL);
// Set the ESContext* to the GWL_USERDATA so that it is available to the
// ESWindowProc
SetWindowLongPtr ( esContext->hWnd, GWL_USERDATA, (LONG) (LONG_PTR) esContext );
if ( esContext->hWnd == NULL )
return GL_FALSE;
ShowWindow ( esContext->hWnd, TRUE );
return GL_TRUE;
}
// Start main windows loop
void WinLoop ( ESContext *esContext )
{
MSG msg = { 0 };
int done = 0;
DWORD lastTime = GetTickCount();
while (!done)
{
int gotMsg = (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE) != 0);
DWORD curTime = GetTickCount();
float deltaTime = (float)( curTime - lastTime ) / 1000.0f;
lastTime = curTime;
if ( gotMsg )
{
if (msg.message==WM_QUIT)
{
done=1;
}
else
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
else
SendMessage( esContext->hWnd, WM_PAINT, 0, 0 );
// Call update function if registered
if ( esContext->updateFunc != NULL )
esContext->updateFunc ( esContext, deltaTime );
}
}
//////////////////////////////////////////////////////////////////////////////////////////////
#endif /* _WIN32 */
////////////////////////////////////////////////////////////////////////////////////////////// | [
"[email protected]"
] | |
c14d46b25b1f1b18184b97e849e9f30429e76218 | 24ce7a1264cb0c4bbf7b7ab904a5dc98ccc1be4e | /search-insert-position.cpp | ff4b5a5c50fbb59fbd7382ae4107fe8c35ad744f | [] | no_license | winniez/myleetcode | 1a61019e0e254fa290faa3c85dd20019ff3c9824 | befb7ed11398e8a0ed8cd021db95bf368242a415 | refs/heads/master | 2016-09-05T20:34:17.779538 | 2014-04-06T21:42:33 | 2014-04-06T21:42:33 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 804 | cpp | /*
Search Insert Position Total
Given a sorted array and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order.
You may assume no duplicates in the array.
Here are few examples.
[1,3,5,6], 5 → 2
[1,3,5,6], 2 → 1
[1,3,5,6], 7 → 4
[1,3,5,6], 0 → 0
*/
/*
Feb 24 2014
Solution:
* scan the input array, return the index if A[index] is no smaller than target. If all elements are smaller than target, return n. Target should be the nth element.
*/
class Solution {
public:
int searchInsert(int A[], int n, int target) {
if (!n || !A) return 0;
for (int i = 0; i < n; i++)
{
if (A[i] >= target)
{
return i;
}
}
return n;
}
};
| [
"[email protected]"
] | |
cf2bc674c8d1c44beb0665a8957c19bd1416a318 | f83ef53177180ebfeb5a3e230aa29794f52ce1fc | /ACE/ACE_wrappers/TAO/tao/AnyTypeCode/Enum_TypeCode.h | 43d3994b0ea472439dc707f7fe511b04875adf55 | [
"LicenseRef-scancode-unknown-license-reference",
"LicenseRef-scancode-proprietary-license",
"LicenseRef-scancode-sun-iiop",
"Apache-2.0"
] | permissive | msrLi/portingSources | fe7528b3fd08eed4a1b41383c88ee5c09c2294ef | 57d561730ab27804a3172b33807f2bffbc9e52ae | refs/heads/master | 2021-07-08T01:22:29.604203 | 2019-07-10T13:07:06 | 2019-07-10T13:07:06 | 196,183,165 | 2 | 1 | Apache-2.0 | 2020-10-13T14:30:53 | 2019-07-10T10:16:46 | null | UTF-8 | C++ | false | false | 3,620 | h | // -*- C++ -*-
//=============================================================================
/**
* @file Enum_TypeCode.h
*
* Header file for a @c tk_enum CORBA::TypeCode.
*
* @author Ossama Othman <[email protected]>
*/
//=============================================================================
#ifndef TAO_ENUM_TYPECODE_H
#define TAO_ENUM_TYPECODE_H
#include /**/ "ace/pre.h"
#include "tao/AnyTypeCode/TypeCode.h"
#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */
#include "tao/AnyTypeCode/TypeCode_Base_Attributes.h"
TAO_BEGIN_VERSIONED_NAMESPACE_DECL
namespace TAO
{
namespace TypeCode
{
/**
* @class Enum
*
* @brief @c CORBA::TypeCode implementation for an OMG IDL
* @c enum.
*
* This class implements a @c CORBA::TypeCode for an OMG IDL
* @c enum.
*/
template <typename StringType,
class EnumeratorArrayType,
class RefCountPolicy>
class Enum
: public CORBA::TypeCode,
private RefCountPolicy
{
public:
/// Constructor.
Enum (char const * id,
char const * name,
EnumeratorArrayType const & enumerators,
CORBA::ULong nenumerators);
/**
* @name TAO-specific @c CORBA::TypeCode Methods
*
* Methods required by TAO's implementation of the
* @c CORBA::TypeCode class.
*
* @see @c CORBA::TypeCode
*/
//@{
virtual bool tao_marshal (TAO_OutputCDR & cdr, CORBA::ULong offset) const;
virtual void tao_duplicate (void);
virtual void tao_release (void);
//@}
protected:
/**
* @name @c TAO CORBA::TypeCode Template Methods
*
* @c tk_enum @c CORBA::TypeCode -specific template methods.
*
* @see @c CORBA::TypeCode
*/
//@{
virtual CORBA::Boolean equal_i (CORBA::TypeCode_ptr tc) const;
virtual CORBA::Boolean equivalent_i (CORBA::TypeCode_ptr tc) const;
virtual CORBA::TypeCode_ptr get_compact_typecode_i (void) const;
virtual char const * id_i (void) const;
virtual char const * name_i (void) const;
virtual CORBA::ULong member_count_i (void) const;
virtual char const * member_name_i (CORBA::ULong index) const;
//@}
private:
/**
* @c Enum Attributes
*
* Attributes representing the structure of an OMG IDL
* @c enum.
*
* @note These attributes are declared in the order in which
* they are marshaled into a CDR stream in order to
* increase cache hits by improving spatial locality.
*/
//@{
/// Base attributes containing repository ID and name of
/// structure type.
Base_Attributes<StringType> base_attributes_;
/// The number of enumerators in the OMG IDL enumeration.
CORBA::ULong const nenumerators_;
/// Array of @c TAO::TypeCode enumerators representing
/// enumerators in the OMG IDL defined @c enum.
EnumeratorArrayType const enumerators_;
};
} // End namespace TypeCode
} // End namespace TAO
TAO_END_VERSIONED_NAMESPACE_DECL
#ifdef __ACE_INLINE__
# include "tao/AnyTypeCode/Enum_TypeCode.inl"
#endif /* __ACE_INLINE__ */
#ifdef ACE_TEMPLATES_REQUIRE_SOURCE
# include "tao/AnyTypeCode/Enum_TypeCode.cpp"
#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */
#ifdef ACE_TEMPLATES_REQUIRE_PRAGMA
# pragma implementation ("Enum_TypeCode.cpp")
#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */
#include /**/ "ace/post.h"
#endif /* TAO_ENUM_TYPECODE_H */
| [
"[email protected]"
] | |
8655bb4b3e65c20413df7c10498a7d1e5b4d599d | 76ca52991ca1a1e50d066e9f7c4827b6a4453414 | /cmds/incident_helper/src/parsers/EventLogTagsParser.h | 79057ce0b3cab5ddeb4df5f2cc58409e007b7210 | [
"Apache-2.0",
"LicenseRef-scancode-unicode"
] | permissive | ResurrectionRemix/android_frameworks_base | 3126048967fa5f14760664bea8002e7911da206a | 5e1db0334755ba47245d69857a17f84503f7ce6f | refs/heads/Q | 2023-02-17T11:50:11.652564 | 2021-09-19T11:36:09 | 2021-09-19T11:36:09 | 17,213,932 | 169 | 1,154 | Apache-2.0 | 2023-02-11T12:45:31 | 2014-02-26T14:52:44 | Java | UTF-8 | C++ | false | false | 1,084 | h | /*
* Copyright (C) 2017 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef EVENT_LOG_TAGS_PARSER_H
#define EVENT_LOG_TAGS_PARSER_H
#include "TextParserBase.h"
using namespace android;
/**
* event.logtags parser, parse file in /system/etc/event-log-tags
*/
class EventLogTagsParser : public TextParserBase {
public:
EventLogTagsParser() : TextParserBase(String8("EventLogTagsParser")) {};
~EventLogTagsParser() {};
virtual status_t Parse(const int in, const int out) const;
};
#endif // EVENT_LOG_TAGS_PARSER_H
| [
"[email protected]"
] | |
dd417c98b1f53b5bf6ae66eb8159c419922d99a6 | 45d201c41ef3b9ded5735ddad916ea064210281d | /gui_main/order_editor.h | d6b099de06015166ca209a85ab6c7ebcb6454e0f | [] | no_license | reduz/coconut-studio | 9a655771448336126a79678642b3ffef46a78068 | b52c5080da427a44e18d653e0a0574410503f4bb | refs/heads/master | 2021-01-22T01:04:55.221695 | 2018-01-10T23:08:42 | 2018-01-10T23:08:42 | 32,185,446 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 223 | h | #ifndef ORDER_EDITOR_H
#define ORDER_EDITOR_H
#include <QWidget>
class OrderEditor : public QWidget
{
Q_OBJECT
public:
explicit OrderEditor(QWidget *parent = 0);
signals:
public slots:
};
#endif // ORDER_EDITOR_H
| [
"reduzio@042f636a-f736-11de-abf5-6d7912ff0902"
] | reduzio@042f636a-f736-11de-abf5-6d7912ff0902 |
0171698cc3a1911aaded01dcf28be2ff97755af9 | da08587500cee23a4ddc2c0ee3d7c8a1d1d969e7 | /projects/leja/leja.cpp | 8830c4c2b9710d4893d5a65fcb0a06699b9f4582 | [] | no_license | knut0815/QUIJIBO | fcdfaf3c12a4ba5f27d5b43ba4b976830449e159 | 2ce03411dd1d0b6e71baa477d4fba91393263819 | refs/heads/master | 2021-06-21T05:02:00.483560 | 2017-06-14T03:18:02 | 2017-06-14T03:18:02 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 17,530 | cpp | /*
QUIJIBO: Source code for the paper Symposium on Geometry Processing
2015 paper "Quaternion Julia Set Shape Optimization"
Copyright (C) 2015 Theodore Kim
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "TRIANGLE_MESH.h"
#include <MERSENNETWISTER.h>
#include <queue>
#include <algorithm>
#include <float.h>
#include "OPTIMIZE_3D.h"
#include "POLYNOMIAL_4D.h"
#include "SPHERE.h"
#include "VECTOR3_FIELD_3D.h"
#include "SIMPLE_PARSER.h"
// used the squared distance? If so, this is not actually potential anymore ...
#define USING_SQUARED 0
using namespace std;
//////////////////////////////////////////////////////////////////////////////
// Meshes and integrators
//////////////////////////////////////////////////////////////////////////////
TRIANGLE_MESH* triangleMesh;
FIELD_3D distanceField;
FIELD_3D colorField;
FIELD_3D offsetColors;
FIELD_3D surfaceShell;
FIELD_3D shellPotential;
float marchingSurface = 0;
// the potential being approximated at an outer shell
vector<int> shellIndices;
vector<VEC3F> shellPositions;
// the surface points being used to approximate the outer shell
vector<int> surfaceIndices;
vector<VEC3F> surfacePositions;
vector<VEC3F> rootPositions;
vector<VEC3F> plyPoints;
//Real relativeErrorThreshold = 0.04;
//Real relativeErrorThreshold = 0.03;
Real relativeErrorThreshold = 0.02;
vector<SPHERE> topSpheres;
vector<SPHERE> bottomSpheres;
vector<Real> topWeights;
vector<Real> bottomWeights;
vector<VEC3F> topPoints;
Real bottomPower = 3.0;
////////////////////////////////////////////////////////////////////////////
// write out an oriented point cloud to PLY
////////////////////////////////////////////////////////////////////////////
bool writePlyPoints(const string& filename, const vector<VEC3F>& points)
{
FILE* file = NULL;
file = fopen(filename.c_str(), "w");
if (file == NULL)
{
cout << __FILE__ << " " << __FUNCTION__ << " " << __LINE__ << " : " << endl;
cout << " Couldn't open file " << filename.c_str() << "!!!" << endl;
exit(0);
}
fprintf(file, "ply\n");
//fprintf(file, "format ascii 1.0\n");
fprintf(file, "format binary_little_endian 1.0\n");
int totalVertices = points.size();
fprintf(file, "element vertex %i\n", totalVertices);
fprintf(file, "property float x\n");
fprintf(file, "property float y\n");
fprintf(file, "property float z\n");
fprintf(file, "element face 0\n");
fprintf(file, "property list uchar int vertex_index\n");
fprintf(file, "end_header\n");
// close the text file
fclose(file);
// reopen in binary for output
file = fopen(filename.c_str(), "ab");
if (file == NULL)
{
cout << __FILE__ << " " << __FUNCTION__ << " " << __LINE__ << " : " << endl;
cout << " Couldn't open file " << filename.c_str() << " for binary output!!!" << endl;
exit(0);
}
for (int x = 0; x < totalVertices; x++)
{
float vertex[] = {points[x][0], points[x][1], points[x][2]};
fwrite((void*)&(vertex[0]), sizeof(float), 1, file);
fwrite((void*)&(vertex[1]), sizeof(float), 1, file);
fwrite((void*)&(vertex[2]), sizeof(float), 1, file);
}
// close the binary file
fclose(file);
return true;
}
//////////////////////////////////////////////////////////////////////////////
// Read in a PLY file of points
//////////////////////////////////////////////////////////////////////////////
void readPointsPLY(const string& filename, vector<VEC3F>& points)
{
points.clear();
FILE* file = NULL;
file = fopen(filename.c_str(), "r");
if (file == NULL)
{
cout << __FILE__ << " " << __FUNCTION__ << " " << __LINE__ << " : " << endl;
cout << " Couldn't open file " << filename.c_str() << "!!!" << endl;
exit(0);
}
fscanf(file, "ply\n");
fscanf(file, "format binary_little_endian 1.0\n");
int totalPoints;
fscanf(file, "element vertex %i\n", &totalPoints);
fscanf(file, "property float x\n");
fscanf(file, "property float y\n");
fscanf(file, "property float z\n");
fscanf(file, "element face 0\n");
fscanf(file, "property list uchar int vertex_index\n");
fscanf(file, "end_header\n");
cout << " scanning for " << totalPoints << " points " << endl;
Real maxMagnitude = 0;
for (int x = 0; x < totalPoints; x++)
{
float vertex[3];
fread((void*)&(vertex[0]), sizeof(float), 1, file);
fread((void*)&(vertex[1]), sizeof(float), 1, file);
fread((void*)&(vertex[2]), sizeof(float), 1, file);
VEC3F vertexFinal(vertex[0], vertex[1], vertex[2]);
if (vertexFinal.magnitude() > 1000)
continue;
if (vertexFinal.magnitude() > maxMagnitude)
{
cout << " max found: " << vertexFinal << endl;
maxMagnitude = vertexFinal.magnitude();
}
points.push_back(vertexFinal);
}
cout << " max point magnitude found: " << maxMagnitude << endl;
// close the binary file
fclose(file);
}
//////////////////////////////////////////////////////////////////////////////
// shuffle a vector in a deterministic way using Mersenne Twister.
// C++11 has this built in, but too late for that now ...
//////////////////////////////////////////////////////////////////////////////
vector<VEC3F> shuffle(vector<VEC3F>& toShuffle)
{
TIMER functionTimer(__FUNCTION__);
MERSENNETWISTER twister(123456);
vector<VEC3F> final(toShuffle.size());
for (unsigned int x = 0; x < toShuffle.size(); x++)
{
int back = toShuffle.size() - 1;
// pick a random element
int pick = twister.randInt(back);
final[x] = toShuffle[pick];
final[pick] = toShuffle[x];
}
return final;
}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
void buildLejaPoints()
{
// Shuffle the random points
cout << " Shuffling ... " << flush;
plyPoints = shuffle(plyPoints);
cout << endl;
// pick one at random as the first Leja point
MERSENNETWISTER twister(123456);
map<int, bool> picked;
int first = twister.randInt(plyPoints.size());
topSpheres.push_back(SPHERE(plyPoints[first], 0.02));
topPoints.push_back(plyPoints[first]);
picked[first] = true;
const VEC3F& currentLeja = topSpheres.back().center();
// initialize the Leja products
vector<double> lejaProducts;
for (int x = 0; x < plyPoints.size(); x++)
{
double distance = (plyPoints[x] - currentLeja).magnitude();
lejaProducts.push_back(distance);
}
// add the next Leja Points
const int totalLejaPoints = 100;
for (int x = 0; x < totalLejaPoints; x++)
{
// find the smallest product
int largestIndex = -1;
double largestDistance = 0;
for (int y = 0; y < lejaProducts.size(); y++)
{
if (picked.find(y) != picked.end())
continue;
if (lejaProducts[y] > largestDistance)
{
largestIndex = y;
largestDistance = lejaProducts[y];
}
}
assert(largestIndex != -1);
// add it to the list
topSpheres.push_back(SPHERE(plyPoints[largestIndex], 0.02));
topPoints.push_back(plyPoints[largestIndex]);
picked[largestIndex] = true;
cout << " Add point " << x << "\t" << plyPoints[largestIndex] << "\t with distance " << largestDistance << endl;
// update the rest of the Leja products
const VEC3F& currentLeja = topSpheres.back().center();
for (int y = 0; y < lejaProducts.size(); y++)
{
double distance = (plyPoints[y] - currentLeja).magnitude();
lejaProducts[y] *= (distance);
}
}
}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
void buildPoissonSourceSimulation()
{
// do it in a way with a known implementation
//srand(123456);
//random_shuffle(plyPoints.begin(), plyPoints.end());
cout << " Shuffling ... " << flush;
plyPoints = shuffle(plyPoints);
cout << endl;
TIMER functionTimer(__FUNCTION__);
// build the residual vector
VECTOR targetPotential(shellIndices.size());
// lift the original potential from the field
for (unsigned int x = 0; x < shellIndices.size(); x++)
targetPotential[x] = shellPotential[shellIndices[x]];
VECTOR residual = targetPotential;
vector<VECTOR> bestColumns;
VECTOR solution;
Real relative = 1;
while (relative > relativeErrorThreshold)
{
// build the candidate set
int candidateSetSize = 100;
vector<VEC3F> candidateSet;
for (int x = 0; x < candidateSetSize; x++)
{
candidateSet.push_back(plyPoints.back());
plyPoints.pop_back();
}
cout << " Source " << bestColumns.size() << ", " << flush;
// build the column for each candidate site
cout << " Building columns ... " << flush;
vector<VECTOR> candidateColumns(candidateSetSize);
#pragma omp parallel
#pragma omp for schedule(dynamic)
for (int x = 0; x < candidateSetSize; x++)
{
// compute the potential here
VECTOR potential(targetPotential.size());
// where is the center of the pole
VEC3F pole = candidateSet[x];
for (int y = 0; y < potential.size(); y++)
{
// get the radius
Real radius = (shellPositions[y] - pole).magnitude();
// assume a unit charge
#if USING_SQUARED
potential[y] = 1.0 / (radius * radius);
#else
potential[y] = 1.0 / radius;
#endif
}
candidateColumns[x] = potential;
}
cout << " done. " << flush;
// find the site with the best projection onto the residual
TIMER dotTimer("Dot Products");
VECTOR dots(candidateSetSize);
#pragma omp parallel
#pragma omp for schedule(dynamic)
for (int x = 0; x < candidateSetSize; x++)
{
// get the projection onto the residual
Real dot = fabs(candidateColumns[x].dot(residual));
dots[x] = dot;
}
Real bestSeen = 0;
int bestSeenIndex = -1;
for (int x = 0; x < dots.size(); x++)
{
if (dots[x] > bestSeen)
{
bestSeen = dots[x];
bestSeenIndex = x;
}
}
dotTimer.stop();
//cout << " Best candidate seen: " << bestSeen << "\t index: " << bestSeenIndex << endl;
assert(bestSeenIndex >= 0);
rootPositions.push_back(candidateSet[bestSeenIndex]);
bestColumns.push_back(candidateColumns[bestSeenIndex]);
const int rows = bestColumns[0].size();
const int cols = bestColumns.size();
MATRIX A(rows, cols);
for (int y = 0; y < cols; y++)
for (int x = 0; x < rows; x++)
A(x,y) = bestColumns[y][x];
MATRIX newA = A;
// do it the Eigen way
VECTOR b(targetPotential);
//bool success = A.solveLeastSquares(b);
//assert(success);
//solution = VECTOR(bestColumns.size());
//for (int x = 0; x < bestColumns.size(); x++)
// solution[x] = b[x];
solution = A.jacobiSvd(Eigen::ComputeThinU | Eigen::ComputeThinV).solve(b);
VECTOR fit = newA * solution;
residual = targetPotential - fit;
relative = residual.norm() / targetPotential.norm();
cout << " Weight: " << solution[solution.size() - 1] << " \t Residual after fit: " << residual.norm() << " relative: " << relative << endl;
cout << " New root magnitude: " << candidateSet[bestSeenIndex].magnitude() << endl;
}
FIELD_3D residualField(shellPotential);
residualField = 0;
for (unsigned int x = 0; x < shellIndices.size(); x++)
residualField[shellIndices[x]] = residual[x];
int positives = 0;
Real topSum = 0;
Real bottomSum = 0;
topSpheres.clear();
topWeights.clear();
bottomSpheres.clear();
bottomWeights.clear();
for (int x = 0; x < solution.size(); x++)
{
if (solution[x] > 0)
{
positives++;
topSpheres.push_back(SPHERE(rootPositions[x], 0.02));
topWeights.push_back(solution[x]);
topSum += solution[x];
}
else
{
bottomSpheres.push_back(SPHERE(rootPositions[x], 0.02));
bottomWeights.push_back(solution[x]);
bottomSum += solution[x];
}
}
cout << " positive roots: " << topWeights.size() << endl;
cout << " negative roots: " << bottomWeights.size() << endl;
cout << " top sum: " << topSum << endl;
cout << " bottom sum: " << bottomSum << endl;
TIMER::printTimings();
}
//////////////////////////////////////////////////////////////////////////////
//
//////////////////////////////////////////////////////////////////////////////
int main(int argc, char* argv[])
{
TIMER functionTimer(__FUNCTION__);
if (argc != 2)
{
cout << " USAGE: " << argv[0] << " <cfg file> " << endl;
exit(0);
}
SIMPLE_PARSER parser(argv[1]);
string path = parser.getString("path", "./temp/");
string distanceFilename = path + parser.getString("distance field", "dummy.field3D");
string potentialFilename = path + parser.getString("potential field", "dummy.field3D");
string pointsFilename = path + parser.getString("poisson output", "dummy.ply");
relativeErrorThreshold = parser.getFloat("relative error threshold", relativeErrorThreshold);
cout << " Using relative error threshold: " << relativeErrorThreshold << endl;
distanceField = FIELD_3D(distanceFilename.c_str());
//colorField = FIELD_3D(potentialFilename.c_str());
// get the points
readPointsPLY(pointsFilename.c_str(), plyPoints);
/*
FIELD_3D fieldCopy(distanceField);
fieldCopy -= marchingSurface;
triangleMesh = new TRIANGLE_MESH(fieldCopy);
int potentialOffset = parser.getInt("potential offset", 3);
cout << " Using a potential offset surface of: " << potentialOffset << endl;
// create an offset distance field
FIELD_3D offsetField(distanceField);
offsetField -= potentialOffset * offsetField.dx();
// get its closest point field
VECTOR3_FIELD_3D closestPoints = VECTOR3_FIELD_3D::computeClosestPoints(offsetField);
//closestPoints.write("./temp/closest.vector.field3d");
// do an extension of the color field using the offset distance
offsetColors = VECTOR3_FIELD_3D::setToClosestPointValues(colorField, closestPoints);
//offsetColors.write("./temp/offset.field3d");
FIELD_3D originalExtensionField = offsetColors;
// create a shell potential
FIELD_3D scaledDistance(offsetField);
shellPotential = FIELD_3D(offsetColors);
shellPotential.setZeroBorder();
const int xRes = shellPotential.xRes();
const int slabSize = shellPotential.slabSize();
for (int z = 1; z < shellPotential.zRes() - 1; z++)
for (int y = 1; y < shellPotential.yRes() - 1; y++)
for (int x = 1; x < shellPotential.xRes() - 1; x++)
{
int index = x + y * xRes + z * slabSize;
if (scaledDistance[index] < 0)
{
shellPotential[index] = 0;
continue;
}
if (scaledDistance[index + 1] < 0 ||
scaledDistance[index - 1] < 0 ||
scaledDistance[index + xRes] < 0 ||
scaledDistance[index - xRes] < 0 ||
scaledDistance[index + slabSize] < 0 ||
scaledDistance[index - slabSize] < 0)
{
// do nothing, just store the location
shellIndices.push_back(index);
shellPositions.push_back(scaledDistance.cellCenter(index));
}
else
shellPotential[index] = 0;
}
surfaceShell = distanceField.outerShell();
for (int x = 0; x < surfaceShell.totalCells(); x++)
if (surfaceShell[x] > 0.5)
{
surfaceIndices.push_back(x);
surfacePositions.push_back(surfaceShell.cellCenter(x));
}
*/
//buildPoissonSourceSimulation();
buildLejaPoints();
writePlyPoints("./temp/leja.ply", topPoints);
// write the roots out
OPTIMIZE_3D optimize3D;
//optimize3D.setScoreFields(distanceField, offsetColors);
optimize3D.setScoreFields(distanceField, distanceField);
vector<QUATERNION> topRoots;
for (unsigned int x = 0; x < topSpheres.size(); x++)
{
VEC3F center = topSpheres[x].translation();
topRoots.push_back(QUATERNION(center[0], center[1], center[2], 0));
}
POLYNOMIAL_4D topPolynomial(topRoots);
for (unsigned int x = 0; x < topSpheres.size(); x++)
topPolynomial.powersMutable()[x] = 1.0;
optimize3D.top() = topPolynomial;
/*
vector<QUATERNION> bottomRoots;
for (unsigned int x = 0; x < bottomSpheres.size(); x++)
{
VEC3F center = bottomSpheres[x].translation();
bottomRoots.push_back(QUATERNION(center[0], center[1], center[2], 0));
}
POLYNOMIAL_4D bottomPolynomial(bottomRoots);
for (unsigned int x = 0; x < bottomWeights.size(); x++)
bottomPolynomial.powersMutable()[x] = fabs(bottomWeights[x]);
optimize3D.bottom() = bottomPolynomial;
*/
// add a zero root to the front
cout << " ADDING A ZERO ROOT " << endl;
QUATERNION zeroRoot(0,0,0,0);
optimize3D.top().addFrontRoot(zeroRoot);
/*
optimize3D.bottom().addFrontRoot(zeroRoot);
*/
string outputFilename = path + parser.getString("source simulation filename", "temp.o3d");
cout << " Outputting to file " << outputFilename.c_str() << endl;
optimize3D.write(outputFilename.c_str());
return 0;
}
| [
"[email protected]"
] | |
3b46e6eb0072490b5e1d171c591ba3afeb8bc4e2 | 2718dbcf4caac1c204fb4ee75f7506c381a49761 | /platform/src/system/ISASimTest.cpp | 1399ddc6b2eeed97cbc46e7bee93a7405fe26cea | [] | no_license | Jing-You/ee6470-final | 0870decb2f1b05b1cc0133f1f37b98da561d0b39 | 9db50304ab1bd4bbc595a03bcad1cb7d26008f92 | refs/heads/master | 2020-12-04T23:03:46.811519 | 2020-01-05T14:24:43 | 2020-01-05T14:24:43 | 231,928,564 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,677 | cpp | #include <systemc>
#include "ISASimPlatform.h"
#include "AccPlatform.h"
#include "tclap/CmdLine.h"
const char *project_name="riscv";
const char *project_file="riscv.ac";
const char *archc_version="2.4.1";
const char *archc_options="-abi ";
std::string concat(std::string s, int n) {
return s + std::to_string(n);
}
size_t split(const std::string &txt, std::vector<std::string> &strs, char ch = ' ') {
size_t pos = txt.find( ch );
size_t initialPos = 0;
strs.clear();
// Decompose statement
while( pos != std::string::npos ) {
strs.push_back( txt.substr( initialPos, pos - initialPos ) );
initialPos = pos + 1;
pos = txt.find( ch, initialPos );
}
// Add the last one
strs.push_back( txt.substr( initialPos, std::min( pos, txt.size() ) - initialPos + 1 ) );
return strs.size();
}
char** new_app_argv(int app_argc, const std::vector<std::string> &split_app_argv) {
char** app_argv_cstr_array = new char*[app_argc];
for (unsigned int i = 0; i<app_argc; i++ ) {
std::string str = split_app_argv[i];
char* arg = new char[str.size()+1];
strcpy(arg, str.c_str());
app_argv_cstr_array[i] = arg;
}
return app_argv_cstr_array;
}
void delete_app_argv(int app_argc, char** app_argv_cstr_array) {
for (unsigned int i = 0; i<app_argc; i++ ) {
delete app_argv_cstr_array[i];
}
delete [] app_argv_cstr_array;
}
int sc_main(int ac, char* av[]) {
std::string app_argv;
bool gdb_enable;
std::string filib_argv;
try {
TCLAP::CmdLine cmd("Triple-core ArchC RISC-V Fault Simulation Platform", ' ', "0.0.0.0");
TCLAP::ValueArg<std::string> app_argv_arg
( "a", "app", "Input application command line arguments argv (enclose string including space with quotes)",
true, "./binary", "string", cmd);
TCLAP::SwitchArg gdb_enable_arg
( "g","gdb","To enable gdb support for ArchC RISC-V processor", cmd, false);
cmd.parse(ac, av);
app_argv = app_argv_arg.getValue();
gdb_enable = gdb_enable_arg.getValue();
}
catch (TCLAP::ArgException &e) //catch any exceptions
{
std::cerr<< "error: " << e.error() << " for argument " << e.argId() << std::endl;
exit(-1);
}
std::vector<std::string> split_app_argv;
size_t app_argc = split(app_argv, split_app_argv);
char** app_argv_cstr_array = new_app_argv(app_argc, split_app_argv);
std::vector<std::string> split_filib_argv;
const int NCORE = 4;
sc_set_time_resolution(1, SC_NS);
AccPlatform acc_platform("AcceleratorPlatform");
ISASimPlatform *platform[NCORE];
for (int i = 0; i < NCORE; ++i)
platform[i] = new ISASimPlatform(concat("Controller", i).c_str());
/* Bus Binding */
for (int i = 0; i < NCORE; ++i) {
platform[i]->ctrler_local_t_adapter(acc_platform.local_bus);
platform[i]->ctrler_global_t_adapter(acc_platform.system_bus);
}
for (int i = 0; i < NCORE; ++i) {
platform[i]->controller.cpu.set_args(app_argc, app_argv_cstr_array);
platform[i]->controller.cpu.load(app_argv_cstr_array[0]);
platform[i]->controller.cpu.init();
}
delete_app_argv(app_argc, app_argv_cstr_array);
cerr << endl;
#ifdef AC_DEBUG
ac_trace("controller.trace");
#endif
sc_start();
for (int i = 0; i < NCORE; ++i)
platform[i]->controller.cpu.PrintStat();
cerr << endl;
#ifdef AC_STATS
ac_stats_base::print_all_stats(std::cerr);
#endif
#ifdef AC_DEBUG
ac_close_trace();
#endif
cout << "= " << sc_time_stamp().to_string() << " =\n"
<< "Finished sc_main." << endl;
return platform[0]->controller.cpu.ac_exit_status;
}
| [
"[email protected]"
] | |
bb7bafe945bb1c4c0bac6941e4849f24a0da29e2 | ee835fddfb793fe0c3a918e9d3c42c3e38f7e76a | /src/B1ParallelWorldConstruction.cc | eab536255357a9b1a06290e0ac4e32bfa2d0baec | [] | no_license | whit2333/bubble_chamber | 75a2809d7e5a1c50bbdf58a27f2c47a170757494 | c5bb2457ed1f08c021eb3b152cd2bdd9f26f6816 | refs/heads/master | 2021-01-10T02:15:43.064580 | 2018-03-04T02:22:19 | 2018-03-04T02:22:19 | 43,964,439 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,225 | cc | #include "B1ParallelWorldConstruction.hh"
#include "G4Box.hh"
#include "G4Tubs.hh"
#include "G4LogicalVolume.hh"
#include "G4PVPlacement.hh"
#include "G4PVParameterised.hh"
#include "G4Material.hh"
#include "G4SystemOfUnits.hh"
#include "G4SDManager.hh"
#include "G4Colour.hh"
#include "G4VisAttributes.hh"
#include <string>
#include "FakeSD.hh"
B1ParallelWorldConstruction ::B1ParallelWorldConstruction(G4String& parallelWorldName) :
G4VUserParallelWorld(parallelWorldName),
fConstructed(false),
fNeedsRebuilt(true)
{
for(int i = 0; i < fNplanes; i++) {
fDet_solid[i] = nullptr;
fDet_log[i] = nullptr;
fDet_phys[i] = nullptr;
fDet_det[i] = nullptr;
fDet_vis[i] = nullptr;
}
for(int i = 0; i < fNNplanes; i++) {
fNDet_solid[i] = nullptr;
fNDet_log[i] = nullptr;
fNDet_phys[i] = nullptr;
fNDet_det[i] = nullptr;
fNDet_vis[i] = nullptr;
}
fDet_pos = {{
{0,0,-3.25*mm},
{0,0,3.25*mm},
{0,0,3.25*mm + 1.0*mm + 6.0*2.54*cm },
{0,0,3.25*mm + 1.0*mm + 6.0*2.54*cm + 15.24*cm + 6.17*mm},
{0,0,3.25*mm + 1.0*mm + 6.0*2.54*cm + 6.17*mm + 2.0*2.54*cm + 30.48*cm - 15.24*cm - 9.17*mm},
{0,0,3.25*mm + 1.0*mm + 6.0*2.54*cm + 6.17*mm +2.0*2.54*cm + 30.48*cm + 5.0*mm},
{0,0,3.25*mm + 1.0*mm + 6.0*2.54*cm + 15.24*cm + 6.17*mm + 38.10*mm + 15.24*cm+ 4.0*mm +15.0*2.54*cm}
}};
std::cout << "Parallel world ctor" <<std::endl;
}
//______________________________________________________________________________
B1ParallelWorldConstruction::~B1ParallelWorldConstruction()
{ }
//______________________________________________________________________________
void B1ParallelWorldConstruction::Construct()
{
if( !fNeedsRebuilt && fConstructed) return;
fConstructed = true;
std::cout << "constriing Parallel world " <<std::endl;
bool checkOverlaps = false;
int natoms = 0;
int ncomponents = 0;
double A = 0.0;
double Z = 0.0;
double thickness = 0.0;
double surface_z = 0.0;
double red = 0.0;
double green = 0.0;
double blue = 0.0;
double alpha = 0.0;
double density = 0.0;
double pressure = 0.0;
double temperature = 0.0;
G4VSolid * scoring_solid = nullptr;
G4LogicalVolume * scoring_log = nullptr;
G4VPhysicalVolume * scoring_phys = nullptr;
FakeSD * scoring_det = nullptr;
G4VisAttributes * scoring_vis = nullptr;
// --------------------------------------------------------------
// World
//
G4VPhysicalVolume * ghostWorld = GetWorld();
G4LogicalVolume * worldLogical = ghostWorld->GetLogicalVolume();
//auto world_vis = new G4VisAttributes();
auto world_vis = new G4VisAttributes(G4VisAttributes::GetInvisible());
//(*world_vis) = ;
world_vis->SetForceWireframe(true);
worldLogical->SetVisAttributes(world_vis);
// --------------------------------------------------------------
//
double scoring_length = 1.0*um;
double step_size = fSpanDistance/double(fNplanes-1);
G4ThreeVector step = fDirection;
step.setMag(step_size);
for(int i = 0; i < fNplanes; i++) {
red = 177.0/256.0;
green = 104.0/256.0;
blue = 177.0/256.0;
alpha = 0.7;
scoring_solid = fDet_solid[i];
scoring_log = fDet_log[i];
scoring_phys = fDet_phys[i];
scoring_det = fDet_det[i];
scoring_vis = fDet_vis[i];
if(scoring_phys) delete scoring_phys;
if(scoring_log) delete scoring_log;
if(scoring_solid) delete scoring_solid;
//if(scoring_det) delete scoring_det;
std::string detname_solid = "scoring_solid_" + std::to_string(i);
std::string detname_log = "scoring_log_" + std::to_string(i);
std::string detname_phys = "scoring_phys_" + std::to_string(i);
scoring_solid = new G4Tubs(detname_solid, 0.0, fDet_size/2.0, scoring_length/2.0, 0.0, 360.*deg );
scoring_log = new G4LogicalVolume(scoring_solid, 0, detname_log);
scoring_phys = new G4PVPlacement(0,fDet_pos[i], scoring_log, detname_phys, worldLogical,false,0,checkOverlaps);
G4Colour scoring_color {red, green, blue, alpha }; // Gray
if(!scoring_vis) {
scoring_vis = new G4VisAttributes(scoring_color);
} else {
scoring_vis->SetColour(scoring_color);
}
scoring_vis->SetForceWireframe(true);
scoring_log->SetVisAttributes(scoring_vis);
//G4UserLimits * scoring_limits = new G4UserLimits(0.004*um);
//scoring_log->SetUserLimits(scoring_limits);
if(!scoring_det){
std::string sdname = "/p" + std::to_string(i);
scoring_det = new FakeSD(sdname);
}
//SetSensitiveDetector("scoring_log",scoring_det);
G4SDManager::GetSDMpointer()->AddNewDetector(scoring_det);
scoring_log->SetSensitiveDetector(scoring_det);
}
// ---------------------
// Pb Pig detector
red = 255.0/256.0;
green = 104.0/256.0;
blue = 0.0/256.0;
alpha = 0.5;
int idet = 0;
scoring_solid = fNDet_solid[idet];
scoring_log = fNDet_log[idet];
scoring_phys = fNDet_phys[idet];
scoring_det = fNDet_det[idet];
scoring_vis = fNDet_vis[idet];
if(scoring_phys) delete scoring_phys;
if(scoring_log) delete scoring_log;
if(scoring_solid) delete scoring_solid;
//if(scoring_det) delete scoring_det;
std::string detname_solid = "Ndet_scoring_solid_" + std::to_string(idet);
std::string detname_log = "Ndet_scoring_log_" + std::to_string(idet);
std::string detname_phys = "Ndet_scoring_phys_" + std::to_string(idet);
fNDet_pos[idet] = Pb_pig_pos + Pb_pig_offset + G4ThreeVector(0,190.0*mm,0);
G4RotationMatrix* rot = new G4RotationMatrix( CLHEP::HepRotationX(90.0*deg) );
scoring_solid = new G4Tubs( detname_solid, 0.0, 4.0*cm/2.0, 5.0*cm/2.0, 0.0, 360.*deg );
scoring_log = new G4LogicalVolume( scoring_solid, 0, detname_log);
scoring_phys = new G4PVPlacement( rot,fNDet_pos[idet], scoring_log, detname_phys, worldLogical,false,0,checkOverlaps);
G4Colour scoring_color {red, green, blue, alpha }; // Gray
if(!scoring_vis) {
scoring_vis = new G4VisAttributes(scoring_color);
} else {
scoring_vis->SetColour(scoring_color);
}
scoring_vis->SetForceWireframe(true);
scoring_log->SetVisAttributes(scoring_vis);
//G4UserLimits * scoring_limits = new G4UserLimits(0.004*um);
//scoring_log->SetUserLimits(scoring_limits);
if(!scoring_det){
std::string sdname = "/n" + std::to_string(idet);
scoring_det = new FakeSD(sdname);
}
//SetSensitiveDetector("scoring_log",scoring_det);
G4SDManager::GetSDMpointer()->AddNewDetector(scoring_det);
scoring_log->SetSensitiveDetector(scoring_det);
fNeedsRebuilt = false;
}
//______________________________________________________________________________
| [
"[email protected]"
] | |
baf4c22b1b014fbfe8a06f345fb41ebd9e996eb2 | 8481b904e1ed3b25f5daa982a3d0cafff5a8d201 | /C++/POJ/POJ 2068.cpp | d2651329bb7ecce913823c2372209c5bc3bf97c7 | [] | no_license | lwher/Algorithm-exercise | e4ac914b90b6e4098ab5236cc936a58f437c2e06 | 2d545af90f7051bf20db0a7a51b8cd0588902bfa | refs/heads/master | 2021-01-17T17:39:33.019131 | 2017-09-12T09:58:54 | 2017-09-12T09:58:54 | 70,559,619 | 1 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 625 | cpp | #include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
using namespace std;
int n,m[21],s;
int dp[21][(1<<13)+1];
int dfs(int now,int left)
{
if(dp[now][left]!=-1) return dp[now][left];
if(left==0)
{dp[now][0]=1;return 1;}
int i,ans=0;
for(i=1;i<=m[now];i++)
{
if(left<i) break;
if(dfs(now%n+1,left-i)==0)
ans=1;
}
dp[now][left]=ans;
return ans;
}
int main()
{
int i;
while(scanf("%d",&n) && n)
{
n*=2;
scanf("%d",&s);
for(i=1;i<=n;i++)
scanf("%d",&m[i]);
memset(dp,-1,sizeof(dp));
if(dfs(1,s)==1)
printf("1\n");
else
printf("0\n");
}
//system("pause");
return 0;
}
| [
"[email protected]"
] | |
66cbbc733378b20ce1bbcd38fbf58e7497f219c1 | ee8d6b2956c4d864eb5fdb7c84f2370a3a1cf7dd | /cpp3/operatorovld.cpp | 9007536f6e2ef02d6dfffb3c11c72e1e608c118b | [] | no_license | CGCC-CS/csc240spring20 | 1e19289c695a123fd93e1e4a91b18e65ef1ebbcc | 321a26d2736e8875d196aa81fc2d0072800eb254 | refs/heads/master | 2020-12-05T20:24:00.227392 | 2020-04-29T04:30:36 | 2020-04-29T04:30:36 | 232,237,328 | 1 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 1,478 | cpp | #include<iostream>
using namespace std;
// ---------------- Start of MyClass ----------------
class MyClass {
private:
int a;
public:
MyClass(int x=0) {
a = x;
}
void print() {
cout << " Printing: " << a << endl;
}
MyClass operator+(const MyClass& that);
MyClass operator+(int x);
// Friends can see private members
friend ostream& operator<<(ostream& strm, const MyClass& m);
friend MyClass operator+(int x, MyClass that);
};
MyClass MyClass::operator+(const MyClass& that) {
MyClass ret(this->a + that.a);
return ret;
}
MyClass MyClass::operator+(int x) {
MyClass ret(this->a + x);
return ret;
}
// ----------------- End of MyClass -----------------
ostream& operator<<(ostream& strm, const MyClass& m) {
strm << "{" << m.a << "}";
return strm;
}
MyClass operator+(int x, MyClass that) {
MyClass ret(x + that.a);
return ret;
}
int main() {
MyClass c1(1);
MyClass c2(2);
MyClass result;
cout << "Initial" << endl;
c1.print();
c2.print();
result.print();
cout << endl << "result = c1 + c2" << endl;
result = c1 + c2; // result = c1.operator+(c2);
result.print();
//cout << "c1 + c2 = " << c1.a << " + " << c2.a << " = " << c1.a+c2.a << endl;
cout << "c1 + c2 = " << c1 << " + " << c2 << " = " << c1+c2 << endl;
cout << "c1 + 10 = " << c1 << " + " << 10 << " = " << c1+10 << endl;
cout << "20 + c2 = " << 20 << " + " << c2 << " = " << 20+c2 << endl;
return 0;
}
| [
"[email protected]"
] | |
8f091884d2a8a3e4eecc9908a5e9650374d0f630 | 841a3bc5cf95f0c115e4d4eba2590a02c2e06dd2 | /main.cpp | 05eab0d977099e914a1d41c2f9eefaa2f2c05106 | [] | no_license | xiaocai2333/arrow_cython | 58231ea12365a437482f02700422c140b351a612 | 6963a4f2200756f76fccd5373694f1c0aade9bdb | refs/heads/master | 2020-12-08T15:59:22.190981 | 2020-01-18T08:25:17 | 2020-01-18T08:25:17 | 233,025,513 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,348 | cpp | #include <iostream>
#include "make_point.h"
#include "gis_func.h"
#include "arrow/api.h"
using namespace std;
int main() {
shared_ptr<arrow::Array> arr_ptr1;
shared_ptr<arrow::Array> arr_ptr2;
arrow::Int64Builder builder1;
shared_ptr<arrow::Array> arr_test_2;
arrow::Status status2;
status2 = builder1.Append(1);
status2 = builder1.Append(2);
status2 = builder1.Append(3);
status2 = builder1.Append(4);
status2 = builder1.Append(5);
status2 = builder1.Finish(&arr_test_2);
arrow::Int64Builder builder2;
shared_ptr<arrow::Array> arr_test_3;
arrow::Status status3;
status3 = builder1.Append(1);
status3 = builder1.Append(2);
status3 = builder1.Append(3);
status3 = builder1.Append(4);
status3 = builder1.Append(5);
status3 = builder1.Finish(&arr_test_3);
auto test_arr = make_point(arr_ptr1, arr_ptr2);
auto string_arr = static_pointer_cast<arrow::StringArray>(test_arr);
auto string_test = gis::gis_func(arr_test_2, arr_test_3);
auto string_arr2 = static_pointer_cast<arrow::StringArray>(string_test);
for (int j = 0; j < string_arr2->length(); ++j) {
cout << string_arr2->GetString(j) << endl;
}
for (int i = 0; i < string_arr->length(); ++i) {
cout << string_arr->GetString(i) << endl;
}
return 0;
} | [
"[email protected]"
] | |
991c47318499867c0c597fcbe9007137685b0606 | c2d270aff0a4d939f43b6359ac2c564b2565be76 | /src/chrome/browser/chromeos/accessibility/accessibility_util.cc | 6b368f9fbe3c257c3891e7005977f4c8828c4d0f | [
"BSD-3-Clause"
] | permissive | bopopescu/QuicDep | dfa5c2b6aa29eb6f52b12486ff7f3757c808808d | bc86b705a6cf02d2eade4f3ea8cf5fe73ef52aa0 | refs/heads/master | 2022-04-26T04:36:55.675836 | 2020-04-29T21:29:26 | 2020-04-29T21:29:26 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,369 | cc | // Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/chromeos/accessibility/accessibility_util.h"
#include "ash/public/cpp/ash_pref_names.h"
#include "chrome/browser/browser_process.h"
#include "chrome/browser/ui/singleton_tabs.h"
#include "chrome/common/url_constants.h"
#include "components/prefs/pref_service.h"
#include "url/gurl.h"
// TODO(yoshiki): move the following method to accessibility_manager.cc and
// remove this file.
namespace chromeos {
namespace accessibility {
void EnableVirtualKeyboard(bool enabled) {
PrefService* pref_service = g_browser_process->local_state();
pref_service->SetBoolean(ash::prefs::kAccessibilityVirtualKeyboardEnabled,
enabled);
pref_service->CommitPendingWrite();
}
bool IsVirtualKeyboardEnabled() {
if (!g_browser_process) {
return false;
}
PrefService* prefs = g_browser_process->local_state();
bool virtual_keyboard_enabled =
prefs &&
prefs->GetBoolean(ash::prefs::kAccessibilityVirtualKeyboardEnabled);
return virtual_keyboard_enabled;
}
void ShowAccessibilityHelp(Browser* browser) {
ShowSingletonTab(browser, GURL(chrome::kChromeAccessibilityHelpURL));
}
} // namespace accessibility
} // namespace chromeos
| [
"[email protected]"
] | |
eb1e4413af451973354992c2f088857393efae1d | 773820425b1fc6db630031e74dd8f55265d9f932 | /securitysdkcore/src/main/cpp/getSign.h | be3d89e03365a8d7e9c5db83e0c5f27b22998a84 | [] | no_license | KingSun0/SecuritySDK | 365e7c56660375fe3825e4f170461d9e42602b2b | c558515849e9d506382cb18643afe3736225d2d2 | refs/heads/master | 2022-03-13T10:50:40.699972 | 2017-12-27T13:06:34 | 2017-12-27T13:06:34 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 547 | h | //
// Created by ffthy on 21/11/2017.
//
#include <stdio.h>
#include <stdlib.h>
#include <jni.h>
#include <android/log.h>
#include <string.h>
#include <sys/ptrace.h>
#include <unistd.h>
#include <sys/types.h>
#include <vector>
#include <string>
#include <fstream>
#include <iostream>
#include "Util.h"
#include <jni.h>
#ifndef SECURITYSDK_GETSIGN_H
#define SECURITYSDK_GETSIGN_H
extern "C"
char* getAppSignSha1(JNIEnv *env, jobject context_object);
extern "C"
jboolean checkValidity(JNIEnv *env, char *Appsha1);
#endif //SECURITYSDK_GETSIGN_H
| [
"[email protected]"
] | |
0ed0cdf3d1e1d91f7aaec059ee0f7566bc9ff48e | 0995c448ad10f024371a99c5a5b872919b586a48 | /Kattis/armystrengtheasyv2.cpp | 4c3ceee83c47f8165a35893662d2decb5bd4c8af | [] | no_license | ChrisMaxheart/Competitive-Programming | fe9ebb079f30f34086ec97efdda2967c5e7c7fe0 | 2c749a3bc87a494da198f2f81f975034a8296f32 | refs/heads/master | 2021-06-14T13:48:39.671292 | 2021-03-27T10:34:46 | 2021-03-27T10:34:46 | 179,540,634 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 894 | cpp | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
class mycomp
{
public:
bool operator() (int a, int b) {
return a > b;
}
};
bool reversecompare(int a, int b)
{
return a > b;
}
int main ()
{
ios::sync_with_stdio(false);
cin.tie(nullptr);
int T;
cin >> T;
while(T--) {
int G, MG;
cin >> G >> MG;
priority_queue<int> Gzilla;
priority_queue<int> MGzilla;
int x;
while(G--) {
cin >> x;
Gzilla.push(x);
}
while (MG--) {
cin >> x;
MGzilla.push(x);
}
// while(Gzilla.size() > 0) {
// cout << Gzilla.top() << endl;
// Gzilla.pop();
// }
int gbest = Gzilla.top();
int mbest = MGzilla.top();
if (gbest < mbest) {
cout << "MechaGodzilla" << endl;
} else {
cout << "Godzilla" << endl;
}
}
return 0;
} | [
"[email protected]"
] | |
6d207de646f32aba61efac6677ab3076bbd3b18a | 12fedd8bfa634d8d0ea01b1e09d1fc00200e5c34 | /Exercise_4.1/Source.cpp | 292dc2d98cb6cbb277882884b33528f9c766a0bd | [] | no_license | shuspieler/CPP-Primer-5th-Exercises | d09b5836be0015fa56eafc9a2dc6c237f3bc30bd | c257ccc21e75b6a016fa2608eacf8b1987c0bac5 | refs/heads/master | 2023-02-23T22:07:19.259133 | 2021-01-24T20:17:52 | 2021-01-24T20:17:52 | 265,661,669 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 89 | cpp | #include<iostream>
int main()
{
std::cout << 5 + 10 * 20 / 2 << std::endl;
return 0;
} | [
"[email protected]"
] | |
08e2051738c1552778b632ff9554b6826319710e | 90592e2cca069daf93afa2667aa77478ee0f27f1 | /build-Calculator-Desktop_Qt_5_4_1_MSVC2013_64bit-Release/release/moc_graphformula.cpp | c8667d44b35f70d0b3899b40e463c416e76ba578 | [] | no_license | MohamedShanaz/xforcerepo | 994e079e68bd7d7e7c67008e65b345ca9ed6af9f | c80bebf8e0113c6ecd20ae7c47e68ecba9c392e4 | refs/heads/master | 2020-05-20T11:30:35.479944 | 2015-07-26T15:18:21 | 2015-07-26T15:18:21 | 37,648,660 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,752 | cpp | /****************************************************************************
** Meta object code from reading C++ file 'graphformula.h'
**
** Created by: The Qt Meta Object Compiler version 67 (Qt 5.4.1)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
#include "../../Calculator/graphformula.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'graphformula.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.4.1. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif
QT_BEGIN_MOC_NAMESPACE
struct qt_meta_stringdata_GraphFormula_t {
QByteArrayData data[1];
char stringdata[13];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
qptrdiff(offsetof(qt_meta_stringdata_GraphFormula_t, stringdata) + ofs \
- idx * sizeof(QByteArrayData)) \
)
static const qt_meta_stringdata_GraphFormula_t qt_meta_stringdata_GraphFormula = {
{
QT_MOC_LITERAL(0, 0, 12) // "GraphFormula"
},
"GraphFormula"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_GraphFormula[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
0, 0, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
0, // signalCount
0 // eod
};
void GraphFormula::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
Q_UNUSED(_o);
Q_UNUSED(_id);
Q_UNUSED(_c);
Q_UNUSED(_a);
}
const QMetaObject GraphFormula::staticMetaObject = {
{ &QDialog::staticMetaObject, qt_meta_stringdata_GraphFormula.data,
qt_meta_data_GraphFormula, qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};
const QMetaObject *GraphFormula::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *GraphFormula::qt_metacast(const char *_clname)
{
if (!_clname) return Q_NULLPTR;
if (!strcmp(_clname, qt_meta_stringdata_GraphFormula.stringdata))
return static_cast<void*>(const_cast< GraphFormula*>(this));
return QDialog::qt_metacast(_clname);
}
int GraphFormula::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QDialog::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
return _id;
}
QT_END_MOC_NAMESPACE
| [
"[email protected]"
] | |
246390a759a03a582548de61be475225f3af1cf5 | 681d04f17b5f7eeec45d6480426536448bd8fb84 | /src/protocol.h | 4e1d2cc268e1f3f35cb792b5f18c6437d7bba6f9 | [
"MIT"
] | permissive | btc10000/jinver-coin | a20340e83c7176998d0d69277eb82a846afe7cc1 | a325e99e9467d78fbeccdc3cea60ae41d7b78f52 | refs/heads/master | 2021-01-24T09:50:03.849787 | 2016-10-06T06:31:19 | 2016-10-06T06:31:19 | 70,128,563 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,410 | h | // Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2012 The Bitcoin developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef __cplusplus
# error This header can only be compiled as C++.
#endif
#ifndef __INCLUDED_PROTOCOL_H__
#define __INCLUDED_PROTOCOL_H__
#include "serialize.h"
#include "netbase.h"
#include <string>
#include "uint256.h"
extern bool fTestNet;
static inline unsigned short GetDefaultPort(const bool testnet = fTestNet)
{
return testnet ? 24452 : 20098;//return testnet ? 30801 : 20801;
}
extern unsigned char pchMessageStart[4];
/** Message header.
* (4) message start.
* (12) command.
* (4) size.
* (4) checksum.
*/
class CMessageHeader
{
public:
CMessageHeader();
CMessageHeader(const char* pszCommand, unsigned int nMessageSizeIn);
std::string GetCommand() const;
bool IsValid() const;
IMPLEMENT_SERIALIZE
(
READWRITE(FLATDATA(pchMessageStart));
READWRITE(FLATDATA(pchCommand));
READWRITE(nMessageSize);
READWRITE(nChecksum);
)
// TODO: make private (improves encapsulation)
public:
enum {
MESSAGE_START_SIZE=sizeof(::pchMessageStart),
COMMAND_SIZE=12,
MESSAGE_SIZE_SIZE=sizeof(int),
CHECKSUM_SIZE=sizeof(int),
MESSAGE_SIZE_OFFSET=MESSAGE_START_SIZE+COMMAND_SIZE,
CHECKSUM_OFFSET=MESSAGE_SIZE_OFFSET+MESSAGE_SIZE_SIZE
};
char pchMessageStart[MESSAGE_START_SIZE];
char pchCommand[COMMAND_SIZE];
unsigned int nMessageSize;
unsigned int nChecksum;
};
/** nServices flags */
enum
{
NODE_NETWORK = (1 << 0),
};
/** A CService with information about it as peer */
class CAddress : public CService
{
public:
CAddress();
explicit CAddress(CService ipIn, uint64 nServicesIn=NODE_NETWORK);
void Init();
IMPLEMENT_SERIALIZE
(
CAddress* pthis = const_cast<CAddress*>(this);
CService* pip = (CService*)pthis;
if (fRead)
pthis->Init();
if (nType & SER_DISK)
READWRITE(nVersion);
if ((nType & SER_DISK) ||
(nVersion >= CADDR_TIME_VERSION && !(nType & SER_GETHASH)))
READWRITE(nTime);
READWRITE(nServices);
READWRITE(*pip);
)
void print() const;
// TODO: make private (improves encapsulation)
public:
uint64 nServices;
// disk and network only
unsigned int nTime;
// memory only
int64 nLastTry;
};
/** inv message data */
class CInv
{
public:
CInv();
CInv(int typeIn, const uint256& hashIn);
CInv(const std::string& strType, const uint256& hashIn);
IMPLEMENT_SERIALIZE
(
READWRITE(type);
READWRITE(hash);
)
friend bool operator<(const CInv& a, const CInv& b);
bool IsKnownType() const;
const char* GetCommand() const;
std::string ToString() const;
void print() const;
// TODO: make private (improves encapsulation)
public:
int type;
uint256 hash;
};
#endif // __INCLUDED_PROTOCOL_H__
| [
"[email protected]"
] | |
af656e967f35798051e4cd42d6e5009121aaf0f4 | af3f1e4863344b3c63ca46f6d300559f4730776e | /main.cpp | 942ce13a47528602c0127130de05f05a9a75ac96 | [
"MIT"
] | permissive | anpefi/tumopp | 7c2e88ce6642fcb7ee26253a2e8fc58794ec4a2a | 7a4f12c0f3126343653358fc9662314c80553737 | refs/heads/master | 2021-01-20T00:56:08.096897 | 2017-04-16T14:48:52 | 2017-04-16T14:48:52 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 428 | cpp | // -*- mode: c++; coding: utf-8 -*-
/*! @file main.cpp
@brief Only defines tiny main()
*/
#include "src/simulation.hpp"
//! Just instantiate and run Simulation
int main(int argc, char* argv[]) {
std::vector<std::string> arguments(argv + 1, argv + argc);
try {
tumopp::Simulation simulation(arguments);
simulation.run();
simulation.write();
} catch (wtl::ExitSuccess) {}
return 0;
}
| [
"[email protected]"
] | |
392697682026cbd9d4ef75513089c191e55fd7cc | ceb2b46d7ab1c591e4d277c8c849e4b8f7b20a36 | /src/APA102.hpp | 20f8e54861966c10d09cc6c2fce750f7bc9b9cc7 | [] | no_license | EricMiddleton1/LightNode-TV | 0f8c336dfe04695f93c71139a1876b47543ef352 | 26ed48d4c8257af11c06596d86fff3a4ef324267 | refs/heads/master | 2020-04-06T03:58:09.245189 | 2017-02-25T00:06:40 | 2017-02-25T00:06:40 | 83,093,371 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 320 | hpp | #pragma once
#include <vector>
#include <cstdint>
#include "LightNode/Color.hpp"
class APA102
{
public:
APA102();
~APA102();
void display(const std::vector<Color>& colors);
private:
static constexpr double GAMMA = 2.3;
std::vector<char> colorToFrame(const Color& c) const;
std::vector<double> gammaTable;
};
| [
"[email protected]"
] | |
4cf3dbfd387c2eb7e08acea7899375f35136b600 | 4bcc9806152542ab43fc2cf47c499424f200896c | /tensorflow/core/kernels/data/finalize_dataset_op.h | 4b2ef22b2b621cb7159bb375e0486a24ed16ee32 | [
"Apache-2.0",
"LicenseRef-scancode-generic-cla",
"BSD-2-Clause"
] | permissive | tensorflow/tensorflow | 906276dbafcc70a941026aa5dc50425ef71ee282 | a7f3934a67900720af3d3b15389551483bee50b8 | refs/heads/master | 2023-08-25T04:24:41.611870 | 2023-08-25T04:06:24 | 2023-08-25T04:14:08 | 45,717,250 | 208,740 | 109,943 | Apache-2.0 | 2023-09-14T20:55:50 | 2015-11-07T01:19:20 | C++ | UTF-8 | C++ | false | false | 2,158 | h | /* Copyright 2021 The TensorFlow Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
#ifndef TENSORFLOW_CORE_KERNELS_DATA_FINALIZE_DATASET_OP_H_
#define TENSORFLOW_CORE_KERNELS_DATA_FINALIZE_DATASET_OP_H_
#include "tensorflow/core/framework/dataset.h"
#include "tensorflow/core/framework/op_kernel.h"
namespace tensorflow {
namespace data {
class FinalizeDatasetOp : public UnaryDatasetOpKernel {
public:
static constexpr const char* const kDatasetType = "Finalize";
static constexpr const char* const kInputDataset = "input_dataset";
static constexpr const char* const kOutputTypes = "output_types";
static constexpr const char* const kOutputShapes = "output_shapes";
static constexpr const char* const kHasCapturedRef = "has_captured_ref";
explicit FinalizeDatasetOp(OpKernelConstruction* ctx);
void MakeDataset(OpKernelContext* ctx, DatasetBase* input,
DatasetBase** output) override;
private:
class Dataset;
bool has_captured_ref_;
};
class FinalizeDatasetNoopOp : public UnaryDatasetOpKernel {
public:
explicit FinalizeDatasetNoopOp(OpKernelConstruction* ctx)
: UnaryDatasetOpKernel(ctx) {}
protected:
void MakeDataset(OpKernelContext* ctx, DatasetBase* input,
DatasetBase** output) override {
LOG(WARNING) << "FinalizeDataset is only supported on CPU. Using it on "
"devices other than CPU has no effect.";
input->Ref();
*output = input;
}
};
} // namespace data
} // namespace tensorflow
#endif // TENSORFLOW_CORE_KERNELS_DATA_FINALIZE_DATASET_OP_H_
| [
"[email protected]"
] | |
7f897047689647821f0de6285bf6bff25a5ec18d | 1061216c2c33c1ed4ffb33e6211565575957e48f | /cpp-restsdk/model/GetMessages_allOf.h | f1efe576aa0f1c16f1673c641aba4928e1859caa | [] | no_license | MSurfer20/test2 | be9532f54839e8f58b60a8e4587348c2810ecdb9 | 13b35d72f33302fa532aea189e8f532272f1f799 | refs/heads/main | 2023-07-03T04:19:57.548080 | 2021-08-11T19:16:42 | 2021-08-11T19:16:42 | 393,920,506 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,820 | h | /**
* Zulip REST API
* Powerful open source group chat
*
* The version of the OpenAPI document: 1.0.0
*
* NOTE: This class is auto generated by OpenAPI-Generator 5.2.0.
* https://openapi-generator.tech
* Do not edit the class manually.
*/
/*
* GetMessages_allOf.h
*
*
*/
#ifndef ORG_OPENAPITOOLS_CLIENT_MODEL_GetMessages_allOf_H_
#define ORG_OPENAPITOOLS_CLIENT_MODEL_GetMessages_allOf_H_
#include "../ModelBase.h"
#include <cpprest/details/basic_types.h>
#include <vector>
#include "AnyType.h"
namespace org {
namespace openapitools {
namespace client {
namespace model {
/// <summary>
///
/// </summary>
class GetMessages_allOf
: public ModelBase
{
public:
GetMessages_allOf();
virtual ~GetMessages_allOf();
/////////////////////////////////////////////
/// ModelBase overrides
void validate() override;
web::json::value toJson() const override;
bool fromJson(const web::json::value& json) override;
void toMultipart(std::shared_ptr<MultipartFormData> multipart, const utility::string_t& namePrefix) const override;
bool fromMultiPart(std::shared_ptr<MultipartFormData> multipart, const utility::string_t& namePrefix) override;
/////////////////////////////////////////////
/// GetMessages_allOf members
/// <summary>
///
/// </summary>
std::shared_ptr<AnyType> getAvatarUrl() const;
bool avatarUrlIsSet() const;
void unsetAvatar_url();
void setAvatarUrl(const std::shared_ptr<AnyType>& value);
/// <summary>
///
/// </summary>
std::shared_ptr<AnyType> getClient() const;
bool clientIsSet() const;
void unsetClient();
void setClient(const std::shared_ptr<AnyType>& value);
/// <summary>
///
/// </summary>
std::shared_ptr<AnyType> getContent() const;
bool contentIsSet() const;
void unsetContent();
void setContent(const std::shared_ptr<AnyType>& value);
/// <summary>
///
/// </summary>
std::shared_ptr<AnyType> getContentType() const;
bool contentTypeIsSet() const;
void unsetContent_type();
void setContentType(const std::shared_ptr<AnyType>& value);
/// <summary>
///
/// </summary>
std::shared_ptr<AnyType> getDisplayRecipient() const;
bool displayRecipientIsSet() const;
void unsetDisplay_recipient();
void setDisplayRecipient(const std::shared_ptr<AnyType>& value);
/// <summary>
///
/// </summary>
std::shared_ptr<AnyType> getId() const;
bool idIsSet() const;
void unsetId();
void setId(const std::shared_ptr<AnyType>& value);
/// <summary>
///
/// </summary>
std::shared_ptr<AnyType> getIsMeMessage() const;
bool isMeMessageIsSet() const;
void unsetIs_me_message();
void setIsMeMessage(const std::shared_ptr<AnyType>& value);
/// <summary>
///
/// </summary>
std::shared_ptr<AnyType> getReactions() const;
bool reactionsIsSet() const;
void unsetReactions();
void setReactions(const std::shared_ptr<AnyType>& value);
/// <summary>
///
/// </summary>
std::shared_ptr<AnyType> getRecipientId() const;
bool recipientIdIsSet() const;
void unsetRecipient_id();
void setRecipientId(const std::shared_ptr<AnyType>& value);
/// <summary>
///
/// </summary>
std::shared_ptr<AnyType> getSenderEmail() const;
bool senderEmailIsSet() const;
void unsetSender_email();
void setSenderEmail(const std::shared_ptr<AnyType>& value);
/// <summary>
///
/// </summary>
std::shared_ptr<AnyType> getSenderFullName() const;
bool senderFullNameIsSet() const;
void unsetSender_full_name();
void setSenderFullName(const std::shared_ptr<AnyType>& value);
/// <summary>
///
/// </summary>
std::shared_ptr<AnyType> getSenderId() const;
bool senderIdIsSet() const;
void unsetSender_id();
void setSenderId(const std::shared_ptr<AnyType>& value);
/// <summary>
///
/// </summary>
std::shared_ptr<AnyType> getSenderRealmStr() const;
bool senderRealmStrIsSet() const;
void unsetSender_realm_str();
void setSenderRealmStr(const std::shared_ptr<AnyType>& value);
/// <summary>
///
/// </summary>
std::shared_ptr<AnyType> getStreamId() const;
bool streamIdIsSet() const;
void unsetStream_id();
void setStreamId(const std::shared_ptr<AnyType>& value);
/// <summary>
///
/// </summary>
std::shared_ptr<AnyType> getSubject() const;
bool subjectIsSet() const;
void unsetSubject();
void setSubject(const std::shared_ptr<AnyType>& value);
/// <summary>
///
/// </summary>
std::shared_ptr<AnyType> getTopicLinks() const;
bool topicLinksIsSet() const;
void unsetTopic_links();
void setTopicLinks(const std::shared_ptr<AnyType>& value);
/// <summary>
///
/// </summary>
std::shared_ptr<AnyType> getSubmessages() const;
bool submessagesIsSet() const;
void unsetSubmessages();
void setSubmessages(const std::shared_ptr<AnyType>& value);
/// <summary>
///
/// </summary>
std::shared_ptr<AnyType> getTimestamp() const;
bool timestampIsSet() const;
void unsetTimestamp();
void setTimestamp(const std::shared_ptr<AnyType>& value);
/// <summary>
///
/// </summary>
std::shared_ptr<AnyType> getType() const;
bool typeIsSet() const;
void unsetType();
void setType(const std::shared_ptr<AnyType>& value);
/// <summary>
/// The user's [message flags][message-flags] for the message. [message-flags]: /api/update-message-flags#available-flags
/// </summary>
std::vector<utility::string_t>& getFlags();
bool flagsIsSet() const;
void unsetFlags();
void setFlags(const std::vector<utility::string_t>& value);
/// <summary>
/// The UNIX timestamp for when the message was last edited, in UTC seconds.
/// </summary>
int32_t getLastEditTimestamp() const;
bool lastEditTimestampIsSet() const;
void unsetLast_edit_timestamp();
void setLastEditTimestamp(int32_t value);
/// <summary>
/// Only present if keyword search was included among the narrow parameters. HTML content of a queried message that matches the narrow, with `<span class=\"highlight\">` elements wrapping the matches for the search keywords.
/// </summary>
utility::string_t getMatchContent() const;
bool matchContentIsSet() const;
void unsetMatch_content();
void setMatchContent(const utility::string_t& value);
/// <summary>
/// Only present if keyword search was included among the narrow parameters. HTML-escaped topic of a queried message that matches the narrow, with `<span class=\"highlight\">` elements wrapping the matches for the search keywords.
/// </summary>
utility::string_t getMatchSubject() const;
bool matchSubjectIsSet() const;
void unsetMatch_subject();
void setMatchSubject(const utility::string_t& value);
protected:
std::shared_ptr<AnyType> m_Avatar_url;
bool m_Avatar_urlIsSet;
std::shared_ptr<AnyType> m_Client;
bool m_ClientIsSet;
std::shared_ptr<AnyType> m_Content;
bool m_ContentIsSet;
std::shared_ptr<AnyType> m_Content_type;
bool m_Content_typeIsSet;
std::shared_ptr<AnyType> m_Display_recipient;
bool m_Display_recipientIsSet;
std::shared_ptr<AnyType> m_Id;
bool m_IdIsSet;
std::shared_ptr<AnyType> m_Is_me_message;
bool m_Is_me_messageIsSet;
std::shared_ptr<AnyType> m_Reactions;
bool m_ReactionsIsSet;
std::shared_ptr<AnyType> m_Recipient_id;
bool m_Recipient_idIsSet;
std::shared_ptr<AnyType> m_Sender_email;
bool m_Sender_emailIsSet;
std::shared_ptr<AnyType> m_Sender_full_name;
bool m_Sender_full_nameIsSet;
std::shared_ptr<AnyType> m_Sender_id;
bool m_Sender_idIsSet;
std::shared_ptr<AnyType> m_Sender_realm_str;
bool m_Sender_realm_strIsSet;
std::shared_ptr<AnyType> m_Stream_id;
bool m_Stream_idIsSet;
std::shared_ptr<AnyType> m_Subject;
bool m_SubjectIsSet;
std::shared_ptr<AnyType> m_Topic_links;
bool m_Topic_linksIsSet;
std::shared_ptr<AnyType> m_Submessages;
bool m_SubmessagesIsSet;
std::shared_ptr<AnyType> m_Timestamp;
bool m_TimestampIsSet;
std::shared_ptr<AnyType> m_Type;
bool m_TypeIsSet;
std::vector<utility::string_t> m_Flags;
bool m_FlagsIsSet;
int32_t m_Last_edit_timestamp;
bool m_Last_edit_timestampIsSet;
utility::string_t m_Match_content;
bool m_Match_contentIsSet;
utility::string_t m_Match_subject;
bool m_Match_subjectIsSet;
};
}
}
}
}
#endif /* ORG_OPENAPITOOLS_CLIENT_MODEL_GetMessages_allOf_H_ */
| [
"[email protected]"
] | |
5b7281473376b3ca2912ad1ee3ecde0932c455d7 | 6d6c99768d208656935e4627cacfb872ba241fe2 | /015-Smart Enviornment Monitoring system Integrated with cloud platform/Smart_Environment_Monitoring_System/Smart_Environment_Monitoring_System.ino | d8acfbdb289441973eba8a83088408d761e48440 | [] | no_license | srikanthkatakam/IOT | f5ab398eed6e32c3f15b24f0d1df4cbae945d708 | 16ec67b08f75da7c90ca4ccda321db6459905df6 | refs/heads/master | 2023-06-25T06:08:42.805771 | 2021-07-28T02:25:47 | 2021-07-28T02:25:47 | 389,020,836 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,656 | ino | /*
Arduino --> ThingSpeak Channel via Ethernet
The ThingSpeak Client sketch is designed for the Arduino and Ethernet.
This sketch updates a channel feed with an analog input reading via the
ThingSpeak API (https://thingspeak.com/docs)
using HTTP POST. The Arduino uses DHCP and DNS for a simpler network setup.
The sketch also includes a Watchdog / Reset function to make sure the
Arduino stays connected and/or regains connectivity after a network outage.
Use the Serial Monitor on the Arduino IDE to see verbose network feedback
and ThingSpeak connectivity status.
Getting Started with ThingSpeak:
* Sign Up for New User Account - https://thingspeak.com/users/new
* Create a new Channel by selecting Channels and then Create New Channel
* Enter the Write API Key in this sketch under "ThingSpeak Settings"
Arduino Requirements:
* Arduino with Ethernet Shield or Arduino Ethernet
* Arduino 1.0+ IDE
Network Requirements:
* Ethernet port on Router
* DHCP enabled on Router
* Unique MAC Address for Arduino
*/
#include <SPI.h>
#include <Ethernet.h>
#include "DHT.h"
#define DHTPIN 2 // what pin we're connected to
#define DHTTYPE DHT11 // define type of sensor DHT 11
DHT dht (DHTPIN, DHTTYPE);
int v;
int Sound;
// Local Network Settings
byte mac[] = { 0xD4, 0x28, 0xB2, 0xFF, 0xA0, 0xA1 }; // Must be unique on local network
// ThingSpeak Settings
char thingSpeakAddress[] = "api.thingspeak.com";
String writeAPIKey = "thingspeak write API";
const int updateThingSpeakInterval = 16 * 1000; // Time interval in milliseconds to update ThingSpeak (number of seconds * 1000 = interval)
// Variable Setup
long lastConnectionTime = 0;
boolean lastConnected = false;
int failedCounter = 0;
EthernetClient client; // Initialize Arduino Ethernet Client
IPAddress ip(192,168,0,190);
IPAddress gateway(192,168,0,1);
IPAddress subnet(255, 255, 255, 0);
void setup()
{
Serial.begin(9600); // Start Serial for debugging on the Serial Monitor
startEthernet(); // Start Ethernet on Arduino
Ethernet.begin(mac, ip, gateway, subnet);
dht.begin();
}
void loop()
{
//------------------------------------------------------------------------
// Read value of Humidity Sensor from Digital Pin 2
delay(2000);
String h = String (dht.readHumidity(), DEC);
String t = String (dht.readTemperature(), DEC);
/*if (isnan(h) || isnan(t))
{
Serial.println("Failed to read from DHT sensor!");
return;
}
Serial.print("Humidity: ");
Serial.print(h);
Serial.print(" %\t");
Serial.print("Temperature: ");
Serial.print(t);
Serial.println(" *C ");*/
//--------------------------------------------------------------------------
// Read Value of MQ-135 from Analog Input Pin A0
String MQ135 = String (analogRead(A0), DEC);
//Serial.println(" MQ135 Value: ");
//Serial.println(MQ135);
//--------------------------------------------------------------------------
// Read Value of MQ-7 from Analog Input Pin A1
String CO = String (analogRead(A1), DEC);
//Serial.println(" MQ7 Value: ");
Serial.println(CO);
//-----------------------------------------------------------------------------
// Read Value of Sound Sensor from Analog Input Pin A3
int v = analogRead(A3); // Reads the value from the Analog PIN A3
Sound= map(v,0,1023,50,140);
Serial.println(Sound);
// Print Update Response to Serial Monitor
if (client.available())
{
char c = client.read();
client.stop();
Serial.print(c);
}
// Disconnect from ThingSpeak
if (!client.connected() && lastConnected)
{
Serial.println("...disconnected");
Serial.println();
client.stop();
}
// Update ThingSpeak
if(!client.connected() && (millis() - lastConnectionTime > updateThingSpeakInterval))
{
updateThingSpeak("field1="+h+"&field2="+t+"&field3="+MQ135+"&field4="+CO+"&field5="+String (Sound));
}
// Check if Arduino Ethernet needs to be restarted
if (failedCounter > 3 ) {startEthernet();}
lastConnected = client.connected();
}
void updateThingSpeak(String tsData)
{
if (client.connect(thingSpeakAddress, 80))
{
client.print("POST /update HTTP/1.1\n");
client.print("Host: api.thingspeak.com\n");
client.print("Connection: close\n");
client.print("X-THINGSPEAKAPIKEY: "+writeAPIKey+"\n");
client.print("Content-Type: application/x-www-form-urlencoded\n");
client.print("Content-Length: ");
client.print(tsData.length());
client.print("\n\n");
client.print(tsData);
EthernetServer server(80);
lastConnectionTime = millis();
if (client.connected())
{
Serial.println("Connecting to ThingSpeak...");
Serial.println();
failedCounter = 0;
}
else
{
failedCounter++;
Serial.println("Connection to ThingSpeak failed ("+String(failedCounter, DEC)+")");
Serial.println();
}
}
else
{
failedCounter++;
Serial.println("Connection to ThingSpeak Failed ("+String(failedCounter, DEC)+")");
Serial.println();
lastConnectionTime = millis();
}
}
void startEthernet()
{
client.stop();
Serial.println("Connecting Arduino to network...");
Serial.println();
delay(1000);
// Connect to network amd obtain an IP address using DHCP
if (Ethernet.begin(mac) == 0)
{
Serial.println("DHCP Failed, reset Arduino to try again");
Serial.println();
}
else
{
Serial.println("Arduino connected to network using DHCP");
Serial.println(Ethernet.localIP());
Serial.println();
}
delay(1000);
}
| [
"[email protected]"
] | |
fa206049d9d221844c66ad1ee1c67959d7f9d090 | 390b8f9360eb827f90b731b0c4d8035ef86338a9 | /include/BinoCamera.h | 7e68266d16d12ef1999b82ddd134c91a6d5630bd | [] | no_license | Bino3D/Bino_Stereo_ROS | 557509ff119a885e26358d2f655ebd9c7fb3dcd8 | 749de12b7bca5b792d6853a35b15a71482f8d78b | refs/heads/master | 2021-09-14T18:18:14.458296 | 2018-05-17T03:44:25 | 2018-05-17T03:44:25 | 110,199,534 | 8 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 5,195 | h | /*
* StereoCamera.h
*
* Created on: 2017年11月6日
* Author: clover
*/
#ifndef SDKLINK_SDKSRC_BINOCAMERA_H_
#define SDKLINK_SDKSRC_BINOCAMERA_H_
#include <iostream>
#include <opencv2/opencv.hpp>
#include <functional>
#include <thread>
#include <mutex>
/**
*@brief 相机参数表述结构体
*其中包含相
* */
struct BinoCameraParameterList{
std::string devPath = "/dev/video0"; /**< 设备节点地址 */
std::string extParameterPath = ""; /**< 相机标定外参文件所在地址*/
std::string intParameterPath = ""; /**< 相机标定内参文件所在地址*/
std::string fisheyeParameterPath = ""; /**< 相机标定内参文件所在地址*/
};
/**
*@brief 测距参数表述结构体
*
* */
typedef struct winpar{
cv::Point3d size; /**< 测距窗口的长度，宽度，最远探测距离(size.x, size.y, size.z) */
double pitch; /**< camera与水平面偏移角度 */
}WindowsParams;
typedef struct nerapot{
cv::Point3d point;
double range;
double angle;
}NearestPoints;
typedef struct classfic{
cv::Point3d range_min;
int num_point;
}ClassIfication;
/**
*@brief imu数据结构体
* */
struct ImuData{
uint32_t time;/**< 采集imu数据的时间*/
float accel_x; /**< imu加速度计x轴数据，单位（g）*/
float accel_y; /**< imu加速度计y轴数据，单位（g）*/
float accel_z; /**< imu加速度计z轴数据，单位（g）*/
float gyro_x; /**< imu陀螺仪x轴数据，单位（弧度/秒）*/
float gyro_y; /**< imu陀螺仪y轴数据，单位（弧度/秒）*/
float gyro_z; /**< imu陀螺仪z轴数据，单位（弧度/秒）*/
};
/**
*@brief BinoCamera 类头文件
*
* */
class BinoCamera {
public:
/**
*@brief BinoCamera 构造函数
*@param paraList 传入的相机启动参数
* */
BinoCamera(BinoCameraParameterList paraList);
virtual ~BinoCamera();
/**
*@brief 抓取一次相机数据，需要在主循环中调用
* */
void Grab();
/**
*@brief 得到双目原始图像
*@param L 返回左相机图像
*@param R 返回右相机图像
* */
void getOrgImage(cv::Mat& L, cv::Mat& R);
/**
@brief 得到双目畸变矫正后图像
@param L 返回左相机矫正后图像
@param R 返回右相机矫正后图像
* */
void getRectImage(cv::Mat& L, cv::Mat& R);
/**
@brief 得到双目鱼眼畸变矫正后图像
@param L 返回左相机矫正后图像
@param R 返回右相机矫正后图像
* */
void getRectFisheyeImage(cv::Mat& L, cv::Mat& R);
/**
@brief 得到得到视差图
@param disparateU16Mat 返回uint16类型的视差图，想得到真实视差值需要转换为float型数据，转换例子：
matU16.convertTo( matF32, CV_32F, 1.0/16);
* */
void getDisparity(cv::Mat& disparateU16Mat);
/**
@brief 获取相机参数
@param para 返回Mat数据的类型为CV_64FC1，row = 1, col = 7，数据内容为：
fx,fy,cx,cy,image_wideth,image_height,bf
* */
bool getCameraParameter(cv::Mat& para);
/**
@brief imu原始数据校正
@param deadmin 死区最小值
@param deadmax 死区最大值
@param axerr 加速度计x轴零偏校正
@param ayerr 加速度计y轴零偏校正
@param azerr 加速度计z轴零偏校正
* */
void setImuCorrection(float deadmin,float deadmax,float axerr,float ayerr,float azerr);
/**
@brief 得到imu原始数据
@param imudatas imu的原始数据
@param timestamp 图像帧曝光时刻的时间
* */
void getImuRawData(std::vector<ImuData> &imuDatas, uint32_t ×tamp);
/**
@brief 得到图像帧曝光时刻的时间
* */
uint32_t getImgTime();
/**
@brief imu解算程序
@param imu imu原始数据
@param timestamp 两次imu数据采集之间的时间戳
@param q 四元数
* */
void ImuRect(ImuData imu,float timestamp,float *q);
/**
@brief 得到距离camera最近的点
@param params 距离测量的相关参数
@param points 视窗内所有点的集合
@param nearpoint 距离camera最近的点的实际坐标(单位：m)
* */
void getNearestPoint(WindowsParams& params, NearestPoints* points, cv::Point3d& nearpoint);
/**
@brief 距离检测功能可视化
@param params 距离测量的相关参数
@param nearpoint 距离camera最近的点的实际坐标(单位：m)
@param PointImage 返回可视化距离检测图像
* */
void getPointImage(NearestPoints* points, cv::Point3d nearpoint, cv::Mat& PointImage);
/**
@brief 双目标定
@param imagelist 存储标定使用图像名称的容器
@param boardSize 使用的棋盘格的规格，写入格式为: boardSize = Size((一行棋盘格的个数 - 1), (一列棋盘格的个数 - 1));
@param squareSize 使用的棋盘格每个格子的大小(单位: m)
* */
void StartStereoCalib(const std::vector<std::string>& imagelist, cv::Size boardSize, const float squareSize);
private:
cv::Mat LeftImg, RightImg, LeftRect, RightRect, DispImg;
int cnt;
ClassIfication object[360];
std::vector<ImuData> ImuDatas;
uint32_t TimeStamp;
};
#endif /* SDKLINK_SDKSRC_BINOCAMERA_H_ */
| [
"[email protected]"
] | |
b04de260089904b2c981ab8ea377fbcc6e2fab33 | 9f7bc8df3f30f2ec31581d6d2eca06e332aa15b4 | /c++/min_max_fix.h | 326616ffe3deb140932299c64167fee6afa3a819 | [
"MIT"
] | permissive | moodboom/Reusable | 58f518b5b81facb862bbb36015aaa00adc710e0e | 5e0a4a85834533cf3ec5bec52cd6c5b0d60df8e8 | refs/heads/master | 2023-08-22T20:06:18.210680 | 2023-08-05T20:08:36 | 2023-08-05T20:08:36 | 50,254,274 | 3 | 3 | MIT | 2023-07-12T17:29:42 | 2016-01-23T19:23:01 | C++ | UTF-8 | C++ | false | false | 2,158 | h | #ifndef MIN_MAX_FIX_H
#define MIN_MAX_FIX_H
//--------------------------------------------------------------------//
// min/max have been problematic in the past, as there are multiple
// definitions in MS and STL headers. This section fixes things up
// for VC 6 and VC 7 and beyond. From here on out, ALWAYS USE THESE
// for min/max:
//
// std::min( 1, 2 )
// std::max( 1, 2 )
//
// Got help on this from here:
//
// http://groups.google.com/groups?hl=en&lr=&ie=UTF-8&safe=active&threadm=3C5024EB.5CC4D8BC%40yahoo.co.uk&rnum=1&prev=/groups%3Fq%3Dafxtempl.h%2Bmin%26hl%3Den%26lr%3D%26ie%3DUTF-8%26safe%3Dactive%26as_qdr%3Dall%26selm%3D3C5024EB.5CC4D8BC%2540yahoo.co.uk%26rnum%3D1
//
//-------------------------------------------------------------------//
#ifdef WIN32
#if _MFC_VER < 0x0700
// Bypass the non-standard version in Microsoft SDK\include\WinDef.h...
#ifndef NOMINMAX
#define NOMINMAX
#endif
#ifdef max
#undef max
#undef min
#endif
#pragma warning(disable : 4786) // Silence annoying STL long-names whining from MS Compiler
// VS 6 does not have std::min/max because it collided with
// some internal MS macro. Here, we define it, but only
// inside the std namespace. Then, using std::min/max()
// works fine...
#include <algorithm>
#define max(a,b) (((a) > (b)) ? (a) : (b))
#define min(a,b) (((a) < (b)) ? (a) : (b))
/*
using std::_cpp_max;
using std::_cpp_min;
namespace std
{
#define max _cpp_max
#define min _cpp_min
}
*/
#else
#define NOMINMAX
// VS 7 and above properly define std::min/max(), but
// there is apparently still legacy code that does not
// include the std:: qualifier. This helps that code
// compile. Use std::min/max() in new code, for compatibility.
#include <algorithm>
using std::min;
using std::max;
// Other stuff we've needed. Not working under VS 7?
// using std::acos;
#endif
#else
#include <algorithm>
using std::min;
using std::max;
#endif
//-------------------------------------------------------------------//
#endif // #define MIN_MAX_FIX_H
| [
"[email protected]"
] | |
8ff207fa9b6a667b1b220442d895061d8e234842 | 06bed8ad5fd60e5bba6297e9870a264bfa91a71d | /libPr3/abstractlight.h | db62a058c9640a02caedcbbcdd0ab29770dae838 | [] | no_license | allenck/DecoderPro_app | 43aeb9561fe3fe9753684f7d6d76146097d78e88 | 226c7f245aeb6951528d970f773776d50ae2c1dc | refs/heads/master | 2023-05-12T07:36:18.153909 | 2023-05-10T21:17:40 | 2023-05-10T21:17:40 | 61,044,197 | 4 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 3,068 | h | #ifndef ABSTRACTLIGHT_H
#define ABSTRACTLIGHT_H
#include <QList>
#include "light.h"
#include "abstractnamedbean.h"
#include "lightcontrol.h"
#include "libPr3_global.h"
class LIBPR3SHARED_EXPORT AbstractLight : /*public AbstractNamedBean,*/ public Light, public PropertyChangeListener
{
Q_OBJECT
Q_INTERFACES(PropertyChangeListener)
public:
//explicit AbstractLight(QObject *parent = 0);
/*public*/ AbstractLight(QString systemName, QString userName, QObject *parent = 0);
/*public*/ AbstractLight(QString systemName, QObject *parent = 0);
/*public*/ bool getEnabled()override;
/*public*/ void setEnabled(bool v) override;
/*public*/ bool isIntensityVariable() override;
/*public*/ void setTargetIntensity(double intensity) override;
/*public*/ double getCurrentIntensity() override;
/*public*/ double getTargetIntensity() override;
/*public*/ void setMaxIntensity(double intensity) override;
/*public*/ double getMaxIntensity() override;
/*public*/ void setMinIntensity(double intensity) override;
/*public*/ double getMinIntensity() override;
/*public*/ bool isTransitionAvailable() override;
/*public*/ void setTransitionTime(double minutes) override;
/*public*/ double getTransitionTime() override;
/*public*/ bool isTransitioning() override;
/*public*/ void setState(int newState)override;
/*public*/ int getState()override;
/*public*/ void activateLight()override ;
/*public*/ void deactivateLight()override;
/*public*/ void clearLightControls()override;
/*public*/ void addLightControl(LightControl* c)override;
/*public*/ QList<LightControl*> getLightControlList()override;
/*public*/ QList<NamedBeanUsageReport*>* getUsageReport(NamedBean* bean)override;
/*public*/ QString getSystemName() const override {return AbstractNamedBean::getSystemName();}
QObject* self() override {return (QObject*)this;}
QObject* pself() override{return (QObject*)this;}
signals:
void propertyChange(QString propertyName, int oldState, int newState);
public slots:
private:
static Logger* log;
protected:
/**
* System independent instance variables (saved between runs)
*/
/*protected*/ QList<LightControl*> lightControlList = QList<LightControl*>();
/*protected*/ double mMaxIntensity = 1.0;
/*protected*/ double mMinIntensity = 0.0;
/**
* System independent operational instance variables (not saved between runs)
*/
/*protected*/ bool mActive = false;
/*protected*/ bool mEnabled = true;
/*protected*/ double mCurrentIntensity = 0.0;
/*protected*/ int mState = OFF;
/*protected*/ void updateIntensityLow(double intensity);
/*protected*/ void updateIntensityIntermediate(double intensity);
/*protected*/ void updateIntensityHigh(double intensity);
/*protected*/ void notifyTargetIntensityChange(double intensity);
/*protected*/ void notifyStateChange(int oldState, int newState);
/*protected*/ void doNewState(int oldState, int newState);
};
#endif // ABSTRACTLIGHT_H
| [
"[email protected]"
] | |
7a9462ece2f5597dc1e0e82c532c7dadaf362874 | b8e6c3cf2743258a289bd7a2a1a66355e285f37c | /leds.ino | b4ce319ea1a196f08aff0959044b44c6d1d81c13 | [] | no_license | cosmikwolf/afx-01a | 52ec65c59103f562c776d8ce20995e7883f84d43 | 5337b4f13ca25b192e1f7eff8b732838cd4d48b7 | refs/heads/master | 2020-04-06T04:35:29.380249 | 2016-12-27T20:03:07 | 2016-12-27T20:03:07 | 30,449,031 | 4 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,663 | ino |
void ledLoop(){
if (pixelTimer > 20000){
if (settingMode == 0){
for (int i=0; i < NUMPIXELS; i++){
if (i == (sequence[selectedSequence].activeStep) ) {
pixels.setPixelColor(i, pixels.Color(255,255,255) );
} else if ( i == selectedStep) {
pixels.setPixelColor(selectedStep, Wheel(int(millis()/3)%255) );
} else {
if(sequence[selectedSequence].stepData[i].gateType == 0){
pixels.setPixelColor(i, pixels.Color(0,0,0));
} else {
pixels.setPixelColor(i, Wheel( sequence[selectedSequence].getStepPitch(i) ) );
}
}
}
pixels.show();
}
pixelTimer = 0;
}
}
// NeoPixel Subs
uint32_t Wheel(byte WheelPos) {
WheelPos = 255 - WheelPos;
if(WheelPos < 85) {
return pixels.Color(255 - WheelPos * 3, 0, WheelPos * 3);
} else if(WheelPos < 170) {
WheelPos -= 85;
return pixels.Color(0, WheelPos * 3, 255 - WheelPos * 3);
} else {
WheelPos -= 170;
return pixels.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
}
}
void theaterChaseRainbow(uint8_t wait) {
for (int j=0; j < 256; j++) { // cycle all 256 colors in the wheel
for (int q=0; q < 3; q++) {
for (int i=0; i < pixels.numPixels(); i=i+3) {
pixels.setPixelColor(i+q, Wheel( (i+j) % 255)); //turn every third pixel on
}
pixels.show();
delay(wait);
for (int i=0; i < pixels.numPixels(); i=i+3) {
pixels.setPixelColor(i+q, 0); //turn every third pixel off
}
}
}
}
uint32_t freemem(){ // for Teensy 3.0
uint32_t stackTop;
uint32_t heapTop;
// current position of the stack.
stackTop = (uint32_t) &stackTop;
// current position of heap.
void* hTop = malloc(1);
heapTop = (uint32_t) hTop;
free(hTop);
// The difference is the free, available ram.
return stackTop - heapTop;
}
void nonBlockingRainbow(uint8_t interval) {
uint16_t i, j;
j = positive_modulo( millis()/interval, 255 );
for(i=0; i<pixels.numPixels(); i++) {
pixels.setPixelColor(i, Wheel((5*i+j) & 255));
}
pixels.show();
}
void nonBlockingRainbow(uint8_t interval, uint8_t *skipArr, uint8_t skipArrSize) {
uint16_t i,n, j;
j = positive_modulo( millis()/interval, 255 );
for(i=0; i < pixels.numPixels(); i++) {
bool skip = false;
for(n=0; n < skipArrSize; n++){
if (skipArr[n] == i){
skip = true;
}
}
if (!skip){
pixels.setPixelColor(i, Wheel((5*i+j) & 255));
} else {
pixels.setPixelColor(i, pixels.Color(10,10,10));
}
}
pixels.show();
}
| [
"[email protected]"
] | |
c106fee2392b07d0cef79df458cbf0013ee1c219 | e14eeedd5a870f53f09a33de9fa5873b685414bb | /dbbackend.h | 5bec646e8e58061b1d33510d8a3110fb5ed02e2b | [
"BSD-3-Clause"
] | permissive | dmleontiev9000/LJ.offline | c6da86600785cddda58a612dc7927eea82b877c2 | 18087cce6a09215d1b169e3b59a525d0c6485eb9 | refs/heads/master | 2021-01-19T04:58:27.427493 | 2017-04-06T15:22:13 | 2017-04-06T15:22:13 | 87,407,486 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 503 | h | #ifndef DBBACKEND_H
#define DBBACKEND_H
#include "backend.h"
class DBBackend : public Backend
{
Q_OBJECT
public:
explicit DBBackend(const QString& driver,
const QString& host,
int port,
const QString& name,
const QString& user,
const QString& password,
QObject *parent = 0);
~DBBackend();
signals:
public slots:
};
#endif // DBBACKEND_H
| [
"[email protected]"
] | |
071a213bb129f0d1337063ecc25cbfe84d5f4654 | 2456a96fb987e12526bb3deeb8f964d66fdbde26 | /Lab_Inheritance.cpp | f013ffcf83268c7e8af654076ee78b2735c6e514 | [] | no_license | OOP2019lab/lab11-182182basitAliAhmad | ec9fee6951a1df4d4c8ccf53c019e999d8177c8a | 05ba23ff684610b62c8509b86a4e38d1802acb40 | refs/heads/master | 2020-05-09T20:37:27.803917 | 2019-04-15T05:02:46 | 2019-04-15T05:02:46 | 181,414,362 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 474 | cpp | #include "l182182_Faculty.h"
#include "l182182_Person.h"
#include "l182182_Student.h"
int main()
{
Student s("Ted", "Thompson", 22, 3.91);
Faculty f("Richard", "Karp", 45, 2, "420");
s.printStudent();
f.printFaculty();
return 0;
}
/*
Output for exercise 5
Person() invoked
Student() invoked
Person() invoked
Faculty() invoked
~Faculty() invoked
~Person() invoked
~Student() invoked
~Person() invoked
Press any key to continue . . .
*/
| [
"[email protected]"
] | |
22f23fcb4bf5ef4105c9627923f1daf818c1748e | 0bb9ee0b177495624dafe4c15597891832147b74 | /VirtualWar/SynapseEngine/ActorSkeleton.cpp | 96d600c7cfb91c0b59e50f005093b6bef97118a4 | [] | no_license | wangscript007/SynapseEngine | 7fcec62b50ba70c9cfc64c06719a2ae170a27a7b | 3e0499181aaadf5244b7810ef2449a09f5aad1a6 | refs/heads/main | 2023-06-11T01:46:26.603230 | 2021-07-10T08:28:58 | 2021-07-10T08:28:58 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 27 | cpp | #include "ActorSkeleton.h"
| [
"[email protected]"
] | |
f06029e8fd2509f0a35f9baf91e24f2099c89ce2 | 877fff5bb313ccd23d1d01bf23b1e1f2b13bb85a | /app/src/main/cpp/dir7941/dir22441/dir26975/dir27120/file27662.cpp | 1f6624f445d762ec5379e59df53d8d4cfc760033 | [] | no_license | tgeng/HugeProject | 829c3bdfb7cbaf57727c41263212d4a67e3eb93d | 4488d3b765e8827636ce5e878baacdf388710ef2 | refs/heads/master | 2022-08-21T16:58:54.161627 | 2020-05-28T01:54:03 | 2020-05-28T01:54:03 | 267,468,475 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 115 | cpp | #ifndef file27662
#error "macro file27662 must be defined"
#endif
static const char* file27662String = "file27662"; | [
"[email protected]"
] | |
2bc5d950e66249311d2fa84410f8ae29309b7769 | d6a26a1eea3c41f7307af9f7b59201bfe99ec15d | /src/HammingCoder.cpp | e29280e339f45169b6967e2ea3a4a9497f4418b0 | [] | no_license | chudinovaa/labs45 | 183b6171f2a4247438a42c3371d021a8f781331d | c894807ade00018e3ec89b768fe81adf6761a049 | refs/heads/master | 2020-08-04T00:54:17.131742 | 2019-10-10T12:02:51 | 2019-10-10T12:02:51 | 211,944,121 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 672 | cpp | #include <cmath>
#include "HammingCoder.h"
uint8_t encode(const unsigned int number)
{
auto d1 = number >> 3u & 1u;
auto d2 = number >> 2u & 1u;
auto d3 = number >> 1u & 1u;
auto d4 = number & 1u;
auto p1 = d1 ^d2 ^d4;
auto p2 = d1 ^d3 ^d4;
auto p3 = d2 ^d3 ^d4;
p1 <<= 6u;
p2 <<= 5u;
d1 <<= 4u;
p3 <<= 3u;
d2 <<= 2u;
d3 <<= 1u;
return static_cast<uint8_t>(p1 | p2 | p3 | d1 | d2 | d3 | d4);
}
std::vector<uint8_t> HammingCoder::encode(const std::vector<uint8_t> &data)
{
auto result = std::vector<uint8_t>();
result.reserve(std::size(data));
for (const auto &element : data)
result.push_back(::encode(element));
return result;
}
| [
"[email protected]"
] | |
cebfbf99aeb9b3866826d02cbacce4604077842a | f3241fb798602996710e21456cbe44e84705d89c | /zyn.serialization/EffectMgrSerializer.h | a5b45b905be0a59f7df48279132f4ff296b20639 | [] | no_license | stephenberry/zynlab | f2af519c0e8bdb9870ca6b78aa38754d1cffd123 | 72f8fb35c43c836d09ad0283fcb3da4a8ff8f994 | refs/heads/master | 2023-07-01T01:54:22.560071 | 2021-08-07T15:15:03 | 2021-08-07T15:15:13 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,320 | h | /*
ZynAddSubFX - a software synthesizer
EffectMgr.h - Effect manager, an interface betwen the program and effects
Copyright (C) 2002-2005 Nasca Octavian Paul
Author: Nasca Octavian Paul
This program is free software; you can redistribute it and/or modify
it under the terms of version 2 of the GNU General Public License
as published by the Free Software Foundation.
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 (version 2 or later) for more details.
You should have received a copy of the GNU General Public License (version 2)
along with this program; if not, write to the Free Software Foundation,
Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef EFFECT_MANAGER_SERIALIZER_H
#define EFFECT_MANAGER_SERIALIZER_H
#include <zyn.common/IPresetsSerializer.h>
#include <zyn.fx/EffectMgr.h>
class EffectManagerSerializer
{
EffectManager *_parameters;
public:
EffectManagerSerializer(EffectManager *parameters);
virtual ~EffectManagerSerializer();
void Serialize(IPresetsSerializer *xml);
void Deserialize(IPresetsSerializer *xml);
};
#endif // EFFECT_MANAGER_SERIALIZER_H
| [
"[email protected]"
] | |
a3ae907a4f491b656dc9d7c7a1dff24ef7704c09 | 7dd42e1f22b4e48bf72f5617b9dab840eabfa3a0 | /LinearTable/sequenceTable.cpp | 9865a3e55e8da109d6a114cb480962ace0b5a2c9 | [] | no_license | eliiik/Data-Structure | d25aaef6881f16fc8b00bbdd8d3e84295362fb91 | 349ad7ac0c309ce9bb4ee08e6f5462542471d356 | refs/heads/master | 2021-06-08T02:01:30.144298 | 2016-12-06T17:45:57 | 2016-12-06T17:45:57 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 60 | cpp | #include <iostream>
using namespace std;
template <class T> | [
"[email protected]"
] | |
5978b377312caff50b87fade696e3b7ff798b100 | 1791461e6740f81c2dd6704ae6a899a6707ee6b1 | /UESTC/2145.cpp | ee13113f1f237c3c7ce2da73d28bf86249a6a198 | [
"MIT"
] | permissive | HeRaNO/OI-ICPC-Codes | b12569caa94828c4bedda99d88303eb6344f5d6e | 4f542bb921914abd4e2ee7e17d8d93c1c91495e4 | refs/heads/master | 2023-08-06T10:46:32.714133 | 2023-07-26T08:10:44 | 2023-07-26T08:10:44 | 163,658,110 | 22 | 6 | null | null | null | null | UTF-8 | C++ | false | false | 2,053 | cpp | #include <bits/stdc++.h>
#define MAXN 100010
using namespace std;
struct col
{
int l,r,all;
col(){}
col(int _l,int _r,int _all):l(_l),r(_r),all(_all){}
col operator + (const col &a)const{
col res;
res.l=l;res.r=a.r;res.all=all+a.all-(r&a.l);
return res;
}
};
struct SegmentTree
{
int p,r,m;col w;
};
SegmentTree tree[1<<19];
int n,m,l,r,a[MAXN][2];
pair<int,int*> b[MAXN<<1];
void BuildTree(int u)
{
if (tree[u].p+1==tree[u].r) return ;
tree[u].m=tree[u].p+tree[u].r>>1;
tree[u<<1].p=tree[u].p;tree[u<<1].r=tree[u].m;BuildTree(u<<1);
tree[u<<1|1].p=tree[u].m;tree[u<<1|1].r=tree[u].r;BuildTree(u<<1|1);
return ;
}
void Pushdown(int u)
{
if (tree[u].w.l==1&&tree[u].w.r==1&&tree[u].w.all==1)
{
tree[u<<1].w=col(1,1,1);tree[u<<1|1].w=col(1,1,1);
}
return ;
}
void modify_one(int u,int x)
{
if (tree[u].p+1==tree[u].r)
{
tree[u].w.l=1;tree[u].w.all=1;
return ;
}
Pushdown(u);
if (x<tree[u].m) modify_one(u<<1,x);
else modify_one(u<<1|1,x);
tree[u].w=tree[u<<1].w+tree[u<<1|1].w;
return ;
}
void modify(int u,int l,int r)
{
if (tree[u].p==l&&tree[u].r==r)
{
tree[u].w=col(1,1,1);
return ;
}
Pushdown(u);
if (r<=tree[u].m) modify(u<<1,l,r);
else if (tree[u].m<=l) modify(u<<1|1,l,r);
else
{
modify(u<<1,l,tree[u].m);
modify(u<<1|1,tree[u].m,r);
}
tree[u].w=tree[u<<1].w+tree[u<<1|1].w;
return ;
}
inline void read(int &x)
{
x=0;char ch;
if ((ch=getchar())==EOF){x=-1;return ;}
while (ch<'0'||ch>'9') ch=getchar();
while (ch>='0'&&ch<='9') x=(x<<3)+(x<<1)+ch-'0',ch=getchar();
return ;
}
int main()
{
read(n);
for (int i=0;i<n;i++)
{
read(a[i][0]);read(a[i][1]);
b[i<<1]=make_pair(a[i][0],&a[i][0]);
b[i<<1|1]=make_pair(a[i][1],&a[i][1]);
}
sort(b,b+(n<<1));
++m;*b[0].second=m;
for (int i=1,p=n<<1;i<p;i++)
{
if (b[i].first!=b[i-1].first) ++m;
*b[i].second=m;
}
tree[1].p=1;tree[1].r=m;BuildTree(1);
for (int i=0;i<n;i++)
{
if (a[i][0]==a[i][1]) modify_one(1,a[i][0]);
else modify(1,a[i][0],a[i][1]);
printf("%d%c",tree[1].w.all,i==n-1?'\n':' ');
}
return 0;
} | [
"[email protected]"
] | |
f8b77be1f84576bc9552c160f2e2e5ea33ba5ba3 | 8e63af49306295050e15f34a10b1f8f3e058ac5f | /main.cpp | 61a39dbc34ec92fefd498e862145b59a5a637a65 | [] | no_license | CIS22C/Lab2b | a8438fc6ac4ffda5dc502f9f3bc97838fc7454a3 | a8c89cb92c6ad616835113eab3886eca0f64a605 | refs/heads/master | 2021-05-01T20:53:54.840077 | 2018-02-12T22:32:53 | 2018-02-12T22:32:53 | 120,967,217 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,566 | cpp | /*
Ambrose Hundal
Stephen Lee
CIS 22C
Winter 18
Lab 2b- QueueADT
*/
#include <iostream>
#include "Queue.h"
#include "List.h"
#include "Currency.h"
#include "Dollar.h"
using namespace std;
void intEnqueue();
void intDequeue();
void intQueueClear();
void stringEnqueue();
void stringDequeue();
void stringClear();
void currencyEnqueue();
void currencyDequeue();
void currencyClear();
int main(){
Queue<int>intQueue;
Queue<string>stringQueue;
Queue<Currency>CurrencyQueue;
cout << "Welcome to Queue ADT implementation. ";
bool loopMenu = true;
while (loopMenu)
{
cout << "Please choose an operation from the options listed below:" << endl
<< "1. Enqueue an integer to the queue" << endl
<< "2. Dequeue an integer from the queue" << endl
<< "3. Clear integer queue" << endl
<< "4. Enqueue a string to the string queue." << endl
<< "5. Dequeue an entry from string queue" << endl
<< "6. Clear the string queue" << endl
<< "7. Enqueue a currenry to queue" << endl
<< "8. Dequeue an entry from currency queue" << endl
<< "9. Clear the Currency queue" << endl
<< "10. Exit Program" << endl;
cin >> choice;
if (cin.fail ())
{
cin.clear ();
choice = 0;
}
cout << endl;
if (choice == 1) intEnqueue();
else if (choice == 2) intDequeue();
else if (choice == 3) intQueueClear();
else if (choice == 4) stringEnqueue();
else if (choice == 5) stringDequeue();
else if (choice == 6) stringClear();
else if (choice == 7) currencyEnqueue();
else if (choice == 8) currencyDequeue();
else if (choice == 9) currencyClear();
else if (choice == 10) loopActive = false;
}
}
}
//intEnqueue
//enters an integer into the queue
void intEnqueue ()
{
int x;
cout << "Enter a number to add to the queue: ";
cin >> x;
intQueue->enqueue(x);
cout << "Queue items:" << endl << intQueue << endl;
}
//intDequeue
//remove an entry from the queue
void intDequeue ()
{
if (intQueue->empty ())
{
cout << "Queue is empty!" << endl;
}
else
{
intQueue->dequeue();
cout << "Integer Queue:" << endl << intQueue << endl << endl;
}
}
//ClearQueue
//clears int queue
void ClearintQueue ()
{
intQueue->clear ();
cout << "Queue contains:" << endl << intQueue << endl << endl;
}
//stringEnqueue
//
void stringEnqueue()
{
string buffer;
ifstream read_input_file ("demo.txt");
cout << "Adding \"demo.txt\" contents to queue:" << endl;
while (true)
{
read_input_file >> buffer;
if (!read_input_file) break;
stringQueue->enqueue(buffer);
}
read_input_file.close ();
cout << "Queue string items:" << endl << stringQueue << endl << endl;
}
//stringDequeue
//removes a string from the queue
void stringDequeue()
{
if (stringDequeue->empty ()) {
cout << "Queue is empty!" << endl;
}
else
{
stringQueue->dequeue ();
cout << "Queue contains:" << endl << stringQueue << endl << endl;
}
}
//stringQueueclear
// Clears the string queue
void stringQueueClear ()
{
stringQueue->clear ();
cout << "string stack items:" << endl << stackString << endl << endl;
}
//currencyEnqueue
//enters a currency to the queue
void currencyEnqueue()
{
currencyQueue->enqueue(Dollar(3, 35));
cout << "Queue currency contains:" << endl << CurrencyQueue << endl << endl;
}
//currencyDequeue
//removes a currency object from the queue
void currencyDequeue ()
{
if (currencyQueue->empty ())
{
cout << "Queue is empty!" << endl << endl;
}
else
{
currencyQueue->dequeue();
cout << "Currency items:" << endl << currencyQueue << endl << endl;
}
}
//currencyClear
//clears the currency queue
currencyClear()
{
currencyQueue->clear ();
cout << "Currency iters:" << endl << currencyQueue << endl << endl;
}
// operator<<
template <class T>
std::ostream& operator<< (std::ostream &foo, List<T> *ListPtr)
{
int itemCount = 0;
if (ListPtr->empty ()) cout << "List is empty" << endl;
else
{
Node<T> *currPtr = ListPtr->getTail ();
while (currPtr != nullptr)
{
itemCount++;
foo << itemCount << ". " << currPtr->value << endl;
currPtr = currPtr->next;
}
}
return foo;
}
template <class T>
std::ostream& operator<< (std::ostream &foo, Queue<T> *ListPtr)
{
int itemCount = 0;
if (ListPtr->empty ()) cout << "List is empty" << endl;
else
{
Node<T> *currPtr = ListPtr->getTail ();
while (currPtr != nullptr)
{
itemCount++;
foo << itemCount << ". " << currPtr->value << endl;
currPtr = currPtr->next;
}
}
return foo;
}
}
| [
"[email protected]"
] | |
b009300ce59928f423a19d3892c2591f2cfb0b0e | 962c065f5afb673cf90df9eebd0d89125983bee8 | /FlatScrollBar/FlatScrollBar.h | d8c8029bca4bd69351766013a503d3d7b085c039 | [] | no_license | ksoftmedia/MFCMsControl | c359a32920f8cfb0d10f82aa33c854b9cd29ccfc | 5736af54525f787a04763d31bd3fd6fe67a1d67f | refs/heads/master | 2020-07-06T11:14:02.097999 | 2019-08-14T15:32:13 | 2019-08-14T15:32:13 | 202,998,540 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 514 | h |
// FlatScrollBar.h : main header file for the PROJECT_NAME application
//
#pragma once
#ifndef __AFXWIN_H__
#error "include 'pch.h' before including this file for PCH"
#endif
#include "resource.h" // main symbols
// CFlatScrollBarApp:
// See FlatScrollBar.cpp for the implementation of this class
//
class CFlatScrollBarApp : public CWinApp
{
public:
CFlatScrollBarApp();
// Overrides
public:
virtual BOOL InitInstance();
// Implementation
DECLARE_MESSAGE_MAP()
};
extern CFlatScrollBarApp theApp;
| [
"[email protected]"
] | |
7f1a9f023a7ecf68f9d17249f36939dc00547501 | b8f67d61d62799db00542b7b3069da6fcdf10f85 | /chrome/browser/android/vr/arcore_device/arcore_device.cc | 0b1b6f9e789e1be928a4fb3231b77a7d6c1f0b98 | [
"BSD-3-Clause"
] | permissive | fujunwei/chromium-src | 535e4cc01dc2c96aac50671222a77de50d2616dc | 57c7d5bbf24af7b342b330fb8775fc76c343ff69 | refs/heads/webml | 2022-12-30T07:55:11.938223 | 2018-08-28T07:07:52 | 2018-08-28T07:07:52 | 138,548,904 | 0 | 0 | NOASSERTION | 2019-03-22T01:51:37 | 2018-06-25T05:47:59 | null | UTF-8 | C++ | false | false | 16,532 | cc | // Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/android/vr/arcore_device/arcore_device.h"
#include "base/bind.h"
#include "base/numerics/math_constants.h"
#include "base/optional.h"
#include "base/task_scheduler/post_task.h"
#include "base/trace_event/trace_event.h"
#include "chrome/browser/android/tab_android.h"
#include "chrome/browser/android/vr/arcore_device/arcore_gl.h"
#include "chrome/browser/android/vr/arcore_device/arcore_gl_thread.h"
#include "chrome/browser/android/vr/arcore_device/arcore_java_utils.h"
#include "chrome/browser/android/vr/mailbox_to_surface_bridge.h"
#include "chrome/browser/permissions/permission_manager.h"
#include "chrome/browser/permissions/permission_result.h"
#include "chrome/browser/permissions/permission_update_infobar_delegate_android.h"
#include "chrome/browser/profiles/profile.h"
#include "components/content_settings/core/common/content_settings_types.h"
#include "content/public/browser/render_frame_host.h"
#include "content/public/browser/web_contents.h"
#include "device/vr/vr_display_impl.h"
#include "ui/display/display.h"
using base::android::JavaRef;
namespace {
constexpr float kDegreesPerRadian = 180.0f / base::kPiFloat;
} // namespace
namespace device {
namespace {
mojom::VRDisplayInfoPtr CreateVRDisplayInfo(uint32_t device_id) {
mojom::VRDisplayInfoPtr device = mojom::VRDisplayInfo::New();
device->index = device_id;
device->displayName = "ARCore VR Device";
device->capabilities = mojom::VRDisplayCapabilities::New();
device->capabilities->hasPosition = true;
device->capabilities->hasExternalDisplay = false;
device->capabilities->canPresent = false;
device->capabilities->can_provide_pass_through_images = true;
device->leftEye = mojom::VREyeParameters::New();
device->rightEye = nullptr;
mojom::VREyeParametersPtr& left_eye = device->leftEye;
left_eye->fieldOfView = mojom::VRFieldOfView::New();
// TODO(lincolnfrog): get these values for real (see gvr device).
uint width = 1080;
uint height = 1795;
double fov_x = 1437.387;
double fov_y = 1438.074;
// TODO(lincolnfrog): get real camera intrinsics.
float horizontal_degrees = atan(width / (2.0 * fov_x)) * kDegreesPerRadian;
float vertical_degrees = atan(height / (2.0 * fov_y)) * kDegreesPerRadian;
left_eye->fieldOfView->leftDegrees = horizontal_degrees;
left_eye->fieldOfView->rightDegrees = horizontal_degrees;
left_eye->fieldOfView->upDegrees = vertical_degrees;
left_eye->fieldOfView->downDegrees = vertical_degrees;
left_eye->offset = {0.0f, 0.0f, 0.0f};
left_eye->renderWidth = width;
left_eye->renderHeight = height;
return device;
}
} // namespace
ARCoreDevice::ARCoreDevice()
: VRDeviceBase(VRDeviceId::ARCORE_DEVICE_ID),
main_thread_task_runner_(base::ThreadTaskRunnerHandle::Get()),
mailbox_bridge_(std::make_unique<vr::MailboxToSurfaceBridge>()),
weak_ptr_factory_(this) {
SetVRDisplayInfo(CreateVRDisplayInfo(GetId()));
arcore_java_utils_ = std::make_unique<vr::ArCoreJavaUtils>(this);
// TODO(https://crbug.com/836524) clean up usage of mailbox bridge
// and extract the methods in this class that interact with ARCore API
// into a separate class that implements the ARCore interface.
mailbox_bridge_->CreateUnboundContextProvider(
base::BindOnce(&ARCoreDevice::OnMailboxBridgeReady, GetWeakPtr()));
}
ARCoreDevice::~ARCoreDevice() {
}
void ARCoreDevice::PauseTracking() {
DCHECK(IsOnMainThread());
if (is_paused_)
return;
is_paused_ = true;
if (!is_arcore_gl_initialized_)
return;
PostTaskToGlThread(base::BindOnce(
&ARCoreGl::Pause, arcore_gl_thread_->GetARCoreGl()->GetWeakPtr()));
}
void ARCoreDevice::ResumeTracking() {
DCHECK(IsOnMainThread());
if (!is_paused_)
return;
is_paused_ = false;
if (!deferred_request_install_supported_arcore_callbacks_.empty())
CallDeferredRequestInstallSupportedARCore();
if (!is_arcore_gl_initialized_)
return;
PostTaskToGlThread(base::BindOnce(
&ARCoreGl::Resume, arcore_gl_thread_->GetARCoreGl()->GetWeakPtr()));
}
void ARCoreDevice::OnMailboxBridgeReady() {
DCHECK(IsOnMainThread());
DCHECK(!arcore_gl_thread_);
// MailboxToSurfaceBridge's destructor's call to DestroyContext must
// happen on the GL thread, so transferring it to that thread is appropriate.
// TODO(https://crbug.com/836553): use same GL thread as GVR.
arcore_gl_thread_ = std::make_unique<ARCoreGlThread>(
std::move(mailbox_bridge_),
CreateMainThreadCallback(base::BindOnce(
&ARCoreDevice::OnARCoreGlThreadInitialized, GetWeakPtr())));
arcore_gl_thread_->Start();
}
void ARCoreDevice::OnARCoreGlThreadInitialized() {
DCHECK(IsOnMainThread());
is_arcore_gl_thread_initialized_ = true;
if (pending_request_session_callback_) {
std::move(pending_request_session_callback_).Run();
}
}
void ARCoreDevice::RequestSession(
mojom::XRDeviceRuntimeSessionOptionsPtr options,
mojom::XRRuntime::RequestSessionCallback callback) {
DCHECK(IsOnMainThread());
// TODO(https://crbug.com/849568): Instead of splitting the initialization
// of this class between construction and RequestSession, perform all the
// initialization at once on the first successful RequestSession call.
if (!is_arcore_gl_thread_initialized_) {
if (pending_request_session_callback_) {
// We can only store one request at a time, so reject any further
// requests.
// TODO(http://crbug.com/836496) Make this queue session requests.
std::move(callback).Run(nullptr, nullptr);
}
pending_request_session_callback_ =
base::BindOnce(&ARCoreDevice::RequestSession, GetWeakPtr(),
std::move(options), std::move(callback));
return;
}
auto preconditions_complete_callback =
base::BindOnce(&ARCoreDevice::OnRequestSessionPreconditionsComplete,
GetWeakPtr(), std::move(callback));
SatisfyRequestSessionPreconditions(
options->render_process_id, options->render_frame_id,
options->has_user_activation, std::move(preconditions_complete_callback));
}
void ARCoreDevice::SatisfyRequestSessionPreconditions(
int render_process_id,
int render_frame_id,
bool has_user_activation,
base::OnceCallback<void(bool)> callback) {
DCHECK(IsOnMainThread());
DCHECK(is_arcore_gl_thread_initialized_);
if (!arcore_java_utils_->ShouldRequestInstallSupportedArCore()) {
// TODO(https://crbug.com/845792): Consider calling a method to ask for the
// appropriate permissions.
// ARCore sessions require camera permission.
RequestCameraPermission(
render_process_id, render_frame_id, has_user_activation,
base::BindOnce(&ARCoreDevice::OnRequestCameraPermissionComplete,
GetWeakPtr(), std::move(callback)));
return;
}
// ARCore is not installed or requires an update. Store the callback to be
// processed later and only the first request session will trigger the
// request to install or update of the ARCore APK.
auto deferred_callback =
base::BindOnce(&ARCoreDevice::OnRequestARCoreInstallOrUpdateComplete,
GetWeakPtr(), render_process_id, render_frame_id,
has_user_activation, std::move(callback));
deferred_request_install_supported_arcore_callbacks_.push_back(
std::move(deferred_callback));
if (deferred_request_install_supported_arcore_callbacks_.size() > 1)
return;
content::RenderFrameHost* render_frame_host =
content::RenderFrameHost::FromID(render_process_id, render_frame_id);
DCHECK(render_frame_host);
content::WebContents* web_contents =
content::WebContents::FromRenderFrameHost(render_frame_host);
DCHECK(web_contents);
TabAndroid* tab_android = TabAndroid::FromWebContents(web_contents);
DCHECK(tab_android);
base::android::ScopedJavaLocalRef<jobject> j_tab_android =
tab_android->GetJavaObject();
DCHECK(!j_tab_android.is_null());
arcore_java_utils_->RequestInstallSupportedArCore(j_tab_android);
}
void ARCoreDevice::OnRequestInstallSupportedARCoreCanceled() {
DCHECK(IsOnMainThread());
DCHECK(is_arcore_gl_thread_initialized_);
DCHECK(!deferred_request_install_supported_arcore_callbacks_.empty());
CallDeferredRequestInstallSupportedARCore();
}
void ARCoreDevice::CallDeferredRequestInstallSupportedARCore() {
DCHECK(IsOnMainThread());
DCHECK(is_arcore_gl_thread_initialized_);
DCHECK(!deferred_request_install_supported_arcore_callbacks_.empty());
for (auto& deferred_callback :
deferred_request_install_supported_arcore_callbacks_) {
std::move(deferred_callback).Run();
}
deferred_request_install_supported_arcore_callbacks_.clear();
}
void ARCoreDevice::OnRequestARCoreInstallOrUpdateComplete(
int render_process_id,
int render_frame_id,
bool has_user_activation,
base::OnceCallback<void(bool)> callback) {
DCHECK(IsOnMainThread());
DCHECK(is_arcore_gl_thread_initialized_);
if (arcore_java_utils_->ShouldRequestInstallSupportedArCore()) {
std::move(callback).Run(false);
return;
}
RequestCameraPermission(
render_process_id, render_frame_id, has_user_activation,
base::BindOnce(&ARCoreDevice::OnRequestCameraPermissionComplete,
GetWeakPtr(), std::move(callback)));
}
void ARCoreDevice::OnRequestCameraPermissionComplete(
base::OnceCallback<void(bool)> callback,
bool success) {
DCHECK(IsOnMainThread());
DCHECK(is_arcore_gl_thread_initialized_);
// By this point ARCore has already been set up, so just return whether the
// permission request was a success.
std::move(callback).Run(success);
}
bool ARCoreDevice::ShouldPauseTrackingWhenFrameDataRestricted() {
return true;
}
void ARCoreDevice::OnMagicWindowFrameDataRequest(
mojom::XRFrameDataProvider::GetFrameDataCallback callback) {
TRACE_EVENT0("gpu", __FUNCTION__);
DCHECK(IsOnMainThread());
// We should not be able to reach this point if we are not initialized.
DCHECK(is_arcore_gl_thread_initialized_);
if (is_paused_) {
std::move(callback).Run(nullptr);
return;
}
// TODO(https://crbug.com/836496) This current implementation does not handle
// multiple sessions well. There should be a better way to handle this than
// taking the max of all sessions.
gfx::Size max_size(0, 0);
display::Display::Rotation rotation;
for (auto& session : magic_window_sessions_) {
max_size.SetToMax(session->sessionFrameSize());
// We have to pick a rotation so just go with the last one.
rotation = session->sessionRotation();
}
if (max_size.IsEmpty()) {
DLOG(ERROR) << "No valid AR frame size provided!";
std::move(callback).Run(nullptr);
return;
}
PostTaskToGlThread(base::BindOnce(
&ARCoreGl::ProduceFrame, arcore_gl_thread_->GetARCoreGl()->GetWeakPtr(),
max_size, rotation, CreateMainThreadCallback(std::move(callback))));
}
void ARCoreDevice::RequestHitTest(
mojom::XRRayPtr ray,
mojom::XREnviromentIntegrationProvider::RequestHitTestCallback callback) {
DCHECK(IsOnMainThread());
PostTaskToGlThread(base::BindOnce(
&ARCoreGl::RequestHitTest, arcore_gl_thread_->GetARCoreGl()->GetWeakPtr(),
std::move(ray), CreateMainThreadCallback(std::move(callback))));
}
void ARCoreDevice::PostTaskToGlThread(base::OnceClosure task) {
DCHECK(IsOnMainThread());
arcore_gl_thread_->GetARCoreGl()->GetGlThreadTaskRunner()->PostTask(
FROM_HERE, std::move(task));
}
bool ARCoreDevice::IsOnMainThread() {
return main_thread_task_runner_->BelongsToCurrentThread();
}
void ARCoreDevice::RequestCameraPermission(
int render_process_id,
int render_frame_id,
bool has_user_activation,
base::OnceCallback<void(bool)> callback) {
DCHECK(IsOnMainThread());
DCHECK(is_arcore_gl_thread_initialized_);
content::RenderFrameHost* rfh =
content::RenderFrameHost::FromID(render_process_id, render_frame_id);
// The RFH may have been destroyed by the time the request is processed.
DCHECK(rfh);
content::WebContents* web_contents =
content::WebContents::FromRenderFrameHost(rfh);
DCHECK(web_contents);
Profile* profile =
Profile::FromBrowserContext(web_contents->GetBrowserContext());
PermissionManager* permission_manager = PermissionManager::Get(profile);
permission_manager->RequestPermission(
CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA, rfh, web_contents->GetURL(),
has_user_activation,
base::BindRepeating(&ARCoreDevice::OnRequestCameraPermissionResult,
GetWeakPtr(), web_contents, base::Passed(&callback)));
}
void ARCoreDevice::OnRequestCameraPermissionResult(
content::WebContents* web_contents,
base::OnceCallback<void(bool)> callback,
ContentSetting content_setting) {
DCHECK(IsOnMainThread());
DCHECK(is_arcore_gl_thread_initialized_);
// If the camera permission is not allowed, abort the request.
if (content_setting != CONTENT_SETTING_ALLOW) {
std::move(callback).Run(false);
return;
}
// Even if the content setting stated that the camera access is allowed,
// the Android camera permission might still need to be requested, so check
// if the OS level permission infobar should be shown.
std::vector<ContentSettingsType> content_settings_types;
content_settings_types.push_back(CONTENT_SETTINGS_TYPE_MEDIASTREAM_CAMERA);
ShowPermissionInfoBarState show_permission_info_bar_state =
PermissionUpdateInfoBarDelegate::ShouldShowPermissionInfoBar(
web_contents, content_settings_types);
switch (show_permission_info_bar_state) {
case ShowPermissionInfoBarState::NO_NEED_TO_SHOW_PERMISSION_INFOBAR:
std::move(callback).Run(true);
return;
case ShowPermissionInfoBarState::SHOW_PERMISSION_INFOBAR:
// Show the Android camera permission info bar.
PermissionUpdateInfoBarDelegate::Create(
web_contents, content_settings_types,
base::BindOnce(&ARCoreDevice::OnRequestAndroidCameraPermissionResult,
GetWeakPtr(), base::Passed(&callback)));
return;
case ShowPermissionInfoBarState::CANNOT_SHOW_PERMISSION_INFOBAR:
std::move(callback).Run(false);
return;
}
NOTREACHED() << "Unknown show permission infobar state.";
}
void ARCoreDevice::OnRequestSessionPreconditionsComplete(
mojom::XRRuntime::RequestSessionCallback callback,
bool success) {
DCHECK(IsOnMainThread());
DCHECK(is_arcore_gl_thread_initialized_);
if (!success) {
std::move(callback).Run(nullptr, nullptr);
return;
}
if (is_arcore_gl_initialized_) {
OnARCoreGlInitializationComplete(std::move(callback), true);
return;
}
PostTaskToGlThread(base::BindOnce(
&ARCoreGl::Initialize, arcore_gl_thread_->GetARCoreGl()->GetWeakPtr(),
CreateMainThreadCallback(
base::BindOnce(&ARCoreDevice::OnARCoreGlInitializationComplete,
GetWeakPtr(), std::move(callback)))));
}
void ARCoreDevice::OnARCoreGlInitializationComplete(
mojom::XRRuntime::RequestSessionCallback callback,
bool success) {
DCHECK(IsOnMainThread());
DCHECK(is_arcore_gl_thread_initialized_);
if (!success) {
std::move(callback).Run(nullptr, nullptr);
return;
}
is_arcore_gl_initialized_ = true;
if (!is_paused_) {
PostTaskToGlThread(base::BindOnce(
&ARCoreGl::Resume, arcore_gl_thread_->GetARCoreGl()->GetWeakPtr()));
}
auto session = mojom::XRSession::New();
mojom::XRFrameDataProviderPtr data_provider;
mojom::XREnviromentIntegrationProviderPtr enviroment_provider;
mojom::XRSessionControllerPtr controller;
magic_window_sessions_.push_back(std::make_unique<VRDisplayImpl>(
this, mojo::MakeRequest(&data_provider),
mojo::MakeRequest(&enviroment_provider), mojo::MakeRequest(&controller)));
session->data_provider = data_provider.PassInterface();
session->enviroment_provider = enviroment_provider.PassInterface();
std::move(callback).Run(std::move(session), std::move(controller));
}
void ARCoreDevice::OnRequestAndroidCameraPermissionResult(
base::OnceCallback<void(bool)> callback,
bool was_android_camera_permission_granted) {
DCHECK(IsOnMainThread());
DCHECK(is_arcore_gl_thread_initialized_);
std::move(callback).Run(was_android_camera_permission_granted);
}
} // namespace device
| [
"[email protected]"
] | |
25bdb6de13fdcd5f396d61d5c62bf39ce6adc54e | fc2a5c34a98e710427cdaf90f9a855053c5fc922 | /chemistry.h | 3dd44f8bb5db923a21fbe43ee6cd559c11d86cc1 | [] | no_license | JackWagner/CombustionAnalysis | 6b29c00d6b020846605a6775163501321b76cd66 | f32bd85b9d50f9b20ce00c02824cce01cf35c408 | refs/heads/master | 2021-01-22T17:39:19.939491 | 2017-03-20T16:32:23 | 2017-03-20T16:32:23 | 85,027,697 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,205 | h | #include <iostream>
#include <map>
#include <string>
#include <cstdio>
#include <cstdlib>
#include <vector>
using namespace std;
class compound {
map<string, int> ATOMIC_NUMBER;//each element name associated with atomic num
double ATOMIC_MASS[83]; //each atomic num associated with atomic mass
int amountOfElements; //number of elements in compound
vector<int> compoundElements; //contains elements as atomic number
vector<double> compoundComposition; //mass percent for each element
double mass; //entire mass of compound
public:
compound(string molecule);
void setValues();
bool parseStringGiven(string given);
void setCompoundValues();
};
void compound::setValues() {
ATOMIC_NUMBER["H"]=1;
ATOMIC_NUMBER["Li"]=3;
ATOMIC_NUMBER["Be"]=4;
ATOMIC_NUMBER["B"]=5;
ATOMIC_NUMBER["C"]=6;
ATOMIC_NUMBER["N"]=7;
ATOMIC_NUMBER["O"]=8;
ATOMIC_NUMBER["F"]=9;
ATOMIC_NUMBER["Na"]=11;
ATOMIC_NUMBER["Mg"]=12;
ATOMIC_NUMBER["Al"]=13;
ATOMIC_NUMBER["Si"]=14;
ATOMIC_NUMBER["P"]=15;
ATOMIC_NUMBER["S"]=16;
ATOMIC_NUMBER["Cl"]=17;
ATOMIC_NUMBER["K"]=19;
ATOMIC_NUMBER["Ca"]=20;
ATOMIC_NUMBER["Sc"]=21;
ATOMIC_NUMBER["Ti"]=22;
ATOMIC_NUMBER["Cr"]=24;
ATOMIC_NUMBER["Mn"]=25;
ATOMIC_NUMBER["Fe"]=26;
ATOMIC_NUMBER["Co"]=27;
ATOMIC_NUMBER["Ni"]=28;
ATOMIC_NUMBER["Cu"]=29;
ATOMIC_NUMBER["Zn"]=30;
ATOMIC_NUMBER["Ga"]=31;
ATOMIC_NUMBER["Ge"]=32;
ATOMIC_NUMBER["As"]=33;
ATOMIC_NUMBER["Se"]=34;
ATOMIC_NUMBER["Br"]=35;
ATOMIC_NUMBER["Rb"]=37;
ATOMIC_NUMBER["Sr"]=38;
ATOMIC_NUMBER["Zr"]=40;
ATOMIC_NUMBER["Ag"]=47;
ATOMIC_NUMBER["Cd"]=48;
ATOMIC_NUMBER["In"]=49;
ATOMIC_NUMBER["Sn"]=50;
ATOMIC_NUMBER["Sb"]=51;
ATOMIC_NUMBER["I"]=53;
ATOMIC_NUMBER["Xe"]=54;
ATOMIC_NUMBER["Cs"]=55;
ATOMIC_NUMBER["Ba"]=56;
ATOMIC_NUMBER["Os"]=76;
ATOMIC_NUMBER["Pt"]=78;
ATOMIC_NUMBER["Au"]=79;
ATOMIC_NUMBER["Hg"]=80;
ATOMIC_NUMBER["Pb"]=82;
ATOMIC_MASS[1]=1.008;
ATOMIC_MASS[3]=6.941;
ATOMIC_MASS[4]=9.012;
ATOMIC_MASS[5]=10.81;
ATOMIC_MASS[6]=12.01;
ATOMIC_MASS[7]=14.01;
ATOMIC_MASS[8]=16.00;
ATOMIC_MASS[9]=19.00;
ATOMIC_MASS[11]=22.99;
ATOMIC_MASS[12]=24.31;
ATOMIC_MASS[13]=26.98;
ATOMIC_MASS[14]=28.09;
ATOMIC_MASS[15]=30.97;
ATOMIC_MASS[16]=32.07;
ATOMIC_MASS[17]=35.45;
ATOMIC_MASS[19]=39.10;
ATOMIC_MASS[20]=40.08;
ATOMIC_MASS[21]=44.96;
ATOMIC_MASS[22]=47.87;
ATOMIC_MASS[24]=52.00;
ATOMIC_MASS[25]=54.94;
ATOMIC_MASS[26]=55.85;
ATOMIC_MASS[27]=58.93;
ATOMIC_MASS[28]=58.69;
ATOMIC_MASS[29]=63.55;
ATOMIC_MASS[30]=65.39;
ATOMIC_MASS[31]=69.72;
ATOMIC_MASS[32]=72.61;
ATOMIC_MASS[33]=74.92;
ATOMIC_MASS[34]=78.96;
ATOMIC_MASS[35]=79.90;
ATOMIC_MASS[37]=85.47;
ATOMIC_MASS[38]=87.62;
ATOMIC_MASS[40]=91.22;
ATOMIC_MASS[47]=107.9;
ATOMIC_MASS[48]=112.4;
ATOMIC_MASS[49]=114.8;
ATOMIC_MASS[50]=118.7;
ATOMIC_MASS[51]=121.8;
ATOMIC_MASS[53]=126.9;
ATOMIC_MASS[54]=131.3;
ATOMIC_MASS[55]=132.9;
ATOMIC_MASS[56]=137.3;
ATOMIC_MASS[76]=190.2;
ATOMIC_MASS[78]=195.1;
ATOMIC_MASS[79]=197.0;
ATOMIC_MASS[80]=200.6;
ATOMIC_MASS[82]=207.2;
// 0.0 means an unused (for the purposes of the program) element.
}
| [
"[email protected]"
] | |
4c3d851095290156dae8c7a6b6ed398434da55d5 | dd6c7ebd047aa67aa266dfc7ef3f125dcaf9ed3a | /hazelcast/src/hazelcast/client/impl/ClientLockReferenceIdGenerator.cpp | f887630a8798b94571793c1635904b78ca3914af | [
"Apache-2.0"
] | permissive | skyend/hazelcast-cpp-client | e81009fa2b27cb53f33fe188b3205498ea7b5e11 | a62e1ce20e17cf2a69e236918860c467e03babba | refs/heads/master | 2020-04-22T00:17:51.954274 | 2019-02-13T09:17:54 | 2019-02-13T09:17:54 | 169,974,434 | 0 | 0 | Apache-2.0 | 2019-02-10T12:13:36 | 2019-02-10T12:13:36 | null | UTF-8 | C++ | false | false | 1,021 | cpp | /*
* Copyright (c) 2008-2018, Hazelcast, Inc. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "hazelcast/client/impl/ClientLockReferenceIdGenerator.h"
namespace hazelcast {
namespace client {
namespace impl {
ClientLockReferenceIdGenerator::ClientLockReferenceIdGenerator() : referenceIdCounter(0) {}
int64_t ClientLockReferenceIdGenerator::getNextReferenceId() {
return ++referenceIdCounter;
}
}
}
}
| [
"[email protected]"
] | |
1025db6a7b49bd6a91fd4d33bdf91b8f5055f999 | c50a42696afb6313e9029de4f4843c5e38da4f4f | /Controller/analyser.h | d5f7927659188bedb2cdc7c35763c8e35743fdfe | [] | no_license | Benjistep/onderzoekDelft | 23137818ae3dd07b1204ac17f9067c584599d73c | 9313f3462c56bf81c05f11fe3f57ff578254ed56 | refs/heads/master | 2016-09-01T06:33:38.800920 | 2016-01-04T17:51:53 | 2016-01-04T17:51:53 | 44,171,800 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 668 | h | #ifndef ANALYSER_H
#define ANALYSER_H
#include <vector>
#include <QDateTime>
#include "../Model/csvvector.h"
#include <QModelIndexList>
#include "result.h"
#include "Situations/situation.h"
class Analyser
{
private:
static map<int, vector<float>*>* selectData(CSVVector &data, QModelIndexList &indexList);
static void calcResult(CSVVector &data, map<int, vector<float>*>* allData, vector<Result*>& resultList);
static bool situationMatch(Situation& situation, CSVVector& data, map<int, vector<float>*>* allData);
public:
static Situation* analyse(CSVVector& data, QModelIndexList& indexList, vector<Situation*>& situations);
};
#endif // ANALYSER_H
| [
"[email protected]"
] | |
bd2d4c6b8aaceb93bb90231d185f240bd63c4458 | 28ecb9ae694562b5303ae96c0ca9f7ff13ec04aa | /so-easy-3/so-easy-3/so-easy-3.cpp | 49450e2d7409944233d8ffb59ba3dadc4b26dc78 | [
"MIT"
] | permissive | songemeng/Algorithm-exercise | 7c5ab3cf2b5de124f95c1fd39b7355bb7960f4eb | 81a8e377fecff8000afad2668aa58ae90a8bbc47 | refs/heads/master | 2021-09-14T20:45:46.739789 | 2018-05-19T02:03:25 | 2018-05-19T02:03:25 | null | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 220 | cpp | // so-easy-3.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <stdio.h>
int main()
{
long sum = 0;
for(int n = 1; n*n <= 1000; n++)
sum += n*n;
printf("%ld", sum);
return 0;
}
| [
"[email protected]"
] | |
72822565ebc2f8ef190c11ac6bc365401539e220 | 214dbcc732e0f6a49336164c793bd4af4754a6f7 | /Algorithmics/Problems from various contests/kafka.cpp | 59846f307aed6c83583168a0e7421f9b813f0b64 | [] | no_license | IrinaMBejan/Personal-work-contests | f878c25507a8bfdab3f7af8d55b780d7632efecb | 4ab2841244a55d074d25e721aefa56431e508c43 | refs/heads/master | 2021-01-20T08:24:47.492233 | 2017-05-03T12:22:26 | 2017-05-03T12:22:26 | 90,142,452 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 917 | cpp | #include <fstream>
using namespace std;
ifstream fin("kafka.in");
ofstream fout("kafka.out");
struct office
{
int cul;
int ok;
int birou;
} a[4001];
int main()
{
int nc,nb,bs,t,c,b,poz,i,gasit=0,k;
fin>>nb>>nc>>bs>>t;
c=1;
b=bs;
int nrp;
for(i=1; i<=nb*nb; i++)
fin>>a[i].cul>>a[i].birou;
for(i=1; i<t&&!gasit; i++)
{
poz=(b-1)*nc+c;
if(a[poz].ok==0)
{
c=a[poz].cul;
b=a[poz].birou;
a[poz].ok=i;
// fout<<poz<<'\n';
}
else
{
gasit=1;
nrp=(t-a[poz].ok+1)%(i-a[poz].ok);
// fout<<"!!!"<<poz<<'\n';
}
}
if(gasit)
for(k=1; k<nrp; k++)
{
poz=(b-1)*nc+c;
c=a[poz].cul;
b=a[poz].birou;
// fout<<b<<" "<<poz<<'\n';
}
fout<<b<<'\n';
return 0;
}
| [
"[email protected]"
] | |
432a301759cb2ff50540a2f01ec6dba33b1deebb | 2a1365c24292ee4ea235301a1ead0403062f4645 | /他人代码_硕/数据结构试验代码（大二上）/贪婪算法（实验13）/arrayQueue.h | 8cab5cc23c733df6a23ec10a3ecaec18fff1862d | [] | no_license | trialley/DataStructuresLabs | 0a10f5bb8afe63585b111a820cf8d3b552018bd1 | 0d2cf9931175b96190a317d1ea14dd18793faf76 | refs/heads/master | 2020-09-27T10:16:31.437406 | 2019-12-31T07:32:11 | 2019-12-31T07:32:11 | 226,492,210 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 2,661 | h | //本队列使用映射公式：location(i)=(location(队列首元素)+i)%arrayLength 即环形数组表示法
#pragma once
#include<iostream>
#include<cstdlib>
#include<algorithm>
template<class T>
class arrayQueue
{
public:
arrayQueue(int initialCapacity = 10)
{//构造函数
if(initialCapacity<0) std::cerr<<"队列长度必须大于0！"<<std::endl;
else{
Queue=new T[initialCapacity];
arrayLength=initialCapacity;
qFront=qBack=0; //这里是从Queue[1]开始插入元素
}
}
~arrayQueue() {delete [] Queue;}
bool empty() const
{
if(qFront==qBack) return true;
else return false;
}
int size() const
{
return (arrayLength+qBack-qFront)%arrayLength;
}
T& front()
{
if(empty()!=true)
return Queue[(qFront+1)%arrayLength];
else
{ std::cerr<<"队列为空"<<std::endl; }
}
T& back()
{
if(empty()!=true)
return Queue[qBack];
else
{ std::cerr<<"队列为空"<<std::endl; exit(1); }
}
T pop()
{//从队首删除元素
T *p=&front(); //这里已经判断了队列是否为空
T temp=(*p);
qFront=(qFront+1)%arrayLength;
(*p).~T(); //析构首元素好像不能表示int的删除...，就是无法恢复到初始化以前的状态
return temp;
}
void push(const T& ele)
{//从队尾添加元素
if( (qBack+1)%arrayLength==qFront )
{//队列将满，加倍数组长度
T *newQueue=new T[2*arrayLength];
int start=(qFront+1)%arrayLength;
if(start==0||start==1)
{//未形成环
std::copy(Queue+start,Queue+qBack+1,newQueue);
}
else
{//形成了环
std::copy(Queue+start,Queue+arrayLength,newQueue);
//复制第2段(start,队列末端，新队列起点）
std::copy(Queue,Queue+qBack+1,newQueue+(arrayLength-start));
//复制第1段（原队列首端，qback,新队列第arraylength-start个位置）
}
qFront=(arrayLength)*2-1;
qBack=arrayLength-1-1; //重新设置首尾游标
arrayLength=arrayLength*2;
delete [] Queue;
Queue=newQueue;
}
//把元素插入队列的尾部
qBack=(qBack+1)%arrayLength;
Queue[qBack]=ele;
}
void output()
{
for(int i=qFront;i<qBack;i++)
std::cout<<Queue[i];
std::cout<<std::endl;
}
private:
int qFront; //队列中第一个元素的前一个未知
int qBack; //队列最后一个元素的位置
int arrayLength; //队列的容量
T *Queue; //队列元素
};
| [
"[email protected]"
] | |
b01673088668d4fbd5bdddc84b722b86028053ea | b068450462f1e24341c62808b84a31bf1ee4b9e0 | /esp32WiFiConfig/esp32WiFiConfig.ino | 9ca7ebdc325d848a41cf09148fdb6e4ad0a7492b | [] | no_license | diogopdvfreitas/umc1819-iot | bad15a6bfba7ce3ee1ff268f5e2b2c1aff2abda6 | ff21fbf9922d203d2e064e99059181997245aa32 | refs/heads/master | 2022-01-15T10:33:26.188974 | 2019-07-15T16:06:03 | 2019-07-15T16:06:03 | 189,729,908 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 13,570 | ino | #include <WiFi.h>
#include <ESPmDNS.h>
#include <Preferences.h>
#include <PubSubClient.h>
/* --- GLOBAL VARIABLES --- */
Preferences preferences;
const int ARDUINO_N = 3;
const int BUTTON_KEY = 0;
const int LED_BUILTIN = 2;
/* --- WIFI CREDENTIALS VARAIBLES --- */
String recv_ssid;
String recv_pass;
IPAddress myIP;
IPAddress serverIP; int serverPort;
/* --- CONNECTION VARIABLES --- */
WiFiClient wifiClient;
PubSubClient client(wifiClient);
const String mqttUsers[] = {"tk3_esp1", "tk3_esp2", "tk3_esp3", "tk3_esp4"};
const String mqttPswrd[] = {"esp1mqtt", "esp2mqtt", "esp3mqtt", "esp4mqtt"};
const String mqttTopic = "mensapoll";
bool wifiConnected = false;
bool foundMQTTBroker = false;
bool mqttConnected = false;
/* --- POLL VARIABLES --- */
enum State{
NOPOLL, INITPOLL, AWAITVOTES, VOTE, VOTED, DECIDED
};
bool messageReceived = false;
String payloadMsgRecv = "";
const int LONG_PRESS = 3000;
const int NO_COUNT_INPUT = 2000;
int currButtonState = 0; // Button's current state
int lastButtonState = 1; // Button's state in the last loop
int timeStartPressed = 0; // Time the button was pressed
int timeEndPressed = 0; // Time the button was released
int timeHold = 0; // How long the button was held
int timeReleased = 0; // How long the button released
int timeLedChange = 0;
bool flagLEDBlink0 = false;
bool flagLEDBlink1 = false;
bool flagLEDBlink2 = false;
int nPollAccept = 0;
int votes = 0;
int decisionTime = 0;
/* --- AUXILIARY METHODS --- */
void ledOn(){
pinMode(LED_BUILTIN, OUTPUT);
digitalWrite(LED_BUILTIN, HIGH);
}
void ledOn(int nTime){
pinMode(LED_BUILTIN, OUTPUT);
int millis = nTime * 1000;
digitalWrite(LED_BUILTIN, HIGH); delay(millis); digitalWrite(LED_BUILTIN, LOW);
}
void ledOff(){
pinMode(LED_BUILTIN, OUTPUT);
digitalWrite(LED_BUILTIN, LOW);
}
void ledBlink(){
pinMode(LED_BUILTIN, OUTPUT);
if(digitalRead(LED_BUILTIN) == HIGH)
digitalWrite(LED_BUILTIN, LOW);
else
digitalWrite(LED_BUILTIN, HIGH);
timeLedChange = millis();
}
void ledBlink(int nTimes, int nTimeAppart){
pinMode(LED_BUILTIN, OUTPUT);
int millis = nTimeAppart * 1000;
for(int i = 0; i <= nTimes - 1; i++) {
digitalWrite(LED_BUILTIN, HIGH); delay(millis); digitalWrite(LED_BUILTIN, LOW); delay(millis);
}
}
void sendMessage(String message){
client.publish(mqttTopic.c_str(), message.c_str());
Serial.print("Message sent ["); Serial.print(mqttTopic); Serial.print("] ");
Serial.println(message);
}
void callback(char* topic, byte* payload, unsigned int length) {
Serial.print("Message arrived [");
Serial.print(topic);
Serial.print("] ");
for(int i = 0; i < length; i++) {
char c = (char)payload[i];
payloadMsgRecv += c;
Serial.print(c);
}
Serial.println();
messageReceived = true;
}
/* --- POLL CLASSES --- */
class PollState{
public:
PollState(){}
virtual void shortPress();
virtual void longPress();
virtual void finish();
virtual State getValue() = 0;
};
PollState* state;
bool initiator = false;
void changeState(State stt);
class State_NoPoll : public PollState{
public:
State_NoPoll(){
ledOff();
initiator = false;
nPollAccept = 0; votes = 0; decisionTime = 0;
flagLEDBlink0 = false; flagLEDBlink1 = false; flagLEDBlink2 = false;
Serial.println("Press button > 3s to initiate poll");
}
void shortPress(){}
void longPress(){
changeState(INITPOLL);
}
void finish(){}
State getValue(){ return NOPOLL; }
};
class State_InitPoll : public PollState{
private:
int presses = 0;
public:
State_InitPoll(){
initiator = true;
Serial.println("Initiating Poll Configuration");
Serial.println("Press the number of positives needed for poll success");
}
void shortPress(){
presses++;
Serial.print("N Times Pressed: "); Serial.println(presses);
}
void longPress(){}
void finish(){
Serial.print("Total Times Pressed: "); Serial.println(presses);
nPollAccept = presses;
ledBlink(presses, 1);
Serial.println("Poll Configuration Finished");
changeState(AWAITVOTES);
}
State getValue(){ return INITPOLL; }
};
class State_AwaitVotes : public PollState{
public:
State_AwaitVotes(){
String message = "POLL "; message += nPollAccept;
sendMessage(message);
Serial.println("Poll Initiated - Awaiting decision");
ledBlink(); flagLEDBlink2 = true;
}
void shortPress(){}
void longPress(){
Serial.println("Cancelling Poll");
sendMessage("CLEAR");
}
void finish(){}
State getValue(){ return AWAITVOTES; }
};
class State_Vote : public PollState{
public:
State_Vote(){
Serial.println("Poll was initiated by another client");
Serial.println("To accept poll press button, to deny long press");
ledBlink(); flagLEDBlink1 = true;
}
void shortPress(){
sendMessage("ACCEPT");
Serial.println("Voted yes on poll - Awaiting decision");
ledOn(); flagLEDBlink1 = false;
changeState(VOTED);
}
void longPress(){
Serial.println("Voted no on poll - Awaiting decision");
ledOff(); flagLEDBlink1 = false;
changeState(VOTED);
}
void finish(){}
State getValue(){ return VOTE; }
};
class State_Voted : public PollState{
public:
State_Voted(){}
void shortPress(){}
void longPress(){}
void finish(){}
State getValue(){ return VOTED; }
};
class State_Decided : public PollState{
public:
State_Decided(){
Serial.println("Decision made - Poll Accepted");
decisionTime = millis();
ledBlink(); flagLEDBlink0 = true;
}
void shortPress(){}
void longPress(){
if(initiator){
Serial.println("Cancelling Poll");
sendMessage("CLEAR");
}
}
void finish(){}
State getValue(){ return DECIDED; }
};
/* --- SETUP & SETUP_AUX METHODS --- */
void setup(){
Serial.begin(115200);
preferences.begin("iotk", false);
delay(2000);
if(receiveCredentials() == true) {
storeCredentials();
ESP.restart();
}
else {
Serial.println("No WiFi Credentials were received");
Serial.println("Using WiFi Credentials stored in memory");
}
String ssid = getStoredSSID();
String pass = getStoredPassword();
for(int i = 0; !initWiFiConn(ssid, pass); i++){ if(i == 1) break; }
if(wifiConnected){
if(!MDNS.begin("ESP")){
Serial.println("Error setting up mDNS responder");
}
else {
Serial.println("Finished setup of mDNS");
for(int i = 0; !browseService("mqtt", "tcp"); i++){ if(i == 2) break; }
if(foundMQTTBroker){
client.setServer(serverIP, serverPort);
client.setCallback(callback);
for(int i = 0; !mqttConnect(); i++){ if(i == 2) break; }
if(mqttConnected){
client.subscribe(mqttTopic.c_str());
Serial.print("Client subscribed to topic "); Serial.print(mqttTopic);
Serial.println(" - Awaiting messages...");
pinMode(BUTTON_KEY, INPUT);
changeState(NOPOLL);
}
else
WiFi.disconnect();
}
else
WiFi.disconnect();
}
}
/* Close the Preferences */
preferences.end();
}
bool receiveCredentials(){
Serial.println();
Serial.println("Waiting for WiFi Credentials");
/*SSID input*/
Serial.print("SSID: ");
int count = 0;
while(Serial.available() == 0) {
delay(1000);
if(count == 10)
return false;
count++;
}
recv_ssid = Serial.readString();
if(recv_ssid[recv_ssid.length() - 1] == '\n')
recv_ssid[recv_ssid.length() - 1] = '\0';
Serial.println(recv_ssid);
/*Password input*/
Serial.print("Password: ");
while (Serial.available() == 0);
recv_pass = Serial.readString();
if(recv_pass[recv_pass.length() - 1] == '\n')
recv_pass[recv_pass.length() - 1] = '\0';
return true;
}
void storeCredentials(){
preferences.clear();
preferences.putString("ssid", recv_ssid);
preferences.putString("pass", recv_pass);
Serial.println("Credentials successfully stored in memory");
}
String getStoredSSID(){
String ssid = preferences.getString("ssid");
Serial.println("Stored SSID: " + ssid);
return ssid;
}
String getStoredPassword(){
String pass = preferences.getString("pass");
Serial.println("Stored Password: " + pass);
return pass;
}
bool initWiFiConn(String ssid, String pass){
/*Connecting to WiFi*/
WiFi.begin(ssid.c_str(), pass.c_str());
/*A delay is needed so we only continue with the program until the ESP32 is effectively connected to the WiFi network*/
int count = 0;
while(WiFi.status() != WL_CONNECTED) {
delay(1000);
Serial.print(".");
if(count == 20) {
Serial.println();
break;
}
count++;
}
if(WiFi.status() == WL_CONNECTED) {
Serial.println();
Serial.println("WiFi Connected.");
Serial.print("IP Address: ");
myIP = WiFi.localIP();
Serial.println(myIP);
ledOn(10);
wifiConnected = true; return true;
}
else {
Serial.println("Connection Attempt Failed");
ledBlink(10, 1);
wifiConnected = false; return false;
}
}
bool browseService(const char * service, const char * proto){
Serial.printf("Browsing for service _%s._%s.local. ... ", service, proto);
int n = MDNS.queryService(service, proto);
if (n == 0) {
Serial.println("No services found");
foundMQTTBroker = false; return false;
}
else {
Serial.print(n);
Serial.println(" service(s) found");
for (int i = 0; i < n; ++i) {
// Print details for each service found
Serial.print(" ");
Serial.print(i + 1);
Serial.print(": ");
Serial.print(MDNS.hostname(i));
Serial.print(" (");
Serial.print(MDNS.IP(i)); serverIP = MDNS.IP(i);
Serial.print(":");
Serial.print(MDNS.port(i)); serverPort = MDNS.port(i);
Serial.println(")");
}
foundMQTTBroker = true; return true;
}
}
bool mqttConnect(){
String id = "ESP32_K"; id += ARDUINO_N;
if(client.connect(id.c_str(), mqttUsers[ARDUINO_N-1].c_str(), mqttPswrd[ARDUINO_N-1].c_str())) {
Serial.println("Client " + id + " connected to server");
Serial.println();
mqttConnected = true; return true;
}
else {
Serial.println("Unable to connect to server");
mqttConnected = false; return false;
}
}
/* --- LOOP & LOOP_AUX METHODS --- */
void loop(){
if(mqttConnected) {
client.loop();
currButtonState = digitalRead(BUTTON_KEY);
if(currButtonState != lastButtonState) {
updateButtonState();
if(currButtonState == HIGH && timeHold <= LONG_PRESS){
state->shortPress();
}
if(currButtonState == HIGH && timeHold >= LONG_PRESS){
state->longPress();
}
}
else {
updateButtonCounter();
if(state->getValue() == INITPOLL && timeReleased >= NO_COUNT_INPUT){
state->finish();
}
}
int ledChangeElapsedTime = millis() - timeLedChange;
if( (flagLEDBlink0 && ledChangeElapsedTime == 500) ||
(flagLEDBlink1 && ledChangeElapsedTime == 1000) ||
(flagLEDBlink2 && ledChangeElapsedTime == 2000) ){
ledBlink();
}
if(messageReceived){
if(payloadMsgRecv.substring(0,4) == "POLL" && state->getValue() == NOPOLL){
nPollAccept = payloadMsgRecv.substring(5).toInt();
changeState(VOTE);
}
if(payloadMsgRecv == "ACCEPT"){
incrementVotes();
}
if(payloadMsgRecv == "CLEAR"){
Serial.println("Poll Cancelled by the host");
changeState(NOPOLL);
}
messageReceived = false;
payloadMsgRecv = "";
}
if(initiator && state->getValue() == DECIDED){
int decisionElapsedTime = millis() - decisionTime;
if(decisionElapsedTime >= 300000) {
sendMessage("CLEAR");
}
}
lastButtonState = currButtonState;
}
}
void updateButtonState(){
/* LOW == Button Pressed
HIGH == Button Released */
if(currButtonState == LOW) {
timeStartPressed = millis(); // Registers the time the button was pressed
timeReleased = timeStartPressed - timeEndPressed; // Registers how long the button was released
}
else {
timeEndPressed = millis(); // Registers the time the button was released
timeHold = timeEndPressed - timeStartPressed; // Registers how long the button was held down
}
}
void updateButtonCounter(){
if(currButtonState == LOW)
timeHold = millis() - timeStartPressed; // Registers for how long the button has been pressed currently
else
timeReleased = millis() - timeEndPressed; // Registers for how long the button has been released currently
}
void changeState(State stt){
switch(stt){
case NOPOLL:
state = new State_NoPoll();
break;
case INITPOLL:
state = new State_InitPoll();
break;
case AWAITVOTES:
state = new State_AwaitVotes();
break;
case VOTE:
state = new State_Vote();
break;
case VOTED:
state = new State_Voted();
break;
case DECIDED:
state = new State_Decided();
break;
}
}
void incrementVotes(){
votes++;
Serial.print("Current Number of votes: "); Serial.println(votes);
if(votes == nPollAccept) {
changeState(DECIDED);
}
} | [
"[email protected]"
] | |
507ef741539f271dcffdfbc78e7478a46ad2ecda | 0e893e9973555651b56f8199d2969e39da7684da | /LoveBabbar's Sheet/Binary Trees/1.cpp | f5467d9ddc77e3a224bf67dbd9ec2e73d4913016 | [] | no_license | Ayush23Dash/C-plus-plus--Repository | e632c06a07c33cf0ea8e299a8134002df28f4cc8 | 854f9aa9b41926a65b1cf63d7290a0d0ac2fbb84 | refs/heads/master | 2022-08-19T18:03:43.095061 | 2022-08-16T12:59:24 | 2022-08-16T12:59:24 | 222,396,924 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 703 | cpp | class Solution
{
public:
//Function to return the level order traversal of a tree.
vector<int> levelOrder(Node* node)
{
//Your code here
vector<int>ans;
if(node == NULL) return ans;
queue<Node *>q;
q.push(node);
while(!q.empty()){
int sz = q.size();
// vector<int>level;
for(int i=0;i<sz;i++){
Node* currentNode = q.front();
if(currentNode->left!=NULL) q.push(currentNode->left);
if(currentNode->right!=NULL) q.push(currentNode->right);
ans.push_back(currentNode->data);
q.pop();
}
}
return ans;
}
}; | [
"[email protected]"
] | |
59de3f6d3680f9ee25b5943debeae7be580954de | 3f74c510cfa78d25ca8e80d070d2538fe2abe76b | /complx/ComplxFrame.hpp | 3fd50907eb38eb3b64eb3d222446209180c01b33 | [] | no_license | brising3/complx | e3f0e4da6af03ab4c2760bbc34ff4bd1004a4add | 5164df0e334ee949e27edf59c6150957653c298b | refs/heads/master | 2020-12-30T22:55:27.326799 | 2014-02-02T22:19:45 | 2014-02-02T22:19:45 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,432 | hpp | #ifndef COMPLEX_FRAME_HPP
#define COMPLEX_FRAME_HPP
#include <wx/grid.h>
#include <wx/textctrl.h>
#include <wx/event.h>
#include <wx/window.h>
#include <wx/filename.h>
#include "ComplxFrameDecl.h"
#include "LC3Console.hpp"
#include "MemoryView.hpp"
#include "MemoryViewFrame.hpp"
enum
{
BASE_2,
BASE_10,
BASE_16,
NUM_BASES,
BASE_CC,
};
class wxThreadEvent;
class ComplxFrame : public ComplxFrameDecl
{
public:
ComplxFrame(long decimal, long disassemble, long stack_size, long true_traps, long interrupts, long highlight, wxString address_str, wxString state_file, wxArrayString files);
~ComplxFrame();
// File menu event handlers
void OnRandomizeAndLoad(wxCommandEvent& event);
void OnRandomizeAndReload(wxCommandEvent& event);
void OnLoad(wxCommandEvent& event);
void OnReload(wxCommandEvent& event);
void OnLoadOver(wxCommandEvent& event);
void OnReloadOver(wxCommandEvent& event);
void OnLoadMachine(wxCommandEvent& event);
void OnSaveMachine(wxCommandEvent& event);
void OnQuit(wxCommandEvent& event);
// View menu event handlers
void OnNewView(wxCommandEvent& event);
void OnGoto(wxCommandEvent& event);
void OnDumbDisassemble(wxCommandEvent& event);
void OnNormalDisassemble(wxCommandEvent& event);
void OnCDisassemble(wxCommandEvent& event);
void OnInstructionHighlight(wxCommandEvent& event);
void OnUnsignedDecimal(wxCommandEvent& event);
// Helpers for view menu actions
void OnDestroyView(wxCloseEvent& event);
// State menu event handlers
void OnStep(wxCommandEvent& event);
void OnBackStep(wxCommandEvent& event);
void OnNextLine(wxCommandEvent& event);
void OnPrevLine(wxCommandEvent& event);
void OnRun(wxCommandEvent& event);
void OnRunFor(wxCommandEvent& event);
void OnRunAgain(wxCommandEvent& event);
void OnRewind(wxCommandEvent& event);
void OnFinish(wxCommandEvent& event);
void OnRandomize(wxCommandEvent& event);
void OnReinitialize(wxCommandEvent& event);
void OnTrueTraps(wxCommandEvent& event);
void OnInterrupts(wxCommandEvent& event);
void OnClearConsole(wxCommandEvent& event);
void OnClearConsoleInput(wxCommandEvent& event);
// Helpers
void OnTextKillFocus(wxFocusEvent& event);
void OnBaseChange(wxMouseEvent& event);
void OnEditAddress(wxCommandEvent& event);
void OnRegisterChanged(wxCommandEvent& text);
// Debug menu event handlers
void OnUndoStack(wxCommandEvent& event);
void OnCallStack(wxCommandEvent& event);
void OnBreakAndWatchpoints(wxCommandEvent& event);
void OnTemppoint(wxCommandEvent& event);
void OnBreakpoint(wxCommandEvent& event);
void OnWatchpoint(wxCommandEvent& event);
void OnAdvancedBreakpoint(wxCommandEvent& event);
void OnBlackbox(wxCommandEvent& event);
// Testing menu event handlers
void OnRunTests(wxCommandEvent& event);
void OnRerunTests(wxCommandEvent& event);
bool TryLoadTests(lc3_test_suite& suite, const wxString& path);
// Help menu event handlers
void OnDocs(wxCommandEvent& event);
void OnISA(wxCommandEvent& event);
void OnChangeLog(wxCommandEvent& event);
void OnCheckForUpdates(wxCommandEvent& event);
void OnAbout(wxCommandEvent& event);
void OnFirstTime(wxCommandEvent& event);
void OnTips(wxCommandEvent& event);
// Misc event handlers required for THINGS.
void OnActivate(wxActivateEvent& event);
void OnIdle(wxIdleEvent& event);
void OnRunUpdate(wxThreadEvent& event);
void OnRunComplete(wxThreadEvent& event);
void OnIo(wxThreadEvent& event);
void OnOutput(wxThreadEvent& event);
void OnNoIo(wxThreadEvent& event);
// Other methods
void OnGetIo();
void UpdatePlay(void);
void UpdatePhrase(const wxString& message);
void UpdateRegisters(void);
void UpdateMemory(void);
void UpdateStatus(void);
bool Running();
private:
LC3Console* console;
std::vector<MemoryViewFrame*> views;
MemoryView* memoryView;
long stack_size;
void UpdateRegister(wxTextCtrl* text, int value, int index);
void OnInit(void);
void SetupExecution(int run_mode, int runtime = -1);
void DoLoadMachine(const wxFileName& filename);
void DoLoadFile(const wxFileName& filename);
};
#endif
| [
"[email protected]"
] | |
387f94196b9b451a2e27a2abd81aac5518a958f3 | 711e5c8b643dd2a93fbcbada982d7ad489fb0169 | /XPSP1/NT/base/screg/sc/client/scapi.cxx | f32aade0213d990daf482198a200857629783e15 | [] | no_license | aurantst/windows-XP-SP1 | 629a7763c082fd04d3b881e0d32a1cfbd523b5ce | d521b6360fcff4294ae6c5651c539f1b9a6cbb49 | refs/heads/master | 2023-03-21T01:08:39.870106 | 2020-09-28T08:10:11 | 2020-09-28T08:10:11 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 82,528 | cxx | /*++
Copyright (c) 1990-1992 Microsoft Corporation
Module Name:
scapi.c
Abstract:
Contains the Service-related API that are implemented solely in
DLL form. These include:
StartServiceCtrlDispatcherA
StartServiceCtrlDispatcherW
RegisterServiceCtrlHandlerW
RegisterServiceCtrlHandlerA
RegisterServiceCtrlHandlerExW
RegisterServiceCtrlHandlerExA
This file also contains the following local support routines:
ScDispatcherLoop
ScCreateDispatchTableW
ScCreateDispatchTableA
ScReadServiceParms
ScConnectServiceController
ScExpungeMessage
ScGetPipeInput
ScGetDispatchEntry
ScNormalizeCmdLineArgs
ScSendResponse
ScSvcctrlThreadW
ScSvcctrlThreadA
RegisterServiceCtrlHandlerHelp
Author:
Dan Lafferty (danl) 09 Apr-1991
Environment:
User Mode -Win32
Revision History:
12-May-1999 jschwart
Convert SERVICE_STATUS_HANDLE to a context handle to fix security
hole (any service can call SetServiceStatus with another service's
handle and succeed)
10-May-1999 jschwart
Create a separate named pipe per service to fix security hole (any
process could flood the pipe since the name was well-known -- pipe
access is now limited to the service account and LocalSystem)
10-Mar-1998 jschwart
Add code to allow services to receive Plug-and-Play control messages
and unpack the message arguments from the pipe
30-Sep-1997 jschwart
StartServiceCtrlDispatcher: If this function [A or W] has already been
called from within this process, return ERROR_SERVICE_ALREADY_RUNNING.
Otherwise, can be destructive (e.g., overwrite AnsiFlag, etc.)
06-Aug-1997 jschwart
ScDispatcherLoop: If the service is processing a shutdown command from
the SCM, it no longer writes the status back to the SCM since the SCM is
now using WriteFile on system shutdown (see control.cxx for more info).
03-Jun-1996 AnirudhS
ScGetPipeInput: If the message received from the service controller
is not a SERVICE_CONTROL_START message, don't allocate space for the
arguments, since there are none, and since that space never gets freed.
22-Sep-1995 AnirudhS
Return codes from InitializeStatusBinding were not being handled
correctly; success was sometimes reported on failure. Fixed this.
12-Aug-1993 Danl
ScGetDispatchEntry: When the first entry in the table is marked as
OwnProcess, then this function should just return the pointer to the
top of the table. It should ignore the ServiceName. In all cases,
when the service is started as an OWN_PROCESS, only the first entry
in the dispath table should be used.
04-Aug-1992 Danl
When starting a service, always pass the service name as the
first parameter in the argument list.
27-May-1992 JohnRo
RAID 9829: winsvc.h and related file cleanup.
09 Apr-1991 danl
created
--*/
//
// INCLUDES
//
#include <scpragma.h>
extern "C"
{
#include <nt.h> // DbgPrint prototype
#include <ntrtl.h> // DbgPrint prototype
#include <nturtl.h> // needed for winbase.h
}
#include <rpc.h> // DataTypes and runtime APIs
#include <windef.h> // windows types needed for winbase.h
#include <winbase.h> // CreateFile
#include <winuser.h> // wsprintf()
#include <winreg.h> // RegOpenKeyEx / RegQueryValueEx
#include <string.h> // strcmp
#include <stdlib.h> // wide character c runtimes.
#include <tstr.h> // WCSSIZE().
#include <winsvc.h> // public Service Controller Interface.
#include "scbind.h" // InitializeStatusBinding
#include <valid.h> // MAX_SERVICE_NAME_LENGTH
#include <control.h> // CONTROL_PIPE_NAME
#include <scdebug.h> // STATIC
#include <sclib.h> // ScConvertToUnicode
//
// Internal Dispatch Table.
//
//
// Bit flags for the dispatch table's dwFlags field
//
#define SERVICE_OWN_PROCESS 0x00000001
#define SERVICE_EX_HANDLER 0x00000002
typedef union _START_ROUTINE_TYPE {
LPSERVICE_MAIN_FUNCTIONW U; // unicode type
LPSERVICE_MAIN_FUNCTIONA A; // ansi type
} START_ROUTINE_TYPE, *LPSTART_ROUTINE_TYPE;
typedef union _HANDLER_FUNCTION_TYPE {
LPHANDLER_FUNCTION Regular; // Regular version
LPHANDLER_FUNCTION_EX Ex; // Extended version
} HANDLER_FUNCTION_TYPE, *LPHANDLER_FUNCTION_TYPE;
typedef struct _INTERNAL_DISPATCH_ENTRY {
LPWSTR ServiceName;
LPWSTR ServiceRealName; // In case the names are different
START_ROUTINE_TYPE ServiceStartRoutine;
HANDLER_FUNCTION_TYPE ControlHandler;
SC_HANDLE StatusHandle;
DWORD dwFlags;
PVOID pContext;
} INTERNAL_DISPATCH_ENTRY, *LPINTERNAL_DISPATCH_ENTRY;
//
// This structure is passed to the internal
// startup thread which calls the real user
// startup routine with argv, argc parameters.
//
typedef struct _THREAD_STARTUP_PARMSW {
DWORD NumArgs;
LPSERVICE_MAIN_FUNCTIONW ServiceStartRoutine;
LPWSTR VectorTable;
} THREAD_STARTUP_PARMSW, *LPTHREAD_STARTUP_PARMSW;
typedef struct _THREAD_STARTUP_PARMSA {
DWORD NumArgs;
LPSERVICE_MAIN_FUNCTIONA ServiceStartRoutine;
LPSTR VectorTable;
} THREAD_STARTUP_PARMSA, *LPTHREAD_STARTUP_PARMSA;
//
// This structure contains the arguments passed
// to a service's extended control handler
//
typedef struct _HANDLEREX_PARMS {
DWORD dwEventType;
LPVOID lpEventData;
} HANDLEREX_PARMS, *LPHANDLEREX_PARMS;
//
// This union contains the arguments to the service
// passed from the server via named pipe
//
typedef union _SERVICE_PARAMS {
THREAD_STARTUP_PARMSW ThreadStartupParms;
HANDLEREX_PARMS HandlerExParms;
} SERVICE_PARAMS, *LPSERVICE_PARAMS;
//
// The following is the amount of time we will wait for the named pipe
// to become available from the Service Controller.
//
#ifdef DEBUG
#define CONTROL_WAIT_PERIOD NMPWAIT_WAIT_FOREVER
#else
#define CONTROL_WAIT_PERIOD 15000 // 15 seconds
#endif
//
// This is the number of times we will continue to loop when pipe read
// failures occur. After this many tries, we cease to read the pipe.
//
#define MAX_RETRY_COUNT 30
//
// Globals
//
LPINTERNAL_DISPATCH_ENTRY DispatchTable=NULL; // table head.
//
// This flag is set to TRUE if the control dispatcher is to support
// ANSI calls. Otherwise the flag is set to FALSE.
//
BOOL AnsiFlag = FALSE;
//
// This variable makes sure StartServiceCtrlDispatcher[A,W] doesn't
// get called twice by the same process, since this is destructive.
// It is initialized to 0 by the linker
//
LONG g_fCalledBefore;
//
// Are we running in the security process?
//
BOOL g_fIsSecProc;
#if defined(_X86_)
//
// Are we running inside a Wow64 process (on Win64)
//
BOOL g_fWow64Process = FALSE;
#endif
//
// Internal Functions
//
DWORD
ScCreateDispatchTableW(
IN CONST SERVICE_TABLE_ENTRYW *UserDispatchTable,
OUT LPINTERNAL_DISPATCH_ENTRY *DispatchTablePtr
);
DWORD
ScCreateDispatchTableA(
IN CONST SERVICE_TABLE_ENTRYA *UserDispatchTable,
OUT LPINTERNAL_DISPATCH_ENTRY *DispatchTablePtr
);
DWORD
ScReadServiceParms(
IN LPCTRL_MSG_HEADER Msg,
IN DWORD dwNumBytesRead,
OUT LPBYTE *ppServiceParams,
OUT LPBYTE *ppTempArgPtr,
OUT LPDWORD lpdwRemainingArgBytes
);
VOID
ScDispatcherLoop(
IN HANDLE PipeHandle,
IN LPCTRL_MSG_HEADER Msg,
IN DWORD dwBufferSize
);
DWORD
ScConnectServiceController (
OUT LPHANDLE pipeHandle
);
VOID
ScExpungeMessage(
IN HANDLE PipeHandle
);
DWORD
ScGetPipeInput (
IN HANDLE PipeHandle,
IN OUT LPCTRL_MSG_HEADER Msg,
IN DWORD dwBufferSize,
OUT LPSERVICE_PARAMS *ppServiceParams
);
DWORD
ScGetDispatchEntry (
OUT LPINTERNAL_DISPATCH_ENTRY *DispatchEntry,
IN LPWSTR ServiceName
);
VOID
ScNormalizeCmdLineArgs(
IN OUT LPCTRL_MSG_HEADER Msg,
IN OUT LPTHREAD_STARTUP_PARMSW ThreadStartupParms
);
VOID
ScSendResponse (
IN HANDLE pipeHandle,
IN DWORD Response,
IN DWORD dwHandlerRetVal
);
DWORD
ScSvcctrlThreadW(
IN LPTHREAD_STARTUP_PARMSW lpThreadStartupParms
);
DWORD
ScSvcctrlThreadA(
IN LPTHREAD_STARTUP_PARMSA lpThreadStartupParms
);
SERVICE_STATUS_HANDLE
WINAPI
RegisterServiceCtrlHandlerHelp (
IN LPCWSTR ServiceName,
IN HANDLER_FUNCTION_TYPE ControlHandler,
IN PVOID pContext,
IN DWORD dwFlags
);
#if defined(_X86_)
//
// Detect if the current process is a 32-bit process running on Win64.
//
VOID DetectWow64Process()
{
NTSTATUS NtStatus;
PVOID Peb32;
NtStatus = NtQueryInformationProcess(NtCurrentProcess(),
ProcessWow64Information,
&Peb32,
sizeof(Peb32),
NULL);
if (NT_SUCCESS(NtStatus) && (Peb32 != NULL))
{
g_fWow64Process = TRUE;
}
}
#endif
extern "C" {
//
// Private function for lsass.exe that tells us we're running
// in the security process
//
VOID
I_ScIsSecurityProcess(
VOID
)
{
g_fIsSecProc = TRUE;
}
//
// Private function for PnP that looks up a service's REAL
// name given its context handle
//
DWORD
I_ScPnPGetServiceName(
IN SERVICE_STATUS_HANDLE hServiceStatus,
OUT LPWSTR lpServiceName,
IN DWORD cchBufSize
)
{
DWORD dwError = ERROR_SERVICE_NOT_IN_EXE;
ASSERT(cchBufSize >= MAX_SERVICE_NAME_LENGTH);
//
// Search the dispatch table.
//
if (DispatchTable != NULL)
{
LPINTERNAL_DISPATCH_ENTRY dispatchEntry;
for (dispatchEntry = DispatchTable;
dispatchEntry->ServiceName != NULL;
dispatchEntry++)
{
//
// Note: SC_HANDLE and SERVICE_STATUS_HANDLE were originally
// different handle types -- they are now the same as
// per the fix for bug #120359 (SERVICE_STATUS_HANDLE
// fix outlined in the file comments above), so this
// cast is OK.
//
if (dispatchEntry->StatusHandle == (SC_HANDLE)hServiceStatus)
{
ASSERT(dispatchEntry->ServiceRealName != NULL);
ASSERT(wcslen(dispatchEntry->ServiceRealName) < cchBufSize);
wcscpy(lpServiceName, dispatchEntry->ServiceRealName);
dwError = NO_ERROR;
break;
}
}
}
return dwError;
}
} // extern "C"
BOOL
WINAPI
StartServiceCtrlDispatcherA (
IN CONST SERVICE_TABLE_ENTRYA * lpServiceStartTable
)
/*++
Routine Description:
This function provides the ANSI interface for the
StartServiceCtrlDispatcher function.
Arguments:
Return Value:
--*/
{
DWORD status;
NTSTATUS ntstatus;
HANDLE pipeHandle;
//
// Make sure this is the only time the control dispatcher is being called
//
if (InterlockedExchange(&g_fCalledBefore, 1) == 1) {
//
// Problem -- the control dispatcher was already called from this process
//
SetLastError(ERROR_SERVICE_ALREADY_RUNNING);
return(FALSE);
}
//
// Set the AnsiFlag to indicate that the control dispatcher must support
// ansi function calls only.
//
AnsiFlag = TRUE;
//
// Create an internal DispatchTable.
//
status = ScCreateDispatchTableA(
(LPSERVICE_TABLE_ENTRYA)lpServiceStartTable,
(LPINTERNAL_DISPATCH_ENTRY *)&DispatchTable);
if (status != NO_ERROR) {
SetLastError(status);
return(FALSE);
}
//
// Allocate a buffer big enough to contain at least the control message
// header and a service name. This ensures that if the message is not
// a message with arguments, it can be read in a single ReadFile.
//
BYTE bPipeMessageHeader[sizeof(CTRL_MSG_HEADER) +
(MAX_SERVICE_NAME_LENGTH+1) * sizeof(WCHAR)];
//
// Connect to the Service Controller
//
status = ScConnectServiceController (&pipeHandle);
if (status != NO_ERROR) {
goto CleanExit;
}
//
// Initialize the binding for the status interface (NetServiceStatus).
//
SCC_LOG(TRACE,"Initialize the Status binding\n",0);
ntstatus = InitializeStatusBinding();
if (ntstatus != STATUS_SUCCESS) {
status = RtlNtStatusToDosError(ntstatus);
CloseHandle(pipeHandle);
goto CleanExit;
}
//
// Enter the dispatcher loop where we service control requests until
// all services in the service table have terminated.
//
ScDispatcherLoop(pipeHandle,
(LPCTRL_MSG_HEADER)&bPipeMessageHeader,
sizeof(bPipeMessageHeader));
CloseHandle(pipeHandle);
CleanExit:
//
// Clean up the dispatch table. Since we created unicode versions
// of all the service names, in ScCreateDispatchTableA, we now need to
// free them.
//
if (DispatchTable != NULL) {
LPINTERNAL_DISPATCH_ENTRY dispatchEntry;
//
// If they're different, it's because we allocated the real name.
// Only check the first entry since this can only happen in the
// SERVICE_OWN_PROCESS case
//
if (DispatchTable->ServiceName != DispatchTable->ServiceRealName) {
LocalFree(DispatchTable->ServiceRealName);
}
for (dispatchEntry = DispatchTable;
dispatchEntry->ServiceName != NULL;
dispatchEntry++) {
LocalFree(dispatchEntry->ServiceName);
}
LocalFree(DispatchTable);
}
if (status != NO_ERROR) {
SetLastError(status);
return(FALSE);
}
return(TRUE);
}
BOOL
WINAPI
StartServiceCtrlDispatcherW (
IN CONST SERVICE_TABLE_ENTRYW * lpServiceStartTable
)
/*++
Routine Description:
This is the Control Dispatcher thread. We do not return from this
function call until the Control Dispatcher is told to shut down.
The Control Dispatcher is responsible for connecting to the Service
Controller's control pipe, and receiving messages from that pipe.
The Control Dispatcher then dispatches the control messages to the
correct control handling routine.
Arguments:
lpServiceStartTable - This is a pointer to the top of a service dispatch
table that the service main process passes in. Each table entry
contains pointers to the ServiceName, and the ServiceStartRotuine.
Return Value:
NO_ERROR - The Control Dispatcher successfully terminated.
ERROR_INVALID_DATA - The specified dispatch table does not contain
entries in the proper format.
ERROR_FAILED_SERVICE_CONTROLLER_CONNECT - The Control Dispatcher
could not connect with the Service Controller.
ERROR_SERVICE_ALREADY_RUNNING - The function has already been called
from within the current process
--*/
{
DWORD status;
NTSTATUS ntStatus;
HANDLE pipeHandle;
//
// Make sure this is the only time the control dispatcher is being called
//
if (InterlockedExchange(&g_fCalledBefore, 1) == 1) {
//
// Problem -- the control dispatcher was already called from this process
//
SetLastError(ERROR_SERVICE_ALREADY_RUNNING);
return(FALSE);
}
//
// Create the Real Dispatch Table
//
__try {
status = ScCreateDispatchTableW((LPSERVICE_TABLE_ENTRYW)lpServiceStartTable, &DispatchTable);
}
__except (EXCEPTION_EXECUTE_HANDLER) {
status = GetExceptionCode();
if (status != EXCEPTION_ACCESS_VIOLATION) {
SCC_LOG(ERROR,"StartServiceCtrlDispatcherW:Unexpected Exception 0x%lx\n",status);
}
}
if (status != NO_ERROR) {
SetLastError(status);
return(FALSE);
}
//
// Allocate a buffer big enough to contain at least the control message
// header and a service name. This ensures that if the message is not
// a message with arguments, it can be read in a single ReadFile.
//
BYTE bPipeMessageHeader[sizeof(CTRL_MSG_HEADER) +
(MAX_SERVICE_NAME_LENGTH+1) * sizeof(WCHAR)];
//
// Connect to the Service Controller
//
status = ScConnectServiceController(&pipeHandle);
if (status != NO_ERROR) {
//
// If they're different, it's because we allocated the real name.
// Only check the first entry since this can only happen in the
// SERVICE_OWN_PROCESS case
//
if (DispatchTable->ServiceName != DispatchTable->ServiceRealName) {
LocalFree(DispatchTable->ServiceRealName);
}
LocalFree(DispatchTable);
SetLastError(status);
return(FALSE);
}
//
// Initialize the binding for the status interface (NetServiceStatus).
//
SCC_LOG(TRACE,"Initialize the Status binding\n",0);
ntStatus = InitializeStatusBinding();
if (ntStatus != STATUS_SUCCESS) {
status = RtlNtStatusToDosError(ntStatus);
CloseHandle(pipeHandle);
//
// If they're different, it's because we allocated the real name.
// Only check the first entry since this can only happen in the
// SERVICE_OWN_PROCESS case
//
if (DispatchTable->ServiceName != DispatchTable->ServiceRealName) {
LocalFree(DispatchTable->ServiceRealName);
}
LocalFree(DispatchTable);
SetLastError(status);
return(FALSE);
}
//
// Enter the dispatcher loop where we service control requests until
// all services in the service table have terminated.
//
ScDispatcherLoop(pipeHandle,
(LPCTRL_MSG_HEADER)&bPipeMessageHeader,
sizeof(bPipeMessageHeader));
CloseHandle(pipeHandle);
//
// If they're different, it's because we allocated the real name.
// Only check the first entry since this can only happen in the
// SERVICE_OWN_PROCESS case
//
if (DispatchTable->ServiceName != DispatchTable->ServiceRealName) {
LocalFree(DispatchTable->ServiceRealName);
}
return(TRUE);
}
VOID
ScDispatcherLoop(
IN HANDLE PipeHandle,
IN LPCTRL_MSG_HEADER Msg,
IN DWORD dwBufferSize
)
/*++
Routine Description:
This is the input loop that the Control Dispatcher stays in through-out
its life. Only two types of events will cause us to leave this loop:
1) The service controller instructed the dispatcher to exit.
2) The dispatcher can no longer communicate with the the
service controller.
Arguments:
PipeHandle: This is a handle to the pipe over which control
requests are received.
Return Value:
none
--*/
{
DWORD status;
DWORD controlStatus;
BOOL continueDispatch;
LPWSTR serviceName = NULL;
LPSERVICE_PARAMS lpServiceParams;
LPTHREAD_START_ROUTINE threadAddress = NULL;
LPVOID threadParms = NULL;
LPTHREAD_STARTUP_PARMSA lpspAnsiParms;
LPINTERNAL_DISPATCH_ENTRY dispatchEntry = NULL;
DWORD threadId;
HANDLE threadHandle;
DWORD i;
DWORD errorCount = 0;
DWORD dwHandlerRetVal = NO_ERROR;
//
// Input Loop
//
continueDispatch = TRUE;
#if defined(_X86_)
//
// Detect if this is a Wow64 Process ?
//
DetectWow64Process();
#endif
do {
//
// Wait for input
//
controlStatus = ScGetPipeInput(PipeHandle,
Msg,
dwBufferSize,
&lpServiceParams);
//
// If we received good input, check to see if we are to shut down
// the ControlDispatcher. If not, then obtain the dispatchEntry
// from the dispatch table.
//
if (controlStatus == NO_ERROR) {
//
// Clear the error count
//
errorCount = 0;
serviceName = (LPWSTR) ((LPBYTE)Msg + Msg->ServiceNameOffset);
SCC_LOG(TRACE, "Read from pipe succeeded for service %ws\n", serviceName);
if ((serviceName[0] == L'\0') &&
(Msg->OpCode == SERVICE_STOP)) {
//
// The Dispatcher is being asked to shut down.
// (security check not required for this operation)
// although perhaps it would be a good idea to verify
// that the request came from the Service Controller.
//
controlStatus = NO_ERROR;
continueDispatch = FALSE;
}
else {
dispatchEntry = DispatchTable;
if (Msg->OpCode == SERVICE_CONTROL_START_OWN) {
dispatchEntry->dwFlags |= SERVICE_OWN_PROCESS;
}
//
// Search the dispatch table to find the service's entry
//
if (!(dispatchEntry->dwFlags & SERVICE_OWN_PROCESS)) {
controlStatus = ScGetDispatchEntry(&dispatchEntry, serviceName);
}
if (controlStatus != NO_ERROR) {
SCC_LOG(TRACE,"Service Name not in Dispatch Table\n",0);
}
}
}
else {
if (controlStatus != ERROR_NOT_ENOUGH_MEMORY) {
//
// If an error occured and it is not an out-of-memory error,
// then the pipe read must have failed.
// In this case we Increment the error count.
// When this count reaches the MAX_RETRY_COUNT, then
// the service controller must be gone. We want to log an
// error and notify an administrator. Then go to sleep forever.
// Only a re-boot will solve this problem.
//
// We should be able to report out-of-memory errors back to
// the caller. It should be noted that out-of-memory errors
// do not clear the error count. But they don't add to it
// either.
//
errorCount++;
if (errorCount > MAX_RETRY_COUNT) {
Sleep(0xffffffff);
}
}
}
//
// Dispatch the request
//
if ((continueDispatch == TRUE) && (controlStatus == NO_ERROR)) {
status = NO_ERROR;
switch(Msg->OpCode) {
case SERVICE_CONTROL_START_SHARE:
case SERVICE_CONTROL_START_OWN:
{
SC_HANDLE hScManager = OpenSCManagerW(NULL,
NULL,
SC_MANAGER_CONNECT);
if (hScManager == NULL) {
status = GetLastError();
SCC_LOG1(ERROR,
"ScDispatcherLoop: OpenSCManagerW FAILED %d\n",
status);
}
else {
//
// Update the StatusHandle in the dispatch entry table
//
dispatchEntry->StatusHandle = OpenServiceW(hScManager,
serviceName,
SERVICE_SET_STATUS);
if (dispatchEntry->StatusHandle == NULL) {
status = GetLastError();
SCC_LOG1(ERROR,
"ScDispatcherLoop: OpenServiceW FAILED %d\n",
status);
}
CloseServiceHandle(hScManager);
}
if (status == NO_ERROR
&&
(dispatchEntry->dwFlags & SERVICE_OWN_PROCESS)
&&
(_wcsicmp(dispatchEntry->ServiceName, serviceName) != 0))
{
//
// Since we don't look up the dispatch record in the OWN_PROCESS
// case (and can't since it will break existing services), there's
// no guarantee that the name in the dispatch table (acquired from
// the RegisterServiceCtrlHandler call) is the real key name of
// the service. Since the SCM passes across the real name when
// the service is started, save it away here if necessary.
//
dispatchEntry->ServiceRealName = (LPWSTR)LocalAlloc(
LMEM_FIXED,
WCSSIZE(serviceName)
);
if (dispatchEntry->ServiceRealName == NULL) {
//
// In case somebody comes searching for the handle (though
// they shouldn't), it's nicer to return an incorrect name
// than to AV trying to copy a NULL pointer.
//
SCC_LOG1(ERROR,
"ScDispatcherLoop: Could not duplicate name for service %ws\n",
serviceName);
dispatchEntry->ServiceRealName = dispatchEntry->ServiceName;
status = ERROR_NOT_ENOUGH_MEMORY;
}
else {
wcscpy(dispatchEntry->ServiceRealName, serviceName);
}
}
if (status == NO_ERROR) {
//
// The Control Dispatcher is to start a service.
// start the new thread.
//
lpServiceParams->ThreadStartupParms.ServiceStartRoutine =
dispatchEntry->ServiceStartRoutine.U;
threadAddress = (LPTHREAD_START_ROUTINE)ScSvcctrlThreadW;
threadParms = (LPVOID)&lpServiceParams->ThreadStartupParms;
//
// If the service needs to be called with ansi parameters,
// then do the conversion here.
//
if (AnsiFlag) {
lpspAnsiParms = (LPTHREAD_STARTUP_PARMSA)
&lpServiceParams->ThreadStartupParms;
for (i = 0;
i < lpServiceParams->ThreadStartupParms.NumArgs;
i++) {
if (!ScConvertToAnsi(
*(&lpspAnsiParms->VectorTable + i),
*(&lpServiceParams->ThreadStartupParms.VectorTable + i))) {
//
// Conversion error occured.
//
SCC_LOG0(ERROR,
"ScDispatcherLoop: Could not convert "
"args to ANSI\n");
status = ERROR_NOT_ENOUGH_MEMORY;
}
}
threadAddress = (LPTHREAD_START_ROUTINE)ScSvcctrlThreadA;
threadParms = lpspAnsiParms;
}
}
if (status == NO_ERROR){
//
// Create the new thread
//
threadHandle = CreateThread (
NULL, // Thread Attributes.
0L, // Stack Size
threadAddress, // lpStartAddress
threadParms, // lpParameter
0L, // Creation Flags
&threadId); // lpThreadId
if (threadHandle == NULL) {
SCC_LOG(ERROR,
"ScDispatcherLoop: CreateThread failed %d\n",
GetLastError());
status = ERROR_SERVICE_NO_THREAD;
}
else {
CloseHandle(threadHandle);
}
}
break;
}
default:
if (dispatchEntry->ControlHandler.Ex != NULL) {
__try {
//
// Call the proper ControlHandler routine.
//
if (dispatchEntry->dwFlags & SERVICE_EX_HANDLER)
{
SCC_LOG2(TRACE,
"Calling extended ControlHandler routine %x "
"for service %ws\n",
Msg->OpCode,
serviceName);
if (lpServiceParams)
{
dwHandlerRetVal = dispatchEntry->ControlHandler.Ex(
Msg->OpCode,
lpServiceParams->HandlerExParms.dwEventType,
lpServiceParams->HandlerExParms.lpEventData,
dispatchEntry->pContext);
}
else
{
dwHandlerRetVal = dispatchEntry->ControlHandler.Ex(
Msg->OpCode,
0,
NULL,
dispatchEntry->pContext);
}
SCC_LOG3(TRACE,
"Extended ControlHandler routine %x "
"returned %d from call to service %ws\n",
Msg->OpCode,
dwHandlerRetVal,
serviceName);
}
else if (IS_NON_EX_CONTROL(Msg->OpCode))
{
SCC_LOG2(TRACE,
"Calling ControlHandler routine %x "
"for service %ws\n",
Msg->OpCode,
serviceName);
#if defined(_X86_)
//
// Hack for __CDECL callbacks. The Windows NT 3.1
// SDK didn't prototype control handler functions
// as WINAPI, so a number of existing 3rd-party
// services have their control handler functions
// built as __cdecl instead. This is a workaround.
// Note that the call to the control handler must
// be the only code between the _asm statements
//
DWORD SaveEdi;
_asm mov SaveEdi, edi;
_asm mov edi, esp; // Both __cdecl and WINAPI
// functions preserve EDI
#endif
//
// Do not add code here
//
dispatchEntry->ControlHandler.Regular(Msg->OpCode);
//
// Do not add code here
//
#if defined(_X86_)
_asm mov esp, edi;
_asm mov edi, SaveEdi;
#endif
SCC_LOG2(TRACE,
"ControlHandler routine %x returned from "
"call to service %ws\n",
Msg->OpCode,
serviceName);
}
else
{
//
// Service registered for an extended control without
// registering an extended handler. The call into the
// service process succeeded, so keep status as NO_ERROR.
// Return an error from the "handler" to notify anybody
// watching for the return code (especially PnP).
//
dwHandlerRetVal = ERROR_CALL_NOT_IMPLEMENTED;
}
}
__except (EXCEPTION_EXECUTE_HANDLER)
{
SCC_LOG2(ERROR,
"ScDispatcherLoop: Exception 0x%lx "
"occurred in service %ws\n",
GetExceptionCode(),
serviceName);
status = ERROR_EXCEPTION_IN_SERVICE;
}
}
else
{
//
// There is no control handling routine
// registered for this service
//
status = ERROR_SERVICE_CANNOT_ACCEPT_CTRL;
}
LocalFree(lpServiceParams);
lpServiceParams = NULL;
// If status is not good here, then an exception occured
// either because the pointer to the control handling
// routine was bad, or because an exception occured
// inside the control handling routine.
//
// ??EVENTLOG??
//
break;
} // end switch.
//
// Send the status back to the sevice controller.
//
if (Msg->OpCode != SERVICE_CONTROL_SHUTDOWN)
{
SCC_LOG(TRACE, "Service %ws about to send response\n", serviceName);
ScSendResponse (PipeHandle, status, dwHandlerRetVal);
SCC_LOG(TRACE, "Service %ws returned from sending response\n", serviceName);
}
}
else {
//
// The controlStatus indicates failure, we always want to try
// to send the status back to the Service Controller.
//
SCC_LOG2(TRACE,
"Service %ws about to send response on error %lu\n",
serviceName,
controlStatus);
ScSendResponse(PipeHandle, controlStatus, dwHandlerRetVal);
SCC_LOG2(TRACE,
"Service %ws returned from sending response on error %lu\n",
serviceName,
controlStatus);
switch (controlStatus) {
case ERROR_SERVICE_NOT_IN_EXE:
case ERROR_SERVICE_NO_THREAD:
//
// The Service Name is not in this .exe's dispatch table.
// Or a thread for a new service couldn't be created.
// ignore it. The Service Controller will tell us to
// shut down if necessary.
//
controlStatus = NO_ERROR;
break;
default:
//
// If the error is not specifically recognized, continue.
//
controlStatus = NO_ERROR;
break;
}
}
}
while (continueDispatch == TRUE);
return;
}
SERVICE_STATUS_HANDLE
WINAPI
RegisterServiceCtrlHandlerHelp (
IN LPCWSTR ServiceName,
IN HANDLER_FUNCTION_TYPE ControlHandler,
IN PVOID pContext,
IN DWORD dwFlags
)
/*++
Routine Description:
This helper function enters a pointer to a control handling routine
and a pointer to a security descriptor into the Control Dispatcher's
dispatch table. It does the work for the RegisterServiceCtrlHandler*
family of APIs
Arguments:
ServiceName - This is a pointer to the Service Name string.
ControlHandler - This is a pointer to the service's control handling
routine.
pContext - This is a pointer to context data supplied by the user.
dwFlags - This is a set of flags that give information about the
control handling routine (currently only discerns between extended
and non-extended handlers)
Return Value:
This function returns a handle to the service that is to be used in
subsequent calls to SetServiceStatus. If the return value is NULL,
an error has occured, and GetLastError can be used to obtain the
error value. Possible values for error are:
NO_ERROR - If the operation was successful.
ERROR_INVALID_PARAMETER - The pointer to the control handler function
is NULL.
ERROR_INVALID_DATA -
ERROR_SERVICE_NOT_IN_EXE - The serviceName could not be found in
the dispatch table. This indicates that the configuration database
says the serice is in this process, but the service name doesn't
exist in the dispatch table.
--*/
{
DWORD status;
LPINTERNAL_DISPATCH_ENTRY dispatchEntry;
//
// Find the service in the dispatch table.
//
dispatchEntry = DispatchTable;
__try {
status = ScGetDispatchEntry(&dispatchEntry, (LPWSTR) ServiceName);
}
__except (EXCEPTION_EXECUTE_HANDLER) {
status = GetExceptionCode();
if (status != EXCEPTION_ACCESS_VIOLATION) {
SCC_LOG(ERROR,
"RegisterServiceCtrlHandlerHelp: Unexpected Exception 0x%lx\n",
status);
}
}
if(status != NO_ERROR) {
SCC_LOG(ERROR,
"RegisterServiceCtrlHandlerHelp: can't find dispatch entry\n",0);
SetLastError(status);
return(0L);
}
//
// Insert the ControlHandler pointer
//
if (ControlHandler.Ex == NULL) {
SCC_LOG(ERROR,
"RegisterServiceCtrlHandlerHelp: Ptr to ctrlhandler is NULL\n",
0);
SetLastError(ERROR_INVALID_PARAMETER);
return(0L);
}
//
// Insert the entries into the table
//
if (dwFlags & SERVICE_EX_HANDLER) {
dispatchEntry->dwFlags |= SERVICE_EX_HANDLER;
dispatchEntry->ControlHandler.Ex = ControlHandler.Ex;
dispatchEntry->pContext = pContext;
}
else {
dispatchEntry->dwFlags &= ~(SERVICE_EX_HANDLER);
dispatchEntry->ControlHandler.Regular = ControlHandler.Regular;
}
//
// This cast is OK -- see comment in I_ScPnPGetServiceName
//
return( (SERVICE_STATUS_HANDLE) dispatchEntry->StatusHandle );
}
SERVICE_STATUS_HANDLE
WINAPI
RegisterServiceCtrlHandlerW (
IN LPCWSTR ServiceName,
IN LPHANDLER_FUNCTION ControlHandler
)
/*++
Routine Description:
This function enters a pointer to a control handling
routine into the Control Dispatcher's dispatch table.
Arguments:
ServiceName -- The service's name
ControlHandler -- Pointer to the control handling routine
Return Value:
Anything returned by RegisterServiceCtrlHandlerHelp
--*/
{
HANDLER_FUNCTION_TYPE Handler;
Handler.Regular = ControlHandler;
return RegisterServiceCtrlHandlerHelp(ServiceName,
Handler,
NULL,
0);
}
SERVICE_STATUS_HANDLE
WINAPI
RegisterServiceCtrlHandlerA (
IN LPCSTR ServiceName,
IN LPHANDLER_FUNCTION ControlHandler
)
/*++
Routine Description:
This is the ansi entry point for RegisterServiceCtrlHandler.
Arguments:
Return Value:
--*/
{
LPWSTR ServiceNameW;
SERVICE_STATUS_HANDLE statusHandle;
if (!ScConvertToUnicode(&ServiceNameW, ServiceName)) {
//
// This can only fail because of a failed LocalAlloc call
// or else the ansi string is garbage.
//
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return(0L);
}
statusHandle = RegisterServiceCtrlHandlerW(ServiceNameW, ControlHandler);
LocalFree(ServiceNameW);
return(statusHandle);
}
SERVICE_STATUS_HANDLE
WINAPI
RegisterServiceCtrlHandlerExW (
IN LPCWSTR ServiceName,
IN LPHANDLER_FUNCTION_EX ControlHandler,
IN PVOID pContext
)
/*++
Routine Description:
This function enters a pointer to an extended control handling
routine into the Control Dispatcher's dispatch table. It is
analogous to RegisterServiceCtrlHandlerW.
Arguments:
ServiceName -- The service's name
ControlHandler -- A pointer to an extended control handling routine
pContext -- User-supplied data that is passed to the control handler
Return Value:
Anything returned by RegisterServiceCtrlHandlerHelp
--*/
{
HANDLER_FUNCTION_TYPE Handler;
Handler.Ex = ControlHandler;
return RegisterServiceCtrlHandlerHelp(ServiceName,
Handler,
pContext,
SERVICE_EX_HANDLER);
}
SERVICE_STATUS_HANDLE
WINAPI
RegisterServiceCtrlHandlerExA (
IN LPCSTR ServiceName,
IN LPHANDLER_FUNCTION_EX ControlHandler,
IN PVOID pContext
)
/*++
Routine Description:
This is the ansi entry point for RegisterServiceCtrlHandlerEx.
Arguments:
Return Value:
--*/
{
LPWSTR ServiceNameW;
SERVICE_STATUS_HANDLE statusHandle;
if(!ScConvertToUnicode(&ServiceNameW, ServiceName)) {
//
// This can only fail because of a failed LocalAlloc call
// or else the ansi string is garbage.
//
SetLastError(ERROR_NOT_ENOUGH_MEMORY);
return(0L);
}
statusHandle = RegisterServiceCtrlHandlerExW(ServiceNameW,
ControlHandler,
pContext);
LocalFree(ServiceNameW);
return(statusHandle);
}
DWORD
ScCreateDispatchTableW(
IN CONST SERVICE_TABLE_ENTRYW *lpServiceStartTable,
OUT LPINTERNAL_DISPATCH_ENTRY *DispatchTablePtr
)
/*++
Routine Description:
This routine allocates space for the Control Dispatchers Dispatch Table.
It also initializes the table with the data that the service main
routine passed in with the lpServiceStartTable parameter.
This routine expects that pointers in the user's dispatch table point
to valid information. And that that information will stay valid and
fixed through out the life of the Control Dispatcher. In otherwords,
the ServiceName string better not move or get cleared.
Arguments:
lpServiceStartTable - This is a pointer to the first entry in the
dispatch table that the service's main routine passed in .
DispatchTablePtr - This is a pointer to the location where the
Service Controller's dispatch table is to be stored.
Return Value:
NO_ERROR - The operation was successful.
ERROR_NOT_ENOUGH_MEMORY - The memory allocation failed.
ERROR_INVALID_PARAMETER - There are no entries in the dispatch table.
--*/
{
DWORD numEntries;
LPINTERNAL_DISPATCH_ENTRY dispatchTable;
const SERVICE_TABLE_ENTRYW * entryPtr;
//
// Count the number of entries in the user dispatch table
//
numEntries = 0;
entryPtr = lpServiceStartTable;
while (entryPtr->lpServiceName != NULL) {
numEntries++;
entryPtr++;
}
if (numEntries == 0) {
SCC_LOG(ERROR,"ScCreateDispatchTable:No entries in Dispatch table!\n",0);
return(ERROR_INVALID_PARAMETER);
}
//
// Allocate space for the Control Dispatcher's Dispatch Table
//
dispatchTable = (LPINTERNAL_DISPATCH_ENTRY)LocalAlloc(LMEM_ZEROINIT,
sizeof(INTERNAL_DISPATCH_ENTRY) * (numEntries + 1));
if (dispatchTable == NULL) {
SCC_LOG(ERROR,"ScCreateDispatchTable: Local Alloc failed rc = %d\n",
GetLastError());
return (ERROR_NOT_ENOUGH_MEMORY);
}
//
// Move user dispatch info into the Control Dispatcher's table.
//
*DispatchTablePtr = dispatchTable;
entryPtr = lpServiceStartTable;
while (entryPtr->lpServiceName != NULL) {
dispatchTable->ServiceName = entryPtr->lpServiceName;
dispatchTable->ServiceRealName = entryPtr->lpServiceName;
dispatchTable->ServiceStartRoutine.U= entryPtr->lpServiceProc;
dispatchTable->ControlHandler.Ex = NULL;
dispatchTable->StatusHandle = NULL;
dispatchTable->dwFlags = 0;
entryPtr++;
dispatchTable++;
}
return (NO_ERROR);
}
DWORD
ScCreateDispatchTableA(
IN CONST SERVICE_TABLE_ENTRYA *lpServiceStartTable,
OUT LPINTERNAL_DISPATCH_ENTRY *DispatchTablePtr
)
/*++
Routine Description:
This routine allocates space for the Control Dispatchers Dispatch Table.
It also initializes the table with the data that the service main
routine passed in with the lpServiceStartTable parameter.
This routine expects that pointers in the user's dispatch table point
to valid information. And that that information will stay valid and
fixed through out the life of the Control Dispatcher. In otherwords,
the ServiceName string better not move or get cleared.
Arguments:
lpServiceStartTable - This is a pointer to the first entry in the
dispatch table that the service's main routine passed in .
DispatchTablePtr - This is a pointer to the location where the
Service Controller's dispatch table is to be stored.
Return Value:
NO_ERROR - The operation was successful.
ERROR_NOT_ENOUGH_MEMORY - The memory allocation failed.
ERROR_INVALID_PARAMETER - There are no entries in the dispatch table.
--*/
{
DWORD numEntries;
DWORD status = NO_ERROR;
LPINTERNAL_DISPATCH_ENTRY dispatchTable;
const SERVICE_TABLE_ENTRYA * entryPtr;
//
// Count the number of entries in the user dispatch table
//
numEntries = 0;
entryPtr = lpServiceStartTable;
while (entryPtr->lpServiceName != NULL) {
numEntries++;
entryPtr++;
}
if (numEntries == 0) {
SCC_LOG(ERROR,"ScCreateDispatchTable:No entries in Dispatch table!\n",0);
return(ERROR_INVALID_PARAMETER);
}
//
// Allocate space for the Control Dispatcher's Dispatch Table
//
dispatchTable = (LPINTERNAL_DISPATCH_ENTRY)LocalAlloc(LMEM_ZEROINIT,
sizeof(INTERNAL_DISPATCH_ENTRY) * (numEntries + 1));
if (dispatchTable == NULL) {
SCC_LOG(ERROR,"ScCreateDispatchTableA: Local Alloc failed rc = %d\n",
GetLastError());
return (ERROR_NOT_ENOUGH_MEMORY);
}
//
// Move user dispatch info into the Control Dispatcher's table.
//
*DispatchTablePtr = dispatchTable;
entryPtr = lpServiceStartTable;
while (entryPtr->lpServiceName != NULL) {
//
// Convert the service name to unicode
//
__try {
if (!ScConvertToUnicode(
&(dispatchTable->ServiceName),
entryPtr->lpServiceName)) {
//
// The convert failed.
//
SCC_LOG(ERROR,"ScCreateDispatcherTableA:ScConvertToUnicode failed\n",0);
//
// This is the only reason for failure that I can think of.
//
status = ERROR_NOT_ENOUGH_MEMORY;
}
}
__except (EXCEPTION_EXECUTE_HANDLER) {
status = GetExceptionCode();
if (status != EXCEPTION_ACCESS_VIOLATION) {
SCC_LOG(ERROR,
"ScCreateDispatchTableA: Unexpected Exception 0x%lx\n",status);
}
}
if (status != NO_ERROR) {
//
// If an error occured, free up the allocated resources.
//
dispatchTable = *DispatchTablePtr;
while (dispatchTable->ServiceName != NULL) {
LocalFree(dispatchTable->ServiceName);
dispatchTable++;
}
LocalFree(*DispatchTablePtr);
return(status);
}
//
// Fill in the rest of the dispatch entry.
//
dispatchTable->ServiceRealName = dispatchTable->ServiceName;
dispatchTable->ServiceStartRoutine.A= entryPtr->lpServiceProc;
dispatchTable->ControlHandler.Ex = NULL;
dispatchTable->StatusHandle = NULL;
dispatchTable->dwFlags = 0;
entryPtr++;
dispatchTable++;
}
return (NO_ERROR);
}
DWORD
ScReadServiceParms(
IN LPCTRL_MSG_HEADER Msg,
IN DWORD dwNumBytesRead,
OUT LPBYTE *ppServiceParams,
OUT LPBYTE *ppTempArgPtr,
OUT LPDWORD lpdwRemainingArgBytes
)
/*++
Routine Description:
This routine calculates the number of bytes needed for the service's
control parameters by using the arg count information in the
message header. The parameter structure is allocated and
as many bytes of argument information as have been captured so far
are placed into the buffer. A second read of the pipe may be necessary
to obtain the remaining bytes of argument information.
NOTE: This function allocates enough space in the startup parameter
buffer for the service name and pointer as well as the rest of the
arguments. However, it does not put the service name into the argument
list. This is because it may take two calls to this routine to
get all the argument information. We can't insert the service name
string until we have all the rest of the argument data.
[serviceNamePtr][argv1][argv2]...[argv1Str][argv2Str]...[serviceNameStr]
or
[serviceNamePtr][dwEventType][EventData][serviceNameStr]
Arguments:
Msg - A pointer to the pipe message header.
dwNumBytesRead - The number of bytes read in the first pipe read.
ppServiceParams - A pointer to a location where the pointer to the
thread startup parameter structure is to be placed.
ppTempArgPtr - A location that will contain the pointer to where
more argument data can be placed by a second read of the pipe.
lpdwRemainingArgBytes - Returns with a count of the number of argument
bytes that remain to be read from the pipe.
Return Value:
NO_ERROR - If the operation was successful.
ERROR_NOT_ENOUGH_MEMORY - If the memory allocation was unsuccessful.
Note:
--*/
{
DWORD dwNameSize; // num bytes in ServiceName.
DWORD dwBufferSize; // num bytes for parameter buffer
LONG lArgBytesRead; // number of arg bytes in first read.
LPSERVICE_PARAMS lpTempParams;
//
// Set out pointer to no arguments unless we discover otherwise
//
*ppTempArgPtr = NULL;
SCC_LOG(TRACE,"ScReadServiceParms: Get service parameters from pipe\n",0);
//
// Note: Here we assume that the service name was read into the buffer
// in its entirety.
//
dwNameSize = (DWORD) WCSSIZE((LPWSTR) ((LPBYTE) Msg + Msg->ServiceNameOffset));
//
// Calculate the size of buffer needed. This will consist of a
// SERVICE_PARAMS structure, plus the service name and a pointer
// for it, plus the rest of the arg info sent in the message
// (We are wasting 4 bytes here since the first pointer in
// the vector table is accounted for twice - but what the heck!).
//
dwBufferSize = Msg->Count -
sizeof(CTRL_MSG_HEADER) +
sizeof(SERVICE_PARAMS) +
sizeof(LPWSTR);
//
// Allocate the memory for the service parameters
//
lpTempParams = (LPSERVICE_PARAMS)LocalAlloc (LMEM_ZEROINIT, dwBufferSize);
if (lpTempParams == NULL)
{
SCC_LOG1(ERROR,
"ScReadServiceParms: LocalAlloc failed rc = %d\n",
GetLastError());
return ERROR_NOT_ENOUGH_MEMORY;
}
lArgBytesRead = dwNumBytesRead - sizeof(CTRL_MSG_HEADER) - dwNameSize;
*lpdwRemainingArgBytes = Msg->Count - dwNumBytesRead;
//
// Unpack message-specific arguments
//
switch (Msg->OpCode) {
case SERVICE_CONTROL_START_OWN:
case SERVICE_CONTROL_START_SHARE:
SCC_LOG(TRACE,"ScReadServiceParms: Starting a service\n", 0);
if (Msg->NumCmdArgs != 0) {
//
// There's only a vector table and ThreadStartupParms
// when the service starts up
//
*ppTempArgPtr = (LPBYTE)&lpTempParams->ThreadStartupParms.VectorTable;
//
// Leave the first vector location blank for the service name
// pointer.
//
(*ppTempArgPtr) += sizeof(LPWSTR);
//
// adjust lArgBytesRead to remove any extra bytes that are
// there for alignment. If a name that is not in the dispatch
// table is passed in, it could be larger than our buffer.
// This could cause lArgBytesRead to become negative.
// However it should fail safe anyway since the name simply
// won't be recognized and an error will be returned.
//
lArgBytesRead -= (Msg->ArgvOffset - Msg->ServiceNameOffset - dwNameSize);
//
// Copy any portion of the command arg info from the first read
// into the buffer that is to be used for the second read.
//
if (lArgBytesRead > 0) {
RtlCopyMemory(*ppTempArgPtr,
(LPBYTE)Msg + Msg->ArgvOffset,
lArgBytesRead);
*ppTempArgPtr += lArgBytesRead;
}
}
break;
case SERVICE_CONTROL_DEVICEEVENT:
case SERVICE_CONTROL_HARDWAREPROFILECHANGE:
case SERVICE_CONTROL_POWEREVENT:
case SERVICE_CONTROL_SESSIONCHANGE:
{
//
// This is a PnP, power, or TS message
//
SCC_LOG1(TRACE,
"ScReadServiceParms: Receiving PnP/power/TS event %x\n",
Msg->OpCode);
//
// adjust lArgBytesRead to remove any extra bytes that are
// there for alignment. If a name that is not in the dispatch
// table is passed in, it could be larger than our buffer.
// This could cause lArgBytesRead to become negative.
// However it should fail safe anyway since the name simply
// won't be recognized and an error will be returned.
//
lArgBytesRead -= (Msg->ArgvOffset - Msg->ServiceNameOffset - dwNameSize);
*ppTempArgPtr = (LPBYTE) &lpTempParams->HandlerExParms.dwEventType;
if (lArgBytesRead > 0)
{
LPBYTE lpArgs;
LPHANDLEREX_PARMS lpHandlerExParms = (LPHANDLEREX_PARMS) (*ppTempArgPtr);
lpArgs = (LPBYTE) Msg + Msg->ArgvOffset;
lpHandlerExParms->dwEventType = *(LPDWORD) lpArgs;
lpArgs += sizeof(DWORD);
lArgBytesRead -= sizeof(DWORD);
RtlCopyMemory(lpHandlerExParms + 1,
lpArgs,
lArgBytesRead);
lpHandlerExParms->lpEventData = lpHandlerExParms + 1;
*ppTempArgPtr = (LPBYTE) (lpHandlerExParms + 1) + lArgBytesRead;
}
break;
}
}
*ppServiceParams = (LPBYTE) lpTempParams;
return NO_ERROR;
}
DWORD
ScConnectServiceController(
OUT LPHANDLE PipeHandle
)
/*++
Routine Description:
This function connects to the Service Controller Pipe.
Arguments:
PipeHandle - This is a pointer to the location where the PipeHandle
is to be placed.
Return Value:
NO_ERROR - if the operation was successful.
ERROR_FAILED_SERVICE_CONTROLLER_CONNECT - if we failed to connect.
--*/
{
BOOL status;
DWORD apiStatus;
DWORD response;
DWORD pipeMode;
DWORD numBytesWritten;
WCHAR wszPipeName[sizeof(CONTROL_PIPE_NAME) / sizeof(WCHAR) + PID_LEN] = CONTROL_PIPE_NAME;
//
// Generate the pipe name -- Security process uses PID 0 since the
// SCM doesn't have the PID at connect-time (it gets it from the
// pipe transaction with the LSA)
//
if (g_fIsSecProc) {
response = 0;
}
else {
//
// Read this process's pipe ID from the registry.
//
HKEY hCurrentValueKey;
status = RegOpenKeyEx(
HKEY_LOCAL_MACHINE,
"System\\CurrentControlSet\\Control\\ServiceCurrent",
0,
KEY_QUERY_VALUE,
&hCurrentValueKey);
if (status == ERROR_SUCCESS)
{
DWORD ValueType;
DWORD cbData = sizeof(response);
status = RegQueryValueEx(
hCurrentValueKey,
NULL, // Use key's unnamed value
0,
&ValueType,
(LPBYTE) &response,
&cbData);
RegCloseKey(hCurrentValueKey);
if (status != ERROR_SUCCESS || ValueType != REG_DWORD)
{
SCC_LOG(ERROR,
"ScConnectServiceController: RegQueryValueEx FAILED %d\n",
status);
return(ERROR_FAILED_SERVICE_CONTROLLER_CONNECT);
}
}
else
{
SCC_LOG(ERROR,
"ScConnectServiceController: RegOpenKeyEx FAILED %d\n",
status);
return(ERROR_FAILED_SERVICE_CONTROLLER_CONNECT);
}
}
_itow(response, wszPipeName + sizeof(CONTROL_PIPE_NAME) / sizeof(WCHAR) - 1, 10);
status = WaitNamedPipeW (
wszPipeName,
CONTROL_WAIT_PERIOD);
if (status != TRUE) {
SCC_LOG(ERROR,"ScConnectServiceController:WaitNamedPipe failed rc = %d\n",
GetLastError());
}
SCC_LOG(TRACE,"ScConnectServiceController:WaitNamedPipe success\n",0);
*PipeHandle = CreateFileW(
wszPipeName, // lpFileName
GENERIC_READ | GENERIC_WRITE, // dwDesiredAccess
FILE_SHARE_READ | FILE_SHARE_WRITE, // dwShareMode
NULL, // lpSecurityAttributes
OPEN_EXISTING, // dwCreationDisposition
FILE_ATTRIBUTE_NORMAL, // dwFileAttributes
0L); // hTemplateFile
if (*PipeHandle == INVALID_HANDLE_VALUE) {
SCC_LOG(ERROR,"ScConnectServiceController:CreateFile failed rc = %d\n",
GetLastError());
return(ERROR_FAILED_SERVICE_CONTROLLER_CONNECT);
}
SCC_LOG(TRACE,"ScConnectServiceController:CreateFile success\n",0);
//
// Set pipe mode
//
pipeMode = PIPE_READMODE_MESSAGE | PIPE_WAIT;
status = SetNamedPipeHandleState (
*PipeHandle,
&pipeMode,
NULL,
NULL);
if (status != TRUE) {
SCC_LOG(ERROR,"ScConnectServiceController:SetNamedPipeHandleState failed rc = %d\n",
GetLastError());
return(ERROR_FAILED_SERVICE_CONTROLLER_CONNECT);
}
else {
SCC_LOG(TRACE,
"ScConnectServiceController SetNamedPipeHandleState Success\n",0);
}
//
// Send initial status - This is the process Id for the service process.
//
response = GetCurrentProcessId();
apiStatus = WriteFile (
*PipeHandle,
&response,
sizeof(response),
&numBytesWritten,
NULL);
if (apiStatus != TRUE) {
//
// If this fails, there is a chance that the pipe is still in good
// shape. So we just go on.
//
// ??EVENTLOG??
//
SCC_LOG(ERROR,"ScConnectServiceController: WriteFile failed, rc= %d\n", GetLastError());
}
else {
SCC_LOG(TRACE,
"ScConnectServiceController: WriteFile success, bytes Written= %d\n",
numBytesWritten);
}
return(NO_ERROR);
}
VOID
ScExpungeMessage(
IN HANDLE PipeHandle
)
/*++
Routine Description:
This routine cleans the remaining portion of a message out of the pipe.
It is called in response to an unsuccessful attempt to allocate the
correct buffer size from the heap. In this routine a small buffer is
allocated on the stack, and successive reads are made until a status
other than ERROR_MORE_DATA is received.
Arguments:
PipeHandle - This is a handle to the pipe in which the message resides.
Return Value:
none - If this operation fails, there is not much I can do about
the data in the pipe.
--*/
{
#define EXPUNGE_BUF_SIZE 100
DWORD status;
DWORD dwNumBytesRead = 0;
BYTE msg[EXPUNGE_BUF_SIZE];
do {
status = ReadFile (
PipeHandle,
msg,
EXPUNGE_BUF_SIZE,
&dwNumBytesRead,
NULL);
}
while( status == ERROR_MORE_DATA);
}
DWORD
ScGetPipeInput (
IN HANDLE PipeHandle,
IN OUT LPCTRL_MSG_HEADER Msg,
IN DWORD dwBufferSize,
OUT LPSERVICE_PARAMS *ppServiceParams
)
/*++
Routine Description:
This routine reads a control message from the pipe and places it into
a message buffer. This routine also allocates a structure for
the service thread information. This structure will eventually
contain everything that is needed to invoke the service startup
routine in the context of a new thread. Items contained in the
structure are:
1) The pointer to the startup routine,
2) The number of arguments, and
3) The table of vectors to the arguments.
Since this routine has knowledge about the buffer size needed for
the arguments, the allocation is done here.
Arguments:
PipeHandle - This is the handle for the pipe that is to be read.
Msg - This is a pointer to a buffer where the data is to be placed.
dwBufferSize - This is the size (in bytes) of the buffer that data is to
be placed in.
ppServiceParams - This is the location where the command args will
be placed
Return Value:
NO_ERROR - if the operation was successful.
ERROR_NOT_ENOUGH_MEMORY - There was not enough memory to create a large
enough buffer for the command line arguments.
ERROR_INVALID_DATA - This is returned if we did not receive a complete
CTRL_MESSAGE_HEADER on the first read.
Any error that ReadFile might return could be returned by this function.
(We may want to return something more specific like ERROR_READ_FAULT)
--*/
{
DWORD status;
BOOL readStatus;
DWORD dwNumBytesRead = 0;
DWORD dwRemainingArgBytes;
LPBYTE pTempArgPtr;
*ppServiceParams = NULL;
//
// Read the header and name string from the pipe.
// NOTE: The number of bytes for the name string is determined by
// the longest service name in the service process. If the actual
// string read is shorter, then the beginning of the command arg
// data may be read with this read.
// Also note: The buffer is large enough to accommodate the longest
// permissible service name.
//
readStatus = ReadFile(PipeHandle,
Msg,
dwBufferSize,
&dwNumBytesRead,
NULL);
SCC_LOG(TRACE,"ScGetPipeInput:ReadFile buffer size = %ld\n",dwBufferSize);
SCC_LOG(TRACE,"ScGetPipeInput:ReadFile dwNumBytesRead = %ld\n",dwNumBytesRead);
if ((readStatus == TRUE) && (dwNumBytesRead > sizeof(CTRL_MSG_HEADER))) {
//
// The Read File read the complete message in one read. So we
// can return with the data.
//
SCC_LOG(TRACE,"ScGetPipeInput: Success!\n",0);
switch (Msg->OpCode) {
case SERVICE_CONTROL_START_OWN:
case SERVICE_CONTROL_START_SHARE:
//
// Read in any start arguments for the service
//
status = ScReadServiceParms(Msg,
dwNumBytesRead,
(LPBYTE *)ppServiceParams,
&pTempArgPtr,
&dwRemainingArgBytes);
if (status != NO_ERROR) {
return status;
}
//
// Change the offsets back into pointers.
//
ScNormalizeCmdLineArgs(Msg,
&(*ppServiceParams)->ThreadStartupParms);
break;
case SERVICE_CONTROL_DEVICEEVENT:
case SERVICE_CONTROL_HARDWAREPROFILECHANGE:
case SERVICE_CONTROL_POWEREVENT:
case SERVICE_CONTROL_SESSIONCHANGE:
//
// Read in the service's PnP/power arguments
//
status = ScReadServiceParms(Msg,
dwNumBytesRead,
(LPBYTE *)ppServiceParams,
&pTempArgPtr,
&dwRemainingArgBytes);
if (status != NO_ERROR) {
return status;
}
break;
default:
ASSERT(Msg->NumCmdArgs == 0);
break;
}
return NO_ERROR;
}
else {
//
// An error was returned from ReadFile. ERROR_MORE_DATA
// means that we need to read some arguments from the buffer.
// Any other error is unexpected, and generates an internal error.
//
if (readStatus != TRUE) {
status = GetLastError();
if (status != ERROR_MORE_DATA) {
SCC_LOG(ERROR,"ScGetPipeInput:Unexpected return code, rc= %ld\n",
status);
return status;
}
}
else {
//
// The read was successful, but we didn't get a complete
// CTRL_MESSAGE_HEADER.
//
return ERROR_INVALID_DATA;
}
}
//
// We must have received an ERROR_MORE_DATA to go down this
// path. This means that the message contains more data. Namely,
// service arguments must be present. Therefore, the pipe must
// be read again. Since the header indicates how many bytes are
// needed, we will allocate a buffer large enough to hold all the
// service arguments.
//
// If a portion of the arguments was read in the first read,
// they will be put in this new buffer. That is so that all the
// command line arg info is in one place.
//
status = ScReadServiceParms(Msg,
dwNumBytesRead,
(LPBYTE *)ppServiceParams,
&pTempArgPtr,
&dwRemainingArgBytes);
if (status != NO_ERROR) {
ScExpungeMessage(PipeHandle);
return status;
}
readStatus = ReadFile(PipeHandle,
pTempArgPtr,
dwRemainingArgBytes,
&dwNumBytesRead,
NULL);
if ((readStatus != TRUE) || (dwNumBytesRead < dwRemainingArgBytes)) {
if (readStatus != TRUE) {
status = GetLastError();
SCC_LOG1(ERROR,
"ScGetPipeInput: ReadFile error (2nd read), rc = %ld\n",
status);
}
else {
status = ERROR_BAD_LENGTH;
}
SCC_LOG2(ERROR,
"ScGetPipeInput: ReadFile read: %d, expected: %d\n",
dwNumBytesRead,
dwRemainingArgBytes);
LocalFree(*ppServiceParams);
return status;
}
if (Msg->OpCode == SERVICE_CONTROL_START_OWN ||
Msg->OpCode == SERVICE_CONTROL_START_SHARE) {
//
// Change the offsets back into pointers.
//
ScNormalizeCmdLineArgs(Msg, &(*ppServiceParams)->ThreadStartupParms);
}
return NO_ERROR;
}
DWORD
ScGetDispatchEntry (
IN OUT LPINTERNAL_DISPATCH_ENTRY *DispatchEntryPtr,
IN LPWSTR ServiceName
)
/*++
Routine Description:
Finds an entry in the Dispatch Table for a particular service which
is identified by a service name string.
Arguments:
DispatchEntryPtr - As an input, the is a location where a pointer to
the top of the DispatchTable is placed. On return, this is the
location where the pointer to the specific dispatch entry is to
be placed. This is an opaque pointer because it could be either
ansi or unicode depending on the operational state of the dispatcher.
ServiceName - This is a pointer to the service name string that was
supplied by the service. Note that it may not be the service's
real name since we never check services that run in their own
process (bug that can never be fixed since it will break existing
services). We must check for this name instead of the real
one.
Return Value:
NO_ERROR - The operation was successful.
ERROR_SERVICE_NOT_IN_EXE - The serviceName could not be found in
the dispatch table. This indicates that the configuration database
says the serice is in this process, but the service name doesn't
exist in the dispatch table.
--*/
{
LPINTERNAL_DISPATCH_ENTRY entryPtr;
DWORD found = FALSE;
entryPtr = *DispatchEntryPtr;
if (entryPtr->dwFlags & SERVICE_OWN_PROCESS) {
return (NO_ERROR);
}
while (entryPtr->ServiceName != NULL) {
if (_wcsicmp(entryPtr->ServiceName, ServiceName) == 0) {
found = TRUE;
break;
}
entryPtr++;
}
if (found) {
*DispatchEntryPtr = entryPtr;
}
else {
SCC_LOG(ERROR,"ScGetDispatchEntry: DispatchEntry not found\n"
" Configuration error - the %ws service is not in this .exe file!\n"
" Check the table passed to StartServiceCtrlDispatcher.\n", ServiceName);
return(ERROR_SERVICE_NOT_IN_EXE);
}
return(NO_ERROR);
}
VOID
ScNormalizeCmdLineArgs(
IN OUT LPCTRL_MSG_HEADER Msg,
IN OUT LPTHREAD_STARTUP_PARMSW ThreadStartupParms
)
/*++
Routine Description:
Normalizes the command line argument information that came across in
the pipe. The argument information is stored in a buffer that consists
of an array of string pointers followed by the strings themselves.
However, in the pipe, the pointers are replaced with offsets. This
routine transforms the offsets into real pointers.
This routine also puts the service name into the array of argument
vectors, and adds the service name string to the end of the
buffer (space has already been allocated for it).
Arguments:
Msg - This is a pointer to the Message. Useful information from this
includes the NumCmdArgs and the service name.
ThreadStartupParms - A pointer to the thread startup parameter structure.
Return Value:
none.
--*/
{
DWORD i;
LPWSTR *argv;
DWORD numCmdArgs;
LPWSTR *serviceNameVector;
LPWSTR serviceNamePtr;
#if defined(_X86_)
PULONG64 argv64 = NULL;
#endif
numCmdArgs = Msg->NumCmdArgs;
argv = &(ThreadStartupParms->VectorTable);
//
// Save the first argv for the service name.
//
serviceNameVector = argv;
argv++;
//
// Normalize the Command Line Argument information by replacing
// offsets in buffer with pointers.
//
// NOTE: The elaborate casting that takes place here is because we
// are taking some (pointer sized) offsets, and turning them back
// into pointers to strings. The offsets are in bytes, and are
// relative to the beginning of the vector table which contains
// pointers to the various command line arg strings.
//
#if defined(_X86_)
if (g_fWow64Process) {
//
// Pointers on the 64-bit land are 64-bit so make argv
// point to the 1st arg after the service name offset
//
argv64 = (PULONG64)argv;
}
#endif
for (i = 0; i < numCmdArgs; i++) {
#if defined(_X86_)
if (g_fWow64Process)
argv[i] = (LPWSTR)((LPBYTE)argv + PtrToUlong(argv64[i]));
else
#endif
argv[i] = (LPWSTR)((LPBYTE)argv + PtrToUlong(argv[i]));
}
//
// If we are starting a service, then we need to add the service name
// to the argument vectors.
//
if ((Msg->OpCode == SERVICE_CONTROL_START_SHARE) ||
(Msg->OpCode == SERVICE_CONTROL_START_OWN)) {
numCmdArgs++;
if (numCmdArgs > 1) {
//
// Find the location for the service name string by finding
// the pointer to the last argument adding its string length
// to it.
//
serviceNamePtr = argv[i-1];
serviceNamePtr += (wcslen(serviceNamePtr) + 1);
}
else {
serviceNamePtr = (LPWSTR)argv;
}
wcscpy(serviceNamePtr, (LPWSTR) ((LPBYTE)Msg + Msg->ServiceNameOffset));
*serviceNameVector = serviceNamePtr;
}
ThreadStartupParms->NumArgs = numCmdArgs;
}
VOID
ScSendResponse (
IN HANDLE PipeHandle,
IN DWORD Response,
IN DWORD dwHandlerRetVal
)
/*++
Routine Description:
This routine sends a status response to the Service Controller's pipe.
Arguments:
Response - This is the status message that is to be sent.
dwHandlerRetVal - This is the return value from the service's control
handler function (NO_ERROR for non-Ex handlers)
Return Value:
none.
--*/
{
DWORD numBytesWritten;
PIPE_RESPONSE_MSG prmResponse;
prmResponse.dwDispatcherStatus = Response;
prmResponse.dwHandlerRetVal = dwHandlerRetVal;
if (!WriteFile(PipeHandle,
&prmResponse,
sizeof(PIPE_RESPONSE_MSG),
&numBytesWritten,
NULL))
{
SCC_LOG1(ERROR,
"ScSendResponse: WriteFile failed, rc= %d\n",
GetLastError());
}
}
DWORD
ScSvcctrlThreadW(
IN LPTHREAD_STARTUP_PARMSW lpThreadStartupParms
)
/*++
Routine Description:
This is the thread for the newly started service. This code
calls the service's main thread with parameters from the
ThreadStartupParms structure.
NOTE: The first item in the argument vector table is the pointer to
the service registry path string.
Arguments:
lpThreadStartupParms - This is a pointer to the ThreadStartupParms
structure. (This is a unicode structure);
Return Value:
--*/
{
//
// Call the Service's Main Routine.
//
((LPSERVICE_MAIN_FUNCTIONW)lpThreadStartupParms->ServiceStartRoutine) (
lpThreadStartupParms->NumArgs,
&lpThreadStartupParms->VectorTable);
LocalFree(lpThreadStartupParms);
return(0);
}
DWORD
ScSvcctrlThreadA(
IN LPTHREAD_STARTUP_PARMSA lpThreadStartupParms
)
/*++
Routine Description:
This is the thread for the newly started service. This code
calls the service's main thread with parameters from the
ThreadStartupParms structure.
NOTE: The first item in the argument vector table is the pointer to
the service registry path string.
Arguments:
lpThreadStartupParms - This is a pointer to the ThreadStartupParms
structure. (This is a unicode structure);
Return Value:
--*/
{
//
// Call the Service's Main Routine.
//
// NOTE: The first item in the argument vector table is the pointer to
// the service registry path string.
//
((LPSERVICE_MAIN_FUNCTIONA)lpThreadStartupParms->ServiceStartRoutine) (
lpThreadStartupParms->NumArgs,
&lpThreadStartupParms->VectorTable);
LocalFree(lpThreadStartupParms);
return(0);
}
| [
"[email protected]"
] | |
0d32a0e1ce5e591920f2da4a0b9bf27274d021fb | 17aadd8f4f5af8d46505d7b7390ab4b3c180fcd3 | /OpenGLRenderer/source/OpenGLRenderer.cpp | cfc8e0564689103677c144c54f1963b4e687fb53 | [] | no_license | platc2/VoxelRendering | 26972d5c269bdac2e922009308d03f4cc481cc31 | 912a3fe72c8dfdd8d9653e5c53c5ded431a124db | refs/heads/master | 2023-03-25T15:46:43.103968 | 2021-03-24T16:43:07 | 2021-03-24T16:43:07 | 351,152,200 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 10,230 | cpp | #ifdef _MSC_VER
#include <ciso646>
#endif
#include "OpenGLRenderer.h"
#include "Texture.h"
#include <iostream>
#include <vector>
#include <string>
#include <stdexcept>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>
#include <GL/glew.h>
using namespace voxel;
static void errorCallback(const GLenum eSource, const GLenum eType, const GLuint uiId, const GLenum eSeverity, const GLsizei iLength, const GLchar* const szMessage, const void* const pUserParameter);
COpenGLRenderer::COpenGLRenderer()
{
}
COpenGLRenderer::~COpenGLRenderer()
{
}
const char* szVS = "\
#version 450\n\
layout(location = 0) in vec2 Position;\n\
layout(location = 1) in vec2 UV;\n\
layout(location = 2) in vec4 Color;\n\
\n\
uniform mat4 ProjMtx;\n\
\n\
out vec2 Frag_UV;\n\
out vec4 Frag_Color;\n\
\n\
void main()\n\
{\n\
Frag_UV = UV;\n\
Frag_Color = Color;\n\
\n\
gl_Position = ProjMtx * vec4(Position.xy, 0, 1);\n\
}\n\
";
const char* szFS = "\
#version 450\n\
in vec2 Frag_UV;\n\
in vec4 Frag_Color;\n\
\n\
uniform sampler2D Texture;\n\
\n\
layout (location = 0) out vec4 Out_Color;\n\
\n\
void main()\n\
{\n\
Out_Color = Frag_Color * texture(Texture, Frag_UV.st);\n\
}\n\
";
static void checkShader(const GLuint uiShader)
{
GLint iStatus;
glGetShaderiv(uiShader, GL_COMPILE_STATUS, &iStatus);
if(iStatus == GL_FALSE)
{
GLint iInfoLogLength;
glGetShaderiv(uiShader, GL_INFO_LOG_LENGTH, &iInfoLogLength);
std::vector<char> vecInfoLog(iInfoLogLength);
glGetShaderInfoLog(uiShader, iInfoLogLength, nullptr, vecInfoLog.data());
std::string strInfoLog(vecInfoLog.begin(), vecInfoLog.end());
std::cout << strInfoLog << std::endl;
exit(0);
}
}
static void checkProgram(const GLuint uiProgram)
{
GLint iStatus;
glGetProgramiv(uiProgram, GL_LINK_STATUS, &iStatus);
if(iStatus == GL_FALSE)
{
GLint iInfoLogLength;
glGetProgramiv(uiProgram, GL_INFO_LOG_LENGTH, &iInfoLogLength);
std::vector<char> vecInfoLog(iInfoLogLength);
glGetProgramInfoLog(uiProgram, iInfoLogLength, nullptr, vecInfoLog.data());
std::string strInfoLog(vecInfoLog.begin(), vecInfoLog.end());
std::cout << strInfoLog << std::endl;
exit(0);
}
}
void COpenGLRenderer::initialize()
{
if(glewInit() not_eq GLEW_OK)
{
throw std::runtime_error("Failed to initialize GLEW");
}
#ifndef NDEBUG
glEnable(GL_DEBUG_OUTPUT);
// Ensure nothing else is executed when an error occurs
glEnable(GL_DEBUG_OUTPUT_SYNCHRONOUS);
glDebugMessageCallback(errorCallback, this);
#endif
// initialize DearImGui
ImGui::CreateContext();
m_pIO = &ImGui::GetIO();
// m_pIO->ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
std::int32_t iWidth = 0;
std::int32_t iHeight = 0;
std::uint8_t* pPixels = nullptr;
m_pIO->Fonts->GetTexDataAsRGBA32(&pPixels, &iWidth, &iHeight);
m_xTexture = new Texture(pPixels, iWidth, iHeight);
m_pIO->Fonts->TexID = reinterpret_cast<void*>(m_xTexture->m_uiHandle);
const GLuint uiVertexShader = glCreateShader(GL_VERTEX_SHADER);
glShaderSource(uiVertexShader, 1, &szVS, nullptr);
glCompileShader(uiVertexShader);
checkShader(uiVertexShader);
const GLuint uiFragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
glShaderSource(uiFragmentShader, 1, &szFS, nullptr);
glCompileShader(uiFragmentShader);
checkShader(uiFragmentShader);
m_uiProgram = glCreateProgram();
glAttachShader(m_uiProgram, uiVertexShader);
glAttachShader(m_uiProgram, uiFragmentShader);
glLinkProgram(m_uiProgram);
checkProgram(m_uiProgram);
glGenBuffers(1, &m_uiVBO);
glBindBuffer(GL_ARRAY_BUFFER, m_uiVBO);
glGenBuffers(1, &m_uiEBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_uiEBO);
glCreateVertexArrays(1, &m_uiVAO);
glBindVertexArray(m_uiVAO);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), reinterpret_cast<void*>(offsetof(ImDrawVert, pos)));
glEnableVertexAttribArray(1);
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(ImDrawVert), reinterpret_cast<void*>(offsetof(ImDrawVert, uv)));
glEnableVertexAttribArray(2);
glVertexAttribPointer(2, 4, GL_UNSIGNED_BYTE, GL_TRUE, sizeof(ImDrawVert), reinterpret_cast<void*>(offsetof(ImDrawVert, col)));
glBindVertexArray(0);
ImGui::StyleColorsDark();
glEnable(GL_CULL_FACE);
glFrontFace(GL_CCW);
glCullFace(GL_BACK);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
}
void COpenGLRenderer::clearScreen()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
void COpenGLRenderer::prepareGui(const double dMousePositionX, const double dMousePositionY, const bool bMouseDown0, const bool bMouseDown1, const std::uint32_t uiWindowWidth, const std::uint32_t uiWindowHeight)
{
m_pIO->DeltaTime = 1.0f / 60.0f;
m_pIO->DisplaySize.x = uiWindowWidth;
m_pIO->DisplaySize.y = uiWindowHeight;
m_pIO->MousePos.x = dMousePositionX;
m_pIO->MousePos.y = dMousePositionY;
m_pIO->MouseDown[0] = bMouseDown0;
m_pIO->MouseDown[1] = bMouseDown1;
ImGui::NewFrame();
}
void COpenGLRenderer::renderGui()
{
ImGui::EndFrame();
ImGui::Render();
ImDrawData* const pDrawData = ImGui::GetDrawData();
renderGui(pDrawData);
}
void COpenGLRenderer::renderGui(ImDrawData* const pDrawData)
{
const std::int32_t iFramebufferWidth = pDrawData->DisplaySize.x * m_pIO->DisplayFramebufferScale.x;
const std::int32_t iFramebufferHeight = pDrawData->DisplaySize.y * m_pIO->DisplayFramebufferScale.y;
if(iFramebufferWidth <= 0 or iFramebufferHeight <= 0)
{
return;
}
pDrawData->ScaleClipRects(m_pIO->DisplayFramebufferScale);
GLint rgLastViewport[4];
glGetIntegerv(GL_VIEWPORT, rgLastViewport);
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glDisable(GL_CULL_FACE);
glDisable(GL_DEPTH_TEST);
glEnable(GL_SCISSOR_TEST);
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
const glm::vec2 xDisplayPos = { pDrawData->DisplayPos.x, pDrawData->DisplayPos.y };
const glm::vec2 xDisplaySize = { pDrawData->DisplaySize.x, pDrawData->DisplaySize.y };
glViewport(0, 0, iFramebufferWidth, iFramebufferHeight);
const glm::mat4 xOrtho = glm::ortho(xDisplayPos.x, xDisplayPos.x + xDisplaySize.x, xDisplayPos.y + xDisplaySize.y, xDisplayPos.y);
glUseProgram(m_uiProgram);
glUniform1i(glGetUniformLocation(m_uiProgram, "Texture"), 0);
glUniformMatrix4fv(glGetUniformLocation(m_uiProgram, "ProjMtx"), 1, GL_FALSE, glm::value_ptr(xOrtho));
glBindVertexArray(m_uiVAO);
glBindBuffer(GL_ARRAY_BUFFER, m_uiVBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_uiEBO);
for(std::int32_t iCommandList = 0; iCommandList < pDrawData->CmdListsCount; ++iCommandList)
{
const ImDrawList* const cmd_list = pDrawData->CmdLists[iCommandList];
const ImDrawIdx* pIndexBufferOffset = 0;
glBufferData(GL_ARRAY_BUFFER, (GLsizeiptr)cmd_list->VtxBuffer.Size * sizeof(ImDrawVert), (const GLvoid*)cmd_list->VtxBuffer.Data, GL_STREAM_DRAW);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, (GLsizeiptr)cmd_list->IdxBuffer.Size * sizeof(ImDrawIdx), (const GLvoid*)cmd_list->IdxBuffer.Data, GL_STREAM_DRAW);
for(std::int32_t iCommand = 0; iCommand < cmd_list->CmdBuffer.Size; ++iCommand)
{
const ImDrawCmd* const pcmd = &cmd_list->CmdBuffer[iCommand];
const ImVec4 clip_rect = ImVec4(pcmd->ClipRect.x - xDisplayPos.x, pcmd->ClipRect.y - xDisplayPos.y, pcmd->ClipRect.z - xDisplayPos.x, pcmd->ClipRect.w - xDisplayPos.y);
if (clip_rect.x < static_cast<float>(iFramebufferWidth) && clip_rect.y < static_cast<float>(iFramebufferHeight) && clip_rect.z >= 0.0f && clip_rect.w >= 0.0f)
{
// Apply scissor/clipping rectangle
glScissor((int)clip_rect.x, (int)(static_cast<float>(iFramebufferHeight) - clip_rect.w), (int)(clip_rect.z - clip_rect.x), (int)(clip_rect.w - clip_rect.y));
glBindTexture(GL_TEXTURE_2D, reinterpret_cast<GLuint>(pcmd->TextureId));
glDrawElements(GL_TRIANGLES, (GLsizei)pcmd->ElemCount, sizeof(ImDrawIdx) == 2 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT, pIndexBufferOffset);
}
pIndexBufferOffset += pcmd->ElemCount;
}
}
glDisable(GL_BLEND);
glEnable(GL_CULL_FACE);
glEnable(GL_DEPTH_TEST);
glDisable(GL_SCISSOR_TEST);
glViewport(rgLastViewport[0], rgLastViewport[1], rgLastViewport[2], rgLastViewport[3]);
}
static const char* errorSource(const GLenum eSource)
{
switch(eSource)
{
case GL_DEBUG_SOURCE_API: return "GL_DEBUG_SOURCE_API";
case GL_DEBUG_SOURCE_WINDOW_SYSTEM: return "GL_DEBUG_SOURCE_WINDOW_SYSTEM";
case GL_DEBUG_SOURCE_SHADER_COMPILER: return "GL_DEBUG_SOURCE_SHADER_COMPILER";
case GL_DEBUG_SOURCE_THIRD_PARTY: return "GL_DEBUG_SOURCE_THIRD_PARTY";
case GL_DEBUG_SOURCE_APPLICATION: return "GL_DEBUG_SOURCE_APPLICATION";
case GL_DEBUG_SOURCE_OTHER: return "GL_DEBUG_SOURCE_OTHER";
// TODO: Don't return value, either throw exception or use mapping array
default: return "";
}
}
static const char* errorType(const GLenum eType)
{
switch(eType)
{
case GL_DEBUG_TYPE_ERROR: return "GL_DEBUG_TYPE_ERROR";
case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: return "GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR";
case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR: return "GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR";
case GL_DEBUG_TYPE_PORTABILITY: return "GL_DEBUG_TYPE_PORTABILITY";
case GL_DEBUG_TYPE_PERFORMANCE: return "GL_DEBUG_TYPE_PERFORMANCE";
case GL_DEBUG_TYPE_MARKER: return "GL_DEBUG_TYPE_MARKER";
case GL_DEBUG_TYPE_PUSH_GROUP: return "GL_DEBUG_TYPE_PUSH_GROUP";
case GL_DEBUG_TYPE_POP_GROUP: return "GL_DEBUG_TYPE_POP_GROUP";
case GL_DEBUG_TYPE_OTHER: return "GL_DEBUG_TYPE_OTHER";
// TODO: Don't return value, either throw exception or use mapping array
default: return "";
}
}
#include <sstream>
static void errorCallback(const GLenum eSource, const GLenum eType, const GLuint uiId, const GLenum eSeverity, const GLsizei iLength, const GLchar* const szMessage, const void* const pUserParameter)
{
std::stringstream xErrorString;
xErrorString << errorSource(eSource) << ":" << errorType(eType) << "\n" << szMessage;
switch(eType)
{
case GL_DEBUG_TYPE_ERROR:
std::cerr << xErrorString.str() << std::endl;
throw std::runtime_error(szMessage);
case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR: // fallthrough
case GL_DEBUG_TYPE_PERFORMANCE: // fallthrough
case GL_DEBUG_TYPE_PORTABILITY:
std::cerr << xErrorString.str() << std::endl;
break;
}
}
| [
"[email protected]"
] | |
f7162079aa49bb9690f241b42ea6ca17fbb2bf84 | dccaab4cb32470d58399750d457d89f3874a99e3 | /3rdparty/include/Poco/MongoDB/ResponseMessage.h | 570576543bcf5568770fc8e8c6d8619eaffbe56b | [] | no_license | Pan-Rongtao/mycar | 44832b0b5fdbb6fb713fddff98afbbe90ced6415 | 05b1f0f52c309607c4c64a06b97580101e30d424 | refs/heads/master | 2020-07-15T20:31:28.183703 | 2019-12-20T07:45:00 | 2019-12-20T07:45:00 | 205,642,065 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,067 | h | //
// ResponseMessage.h
//
// Library: MongoDB
// Package: MongoDB
// Module: ResponseMessage
//
// Definition of the ResponseMessage class.
//
// Copyright (c) 2012, Applied Informatics Software Engineering GmbH.
// and Contributors.
//
// SPDX-License-Identifier: BSL-1.0
//
#ifndef MongoDB_ResponseMessage_INCLUDED
#define MongoDB_ResponseMessage_INCLUDED
#include "Poco/MongoDB/MongoDB.h"
#include "Poco/MongoDB/Message.h"
#include "Poco/MongoDB/Document.h"
#include <istream>
#include <cstdlib>
namespace Poco {
namespace MongoDB {
class MongoDB_API ResponseMessage: public Message
/// This class represents a response (OP_REPLY) from MongoDB.
{
public:
ResponseMessage();
/// Creates an empty ResponseMessage.
virtual ~ResponseMessage();
/// Destroys the ResponseMessage.
Int64 cursorID() const;
/// Returns the cursor ID.
void clear();
/// Clears the response.
std::size_t count() const;
/// Returns the number of documents in the response.
Document::Vector& documents();
/// Returns a vector containing the received documents.
bool empty() const;
/// Returns true if the response does not contain any documents.
bool hasDocuments() const;
/// Returns true if there is at least one document in the response.
void read(std::istream& istr);
/// Reads the response from the stream.
private:
Int32 _responseFlags;
Int64 _cursorID;
Int32 _startingFrom;
Int32 _numberReturned;
Document::Vector _documents;
};
//
// inlines
//
inline std::size_t ResponseMessage::count() const
{
return _documents.size();
}
inline bool ResponseMessage::empty() const
{
return _documents.size() == 0;
}
inline Int64 ResponseMessage::cursorID() const
{
return _cursorID;
}
inline Document::Vector& ResponseMessage::documents()
{
return _documents;
}
inline bool ResponseMessage::hasDocuments() const
{
return _documents.size() > 0;
}
} } // namespace Poco::MongoDB
#endif // MongoDB_ResponseMessage_INCLUDED
| [
"[email protected]"
] | |
99947b7c166292230e88a32599d567e6fe2ad554 | 30bdd8ab897e056f0fb2f9937dcf2f608c1fd06a | /CodesNew/3056.cpp | b38e2184133e709777329802a21192be72175ffa | [] | no_license | thegamer1907/Code_Analysis | 0a2bb97a9fb5faf01d983c223d9715eb419b7519 | 48079e399321b585efc8a2c6a84c25e2e7a22a61 | refs/heads/master | 2020-05-27T01:20:55.921937 | 2019-11-20T11:15:11 | 2019-11-20T11:15:11 | 188,403,594 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 953 | cpp | #pragma GCC optimize("O3")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
#define N 1000005
#define md ll(1e8)
#define ff first.first
#define fs first.second
string s = "";
int main(){
ios :: sync_with_stdio(false); cin.tie(0); cout.tie(0);
ll k;
cin >> k;
cin >> s;
ll sz = s.size();
vector <ll > sum(sz);
sum[0] = int(s[0] == '1') ;
for(int i = 1 ; i < sz ; i++ ){
sum[i] = sum[i-1] + int(s[i] == '1');
}
pair< vector <ll > :: iterator , vector <ll > :: iterator > bound = {sum.begin() , sum.end()};
if(sum[sz-1] < k){
cout << 0 << endl;
return 0;
}
ll ans = 0;
ll x;
for(int i = 0 ; i < sz ; i++){
if(sum[i] < k) continue;
x = sum[i] - k;
bound = equal_range(sum.begin() , sum.begin() + i, x);
//cout << i << " " << sum[i]<<" " << bound.second - bound.first + int(x==0)<<endl;
ans += bound.second-bound.first + int(x==0);
}
cout << ans <<endl;
return 0;
}
| [
"[email protected]"
] | |
d055807b41ad7944adce1ef670bb151becdb717a | c6c8ebb6647556273411c0f9db8cf5fb2a80c618 | /Day767.cpp | 9403d36e6aef70c97a1711471091fd71487ff574 | [] | no_license | dhanendraverma/Daily-Coding-Problem | 3d254591880439c48a3963045298c965790ae5be | 4bec6bc4fa72d7ab7a21332bdef78a544a9cb3df | refs/heads/master | 2023-01-19T15:26:18.508292 | 2023-01-14T07:27:12 | 2023-01-14T07:27:12 | 189,551,929 | 35 | 12 | null | null | null | null | UTF-8 | C++ | false | false | 1,364 | cpp | /**************************************************************************************************************************************
This problem was asked by Google.
Given a word W and a string S, find all starting indices in S which are anagrams of W.
For example, given that W is "ab", and S is "abxaba", return 0, 3, and 4.
**************************************************************************************************************************************/
#include <iostream>
#include <vector>
using namespace std;
bool compareMaps(vector<int>& s_map, vector<int>& word_map){
for(int i=0;i<256;i++)
if(s_map[i]!=word_map[i])
return false;
return true;
}
vector<int> findAnagramIndices(string word, string s)
{
vector<int> ans;
if(word.length()>s.length())
return ans;
int word_len = word.length();
vector<int> word_map(256,0), s_map(256,0);
for (int i=0; i<word_len; i++)
{
word_map[word[i]]++;
s_map[s[i]]++;
}
for (int i=word_len; i<s.length(); i++)
{
if (compareMaps(word_map, s_map))
ans.push_back(i - word_len);
s_map[s[i]]++;
s_map[s[i-word_len]]--;
}
if (compareMaps(word_map, s_map))
ans.push_back(s.length()-word_len);
return ans;
}
int main() {
string word = "ABCD";
string s = "BACDGABCDA";
vector<int> ans = findAnagramIndices(word,s);
for(auto i:ans)
cout<<i<<" ";
return 0;
}
| [
"[email protected]"
] | |
4d4a0929b089811053de5acd692fcd5f78f9ed1f | cb8349985ab353e193379a0bbf212e2526008c0b | /include/AST/arrayAccess.h | 031745f2e8757621059f91dc42e17c1c309104f1 | [] | no_license | ericluii/joos-compiler | b29869479caa4e282e4598b81c3369967b0c03a7 | 70e915ab001a4812f75302a0f516e1960600035e | refs/heads/master | 2021-01-19T07:53:46.020627 | 2015-04-06T07:23:56 | 2015-04-06T07:23:56 | 28,887,471 | 4 | 4 | null | 2015-04-06T07:23:57 | 2015-01-06T22:52:54 | C++ | UTF-8 | C++ | false | false | 1,348 | h | #ifndef __ARRAYACCESS_H__
#define __ARRAYACCESS_H__
#include "ast.h"
#include "expression.h"
#include "primary.h"
#include "evaluatedType.h"
class CompilationTable;
class ArrayAccess : public Primary {
protected:
Expression* accessExpr;
EVALUATED_TYPE accessType;
CompilationTable* accessedObject;
public:
ArrayAccess(Expression* accessExpr) : Primary(), accessExpr(accessExpr), accessType(ET_NOTEVALUATED), accessedObject(NULL) {}
virtual ~ArrayAccess() {
delete accessExpr;
}
void setTypeOfArrayElements(EVALUATED_TYPE set, CompilationTable* obj = NULL) { accessType = set; accessedObject = obj; }
bool isAccessingIntArray() { return accessType == ET_INT; }
bool isAccessingShortArray() { return accessType == ET_SHORT; }
bool isAccessingByteArray() { return accessType == ET_BYTE; }
bool isAccessingCharArray() { return accessType == ET_CHAR; }
bool isAccessingBooleanArray() { return accessType == ET_BOOLEAN; }
bool isAccessingObjectArray() { return accessType == ET_OBJECT; }
EVALUATED_TYPE getTypeOfArrayElements() { return accessType; }
CompilationTable* getTableOfArrayObjects() { return accessedObject; }
Expression* getAccessExpression() { return accessExpr; }
};
#endif
| [
"btruhand@Dariensthing.(none)"
] | btruhand@Dariensthing.(none) |
6ff98092e4d7dd6f59199129c597c314bc6402fe | 8916635ef0bd386486df23dbc75b0c7c4021f7e4 | /2012/20121030BestTime2BuyAndSellStock3.cpp | e87c099f9df3605303193525cdc9269d38417d76 | [] | no_license | ibillxia/xleetcode | 37c3570564e5a5217395a19fa9a16f9a8926cae3 | e10bda3c39b455a93764ed911de929a078046c39 | refs/heads/master | 2016-09-06T09:47:35.629057 | 2014-07-08T12:34:33 | 2014-07-08T12:34:33 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,821 | cpp | #include<iostream>
#include<vector>
#include<stack>
#include<queue>
#include<string>
#include<map>
#include<cstdio>
#include<cstring>
#include<cmath>
using namespace std;
#define FOR(i,n) for(int i=0;i<n;i++)
class Solution {
public:
int maxProfit(vector<int> &prices){
int i,sz;
sz = prices.size();
if(sz<2)return 0;
if(sz==2) return prices[0]>prices[1] ? 0 : prices[1]-prices[0];
int *f = new int[sz];
int *g = new int[sz];
memset(f,0,sizeof(int)*sz);
memset(g,0,sizeof(int)*sz);
int mi,mx;
for(i=1,mi=prices[0];i<sz;i++){
if(prices[i]<mi)mi=prices[i];
f[i]=max(f[i-1],prices[i]-mi);
}
for(i=sz-2,mx=prices[sz-1];i>=0;i--){
if(prices[i]>mx)mx=prices[i];
g[i]=max(g[i],mx-prices[i]);
}
int ans=0;
for(i=0;i<sz;i++){
ans = max(ans,f[i]+g[i]);
}
return ans;
}
int maxProfit2(vector<int> &prices) { // TLE
int i,j;
j=prices.size();
if(j<2)return 0;
if(j==2)return prices[0]>prices[1]? 0: prices[1]-prices[0];
int ma,mb,ans=0;
i=0;
while(i<j-1){
if(prices[i]>prices[i+1]){
ma = maxProfit(prices,0,i+1);
mb = maxProfit(prices,i+1,j);
if(ma+mb>ans)ans=ma+mb;
}
i++;
}
return ans;
}
private:
int maxProfit(vector<int> &prices,int start,int end){
if(start>=end)return 0;
int i=start+1,mi=start,mx=start+1,ans=0;
while(i<end){
if(prices[i]<prices[mi])mi=i;
else if(prices[i]-prices[mi]>ans)ans=prices[i]-prices[mi];
i++;
}
return ans;
}
};
int main()
{
Solution sol;
//vector<int> v(10);
//v[0]=v[1]=3;
//v[2]=v[3]=5;
//v[4]=v[5]=1;
//v[6]=v[7]=4;
//v[8]=v[9]=2;
int a[]={1,2,4,2,5,7,2,4,9,0};
vector<int> v(a,a+10);
//v[0]=v[4]=2,v[1]=v[3]=0,v[2]=1;
int ans = sol.maxProfit(v);
cout<<ans<<endl;
return 0;
}
| [
"[email protected]"
] |
Subsets and Splits