/*-------------------------------------------------------------------------
 *
 * tgRecipe.c--
 *      Tioga recipe-related definitions
 *      these functions can be used in both the frontend and the 
 *      backend
 *    
 *      this file must be kept current with recipe-schema.sql
 *
 * Copyright (c) 1994, Regents of the University of California
 *
 *
 * IDENTIFICATION
 *    $Header: /cvsroot/pgsql/src/backend/tioga/Attic/tgRecipe.c,v 1.2 1996/11/03 06:52:45 scrappy Exp $
 *
 *-------------------------------------------------------------------------
 */

#include <stdlib.h>
#include "postgres.h"
#include "tioga/tgRecipe.h"

#include "catalog/catalog.h" /*for newoid() */

static Arr_TgString *TextArray2ArrTgString(char *str);

#define ARRAY_LEFT_DELIM '{'
#define ARRAY_RIGHT_DELIM '}'
#define ARRAY_ELEM_LEFT '"'
#define ARRAY_ELEM_RIGHT '"'
#define ARRAY_ELEM_SEPARATOR ','

/* maximum length of query string */
#define MAX_QBUF_LENGTH 2048 

/**** the queries being used ********/
#define Q_RETRIEVE_RECIPE_BYNAME \
      "select * from Recipes where Recipes.elemName = '%s';"
#define Q_RETRIEVE_ELEMENTS_IN_RECIPE \
      "select e.* from Element e, Node n where n.belongsTo = '%s' and n.nodeElem = e.elemName;"
#define Q_RETRIEVE_NODES_IN_RECIPE \
      "select * from Node n where n.belongsTo = '%s'"
#define Q_LOOKUP_EDGES_IN_RECIPE \
      "select * from Edge e where e.belongsTo = '%s'"

/* static functions only used here */
static void fillTgElement(TgElement *elem,  PortalBuffer *pbuf, int tupno);
static void fillTgNode(TgRecipe *r, TgNode *node,  PortalBuffer *pbuf, int tupno);
static TgRecipe* fillTgRecipe(PortalBuffer* pbuf, int tupno);
static void lookupEdges(TgRecipe *r, char* name);
static void fillAllNodes(TgRecipe *r, char* name);
static void fillAllElements(TgRecipe *r, char* name);
static TgNode* connectTee(TgRecipe *r, TgNodePtr fromNode, TgNodePtr toNode,
		       int fromPort, int toPort);

/*
 * TextArray2ArrTgString --  take a string of the form:
 *                      {"fooo", "bar", "xxxxx"} (for postgres)
 *                      and parse it into a Array of TgString's
 *
 * always returns a valid Arr_TgString.  It could be a newly initialized one with
 * zero elements
 */
Arr_TgString*
TextArray2ArrTgString(char *str)
{
  Arr_TgString *result;
  
  char* beginQuote;
  char* endQuote;
  int nextlen;
  char* word;
  
  result = newArr_TgString();
  
  if ((str == NULL) || (str[0] == '\0'))
    return result;
  
  if (*str != ARRAY_LEFT_DELIM) {
    elog(NOTICE,"TextArray2ArrTgString: badly formed string, must have %c as \
first character\n", ARRAY_LEFT_DELIM);
    return result;
  }
  
  str++; /* skip the first { */
  while  ( *str != '}' ) {
    if (*str == '\0') {
      elog(NOTICE,"TextArray2ArrTgString: text string ended prematurely\n");
      return result;
    }

    if ((beginQuote = index(str, ARRAY_ELEM_LEFT)) == NULL) {
      elog(NOTICE,"textArray2ArrTgString:  missing a begin quote\n");
      return result;
    }
    if  ( (endQuote = index(beginQuote+1,'"')) == NULL) {
      elog(NOTICE,"textArray2ArrTgString:  missing an end quote\n");
      return result;
    }
    nextlen = endQuote - beginQuote; /* don't subtract one here because we
				      need the extra character for \0 anyway */
    word = (char*) malloc(nextlen);
    strncpy(word, beginQuote+1, nextlen-1);
    word[nextlen-1] ='\0';
    addArr_TgString(result, (TgString*)&word);
    free (word);
    str = endQuote + 1;
  }
  return result;
}

/* -------------------------------------
findElemInRecipe()
   given an element name, find that element in the TgRecipe structure and return it.

   XXX Currently, this is done by linear search.  Change to using a hash table.
-------------------------------------- */

