/* ------- code automatically created by ../scripts/adms_build_object.pl -------------- */
#include <admsObject/objectBlock.h>
#include <admsObject/objectAdmsmain.h>

inline void adms_block_free(p_block myblock)
{
  if(!myblock)
    return;
  adms_enumeration_free(myblock->_math._dependency);
  free(myblock->_math._value);
  {p_slist l=myblock->_attribute;for(;l;l=l->next) adms_attribute_free(adms_attribute(l->data));}
  adms_slist_free(myblock->_attribute);
  adms_slist_free(myblock->_variable);
  adms_slist_free(myblock->_item);
  adms_slist_free(myblock->_probe);
  adms_quark_free(myblock->_name);
  adms_global_increment_nbblockdestroy();
  free(myblock);
}
int adms_block_cmp (p_block myblock,p_block refblock)
{
  int status;
  status =
  (
    (adms_block_valueof_module (myblock) != adms_block_valueof_module (refblock))
    ||
    !!strcmp(adms_block_valueof_name (myblock)->_value,adms_block_valueof_name (refblock)->_value)
    ||
    (adms_block_valueof_block (myblock) != adms_block_valueof_block (refblock))
  );
  return status;
}
p_block adms_block_new(p_module mymodule,p_quark myname,p_block myblock)
{
  p_block mynewblock=(p_block) calloc(1,(size_t)sizeof(t_block));
  adms_global_increment_nbblocknew();
  mynewblock->_math._adms._datatypename=adms_adms_enumeration_datatypename_block;
  mynewblock->_math._adms._seen=adms_adms_enumeration_seen_no;
  (mynewblock->_math)._value=adms_real_new(adms_NAN);
  (mynewblock->_math)._static=adms_enumeration_new(adms_math_enumeration_static_no,adms_math_fromstring_static_impl,adms_math_tostring_static_impl);
  (mynewblock->_math)._dynamic=adms_enumeration_new(adms_math_enumeration_dynamic_no,adms_math_fromstring_dynamic_impl,adms_math_tostring_dynamic_impl);
  (mynewblock->_math)._dependency=adms_enumeration_new(adms_math_enumeration_dependency_constant,adms_math_fromstring_dependency_impl,adms_math_tostring_dependency_impl);
  mynewblock->_module_isdefault=-1;
  adms_block_valueto_module (mynewblock,mymodule);
  mynewblock->_module_isdefault=1;
  mynewblock->_name_isdefault=-1;
  adms_block_valueto_name (mynewblock,myname);
  mynewblock->_name_isdefault=1;
  mynewblock->_block_isdefault=-1;
  adms_block_valueto_block (mynewblock,myblock);
  mynewblock->_block_isdefault=1;
  mynewblock->_attribute_isdefault=-1;
  mynewblock->_variable_isdefault=-1;
  mynewblock->_item_isdefault=-1;
  mynewblock->_probe_isdefault=-1;
  return mynewblock;
}
p_adms adms_block_new_impl (p_adms arguments[])
{
  p_block mynewblock;
  p_module mymodule=(p_module)arguments[0];
  p_quark myname=adms_quark_new((char*)arguments[1]);
  p_block myblock=(p_block)arguments[2];
  mynewblock=adms_block_new(mymodule,myname,myblock);
  return adms_adms(mynewblock);
}
/*$1:$2*/
char*adms_block_uid (p_block mynewblock)
{
  char*myuid=NULL;
  char*myuid0=adms_module_uid(mynewblock->_module);
  char*myuid1=adms_quark_uid(mynewblock->_name);
  adms_strconcat(&myuid,myuid0);
  adms_strconcat2(&myuid,":");
  adms_strconcat(&myuid,myuid1);
  return myuid;
}

inline void
adms_block_valueto_module (p_block myblock,p_module _module)
{
  myblock->_module=_module;
  myblock->_module_isdefault=0;
}

inline void
adms_block_valueto_name (p_block myblock,p_quark _name)
{
  if(myblock->_name_isdefault!=-1)
    adms_quark_free(myblock->_name);
  myblock->_name=_name;
  myblock->_name_isdefault=0;
}

inline void
adms_block_valueto_block (p_block myblock,p_block _block)
{
  myblock->_block=_block;
  myblock->_block_isdefault=0;
}

inline void
adms_block_valueto_attribute (p_block myblock,p_slist _attribute)
{
  myblock->_attribute=_attribute;
  myblock->_attribute_isdefault=0;
}
p_attribute
adms_block_list_attribute_lookup_by_id (p_block mymyblock,p_quark myname)
{
  p_slist list=adms_block_valueof_attribute(mymyblock);
  while(list) {
    p_attribute refattribute=adms_attribute(list->data);
    if(!strcmp(adms_attribute_valueof_name(refattribute)->_value,myname->_value))
      return refattribute;
    list=list->next;
  }
  return NULL;
}
p_attribute
adms_block_list_attribute_prepend_by_id (p_block mymyblock,p_quark myname)
{
  p_attribute refattribute=adms_attribute_new(myname);
  adms_slist_push(&adms_block_valueof_attribute(mymyblock),adms_adms(refattribute));
  return refattribute;
}
p_attribute
adms_block_list_attribute_prepend_by_id_once_or_ignore (p_block mymyblock,p_quark myname)
{
  p_attribute refattribute=adms_attribute_new(myname);
  adms_slist_push(&adms_block_valueof_attribute(mymyblock),adms_adms(refattribute));
  return refattribute;
}
void
adms_block_list_attribute_prepend (p_block mymyblock,p_attribute myattribute)
{
  adms_slist_push(&adms_block_valueof_attribute(mymyblock),adms_adms(myattribute));
}

