Example #1
0
void AggregateDeclaration::semantic3(Scope *sc)
{
    //printf("AggregateDeclaration::semantic3(%s)\n", toChars());
    if (members)
    {
        sc = sc->push(this);
        for (size_t i = 0; i < members->dim; i++)
        {
            Dsymbol *s = (*members)[i];
            s->semantic3(sc);
        }
        sc->pop();

        if (!getRTInfo)
        {   // Evaluate: gcinfo!type
            Objects *tiargs = new Objects();
            tiargs->push(type);
            TemplateInstance *ti = new TemplateInstance(loc, Type::rtinfo, tiargs);
            ti->semantic(sc);
            ti->semantic2(sc);
            ti->semantic3(sc);
            Dsymbol *s = ti->toAlias();
            Expression *e = new DsymbolExp(0, s, 0);
            e = e->semantic(ti->tempdecl->scope);
            e = e->ctfeInterpret();
            getRTInfo = e;
        }
    }
}
/* -----------------------------------------------------------------------------
 * Detection (FAKE)
 */
void SampleDetector::detect( const Mat& rgb, const Mat& depth, Objects& objects, int FLAGS )
{
    objects.clear();

    // Set a bounding box of a FAKE detection
    Object detection;
    detection.m_bb.x = 100 + (rand() % 20); 
    detection.m_bb.y = 100 + (rand() % 20); 
    detection.m_bb.width = 100 + (rand() % 5);
    detection.m_bb.height = 100 + (rand() % 5);
    
    detection.m_pos_2D.x = detection.m_bb.x + (detection.m_bb.width / 2);
    detection.m_pos_2D.y = detection.m_bb.y + (detection.m_bb.height / 2);
    
    detection.m_class = unknown;
    detection.m_score = 0;
detection.m_angle = 0;

detection.m_mask = Mat(cvSize(0, 0), CV_8U);

detection.m_timestamp = 0;
detection.m_speed = cv::Point3f(0,0,0);



    
    objects.push_back(detection);
}
Example #3
0
void AggregateDeclaration::semantic3(Scope *sc)
{
    //printf("AggregateDeclaration::semantic3(%s) type = %s, errors = %d\n", toChars(), type->toChars(), errors);
    if (!members)
        return;

    StructDeclaration *sd = isStructDeclaration();
    if (!sc)    // from runDeferredSemantic3 for TypeInfo generation
    {
        assert(sd);
        sd->semanticTypeInfoMembers();
        return;
    }

    Scope *sc2 = sc->push(this);
    sc2->stc &= STCsafe | STCtrusted | STCsystem;
    sc2->parent = this;
    if (isUnionDeclaration())
        sc2->inunion = 1;
    sc2->protection = Prot(PROTpublic);
    sc2->explicitProtection = 0;
    sc2->structalign = STRUCTALIGN_DEFAULT;
    sc2->userAttribDecl = NULL;

    for (size_t i = 0; i < members->dim; i++)
    {
        Dsymbol *s = (*members)[i];
        s->semantic3(sc2);
    }

    sc2->pop();

    // don't do it for unused deprecated types
    // or error types
    if (!getRTInfo && Type::rtinfo &&
        (!isDeprecated() || global.params.useDeprecated) &&
        (type && type->ty != Terror))
    {
        // Evaluate: RTinfo!type
        Objects *tiargs = new Objects();
        tiargs->push(type);
        TemplateInstance *ti = new TemplateInstance(loc, Type::rtinfo, tiargs);
        ti->semantic(sc);
        ti->semantic2(sc);
        ti->semantic3(sc);
        Dsymbol *s = ti->toAlias();
        Expression *e = new DsymbolExp(Loc(), s, 0);

        Scope *sc3 = ti->tempdecl->scope->startCTFE();
        sc3->tinst = sc->tinst;
        e = e->semantic(sc3);
        sc3->endCTFE();

        e = e->ctfeInterpret();
        getRTInfo = e;
    }

    if (sd)
        sd->semanticTypeInfoMembers();
}
Example #4
0
/*******************************************
 * Helper function to turn operator into template argument list
 */