TgElement* 
findElemInRecipe(TgRecipe *r, char* elemName)
{
  int i;
  Arr_TgElementPtr* arr = r->elements;
  TgElement* e;

  for (i=0;i<arr->num;i++) {
    e = (TgElement*)arr->val[i];
    if (strcmp(e->elemName, elemName) == 0)
      return e;
  }
  elog (NOTICE, "Element named %s not found in recipe named %s", elemName, r->elmValue.elemName);
  return NULL;
}

/* -------------------------------------
findNodeInRecipe()
   given an node name, find that node in the TgRecipe structure and return it.

   XXX Currently, this is done by linear search.  Change to using a hash table.
-------------------------------------- */

TgNode* 
findNodeInRecipe(TgRecipe *r, char* nodeName)
{
  int i;
  Arr_TgNodePtr* arr = r->allNodes;
  TgNode *n;

  for (i=0;i<arr->num;i++) {
    n = (TgNode*)arr->val[i];
    if (strcmp(n->nodeName, nodeName) == 0)
      return n;
  }
  elog (NOTICE, "Node named %s not found in recipe named %s", nodeName, r->elmValue.elemName);
  return NULL;
}


/* -------------------------------------
fillTgNode
    takes a query result in the PortalBuffer containing a Node
    and converts it to a C Node strcture.
    The Node structure passed in is 'filled' appropriately

-------------------------------------- */

void
fillTgNode(TgRecipe* r, TgNode *node,  PortalBuffer *pbuf, int tupno)
{
  char* nodeType;
  char* nodeElem;
  char* locString;  /* ascii string rep of the point */
  static int attnums_initialized = 0;
  static int nodeName_attnum;
  static int nodeElem_attnum;
  static int nodeType_attnum;
  static int loc_attnum;
  TgNodePtr BlankNodePtr;
  int i;

  if (!attnums_initialized) {
    /* the first time fillTgNode is called,
       we find out all the relevant attribute numbers in a TgNode
       so subsequent calls are speeded up,
       the assumption is that the schema won't change between calls*/
    nodeName_attnum = PQfnumber(pbuf, tupno, "nodeName");
    nodeElem_attnum = PQfnumber(pbuf, tupno, "nodeElem");
    nodeType_attnum = PQfnumber(pbuf, tupno, "nodeType");
    loc_attnum = PQfnumber(pbuf, tupno, "loc");
    attnums_initialized = 1;
  }
  node->nodeName = PQgetAttr(pbuf, tupno, nodeName_attnum);
  locString = PQgetvalue(pbuf, tupno, loc_attnum);
  if (locString == NULL || locString[0] == '\0') {
     node->loc.x = 0; node->loc.y = 0; /* assign to zero for default */
   }
  else
      {
	  float x,y;
	  sscanf(locString, "(%f, %f)", &x, &y);
	  node->loc.x = x;
	  node->loc.y = y;
      }
  nodeElem = PQgetvalue(pbuf, tupno, nodeElem_attnum);
  node->nodeElem = findElemInRecipe(r,nodeElem);
  node->inNodes = newArr_TgNodePtr();
  node->outNodes = newArr_TgNodePtr();

  /* fill the inNodes array with as many NULL's are there are inPorts in
   * the underlying element */
  BlankNodePtr = (TgNodePtr)NULL;
  for (i = 0 ; i < node->nodeElem->inPorts->num ; i++)
    addArr_TgNodePtr(node->inNodes, &BlankNodePtr);

  /* fill the outNodes array with as many NULL's are there are inPorts in
   * the underlying element */
  for (i = 0 ; i < node->nodeElem->outPorts->num ; i++)
    addArr_TgNodePtr(node->outNodes, &BlankNodePtr);

  nodeType = PQgetvalue(pbuf, tupno, nodeType_attnum);

  if (strcmp(nodeType, "Ingred") == 0)
    node->nodeType = TG_INGRED_NODE;
  else if (strcmp(nodeType, "Eye") == 0)
    node->nodeType = TG_EYE_NODE;
  else if (strcmp(nodeType, "Recipe") == 0)
    node->nodeType = TG_RECIPE_NODE;
  else
    elog(NOTICE, "fillTgNode: unknown nodeType field value : %s\n", nodeType);
  
}

