shapes.c++

Go to the documentation of this file.

/*


    Copyright (C) 2009 Joseph Pingenot

    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU Affero General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Affero General Public License for more details.

    You should have received a copy of the GNU Affero General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

*/


#include <stdlib.h>
#include <stdio.h>
#include <glib.h>
#include <libmodelxx/shapes.h++>
#include <libmodelxx/key_values.h++>

using namespace ::kdotp::libmodelxx::postprocessing;

namespace kdotp {
  namespace libmodelxx {
    namespace grid {

      struct shape_block* make_block_from_shape(struct shape *s, int dim, bool abs) {
  shape_block* b = (struct shape_block*)malloc(sizeof(struct shape_block));
  b->op = LEAF;
  if(abs) {
    b->type = ABSBLOCK;
  }else{
    b->type = BLOCK;
  }
  b->generic = false;
  b->center = (struct function_exp*)malloc(sizeof(struct function_exp));
  if((b->center == NULL)) {
    if(abs) {
      fprintf(stderr, "kdotp::libmodelxx::grid::make_block_from_shape: ERROR allocating memory for first corner coordinate\n");
    }else{
      fprintf(stderr, "kdotp::libmodelxx::grid::make_block_from_shape: ERROR allocating memory for center\n");
    }
    exit(15);
  }
  b->L = (struct function_exp*)malloc(sizeof(struct function_exp));
  if((b->L == NULL)) {
    if(abs) {
      fprintf(stderr, "kdotp::libmodelxx::grid::make_block_from_shape: ERROR allocating memory for second corner coordinate\n");
    }else{
      fprintf(stderr, "kdotp::libmodelxx::grid::make_block_from_shape: ERROR allocating memory for L\n");
    }
    exit(16);
  }
  /*There should be two vectors: the center of the box, and the width
   *  of the box (vector from one corner to the other)
   *As a convenience, the vectors may be scalars if there is only
   *  one dimension
   */
  GString* str = g_string_new("");
  GList *l = s->descriptor;
  if(l == NULL) {
    fprintf(stderr, "kdotp::libmodelxx::grid::make_global_from_shape: ERROR: insufficient shape description was given to a \"block\" or \"absblock\" shape, which takes only two vectors. This superfluous information will be ignored.\n");
    exit(17);
  }
  b->center = (struct function_exp*)(l->data);
  function_print_tree(b->center, &str, 1);
  fprintf(stderr, "b->center:\n%s\n", str->str);
  g_string_free(str, TRUE);
  l = l->next;
  if(l == NULL) {
    fprintf(stderr, "kdotp::libmodelxx::grid::make_global_from_shape: ERROR: insufficient shape description was given to a \"block\" or \"absblock\" shape, which takes only two vectors. This superfluous information will be ignored.\n");    exit(18);
  }
  b->L = (struct function_exp*)(l->data);
  str = g_string_new("");
  function_print_tree(b->L, &str, 1);
  fprintf(stderr, "b->L:\n%s\n", str->str);
  g_string_free(str, TRUE);
  l=l->next;
  if(l != NULL) {
    fprintf(stderr, "kdotp::libmodelxx::grid::make_global_from_shape: WARNING: extra shape description was given to a \"block\" shape, which takes only two vectors. This superfluous information will be ignored.\n");
  }
  return b;
      }
      struct shape_global* make_global_from_shape(struct shape *s, int dim) {
  shape_global* g = (struct shape_global*)malloc(sizeof(struct shape_global));
  g->op = LEAF;
  g->type = GLOBAL;
  g->generic = false;
  if((s->descriptor) != NULL) {
    fprintf(stderr, "kdotp::libmodelxx::grid::make_global_from_shape: WARNING: a shape description was given to a \"global\" shape, which takes no description. This superfluous information will be ignored.\n");
  }
  return g;
      }

