/*
 * sets the supported operational attributes (if required)
 */
int
ldbm_back_operational(
	BackendDB	*be,
	Connection	*conn, 
	Operation	*op,
	Entry		*e,
	AttributeName		*attrs,
	int		opattrs,
	Attribute	**a )
{
	Attribute	**aa = a;

	assert( e );

	if ( opattrs || ad_inlist( slap_schema.si_ad_hasSubordinates, attrs ) ) {
		int	hs;

		hs = has_children( be, e );
		*aa = slap_operational_hasSubordinate( hs );
		if ( *aa != NULL ) {
			aa = &(*aa)->a_next;
		}
	}
	
	return 0;
}
Exemple #2
0
 void item::remove()
 {
   while(has_children())
     {
       first_child_item->remove();
     }
   data->self_refs.erase(relation_ptr->get_name());
   if(prev_item)
     prev_item->next_item=next_item;
   else
     {
       if(parent_item)
         parent_item->first_child_item=next_item;
       else
         relation_ptr->head=next_item;
     }
   if(next_item)
     next_item->prev_item=prev_item;
   else
     {
       if(parent_item)
         parent_item->last_child_item=prev_item;
       else
         relation_ptr->tail=prev_item;
     }
   delete this;
 }
Exemple #3
0
void delete_min_phase_1(heap *h) {
    node *min = h->root;
    if (has_children(min)) {
        // Orphan all children
        node *first = min->child;
        node *curr  = min->child;
        do {
            curr->parent = NULL;
            curr = curr->right_sibling;
        } while (curr != first);

        // If the root has siblings, first cut it out of its sibling list
        // and then meld sibling and children lists
        if (has_siblings(min)) {
            node *rsib = min->right_sibling;
            cut_from_sibling_list(min);
            meld(first, rsib);
        }

        // Pick the first child as the new temporary root
        h->root = first;
    } else {
        // Due to the early return in the top, we are guaranteed that
        // if min has no children, it must have siblings, so we start
        // by cutting it out of its sibling list.
        node *sib = min->right_sibling;
        cut_from_sibling_list(min);

        // Pick a sibling (arbitrary) as the new temporary root
        h->root = sib;
    }
}
int count(link x)
{
    link u = x->l, v = x->r;

    if (u == NULL && v == NULL)
        return 0;
    if (u != NULL && v == NULL)
        return count(u);
    if (u == NULL && v != NULL)
        return count(v);
    if (has_children(u) && !has_children(v))
        return 1 + count(u);
    if (has_children(v) && !has_children(u))
        return 1 + count(v);
    return count(u) + count(v);
}
Exemple #5
0
/// Was the event on the 'collapse' button?
///
int Fl_Tree_Item::event_on_collapse_icon(const Fl_Tree_Prefs &prefs) const {
    if ( _visible && _active && has_children() && prefs.showcollapse() ) {
        return(event_inside(_collapse_xywh) ? 1 : 0);
    } else {
	return(0);
    }
}
Node* Node::get_last_child()
{
    if (has_children())
    {
        return child(num_children() - 1)->get_last_child();
    }
    return this;
}
Exemple #7
0
void MultiGrid::element_to_be_erased(TElem* elem)
{
//	we have to remove the elements children as well.
	if(has_children(elem)){
		get_info(elem).unregister_from_children(*this);
	}
//	we have to remove the associated info object
	release_child_info(elem);
}
Exemple #8
0
QuadTree::~QuadTree(){
	delete bodies;
	if(has_children()) {
		for(QuadTree * t : children) {
			delete t;
		}
	}
	if(_remove_bodies_list != nullptr) delete _remove_bodies_list;
}
Exemple #9
0
grid_octree_node* grid_octree_node::
get_child_at_index(const size_t& index)
{
	if(!has_children() || index > 8)
	{
		return nullptr;
	}
	
	return child_nodes_[index];
}
Exemple #10
0
void get_paths(QStringList paths){
    QString str;

    foreach(str, paths){
        if(has_children(str)){
            get_paths(get_absolute_dir_paths(str));
            store_paths(get_absolute_file_paths(str));
        }
    }
}
Exemple #11
0
/*!

\brief Determines if the config context is empty.
\return Returns dmz::True if the config context has no attributes and no children.
Also returns dmz::True if the config context is NULL.

*/
dmz::Boolean
dmz::Config::is_empty () const {

   Boolean result (True);

   if (_state.context) {

      if (_state.context->attrTable.get_count ()) { result = False; }
      else { result = !has_children (); }
   }

   return result;
}
Exemple #12
0
/*!

\brief Adds the children from a config context.
\details This function is equivalent to iterating through \a Data's children and
adding them one at a time.
\param[in] Data Config containing config context of which its children will be added.
\return Returns dmz::True if the children were added.

*/
dmz::Boolean
dmz::Config::add_children (const Config &Data) {

   if (_state.context && _state.context->Name) {

      ConfigIterator it;
      Config cd;

      while (Data.get_next_config (it, cd)) { add_config (cd); }
   }

   return has_children ();
}
Exemple #13
0
node* delete_min(heap *h) {
    // In the special case where the heap root has no siblings and no
    // children, we can simply null the root, decrease the size, and
    // return early, as no complicated work is required.
    node *min = h->root;
    if (!has_children(min) && !has_siblings(min)) {
        h->root = NULL;
        h->size -= 1;
        return min;
    }

    // Step 1: Remove minimum node (min)
    // If min has children, they are orphaned. If min also has siblings,
    // min is cut out from the sibling list, which is then combined with
    // the children list.
    // If min has siblings but no children, it is just cut out from the
    // sibling list.
    delete_min_phase_1(h);

    // Step 2: Link roots of same rank/degree
    // We use an array to keep track of the last seen root of each rank,
    // and link roots whenever we get a collision. The node that remains
    // a root gets a promotion (rank++), and is attempted inserted into
    // its new place in the array, where we again link in case of a new
    // collision, and so on.
    // To make sure the root pointer in the heap continues to point to
    // an actual root, we update it to point to the "link winner" every
    // time we link.
    // Because the initial root may not remain as such, we also have to
    // keep track of an "end" node, i.e. the right-most (last) node in
    // the sibling list of the root (its left sibling), starting from
    // the initial root itself.
    // In the linking step, the "loser" (the root with the highest key
    // value) is cut out of its sibling list, and combined with the
    // children list of the "winner".
    delete_min_phase_2(h);

    // Step 3: Find new min
    // We simply iterate over all root nodes, updating the root pointer
    // of the heap every time we find a smaller key
    delete_min_phase_3(h);

    // Finally, decrease heap size, and return the extracted min node
    h->size -= 1;
    return min;
}
/*
 * sets *hasSubordinates to LDAP_COMPARE_TRUE/LDAP_COMPARE_FALSE
 * if the entry has children or not.
 */
