Coverage Report

 // Do not edit this file!  It was generated by Melati POEM's DSD preprocessor.
 
 package org.melati.poem.generated;
 
 
 import org.melati.poem.AccessPoemException;
 import org.melati.poem.Column;
 import org.melati.poem.Database;
 import org.melati.poem.DefinitionSource;
 import org.melati.poem.DisplayLevel;
 import org.melati.poem.Field;
 import org.melati.poem.Group;
 import org.melati.poem.GroupMembership;
 import org.melati.poem.JdbcPersistent;
 import org.melati.poem.Persistent;
 import org.melati.poem.PoemDatabaseTables;
 import org.melati.poem.PoemException;
 import org.melati.poem.PoemTable;
 import org.melati.poem.ReferencePoemType;
 import org.melati.poem.Searchability;
 import org.melati.poem.StandardIntegrityFix;
 import org.melati.poem.TroidPoemType;
 import org.melati.poem.User;
 import org.melati.poem.ValidationPoemException;
 
 
 /**
  * Melati POEM generated base class for <code>Table</code> <code>groupMembership</code>.
  *
  * See org.melati.poem.prepro.TableDef#generateTableBaseJava 
  */
 
 public class GroupMembershipTableBase<T extends GroupMembership> extends PoemTable<T> {
 
   private Column<Integer> col_id = null;
   private Column<Integer> col_user = null;
   private Column<Integer> col_group = null;
 
  /**
   * Constructor. 
   * 
   * See org.melati.poem.prepro.TableDef#generateTableBaseJava 
   * @param database          the POEM database we are using
   * @param name              the name of this <code>Table</code>
   * @param definitionSource  which definition is being used
   * @throws PoemException    if anything goes wrong
   */
 
   public GroupMembershipTableBase(
       Database database, String name,
       DefinitionSource definitionSource) throws PoemException {
     super(database, name, definitionSource);
   }
 
 
  /**
   * Get the database tables.
   *
   * See org.melati.poem.prepro.TableDef#generateTableBaseJava 
   * @return the database tables
   */
   public PoemDatabaseTables getPoemDatabaseTables() {
     return (PoemDatabaseTables)getDatabase();
   }
 
 
  /**
   * Initialise this table by defining its columns.
   *
   * See org.melati.poem.prepro.TableDef#generateTableBaseJava 
   */
   public void init() throws PoemException {
     super.init();
     defineColumn(col_id =
         new Column<Integer>(this, "id",
                    new TroidPoemType(),
                    DefinitionSource.dsd) { 
           public Object getCooked(Persistent g)
               throws AccessPoemException, PoemException {
             return ((GroupMembership)g).getId();
           }
 
           public void setCooked(Persistent g, Object cooked)
               throws AccessPoemException, ValidationPoemException {
             ((GroupMembership)g).setId((Integer)cooked);
           }
 
           public Field<Integer> asField(Persistent g) {
             return ((GroupMembership)g).getIdField();
           }
 
           public boolean defaultUserEditable() {
             return false;
           }
 
           public boolean defaultUserCreateable() {
             return false;
           }
 
           public DisplayLevel defaultDisplayLevel() {
             return DisplayLevel.detail;
           }
 
           public int defaultDisplayOrder() {
             return 0;
           }
 
           public String defaultDescription() {
             return "The Table Row Object ID";
           }
 
           public Object getRaw_unsafe(Persistent g)
               throws AccessPoemException {
             return ((GroupMembership)g).getId_unsafe();
           }
 
           public void setRaw_unsafe(Persistent g, Object raw)
               throws AccessPoemException {
             ((GroupMembership)g).setId_unsafe((Integer)raw);
           }
 
           public Object getRaw(Persistent g)
               throws AccessPoemException {
             return ((GroupMembership)g).getId();
           }
 
           public void setRaw(Persistent g, Object raw)
               throws AccessPoemException {
             ((GroupMembership)g).setId((Integer)raw);
           }
         });
 
     defineColumn(col_user =
         new Column<Integer>(this, "user",
                    new ReferencePoemType(getPoemDatabaseTables().
                                              getUserTable(), false),
                    DefinitionSource.dsd) { 
           public Object getCooked(Persistent g)
               throws AccessPoemException, PoemException {
             return ((GroupMembership)g).getUser();
           }
 
           public void setCooked(Persistent g, Object cooked)
               throws AccessPoemException, ValidationPoemException {
             ((GroupMembership)g).setUser((User)cooked);
           }
 
           public Field<Integer> asField(Persistent g) {
             return ((GroupMembership)g).getUserField();
           }
 
           public Searchability defaultSearchability() {
             return Searchability.yes;
           }
 
           public Integer defaultDisplayOrderPriority() {
             return new Integer(0);
           }
 
           public String defaultDisplayName() {
             return "User";
           }
 
           public int defaultDisplayOrder() {
             return 1;
           }
 
           public String defaultDescription() {
             return "The user who belongs to the group";
           }
 
           public boolean defaultIndexed() {
             return true;
           }
 
           public String defaultRenderinfo() {
             return "SelectionWindow";
           }
 
           public Object getRaw_unsafe(Persistent g)
               throws AccessPoemException {
             return ((GroupMembership)g).getUser_unsafe();
           }
 
           public void setRaw_unsafe(Persistent g, Object raw)
               throws AccessPoemException {
             ((GroupMembership)g).setUser_unsafe((Integer)raw);
           }
 
           public Object getRaw(Persistent g)
               throws AccessPoemException {
             return ((GroupMembership)g).getUserTroid();
           }
 
           public void setRaw(Persistent g, Object raw)
               throws AccessPoemException {
             ((GroupMembership)g).setUserTroid((Integer)raw);
           }
 
           public StandardIntegrityFix defaultIntegrityFix() {
             return StandardIntegrityFix.delete;
           }
         });
 
     defineColumn(col_group =
         new Column<Integer>(this, "group",
                    new ReferencePoemType(getPoemDatabaseTables().
                                              getGroupTable(), false),
                    DefinitionSource.dsd) { 
           public Object getCooked(Persistent g)
               throws AccessPoemException, PoemException {
             return ((GroupMembership)g).getGroup();
           }
 
           public void setCooked(Persistent g, Object cooked)
               throws AccessPoemException, ValidationPoemException {
             ((GroupMembership)g).setGroup((Group)cooked);
           }
 
           public Field<Integer> asField(Persistent g) {
             return ((GroupMembership)g).getGroupField();
           }
 
           public Searchability defaultSearchability() {
             return Searchability.primary;
           }
 
           public Integer defaultDisplayOrderPriority() {
             return new Integer(1);
           }
 
           public String defaultDisplayName() {
             return "Group";
           }
 
           public int defaultDisplayOrder() {
             return 2;
           }
 
           public String defaultDescription() {
             return "The group to which the user belongs";
           }
 
           public Object getRaw_unsafe(Persistent g)
               throws AccessPoemException {
             return ((GroupMembership)g).getGroup_unsafe();
           }
 
           public void setRaw_unsafe(Persistent g, Object raw)
               throws AccessPoemException {
             ((GroupMembership)g).setGroup_unsafe((Integer)raw);
           }
 
           public Object getRaw(Persistent g)
               throws AccessPoemException {
             return ((GroupMembership)g).getGroupTroid();
           }
 
           public void setRaw(Persistent g, Object raw)
               throws AccessPoemException {
             ((GroupMembership)g).setGroupTroid((Integer)raw);
           }
         });
   }
 
 
  /**
   * Retrieves the <code>Id</code> <code>Column</code> for this 
   * <code>groupMembership</code> <code>Table</code>.
   * 
   * see org.melati.poem.prepro.FieldDef#generateColAccessor 
   * @return the id <code>Column</code>
   */
   public final Column<Integer> getIdColumn() {
     return col_id;
   }
 
 
  /**
   * Retrieves the <code>User</code> <code>Column</code> for this 
   * <code>groupMembership</code> <code>Table</code>.
   * 
   * see org.melati.poem.prepro.FieldDef#generateColAccessor 
   * @return the user <code>Column</code>
   */
   public final Column<Integer> getUserColumn() {
     return col_user;
   }
 
 
  /**
   * Retrieves the <code>Group</code> <code>Column</code> for this 
   * <code>groupMembership</code> <code>Table</code>.
   * 
   * see org.melati.poem.prepro.FieldDef#generateColAccessor 
   * @return the group <code>Column</code>
   */
   public final Column<Integer> getGroupColumn() {
     return col_group;
   }
 
 
  /**
   * Retrieve the <code>GroupMembership</code> as a <code>GroupMembership</code>.
   *
   * See org.melati.poem.prepro.TableDef#generateTableBaseJava 
   * @param troid a Table Row Object ID
   * @return the <code>Persistent</code> identified by the <code>troid</code>
   */
   public GroupMembership getGroupMembershipObject(Integer troid) {
     return (GroupMembership)getObject(troid);
   }
 
 
  /**
   * Retrieve the <code>GroupMembership</code> 
   * as a <code>GroupMembership</code>.
   *
   * See org.melati.poem.prepro.TableDef#generateTableBaseJava 
   * @param troid a Table Row Object ID
   * @return the <code>Persistent</code> identified   */
   public GroupMembership getGroupMembershipObject(int troid) {
     return (GroupMembership)getObject(troid);
   }
 
   protected JdbcPersistent _newPersistent() {
     return new GroupMembership();
   }
   public String defaultDisplayName() {
     return "Group membership";
   }
 
   public String defaultDescription() {
     return "A record that a given User is a member of a given Group";
   }
 
   public String defaultCategory() {
     return "User";
   }
 
   public int defaultDisplayOrder() {
     return 2040;
   }
 }
 

