Anubis / Anubis


 Standard MUSCLE field type-constants

read tools/basis.anubis
read network/tools.anubis
read system/string.anubis
read system/types.anubis
read system/convert.anubis
read system/data_io.anubis

public define Int32 _B_ANY_TYPE     = 1095653716. // 'ANYT',  // wild card
public define Int32 _B_BOOL_TYPE    = 1112493900. // 'BOOL',
public define Int32 _B_DOUBLE_TYPE  = 1145195589. // 'DBLE',
public define Int32 _B_FLOAT_TYPE   = 1179406164. // 'FLOT',
public define Int32 _B_INT64_TYPE   = 1280069191. // 'LLNG',
public define Int32 _B_INT32_TYPE   = 1280265799. // 'LONG',
public define Int32 _B_INT16_TYPE   = 1397248596. // 'SHRT',
public define Int32 _B_INT8_TYPE    = 1113150533. // 'BYTE',
public define Int32 _B_MESSAGE_TYPE = 1297303367. // 'MSGG',
public define Int32 _B_POINTER_TYPE = 1347310674. // 'PNTR',
public define Int32 _B_POINT_TYPE   = 1112559188. // 'BPNT',
public define Int32 _B_RECT_TYPE    = 1380270932. // 'RECT',
public define Int32 _B_STRING_TYPE  = 1129534546. // 'CSTR',
public define Int32 _B_OBJECT_TYPE  = 1330664530. // 'OPTR',  // used for flattened objects
public define Int32 _B_RAW_TYPE     = 1380013908. // 'RAWT',  // used for raw byte arrays

public define Int32 _CURRENT_PROTOCOL_VERSION = 1347235888.   // 'PM00' -- our magic number 0x504D3030

public define Int32 _MUSCLE_MESSAGE_ENCODING_DEFAULT = 1164862256. //header for network transfert

public type Message:...

public define Maybe(Message) unflatten_message ( Data_IO io ).
public define Maybe(ByteArray) flatten_message ( Message msg ).

  
public type Message_Send_Result:
  flatten_error,
  network_error,
  ok.

  
type Muscle_object:
  b_bool(Bool),
  b_double(Float),
  b_float(Float32),
  b_int64(Int64),
  b_int32(Int32),
  b_int16(Int16),
  b_int8(Word8),
  b_message(Message),
  b_pointer(Int32),
  b_point(B_Point),
  b_rect(B_Rect),
  b_string(String),
  b_custom(ByteArray),
  b_raw(ByteArray).
  
type Muscle_type:
  b_any_t,
  b_bool_t,
  b_double_t,
  b_float_t,
  b_int64_t,
  b_int32_t,
  b_int16_t,
  b_int8_t,
  b_message_t,
  b_pointer_t,
  b_point_t,
  b_rect_t,
  b_string_t,
  b_custom_t(Int32), /*,
  b_object,*/
  b_raw_t.
  
type Message_field:
  message_field
  (
    String                    name,
    Muscle_type               type_code,
    Var(List(Muscle_object))  items
  ).
  
public type Message:
  message
  (
    Var(Int32)                what,
    Var(Int32)                numField,
    Var(List(Message_field))  fields
  ).
       
       
  /** Create an empty message with only his what code */
public define Message 
  message
  (
    Int32 what
  )=
  message(var(what), var(0), var([ ])).

define Int32 
  get_Int32_type_code
  (
    Muscle_type type_code
  )=
  if type_code is
  {
     b_any_t      then  _B_ANY_TYPE,
     b_bool_t     then  _B_BOOL_TYPE,
     b_double_t   then  _B_DOUBLE_TYPE,
     b_float_t    then  _B_FLOAT_TYPE,
     b_int64_t    then  _B_INT64_TYPE,
     b_int32_t    then  _B_INT32_TYPE,
     b_int16_t    then  _B_INT16_TYPE,
     b_int8_t     then  _B_INT8_TYPE,
     b_message_t  then  _B_MESSAGE_TYPE,
     b_pointer_t  then  _B_POINTER_TYPE,
     b_point_t    then  _B_POINT_TYPE,
     b_rect_t     then  _B_RECT_TYPE,
     b_string_t   then  _B_STRING_TYPE,
     b_custom_t(v)then  v,  
     b_raw_t      then  _B_RAW_TYPE,
  }
  .
  
define Maybe(Muscle_type)
  get_muscle_type
  (
    Int32 type_code
  )=
  if type_code = _B_BOOL_TYPE then
    success(b_bool_t)
  else if type_code = _B_DOUBLE_TYPE then
    success(b_double_t)
  else if type_code = _B_FLOAT_TYPE then
    success(b_float_t)
  else if type_code = _B_INT64_TYPE then
    success(b_int64_t)
  else if type_code = _B_INT32_TYPE then
    success(b_int32_t)
  else if type_code = _B_INT16_TYPE then
    success(b_int16_t)
  else if type_code = _B_INT8_TYPE then
    success(b_int8_t)
  else if type_code = _B_MESSAGE_TYPE then
    success(b_message_t)    
  else if type_code = _B_POINTER_TYPE then
    success(b_message_t)    
  else if type_code = _B_POINT_TYPE then
    success(b_point_t)
  else if type_code = _B_RECT_TYPE then
    success(b_rect_t)
  else if type_code = _B_STRING_TYPE then
    success(b_string_t)
  else if type_code = _B_RAW_TYPE then
    success(b_raw_t)
  else
    print("muscle custom type " + to_hexa(type_code) + "\n");
    success(b_custom_t(type_code)).
 

public define One
  print_to_stream
  (
    Message msg
  )=
  print("Message: what = " + *msg.what + ", ASCII = \"" + to_ascii(*msg.what) + "\", Hexa = 0x" + to_hexa(*msg.what) + "\n" +
        "entry count=" + *msg.numField +"\n").
  