int
ldbm_back_hasSubordinates(
	BackendDB	*be,
	Connection	*conn, 
	Operation	*op,
	Entry		*e,
	int		*hasSubordinates )
{
	if ( has_children( be, e ) ) {
		*hasSubordinates = LDAP_COMPARE_TRUE;

	} else {
		*hasSubordinates = LDAP_COMPARE_FALSE;
	}

	return 0;
}
Exemple #15
0
bool QuadTree::insert(Body* b){
	// Ignore objects which do not belong in this quad tree
	if (!boundary.containsPoint(b->position)){
		return false;
	}

	if (!has_children() && bodies->size() < QT_NODE_CAPACITY){
		// std::cout << "adding " << b << std::endl;
		//node_b.position = b->position;
		bodies->push_back(b);
		return true;
	}

	if( northWest == nullptr ){
		subdivide();
	}

	bool inserted = false;
	for(QuadTree * child : children) {
		if(child->insert(b)) {
			inserted = true;
			break;
		}
	}

	add_body(b);

	while(!bodies->empty()){
		b = bodies->back();
		bodies->pop_back();
		//node_mass+=b.mass;
		add_body(b);

		for(QuadTree * child : children) {
			if(child->insert(b)) {
				inserted = true;
				break;
			}
		}
	}
	
	if(inserted) return true;
	// Otherwise, the point cannot be inserted for some unknown reason (which should never happen)
	return false;
}
Exemple #16
0
bool QuadTree::print_tree(int depth){
	for(int i = 0 ; i < depth ; ++i){
		std::cout << "\t";
	}
	if(!has_children()){
		if(bodies->size() != 0){
			for(std::vector<Body*>::iterator it = bodies->begin() ; it != bodies->end() ; ++it){
				std::cout << **it ;
			}
			std::cout << std::endl;
		}else{std::cout << "Empty leaf" << std::endl;}
		return true;
	}
	std::cout << "Empty node " << node_b.mass << " x: " << node_b.position.x << " y: " << node_b.position.y << std::endl;
	depth++;
	northWest->print_tree(depth +1);
	northEast->print_tree(depth +1);
	southWest->print_tree(depth +1);
	southEast->print_tree(depth +1);

	return true;
}
Exemple #17
0
int QuadTree::_update(Body ** removed_bodies) {
	int index = 0;
	if(!has_children()) {
		for(size_t i=0; i<bodies->size(); ++i) {
			if(!boundary.containsPoint((*bodies)[i]->position)) {
				remove_body((*bodies)[i]);
				removed_bodies[index++] = (*bodies)[i];
				bodies->erase(bodies->begin() + i);
			}
		}
	} else if(northWest != NULL) {

		int empty = 0;
		for(QuadTree * t : children) {
			index += t->_update(removed_bodies + index);
			if(t->empty()) ++empty;
		}

		if(empty == 4) {
			/* All childrens are empty, delete them, so that we also become empty */
			for(QuadTree * &t : children) {
				delete t;
				t = nullptr;
			}
		}

		for(int i=0;i<index;++i) {
			remove_body(removed_bodies[i]);
		}
	} else {
		printf("Derp\n");
		abort();
	}

	return index;
}
Exemple #18
0
void MultiGrid::
clear_child_connections(TElem* parent)
{
	if(has_children(parent))
		get_info(parent).unregister_from_children(*this);
}
Exemple #19
0
void delete_min_phase_2(heap *h) {
    int max_rank = (int) ceil(2 * (log(h->size + 1) / log(2.0)));
    node *ranks[max_rank];
    for (int i = 0; i < max_rank; i++) {
        ranks[i] = NULL;
    }

    // The chain of root nodes is modified in the linking step, so to make
    // absolutely sure we go through all the root nodes, we store pointers
    // to them in an array, and iterate the array instead of depending on
    // the possibly shifty sibling list.
    int n = root_count(h);
    node **roots = (node**) malloc(n * sizeof(node*));

    // Populate the array
    node *current = h->root;
    for (int i = 0; i < n; i++) {
        roots[i] = current;
        current = current->right_sibling;
    }

    // Go through each node in the array
    for (int i = 0; i < n; i++) {
        node *curr = roots[i];

        // If there are pre-existing array entries, start linking
        while (ranks[curr->rank] != NULL) {
            // Determine winner and loser
            node *winner = (curr->key < ranks[curr->rank]->key ? curr : ranks[curr->rank]);
            node *loser  = (curr->key < ranks[curr->rank]->key ? ranks[curr->rank] : curr);

            // Null the array entry right away
            ranks[curr->rank] = NULL;

            // Update loser's parent pointer and promote winner
            loser->parent = winner;
            winner->rank += 1;

            // Cut loser out of its sibling list, and meld with the
            // children list of the winner (if any, otherwise just
            // set the loser as the only child of the winner).
            cut_from_sibling_list(loser);
            if (has_children(winner)) {
                meld(winner->child, loser);
            } else {
                winner->child = loser;
            }

            // Update current to be the winner
            curr = winner;
        }

        // Otherwise/finally, insert current into its place in the
        // array, and make it the temporary heap root.
        ranks[curr->rank] = curr;
        h->root = curr;
    }

    // Free the possibly HUGE array
    free(roots);
}
Exemple #20
0
/// Draw this item and its children.
void Fl_Tree_Item::draw(int X, int &Y, int W, Fl_Widget *tree, 
                        const Fl_Tree_Prefs &prefs, int lastchild) {
    if ( ! _visible ) return; 
    fl_font(_labelfont, _labelsize);
    int H = _labelsize + fl_descent() + prefs.linespacing();
    // Colors, fonts
    Fl_Color fg = _selected ? prefs.bgcolor()     : _labelfgcolor;
    Fl_Color bg = _selected ? prefs.selectcolor() : _labelbgcolor;
    if ( ! _active ) {
	fg = fl_inactive(fg);
	if ( _selected ) bg = fl_inactive(bg);
    }
    // Update the xywh of this item
    _xywh[0] = X;
    _xywh[1] = Y;
    _xywh[2] = W;
    _xywh[3] = H;
    // Text size
    int textw=0, texth=0;
    fl_measure(_label, textw, texth, 0);
    int textycenter = Y+(H/2);
    int &icon_x = _collapse_xywh[0] = X-1;
    int &icon_y = _collapse_xywh[1] = textycenter - (prefs.openicon()->h()/2);
    int &icon_w = _collapse_xywh[2] = prefs.openicon()->w();
    _collapse_xywh[3] = prefs.openicon()->h();
    // Horizontal connector values
    int hstartx  = X+icon_w/2-1;
    int hendx    = hstartx + prefs.connectorwidth();
    int hcenterx = X + icon_w + ((hendx - (X + icon_w)) / 2);

    // See if we should draw this item
    //    If this item is root, and showroot() is disabled, don't draw.
    //
    char drawthis = ( is_root() && prefs.showroot() == 0 ) ? 0 : 1;
    if ( drawthis ) {
	// Draw connectors
	if ( prefs.connectorstyle() != FL_TREE_CONNECTOR_NONE ) {
	    // Horiz connector between center of icon and text
	    draw_horizontal_connector(hstartx, hendx, textycenter, prefs);
	    if ( has_children() && is_open() ) {
		// Small vertical line down to children
		draw_vertical_connector(hcenterx, textycenter, Y+H, prefs);
	    }
	    // Connectors for last child
	    if ( ! is_root() ) {
		if ( lastchild ) {
		    draw_vertical_connector(hstartx, Y, textycenter, prefs);
		} else {
		    draw_vertical_connector(hstartx, Y, Y+H, prefs);
		}
	    }
	} 
	// Draw collapse icon
	if ( has_children() && prefs.showcollapse() ) {
	    // Draw icon image
	    if ( is_open() ) {
		prefs.closeicon()->draw(icon_x,icon_y);
	    } else {
		prefs.openicon()->draw(icon_x,icon_y);
	    }
	}
	// Background for this item
	int &bx = _label_xywh[0] = X+(icon_w/2-1+prefs.connectorwidth());
	int &by = _label_xywh[1] = Y;
	int &bw = _label_xywh[2] = W-(icon_w/2-1+prefs.connectorwidth());
	int &bh = _label_xywh[3] = texth;
	// Draw bg only if different from tree's bg
	if ( bg != tree->color() || is_selected() ) {
	    if ( is_selected() ) {
		// Selected? Use selectbox() style
		fl_draw_box(prefs.selectbox(), bx, by, bw, bh, bg);
	    } else {
		// Not Selected? use plain filled rectangle
		fl_color(bg);
		fl_rectf(bx, by, bw, bh);
	    }
	}
	// Draw user icon (if any)
	int useroff = (icon_w/2-1+prefs.connectorwidth());
	if ( usericon() ) {
	    // Item has user icon? Use it
	    useroff += prefs.usericonmarginleft();
	    usericon()->draw(X+useroff,icon_y);
	    useroff += usericon()->w();
	} else if ( prefs.usericon() ) {
	    // Prefs has user icon? Use it
	    useroff += prefs.usericonmarginleft();
	    prefs.usericon()->draw(X+useroff,icon_y);
	    useroff += prefs.usericon()->w();
	}
	useroff += prefs.labelmarginleft();
	// Draw label
	if ( widget() ) {
	    // Widget? Draw it
	    int lx = X+useroff;
	    int ly = by;
	    int lw = widget()->w();
	    int lh = bh;
	    if ( widget()->x() != lx || widget()->y() != ly ||
		 widget()->w() != lw || widget()->h() != lh ) {
		widget()->resize(lx, ly, lw, lh);		// fltk will handle drawing this
	    }
	} else {
	    // No label widget? Draw text label
	    if ( _label ) {
		fl_color(fg);
		fl_draw(_label, X+useroff, Y+H-fl_descent()-1);
	    }
	}
	Y += H;
    }			// end drawthis
    // Draw children
    if ( has_children() && is_open() ) {
	int child_x = drawthis ? 			// offset children to right,
	              (hcenterx - (icon_w/2) + 1) : X;	// unless didn't drawthis
	int child_w = W - (child_x-X);
	int child_y_start = Y;
	for ( int t=0; t<children(); t++ ) {
	    int lchild = ((t+1)==children()) ? 1 : 0;
	    _children[t]->draw(child_x, Y, child_w, tree, prefs, lchild);
	}
	if ( has_children() && is_open() ) {
	    Y += prefs.openchild_marginbottom();	// offset below open child tree
	}
	if ( ! lastchild ) {
	    draw_vertical_connector(hstartx, child_y_start, Y, prefs);
	}
    }
}