/** * Creates an object from a byte buffer */ public static <T extends Object> T objectFromByteBuffer(byte[] buffer) throws Exception { if(buffer == null) return null; return objectFromByteBuffer(buffer,0,buffer.length); }
public Object getValue() throws Exception { return Util.objectFromByteBuffer(attr_value); }
public Object getValue() throws Exception { return Util.objectFromByteBuffer(attr_value); }
public static <T extends Object> T objectFromByteBuffer(byte[] buffer,int offset,int length) throws Exception { return objectFromByteBuffer(buffer, offset, length, null); }
/** * Uses custom serialization to create an object from the buffer of the message. Note that this is dangerous when * using your own classloader, e.g. inside of an application server ! Most likely, JGroups will use the system * classloader to deserialize the buffer into an object, whereas (for example) a web application will want to use * the webapp's classloader, resulting in a ClassCastException. The recommended way is for the application to use * their own serialization and only pass byte[] buffer to JGroups.<p/> * As of 3.5, a classloader can be passed in. It will be used first to find a class, before contacting * the other classloaders in the list. If null, the default list of classloaders will be used. * @return the object */ public <T extends Object> T getObject(ClassLoader loader) { try { return Util.objectFromByteBuffer(buf, offset, length, loader); } catch(Exception ex) { throw new IllegalArgumentException(ex); } }
public static Object readObject(DataInput in) throws Exception { int len=in.readInt(); if(len == -1) return readGenericStreamable(in); byte[] buf=new byte[len]; in.readFully(buf, 0, len); return objectFromByteBuffer(buf); }
public void run() { DatagramPacket packet; byte[] buf; DiscoveryResponse rsp; List l; InetAddress bind_interface; InetSocketAddress responder_addr; while (running) { try { buf = new byte[16000]; packet = new DatagramPacket(buf, buf.length); sock.receive(packet); rsp = (DiscoveryResponse) Util.objectFromByteBuffer(packet.getData()); System.out.println("<== " + rsp); bind_interface = rsp.interface_used; l = (List) map.get(bind_interface); if (l == null) map.put(bind_interface, (l = new ArrayList())); responder_addr = rsp.discovery_responder; if (!l.contains(responder_addr)) l.add(responder_addr); } catch (Exception ex) { System.err.println("UcastReceiver.run(): " + ex); } } } }
public void readFrom(DataInput in) throws Exception { type=Type.values()[in.readByte()]; // We can't use Util.readObject since it's size is limited to 2^15-1 try { short first = in.readShort(); if (first == -1) { object = Util.readGenericStreamable(in); } else { ByteBuffer bb = ByteBuffer.allocate(4); bb.putShort(first); bb.putShort(in.readShort()); int size = bb.getInt(0); byte[] bytes = new byte[size]; in.readFully(bytes, 0, size); object = Util.objectFromByteBuffer(bytes); } } catch (IOException e) { throw e; } catch (Exception e) { throw new IOException("Exception encountered while serializing execution request", e); } request=in.readLong(); }
public void run() { while (running) { buf = new byte[16000]; mcast_packet = new DatagramPacket(buf, buf.length); try { mcast_sock.receive(mcast_packet); req = (DiscoveryRequest) Util.objectFromByteBuffer(mcast_packet.getData()); System.out.println("<-- " + req); // send response back to req.sender_addr rsp = new DiscoveryResponse(new InetSocketAddress(local_addr, local_port), req.sender_addr.getAddress()); buf = Util.objectToByteBuffer(rsp); rsp_packet = new DatagramPacket(buf, buf.length, req.sender_addr); sock.send(rsp_packet); } catch (Exception ex) { System.err.println("McastReceiver.run(): " + ex + ", rsp_packet=" + rsp_packet.getSocketAddress() + ", length=" + rsp_packet.getLength() + " bytes"); ex.printStackTrace(); } } } }
/** * Creates an object from a byte buffer */ public static <T extends Object> T objectFromByteBuffer(byte[] buffer) throws Exception { if(buffer == null) return null; return objectFromByteBuffer(buffer,0,buffer.length); }
public Object getValue() throws Exception { return Util.objectFromByteBuffer(attr_value); }
public static <T extends Object> T objectFromByteBuffer(byte[] buffer,int offset,int length) throws Exception { return objectFromByteBuffer(buffer, offset, length, null); }
public void setState(byte[] state) { try { history=(LinkedList)Util.objectFromByteBuffer(state); } catch(Exception e) { e.printStackTrace(); } }
private void handleServicesRsp(Address sender, byte[] state) throws Exception { Set<String> s=(Set<String>) Util.objectFromByteBuffer(state); synchronized(service_responses) { Set<String> tmp=service_responses.get(sender); if(tmp == null) tmp=new HashSet<String>(); tmp.addAll(s); service_responses.put(sender, tmp); if(log.isTraceEnabled()) log.trace("received service response: " + sender + "(" + s.toString() + ")"); service_responses.notifyAll(); } }
public static Object readObject(DataInput in) throws Exception { int len=in.readInt(); if(len == -1) return readGenericStreamable(in); byte[] buf=new byte[len]; in.readFully(buf, 0, len); return objectFromByteBuffer(buf); }
public void setState(byte[] state) { try { integrate((Hashtable)Util.objectFromByteBuffer(state)); } catch(Exception ex) { ex.printStackTrace(); } }
/** * Creates an object from a byte buffer */ public static Object objectFromByteBuffer(byte[] buffer) throws Exception { if(buffer == null) return null; if(JGROUPS_COMPAT) return oldObjectFromByteBuffer(buffer); return objectFromByteBuffer(buffer, 0, buffer.length); }
public static Object readObject(DataInputStream in) throws Exception { short len=in.readShort(); Object retval=null; if(len == -1) { retval=readGenericStreamable(in); } else { byte[] buf=new byte[len]; in.readFully(buf, 0, len); retval=objectFromByteBuffer(buf); } return retval; }
public void setState(byte[] new_state) { Hashtable new_copy; try { new_copy=(Hashtable)Util.objectFromByteBuffer(new_state); if(new_copy == null) return; } catch(Throwable ex) { if(log.isErrorEnabled()) log.error("exception unmarshalling state: " + ex); return; } _putAll(new_copy); state_promise.setResult(Boolean.TRUE); }
public void setState(byte[] new_state) { HashMap<K,V> new_copy; try { new_copy=(HashMap<K,V>)Util.objectFromByteBuffer(new_state); if(new_copy == null) return; } catch(Throwable ex) { if(log.isErrorEnabled()) log.error("exception unmarshalling state: " + ex); return; } _putAll(new_copy); state_promise.setResult(Boolean.TRUE); }