public define One
  set_what
  (
    Message msg,
    Int32   new_what
  ) =
  msg.what <- new_what.

  /** Don't allow the user to put data blobs under any of the non-data-blob type codes,
   * because that would mess up our internal logic which assumes that fields of those
   * types have the appropriate data for their type
   * @param typeCode 
   */

public define Bool
  is_type_code_variable_size
  (
    Muscle_type type_code
  ) =
  if type_code = b_bool_t    |
     type_code = b_double_t  |
     type_code = b_float_t   |
     type_code = b_int64_t   |
     type_code = b_int32_t   |
     type_code = b_int16_t   |
     type_code = b_int8_t    |
     type_code = b_pointer_t |
     type_code = b_point_t   |
     type_code = b_rect_t then 
    true
  else
    false.

define Maybe(ByteArray)
  read_data
  (
    Data_IO io,
    Int32   nb_bytes
  ) =
  if read_bytes(io, nb_bytes) is
  {
    failure        then failure,
    time_out       then failure, 
    success(bytes) then success(bytes),
    truncated(_)   then failure
  }.
  
define Maybe(Int32)
  read_Int32
  (
    Data_IO  io,
  ) =
  if read_bytes(io, 4) is
  {
    failure        then failure,
    time_out       then failure, 
    success(bytes) then 
    //TODO convert to right the platform endian
      with value = lendian_to_host_Int32(bytes),
//      print("Int32["+value+"] "+to_ascii(value)+ "\n");
      success(value),
    truncated(_)   then failure
  }.

define Maybe(Int64)
  read_Int64
  (
    Data_IO  io,
  ) =
  if read_bytes(io, 8) is
  {
    failure        then failure,
    time_out       then failure, 
    success(bytes) then 
    //TODO convert to right the platform endian
      with value = lendian_to_host_Int64(bytes),
//      print("Int32["+value+"] "+to_ascii(value)+ "\n");
      success(value),
    truncated(_)   then failure
  }.

define Maybe(Float32)
  read_float32
  (
    Data_IO  io,
  ) =
  if read_bytes(io, 4) is
  {
    failure        then failure,
    time_out       then failure, 
    success(bytes) then 
    //TODO convert to right the platform endian
      with value = lendian_to_host_Int32(bytes),
//      print("Int32["+value+"] "+to_ascii(value)+ "\n");
      success(float32(value)),
    truncated(_)   then failure
  }.

define Maybe(Float)
  read_float64
  (
    Data_IO  io,
  ) =
  if read_bytes(io, 8) is
  {
    failure        then failure,
    time_out       then failure, 
    success(bytes) then 
    //TODO convert to right the platform endian
    lendian_to_host_Float64(bytes),
    truncated(_)   then failure
  }.

define Maybe(Int16)
  read_Int16
  (
    Data_IO  io,
  ) =
  if read_bytes(io, 2) is
  {
    failure        then failure,
    time_out       then failure, 
    success(bytes) then 
      with value = lendian_to_host_Int16(bytes),
      success(value),
    truncated(_)   then failure
  }.

define Maybe(Muscle_object)
  read_one_field_item
  (
    Data_IO     source,
    Muscle_type b_type
  )=
  if b_type is
  {
    b_any_t      then
      failure,
    //read one B_BOOL field
    b_bool_t     then
    if read_data(source, 1) is
    {
      failure           then failure,
      success(ba_bool)  then 
        with bool8 = force_nth(0, ba_bool),
        //print("B_BOOL = " + bool8 + "\n");
        with real_bool = if bool8 = 0 then false else true,
        success(b_bool(real_bool)) //convert into Anubis Bool
    }
    //read one B_DOUBLE field
    b_double_t     then
    if read_float64(source) is
    {
      failure         then failure,
      success(value)  then 
        //print("B_DOUBLE = " + float_to_string(value,5) + "\n");
        success(b_double(value)) //convert into Anubis Int32
    }
    //read one B_FLOAT field
    b_float_t     then
    if read_float32(source) is
    {
      failure           then failure,
      success(value)  then 
        //print("B_FLOAT = Float32 not yet available\n");
        success(b_float(value)) //convert into Anubis Int32
    }
    //read one B_INT64 field
    b_int64_t     then
    if read_Int64(source) is
    {
      failure           then failure,
      success(value)  then 
        //print("B_INT64 = not yet printable\n");
        success(b_int64(value)) //convert into Anubis Int64
    }
    //read one B_INT32 field
    b_int32_t     then
    if read_Int32(source) is
    {
      failure           then failure,
      success(value)  then 
        //print("B_INT32 = " + value + "\n");
        success(b_int32(value)) //convert into Anubis Int32
    }
    //read one B_INT16 field
    b_int16_t     then
    if read_Int16(source) is
    {
      failure         then failure,
      success(value)  then 
        //print("B_INT16 = " + value + "\n");
        success(b_int16(value)) //convert into Anubis Int32
    }
    
    //read one B_INT8 field
    b_int8_t     then
    if read_data(source, 1) is
    {
      failure         then failure,
      success(ba_value)  then 
        with value = force_nth(0,ba_value),
        //print("B_INT8 = " + value + "\n");
        success(b_int8(value)) //convert into Anubis Int32
    }

    //read one B_MESSAGE field    
    b_message_t   then
     if unflatten_message(source) is
     {
        failure           then failure,
        success(message)  then
          success(b_message(message))
     }
     
    //read one B_POINTER field. Remark, we read it for compatibility, but itsn't useful in
    //Anubis Language, because pointer doesn't exist.
    b_pointer_t     then
    if read_Int32(source) is
    {
      failure           then failure,
      success(value)  then 
        //print("B_POINTER = " + value + "\n");
        success(b_pointer(value)) //convert into Anubis Int32
    }

  //read one B_POINT field
    b_point_t   then  
     if read_float32(source)  is
     {
      failure       then failure,
      success(x)    then 
        if read_float32(source) is
        {
          failure     then failure,
          success(y)  then 
            //print("B_POINT = Float32 not yet available\n");
            success(b_point(point(x, y)))  //return the point value
        }
     }

  //read one B_RECT field
    b_rect_t   then  
     if read_float32(source)  is
     {
      failure       then failure,
      success(x)    then 
        if read_float32(source) is
        {
          failure     then failure,
          success(y)  then 
            if read_float32(source) is
            {
              failure     then failure,
              success(w)  then 
                if read_float32(source) is
                {
                  failure     then failure,
                  success(h)  then 
                    //print("B_RECT = Float32 not yet available\n");
                    success(b_rect(rect(point(x, y), point(w,h))))  //return the point value
                }
            }
        }
     }

    //read one B_STRING field
    b_string_t   then  
     if read_Int32(source)  is
     {
      failure then failure,
      success(size) then                //get his size
        if read_data(source, size) is   //and read it
        {
          failure             then failure,
          success(ba_string)  then 
            //print("B_STRING = " + to_string(ba_string) + "\n");
            success(b_string(to_string(ba_string))) //convert into Anubis String
        }
     }
    //read one CUSTOM field
    b_custom_t(_)  then
     if read_Int32(source)  is
     {
      failure then failure,
      success(size) then                //get his size
        if read_data(source, size) is   //and read it
        {
          failure             then failure,
          success(ba_custom)  then 
            success(b_custom(ba_custom))
        }
     }
    //read one RAW field
    b_raw_t  then
     if read_Int32(source)  is
     {
      failure then failure,
      success(size) then                //get his size
        if read_data(source, size) is   //and read it
        {
          failure          then failure,
          success(ba_raw)  then 
            success(b_raw(ba_raw))
        }
     }
  }
  .

