Decodes, inflates and deserializes the specified base64-encoded message to an {@link XMLObject}.
18063
static XMLObject fromDeflatedBase64(String base64Encoded) {
        requireNonNull(base64Encoded, "base64Encoded");

        final byte[] base64decoded;
        try {
            base64decoded = Base64.getMimeDecoder().decode(base64Encoded);
        } catch (IllegalArgumentException e) {
            throw new SamlException("failed to decode a deflated base64 string", e);
        }

        final ByteArrayOutputStream bytesOut = new ByteArrayOutputStream();
        try (InflaterOutputStream inflaterOutputStream =
                     new InflaterOutputStream(bytesOut, new Inflater(true))) {
            inflaterOutputStream.write(base64decoded);
        } catch (IOException e) {
            throw new SamlException("failed to inflate a SAML message", e);
        }

        return SamlMessageUtil.deserialize(bytesOut.toByteArray());
    }
826833
public static org.apache.axis.encoding.Deserializer getDeserializer(
           java.lang.String mechType, 
           java.lang.Class _javaType,  
           javax.xml.namespace.QName _xmlType) {
        return 
          new  org.apache.axis.encoding.ser.BeanDeserializer(
            _javaType, _xmlType, typeDesc);
    }
882999
public Object deserialize(String data) {
		if ((data == null) || (data.length() == 0)) {
			return null;
		}
		ObjectInputStream ois = null;
		ByteArrayInputStream bis = null;
		try {
			bis = new ByteArrayInputStream(Base64.decodeBase64(data.getBytes()));
			ois = new ObjectInputStream(bis);
			return ois.readObject();
		} catch (ClassNotFoundException e) {
			LOGGER.error("Can't deserialize data from Base64", e);
			throw new IllegalArgumentException(e);
		} catch (IOException e) {
			LOGGER.error("Can't deserialize data from Base64", e);
			throw new IllegalArgumentException(e);
		} catch (Exception e) {
			LOGGER.error("Can't deserialize data from Base64", e);
			throw new IllegalArgumentException(e);
		} finally {
			try {
				if (ois != null) {
					ois.close();
				}
			} catch (Exception e) {
				LOGGER.error("Can't close ObjetInputStream used for deserialize data from Base64", e);
			}
		}
	}
101236
public static BigInteger decode(String s) {
        byte[] bytes = Base64.decodeBase64(s);

        BigInteger bi = new BigInteger(1, bytes);
        return bi;
    }
634554
@Override
    public void setSerializedObject(byte[] payload) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.entry(this, tc, "setSerializedObject", payload);

        // Set the new data into the message itself
        getPayload().setField(JmsObjectBodyAccess.BODY_DATA_VALUE, payload);
        // Throw away any references to the old 'real' object we have
        realObject = null;
        hasRealObject = false;
        hasSerializedRealObject = false;
        softRefToRealObject = null;
        clearCachedLengths();

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
            SibTr.exit(this, tc, "setSerializedObject");
    }
565421
static Object decode(String s) {
    byte[] bytes = Base64.base64ToByteArray(s);
    ObjectInputStream objectInputStream;
    try {
      objectInputStream = new ObjectInputStream(
          new ByteArrayInputStream(bytes));
      return objectInputStream.readObject();
    } catch (IOException | ClassNotFoundException e) {
      log.error(e);
      return null;
    }
  }
507773
public static byte[] fromBase64(String base64String) {

        byte[] result = null;
        if (base64String != null) {
            result = Base64.decodeBase64(base64String);
        }
        return result;
    }
617101
@Deprecated
	public static FileMessage decode(String encodedMessage) throws IOException {
		return decode(
			encodedMessage.isEmpty()
			? ByteArray.EMPTY_BYTE_ARRAY
			: new ByteArray(
				Base64Coder.decode(
					encodedMessage
				)
			)
		);
	}
1063525
public static Object xmlToObject(String fileName) throws FileNotFoundException {
		FileInputStream fi = new FileInputStream(fileName);
		XMLDecoder decoder = new XMLDecoder(fi);
		Object object = decoder.readObject();
		decoder.close();
		return object;
	}
620493
public GatewayMessage decode(ByteBuf byteBuf) throws MessageCodecException {
    try (InputStream stream = new ByteBufInputStream(byteBuf, true)) {
      JsonParser jp = jsonFactory.createParser(stream);
      GatewayMessage.Builder result = GatewayMessage.builder();

      JsonToken current = jp.nextToken();
      if (current != JsonToken.START_OBJECT) {
        throw new MessageCodecException("Root should be object", null);
      }
      long dataStart = 0;
      long dataEnd = 0;
      while ((jp.nextToken()) != JsonToken.END_OBJECT) {
        String fieldName = jp.getCurrentName();
        current = jp.nextToken();
        if (current == VALUE_NULL) {
          continue;
        }

        if (fieldName.equals(DATA_FIELD)) {
          dataStart = jp.getTokenLocation().getByteOffset();
          if (current.isScalarValue()) {
            if (!current.isNumeric() && !current.isBoolean()) {
              jp.getValueAsString();
            }
          } else if (current.isStructStart()) {
            jp.skipChildren();
          }
          dataEnd = jp.getCurrentLocation().getByteOffset();
        } else {
          // headers
          result.header(fieldName, jp.getValueAsString());
        }
      }
      // data
      if (dataEnd > dataStart) {
        result.data(byteBuf.copy((int) dataStart, (int) (dataEnd - dataStart)));
      }
      return result.build();
    } catch (Throwable ex) {
      throw new MessageCodecException("Failed to decode message", ex);
    }
  }
812314
@Pure
	@Inline(value = "Base64Coder.decode(($1).toCharArray())", imported = {Base64Coder.class})
	public static byte[] decode(String string) {
		return decode(string.toCharArray());
	}
415529
protected V decode(String value) {
    return valueSerializer.decode(BaseEncoding.base16().decode(value));
  }
119047
public static Binary fromBase64(String base64) {
        byte[] arr = Base64.decode(base64);
        return Binary.wrap(arr);
    }
892871
@Deprecated
    public static String decode(String string)
    {
        try {
            byte[] bytes = Base64.decode(string.toCharArray());
            return new String(bytes, DEFAULT_ENCODING);
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            return null;
        }
    }
257474
public static Object toObject(String xml, String encoding, Class<?> cls) throws UnmarshalException {
		
		if (xml == null || xml.trim().equals("")) {
			throw new UnmarshalException("XML String is Empty");
		}
		
		Object object = null;
		
		Unmarshaller bind = null;
		
		try {
			bind = new XmlUnmarshaller(new ByteArrayInputStream(xml.getBytes(encoding)));
		} catch (UnsupportedEncodingException e) {
			throw new UnmarshalException(e);
		}
		
		if (bind != null) {
			bind.setRootClass(cls);
			object = bind.unmarshal();
		}
		
		return object;
	}
877742
protected E decode(String element) {
    return elementSerializer.decode(BaseEncoding.base16().decode(element));
  }
1024916
public Object unmarshalRootElement(Reader inStream, BaseXmlTrxMessageIn soapTrxMessage) throws Exception
    {
    	String xml = Utility.transferURLStream(null, null, inStream, null);
    	soapTrxMessage.getMessage().setXML(xml);

    	return xml;
    }