Objects *opToArg(Scope *sc, enum TOK op)
{
    /* Remove the = from op=
     */
    switch (op)
    {
        case TOKaddass: op = TOKadd; break;
        case TOKminass: op = TOKmin; break;
        case TOKmulass: op = TOKmul; break;
        case TOKdivass: op = TOKdiv; break;
        case TOKmodass: op = TOKmod; break;
        case TOKandass: op = TOKand; break;
        case TOKorass:  op = TOKor;  break;
        case TOKxorass: op = TOKxor; break;
        case TOKshlass: op = TOKshl; break;
        case TOKshrass: op = TOKshr; break;
        case TOKushrass: op = TOKushr; break;
        case TOKcatass: op = TOKcat; break;
        case TOKpowass: op = TOKpow; break;
    }
    Expression *e = new StringExp(0, (char *)Token::toChars(op));
    e = e->semantic(sc);
    Objects *targsi = new Objects();
    targsi->push(e);
    return targsi;
}
Example #5
0
Objects
instances(World* world, const URISet& types)
{
	LilvNode* rdf_type = lilv_new_uri(
		world->lilv_world(), LILV_NS_RDF "type");

	Objects result;
	for (const auto& t : types) {
		LilvNode*  type    = lilv_new_uri(world->lilv_world(), t.c_str());
		LilvNodes* objects = lilv_world_find_nodes(
			world->lilv_world(), NULL, rdf_type, type);
		LILV_FOREACH(nodes, o, objects) {
			const LilvNode* object = lilv_nodes_get(objects, o);
			if (!lilv_node_is_uri(object)) {
				continue;
			}
			const std::string label = RDFS::label(world, object);
			result.insert(
				std::make_pair(label,
				               Raul::URI(lilv_node_as_string(object))));
		}
		lilv_node_free(type);
	}

	lilv_node_free(rdf_type);
	return result;
}
Example #6
0
        /** \brief
        Force the pointer for the object in store to be a specific pointer.

        This can be useful for singleton values.
        These usually must be removed from the store explicitly.

        \pre No object with this value is already in the store.
        */
        void set (std::shared_ptr <Value const> pointer) {
            // The value must not be in the store yet.
            assert (objects_.find (*pointer,
                boost::hash <Value>(), EqualToWeakPtr()) == objects_.end());

            objects_.insert (std::move (pointer));
        }
void
ObjectDeleteCommandImpl::execute()
{
  for(Objects::iterator i = objects.begin(); i != objects.end(); ++i)
  {
    object_layer.delete_object(*i);
  }
}
void
ObjectDeleteCommandImpl::undo()
{
  for(Objects::iterator i = objects.begin(); i != objects.end(); ++i)
  {
    object_layer.add_object(*i);
  }
}
void
ObjectMoveCommandImpl::undo()
{
  for(ObjectMoveCommandImpl::Objects::iterator i = objects.begin(); 
      i != objects.end();
      ++i)
  {
    i->obj.set_pos(i->old_pos);
  }
}
Example #10
0
void SEQFile::clearAnims() {
	Objects objects = getOrderedObjects();

	// Remove the animation frames, in reverse drawing order
	for (Objects::iterator o = objects.legacy_reverse_begin(); o != objects.end(); --o) {
		int16 left, top, right, bottom;

		if (o->object->clear(*_vm->_draw->_backSurface, left, top, right, bottom))
			_vm->_draw->dirtiedRect(_vm->_draw->_backSurface, left, top, right, bottom);
	}
}
	void drawCalibratedObjects(gluit::Graphics& g) const
	{
		Objects transformed = objects;
		for (Objects::Iterator object = transformed.begin(); object != transformed.end(); ++object) {
			(*object)->transform(*transformer);

			gluit::Point position = convert((*object)->getPosition());

			g.setColor(0xFF6666CC);
			g.drawEllipse(gluit::Rectangle(gluit::Size(40)).centerOn(position), true);
		}
	}