define Maybe(List(Muscle_object))
  read_field_items
  (
    Data_IO     source,
    Muscle_type b_type,
    Int32       count
  )=
  if count =< 0 then 
    success([ ]) 
  else
    if read_one_field_item(source, b_type) is 
    {
      failure            then failure, 
      success(first_one) then 
        if read_field_items(source, b_type, count-1) is 
        {
          failure         then failure, 
          success(others) then success([first_one . others])
        }
    }.

define Maybe(List(Muscle_object))
  read_message_field_items
  (
    Data_IO source,
    Int32   amount
  )=
  if amount =< 0 then
    success([ ])
  else
    if read_Int32(source) is
    {
      failure                       then failure,
      success(current_message_size) then
      //now we have the size of current message
      if read_one_field_item(source, b_message_t) is 
      {
        failure            then failure, 
        success(first_one) then 
          if read_message_field_items(source, amount - (current_message_size + 4)) is 
          {
            failure         then failure, 
            success(others) then success([first_one . others])
          }
      }
    }.
  
define Maybe(Message_field)   
  read_one_field
  (
    Data_IO    source
  )=
  //read length of the field name (4 bytes)
  if read_Int32(source) is
  {
    failure               then failure,
    success(name_length)  then
    //read the field name itself  
    if read_data(source, name_length) is
    {
      failure           then failure
      success(ba_name)  then  
      with field_name = to_string(ba_name),
      //read the type code of the field (4 bytes)
      if read_Int32(source) is
      {
        failure then failure,
        success(int32_type_code) then
        //read the length of data depending on the type, the meaning of that length is different
        // * for fixed size type_code, we can determine the number of data by dividing that number
        //   by datum size.
        // * for non fixed size type_code it's only the total size of data independtly of number of data
        if read_Int32(source) is
        {
          failure               then failure
          success(data_length)  then
          if get_muscle_type(int32_type_code) is
          {
            failure             then failure,
            success(type_code)  then
            if type_code is
            {
              b_any_t   then  failure,
  // read BOOL
              b_bool_t  then  
                if read_field_items(source, type_code, data_length) is
                {
                  failure               then failure,
                  success(field_items)  then success(message_field(field_name, type_code, var(field_items)))
                }
  // read DOUBLE
              b_double_t  then  
                if read_field_items(source, type_code, data_length >> 3) is
                {
                  failure               then failure,
                  success(field_items)  then success(message_field(field_name, type_code, var(field_items)))
                }
  // read FLOAT
              b_float_t  then  
                if read_field_items(source, type_code, data_length >> 2) is
                {
                  failure               then failure,
                  success(field_items)  then success(message_field(field_name, type_code, var(field_items)))
                }
  // read INT64
              b_int64_t then
                if read_field_items(source, type_code, data_length >> 3) is
                {
                  failure               then failure,
                  success(field_items)  then success(message_field(field_name, type_code, var(field_items)))
                }
  // read INT32
              b_int32_t then
                if read_field_items(source, type_code, data_length >> 2) is
                {
                  failure               then failure,
                  success(field_items)  then success(message_field(field_name, type_code, var(field_items)))
                }
  // read INT16                
              b_int16_t then
                if read_field_items(source, type_code, data_length >> 1) is
                {
                  failure       then failure,
                  success(field_items)  then success(message_field(field_name, type_code, var(field_items)))
                }
  // read INT8                
              b_int8_t then
                if read_field_items(source, type_code, data_length) is
                {
                  failure       then failure,
                  success(field_items)  then success(message_field(field_name, type_code, var(field_items)))
                } 
                
  // read MESSAGE                
              b_message_t then
                if read_message_field_items(source, data_length) is
                {
                  failure               then failure,
                  success(field_items)  then success(message_field(field_name, type_code, var(field_items)))
                } 

  // read POINTER
              b_pointer_t then
                if read_field_items(source, type_code, data_length >> 2) is
                {
                  failure               then failure,
                  success(field_items)  then success(message_field(field_name, type_code, var(field_items)))
                }

  // read POINT
              b_point_t then
                if read_field_items(source, type_code, data_length >> 3) is
                {
                  failure       then failure,
                  success(field_items)  then success(message_field(field_name, type_code, var(field_items)))
                }
  // read RECT
              b_rect_t then
                if read_field_items(source, type_code, data_length >> 4) is
                {
                  failure       then failure,
                  success(field_items)  then success(message_field(field_name, type_code, var(field_items)))
                }
                
  // read STRING               
              b_string_t then
                if read_Int32(source) is    //get numbers items in that field
                {
                  failure           then failure,
                  success(nb_items) then 
                  if read_field_items(source, type_code, nb_items) is
                  {
                    failure               then failure,
                    success(field_items)  then success(message_field(field_name, type_code, var(field_items)))
                  }
                }
  // read CUSTOM               
              b_custom_t(code) then
                if read_Int32(source) is    //get numbers items in that field
                {
                  failure           then failure,
                  success(nb_items) then 
                  if read_field_items(source, type_code, nb_items) is
                  {
                    failure               then failure,
                    success(field_items)  then success(message_field(field_name, type_code, var(field_items)))
                  }
                }
  // read RAW               
              b_raw_t then
                if read_Int32(source) is    //get numbers items in that field
                {
                  failure           then failure,
                  success(nb_items) then 
                  if read_field_items(source, type_code, nb_items) is
                  {
                    failure               then failure,
                    success(field_items)  then success(message_field(field_name, type_code, var(field_items)))
                  }
                }
            }
          }
        }
      }
    }
  }.
  
  /** Read each field
   *  @return 'failure' if it cannot read the required number of elements
   */