/* -------------------------------------
fillTgElement
    takes a query result in the PortalBuffer containing a Element 
    and converts it to a C TgElement strcture.
    The TgElement structure passed in is 'filled' appropriately
  ------------------------------------ */

void
fillTgElement(TgElement *elem,  PortalBuffer *pbuf, int tupno)
{
  char* srcLang, *elemType;
  static int attnums_initialized = 0;
  static int elemName_attnum; 
  static int elemType_attnum; 
  static int inPorts_attnum;
  static int inTypes_attnum;
  static int outPorts_attnum;
  static int outTypes_attnum;
  static int doc_attnum;
  static int keywords_attnum;
  static int icon_attnum;
  static int srcLang_attnum;
  static int src_attnum;
  static int owner_attnum;

  if (!attnums_initialized) {
    /* the first time fillTgElement is called,
       we find out all the relevant attribute numbers in a TgElement
       so subsequent calls are speeded up,
       the assumption is that the schema won't change between calls*/
    elemName_attnum = PQfnumber(pbuf, tupno, "elemName");
    elemType_attnum = PQfnumber(pbuf, tupno, "elemType");
    inPorts_attnum = PQfnumber(pbuf, tupno, "inPorts");
    inTypes_attnum = PQfnumber(pbuf, tupno, "inTypes");
    outPorts_attnum = PQfnumber(pbuf, tupno, "outPorts");
    outTypes_attnum = PQfnumber(pbuf, tupno, "outTypes");
    doc_attnum = PQfnumber(pbuf, tupno, "doc");
    keywords_attnum = PQfnumber(pbuf, tupno, "keywords");
    icon_attnum = PQfnumber(pbuf, tupno, "icon");
    srcLang_attnum = PQfnumber(pbuf, tupno, "srcLang");
    src_attnum = PQfnumber(pbuf, tupno, "src");
    attnums_initialized = 1;
  }

  elem->elemName = PQgetAttr(pbuf, tupno, elemName_attnum);
  elem->inPorts = TextArray2ArrTgString(PQgetvalue(pbuf, tupno, inPorts_attnum));
  elem->inTypes = TextArray2ArrTgString(PQgetvalue(pbuf, tupno, inTypes_attnum));
  elem->outPorts = TextArray2ArrTgString(PQgetvalue(pbuf, tupno, outPorts_attnum));
  elem->outTypes = TextArray2ArrTgString(PQgetvalue(pbuf, tupno, outTypes_attnum));
  elem->doc = PQgetAttr(pbuf, tupno, doc_attnum);
  elem->keywords = TextArray2ArrTgString(PQgetvalue(pbuf, tupno, keywords_attnum));
  elem->icon = PQgetAttr(pbuf,tupno, icon_attnum);
  elem->src = PQgetAttr(pbuf,tupno, src_attnum);
  elem->owner = PQgetAttr(pbuf,tupno, owner_attnum);

  /* we don't need to keep the value returned so use PQgetvalue()
     instead of PQgetAttr() */
  srcLang = PQgetvalue(pbuf,tupno, srcLang_attnum); 

  if (strcmp(srcLang, "SQL") == 0) 
    elem->srcLang = TG_SQL;
  else
    if (strcmp(srcLang, "C") == 0)
      elem->srcLang = TG_C;
  else
    if (strcmp(srcLang, "RecipeGraph") == 0)
      elem->srcLang = TG_RECIPE_GRAPH;
  else
    if (strcmp(srcLang, "Compiled") == 0)
      elem->srcLang = TG_COMPILED;
  else
    elog(NOTICE, "fillTgElement(): unknown srcLang field value : %s\n", srcLang);

  elemType = PQgetvalue(pbuf, tupno, elemType_attnum);
  if (strcmp(elemType, "Ingred") == 0)
    elem->elemType = TG_INGRED;
  else if (strcmp(elemType, "Eye") == 0)
    elem->elemType = TG_EYE;
  else if (strcmp(elemType, "Recipe") == 0)
    elem->elemType = TG_RECIPE;
  else
    elog(NOTICE, "fillTgElement(): unknown elemType field value : %s\n", elemType);


}
/* -------------------------------------
lookupEdges - 
    look up the edges of a recipe and fill in the inNodes 
    and outNodes of each node.
    In the process of connecting edges, we detect tee's and create
    teeNodes.  We add the teeNodes to the allNodes field of r as well
------------------------------------ */
void 
lookupEdges(TgRecipe *r, char* name)
{
  char qbuf[MAX_QBUF_LENGTH];
  int i;
  char *pqres;
  char *pbufname;
  PortalBuffer *pbuf;
  int ntups;
  int fromNode_attnum;
  int fromPort_attnum;
  int toPort_attnum;
  int toNode_attnum;
  char *toNode, *fromNode;
  char *toPortStr, *fromPortStr;
  int toPort, fromPort;

  TgNodePtr fromNodePtr, toNodePtr;

  sprintf(qbuf, Q_LOOKUP_EDGES_IN_RECIPE, name);
  pqres = PQexec(qbuf);
  pqres = PQexec(qbuf);
  if (*pqres == 'R' || *pqres == 'E') {
    elog(NOTICE, "lookupEdges(): Error while executing query : %s\n", qbuf);
    elog(NOTICE, "result = %s, error is %s\n", pqres, PQerrormsg);
    return;
  }
  pbufname = ++pqres;
  pbuf = PQparray(pbufname);
  ntups = PQntuplesGroup(pbuf,0);

  if (ntups == 0) { return; }

  fromNode_attnum = PQfnumber(pbuf, 0, "fromNode");
  fromPort_attnum = PQfnumber(pbuf, 0, "fromPort");
  toNode_attnum = PQfnumber(pbuf, 0, "toNode");
  toPort_attnum = PQfnumber(pbuf, 0, "toPort");

  for (i=0;i<ntups;i++) {

    fromNode = PQgetvalue(pbuf, i, fromNode_attnum);
    toNode = PQgetvalue(pbuf, i, toNode_attnum);
    fromPortStr = PQgetvalue(pbuf, i, fromPort_attnum);
    toPortStr = PQgetvalue(pbuf, i, toPort_attnum);

    if (!fromPortStr || fromPortStr[0] == '\0')  {
      elog(NOTICE, "lookupEdges():  SANITY CHECK failed.  Edge with invalid fromPort value!");
      return;
    }
    if (!toPortStr || toPortStr[0] == '\0') {
      elog(NOTICE, "lookupEdges():  SANITY CHECK failed.  Edge with invalid toPort value!!");
      return;
    }
    fromPort = atoi(fromPortStr);
    toPort = atoi(toPortStr);

    fromNodePtr = findNodeInRecipe(r, fromNode);
    if (!fromNodePtr) {
      elog(NOTICE, "lookupEdges():  SANITY CHECK failed.  Edge with bad fromNode value!");
      return;
    }
    toNodePtr = findNodeInRecipe(r, toNode);
    if (!toNodePtr) {
      elog(NOTICE, "lookupEdges():  SANITY CHECK failed.  Edge with bad toNode value!");
      return;
    }

    /* check to see if the from port is already connected.
       if it is, then this means we should construct a Tee node 
    */
    if (fromNodePtr->outNodes->val[fromPort-1] != NULL) {
	TgNodePtr tn;

	tn = connectTee(r,fromNodePtr, toNodePtr, fromPort, toPort);
	addArr_TgNodePtr(r->allNodes,&tn);
    } else {
	fromNodePtr->outNodes->val[fromPort-1] = toNodePtr;
	toNodePtr->inNodes->val[toPort-1] = fromNodePtr;
    }
  }

  PQclear(pbufname);
}