Example #12
0
void Frame::drawAll()
{
	clear(sf::Color::Black);
	Objects toDraw = objectsInBounds(sf::FloatRect(sf::Vector2f(0,0),_bounds));
	Objects::iterator it = toDraw.begin();
	for(;it != toDraw.end();it++)
	{
		(*it)->onDisplay();
		draw(*(*it)->getDrawable());
	}
	display();
}
Example #13
0
void SEQFile::drawAnims() {
	Objects objects = getOrderedObjects();

	// Draw the animation frames and advance the animation
	for (Objects::iterator o = objects.begin(); o != objects.end(); ++o) {
		int16 left, top, right, bottom;

		if (o->object->draw(*_vm->_draw->_backSurface, left, top, right, bottom))
			_vm->_draw->dirtiedRect(_vm->_draw->_backSurface, left, top, right, bottom);

		o->object->advance();
	}
}
Example #14
0
	// remove all contained objects. 
	virtual void clear()
	{
		while(!objects.empty())
		{
#ifdef _DEBUG
			Target *obj=objects.begin()->second;
			delete obj;
#else
			delete objects.begin()->second;
#endif
		}
		assert(objects.empty());
	}
Example #15
0
        // Rvalue reference.
        std::shared_ptr <Value const> get (Value && value) {
            auto existing = objects_.find (value,
                boost::hash <Value>(), EqualToWeakPtr());
            if (existing != objects_.end())
                return existing->get();

            // The value is not in the store yet; insert it.
            auto sole = SoleType::construct (*this, std::move (value));
            Pointer newElement (sole);
            objects_.insert (std::move (newElement));

            return sole;
        }
Example #16
0
	// called in Stored constructor
	// assignes new unique ID and back iterator
	virtual ID add(Target * object)
	{
		assert(generator);
		if(!valid(object->id()))	
			object->localID=generator->generate(object);
		else if(contains(object->id()))
		{
			assert(false);
		}
		objects.insert(std::make_pair(object->id(),object));	
		Objects::iterator it=objects.find(object->id());
		object->back=it;
		onAdd(object);		// raise onAdd event.
		return object->id();
	}
Example #17
0
  void clear()
  {
    for(typename Objects::reverse_iterator i = objects.rbegin(); i != objects.rend(); ++i)
      (*i)->~T();
    objects.clear();

    // FIXME: We don't have to delete the chunks, instead we should
    // just reset the pointer to start and reuse them
    for(typename Chunks::reverse_iterator i = chunks.rbegin(); i != chunks.rend(); ++i)
    {
      delete[] *i;
    }
    chunks.clear();

    next_free = 0;
  }
Example #18
0
ObjectLayer::Objects
ObjectLayer::get_selection(const CL_Rectf& rect)
{
  Objects selection;

  for(Objects::iterator i = impl->objects.begin(); i != impl->objects.end(); ++i)
  {
    // FIXME:
    if (rect.is_inside((*i).get_pos()))
    {
      selection.push_back(*i);
    }
  }

  return selection;
}
Example #19
0
	void Print(std::ostream& stream)
	{
		std::vector<Objects::const_iterator> referencedObjects;
		referencedObjects.reserve(links.size());
		for(Links::const_iterator i = links.begin(); i != links.end(); ++i)
			referencedObjects.push_back(i->second);
		std::sort(referencedObjects.begin(), referencedObjects.end());
		referencedObjects.resize(std::unique(referencedObjects.begin(), referencedObjects.end()) - referencedObjects.begin());

		// пока просто вывести
		for(Objects::const_iterator object = objects.begin(); object != objects.end(); ++object)
		{
			if(std::binary_search(referencedObjects.begin(), referencedObjects.end(), object))
				continue;
			Print(stream, object);
		}
	}
Example #20
0
        /** \brief
        Retrieve the sole object with value \a value.

        If an object with this value is already in the store, return a pointer
        to that object.
        If not, return a pointer to a newly allocated object.
        */
        std::shared_ptr <Value const> get (Value const & value) {
            auto existing = objects_.find (value,
                boost::hash <Value>(), EqualToWeakPtr());
            if (existing != objects_.end())
                return existing->get();

            // The value is not in the store yet; insert it.
            auto sole = SoleType::construct (*this, value);
            Pointer newElement (sole);
            // Note that this insertion involves a mere copy of newElement into
            // another place in memory.
            // No objects will therefore be deleted, and no objects will
            // therefore attempt to remove themselves from the store.
            objects_.insert (std::move (newElement));

            return sole;
        }