define  Maybe(List(Message_field))     
  read_fields
  (
    Data_IO  source, 
    Int32    n  // number of elements to read
  ) =
  if n =< 0 then 
    success([ ]) 
  else
    if read_one_field(source) is 
    {
      failure            then failure, 
      success(first_one) then 
        if read_fields(source, n-1) is 
        {
          failure         then failure, 
          success(others) then success([first_one . others])
        }
    }.

define Maybe(ByteArray)
  flatten_items
  (
    Muscle_type         type_code,
    List(Muscle_object) m_o,
    ByteArray           so_far
  )=
  if m_o is
  {
    []      then success(so_far),
    [h . t] then
    if h is
    {
      b_bool(data)        then
        flatten_items(type_code, t, so_far + to_ByteArray(data)),
      
      b_double(data)      then  
        flatten_items(type_code, t, so_far + host_to_lendian_Float64_ByteArray(data)),
      
      b_float(data)       then  
        flatten_items(type_code, t, so_far + host_to_lendian_Float32_ByteArray(data)),
        
     b_int64(data)        then
        flatten_items(type_code, t, so_far + host_to_lendian_Int64_ByteArray(data)),
        
     b_int32(data)        then  
        flatten_items(type_code, t, so_far + host_to_lendian_Int32_ByteArray(data)),
        
     b_int16(data)        then  
        flatten_items(type_code, t, so_far + host_to_lendian_Int16_ByteArray(data)),
        
     b_int8(data)         then  
        flatten_items(type_code, t, so_far + to_ByteArray(data)),

     b_message(data)      then  
        with result = flatten_message(data),
        if result is
        {
          failure           then  failure,
          success(message)  then
            flatten_items(type_code, t, so_far + host_to_lendian_Int32_ByteArray(length(message)) + message),             
        }
     b_pointer(data)      then  
        flatten_items(type_code, t, so_far + host_to_lendian_Int32_ByteArray(data)),
        
     b_point(data)        then  
        flatten_items(type_code, t, so_far + host_to_lendian_B_Point_ByteArray(data)),
        
     b_rect(data)         then
        flatten_items(type_code, t, so_far + host_to_lendian_B_Rect_ByteArray(data)),
     b_string(data)       then
        flatten_items(type_code, t, so_far + host_to_lendian_Int32_ByteArray(length(data)+1)
                                           + to_byte_array(data) 
                                           + constant_byte_array(1,0)),
        
     b_custom(data)       then  
        flatten_items(type_code, t, so_far + host_to_lendian_Int32_ByteArray(length(data)) + data),
     b_raw(data)          then
        flatten_items(type_code, t, so_far + host_to_lendian_Int32_ByteArray(length(data)) + data)
    }
  }.
  
define Maybe(ByteArray)
  flatten_one_field
  (
    Muscle_type         type_code,
    List(Muscle_object) m_o
  )=
  with result = flatten_items(type_code, m_o, constant_byte_array(0, 0)),
  if result is
  {
    failure             then failure
    success(flat_items) then
      if type_code is
      {
        b_any_t then  failure,
        
        b_bool_t then 
          success(host_to_lendian_Int32_ByteArray(length(m_o)) + flat_items )
          
        b_double_t then  
          success(host_to_lendian_Int32_ByteArray(length(m_o)<<3) + flat_items )
          
        b_float_t then  
          success(host_to_lendian_Int32_ByteArray(length(m_o)<<2) + flat_items )
        b_int64_t then  
          success(host_to_lendian_Int32_ByteArray(length(m_o)<<3) + flat_items )
        b_int32_t then  
          success(host_to_lendian_Int32_ByteArray(length(m_o)<<2) + flat_items )
        b_int16_t then
          success(host_to_lendian_Int32_ByteArray(length(m_o)<<1) + flat_items )    
        b_int8_t then  
          success(host_to_lendian_Int32_ByteArray(length(m_o)) + flat_items )
        b_message_t then
          success(host_to_lendian_Int32_ByteArray(length(flat_items)) + flat_items )
        b_pointer_t then  
          success(host_to_lendian_Int32_ByteArray(length(m_o)) + flat_items )
        b_point_t then
          success(host_to_lendian_Int32_ByteArray(length(m_o)<<3) + flat_items )   
        b_rect_t then  
          success(host_to_lendian_Int32_ByteArray(length(m_o)<<4) + flat_items )        
        b_string_t then  
          success(host_to_lendian_Int32_ByteArray(length(flat_items) + 4) + //size of all items
                  host_to_lendian_Int32_ByteArray(length(m_o)) +        //number of items
                  flat_items )
        b_custom_t(Int32 _0) then
          success(host_to_lendian_Int32_ByteArray(length(flat_items) + 4) + //size of all items
                  host_to_lendian_Int32_ByteArray(length(m_o)) +        //number of items
                  flat_items )
        b_raw_t then  
          success(host_to_lendian_Int32_ByteArray(length(flat_items) + 4) + //size of all items
                  host_to_lendian_Int32_ByteArray(length(m_o)) +        //number of items
                  flat_items )
      }
   }
  .
  
