int main(int argc, char **argv) {
List *a = create_fixed(6);
List *b = create_fixed(6);
insert_iter(a, 3);
insert_iter(b, 4);
a->n->n = NULL;
b->n->n = NULL;
return 1;
}
int main(int argc, char **argv) {
List *head = create_fixed(6);
insert_iter(head, 3);
return 1;
}
void GPG::Key::getDescription(std::vector<std::string> &descrArray,
size_t width)
{
std::string keyDescr=longname;
do
{
std::vector<unicode_char> unicode_buf;
size_t p=keyDescr.find('\n');
if (p == std::string::npos)
{
unicode::iconvert::convert(keyDescr,
unicode_default_chset(),
unicode_buf);
keyDescr="";
}
else
{
unicode::iconvert::convert(keyDescr.substr(0, p),
unicode_default_chset(),
unicode_buf);
keyDescr=keyDescr.substr(p+1);
}
std::vector< std::vector<unicode_char> > wrapped_text;
std::back_insert_iterator<std::vector< std::vector
<unicode_char> > >
insert_iter(wrapped_text);
unicodewordwrap(unicode_buf.begin(),
unicode_buf.end(),
unicoderewrapnone(),
insert_iter,
width,
true);
for (std::vector< std::vector<unicode_char> >::const_iterator
b(wrapped_text.begin()),
e(wrapped_text.end()); b != e; ++b)
{
descrArray.push_back(unicode::iconvert
::convert(*b,
unicode_default_chset())
);
}
} while (keyDescr.size() > 0);
}
void CursesMultilineLabel::init()
{
int w=getWidth();
if (w < 10)
w=10;
lines.clear();
std::back_insert_iterator< std::vector< std::vector<unicode_char> > >
insert_iter(lines);
unicodewordwrap(text.begin(), text.end(),
unicoderewrapnone(), insert_iter, w, true);
}
void event(State* s) {
if(s->iter==0||s->list==0) {
s->list=create_iter(6);
} else if(s->iter<s->maxlen) {
insert_iter(s->list, s->iter);
} else {
delall_iter(s->list);
s->list=0;
s->iter=0;
}
#ifdef MYPRINT
if(s->list) {
s->list->print();
printf(" iter:%d max:%d\n",s->iter,s->maxlen);
}
#endif
s->iter++;
}
void event(class State *s)
{
if (s -> State::iter == 0 || s -> State::list == 0) {
(*rts.avpushptr((void**)&(s -> list))) = create_iter(6);
}
else {
if (s -> State::iter < s -> State::maxlen) {
insert_iter(s -> State::list, s -> State::iter);
}
else {
delall_iter(s -> State::list);
(*rts.avpushptr((void**)&(s -> list))) = 0;
(*rts.avpush(&(s -> iter))) = 0;
}
}
#ifdef PRINT
#endif
(*rts.avpush(&(s -> iter)))++;
}
int
Task_Entry::conjunctive_merge (Dependency_Type dt,
ACE_Unbounded_Set <Dispatch_Entry *> &dispatch_entries,
ACE_CString &unresolved_locals,
ACE_CString &unresolved_remotes)
{
int result = 0;
char string_buffer [BUFSIZ];
// Iterate over the dependencies, and determine the total frame
// size.
u_long frame_size = 1;
ACE_Unbounded_Set_Iterator <Task_Entry_Link *> dep_iter (callers_);
for (dep_iter.first ();
dep_iter.done () == 0;
dep_iter.advance ())
{
Task_Entry_Link **link;
if (dep_iter.next (link) == 0
|| link == 0
|| *link == 0)
return -1;
// The link matches the dependency type given.
if ((*link)->dependency_type () == dt)
{
// Check for and warn about unresolved remote dependencies
// in the ONE_WAY call graph.
if ((*link)->dependency_type () == RtecBase::ONE_WAY_CALL
&& (*link)->caller ().has_unresolved_remote_dependencies ()
&& ! this->has_unresolved_remote_dependencies ())
{
// Propagate the unresolved remote dependency flag, and
// issue a debug scheduler warning.
this->has_unresolved_remote_dependencies (1);
ORBSVCS_DEBUG ((LM_DEBUG,
"Warning: an operation identified by "
"\"%s\" has unresolved remote dependencies.\n",
(const char*) this->rt_info ()->entry_point));
// Record entry point in list of unresolved remote
// dependencies
ACE_OS::sprintf (string_buffer,
"// %s\n",
(const char*) this->rt_info ()->entry_point);
unresolved_remotes +=
ACE_CString (string_buffer);
}
// Check for and warn about unresolved local dependencies in
// the ONE_WAY call graph.
if ((*link)->dependency_type () == RtecBase::ONE_WAY_CALL
&& (*link)->caller ().has_unresolved_local_dependencies ()
&& ! this->has_unresolved_local_dependencies ())
{
// Propagate the unresolved local dependency flag, and
// issue a debug scheduler warning.
this->has_unresolved_local_dependencies (1);
ORBSVCS_DEBUG ((LM_DEBUG,
"Warning: an operation identified by "
"\"%s\" has unresolved local dependencies.\n",
(const char*) this->rt_info ()->entry_point));
// Record entry point in list of unresolved local dependencies
ACE_OS::sprintf (string_buffer,
"// %s\n",
(const char*) this->rt_info ()->entry_point);
unresolved_locals +=
ACE_CString (string_buffer);
}
frame_size = ACE::minimum_frame_size (frame_size,
(*link)->caller ().effective_period_);
}
}
// Reframe dispatches in the set to the new frame size (expands the
// set's effective period to be the new enclosing frame).
if (reframe (dispatch_entries,
*this, dispatches_,
effective_period_,
frame_size) < 0)
return -1;
// A container and iterator for virtual dispatch sets over which the
// conjunction will operate
ACE_Ordered_MultiSet <Dispatch_Proxy_Iterator *> conj_set;
ACE_Ordered_MultiSet_Iterator <Dispatch_Proxy_Iterator *> conj_set_iter (conj_set);
// Iterate over the dependencies, and for each of the given call
// type, create a Dispatch_Proxy_Iterator for the caller's dispatch
// set, using the caller's period, the total frame size, and the
// number of calls: if any of the sets is empty, just return 0;
for (dep_iter.first ();
dep_iter.done () == 0;
dep_iter.advance ())
{
Task_Entry_Link **link;
if (dep_iter.next (link) == 0
|| link == 0
|| *link == 0)
return -1;
// The link matches the dependency type given.
if ((*link)->dependency_type () == dt)
{
Dispatch_Proxy_Iterator *proxy_ptr;
ACE_NEW_RETURN (proxy_ptr,
Dispatch_Proxy_Iterator ((*link)->caller ().dispatches_,
(*link)->caller ().effective_period_,
frame_size,
(*link)->number_of_calls ()),
-1);
// If there are no entries in the virtual set, we're done.
if (proxy_ptr->done ())
return 0;
else if (conj_set.insert (proxy_ptr, conj_set_iter) < 0)
return -1;
}
}
// loop, adding conjunctive dispatches, until one of the conjunctive
// dispatch sources runs out of entries over the total frame
conj_set_iter.first ();
int more_dispatches = (conj_set_iter.done ()) ? 0 : 1;
while (more_dispatches)
{
Time arrival = 0;
Time deadline = 0;
Preemption_Priority priority = 0;
OS_Priority OS_priority = 0;
for (conj_set_iter.first ();
conj_set_iter.done () == 0;
conj_set_iter.advance ())
{
// initialize to earliest arrival and deadline, and highest priority
arrival = 0;
deadline = 0;
priority = 0;
OS_priority = 0;
// Policy: conjunctively dispatched operations get the
// latest deadline of any of the dispatches in the
// conjunction at the time they were dispatched - when and
// if it is useful to change any of the merge policies, this
// should be one of the decisions factored out into the
// conjunctive merge strategy class.
// Policy: conjunctively dispatched operations get the
// lowest priority of any of the dispatches in the
// conjunction at the time they were dispatched - when and
// if it is useful to change any of the merge policies, this
// should be one of the decisions factored out into the
// conjunctive merge strategy class.
// Obtain a pointer to the current dispatch proxy iterator.
Dispatch_Proxy_Iterator **proxy_iter;
if (conj_set_iter.next (proxy_iter) == 0
|| proxy_iter == 0
|| *proxy_iter == 0)
return -1;
// Use latest arrival, latest deadline, lowest priority (0 is highest).
if (arrival <= (*proxy_iter)->arrival ())
arrival = (*proxy_iter)->arrival ();
if (deadline <= (*proxy_iter)->deadline ())
deadline = (*proxy_iter)->deadline ();
if (priority <= (*proxy_iter)->priority ())
{
priority = (*proxy_iter)->priority ();
OS_priority = (*proxy_iter)->OS_priority ();
}
(*proxy_iter)->advance ();
if ((*proxy_iter)->done ())
more_dispatches = 0;
}
Dispatch_Entry *entry_ptr;
ACE_NEW_RETURN (entry_ptr,
Dispatch_Entry (arrival,
deadline,
priority,
OS_priority,
*this),
-1);
// If even one new dispatch was inserted, result is "something
// happened".
result = 1;
// Add the new dispatch entry to the set of all dispatches, and
// a link to it to the dispatch links for this task entry.
if (dispatch_entries.insert (entry_ptr) < 0)
return -1;
// Use iterator for efficient insertion into the dispatch set.
ACE_Ordered_MultiSet_Iterator <Dispatch_Entry_Link> insert_iter (dispatches_);
if (dispatches_.insert (Dispatch_Entry_Link (*entry_ptr),
insert_iter) < 0)
return -1;
// TBD - Clients are not assigned priority, but rather obtain it
// from their call dependencies. We could complain here if
// there is a priority specified that doesn't match (or is lower
// QoS?)
}
return result;
}
