// CORBA IDL

module demo
{
   module grid 
   { 
      interface MyServer
      {
         typedef fixed<5,2> fixedT;
      }
   }
}

e.g.
fixedTHelper
fixedTHolder

// J# 

package demo.grid.MyServerPackage;

/** 
 * Helper class for : fixedT
 *  
 * @author TomORB J# Native Compiler
 */ 
public class fixedTHelper
{
   /**
    * Insert fixedT into an any
    * @param a an any
    * @param t fixedT value
    */
   public static void insert(org.omg.CORBA.Any a, java.math.BigDecimal t)
   {
      a.insert_Streamable(new demo.grid.MyServerPackage.fixedTHolder(t));
   }

   /**
    * Extract fixedT from an any
    * @param a an any
    * @return the extracted fixedT value
    */
   public static java.math.BigDecimal extract(org.omg.CORBA.Any a)
   {
      if (!a.type().equal(type()))
         throw new org.omg.CORBA.MARSHAL();
      return read(a.create_input_stream());
   }

   //
   // Internal TypeCode value
   //
   private static org.omg.CORBA.TypeCode _tc = null;

   /**
    * Return the fixedT TypeCode
    * @return a TypeCode
    */
   public static org.omg.CORBA.TypeCode type()
   {
      if (_tc == null) {
         org.omg.CORBA.ORB orb = org.omg.CORBA.ORB.init();
         _tc = orb.create_alias_tc(id(),"fixedT",orb.create_fixed_tc((short)5,(short)2));
      }
      return _tc;
   }

   /**
    * Return the fixedT IDL ID
    * @return an ID
    */
   public static java.lang.String id()
   {
      return _id;
   }

   private final static java.lang.String _id = "IDL:demo/grid/MyServer/fixedT:1.0";

   /**
    * Read fixedT from a marshalled stream
    * @param istream the input stream
    * @return the readed fixedT value
    */
   public static java.math.BigDecimal read(org.omg.CORBA.portable.InputStream istream)
   {
      java.math.BigDecimal _f = istream.read_fixed();
      return _f.movePointLeft(2);
   }

   /**
    * Write fixedT into a marshalled stream
    * @param ostream the output stream
    * @param value fixedT value
    */
   public static void write(org.omg.CORBA.portable.OutputStream ostream, java.math.BigDecimal value)
   {
      if (value.scale() != 2)
         throw new org.omg.CORBA.DATA_CONVERSION();
      ostream.write_fixed(value);
   }
}

package demo.grid.MyServerPackage;

/**
 * Holder class for : fixedT
 * 
 * @author TomORB J# Native Compiler
 */
final public class fixedTHolder
		implements org.omg.CORBA.portable.Streamable
{
   /**
    * Internal fixedT value
    */
   public java.math.BigDecimal value;

   /**
    * Default constructor
    */
   public fixedTHolder()
   { }

   /**
    * Constructor with value initialisation
    * @param initial the initial value
    */
   public fixedTHolder(java.math.BigDecimal initial)
   {
      value = initial;
   }

   /**
    * Read fixedT from a marshalled stream
    * @param istream the input stream
    */
   public void _read(org.omg.CORBA.portable.InputStream istream)
   {
      value = fixedTHelper.read(istream);
   }

   /**
    * Write fixedT into a marshalled stream
    * @param ostream the output stream
    */
   public void _write(org.omg.CORBA.portable.OutputStream ostream)
   {
      fixedTHelper.write(ostream,value);
   }

   /**
    * Return the fixedT TypeCode
    * @return a TypeCode
    */
   public org.omg.CORBA.TypeCode _type()
   {
      return fixedTHelper.type();
   }

}