Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from http://www.ncbi.nlm.nih.gov/IEB/ToolBox/CPP_DOC/doxyhtml/tree__msvc7_8hpp_source.html below:

NCBI C++ ToolKit: include/algo/structure/cd_utils/tree_msvc7.hpp Source File

<

T1,

T2>

((

*) p) T1(

);

<

T,

tree_node_allocator = std::allocator<tree_node_<T> > >

:

stlport::bidirectional_iterator<T, ptrdiff_t> {

* operator->()

;

skip_children();

number_of_children()

;

set_first_parent_();

find_leftmost_parent_();

<

iter> iter parent(iter)

;

<

iter> iter erase(iter);

<

iter> iter append_child(iter position);

<

iter> iter append_child(iter position,

& x);

<

iter> iter append_child(iter position, iter other_position);

<

iter> iter insert(iter position,

& x);

<

iter> iter insert_subtree(iter position,

& subtree);

<

iter> iter insert_after(iter position,

& x);

<

iter> iter replace(iter position,

& x);

<

iter> iter replace(iter position,

& from);

<

iter> iter

(iter position);

<

iter> iter reparent(iter position, iter from);

<

iter> iter move_before(iter target, iter

);

duplicate_leaves=

);

<

StrictWeakOrdering>

<

iter>

equal(

iter& one,

iter& two,

iter& three)

;

<

iter,

BinaryPredicate>

equal(

iter& one,

iter& two,

iter& three, BinaryPredicate)

;

<

iter>

equal_subtree(

iter& one,

iter& two)

;

<

iter,

BinaryPredicate>

equal_subtree(

iter& one,

iter& two, BinaryPredicate)

;

()

;

number_of_children(

&)

;

number_of_siblings(

&)

;

one.node < two.

;

attachNode, oldParent, z, zz;

nTopLevelNodes = number_of_siblings(begin());

= subtree(newRoot, next_sibling(newRoot));

oldParent = parent(newRoot);

z = parent(oldParent);

attachNode =

.reparent(attachNode, oldParent, next_sibling(oldParent));

