开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 中间件编程 > 查看源码
JABMessage.java
资源名称：blacktie-2.0.0.M3-src.zip　[点击查看]
上传用户：xfwatch
上传日期：2020-12-14
资源大小：872k
文件大小：13k
源码类别：

中间件编程

开发平台：

Java

JABMessage.java：源码内容
  1. /*
  2.  * JBoss, Home of Professional Open Source
  3.  * Copyright 2008, Red Hat, Inc., and others contributors as indicated
  4.  * by the @authors tag. All rights reserved.
  5.  * See the copyright.txt in the distribution for a
  6.  * full listing of individual contributors.
  7.  * This copyrighted material is made available to anyone wishing to use,
  8.  * modify, copy, or redistribute it subject to the terms and conditions
  9.  * of the GNU Lesser General Public License, v. 2.1.
  10.  * This program is distributed in the hope that it will be useful, but WITHOUT A
  11.  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A
  12.  * PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more details.
  13.  * You should have received a copy of the GNU Lesser General Public License,
  14.  * v.2.1 along with this distribution; if not, write to the Free Software
  15.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  16.  * MA  02110-1301, USA.
  17.  */
  18. package org.jboss.blacktie.jatmibroker.jab;
  20. import java.util.Map;
  22. import org.jboss.blacktie.jatmibroker.xatmi.Buffer;
  23. import org.jboss.blacktie.jatmibroker.xatmi.Connection;
  24. import org.jboss.blacktie.jatmibroker.xatmi.ConnectionException;
  25. import org.jboss.blacktie.jatmibroker.xatmi.Response;
  26. import org.jboss.blacktie.jatmibroker.xatmi.X_COMMON;
  27. import org.jboss.blacktie.jatmibroker.xatmi.X_C_TYPE;
  28. import org.jboss.blacktie.jatmibroker.xatmi.X_OCTET;
  30. /**
  31.  * The JABRequest class wraps the output parameter to the service.
  32.  * 
  33.  * @see JABRemoteService
  34.  */
  35. public class JABMessage implements Message {
  37. /**
  38.  * The rcode if this is a response
  39.  */
  40. private int rcode;
  42. private X_OCTET xOctet;
  44. private X_COMMON xCommon;
  46. private X_C_TYPE xCType;
  48. /**
  49.  * The request should be created from the JABRemoteService getRequest
  50.  * method.
  51.  * 
  52.  * @param connection
  53.  *            The connection to use
  54.  * @param bufferSubType
  55.  * @param bufferType
  56.  * @throws JABException
  57.  */
  58. JABMessage(Connection connection, String bufferType, String bufferSubType)
  59. throws JABException {
  60. try {
  61. Buffer buffer = connection.tpalloc(bufferType, bufferSubType);
  62. if (buffer.getType().equals("X_OCTET")) {
  63. xOctet = (X_OCTET) buffer;
  64. } else if (buffer.getType().equals("X_COMMON")) {
  65. xCommon = (X_COMMON) buffer;
  66. } else {
  67. xCType = (X_C_TYPE) buffer;
  68. }
  69. } catch (ConnectionException e) {
  70. throw new JABException("Could not create an X_OCTET buffer", e);
  71. }
  72. }
  74. /**
  75.  * Create a message from the response
  76.  * 
  77.  * @param response
  78.  *            The response
  79.  */
  80. JABMessage(Response response) {
  81. Buffer buffer = response.getBuffer();
  82. if (buffer.getType().equals("X_OCTET")) {
  83. xOctet = (X_OCTET) buffer;
  84. } else if (buffer.getType().equals("X_COMMON")) {
  85. xCommon = (X_COMMON) buffer;
  86. } else {
  87. xCType = (X_C_TYPE) buffer;
  88. }
  89. rcode = response.getRcode();
  90. }
  92. /**
  93.  * An internal method to access the actual buffer.
  94.  * 
  95.  * @return The buffer
  96.  */
  97. Buffer getBuffer() {
  98. if (xOctet != null) {
  99. return xOctet;
  100. } else if (xCommon != null) {
  101. return xCommon;
  102. } else {
  103. return xCType;
  104. }
  105. }
  107. /**
  108.  * Clear the real buffer
  109.  */
  110. void clear() {
  111. if (xOctet != null) {
  112. xOctet.clear();
  113. } else if (xCommon != null) {
  114. xCommon.clear();
  115. } else {
  116. xCType.clear();
  117. }
  118. }
  120. /**
  121.  * Get the rcode that tpreturn returned with.
  122.  * 
  123.  * @return The application return code.
  124.  */
  125. int getRCode() {
  126. return rcode;
  127. }
  129. /**
  130.  * Get the content of the buffer
  131.  * 
  132.  * @param key
  133.  *            The content of the buffer to set
  134.  * @param position
  135.  *            The position to check
  136.  * @throws JABException
  137.  *             In case the content is malformed
  138.  */
  139. public byte getByte(String key) throws JABException {
  140. if (xOctet != null) {
  141. throw new JABException("Not supported for this buffer type");
  142. } else if (xCommon != null) {
  143. try {
  144. return xCommon.getByte(key);
  145. } catch (Throwable t) {
  146. throw new JABException(t.getMessage(), t);
  147. }
  148. } else {
  149. try {
  150. return xCType.getByte(key);
  151. } catch (Throwable t) {
  152. throw new JABException(t.getMessage(), t);
  153. }
  154. }
  155. }
  157. public byte[] getByteArray(String key) throws JABException {
  158. if (xOctet != null) {
  159. if (key.equals("X_OCTET")) {
  160. return xOctet.getByteArray();
  161. } else {
  162. throw new JABException(
  163. "X_OCTET buffers contain a single attribute X_OCTET");
  164. }
  165. } else if (xCommon != null) {
  166. try {
  167. return xCommon.getByteArray(key);
  168. } catch (Throwable t) {
  169. throw new JABException(t.getMessage(), t);
  170. }
  171. } else {
  172. try {
  173. return xCType.getByteArray(key);
  174. } catch (Throwable t) {
  175. throw new JABException(t.getMessage(), t);
  176. }
  177. }
  178. }
  180. public byte[][] getByteArrayArray(String key) throws JABException {
  181. if (xOctet != null) {
  182. throw new JABException("Not supported for this buffer type");
  183. } else if (xCommon != null) {
  184. throw new JABException("Not supported for this buffer type");
  185. } else {
  186. try {
  187. return xCType.getByteArrayArray(key);
  188. } catch (Throwable t) {
  189. throw new JABException(t.getMessage(), t);
  190. }
  191. }
  192. }
  194. public double getDouble(String key) throws JABException {
  195. if (xOctet != null) {
  196. throw new JABException("Not supported for this buffer type");
  197. } else if (xCommon != null) {
  198. throw new JABException("Not supported for this buffer type");
  199. } else {
  200. try {
  201. return xCType.getDouble(key);
  202. } catch (Throwable t) {
  203. throw new JABException(t.getMessage(), t);
  204. }
  205. }
  206. }
  208. public double[] getDoubleArray(String key) throws JABException {
  209. if (xOctet != null) {
  210. throw new JABException("Not supported for this buffer type");
  211. } else if (xCommon != null) {
  212. throw new JABException("Not supported for this buffer type");
  213. } else {
  214. try {
  215. return xCType.getDoubleArray(key);
  216. } catch (Throwable t) {
  217. throw new JABException(t.getMessage(), t);
  218. }
  219. }
  220. }
  222. public float getFloat(String key) throws JABException {
  223. if (xOctet != null) {
  224. throw new JABException("Not supported for this buffer type");
  225. } else if (xCommon != null) {
  226. throw new JABException("Not supported for this buffer type");
  227. } else {
  228. try {
  229. return xCType.getFloat(key);
  230. } catch (Throwable t) {
  231. throw new JABException(t.getMessage(), t);
  232. }
  233. }
  234. }
  236. public float[] getFloatArray(String key) throws JABException {
  237. if (xOctet != null) {
  238. throw new JABException("Not supported for this buffer type");
  239. } else if (xCommon != null) {
  240. throw new JABException("Not supported for this buffer type");
  241. } else {
  242. try {
  243. return xCType.getFloatArray(key);
  244. } catch (Throwable t) {
  245. throw new JABException(t.getMessage(), t);
  246. }
  247. }
  248. }
  250. public int getInt(String key) throws JABException {
  251. if (xOctet != null) {
  252. throw new JABException("Not supported for this buffer type");
  253. } else if (xCommon != null) {
  254. throw new JABException("Not supported for this buffer type");
  255. } else {
  256. try {
  257. return xCType.getInt(key);
  258. } catch (Throwable t) {
  259. throw new JABException(t.getMessage(), t);
  260. }
  261. }
  262. }
  264. public int[] getIntArray(String key) throws JABException {
  265. if (xOctet != null) {
  266. throw new JABException("Not supported for this buffer type");
  267. } else if (xCommon != null) {
  268. throw new JABException("Not supported for this buffer type");
  269. } else {
  270. try {
  271. return xCType.getIntArray(key);
  272. } catch (Throwable t) {
  273. throw new JABException(t.getMessage(), t);
  274. }
  275. }
  276. }
  278. public short getShort(String key) throws JABException {
  279. if (xOctet != null) {
  280. throw new JABException("Not supported for this buffer type");
  281. } else if (xCommon != null) {
  282. try {
  283. return xCommon.getShort(key);
  284. } catch (Throwable t) {
  285. throw new JABException(t.getMessage(), t);
  286. }
  287. } else {
  288. try {
  289. return xCType.getShort(key);
  290. } catch (Throwable t) {
  291. throw new JABException(t.getMessage(), t);
  292. }
  293. }
  294. }
  296. public short[] getShortArray(String key) throws JABException {
  297. if (xOctet != null) {
  298. throw new JABException("Not supported for this buffer type");
  299. } else if (xCommon != null) {
  300. try {
  301. return xCommon.getShortArray(key);
  302. } catch (Throwable t) {
  303. throw new JABException(t.getMessage(), t);
  304. }
  305. } else {
  306. try {
  307. return xCType.getShortArray(key);
  308. } catch (Throwable t) {
  309. throw new JABException(t.getMessage(), t);
  310. }
  311. }
  312. }
  314. public void setByte(String key, byte data) throws JABException {
  315. if (xOctet != null) {
  316. throw new JABException("Not supported for this buffer type");
  317. } else if (xCommon != null) {
  318. try {
  319. xCommon.setByte(key, data);
  320. } catch (Throwable t) {
  321. throw new JABException(t.getMessage(), t);
  322. }
  323. } else {
  324. try {
  325. xCType.setByte(key, data);
  326. } catch (Throwable t) {
  327. throw new JABException(t.getMessage(), t);
  328. }
  329. }
  330. }
  332. public void setByteArray(String key, byte[] data) throws JABException {
  333. if (xOctet != null) {
  334. if (key.equals("X_OCTET")) {
  335. xOctet.setByteArray(data);
  336. } else {
  337. throw new JABException(
  338. "X_OCTET buffers contain a single attribute X_OCTET");
  339. }
  340. } else if (xCommon != null) {
  341. try {
  342. xCommon.setByteArray(key, data);
  343. } catch (Throwable t) {
  344. throw new JABException(t.getMessage(), t);
  345. }
  346. } else {
  347. try {
  348. xCType.setByteArray(key, data);
  349. } catch (Throwable t) {
  350. throw new JABException(t.getMessage(), t);
  351. }
  352. }
  353. }
  355. public void setByteArrayArray(String key, byte[][] data)
  356. throws JABException {
  357. if (xOctet != null) {
  358. throw new JABException("Not supported for this buffer type");
  359. } else if (xCommon != null) {
  360. throw new JABException("Not supported for this buffer type");
  361. } else {
  362. try {
  363. xCType.setByteArrayArray(key, data);
  364. } catch (Throwable t) {
  365. throw new JABException(t.getMessage(), t);
  366. }
  367. }
  368. }
  370. public void setDouble(String key, double data) throws JABException {
  371. if (xOctet != null) {
  372. throw new JABException("Not supported for this buffer type");
  373. } else if (xCommon != null) {
  374. throw new JABException("Not supported for this buffer type");
  375. } else {
  376. try {
  377. xCType.setDouble(key, data);
  378. } catch (Throwable t) {
  379. throw new JABException(t.getMessage(), t);
  380. }
  381. }
  382. }
  384. public void setDoubleArray(String key, double[] data) throws JABException {
  385. if (xOctet != null) {
  386. throw new JABException("Not supported for this buffer type");
  387. } else if (xCommon != null) {
  388. throw new JABException("Not supported for this buffer type");
  389. } else {
  390. try {
  391. xCType.setDoubleArray(key, data);
  392. } catch (Throwable t) {
  393. throw new JABException(t.getMessage(), t);
  394. }
  395. }
  396. }
  398. public void setFloat(String key, float data) throws JABException {
  399. if (xOctet != null) {
  400. throw new JABException("Not supported for this buffer type");
  401. } else if (xCommon != null) {
  402. throw new JABException("Not supported for this buffer type");
  403. } else {
  404. try {
  405. xCType.setFloat(key, data);
  406. } catch (Throwable t) {
  407. throw new JABException(t.getMessage(), t);
  408. }
  409. }
  410. }
  412. public void setFloatArray(String key, float[] data) throws JABException {
  413. if (xOctet != null) {
  414. throw new JABException("Not supported for this buffer type");
  415. } else if (xCommon != null) {
  416. throw new JABException("Not supported for this buffer type");
  417. } else {
  418. try {
  419. xCType.setFloatArray(key, data);
  420. } catch (Throwable t) {
  421. throw new JABException(t.getMessage(), t);
  422. }
  423. }
  424. }
  426. public void setInt(String key, int data) throws JABException {
  427. if (xOctet != null) {
  428. throw new JABException("Not supported for this buffer type");
  429. } else if (xCommon != null) {
  430. throw new JABException("Not supported for this buffer type");
  431. } else {
  432. try {
  433. xCType.setInt(key, data);
  434. } catch (Throwable t) {
  435. throw new JABException(t.getMessage(), t);
  436. }
  437. }
  438. }
  440. public void setIntArray(String key, int[] data) throws JABException {
  441. if (xOctet != null) {
  442. throw new JABException("Not supported for this buffer type");
  443. } else if (xCommon != null) {
  444. throw new JABException("Not supported for this buffer type");
  445. } else {
  446. try {
  447. xCType.setIntArray(key, data);
  448. } catch (Throwable t) {
  449. throw new JABException(t.getMessage(), t);
  450. }
  451. }
  452. }
  454. public void setShort(String key, short data) throws JABException {
  455. if (xOctet != null) {
  456. throw new JABException("Not supported for this buffer type");
  457. } else if (xCommon != null) {
  458. try {
  459. xCommon.setShort(key, data);
  460. } catch (Throwable t) {
  461. throw new JABException(t.getMessage(), t);
  462. }
  463. } else {
  464. try {
  465. xCType.setShort(key, data);
  466. } catch (Throwable t) {
  467. throw new JABException(t.getMessage(), t);
  468. }
  469. }
  470. }
  472. public void setShortArray(String key, short[] data) throws JABException {
  473. if (xOctet != null) {
  474. throw new JABException("Not supported for this buffer type");
  475. } else if (xCommon != null) {
  476. try {
  477. xCommon.setShortArray(key, data);
  478. } catch (Throwable t) {
  479. throw new JABException(t.getMessage(), t);
  480. }
  481. } else {
  482. try {
  483. xCType.setShortArray(key, data);
  484. } catch (Throwable t) {
  485. throw new JABException(t.getMessage(), t);
  486. }
  487. }
  488. }
  490. int getLength() {
  491. if (xOctet != null) {
  492. return xOctet.getByteArray().length;
  493. } else {
  494. return 0;
  495. }
  496. }
  498. public Map<String, Class> getMessageFormat() {
  499. if (xOctet != null) {
  500. return xOctet.getFormat();
  501. } else if (xCommon != null) {
  502. return xCommon.getFormat();
  503. } else {
  504. return xCType.getFormat();
  505. }
  506. }
  507. }