define Maybe(ByteArray)
  flatten_fields
  (
    List(Message_field) fields,
    ByteArray           so_far
  )=
  if fields is
  {
    [ ]       then success(so_far), //in reality, this is an empty bytearray, because there aren't any field
    [ h . t ] then
      //write size of name + 1 for NULL erminated string
      with flatten_header = host_to_lendian_Int32_ByteArray(length(h.name)+1) +
      //write the name + NULL
                            to_byte_array(h.name) + constant_byte_array(1,0) +
      //write the type_code of the field
                            host_to_lendian_Int32_ByteArray(get_Int32_type_code(h.type_code))
                            ,
                            
      if flatten_one_field(h.type_code , *h.items) is
      {
        failure               then  failure,
        success(flatten_body) then
        if t is 
        {
          []      then  success(so_far + flatten_header + flatten_body),
          [_ ._]  then  flatten_fields(t, so_far + flatten_header + flatten_body )
        }
      }
  }.  
    
  /**
   *  Converts the given Message into a flattened buffer of bytes (ByteArray) that can be saved to disk
   *  or sent over a network, and later converted back into an identical Message type.
   *  @param msg  The message to be flatten
   *  @return     failure if any error occur otherwise the ByteArray with the flattened message
   */
define Maybe(ByteArray)
  flatten_message
  (
    Message msg
  )=
  with message_header = 
    host_to_lendian_Int32_ByteArray(_CURRENT_PROTOCOL_VERSION) +
    host_to_lendian_Int32_ByteArray(*msg.what) +
    host_to_lendian_Int32_ByteArray(length(*msg.fields)),
    
    if flatten_fields(*msg.fields, to_byte_array("")) is
    {
      failure                   then  failure
      success(flattened_fields) then  success(message_header + flattened_fields)
    }.
   

   /* Format:  0. Protocol revision number (4 bytes, always set to CURRENT_PROTOCOL_VERSION) */
   /*          1. 'what' code (4 bytes)                                                      */
   /*          2. Number of entries (4 bytes)                                                */
   
   /*          3. Entry name length (4 bytes)                                                */
   /*          4. Entry name string (flattened String)                                       */
   /*          5. Entry type code (4 bytes)                                                  */
   /*          6. Entry data length (4 bytes)                                                */
   /*          7. Entry data (n bytes)                                                       */
   /*          8. loop to 3 as necessary                                                     */

define Maybe(Message)
  unflatten_message
  (
    Data_IO io
  )=
  if read_Int32(io) is
  {
    failure                   then failure,
    success(protocolVersion)  then
      if protocolVersion = _CURRENT_PROTOCOL_VERSION then
        //get the 'what' code 
        if read_Int32(io) is
        {
          failure             then failure,
          success(what_code)  then
           //print("what code = [" + to_ascii(what_code) + "] 0x"+ to_hexa(what_code) + " " + what_code + "\n");
           //get the number of entries at this level 
           if read_Int32(io)  is
           {
              failure             then failure,
              success(nb_entries) then
              //print("Nb Entries = " + nb_entries + "\n");
              //get all fields of this level
              if read_fields(io, nb_entries) is
              {
                failure         then failure,
                success(fields) then success(message(var(what_code), var(nb_entries), var(fields)))
              }
           }
        }
     else //This is not the same level version of message protocol
      failure
  }
  .


define Maybe(Message_field)
  find_field
  (
    List(Message_field) msg_fields,
    Muscle_type         search_type_code,
    String              search_name
  )=
  if msg_fields is
  {
    []        then failure,
    [ h . t ] then
      //test if the head of list contain the field with same name and type
      if search_type_code = b_any_t then //With ANY_TYPE we don't care about type_code
        if h.name = search_name then 
          success(h)
        else 
          find_field(t, search_type_code, search_name)
      else  //we search for exact type and name
        if (h.name = search_name) & (h.type_code = search_type_code) then 
          success(h)
        else 
          find_field(t, search_type_code, search_name)      
  }.
 
define Maybe(Muscle_object)
  find_data
  (
    List(Message_field) fields,
    Muscle_type         type_code,
    String              name,
    Int32               index
  )=
  if find_field(fields, type_code, name) is
  {
    failure         then  
      failure, //we don't find any fields matching with query
    success(field)  then 
      nth(index, *field.items) 
  }.
    
  
define Maybe(Muscle_object)
  find_data
  (
    Muscle_type  type_code,
    Message     msg,
    String      name,
    Int32       index
  )=
  find_data(*msg.fields, type_code, name, index).
  
/********************** Add collection ********************/

  /** @fn add_data
   *  Generic method, capable of adding any type of data to the Message.
   *  @param message     The message where the data to be add
   *  @param field_name  Name of the field to add (or add to)
   *  @param type_code   The _B_*_TYPE code indicating the type of data that will be added.
   *  @param m_object    Muscle_object that contain the bytes of data to add.  The data is copied out
   *                     and exactly how it is interpreted depends on (type).
   *  @return success(One) on success, failure
   */

define Maybe(One)
  add_data
  (
    Message       msg,
    String        field_name,
    Muscle_type   type_code,
    Muscle_object m_object
  )=
  if find_field(*msg.fields, type_code, field_name) is
  {
    failure then  //we can't find a list of fields, then we create it
      with new_field = message_field(field_name, type_code, var([m_object])),
        msg.fields <- [ new_field . *msg.fields]; 
        success(unique),
      success(items_list) then
        items_list.items <- [ m_object . *items_list.items];
        success(unique)
  }.
  
  /** Adds a new string to the Message.
   *  @param name Name of the field to add (or add to)
   *  @param value The string to add
   *  @return success(One) on success, failure
   */