(nTopLevelNodes > 1) {

(nTopLevelNodes > 2) {

(z.

() && z != end()) {

zz = next_sibling(z);

.reparent(attachNode, z, zz);

nChildren =

.number_of_children(attachNode);

(nChildren <= 1) {

oldParent =

.parent(attachNode);

(nChildren == 1) {

z =

.reparent(oldParent, attachNode.

(), next_sibling(attachNode.

()));

head_initialise_();

<

StrictWeakOrdering>

<

T,

tree_node_allocator>

(one.node > two.

)

;

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

replace(begin(), other);

<

T,

tree_node_allocator>

alloc_.deallocate(

,1);

alloc_.deallocate(feet,1);

<

T,

tree_node_allocator>

feet = (

*) alloc_.allocate(1);

->first_child=0;

->prev_sibling=0;

->next_sibling=feet;

feet->prev_sibling=

;

feet->next_sibling=0;

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

(it!=other.

()) {

to=insert(to, (*it));

(it!=other.

()) {

<

T,

tree_node_allocator>

(

->next_sibling!=feet)

<

T,

tree_node_allocator>

alloc_.deallocate(

,1);

<

T,

tree_node_allocator>

<

iter>

alloc_.deallocate(cur,1);

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

(

->first_child)

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

curdepth=0;

(curdepth<dp) {

(

->first_child==0) {

std::range_error(

);

<

T,

tree_node_allocator>

curdepth=1;

(curdepth<dp) {

(

->first_child==0) {

std::range_error(

);

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

iter>

(position.node!=0);

iter(position.node->parent);

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

iter>

->parent=position.node;

(position.node->last_child!=0) {

position.node->last_child->next_sibling=

;

position.node->first_child=

;

->prev_sibling=position.node->last_child;

position.node->last_child=

;

->next_sibling=0;

<

T,

tree_node_allocator>

<

iter>

->parent=position.node;

(position.node->last_child!=0) {

position.node->last_child->next_sibling=

;

position.node->first_child=

;

->prev_sibling=position.node->last_child;

position.node->last_child=

;

->next_sibling=0;

<

T,

tree_node_allocator>

<

iter>

replace(aargh, other);

<

T,

tree_node_allocator>

<

iter>

insert_subtree(position.end(), from);

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

iter>

(position.node==0) {

->parent=position.node->parent;

->next_sibling=position.node;

->prev_sibling=position.node->prev_sibling;

position.node->prev_sibling=

;

(

->prev_sibling==0)

->parent->first_child=

;

->prev_sibling->next_sibling=

;

<

T,

tree_node_allocator>

->next_sibling=position.

;

(position.

==0) {

->parent->last_child=

;

(

->prev_sibling==0)

->parent->first_child=

;

->prev_sibling->next_sibling=

;

<

T,

tree_node_allocator>

<

iter>

->parent=position.node->parent;

->prev_sibling=position.node;

->next_sibling=position.node->next_sibling;

position.node->next_sibling=

;

(

->next_sibling==0) {

->parent->last_child=

;

->next_sibling->prev_sibling=

;

<

T,

tree_node_allocator>

<

iter>

replace(it, subtree);

<

T,

tree_node_allocator>

<

iter>

<

T,

tree_node_allocator>

<

iter>

erase_children(position);

alloc_.deallocate(current_to,1);

toit=append_child(toit, current_from->

);

(current_from->

==0 && current_from!=start_from) {

current_from=current_from->

;

(current_from!=

) {

toit=append_child(parent(toit), current_from->

);

}

(current_from!=

);

<

T,

tree_node_allocator>

((++orig_begin)!=orig_end)

((++new_begin)!=new_end)

(new_first==new_last)

(

==orig_last)

<

T,

tree_node_allocator>

<

iter>

(position.node->first_child==0)

->parent=position.node->parent;

(position.node->next_sibling) {

position.node->last_child->next_sibling=position.node->next_sibling;

position.node->next_sibling->prev_sibling=position.node->last_child;

position.node->parent->last_child=position.node->last_child;

position.node->next_sibling=position.node->first_child;

position.node->next_sibling->prev_sibling=position.node;

position.node->first_child=0;

position.node->last_child=0;

<

T,

tree_node_allocator>

<

iter>

(begin==end)

begin;

((++begin)!=end) {

(

->prev_sibling==0) {

->parent->first_child=

->next_sibling;

->prev_sibling->next_sibling=

->next_sibling;

(

->next_sibling==0) {

->parent->last_child=

->prev_sibling;

->next_sibling->prev_sibling=

->prev_sibling;

(position.node->first_child==0) {

position.node->first_child=

;

position.node->last_child=

;

->prev_sibling=0;

position.node->last_child->next_sibling=

;

->prev_sibling=position.node->last_child;

position.node->last_child=

;

->next_sibling=0;

pos->

=position.node;

(pos==

)

;

<

T,

tree_node_allocator>

(from.node->first_child==0)

position;

reparent(position, from.node->first_child, end(from));

<

T,

tree_node_allocator>

(dst==src)

;

dst->

->first_child=src;

<

T,

tree_node_allocator>

duplicate_leaves)

(from1!=from2) {

((fnd=std::find(to1, to2, (*from1))) != to2) {

(from1.

()==from1.

()) {

(duplicate_leaves)

append_child(parent(to1), (*from1));

merge(fnd.

(), fnd.

(), from1.

(), from1.

(), duplicate_leaves);

insert_subtree(to2, from1);

<

T,

tree_node_allocator>

<

StrictWeakOrdering>

StrictWeakOrdering comp;

comp(

->data,

->data);

<

T,

tree_node_allocator>

(from, to, comp, deep);

<

T,

tree_node_allocator>

<

StrictWeakOrdering>

StrictWeakOrdering comp,

deep)

(from==to)

;

std::multiset<tree_node *, compare_nodes<StrictWeakOrdering> > nodes;

nodes.insert(it.

);

std::multiset<tree_node *, compare_nodes<StrictWeakOrdering> >

nit=nodes.

(), eit=nodes.

();

((*nit)->parent!=0)

(*nit)->parent->first_child=(*nit);

->next_sibling=(*nit);

(*nit)->prev_sibling=

;

->next_sibling=(*nit);

->next_sibling=(*eit);

(*eit)->next_sibling=

;

(*eit)->prev_sibling=

;

((*eit)->parent!=0)

(*eit)->parent->last_child=(*eit);

->prev_sibling=(*eit);

(begin(bcs), end(bcs), comp, deep);

<

T,

tree_node_allocator>

<

iter>

std::equal_to<T> comp;

equal(one_, two, three_, comp);

<

T,

tree_node_allocator>

<

iter>

std::equal_to<T> comp;

equal_subtree(one_, two_, comp);

<

T,

tree_node_allocator>

<

iter,

BinaryPredicate>

(one!=two &&

(three)) {

(!fun(*one,*three))

<

T,

tree_node_allocator>

<

iter,

BinaryPredicate>

(!fun(*one,*two))

;

(number_of_children(one)!=number_of_children(two))

;

equal(begin(one),end(one),begin(two),fun);

<

T,

tree_node_allocator>

.replace(

.begin(),

.end(), from, to);

<

T,

tree_node_allocator>

.replace(

.begin(),

.end(), from, to);

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

(pos->

!=0) {

<

T,

tree_node_allocator>

(pos==0)

0;

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

(

!=end) {

(

==it)

;

<

T,

tree_node_allocator>

(it.

==0 || it.

==feet)

;

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

=

->next_sibling;

<

T,

tree_node_allocator>

: node(0), skip_current_children_(

)

<

T,

tree_node_allocator>

: node(tn), skip_current_children_(

)

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

&(node->data);

<

T,

tree_node_allocator>

(other.

!=this->node)

;

<

T,

tree_node_allocator>

(other.

==this->node)

;

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

skip_current_children_=

;

<

T,

tree_node_allocator>

(pos==0)

0;

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

(this->

==0) {

<

T,

tree_node_allocator>

(!this->skip_current_children_ && this->node->first_child != 0) {

this->node=this->node->first_child;

this->skip_current_children_=

;

(this->node->next_sibling==0) {

this->node=this->node->parent;

this->node=this->node->next_sibling;

<

T,

tree_node_allocator>

(this->node->prev_sibling) {

this->node=this->node->prev_sibling;

(this->node->last_child)

this->node=this->node->last_child;

this->node=this->node->parent;

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

(this->

==0) {

<

T,

tree_node_allocator>

(this->node->next_sibling==0)

this->node=this->node->parent;

this->node=this->node->next_sibling;

(this->skip_current_children_) {

this->skip_current_children_=

;

(this->node->first_child)

this->node=this->node->first_child;

<

T,

tree_node_allocator>

(this->skip_current_children_ || this->node->last_child==0) {

this->skip_current_children_=

;

(this->node->prev_sibling==0)

this->node=this->node->parent;

this->node=this->node->prev_sibling;

this->node=this->node->last_child;

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

(this->node->first_child)

this->node=this->node->first_child;

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

:

(other.node), first_parent_(other.first_parent_)

<

T,

tree_node_allocator>

(this->node==0)

;

(this->node->parent!=0)

first_parent_=this->node->parent;

find_leftmost_parent_();

<

T,

tree_node_allocator>

first_parent_=tmppar;

<

T,

tree_node_allocator>

(this->node->next_sibling!=0) {

this->node=this->node->next_sibling;

(this->node->parent==0 && this->node->next_sibling==0)

<

T,

tree_node_allocator>

(this->node->prev_sibling!=0) {

this->node=this->node->prev_sibling;

(this->node->parent==0 && this->node->prev_sibling==0)

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

(this->node==0)

;

(this->node->parent!=0)

parent_=this->node->parent;

<

T,

tree_node_allocator>

this->node=this->node->next_sibling;

<

T,

tree_node_allocator>

(this->node) this->node=this->node->prev_sibling;

this->node=parent_->last_child;

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

<

T,

tree_node_allocator>

fixed_depth_iterator & operator--()

tree_node * first_parent_

fixed_depth_iterator & operator+=(unsigned int)

fixed_depth_iterator & operator++()

void find_leftmost_parent_()

fixed_depth_iterator & operator-=(unsigned int)

bool operator()(const typename tree< T, tree_node_allocator >::iterator_base &one, const typename tree< T, tree_node_allocator >::iterator_base &two) const

sibling_iterator end() const

bool operator!=(const iterator_base &) const

std::bidirectional_iterator_tag iterator_category

bool operator==(const iterator_base &) const

bool skip_current_children_

unsigned int number_of_children() const

sibling_iterator begin() const

ptrdiff_t difference_type

post_order_iterator & operator+=(unsigned int)

post_order_iterator & operator-=(unsigned int)

post_order_iterator & operator++()

post_order_iterator & operator--()

pre_order_iterator & operator++()

pre_order_iterator & operator--()

pre_order_iterator & operator+=(unsigned int)

pre_order_iterator & operator-=(unsigned int)

tree_node * range_first() const

sibling_iterator & operator--()

tree_node * range_last() const

sibling_iterator & operator++()

sibling_iterator & operator+=(unsigned int)

sibling_iterator & operator-=(unsigned int)

tree_node_< T > * next_sibling

tree_node_< T > * last_child

tree_node_< T > * first_child

tree_node_< T > * prev_sibling

post_order_iterator begin_post() const

void erase_children(const iterator_base &)

bool equal_subtree(const iter &one, const iter &two) const

bool equal(const iter &one, const iter &two, const iter &three) const

sibling_iterator child(const iterator_base &position, unsigned int) const

void merge(sibling_iterator, sibling_iterator, sibling_iterator, sibling_iterator, bool duplicate_leaves=false)

pre_order_iterator iterator

iter insert_after(iter position, const T &x)

void copy_(const tree< T, tree_node_allocator > &other)

sibling_iterator previous_sibling(const iterator_base &) const

void sort(sibling_iterator from, sibling_iterator to, bool deep=false)

sibling_iterator next_sibling(const iterator_base &) const

tree_node_< T > tree_node

iter insert_subtree(iter position, const iterator_base &subtree)

tree_node_allocator alloc_

int depth(const iterator_base &) const

bool is_valid(const iterator_base &) const

post_order_iterator end_post() const

void operator=(const tree< T, tree_node_allocator > &)

iter append_child(iter position)

tree reroot(iterator newRoot)

unsigned int index(sibling_iterator it) const

bool is_in_subtree(const iterator_base &position, const iterator_base &begin, const iterator_base &end) const

iter replace(iter position, const T &x)

iter move_after(iter target, iter source)

iter append_children(iter position, sibling_iterator from, sibling_iterator to)

pre_order_iterator begin() const

iter insert(iter position, const T &x)

fixed_depth_iterator begin_fixed(const iterator_base &, unsigned int) const

unsigned int number_of_children(const iterator_base &) const

fixed_depth_iterator end_fixed(const iterator_base &, unsigned int) const

iter move_below(iter target, iter source)

iter reparent(iter position, sibling_iterator begin, sibling_iterator end)

void swap(sibling_iterator it)

pre_order_iterator set_head(const T &x)

iter flatten(iter position)

unsigned int number_of_siblings(const iterator_base &) const

tree subtree(sibling_iterator from, sibling_iterator to) const

pre_order_iterator end() const

iter move_before(iter target, iter source)

static bool is_valid(const char *num, int type, CONV_RESULT *cr)

static unsigned char depth[2 *(256+1+29)+1]

bool operator==(const CEquivRange &A, const CEquivRange &B)

static DLIST_TYPE *DLIST_NAME() first(DLIST_LIST_TYPE *list)

static DLIST_TYPE *DLIST_NAME() last(DLIST_LIST_TYPE *list)

static DLIST_TYPE *DLIST_NAME() prev(DLIST_LIST_TYPE *list, DLIST_TYPE *item)

static DLIST_TYPE *DLIST_NAME() next(DLIST_LIST_TYPE *list, DLIST_TYPE *item)

void swap(NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair1, NCBI_NS_NCBI::pair_base_member< T1, T2 > &pair2)

CVect2< NCBI_PROMOTE(int,U) > operator*(int v1, const CVect2< U > &v2)

bool operator!=(const CNCBI_IPAddr &lhs, unsigned int rhs)

#define NCBI_CDUTILS_EXPORT

CNcbiMatrix< T > & operator+=(CNcbiMatrix< T > &, const CNcbiMatrix< U > &)

global addition: matrix += matrix

CNcbiMatrix< T > & operator-=(CNcbiMatrix< T > &, const CNcbiMatrix< U > &)

global subtraction: matrix -= matrix

constexpr auto sort(_Init &&init)

constexpr bool empty(list< Ts... >) noexcept

void constructor(T1 *p, T2 &val)

double value_type

The numeric datatype used by the parser.

const struct ncbi::grid::netcache::search::fields::SIZE size

const CharType(& source)[N]

S & operator--(CNetRef< S > &r, int)

void flatten(size_t dimension_, const Int4 *const *scoreMatrix_, const double *const *prob_, size_t *dim_, Int4 **score_, double **p_, size_t dimension2_=0)

void copy(Njn::Matrix< S > *matrix_, const Njn::Matrix< T > &matrix0_)

bool operator>(const typename tree< T, tree_node_allocator >::iterator_base &one, const typename tree< T, tree_node_allocator >::iterator_base &two)

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4