/* sort signed ints: flip highest bit, sort as unsigned, flip back */
static void radix_sort(int *a, const size_t len) {
size_t i;
uint *x = (uint*) a;
each(i, len) x[i] ^= INT_MIN;
rad_sort_u(x, x + len, INT_MIN);
each(i, len) x[i] ^= INT_MIN;
}
void test() {
int len = 16, x[16], i;
each(i, len) x[i] = rand() % 512 - 256;
each(i, len) printf("%d%c", x[i], i + 1 < len ? ' ' : '\n');
radix_sort(x, len);
each(i, len) printf("%d%c", x[i], i + 1 < len ? ' ' : '\n');
}
void radix_sort(int *a, const size_t len)
{
size_t i;
uint *x = (uint*) a;
// Flip negative signs so sorting works properly
each(i, len) x[i] ^= INT_MIN;
// Sort unsigned
rad_sort_u(x, x+len, INT_MIN);
// Flip negative signs back
each(i, len) x[i] ^= INT_MIN;
}
int main(void)
{
int len = 16, x[16], i;
size_t len = 16, i;
each(i, len) x[i] = rand() % 512 - 256;
radix_sort(x, len);
each(i, len) printf("%d%c", x[i], i + 1 < len ? ' ' : '\n');
return 0;
}
void ScreenManager::ClearAllScreens()
{
for each (Screen* s in mScreens)
s->~Screen();
mScreens.clear();
}
void Revert()
{
for each (memPatch i in changes)
WriteMemRaw(i.location, i.patch, i.patchSize);
changes.clear();
return;
}
const AABB Mesh::aabb() const {
//FIXME: This should totally be cached for speed
AABB result;
if(!this->submesh_count()) {
return result;
}
float max = std::numeric_limits<float>::max();
float min = std::numeric_limits<float>::min();
result.min = smlt::Vec3(max, max, max);
result.max = smlt::Vec3(min, min, min);
each([&result](const std::string& name, SubMesh* mesh) {
if(mesh->aabb().min.x < result.min.x) result.min.x = mesh->aabb().min.x;
if(mesh->aabb().min.y < result.min.y) result.min.y = mesh->aabb().min.y;
if(mesh->aabb().min.z < result.min.z) result.min.z = mesh->aabb().min.z;
if(mesh->aabb().max.x > result.max.x) result.max.x = mesh->aabb().max.x;
if(mesh->aabb().max.y > result.max.y) result.max.y = mesh->aabb().max.y;
if(mesh->aabb().max.z > result.max.z) result.max.z = mesh->aabb().max.z;
});
return result;
}
void Mesh::transform_vertices(const smlt::Mat4& transform, bool include_submeshes) {
shared_data->move_to_start();
for(uint32_t i = 0; i < shared_data->count(); ++i) {
if(shared_data->specification().has_positions()) {
smlt::Vec3 v = shared_data->position_at<Vec3>(i);
kmVec3MultiplyMat4(&v, &v, &transform);
shared_data->position(v);
}
if(shared_data->specification().has_normals()) {
smlt::Vec3 n;
shared_data->normal_at(i, n);
kmVec3TransformNormal(&n, &n, &transform);
shared_data->normal(n.normalized());
}
shared_data->move_next();
}
shared_data->done();
if(include_submeshes) {
each([transform](const std::string& name, SubMesh* mesh) {
if(!mesh->uses_shared_vertices()) {
mesh->transform_vertices(transform);
}
});
}
}
int BaseLocationImpl::minerals() const
{
int count=0;
for each (BWAPI::Unit* m in this->staticMinerals)
count+=m->getResources();
return count;
}
int BaseLocationImpl::gas() const
{
int count=0;
for each (BWAPI::Unit* g in this->geysers)
count+=g->getResources();
return count;
}
//=================================================================================================
void Container::Event(GuiEvent e)
{
if(e == GuiEvent_WindowResize)
{
for each(Control* ctrl in ctrls)
ctrl->Event(GuiEvent_WindowResize);
}
}
HdB::AudioSystem::~AudioSystem()
{
for each (Sound^ s in mLoadedSounds)
delete s;
mLoadedSounds->Clear();
delete mPrimaryBuffer;
delete mSoundDev;
}
void track::each(std::function<bool(track& track)> value_cb)
{
each([&](json::object& value) -> bool
{
auto v = track(std::move(value));
return value_cb(v);
});
}
size_t Path::listDir(PathList &l, bool recurse, unsigned short flags) const {
EachFunc func;
details::DirLister dl(l);
Bind(&dl, &details::DirLister::dirItem, func);
l.clear();
each(func, recurse, flags);
return l.size();
}
bool PlayState::onExit() {
for each(GameObject * go in gameObjects)
go->clean();
for each(auto texture in textures)
TextureManager::getInstance()->remove(texture);
gameObjects.clear();
textures.clear();
return true;
}
void PlayState::handleEvents(SDL_Event e) {
for each (GameObject * go in gameObjects)
go->handleEvents(e);
//EXIT
if (e.type == SDL_KEYDOWN && e.key.keysym.scancode == SDL_SCANCODE_ESCAPE) {
Game::getInstance()->getGameStateMachine()->pushState(new PauseState());
}
}
OverlaysEnum::OverlaysEnum(OverlaysContainer *pOverlays)
: refCount(0)
{
// Create a copy of overlays.
for each (Overlay *p in *pOverlays)
overlays.push_back(p);
Rewind();
}
void Board::draw(const Camera& camera)
{
// Draw the tiles
for each (Tile* var in m_Tiles)
var->draw(camera);
/*for (int i = 0; i < m_Tiles.size(); i++) // if not using C++11
m_Tiles[i]->draw(camera);*/
}
std::ostream& operator<<(std::ostream & in_stream, const CreoAssembledFeatureDefinition &in_CreoAssembledFeatureDefinition)
{
in_stream << "****************************************************************************" << std::endl;
in_stream << "Creo-Assembled-Feature-Definition read from the assembled-model feature tree" << std::endl;
in_stream << "Model Name: " << (std::string)in_CreoAssembledFeatureDefinition.modelName << std::endl;
in_stream << "Component Instance ID: " << (std::string)in_CreoAssembledFeatureDefinition.componentInstanceID << std::endl;
in_stream << "****************************************************************************" << std::endl;
if ( in_CreoAssembledFeatureDefinition.constraintSetDefinitions.size() == 0 )
in_stream << "No sets found." << std::endl;
for each ( CreoConstraintSetDefinition i in in_CreoAssembledFeatureDefinition.constraintSetDefinitions) in_stream << i;
if ( in_CreoAssembledFeatureDefinition.constraintDefinitions.size() == 0 )
in_stream << "No constraints found with valid references." << std::endl;
for each ( CreoConstraintDefinition i in in_CreoAssembledFeatureDefinition.constraintDefinitions) in_stream << i;
return in_stream;
}
int main()
{
int data[] = {32, 54, 33, 76, 4, 26, 76};
int *ptr = new int[7];
ptr = data;
for (int i = 0; i < 7; ++i)
cout << each(ptr) << " ";
delete ptr;
}
bool RelationShip::isRelationType(string relationType){
if(this->hasSizeToConnect())
return false;
bool isRType = true;
if(relationType == RelationType::One){
for each(Component* component in this->getAllConnections())
isRType &= (component->getName() == RelationType::One);
}
else{
static int rasmap_eachrme(struct RasMap* rm, int (*each)(void* data,
void* key, void* val), void* data)
{
struct RasMapElement* rme = rm->rme;
for(; 0 != rme; rme = rme->rme)
{
ras_retn_iferr(each(data, rme->key, rme->val));
}
return 0;
}
int rasmap_each(struct RasMap* rm, rasmap_each_t* each, void* data)
{
struct RasMapElement* rme;
ras_retn_if((0 == rm || 0 == each), -EINVAL);
for(rme = rm->nxt; 0 != rme; rme = rme->nxt)
{
ras_retn_iferr(each(data, rme->key, rme->val));
}
return 0;
}
void cs_selected_foreach (GCallback cb, gpointer data)
{
void (*each)(ClutterActor *actor, gpointer data)=(void*)cb;
GList *s;
for (s = selected; s; s = s->next)
{
ClutterActor *actor = s->data;
if (actor != clutter_actor_get_stage (actor))
each(actor, data);
}
}
void RemoteNode3DSub::Destroy()
{
::Ogre::String ostr_scenenode = StringConvert::CLRToOgre(PREFIX_REMOTENODE_SCENENODE + ID);
::Ogre::String ostr_entity = StringConvert::CLRToOgre(PREFIX_REMOTENODE_ENTITY + ID);
// cleanup scenenode
if (RootNode->SceneManager->hasSceneNode(ostr_scenenode))
RootNode->SceneManager->destroySceneNode(ostr_scenenode);
if (SceneNode != nullptr)
{
//SceneNode.Dispose();
SceneNode = nullptr;
}
// cleanup entity
if (RootNode->SceneManager->hasEntity(ostr_entity))
RootNode->SceneManager->destroyEntity(ostr_entity);
if (Entity != nullptr)
{
//Entity.Dispose();
Entity = nullptr;
}
if (ParticleSystems != nullptr)
{
// cleanup particle systems
for(unsigned int i=0; i<ParticleSystems->size(); i++)
{
::ParticleUniverse::ParticleSystem* particleSystem = ParticleSystems->at(i);
::ParticleUniverse::ParticleSystemManager* particleMan =
::ParticleUniverse::ParticleSystemManager::getSingletonPtr();
particleMan->destroyParticleSystem(particleSystem, RootNode->SceneManager);
}
delete ParticleSystems;
ParticleSystems = nullptr;
}
if (SubNodes != nullptr)
{
for each (RemoteNode3DSub^ subNode in SubNodes)
subNode->Destroy();
SubNodes->Clear();
SubNodes = nullptr;
}
};
void ScreenManager::Draw(float deltaTime)
{
// clear for each tick
mD3DDevice->ClearRenderTargetView( mD3DManager->mRenderTargetView, D3DXCOLOR( 0.0, 0.0, 0.0, 0.0 ) );
// draw every screen (the one in focus will always be placed on top
for each (Screen* screen in mScreens)
screen->Draw();
// set state and chain
//mD3DDevice->RSSetState(mD3DManager->pRS);
mD3DManager->mSwapChain->Present(1,0); // no lock on fps
}
PluginSettings(
#ifdef FAR3
FARAPISETTINGSCONTROL settingsControl, const GUID &guid)
{
SettingsControl = settingsControl;
handle = INVALID_HANDLE_VALUE;
FarSettingsCreate settings = {sizeof settings,guid,handle};
if(SettingsControl(INVALID_HANDLE_VALUE,SCTL_CREATE,PSL_ROAMING,&settings))
handle = settings.Handle;
#else
bool bWrite)
{
extern TCHAR PluginRootKey[];
DWORD disp;
if((bWrite ?
RegCreateKeyEx(HKEY_CURRENT_USER, PluginRootKey, 0, 0, 0, KEY_WRITE|KEY_READ, 0, &hKey, &disp) :
RegOpenKeyEx(HKEY_CURRENT_USER, PluginRootKey, 0, KEY_READ, &hKey))
!=ERROR_SUCCESS)
hKey = 0;
#endif
}
~PluginSettings()
{
#ifdef FAR3
SettingsControl(handle,SCTL_FREE,0,0);
#else
for each(HKEY hk in subKeys) //for(HKEY hk : subKeys) after moving to a newer VC
RegCloseKey(hk);
subKeys.clear();
if(hKey)
RegCloseKey(hKey);
hKey = 0;
#endif
}
KEY_TYPE CreateSubKey(PCWSTR Name, KEY_TYPE root = 0)
{
#ifdef FAR3
FarSettingsValue value = {sizeof value, root, Name};
return (KEY_TYPE)SettingsControl(handle,SCTL_CREATESUBKEY,0,&value);
#else
if(root == 0) root = hKey;
HKEY hk;
if(RegCreateKeyW(root, Name, &hk) != ERROR_SUCCESS)
return 0;
subKeys.push_back(hk);
return hk;
#endif
}
void RetrieveCreoMaterialsNames( const std::vector<std::string> &in_ListOfComponentInstanceIDs,
std::map<std::string, isis::CADComponentData> &in_CADComponentData_map,
std::map<std::string, std::string> &out_ComponentID_to_MaterialName_map )
throw (isis::application_exception)
{
bool errorOccrred = false;
std::stringstream errorNotFoundMaterials;
errorNotFoundMaterials << "Material(s) not set in Creo Model(s):";
ProMaterial material;
char stringBuffer[PRO_NAME_SIZE];
std::string materialName;
for each ( std::string i in in_ListOfComponentInstanceIDs)
{
if ( in_CADComponentData_map[i].modelType == PRO_PART )
{
try
{
isis::isis_ProMaterialCurrentGet( in_CADComponentData_map[i].modelHandle, &material );
char stringBuffer[PRO_NAME_SIZE]; // PRO_NAME_SIZE = 32
materialName = ProWstringToString( stringBuffer, material.matl_name );
// A component ID should not occurr more than once
if ( out_ComponentID_to_MaterialName_map.find(i) != out_ComponentID_to_MaterialName_map.end() )
{
std::stringstream errorString;
errorString <<
"Function: RetrieveCreoMaterialsNames, A ComponentInstanceID (" << in_CADComponentData_map[i].componentID << ") appeared more than once in in_ListOfComponentInstanceIDs" << std::endl <<
"in_ListOfComponentInstanceIDs: " << std::endl;
for each ( std::string j in in_ListOfComponentInstanceIDs )
errorString << "ComponentInstanceID: " << i << "ComponentName: " << in_CADComponentData_map[i].name;
throw isis::application_exception(errorString.str().c_str());
}
out_ComponentID_to_MaterialName_map[i] = materialName;
}
catch ( isis::application_exception ex )
{
errorOccrred = true;
errorNotFoundMaterials << std::endl <<
" Component Instance ID: " << in_CADComponentData_map[i].componentID << std::endl <<
" Component Name: " << in_CADComponentData_map[i].name << std::endl <<
" Component Type: " << ProMdlType_string(in_CADComponentData_map[i].modelType) << std::endl <<
" Exception: " << ex.what() << std::endl;
}
void test3(void)
{
jv_pool_t *pool;
jv_uint_t i;
pool=jv_pool_create(4096);
each(pool);
srand(time(NULL));
for(i=0;i<100;i++)
{
jv_uint_t j = rand()%100 + 500;
jv_lump_t* lump = (jv_lump_t*)jv_pool_alloc(pool,j);
printf("apply memory size:%u\n",j);
if(lump==NULL)
{
printf("free is error.\n");
continue;
}
jv_pool_free(pool,lump);
}
each(pool);
jv_pool_destroy(pool);
}
void Mesh::set_diffuse(const smlt::Colour& colour, bool include_submeshes) {
shared_data->move_to_start();
for(uint32_t i = 0; i < shared_data->count(); ++i) {
shared_data->diffuse(colour);
shared_data->move_next();
}
shared_data->done();
if(include_submeshes) {
each([=](const std::string& name, SubMesh* mesh) {
if(!mesh->uses_shared_vertices()) {
mesh->set_diffuse(colour);
}
});
}
}