public define Maybe(One)
  add_string
  (
    Message msg,
    String  name,
    String  value
  )=
  add_data(msg, name, b_string_t, b_string(value)).

  /** Adds a new Word8 to the Message.
   *  @param name Name of the field to add (or add to)
   *  @param value The Word8 to add
   *  @return success(One) on success, failure
   */
public define Maybe(One)
  add_int8
  (
    Message msg,
    String  name,
    Word8  value
  )=
  add_data(msg, name, b_int8_t, b_int8(value)).

  /** Adds a new Int16 to the Message.
   *  @param name Name of the field to add (or add to)
   *  @param value The Int16 to add
   *  @return success(One) on success, failure
   */
public define Maybe(One)
  add_int16
  (
    Message msg,
    String  name,
    Int16  value
  )=
  add_data(msg, name, b_int16_t, b_int16(value)).

  /** Adds a new Int32 to the Message.
   *  @param name Name of the field to add (or add to)
   *  @param value The Int32 to add
   *  @return success(One) on success, failure
   */
public define Maybe(One)
  add_int32
  (
    Message msg,
    String  name,
    Int32   value
  )=
  add_data(msg, name, b_int32_t, b_int32(value)).

  /** Adds a new string to the Message.
   *  @param name Name of the field to add (or add to)
   *  @param value The string to add
   *  @return success(One) on success, failure
   */
public define Maybe(One)
  add_int64
  (
    Message msg,
    String  name,
    Int64   value
  )=
  add_data(msg, name, b_int64_t, b_int64(value)).

  /** Adds a new Bool to the Message.
   *  @param name Name of the field to add (or add to)
   *  @param value The Bool to add
   *  @return success(One) on success, failure
   */
public define Maybe(One)
  add_bool
  (
    Message msg,
    String  name,
    Bool  value
  )=
  add_data(msg, name, b_bool_t, b_bool(value)).
  
  /** Adds a new Float (Float32) to the Message.
   *  @param name Name of the field to add (or add to)
   *  @param value The Float (Float32) to add
   *  @return success(One) on success, failure
   */
public define Maybe(One)
  add_float
  (
    Message msg,
    String  name,
    Float32 value
  )=
  add_data(msg, name, b_float_t, b_float(value)).

  /** Adds a new Double (Float64) to the Message.
   *  @param name Name of the field to add (or add to)
   *  @param value The Double (Float 64) to add
   *  @return success(One) on success, failure
   */
public define Maybe(One)
  add_double
  (
    Message msg,
    String  name,
    Float   value
  )=
  add_data(msg, name, b_double_t, b_double(value)).

  /** Adds a new Message to the Message.
   *  @param name Name of the field to add (or add to)
   *  @param value The Message to add
   *  @return success(One) on success, failure
   */
public define Maybe(One)
  add_message
  (
    Message msg,
    String  name,
    Message value
  )=
  add_data(msg, name, b_message_t, b_message(value)).

  /** Adds a new B_Point to the Message.
   *  @param name Name of the field to add (or add to)
   *  @param value The B_Point to add
   *  @return success(One) on success, failure
   */
public define Maybe(One)
  add_point
  (
    Message msg,
    String  name,
    B_Point value
  )=
  add_data(msg, name, b_point_t, b_point(value)).

  /** Adds a new B_Rect to the Message.
   *  @param name Name of the field to add (or add to)
   *  @param value The B_Rect to add
   *  @return success(One) on success, failure
   */
public define Maybe(One)
  add_rect
  (
    Message msg,
    String  name,
    B_Rect  value
  )=
  add_data(msg, name, b_rect_t, b_rect(value)).

  /** Adds a new ByteArray to the Message.
   *  @param name     Name of the field to add (or add to)
   *  @param content  The bytes array to add
   *  @return success(One) on success, failure
   */
public define Maybe(One)
  add_raw
  (
    Message   msg,
    String    name,
    ByteArray content
  )=
  add_data(msg, name, b_raw_t, b_raw(content)).


/********************** Find collection ********************/

  /** Retrieve a String value from the Message.
   * @param msg Message where we search the String
   * @param name The field name to look for the string value under.
   * @param index The index of the String item in its field entry.
   * @return 'success(String)' if the String value was found, or 'failure' if it wasn't.
   */
public define Maybe(String)
  find_string
  (
    Message msg,
    String  name,
    Int32   index
  )=
  if find_data(b_string_t, msg, name, index) is success(mo) then
    if mo is b_string(value) then
      success(value)
    else
      failure
  else
    failure.

   /** As above, only (index) isn't specified.  It is assumed to be zero. */
public define Maybe(String)
  find_string
  (
    Message msg,
    String  name
  )= find_string(msg, name, 0).
  
  /** Retrieve an Word8 value from the Message.
   *  @param msg Message where we search the Word8
   *  @param name The field name to look for the int8 value under.
   *  @param index The index of the Word8 item in its field entry.
   *  @return 'success(Word8)' if the Word8 value was found, or 'failure' if it wasn't.
   */
public define Maybe(Word8)
  find_int8
  (
    Message msg,
    String  name,
    Int32   index
  )=
  if find_data(b_int8_t, msg, name, index) is success(mo) then
    if mo is b_int8(value) then
      success(value)
    else
      failure
  else
    failure.
    
   /** As above, only (index) isn't specified.  It is assumed to be zero. */
public define Maybe(Word8)
  find_int8
  (
    Message msg,
    String  name
  )= find_int8(msg, name, 0).

  /** Retrieve an Int16 value from the Message.
   *  @param msg Message where we search the Int16
   *  @param name The field name to look for the Int16 value under.
   *  @param index The index of the Int16 item in its field entry.
   *  @return 'success(Int16)' if the Int16 value was found, or 'failure' if it wasn't.
   */
