Registry{
  (@
    private Hashtable typeMap;
    private Hashtable entityMap;
    private Hashtable categoryTypeMap;
    private Hashtable categoryMap;
  @)
  init (@
    typeMap = new Hashtable();
    set_types(new TypeList());
    entityMap = new Hashtable();
    set_entities(new EntityList());
    categoryTypeMap = new Hashtable();
    categoryMap = new Hashtable();
    set_categories(new CategoryList());
  @)
  (@
    DefinedType get_type(TypeName name) throws ParseException
    {
      String key = name.get_value();
      DefinedType type = (DefinedType)(typeMap.get(key));
      if( type == null)
        throw new ParseException("Undefined Type: "+key);
      return type;
    }
    private void put_type(DefinedType type) throws ParseException
    {
      String key = type.get_name().get_value();
      if( typeMap.contains(key))
        throw new ParseException("Duplicate Type "+key);
      typeMap.put(key,type);
    }
    private Entity get_entity(EntityName name) throws ParseException
    {
      Entity entity = (Entity)(entityMap.get(name.get_value()));
      if( entity == null)
        throw new ParseException("Undefined Entity: "+name);
      return entity;
    }
    private void put_entity(Entity entity) throws ParseException {
      String key = entity.get_name().get_value();
      if( entityMap.contains(key))
        throw new ParseException("Duplicate Entity: "+key);
      entityMap.put(key,entity);
    }
    private CodeCategoryType get_categoryType(String name)
      throws ParseException
    {
      CodeCategoryType ctype =
        (CodeCategoryType)(categoryTypeMap.get(name));
      if( ctype == null)
        throw new ParseException("Undefined Code Category Type: "+name);
      return ctype;
    }
    private void put_categoryType(CodeCategoryType ctype) 
      throws ParseException
    {
      String key = ctype.get_name();
      if( categoryTypeMap.contains(key))
        throw new ParseException("Duplicate Code Category Type "+key);
      categoryTypeMap.put(key,ctype);
    }
    CodeCategory get_category(String name) throws ParseException
    {
      CodeCategory category =
        (CodeCategory)(categoryMap.get(name));
      if( category == null)
        throw new ParseException("Undefined Code Category: "+name);
      return category;
    }
    private void put_category(CodeCategory category)
      throws ParseException
    {
      String key = category.get_tag();
      if( categoryMap.contains(key))
        throw new ParseException("Duplicate Code Category:"+key);
      categoryMap.put(key,category);
    }
    void add(DefinedType type) throws ParseException {
      put_type(type);
      get_types().add(type);
    }
    void createEntity(EntityName name) throws ParseException {
      Entity entity = new Entity();
      entity.set_name(name);
      put_entity(entity);
      get_entities().add(entity);    
    }
    void setEntityKeys(EntityName name, AccessKeyList keys)
      throws ParseException
    {
      Entity entity = get_entity(name);
      entity.set_keys(keys);
    }
    void addEntityParent(EntityName name, EntityName parentName)
      throws ParseException
    {
      Entity entity = get_entity(name);
      Entity parent = get_entity(parentName);
      if( parent == entity)
        throw new ParseException("Self Inheritence: "+name);
      entity.add(new ParentEntity(parent));
    }
    void addEntityMethod(EntityName name, Method method)
      throws ParseException
    {
      Entity entity = get_entity(name);
      entity.add(method);
    }
  void createCategoryType
    (String name, String header, String impl, String make)
    throws ParseException
  {
    CodeCategoryType ctype =
      new CodeCategoryType(
        name,
        new HeaderTemplate(header),
        new ImplTemplate(impl),
        new MakeTemplate(make));
    put_categoryType(ctype);
  }
  void createNonGeneratedCategory(
    String name,
    String macroBaseName,
    String classNamePattern,
    String headerFilePattern)
    throws ParseException
  {
    NonGeneratedCodeCategory category =
      new NonGeneratedCodeCategory(
         name,macroBaseName,classNamePattern,headerFilePattern);
    put_category(category);
    get_categories().add(category);
  }
  void createGeneratedCategory(
    String name,
    String macroBaseName,
    String classNamePattern,
    String headerFilePattern,
    String implFilePattern,
    String type_name,
    AccessKeyList keys)
    throws ParseException
  {
    CodeCategoryType ctype = get_categoryType(type_name);
    if( ctype == null)
      throw new ParseException("Undefined Code Category: "+type_name);

    GeneratedCodeCategory category =
      new GeneratedCodeCategory(
         name,macroBaseName,classNamePattern,headerFilePattern,
         implFilePattern,ctype,keys);
    put_category(category);
    get_categories().add(category);
  }
  @)
}
TypeList {
  init (@
    set_value(new DefinedType_List(null));
  @)
  void add(DefinedType type) (@
    get_value().addElement(type);
  @)
}
MethodList {
  init (@
    set_value(new Method_List(null));
  @)
  void add(Method method) (@
    get_value().addElement(method);
  @)
}
EntityList {
  init (@
    set_value(new Entity_List(null));
  @)
  void add(Entity entity) (@
    get_value().addElement(entity);
  @)
}
DefinedType {
  init (@
    name = null;
    header = null;
  @)
}
AccessKeyList {
  (@ Hashtable memberMap; @)
  init (@
    memberMap = new Hashtable();
    set_accesskey_list(new AccessKey_List(null));
  @)
  boolean contains(AccessKey key) (@
    return memberMap.containsKey(key.get_tag());
  @)
  void add(AccessKey key) (@
    if( ! contains(key)){
      memberMap.put(key.get_tag(),key);
      get_accesskey_list().addElement(key);
    }
  @)
}
Entity {
  init (@
    set_name(null);
    set_parents(new ParentEntity_List(null));
    set_methods(new MethodList());
    set_keys(new AccessKeyList());
  @)
  void add(Method method) (@
    get_methods().add(method);
  @)
  void add(ParentEntity parent) (@
    get_parents().addElement(parent);
  @)
}
Method {
  init (@
    set_name(null);
    set_bodyVersion(null);
    set_isStatic(false);
    set_isConst(false);
    set_isVirtual(false);
    set_keys(new AccessKeyList());
    set_returnDecl(null);
    set_args(new ArgDeclList());
  @)
  void add(ArgumentDecl decl) (@
    get_args().append(decl);
  @)
}
TypeDecl {
  init (@
    set_prefix("");
    set_suffix("");
    set_isRef(false);
    set_type(null);
    set_tmplType(new TypeUseList());
    set_arrayDim(new ConstantList());
  @)
  void append_prefix(String text) (@
    set_prefix(get_prefix()+text);
  @)
  void append_suffix(String text) (@
    set_suffix(get_suffix()+text);
  @)
  void add_tmplType(TypeUse use) (@
    get_tmplType().add(use);
  @)
  void add_arrayDim(Constant dim) (@
    get_arrayDim().add(dim);
  @)
}
ArgumentDecl {
  init (@
    set_name(null);
    set_initializer(null);
  @)
}
EntityName {
  public String toString() (@
    return get_value();
  @)
}
CategoryList{
  init (@
    set_value(new CodeCategory_List());
  @)
  void add(CodeCategory category) (@
    get_value().addElement(category);
  @)
}
TypeUseList {
  init (@
    set_value(new TypeUse_List(null));
  @)
  void add(TypeUse elem) (@
    get_value().addElement(elem);
  @)
}
ConstantList {
  init (@
    set_value(new Constant_List(null));
  @)
  void add(Constant elem) (@
    get_value().addElement(elem);
  @)
}
ArgDeclList {
  (@
    private Vector args; // preserves ordering of declarations
  @)
  init (@
    args = new Vector();
    set_value(new ArgumentDecl_List(null));
  @)
  void append(ArgumentDecl decl)(@
     args.addElement(decl);
     get_value().addElement(decl);
  @)
  int size()(@
    return args.size();
  @)
  ArgumentDecl elementAt(int index)(@
    return (ArgumentDecl)(args.elementAt(index));
  @)
}