Example #21
0
File: struct.c Project: duralog/ldc
void AggregateDeclaration::semantic3(Scope *sc)
{
#if IN_LLVM
    if (!global.inExtraInliningSemantic)
        availableExternally = false;
#endif

    //printf("AggregateDeclaration::semantic3(%s)\n", toChars());
    if (members)
    {
        sc = sc->push(this);
        sc->parent = this;
        for (size_t i = 0; i < members->dim; i++)
        {
            Dsymbol *s = (*members)[i];
            s->semantic3(sc);
        }

        if (StructDeclaration *sd = isStructDeclaration())
        {
            //if (sd->xeq != NULL) printf("sd = %s xeq @ [%s]\n", sd->toChars(), sd->loc.toChars());
            //assert(sd->xeq == NULL);
            if (sd->xeq == NULL)
                sd->xeq = sd->buildXopEquals(sc);
        }
        sc = sc->pop();

        if (!getRTInfo && Type::rtinfo &&
            (!isDeprecated() || global.params.useDeprecated) && // don't do it for unused deprecated types
            (type && type->ty != Terror)) // or error types
        {   // Evaluate: gcinfo!type
            Objects *tiargs = new Objects();
            tiargs->push(type);
            TemplateInstance *ti = new TemplateInstance(loc, Type::rtinfo, tiargs);
            ti->semantic(sc);
            ti->semantic2(sc);
            ti->semantic3(sc);
            Dsymbol *s = ti->toAlias();
            Expression *e = new DsymbolExp(Loc(), s, 0);
            e = e->ctfeSemantic(ti->tempdecl->scope);
            e = e->ctfeInterpret();
            getRTInfo = e;
        }
    }
}
Example #22
0
unsigned int ReturnObjectListImpl::numberOfValidObjects() const
{
    for (size_t i = objects.size()-1; i >= 0; i--)
    {
      if(!objects[i].empty()) return (unsigned int)(i+1);
    }

    return 0;
}
void InitBulletPhysics()
{
	m_collisionConfiguration = new btDefaultCollisionConfiguration(); //collision configuration contains default setup for memory, collision setup
	m_dispatcher			 = new btCollisionDispatcher(m_collisionConfiguration); //use the default collision dispatcher 
	m_broadphase		  	 = new btDbvtBroadphase();
	m_solver			 	 = new btSequentialImpulseConstraintSolver; //the default constraint solver
	m_dynamicsWorld			 = new btDiscreteDynamicsWorld(m_dispatcher,m_broadphase,m_solver,m_collisionConfiguration);
	m_dynamicsWorld->setGravity(btVector3(0,-20,0));

	g_fPosX  = 0.0f;
	g_fPosY  = -5.0f;
	g_fPosZ  = 0.0f;

	Objects Object;  //This Order Must Be Preserved
	Object.createGround(-3.0f);
	Object.createWallZ(5, 10, 2.0, 0.0f, 0.0f, 0.0f);
	Object.createStones(50.0f, 0.0f, 10.0f, 1);
}
Example #24
0
void
Store::remove(const iterator top, Objects& removed)
{
	if (top != end()) {
		const iterator descendants_end = find_descendants_end(top);
		removed.insert(top, descendants_end);
		erase(top, descendants_end);
	}
}
TimelineLayer::Objects
TimelineLayer::get_objects(float selection_start, float selection_end) const
{
    assert(selection_start <= selection_end);

    Objects objects;

    for(const_iterator i = begin(); i != end(); ++i)
    {
        if (selection_start <= (*i)->get_pos() &&
                selection_end   >  (*i)->get_pos() + (*i)->get_width())
        {
            objects.push_back(*i);
        }
    }

    return objects;
}
Example #26
0
/***********************************************
 * This is mostly the same as UnaryExp::op_overload(), but has
 * a different rewrite.
 */
