LyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioNCkNvcHlyaWdodCAoYykgMjAwMCwgMjAwMSwgMjAwMiBJQk0gQ29ycC4gYW5kIG90aGVycy4NCkFsbCByaWdodHMgcmVzZXJ2ZWQuIKAgVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscw0KYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgQ29tbW9uIFB1YmxpYyBMaWNlbnNlIHYwLjUNCndoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0DQpodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MDUuaHRtbA0KoA0KQ29udHJpYnV0b3JzOg0KICAgICBJQk0gQ29ycG9yYXRpb24gLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24NCioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovDQpwYWNrYWdlIG9yZy5lY2xpcHNlLmpkdC5jb3JlOw0KDQppbXBvcnQgb3JnLmVjbGlwc2UuamR0LmludGVybmFsLmNvcmUuKjsNCg0KLyoqDQogKiBDb21tb24gcHJvdG9jb2wgZm9yIEphdmEgZWxlbWVudHMgdGhhdCBjYW4gYmUgbWVtYmVycyBvZiB0eXBlcy4NCiAqIFRoaXMgc2V0IGNvbnNpc3RzIG9mIDxjb2RlPklUeXBlPC9jb2RlPiwgPGNvZGU+SU1ldGhvZDwvY29kZT4sIA0KICogPGNvZGU+SUZpZWxkPC9jb2RlPiwgYW5kIDxjb2RlPklJbml0aWFsaXplcjwvY29kZT4uDQogKiA8cD4NCiAqIFRoaXMgaW50ZXJmYWNlIGlzIG5vdCBpbnRlbmRlZCB0byBiZSBpbXBsZW1lbnRlZCBieSBjbGllbnRzLg0KICogPC9wPg0KICovDQpwdWJsaWMgaW50ZXJmYWNlIElNZW1iZXIgZXh0ZW5kcyBJSmF2YUVsZW1lbnQsIElTb3VyY2VSZWZlcmVuY2UsIElTb3VyY2VNYW5pcHVsYXRpb24gew0KLyoqDQogKiBSZXR1cm5zIHRoZSBjbGFzcyBmaWxlIGluIHdoaWNoIHRoaXMgbWVtYmVyIGlzIGRlY2xhcmVkLCBvciA8Y29kZT5udWxsPC9jb2RlPg0KICogaWYgdGhpcyBtZW1iZXIgaXMgbm90IGRlY2xhcmVkIGluIGEgY2xhc3MgZmlsZSAoZm9yIGV4YW1wbGUsIGEgc291cmNlIHR5cGUpLg0KICogVGhpcyBpcyBhIGhhbmRsZS1vbmx5IG1ldGhvZC4NCiAqLw0KSUNsYXNzRmlsZSBnZXRDbGFzc0ZpbGUoKTsNCi8qKg0KICogUmV0dXJucyB0aGUgY29tcGlsYXRpb24gdW5pdCBpbiB3aGljaCB0aGlzIG1lbWJlciBpcyBkZWNsYXJlZCwgb3IgPGNvZGU+bnVsbDwvY29kZT4NCiAqIGlmIHRoaXMgbWVtYmVyIGlzIG5vdCBkZWNsYXJlZCBpbiBhIGNvbXBpbGF0aW9uIHVuaXQgKGZvciBleGFtcGxlLCBhIGJpbmFyeSB0eXBlKS4NCiAqIFRoaXMgaXMgYSBoYW5kbGUtb25seSBtZXRob2QuDQogKi8NCklDb21waWxhdGlvblVuaXQgZ2V0Q29tcGlsYXRpb25Vbml0KCk7DQovKioNCiAqIFJldHVybnMgdGhlIHR5cGUgaW4gd2hpY2ggdGhpcyBtZW1iZXIgaXMgZGVjbGFyZWQsIG9yIDxjb2RlPm51bGw8L2NvZGU+DQogKiBpZiB0aGlzIG1lbWJlciBpcyBub3QgZGVjbGFyZWQgaW4gYSB0eXBlIChmb3IgZXhhbXBsZSwgYSB0b3AtbGV2ZWwgdHlwZSkuDQogKiBUaGlzIGlzIGEgaGFuZGxlLW9ubHkgbWV0aG9kLg0KICovDQpJVHlwZSBnZXREZWNsYXJpbmdUeXBlKCk7DQovKioNCiAqIFJldHVybnMgdGhlIG1vZGlmaWVyIGZsYWdzIGZvciB0aGlzIG1lbWJlci4gVGhlIGZsYWdzIGNhbiBiZSBleGFtaW5lZCB1c2luZyBjbGFzcw0KICogPGNvZGU+RmxhZ3M8L2NvZGU+Lg0KICoNCiAqIEBleGNlcHRpb24gSmF2YU1vZGVsRXhjZXB0aW9uIGlmIHRoaXMgZWxlbWVudCBkb2VzIG5vdCBleGlzdCBvciBpZiBhbg0KICogICAgICBleGNlcHRpb24gb2NjdXJzIHdoaWxlIGFjY2Vzc2luZyBpdHMgY29ycmVzcG9uZGluZyByZXNvdXJjZS4NCiAqDQogKiBAc2VlIEZsYWdzDQogKi8NCmludCBnZXRGbGFncygpIHRocm93cyBKYXZhTW9kZWxFeGNlcHRpb247DQovKioNCiAqIFJldHVybnMgdGhlIHNvdXJjZSByYW5nZSBvZiB0aGlzIG1lbWJlcidzIHNpbXBsZSBuYW1lLA0KICogb3IgPGNvZGU+bnVsbDwvY29kZT4gaWYgdGhpcyBtZW1iZXIgZG9lcyBub3QgaGF2ZSBhIG5hbWUNCiAqIChmb3IgZXhhbXBsZSwgYW4gaW5pdGlhbGl6ZXIpLCBvciBpZiB0aGlzIG1lbWJlciBkb2VzIG5vdCBoYXZlDQogKiBhc3NvY2lhdGVkIHNvdXJjZSBjb2RlIChmb3IgZXhhbXBsZSwgYSBiaW5hcnkgdHlwZSkuDQogKg0KICogQGV4Y2VwdGlvbiBKYXZhTW9kZWxFeGNlcHRpb24gaWYgdGhpcyBlbGVtZW50IGRvZXMgbm90IGV4aXN0IG9yIGlmIGFuDQogKiAgICAgIGV4Y2VwdGlvbiBvY2N1cnMgd2hpbGUgYWNjZXNzaW5nIGl0cyBjb3JyZXNwb25kaW5nIHJlc291cmNlLg0KICovDQpJU291cmNlUmFuZ2UgZ2V0TmFtZVJhbmdlKCkgdGhyb3dzIEphdmFNb2RlbEV4Y2VwdGlvbjsNCi8qKg0KICogUmV0dXJucyB3aGV0aGVyIHRoaXMgbWVtYmVyIGlzIGZyb20gYSBjbGFzcyBmaWxlLg0KICogVGhpcyBpcyBhIGhhbmRsZS1vbmx5IG1ldGhvZC4NCiAqDQogKiBAcmV0dXJuIDxjb2RlPnRydWU8L2NvZGU+IGlmIGZyb20gYSBjbGFzcyBmaWxlLCBhbmQgPGNvZGU+ZmFsc2U8L2NvZGU+IGlmDQogKiAgIGZyb20gYSBjb21waWxhdGlvbiB1bml0DQogKi8NCmJvb2xlYW4gaXNCaW5hcnkoKTsNCn0NCg==