1: import java.util.ArrayList;

2: import java.util.List;

3:

6:

7: public final class DataTable {

8:

9: private DataRowCollection rows; //用于保存DataRow的集合对象

10: private DataColumnCollection columns; //用于保存DataColumn的对象

11: private String tableName; //表名

12: private boolean readOnly = false;

13: private int nextRowIndex = 0;

14: private DataExpression dataExpression;

15: private Object tag;

16:

17: public DataTable() {

18: this.columns = new DataColumnCollection();

19: this.rows = new DataRowCollection();

20: this.rows.setColumns(columns);

21: dataExpression = new DataExpression(this);

22: }

23:

24: public DataTable(String dataTableName) {

25: this();

26: this.tableName = dataTableName;

27: }

28:

29: public int getTotalCount() {

30: return rows.size();

31: }

32:

33: public boolean isReadOnly() {

34: return this.readOnly;

35: }

36:

37: public void setReadOnly(boolean readOnly) {

38: this.readOnly = readOnly;

39: }

40:

41: /**

42: * 功能描述： 返回表名

43: * @param

44: */

45: public String getTableName() {

46: return this.tableName;

47: }

48:

49: /**

50: * 功能描述： 设置表名

51: * @param

52: */

53: public void setTableName(String tableName) {

54: this.tableName = tableName;

55: }

56:

57: /**

58: * 功能描述： 返回该表引用的封装类

59: * @param

60: * @return: DataRowCollection

61: */

62: public DataRowCollection getRows() {

63: return this.rows;

64: }

65:

66: public DataColumnCollection getColumns() {

67: return this.columns;

68: }

69:

70: /**

71: * 功能描述： 获取指定行指定列的数据

72: * @param

73: * @return: Object

74: */

75:

76: public Object getValue(int row,

77: String colName) {

78: return this.rows.get(row).getValue(colName);

79: }

80:

81: public Object getValue(int row,

82: int col) {

83: return this.rows.get(row).getValue(col);

84: }

85:

86: /**

87: * 功能描述： 为该表数据新建一行

88: * @param

89: * @return: DataRow

90: */

91: public DataRow newRow() throws Exception {

92: DataRow tempRow = new DataRow(this);

93: nextRowIndex = nextRowIndex < this.rows.size() ? this.rows.size()

94: : nextRowIndex;

95: tempRow.setColumns(this.columns);

96: tempRow.setRowIndex(nextRowIndex++);

97: return tempRow;

98: }

99:

100: public void setValue(int row,

101: int col,

102: Object value) {

103: this.rows.get(row).setValue(col, value);

104: }

105:

106: public void setValue(int row,

107: String colName,

108: Object value) {

109: this.rows.get(row).setValue(colName, value);

110: }

111:

112: /**

113: * @param tag

114: */

115: public void setTag(Object tag) {

116: this.tag = tag;

117: }

118:

119: /**

120: * @return the tag

121: */

122: public Object getTag() {

123: return tag;

124: }

125:

126: public DataColumn addColumn(String columnName,

127: int dataType) throws Exception {

128: return this.columns.addColumn(columnName, dataType);

129: }

130:

131: public boolean addRow(DataRow row) throws Exception {

132: if (row.getRowIndex() > this.rows.size())

133: row.setRowIndex(this.rows.size());

134: return this.rows.add(row);

135: }

136:

137: //以下为数据表扩展方法实现集合

138: /**

139: * 功能描述： 返回符合过滤条件的数据行集合，并返回

140: * @param

141: * @return: DataTable

142: */

143: public List select(String filterString) {

144: List rows = new ArrayList();

145: if (StringUtil.isNotEmpty(filterString)) {

146: for (Object row : this.rows) {

147: DataRow currentRow = (DataRow) row;

148: if ((Boolean) dataExpression.compute(filterString,

149: currentRow.getItemMap())) {

150: rows.add(currentRow);

151: }

152: }

153: return rows;

154: } else {

155: return this.rows;

156: }

157: }

158:

159: /**

160: * 功能描述： 对当前表进行查询 过滤，并返回指定列集合拼装的DataTable对象

161: * @param

162: * @return: DataTable

163: */

164: public DataTable select(String filterString,

165: String[] columns,

166: boolean distinct) throws Exception {

167: DataTable result = new DataTable();

168: List rows = select(filterString);

169: //构造表结构

170: for (String c : columns) {

171: DataColumn dc = this.columns.get(c);

172: DataColumn newDc = new DataColumn(dc.getColumnName(),

173: dc.getDataType());

174: newDc.setCaptionName(dc.getCaptionName());

175: result.columns.add(newDc);

176: }

177: //填充数据

178: for (DataRow r : rows) {

179: DataRow newRow = result.newRow();

180: newRow.copyFrom(r);

181: result.addRow(newRow);

182: }

183: return result;

184: }

185:

186: public DataTable select(String tableName,

187: String selectField,

188: String filterString,

189: String groupField) {

190: DataTable result = new DataTable();

191: //

192: return result;

193: }

194:

195: /**

196: * 功能描述： 根据指定表达式对符合过滤条件的数据进行计算

197: * @param

198: * @return: Object

199: * @author: James Cheung

200: * @version: 2.0

201: */

202: public Object compute(String expression,

203: String filter) {

204: return dataExpression.compute(expression, select(filter));

205: }

206:

207: public Object max(String columns,

208: String filter) {

209: return null;

210: }

211:

212: public Object min(String columns,

213: String filter) {

214: return null;

215: }

216:

217: public Object avg(String columns,

218: String filter) {

219: return null;

220: }

221:

222: public Object max(String columns,

223: String filter,

224: String groupBy) {

225: return null;

226: }

227:

228: public Object min(String columns,

229: String filter,

230: String groupBy) {

231: return null;

232: }

233:

234: public Object avg(String columns,

235: String filter,

236: String groupBy) {

237: return null;

238: }

239:

240: private List getColumns(String colString) {

241: List columns = new ArrayList();

242:

243: return columns;

244: }

245: }