Beispiel #1
0
/* FALSE means, there is no further element
 */
static Bool set_range_iter_next(
   SetIter*   iter,
   const Set* set,
   Tuple*     tuple,
   int        offset)
{
   int   val;
   Numb* numb;

   assert(set_range_iter_is_valid(iter));
   assert(set_range_is_valid(set));
   assert(tuple_is_valid(tuple));
   assert(offset >= 0);
   assert(offset <  tuple_get_dim(tuple));

   if (iter->range.now > iter->range.last)
      return FALSE;

   val  = idx_to_val(set->range.begin, set->range.step, iter->range.now);
   numb = numb_new_integer(val);

   tuple_set_elem(tuple, offset, elem_new_numb(numb));

   numb_free(numb);

   iter->range.now++;

   return TRUE;
}
Beispiel #2
0
/* ------------------------------------------------------------------------- 
 * --- get_tuple                 
 * -------------------------------------------------------------------------
 */
static void set_range_get_tuple(
   const Set* set,
   int        idx,
   Tuple*     tuple,
   int        offset)
{
   int   val;
   Numb* numb;
      
   assert(set_range_is_valid(set));
   assert(idx >= 0);
   assert(idx <= set->head.members);
   assert(tuple_is_valid(tuple));
   assert(offset >= 0);
   assert(offset <  tuple_get_dim(tuple));

   val  = idx_to_val(set->range.begin, set->range.step, idx);
   numb = numb_new_integer(val);

   tuple_set_elem(tuple, offset, elem_new_numb(numb));

   numb_free(numb);
}
Beispiel #3
0
/*ARGSUSED*/
static Bool set_prod_iter_next(
   SetIter*   iter,
   const Set* set,
   Tuple*     tuple,
   int        offset)
{
   Set*       a;
   Set*       b;
   SetIter*   iter_a;
   SetIter*   iter_b;
   int        offset2;
   int        i;
   
   assert(set_prod_iter_is_valid(iter));
   assert(set_prod_is_valid(set));
   assert(tuple_is_valid(tuple));
   assert(offset >= 0);
   assert(offset + set->head.dim <= tuple_get_dim(tuple));

   a       = set->prod.set_a;
   b       = set->prod.set_b;
   iter_a  = iter->prod.iter_a;
   iter_b  = iter->prod.iter_b;
   offset2 = offset + a->head.dim;

   if (iter->prod.first)
   {
      iter->prod.first = FALSE;

      return get_both_parts(a, b, iter, iter_a, iter_b, tuple, offset, offset2);
   }
   assert(!iter->prod.first);
   
   /* Get back part
    */
   if (set_iter_next_intern(iter_b, b, tuple, offset2))
   {
      /* copy fore part
       */
      for(i = 0; i < a->head.dim; i++)
         tuple_set_elem(tuple, i + offset, elem_copy(iter->prod.elem[i]));

      return TRUE;
   }

   /* No back part, so reset it
    */
   set_iter_reset_intern(iter_b, b);

   /* Clear elem cache
    */
   for(i = 0; i < set->head.dim; i++)
   {
      if (iter->prod.elem[i] != NULL)
      {
         elem_free(iter->prod.elem[i]);

         iter->prod.elem[i] = NULL;
      }
   }
   return get_both_parts(a, b, iter, iter_a, iter_b, tuple, offset, offset2);
}