Expression *CastExp::op_overload(Scope *sc)
{
    //printf("CastExp::op_overload() (%s)\n", toChars());
    AggregateDeclaration *ad = isAggregate(e1->type);
    if (ad)
    {
        Dsymbol *fd = NULL;
        /* Rewrite as:
         *      e1.opCast!(T)();
         */
        fd = search_function(ad, Id::cast);
        if (fd)
        {
#if 1 // Backwards compatibility with D1 if opCast is a function, not a template
            if (fd->isFuncDeclaration())
            {   // Rewrite as:  e1.opCast()
                return build_overload(loc, sc, e1, NULL, fd);
            }
#endif
            Objects *targsi = new Objects();
            targsi->push(to);
            Expression *e = new DotTemplateInstanceExp(loc, e1, fd->ident, targsi);
            e = new CallExp(loc, e);
            e = e->semantic(sc);
            return e;
        }

        // Didn't find it. Forward to aliasthis
        if (ad->aliasthis)
        {
            /* Rewrite op(e1) as:
             *  op(e1.aliasthis)
             */
            Expression *e1 = new DotIdExp(loc, this->e1, ad->aliasthis->ident);
            Expression *e = copy();
            ((UnaExp *)e)->e1 = e1;
            e = e->trySemantic(sc);
            return e;
        }
    }
    return NULL;
}
	void handleSourceDataUpdate(const Source<Objects>& source)
	{
		Objects::Mutex::scoped_lock lock(objects.mutex);

		objects = source.get();

		if (calibrating) {
			for (Objects::Iterator object = objects.begin(); object != objects.end(); ++object) {
				if ((*object)->isNew()) {
					objectAdded(*object);
				} else if ((*object)->isDead()) {
					objectRemoved(*object);
				} else {
					objectUpdated(*object);
				}
			}
		}

		repaint();
	}
Example #28
0
void
Store::rename(const iterator top, const Raul::Path& new_path)
{
	const Raul::Path old_path = top->first;

	// Remove the object and all its descendants
	Objects removed;
	remove(top, removed);

	// Rename all the removed objects
	for (Objects::const_iterator i = removed.begin(); i != removed.end(); ++i) {
		const Raul::Path path = (i->first == old_path)
			? new_path
			: new_path.child(
				Raul::Path(i->first.substr(old_path.base().length() - 1)));

		i->second->set_path(path);
		assert(find(path) == end());  // Shouldn't be dropping objects!
		insert(make_pair(path, i->second));
	}
}
Example #29
0
	// called in Stored destructor
	// removes the object from list. returns iterator to next valid object.
	virtual void remove(Target * object)
	{
		// some STL versions of remove return void instead 
		// of returning iterator to next object. So we 
		// need to get it manually
		onRemove(object);	// raise onRemove event
		generator->free(object->id());
		object->localID=-1;
		//idGenerator.freeID(object->id());
	
		objects.erase(object->back);	
	}
Example #30
0
void TUIOSender::send(const Objects& objects)
{
	Mutex::scoped_lock lock(mutex);

	if (!socket) {
		return;
	}

	try {
		char buffer[OUTBOUND_PACKET_STREAM_BUFFER_SIZE];
		osc::OutboundPacketStream p(buffer, OUTBOUND_PACKET_STREAM_BUFFER_SIZE);

		p << osc::BeginBundleImmediate;

		p << osc::BeginMessage(oscAddress.getValue().c_str()) << "source" << sourceId.get().c_str() << osc::EndMessage;

		p << osc::BeginMessage(oscAddress.getValue().c_str());
		p << "alive";
		for (Objects::ConstIterator object = objects.begin(); object != objects.end(); ++object) {
			if ((*object)->isAlive()) {
				p << int((*object)->getId());
			}
		}
		p << osc::EndMessage;

		for (Objects::ConstIterator object = objects.begin(); object != objects.end(); ++object) {
			if ((*object)->isAlive()) {
				p << osc::BeginMessage(oscAddress.getValue().c_str()) << "set" << (*object) << osc::EndMessage;
			}
		}

		p << osc::BeginMessage(oscAddress.getValue().c_str()) << "fseq" << int(frameSequenceNumber++) << osc::EndMessage;

		p << osc::EndBundle;

		socket->Send(p.Data(), p.Size());
	} catch (osc::OutOfBufferMemoryException& e) {
		LOG4CPLUS_ERROR(logger, "Sending objects failed, too many objects to send (" << objects.getSize() << ")");
	}
}