/*
   handle tee connections here
   Everytime an output port is connected multiply,
   we explicitly insert TgTeeNode

   returns the teeNode created
*/
static TgNode*
connectTee(TgRecipe *r, TgNodePtr fromNode, TgNodePtr toNode,
	   int fromPort, int toPort)
{
    TgNodePtr origToNode;
    TgNodePtr tn;
    TgNodePtr BlankNodePtr;
    int origToPort;
    int i;

    /* the toNode formerly pointed to */
    origToNode = fromNode->outNodes->val[fromPort-1];

    if (origToNode == NULL) {
	elog(NOTICE,"Internal Error: connectTee() called with a null origToNode");
	return;
    }

    for (i=0;i<origToNode->inNodes->num;i++) {
	if (origToNode->inNodes->val[i] == fromNode)
	    break;
    }

    /* the inport of the former toNode  */
    /* ports start with 1, array indices start from 0 */
    origToPort = i + 1;

    /* add a tee node now. */
    tn = malloc(sizeof(TgNode));
    /* generate a name for the tee node table */
    tn->nodeName = malloc(50);
    sprintf(tn->nodeName, "tee_%d", newoid());
/*    tn->nodeName = NULL; */
    
    tn->nodeType = TG_TEE_NODE;
    tn->nodeElem = NULL;
    tn->inNodes = newArr_TgNodePtr();
    tn->outNodes = newArr_TgNodePtr();

    BlankNodePtr = (TgNodePtr)NULL;
    /* each TgTeeNode has one input and two outputs, NULL them initiallly */
    addArr_TgNodePtr(tn->inNodes, &BlankNodePtr);
    addArr_TgNodePtr(tn->outNodes, &BlankNodePtr);
    addArr_TgNodePtr(tn->outNodes, &BlankNodePtr);

    /* make the old toNode the left parent of the tee node
       add the new toNode as the right parent of the tee node */
    tn->outNodes->val[0] = origToNode;
    origToNode->inNodes->val[origToPort-1] = tn;

    tn->outNodes->val[1] = toNode;
    toNode->inNodes->val[toPort-1] = tn;

    /* connect the fromNode to the new tee node */
    fromNode->outNodes->val[fromPort-1] = tn;
    tn->inNodes->val[0] = fromNode;

    return tn;
}