1		// Do not edit this file! It was generated by Melati POEM's DSD preprocessor.
2
3		package org.melati.poem.generated;
4
5
6		import org.melati.poem.AccessPoemException;
7		import org.melati.poem.Column;
8		import org.melati.poem.Database;
9		import org.melati.poem.DefinitionSource;
10		import org.melati.poem.DisplayLevel;
11		import org.melati.poem.Field;
12		import org.melati.poem.Group;
13		import org.melati.poem.GroupMembership;
14		import org.melati.poem.JdbcPersistent;
15		import org.melati.poem.Persistent;
16		import org.melati.poem.PoemDatabaseTables;
17		import org.melati.poem.PoemException;
18		import org.melati.poem.PoemTable;
19		import org.melati.poem.ReferencePoemType;
20		import org.melati.poem.Searchability;
21		import org.melati.poem.StandardIntegrityFix;
22		import org.melati.poem.TroidPoemType;
23		import org.melati.poem.User;
24		import org.melati.poem.ValidationPoemException;
25
26
27		/**
28		* Melati POEM generated base class for <code>Table</code> <code>groupMembership</code>.
29		*
30		* See org.melati.poem.prepro.TableDef#generateTableBaseJava
31		*/
32
33		public class GroupMembershipTableBase<T extends GroupMembership> extends PoemTable<T> {
34
35	64	private Column<Integer> col_id = null;
36	64	private Column<Integer> col_user = null;
37	64	private Column<Integer> col_group = null;
38
39		/**
40		* Constructor.
41		*
42		* See org.melati.poem.prepro.TableDef#generateTableBaseJava
43		* @param database the POEM database we are using
44		* @param name the name of this <code>Table</code>
45		* @param definitionSource which definition is being used
46		* @throws PoemException if anything goes wrong
47		*/
48
49		public GroupMembershipTableBase(
50		Database database, String name,
51		DefinitionSource definitionSource) throws PoemException {
52	64	super(database, name, definitionSource);
53	64	}
54
55
56		/**
57		* Get the database tables.
58		*
59		* See org.melati.poem.prepro.TableDef#generateTableBaseJava
60		* @return the database tables
61		*/
62		public PoemDatabaseTables getPoemDatabaseTables() {
63	82	return (PoemDatabaseTables)getDatabase();
64		}
65
66
67		/**
68		* Initialise this table by defining its columns.
69		*
70		* See org.melati.poem.prepro.TableDef#generateTableBaseJava
71		*/
72		public void init() throws PoemException {
73	41	super.init();
74	41	defineColumn(col_id =
75		new Column<Integer>(this, "id",
76		new TroidPoemType(),
77	41	DefinitionSource.dsd) {
78		public Object getCooked(Persistent g)
79		throws AccessPoemException, PoemException {
80	0	return ((GroupMembership)g).getId();
81		}
82
83		public void setCooked(Persistent g, Object cooked)
84		throws AccessPoemException, ValidationPoemException {
85	0	((GroupMembership)g).setId((Integer)cooked);
86	0	}
87
88		public Field<Integer> asField(Persistent g) {
89	9	return ((GroupMembership)g).getIdField();
90		}
91
92		public boolean defaultUserEditable() {
93	40	return false;
94		}
95
96		public boolean defaultUserCreateable() {
97	40	return false;
98		}
99
100		public DisplayLevel defaultDisplayLevel() {
101	80	return DisplayLevel.detail;
102		}
103
104		public int defaultDisplayOrder() {
105	40	return 0;
106		}
107
108		public String defaultDescription() {
109	40	return "The Table Row Object ID";
110		}
111
112		public Object getRaw_unsafe(Persistent g)
113		throws AccessPoemException {
114	91	return ((GroupMembership)g).getId_unsafe();
115		}
116
117		public void setRaw_unsafe(Persistent g, Object raw)
118		throws AccessPoemException {
119	54	((GroupMembership)g).setId_unsafe((Integer)raw);
120	54	}
121
122		public Object getRaw(Persistent g)
123		throws AccessPoemException {
124	9	return ((GroupMembership)g).getId();
125		}
126
127		public void setRaw(Persistent g, Object raw)
128		throws AccessPoemException {
129	0	((GroupMembership)g).setId((Integer)raw);
130	0	}
131		});
132
133	82	defineColumn(col_user =
134		new Column<Integer>(this, "user",
135	41	new ReferencePoemType(getPoemDatabaseTables().
136	41	getUserTable(), false),
137	41	DefinitionSource.dsd) {
138		public Object getCooked(Persistent g)
139		throws AccessPoemException, PoemException {
140	0	return ((GroupMembership)g).getUser();
141		}
142
143		public void setCooked(Persistent g, Object cooked)
144		throws AccessPoemException, ValidationPoemException {
145	0	((GroupMembership)g).setUser((User)cooked);
146	0	}
147
148		public Field<Integer> asField(Persistent g) {
149	14	return ((GroupMembership)g).getUserField();
150		}
151
152		public Searchability defaultSearchability() {
153	80	return Searchability.yes;
154		}
155
156		public Integer defaultDisplayOrderPriority() {
157	40	return new Integer(0);
158		}
159
160		public String defaultDisplayName() {
161	40	return "User";
162		}
163
164		public int defaultDisplayOrder() {
165	40	return 1;
166		}
167
168		public String defaultDescription() {
169	40	return "The user who belongs to the group";
170		}
171
172		public boolean defaultIndexed() {
173	40	return true;
174		}
175
176		public String defaultRenderinfo() {
177	40	return "SelectionWindow";
178		}
179
180		public Object getRaw_unsafe(Persistent g)
181		throws AccessPoemException {
182	91	return ((GroupMembership)g).getUser_unsafe();
183		}
184
185		public void setRaw_unsafe(Persistent g, Object raw)
186		throws AccessPoemException {
187	4	((GroupMembership)g).setUser_unsafe((Integer)raw);
188	4	}
189
190		public Object getRaw(Persistent g)
191		throws AccessPoemException {
192	14	return ((GroupMembership)g).getUserTroid();
193		}
194
195		public void setRaw(Persistent g, Object raw)
196		throws AccessPoemException {
197	0	((GroupMembership)g).setUserTroid((Integer)raw);
198	0	}
199
200		public StandardIntegrityFix defaultIntegrityFix() {
201	40	return StandardIntegrityFix.delete;
202		}
203		});
204
205	82	defineColumn(col_group =
206		new Column<Integer>(this, "group",
207	41	new ReferencePoemType(getPoemDatabaseTables().
208	41	getGroupTable(), false),
209	41	DefinitionSource.dsd) {
210		public Object getCooked(Persistent g)
211		throws AccessPoemException, PoemException {
212	0	return ((GroupMembership)g).getGroup();
213		}
214
215		public void setCooked(Persistent g, Object cooked)
216		throws AccessPoemException, ValidationPoemException {
217	0	((GroupMembership)g).setGroup((Group)cooked);
218	0	}
219
220		public Field<Integer> asField(Persistent g) {
221	12	return ((GroupMembership)g).getGroupField();
222		}
223
224		public Searchability defaultSearchability() {
225	80	return Searchability.primary;
226		}
227
228		public Integer defaultDisplayOrderPriority() {
229	40	return new Integer(1);
230		}
231
232		public String defaultDisplayName() {
233	40	return "Group";
234		}
235
236		public int defaultDisplayOrder() {
237	40	return 2;
238		}
239
240		public String defaultDescription() {
241	40	return "The group to which the user belongs";
242		}
243
244		public Object getRaw_unsafe(Persistent g)
245		throws AccessPoemException {
246	91	return ((GroupMembership)g).getGroup_unsafe();
247		}
248
249		public void setRaw_unsafe(Persistent g, Object raw)
250		throws AccessPoemException {
251	4	((GroupMembership)g).setGroup_unsafe((Integer)raw);
252	4	}
253
254		public Object getRaw(Persistent g)
255		throws AccessPoemException {
256	12	return ((GroupMembership)g).getGroupTroid();
257		}
258
259		public void setRaw(Persistent g, Object raw)
260		throws AccessPoemException {
261	0	((GroupMembership)g).setGroupTroid((Integer)raw);
262	0	}
263		});
264	41	}
265
266
267		/**
268		* Retrieves the <code>Id</code> <code>Column</code> for this
269		* <code>groupMembership</code> <code>Table</code>.
270		*
271		* see org.melati.poem.prepro.FieldDef#generateColAccessor
272		* @return the id <code>Column</code>
273		*/
274		public final Column<Integer> getIdColumn() {
275	9	return col_id;
276		}
277
278
279		/**
280		* Retrieves the <code>User</code> <code>Column</code> for this
281		* <code>groupMembership</code> <code>Table</code>.
282		*
283		* see org.melati.poem.prepro.FieldDef#generateColAccessor
284		* @return the user <code>Column</code>
285		*/
286		public final Column<Integer> getUserColumn() {
287	62	return col_user;
288		}
289
290
291		/**
292		* Retrieves the <code>Group</code> <code>Column</code> for this
293		* <code>groupMembership</code> <code>Table</code>.
294		*
295		* see org.melati.poem.prepro.FieldDef#generateColAccessor
296		* @return the group <code>Column</code>
297		*/
298		public final Column<Integer> getGroupColumn() {
299	61	return col_group;
300		}
301
302
303		/**
304		* Retrieve the <code>GroupMembership</code> as a <code>GroupMembership</code>.
305		*
306		* See org.melati.poem.prepro.TableDef#generateTableBaseJava
307		* @param troid a Table Row Object ID
308		* @return the <code>Persistent</code> identified by the <code>troid</code>
309		*/
310		public GroupMembership getGroupMembershipObject(Integer troid) {
311	0	return (GroupMembership)getObject(troid);
312		}
313
314
315		/**
316		* Retrieve the <code>GroupMembership</code>
317		* as a <code>GroupMembership</code>.
318		*
319		* See org.melati.poem.prepro.TableDef#generateTableBaseJava
320		* @param troid a Table Row Object ID
321		* @return the <code>Persistent</code> identified */
322		public GroupMembership getGroupMembershipObject(int troid) {
323	0	return (GroupMembership)getObject(troid);
324		}
325
326		protected JdbcPersistent _newPersistent() {
327	44	return new GroupMembership();
328		}
329		public String defaultDisplayName() {
330	40	return "Group membership";
331		}
332
333		public String defaultDescription() {
334	40	return "A record that a given User is a member of a given Group";
335		}
336
337		public String defaultCategory() {
338	40	return "User";
339		}
340
341		public int defaultDisplayOrder() {
342	40	return 2040;
343		}
344		}
345