Creates a new dependency information that is populated using the argument map.

Indicates whether some other object is "equal to" this one.

The equals method implements an equivalence relation on non-null object references:

• It is reflexive: for any non-null reference value x, x.equals(x) should return true.
• It is symmetric: for any non-null reference values x and y, x.equals(y) should return true if and only if y.equals(x) returns true.
• It is transitive: for any non-null reference values x, y, and z, if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) should return true.
• It is consistent: for any non-null reference values x and y, multiple invocations of x.equals(y) consistently return true or consistently return false, provided no information used in equals comparisons on the objects is modified.
• For any non-null reference value x, x.equals(null) should return false.

The equals method for class Object implements the most discriminating possible equivalence relation on objects; that is, for any non-null reference values x and y, this method returns true if and only if x and y refer to the same object (x == y has the value true).

Note that it is generally necessary to override the hashCode method whenever this method is overridden, so as to maintain the general contract for the hashCode method, which states that equal objects must have equal hash codes.

Gets the dependency information.

Returns a hash code value for the object. This method is supported for the benefit of hash tables such as those provided by HashMap.

The general contract of hashCode is:

• Whenever it is invoked on the same object more than once during an execution of a Java application, the hashCode method must consistently return the same integer, provided no information used in equals comparisons on the object is modified. This integer need not remain consistent from one execution of an application to another execution of the same application.
• If two objects are equal according to the equals(Object) method, then calling the hashCode method on each of the two objects must produce the same integer result.
• It is not required that if two objects are unequal according to the Object.equals(Object) method, then calling the hashCode method on each of the two objects must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal objects may improve the performance of hash tables.

As much as is reasonably practical, the hashCode method defined by class Object does return distinct integers for distinct objects. (This is typically implemented by converting the internal address of the object into an integer, but this implementation technique is not required by the Java™ programming language.)

Checks if this dependency object is empty.

The object implements the readExternal method to restore its contents by calling the methods of DataInput for primitive types and readObject for objects, strings and arrays. The readExternal method must read the values in the same sequence and with the same types as were written by writeExternal.

Parses the data from the argument input stream and constructs a new dependency information object.

The format of the input is the following:

 <dependency-uri>
 	<dependency-kind>[,<dependency-kind>]*
 		[entries: <wildcard>[;<wildcard>]*]?
 		[<meta-key>: <meta-value>]*
 	[SHA-256: <hexa>]?
 	[SHA-1: <hexa>]?
 	[MD5: <hexa>]?
 	<source-attachment|documentation-attachment>: <uri>
 		[SHA-256: <hexa>]?
 		[SHA-1: <hexa>]?
 		[MD5: <hexa>]?
 		[entries: <wildcard>[;<wildcard>]*]?
 		[target: <wildcard>[;<wildcard>]*]?
 		[<meta-key>: <meta-value>]*
 

The format itself is somewhat derived from the format defined by BundleDependencyInformation.readFrom(InputStream, BundleIdentifier). Please refer to that to get detailed information about indenting and formatting.

The format consists of top level URI blocks that define an external dependency. The file format doesn't impose any restriction on the scheme of the URI, however, some bundle storages may do so.

Each dependency declaration can have the following sub-entries:

• Dependency delcaration. One or multiple kinds are associated with a dependency. In addition to that, arbitrary meta-data can be declared for the dependencies.

  The special entries meta-data specifies that the subject of the dependency should be taken from the declared URI by interpreting it as a ZIP archive. The entries meta-data declare one or more wildcards that are used to select the entries in the archive.

  The special / wildcard in the entries meta-data will signal that the resource ZIP archive should be used. This is the default behaviour.

  The dependency kinds and other meta-data are interpreted the same way as in BundleDependency.

• Hash declarations. SHA-256, SHA-1 and MD5 hashes can be declared for the referenced resource. The repository will verify that the contents of the external resource matches the specified hashes.

  This can be useful to prevent unexpected changes to the external resources. Some bundle storages may require you to specify hashes to validate the bundle.

• Source and documentation attachments. The source-attachment and documentation-attachment entries can be used to declare additional meta-resources that are associated with the external resource. The hash and entries values work the same way as previously. The target meta-data specify the archive entries in the main resource for which the attachments are declared.

An example:

 https://example.com/external.jar
 	classpath
 	SHA-256: 1234567890123456789012345678901234567890123456789012345678901234
 

The above declares an external classpath dependency on https://example.com/external.jar and expects it to have the SHA-256 hash as declared above.

Using the entries attribute:

 https://example.com/external.jar
 	classpath
 		entries: lib/*.jar
 

The above is a dependency that loads all jar files in the lib directory of the specified resource. Note that the external.jar itself won't be part of the classpath! To do that, use the / special entry:

 https://example.com/external.jar
 	classpath
 		entries: /;lib/*.jar
 

The addition of the / value to the entries property will cause the external.jar to be part of the classpath dependency as well as all the specified libraries in it.

Returns a string representation of the object. In general, the toString method returns a string that "textually represents" this object. The result should be a concise but informative representation that is easy for a person to read. It is recommended that all subclasses override this method.

The toString method for class Object returns a string consisting of the name of the class of which the object is an instance, the at-sign character `@', and the unsigned hexadecimal representation of the hash code of the object. In other words, this method returns a string equal to the value of:

 getClass().getName() + '@' + Integer.toHexString(hashCode())
 

The object implements the writeExternal method to save its contents by calling the methods of DataOutput for its primitive values or calling the writeObject method of ObjectOutput for objects, strings, and arrays.