public define Maybe(Int16)
  find_int16
  (
    Message msg,
    String  name,
    Int32   index
  )=
  if find_data(b_int16_t, msg, name, index) is success(mo) then
    if mo is b_int16(value) then
      success(value)
    else
      failure
  else
    failure.
    
   /** As above, only (index) isn't specified.  It is assumed to be zero. */
public define Maybe(Int16)
  find_int16
  (
    Message msg,
    String  name
  )= find_int16(msg, name, 0).

  /** Retrieve an Int32 value from the Message.
   *  @param msg Message where we search the Int32
   *  @param name The field name to look for the Int32 value under.
   *  @param index The index of the Int32 item in its field entry.
   *  @return 'success(Int32)' if the Int32 value was found, or 'failure' if it wasn't.
   */
public define Maybe(Int32)
  find_int32
  (
    Message msg,
    String  name,
    Int32   index
  )=
  if find_data(b_int32_t, msg, name, index) is success(mo) then
    if mo is b_int32(value) then
      success(value)
    else
      failure
  else
    failure.
    
   /** As above, only (index) isn't specified.  It is assumed to be zero. */
public define Maybe(Int32)
  find_int32
  (
    Message msg,
    String  name
  )= find_int32(msg, name, 0).

  /** Retrieve an Int64 value from the Message.
   *  @param msg Message where we search the Int64
   *  @param name The field name to look for the Int64 value under.
   *  @param index The index of the Int64 item in its field entry.
   *  @return 'success(Int64)' if the Int64 value was found, or 'failure' if it wasn't.
   */
public define Maybe(Int64)
  find_int64
  (
    Message msg,
    String  name,
    Int32   index
  )=
  if find_data(b_int64_t, msg, name, index) is success(mo) then
    if mo is b_int64(value) then
      success(value)
    else
      failure
  else
    failure.
    
   /** As above, only (index) isn't specified.  It is assumed to be zero. */
public define Maybe(Int64)
  find_int64
  (
    Message msg,
    String  name
  )= find_int64(msg, name, 0).

  /** Retrieve an Bool value from the Message.
   *  @param msg Message where we search the Bool
   *  @param name The field name to look for the Bool value under.
   *  @param index The index of the Bool item in its field entry.
   *  @return 'success(Bool)' if the Bool value was found, or 'failure' if it wasn't.
   */
public define Maybe(Bool)
  find_bool
  (
    Message msg,
    String  name,
    Int32   index
  )=
  if find_data(b_bool_t, msg, name, index) is success(mo) then
    if mo is b_bool(value) then
      success(value)
    else
      failure
  else
    failure.

   /** As above, only (index) isn't specified.  It is assumed to be zero. */
public define Maybe(Bool)
  find_bool
  (
    Message msg,
    String  name
  )= find_bool(msg, name, 0).

  /** Retrieve an Float32 value from the Message.
   *  @param msg Message where we search the string
   *  @param name The field name to look for the Float32 value under.
   *  @param index The index of the Float32 item in its field entry.
   *  @return 'success(Float32)' if the Float32 value was found, or 'failure' if it wasn't.
   */
public define Maybe(Float32)
  find_float32
  (
    Message msg,
    String  name,
    Int32   index
  )=
  if find_data(b_float_t, msg, name, index) is success(mo) then
    if mo is b_float(value) then
      success(value)
    else
      failure
  else
    failure.

   /** As above, only (index) isn't specified.  It is assumed to be zero. */
public define Maybe(Float32)
  find_float32
  (
    Message msg,
    String  name
  )= find_float32(msg, name, 0).

  /** Retrieve an Float64 value from the Message.
   *  @param msg Message where we search the string
   *  @param name The field name to look for the Float64 value under.
   *  @param index The index of the Float64 item in its field entry.
   *  @return 'success(Float64)' if the Float64 value was found, or 'failure' if it wasn't.
   */
public define Maybe(Float)
  find_float64
  (
    Message msg,
    String  name,
    Int32   index
  )=
  if find_data(b_double_t, msg, name, index) is success(mo) then
    if mo is b_double(value) then
      success(value)
    else
      failure
  else
    failure.

   /** As above, only (index) isn't specified.  It is assumed to be zero. */
public define Maybe(Float)
  find_float64
  (
    Message msg,
    String  name
  )= find_float64(msg, name, 0).
  
  /** Retrieve a Message from the Message.
   *  @param msg Message where we search the Message
   *  @param name The field name to look for the Message under.
   *  @param index The index of the Message item in its field entry.
   *  @return 'success(Message)' if the Message was found, or 'failure' if it wasn't.
   */
public define Maybe(Message)
  find_message
  (
    Message msg,
    String  name,
    Int32   index
  )=
  if find_data(b_message_t, msg, name, index) is success(mo) then
    if mo is b_message(value) then
      success(value)
    else
      failure
  else
    failure.

   /** As above, only (index) isn't specified.  It is assumed to be zero. */
public define Maybe(Message)
  find_message
  (
    Message msg,
    String  name
  )= find_message(msg, name, 0).

  /** Retrieve a B_Point from the Message.
   *  @param msg Message where we search the Message
   *  @param name The field name to look for the B_Point under.
   *  @param index The index of the B_Point item in its field entry.
   *  @return 'success(Message)' if the B_Point was found, or 'failure' if it wasn't.
   */
public define Maybe(B_Point)
  find_point
  (
    Message msg,
    String  name,
    Int32   index
  )=
  if find_data(b_point_t, msg, name, index) is success(mo) then
    if mo is b_point(value) then
      success(value)
    else
      failure
  else
    failure.

   /** As above, only (index) isn't specified.  It is assumed to be zero. */