/* -------------------------------------
fillAllNodes
    fill out the nodes of a recipe
  ------------------------------------ */
void 
fillAllNodes(TgRecipe *r, char* name)
{
  char qbuf[MAX_QBUF_LENGTH];
  int i;
  char *pqres;
  char *pbufname;
  PortalBuffer *pbuf;
  int ntups;
  TgElement *elem;
  TgNode *node;

  /* 1) fill out the elements that are in the recipe */
  sprintf(qbuf, Q_RETRIEVE_ELEMENTS_IN_RECIPE, name);
  pqres = PQexec(qbuf);
  if (*pqres == 'R' || *pqres == 'E') {
    elog(NOTICE, "fillAllNodes(): Error while executing query : %s\n", qbuf);
    elog(NOTICE, "result = %s, error is %s\n", pqres, PQerrormsg);
    return;
  }
  pbufname = ++pqres;
  pbuf = PQparray(pbufname);
  ntups = PQntuplesGroup(pbuf,0);
  for (i=0;i<ntups;i++) {
    elem = malloc(sizeof(TgElement));
    fillTgElement(elem, pbuf, i);
    addArr_TgElementPtr(r->elements, &elem);
  }
  PQclear(pbufname);
  
  sprintf(qbuf, Q_RETRIEVE_NODES_IN_RECIPE, name);
  pqres = PQexec(qbuf);
  if (*pqres == 'R' || *pqres == 'E') {
    elog(NOTICE, "fillAllNodes(): Error while executing query : %s\n", qbuf);
    elog(NOTICE, "result = %s, error is %s\n", pqres, PQerrormsg);
    return;
  }
  pbufname = ++pqres;
  pbuf = PQparray(pbufname);
  ntups = PQntuplesGroup(pbuf,0);
  for (i=0;i<ntups;i++) {
    node = malloc(sizeof(TgNode));
    fillTgNode(r, node, pbuf, i);
    addArr_TgNodePtr(r->allNodes, &node);
  }
  PQclear(pbufname);

}


/* -------------------------------------
fillAllElements
    fill out the elements of a recipe
  ------------------------------------ */
void 
fillAllElements(TgRecipe *r, char* name)
{
  char qbuf[MAX_QBUF_LENGTH];
  int i;
  char *pqres;
  char *pbufname;
  PortalBuffer *pbuf;
  int ntups;
  TgElement *elem;

  sprintf(qbuf, Q_RETRIEVE_ELEMENTS_IN_RECIPE, name);
  pqres = PQexec(qbuf);
  if (*pqres == 'R' || *pqres == 'E') {
    elog(NOTICE, "fillAllElements(): Error while executing query : %s\n", qbuf);
    elog(NOTICE, "result = %s, error is %s\n", pqres, PQerrormsg);
    return;
  }
  pbufname = ++pqres;
  pbuf = PQparray(pbufname);
  ntups = PQntuplesGroup(pbuf,0);
  for (i=0;i<ntups;i++) {
    elem = malloc(sizeof(TgElement));
    fillTgElement(elem, pbuf, i);
    addArr_TgElementPtr(r->elements, &elem);
  }
  PQclear(pbufname);
  
}