      /**
       *\note Algorithm:
       *1) Recurse on non-leaf nodes
       *2) Set l, r from recursion.
       *3) If leaf, set the respective type using above helper function.
       *\note caller MUST set the return value; you may just have a leaf node.
       */
      struct shape_tree* postprocess_shape_tree(struct shape_tree* st, int dim) {
  /*Simple bounce for NULL links.*/
  if(st == NULL) return NULL;
  if(st->op != LEAF) {
    if(st->l == NULL){
      fprintf(stderr, "kdotp::libmodelxx::grid::postprocess_shape_tree: left subtree of a non-LEAF shape tree node should never be NULL, but is! (op is %d)\n", st->op);
      return NULL;
    }
    if(((st->l) = postprocess_shape_tree(st->l, dim)) != NULL) {
      /*If this was already NULL, we're fine.*/
      if((st->r == NULL) || (((st->r) = postprocess_shape_tree(st->r, dim)) != NULL)) {
        return st;
      }else{
        fprintf(stderr, "kdotp::libmodelxx::grid::postprocess_shape_tree: got NULL postprocessing right subtree (op is %d)\n", st->op);
      }
    }else{
      fprintf(stderr, "kdotp::libmodelxx::grid::postprocess_shape_tree: got NULL postprocessing left subtree (op is %d)\n", st->op);
    }
    /*If we get to here, one or the other of the ones failed.*/
    return NULL;
  }
  /*This will only execute for leaf nodes.*/
  struct shape* s = (struct shape*)st;
  if(!(s->generic)) {
    fprintf(stderr, "kdotp::libmodelxx::grid::postprocess_shape_tree: WARNING shape is not generic, although it's expected to be!\n");
    /*For some reason, this shape has already been
     *postprocessed.  Just return it, then.
     */
    return st;
  }
  struct shape* n = NULL;
  switch (s->type) {
  case BLOCK:
    n = (struct shape*)make_block_from_shape(s, dim, false);
    break;
  case ABSBLOCK:
    n = (struct shape*)make_block_from_shape(s, dim, true);
    break;
  case GLOBAL:
    n = (struct shape*)make_global_from_shape(s, dim);
    break;
  default:
    fprintf(stderr, "kdotp::libmodelxx::grid::process_shape_tree: ERROR unrecognized shape type (numeric: %d)\n", s->type);
    return NULL;
  }
  shape_free(s);
  return (struct shape_tree*)n;
      }

      void shape_block_free(struct shape_block *b) {
  free_function(b->center);
  free_function(b->L);
  free(b);
      }

      void shape_global_free(struct shape_global *b) {
  free(b);
      }


      void shape_free(struct shape *s) {
  /*Free the value list.*/
  GList* l;
  if(s->generic){
    /*The functions are moved over to the new structure; just free the list.*/
    g_list_free(s->descriptor);
  }else{
    switch(s->type){
    case GLOBAL:
      shape_global_free((struct shape_global*)s);
      break;
    case BLOCK:
      shape_block_free((struct shape_block*)s);
      break;
    case ABSBLOCK:
      shape_block_free((struct shape_block*)s);
      break;
    default:
      fprintf(stderr, "kdotp::libmodelxx::grid::shape_free: didn't recognize non-generic shape type (numeric %d)\n", s->type);
    }
  }
  free(s);
      }

      void shape_tree_free(struct shape_tree *st) {
  if(st == NULL) return;
  if(st->op != LEAF) {
    shape_tree_free(st->l);
    shape_tree_free(st->r);
  }else{
    shape_free((struct shape*)st);
  }
      }

      enum shape_type get_shape_from_identifier(const char* identifier) {
  if(!g_ascii_strcasecmp(identifier, "block")){
    return BLOCK;
  }else if(!g_ascii_strcasecmp(identifier, "absblock")){
    return ABSBLOCK;
  }else if(!g_ascii_strcasecmp(identifier, "global")){
    return GLOBAL;
  }
  return INVALID;
      }


      void get_string_from_shape_type(char** str, enum shape_type t) {
        GString *s = NULL;
  switch(t) {
  case INVALID:
    s = g_string_new("invalid");
    break;
  case BLOCK:
    s = g_string_new("block");
    break;
  case ABSBLOCK:
    s = g_string_new("absblock");
    break;
  case GLOBAL:
    s = g_string_new("global");
    break;
  default:
    s = g_string_new("unkdnown(");
    g_string_append_printf(s, "%d)", t);
  }
  *str = s->str;
  g_string_free(s, FALSE);
      }


    }
  }
}