public define Maybe(B_Point)
  find_point
  (
    Message msg,
    String  name
  )= find_point(msg, name, 0).
  
  /** Retrieve a B_Rect from the Message.
   *  @param msg Message where we search the Message
   *  @param name The field name to look for the B_Rect under.
   *  @param index The index of the B_Rect item in its field entry.
   *  @return 'success(Message)' if the B_Rect was found, or 'failure' if it wasn't.
   */
   
public define Maybe(B_Rect)
  find_rect
  (
    Message msg,
    String  name,
    Int32   index
  )=
  if find_data(b_rect_t, msg, name, index) is success(mo) then
    if mo is b_rect(value) then
      success(value)
    else
      failure
  else
    failure.

   /** As above, only (index) isn't specified.  It is assumed to be zero. */
public define Maybe(B_Rect)
  find_rect
  (
    Message msg,
    String  name
  )= find_rect(msg, name, 0).

  /** Retrieve a Raw (ByteArray) from the Message.
   *  @param msg Message where we search the Message
   *  @param name The field name to look for the Raw under.
   *  @param index The index of the Raw item in its field entry.
   *  @return 'success(Message)' if the B_Rect was found, or 'failure' if it wasn't.
   */
   
public define Maybe(ByteArray)
  find_raw
  (
    Message msg,
    String  name,
    Int32   index
  )=
  if find_data(b_raw_t, msg, name, index) is success(mo) then
    if mo is b_raw(value) then
      success(value)
    else
      failure
  else
    failure.

   /** As above, only (index) isn't specified.  It is assumed to be zero. */
public define Maybe(ByteArray)
  find_raw
  (
    Message msg,
    String  name
  )= find_raw(msg, name, 0).

/********************** I/O socket *****************************/

  /**
   * create the right udp socket. determine if we must create broadcast
   * or not udp socket
   */
   
define Create_UDP_Client_Socket_Result
  create_udp_socket
  (
    Int32  ip,
  )=
  if ip = ip_address((255,255,255,255)) then
    create_udp_client_broadcast_socket
  else
    create_udp_client_socket
  .
  

public define Message_Send_Result
  send_message_by_udp
  (
    Message      msg,
    Int32        ip_address,  // where you want to send the data
    Int32        ip_port, 
  )=
  if flatten_message(msg) is
  {
      failure  then print("Error flattening identity Message"); flatten_error,
      success(buffer) then
        if create_udp_socket(ip_address) is
        {
          cannot_create_the_socket then network_error,
          ok(socket)               then
            //the necessary UDP socket was created, hence we send the Message packet
            with header = host_to_lendian_Int32_ByteArray(length(buffer)) + 
                          host_to_lendian_Int32_ByteArray(_MUSCLE_MESSAGE_ENCODING_DEFAULT) +
                          buffer,
            //send the header + buffer. that header is construct as follow (size of the following message + header mark)
            if udp_send(socket, ip_address, ip_port, header) is
            {
              network_unreachable then network_error,
              packet_sent         then ok
            }
        }
    }.

public define Maybe(Message)
  receive_message_from_io
  (
    Data_IO io
  ) =
    if read_Int32(io) is
    {
      failure                   then print("Can't read data \n"); failure,
      success(data_len)  then
        if read_Int32(io) is
        {
          failure                   then print("Can't read data \n"); failure,
          success(encoding)  then
            if encoding = _MUSCLE_MESSAGE_ENCODING_DEFAULT then
              unflatten_message(io)
            else print("Bad header or unknown encoding:" + encoding); failure
        }
    }.
  
  
public define Maybe(Int32)
  send_buffer
  (
    RWStream  conn,
    ByteArray buffer,
    Int32     left_to_send,
    Int32     so_far
  )=
  if left_to_send = 0 then
    success(so_far)
  else
    if write(weaken(conn), buffer) is
    {
      failure     then failure,
      success(len)then 
      if left_to_send = len then
        success(so_far+len)
      else
        send_buffer(conn, extract(buffer, len, length(buffer)), left_to_send - len, so_far+len)
    }
  .
  
public define Message_Send_Result
  send_message_by_Stream
  (
    RWStream  conn,
    Message   msg
  )=
  if flatten_message(msg) is
  {
    failure          then println("Error flattening identity Message"); flatten_error,
    success(buffer) then 
    with header = host_to_lendian_Int32_ByteArray(length(buffer)) + 
                  host_to_lendian_Int32_ByteArray(_MUSCLE_MESSAGE_ENCODING_DEFAULT),
    //send the header. that header is construct as follow (size of the following message + header mark)
    if send_buffer(conn,header, length(header), 0) is
    {
      failure    then network_error,
      success(_) then 
      //now we send the real message
      if send_buffer(conn, buffer, length(buffer), 0) is
      {
        failure     then network_error,
        success(len)then ok
      }
    }
  }.
  



 global define One
  muscle_file
  (
    List(String)  args
  ) =
  if (Maybe(RStream))file("c:/muscle/python/test_multi_msg.msg", read) is
  {
     failure          then print("Open file Error\n"),
     success(source)  then 
      if unflatten_message(make_data_io(source)) is
      {
        failure           then print("File Message ERROR \n"),
        success(message)  then 
          print("File Message decoded\n");
          print_to_stream(message);/*
          if find_message(message, "message") is
          {
            failure               then print("Can't find message \"message\" \n"),
            success(sub_message)  then
              forget(add_string(sub_message, "toto", "tata"));
              if find_string(sub_message, "toto") is
              {
                failure             then print("can't find string \"string\" \n"),
                success(the_string) then print("the string found is [" + the_string + "] \n")
                              
              }
          };*/
          if flatten_message(message) is
          {
            failure         then print("Can't flatten message\n"),
            success(ba_msg) then 
            //now write the result into file
            if file("c:/muscle/python/Anubis.test_multi_msg.msg", new) is
            {
              failure     then print("Can't open file \n"),
              success(fd) then forget(write(weaken(fd), ba_msg))
            }
            
          }
      }
  }
  .