/* -------------------------------------
fillTgRecipe
    takes a query result in the PortalBuffer containing a Recipe
    and converts it to a C TgRecipe strcture
  ------------------------------------ */
TgRecipe* 
fillTgRecipe(PortalBuffer* pbuf, int tupno)
{
  TgRecipe* r;
  int i,j;

  /* 1) set up the recipe structure */
  r = (TgRecipe*)malloc(sizeof(TgRecipe));
  fillTgElement(&r->elmValue, pbuf, 0); 
  r->elmValue.elemType = TG_RECIPE;
  r->allNodes = newArr_TgNodePtr();
  r->rootNodes = newArr_TgNodePtr();
  r->eyes = newArr_TgNodePtr();
  r->tees = newArr_TgNodePtr();
  r->elements = newArr_TgElementPtr();

  /* 2) find all the elements. There may be less elements than nodes
        because you can have multiple instantiations of an element
	in a recipe*/
  fillAllElements(r, r->elmValue.elemName);

  /* 3) find all the nodes in the recipe*/
  fillAllNodes(r, r->elmValue.elemName);
  
  /* 4) find all the edges, and connect the nodes,
        may also add tee nodes to the allNodes field*/
  lookupEdges(r, r->elmValue.elemName);

  /* 5) find all the rootNodes in the recipe */
  /*   root nodes are nodes with no incoming nodes or
       whose incoming nodes are all null */
  /* 6) find all the eyes in the recipe */
  /* eye nodes are nodes with the node type TG_EYE_NODE */
  /* 7) find all the tee nodes in the recipe */
  /* tee nodes are nodes with the node type TG_TEE_NODE */
  for (i=0;i<r->allNodes->num;i++) {
    TgNode* nptr = r->allNodes->val[i];

    if (nptr->nodeType == TG_EYE_NODE) 
	addArr_TgNodePtr(r->eyes, &nptr);
    else
	if (nptr->nodeType == TG_TEE_NODE)
	    addArr_TgNodePtr(r->tees, &nptr);

    if (nptr->inNodes->num == 0) 
	addArr_TgNodePtr(r->rootNodes, &nptr);
    else {
	for (j=0;
	   j<nptr->inNodes->num && (nptr->inNodes->val[j] == NULL);
	   j++);
      if (j == nptr->inNodes->num)
	addArr_TgNodePtr(r->rootNodes, &nptr);
    }
  }

  return r;

}


/* -------------------------------------
retrieveRecipe
   find the recipe with the given name
  ------------------------------------ */
TgRecipe*
retrieveRecipe(char* name)
{
  char qbuf[MAX_QBUF_LENGTH];
  TgRecipe* recipe;
  char *pqres;
  char *pbufname;
  PortalBuffer *pbuf;
  int ntups;

  sprintf(qbuf, Q_RETRIEVE_RECIPE_BYNAME, name);

  pqres = PQexec(qbuf);
  if (*pqres == 'R' || *pqres == 'E') {
    elog(NOTICE, "retrieveRecipe: Error while executing query : %s\n", qbuf);
    elog(NOTICE, "result = %s, error is %s\n", pqres, PQerrormsg);
    return NULL;
  }
  pbufname = ++pqres;
  pbuf = PQparray(pbufname);
  ntups = PQntuplesGroup(pbuf,0);
  if (ntups == 0) {
    elog(NOTICE, "retrieveRecipe():  No recipe named %s exists\n", name);
    return NULL;
  }
  if (ntups != 1) {
    elog(NOTICE, "retrieveRecipe():  Multiple (%d) recipes named %s exists\n", ntups, name);
    return NULL;
  }

  recipe = fillTgRecipe(pbuf,0);

  PQclear(pbufname);
  return recipe;

}

/* -------------------- copyXXX functions ----------------------- */
void copyTgElementPtr(TgElementPtr* from, TgElementPtr* to)
{
  *to = *from;
}

void copyTgNodePtr(TgNodePtr* from, TgNodePtr* to)
{
  *to = *from;
}

void copyTgRecipePtr(TgRecipePtr* from, TgRecipePtr* to)
{
  *to = *from;
}

void copyTgString(TgString* from, TgString* to)
{
  TgString fromTgString = *from;
  TgString toTgString;
  toTgString = (TgString)malloc(strlen(fromTgString)+1);
  strcpy(toTgString, fromTgString);
  *to = toTgString;
}

