main()
{
register struct oi_item *o;
register struct zone_item *z;
register struct bay_item *b;
register struct hw_item *h;
register struct pw_item *p;
extern leave();
open_all(); /*open all files */
for(i = 0;i < NUM_PROMPTS;i++) /*clear the buffers */
for(j = 0;j < BUF_SIZE;j++)
buf[i][j] = 0;
fix(zero_counts);
sd_screen_off();
sd_clear_screen();
sd_text(zero_counts);
sd_screen_on();
while(1)
{
t = sd_input(&fld[0],sd_prompt(&fld[0],0),&rm,buf[0],0);
if(t == EXIT) leave();
if(code_to_caps(*buf[0]) == 'y') /* zero the shorts counts */
{
sp->sp_sh_printed = 0;
sp->sp_sh_count = 0;
sp->sp_rs_printed = 0;
sp->sp_rs_count = 0;
sp->sp_tl_printed = 0;
sp->sp_tl_count = 0;
sp->sp_sl_printed = 0;
sp->sp_sl_count = 0;
sp->sp_pl_printed = 0;
sp->sp_pl_count = 0;
sp->sp_bpl_printed = 0;
sp->sp_bpl_count = 0;
sp->sp_pl_order = 0;
sp->sp_pl_print = 0;
sp->sp_sl_order = 0;
sp->sp_sl_print = 0;
sp->sp_tl_order = 0;
sp->sp_tl_print = 0;
eh_post(ERR_CONFIRM,"Zero Counts");
break;
}
else if(code_to_caps(*buf[0]) == 'n') break;
else
{
eh_post(ERR_YN,0);
}
}
if(sp->sp_config_status != 'y') leave();
while(1)
{
while (1)
{
t = sd_input(&fld[1],sd_prompt(&fld[1],0),&rm,buf[1],0);
if(t == EXIT) leave();
if(code_to_caps(*buf[1]) == 'n' || code_to_caps(*buf[1]) == 'y') break;
eh_post(ERR_YN,0);
}
while (1)
{
t = sd_input(&fld[2],sd_prompt(&fld[2],0),&rm,buf[2],0);
if(t == EXIT) leave();
if(code_to_caps(*buf[2]) == 'n' || code_to_caps(*buf[2]) == 'y') break;
eh_post(ERR_YN,0);
}
if (code_to_caps(*buf[1]) == 'n' && code_to_caps(*buf[2]) == 'n') leave();
if(IS_ONE_PICKLINE) pickline = op_pl;
else
{
if(SUPER_OP) pickline_prompt();
else pickline = op_pl;
}
if (pickline == 0 && code_to_caps(*buf[1]) == 'y')
{
for (i = 0; i < coh->co_pl_cnt; i++) /*for all picklines */
{
pl[i].pl_complete = 0;
}
for (i = 0; i < coh->co_zone_cnt; i++)
{
zone[i].zt_count = 0;
}
eh_post(ERR_CONFIRM,"Zero counts");
}
else if (code_to_caps(*buf[1]) == 'y')
{
pl[pickline - 1].pl_complete = 0;
for (i = 0; i < coh->co_zone_cnt; i++)
{
if (pickline == zone[i].zt_pl) zone[i].zt_count = 0;
}
eh_post(ERR_CONFIRM,"Zero counts");
}
if (code_to_caps(*buf[2]) == 'y')
{
sd_wait();
for (i = 0; i < coh->co_pl_cnt; i++)
{
if (pickline && pl[i].pl_pl != pickline) continue;
pl[i].pl_lines_to_go = 0;
pl[i].pl_units_to_go = 0;
}
for (j = 0, p = pw; j < coh->co_prod_cnt; j++, p++)
{
h = &hw[p->pw_ptr - 1];
if (h->hw_bay)
{
b = &bay[h->hw_bay - 1];
if (b->bay_zone)
{
z = &zone[b->bay_zone - 1];
if (pickline && z->zt_pl != pickline) continue;
p->pw_units_to_go = 0;
p->pw_lines_to_go = 0;
}
}
}
for (i = 0, o = oc->oi_tab; i < oc->of_size; i++, o++)
{
if (!o->oi_pl || !o->oi_on) continue;
if (pickline && o->oi_pl != pickline) continue;
if (o->oi_queue == OC_COMPLETE) continue;
op_rec->pi_pl = o->oi_pl;
op_rec->pi_on = o->oi_on;
op_rec->pi_mod = 1;
pick_startkey(op_rec);
op_rec->pi_mod = coh->co_prod_cnt;
pick_stopkey(op_rec);
begin_work();
while (!pick_next(op_rec, NOLOCK))
{
if (op_rec->pi_flags & PICKED) continue;
if (op_rec->pi_flags & NO_PICK) continue;
pl[op_rec->pi_pl - 1].pl_units_to_go += op_rec->pi_ordered;
pl[op_rec->pi_pl - 1].pl_lines_to_go += 1;
pw[op_rec->pi_mod - 1].pw_units_to_go += op_rec->pi_ordered;
pw[op_rec->pi_mod - 1].pw_lines_to_go += 1;
}
commit_work();
}
eh_post(ERR_CONFIRM, "Zero Remaining:");
}
if (SUPER_OP && pickline != 0 && (!(IS_ONE_PICKLINE)))
{
sd_cursor(0,9,1);
sd_clear_line();
sd_cursor(0,10,1);
sd_clear_line();
continue;
}
leave();
}
}
main()
{
register struct pw_item *i;
register struct st_item *s;
register long k, errors;
long pid, status;
char command[80];
putenv("_=orphan_picks");
chdir(getenv("HOME"));
database_open();
ss_open();
co_open();
oc_open();
od_open();
if (sp->sp_sku_support == 'n') leave(0);
errors = 0;
tmp_name(fd_name);
fd = fopen(fd_name, "w");
if (fd == 0) krash("main", "open temp", 1);
if (sp->sp_sku_support == 'y') /* only when sku support */
{
for (k = 0, i = pw; k < coh->co_prod_cnt; k++, i++)
{
if (i->pw_lines_to_go <= 0) continue; /* has no picks */
s = mod_lookup(k + 1); /* find in sku table */
if (s) continue; /* module has a sku */
fprintf(fd, "No SKU Assigned To Module %d Has %d Picks\n",
k + 1, i->pw_lines_to_go);
errors++;
}
}
#ifdef DEBUG
fprintf(stderr, "errors=%d\n", errors);
#endif
fprintf(fd, "\n\n");
pick_setkey(1);
begin_work();
while (!pick_next(op_rec, NOLOCK))
{
#ifdef DEBUG
fprintf(stderr, "pl=%d on=%d mod=%d flag=%x\n",
op_rec->pi_pl, op_rec->pi_on, op_rec->pi_mod, op_rec->pi_flags);
#endif
commit_work();
begin_work();
if (op_rec->pi_flags & VALIDATED) continue;
fprintf(fd,
"Pickline: %2d Order: %7.*d Mod: %5d SKU: %-15.15s Quan: %3d\n",
op_rec->pi_pl, rf->rf_on, op_rec->pi_on, op_rec->pi_mod,
op_rec->pi_sku, op_rec->pi_ordered);
errors++;
}
commit_work();
fclose(fd);
if (errors)
{
tmp_name(ed_name);
if (fork() == 0)
{
execlp("prft", "prft", fd_name, ed_name, "sys/report/orphan_picks.h", 0);
krash("main", "load prft", 1);
}
pid = wait(&status);
if (!pid || status) krash("main", "prft failed", 1);
sprintf(command, "%s %s", getenv("LPR"), fd_name);
}
else unlink(fd_name);
leave(0);
}
static int split_rtree_node(SplitStruct *node, int n_entries,
int all_size, /* Total key's size */
int key_size,
int min_size, /* Minimal group size */
int size1, int size2 /* initial group sizes */,
double **d_buffer, int n_dim)
{
SplitStruct *cur;
SplitStruct *a= NULL, *b= NULL;
double *g1 = reserve_coords(d_buffer, n_dim);
double *g2 = reserve_coords(d_buffer, n_dim);
SplitStruct *next= NULL;
int next_node= 0;
int i;
SplitStruct *end = node + n_entries;
if (all_size < min_size * 2)
{
return 1;
}
cur = node;
for (; cur<end; ++cur)
{
cur->square = count_square(cur->coords, n_dim);
cur->n_node = 0;
}
pick_seeds(node, n_entries, &a, &b, n_dim);
a->n_node = 1;
b->n_node = 2;
copy_coords(g1, a->coords, n_dim);
size1 += key_size;
copy_coords(g2, b->coords, n_dim);
size2 += key_size;
for (i=n_entries - 2; i>0; --i)
{
if (all_size - (size2 + key_size) < min_size) /* Can't write into group 2 */
{
mark_all_entries(node, n_entries, 1);
break;
}
if (all_size - (size1 + key_size) < min_size) /* Can't write into group 1 */
{
mark_all_entries(node, n_entries, 2);
break;
}
pick_next(node, n_entries, g1, g2, &next, &next_node, n_dim);
if (next_node == 1)
{
size1 += key_size;
mbr_join(g1, next->coords, n_dim);
}
else
{
size2 += key_size;
mbr_join(g2, next->coords, n_dim);
}
next->n_node = next_node;
}
return 0;
}
static inline void apply(Node & n,
Node & second_node,
Box & box1,
Box & box2,
parameters_type const& parameters,
Translator const& translator,
Allocators & allocators)
{
typedef typename rtree::elements_type<Node>::type elements_type;
typedef typename elements_type::value_type element_type;
typedef typename rtree::element_indexable_type<element_type, Translator>::type indexable_type;
elements_type & elements1 = rtree::elements(n);
elements_type & elements2 = rtree::elements(second_node);
BOOST_GEOMETRY_INDEX_ASSERT(elements1.size() == parameters.get_max_elements() + 1, "unexpected elements number");
// copy original elements - use in-memory storage (std::allocator)
// TODO: move if noexcept
typedef typename rtree::container_from_elements_type<elements_type, element_type>::type
container_type;
container_type elements_copy(elements1.begin(), elements1.end()); // MAY THROW, STRONG (alloc, copy)
container_type elements_backup(elements1.begin(), elements1.end()); // MAY THROW, STRONG (alloc, copy)
// calculate initial seeds
size_t seed1 = 0;
size_t seed2 = 0;
quadratic::pick_seeds<Box>(elements_copy, parameters, translator, seed1, seed2);
// prepare nodes' elements containers
elements1.clear();
BOOST_GEOMETRY_INDEX_ASSERT(elements2.empty(), "second node's elements container should be empty");
BOOST_TRY
{
// add seeds
elements1.push_back(elements_copy[seed1]); // MAY THROW, STRONG (copy)
elements2.push_back(elements_copy[seed2]); // MAY THROW, STRONG (alloc, copy)
// calculate boxes
detail::bounds(rtree::element_indexable(elements_copy[seed1], translator), box1);
detail::bounds(rtree::element_indexable(elements_copy[seed2], translator), box2);
// remove seeds
if (seed1 < seed2)
{
rtree::move_from_back(elements_copy, elements_copy.begin() + seed2); // MAY THROW, STRONG (copy)
elements_copy.pop_back();
rtree::move_from_back(elements_copy, elements_copy.begin() + seed1); // MAY THROW, STRONG (copy)
elements_copy.pop_back();
}
else
{
rtree::move_from_back(elements_copy, elements_copy.begin() + seed1); // MAY THROW, STRONG (copy)
elements_copy.pop_back();
rtree::move_from_back(elements_copy, elements_copy.begin() + seed2); // MAY THROW, STRONG (copy)
elements_copy.pop_back();
}
// initialize areas
content_type content1 = index::detail::content(box1);
content_type content2 = index::detail::content(box2);
size_t remaining = elements_copy.size();
// redistribute the rest of the elements
while ( !elements_copy.empty() )
{
typename container_type::reverse_iterator el_it = elements_copy.rbegin();
bool insert_into_group1 = false;
size_t elements1_count = elements1.size();
size_t elements2_count = elements2.size();
// if there is small number of elements left and the number of elements in node is lesser than min_elems
// just insert them to this node
if ( elements1_count + remaining <= parameters.get_min_elements() )
{
insert_into_group1 = true;
}
else if ( elements2_count + remaining <= parameters.get_min_elements() )
{
insert_into_group1 = false;
}
// insert the best element
else
{
// find element with minimum groups areas increses differences
content_type content_increase1 = 0;
content_type content_increase2 = 0;
el_it = pick_next(elements_copy.rbegin(), elements_copy.rend(),
box1, box2, content1, content2, translator,
content_increase1, content_increase2);
if ( content_increase1 < content_increase2 ||
( content_increase1 == content_increase2 && ( content1 < content2 ||
( content1 == content2 && elements1_count <= elements2_count ) )
) )
{
insert_into_group1 = true;
}
else
{
insert_into_group1 = false;
}
}
// move element to the choosen group
element_type const& elem = *el_it;
indexable_type const& indexable = rtree::element_indexable(elem, translator);
if ( insert_into_group1 )
{
elements1.push_back(elem); // MAY THROW, STRONG (copy)
geometry::expand(box1, indexable);
content1 = index::detail::content(box1);
}
else
{
elements2.push_back(elem); // MAY THROW, STRONG (alloc, copy)
geometry::expand(box2, indexable);
content2 = index::detail::content(box2);
}
BOOST_GEOMETRY_INDEX_ASSERT(!elements_copy.empty(), "expected more elements");
typename container_type::iterator el_it_base = el_it.base();
rtree::move_from_back(elements_copy, --el_it_base); // MAY THROW, STRONG (copy)
elements_copy.pop_back();
BOOST_GEOMETRY_INDEX_ASSERT(0 < remaining, "expected more remaining elements");
--remaining;
}
}
BOOST_CATCH(...)
{
//elements_copy.clear();
elements1.clear();
elements2.clear();
rtree::destroy_elements<Value, Options, Translator, Box, Allocators>::apply(elements_backup, allocators);
//elements_backup.clear();
BOOST_RETHROW // RETHROW, BASIC
}