inline void
adms_block_valueto_variable (p_block myblock,p_slist _variable)
{
  myblock->_variable=_variable;
  myblock->_variable_isdefault=0;
}
p_variable
adms_block_list_variable_lookup_by_id (p_block mymyblock,p_module mymodule,p_quark myname,p_adms myblock)
{
  p_slist list=adms_block_valueof_variable(mymyblock);
  while(list) {
    p_variable refvariable=adms_variable(list->data);
    if((adms_variable_valueof_module(refvariable)==mymodule)&&
       !strcmp(adms_variable_valueof_name(refvariable)->_value,myname->_value)&&
       (adms_variable_valueof_block(refvariable)==myblock))
      return refvariable;
    list=list->next;
  }
  return NULL;
}
p_variable
adms_block_list_variable_prepend_by_id (p_block mymyblock,p_module mymodule,p_quark myname,p_adms myblock)
{
  p_variable refvariable=adms_variable_new(mymodule,myname,myblock);
  adms_slist_push(&adms_block_valueof_variable(mymyblock),adms_adms(refvariable));
  return refvariable;
}
p_variable
adms_block_list_variable_prepend_by_id_once_or_abort (p_block mymyblock,p_module mymodule,p_quark myname,p_adms myblock)
{
  p_slist list=adms_block_valueof_variable(mymyblock);
  p_variable refvariable=adms_variable_new(mymodule,myname,myblock);
  while(list)
  {
    if(!adms_variable_cmp(adms_variable(list->data),refvariable))
    {
      adms_message_fatal(("block=[%s] variable=[%s] already defined\n",
        adms_block_uid(mymyblock),adms_variable_uid(refvariable)))
      adms_variable_free (refvariable);
    }
    list=list->next;
  }
  adms_slist_push(&adms_block_valueof_variable(mymyblock),adms_adms(refvariable));
  return refvariable;
}
void
adms_block_list_variable_prepend_once_or_abort (p_block mymyblock,p_variable myvariable)
{
  p_slist list=adms_block_valueof_variable(mymyblock);
  while(list)
  {
    if(!adms_variable_cmp(adms_variable(list->data),myvariable))
    {
      adms_message_fatal(("block=[%s] variable=[%s] already defined\n",
        adms_block_uid(mymyblock),adms_variable_uid(myvariable)))
      return;
    }
    list=list->next;
  }
  adms_slist_push(&adms_block_valueof_variable(mymyblock),adms_adms(myvariable));
}

inline void
adms_block_valueto_item (p_block myblock,p_slist _item)
{
  myblock->_item=_item;
  myblock->_item_isdefault=0;
}
void
adms_block_list_item_prepend (p_block mymyblock,p_adms myitem)
{
  adms_slist_push(&adms_block_valueof_item(mymyblock),adms_adms(myitem));
}

inline void
adms_block_valueto_probe (p_block myblock,p_slist _probe)
{
  myblock->_probe=_probe;
  myblock->_probe_isdefault=0;
}
p_probe
adms_block_list_probe_lookup_by_id (p_block mymyblock,p_module mymodule,p_branch mybranch,p_nature mynature)
{
  p_slist list=adms_block_valueof_probe(mymyblock);
  while(list) {
    p_probe refprobe=adms_probe(list->data);
    if((adms_probe_valueof_module(refprobe)==mymodule)&&
       (adms_probe_valueof_branch(refprobe)==mybranch)&&
       (adms_probe_valueof_nature(refprobe)==mynature))
      return refprobe;
    list=list->next;
  }
  return NULL;
}
p_probe
adms_block_list_probe_prepend_by_id (p_block mymyblock,p_module mymodule,p_branch mybranch,p_nature mynature)
{
  p_probe refprobe=adms_probe_new(mymodule,mybranch,mynature);
  adms_slist_push(&adms_block_valueof_probe(mymyblock),adms_adms(refprobe));
  return refprobe;
}
p_probe
adms_block_list_probe_prepend_by_id_once_or_ignore (p_block mymyblock,p_module mymodule,p_branch mybranch,p_nature mynature)
{
  p_slist list=adms_block_valueof_probe(mymyblock);
  p_probe refprobe=adms_probe_new(mymodule,mybranch,mynature);
  while(list)
  {
    if(!adms_probe_cmp(adms_probe(list->data),refprobe))
    {
      adms_probe_free (refprobe);
      return adms_probe(list->data);
    }
    list=list->next;
  }
  adms_slist_push(&adms_block_valueof_probe(mymyblock),adms_adms(refprobe));
  return refprobe;
}
void
adms_block_list_probe_prepend_once_or_ignore (p_block mymyblock,p_probe myprobe)
{
  p_slist list=adms_block_valueof_probe(mymyblock);
  while(list)
  {
    if(!adms_probe_cmp(adms_probe(list->data),myprobe))
      return;
    list=list->next;
  }
  adms_slist_push(&adms_block_valueof_probe(mymyblock),adms_adms(myprobe));
}