Key | Value |
---|---|
FileName | ./usr/share/perl5/XML/Compile/Translate/Template.pm |
FileSize | 28399 |
MD5 | 403EF4B99C975EA51471EC97457369E6 |
SHA-1 | 18930EDB1219CDDD588962558CEA69891E82F8BE |
SHA-256 | 7B635C4193F00C7B800DAE2CA0E6E1E4B9E0DCBCA65F9FCE5F7806A3F1AE40B6 |
SSDEEP | 768:jZHp3NeUCYanDowknwZ7QPwuKiglFd3aOqg/LuH4mtAOBBgZpa1mBPOm:1Hp3NeUCYanDoPna7QPDKiEFdaOt/mro |
TLSH | T1C7D28558706B667041E391341FCBD940AE6A8053075CD940BBEC92AEAFC1B72D4E9BFD |
hashlookup:parent-total | 16 |
hashlookup:trust | 100 |
The searched file hash is included in 16 parent files which include package known and seen by metalookup. A sample is included below:
Key | Value |
---|---|
FileSize | 225876 |
MD5 | A4819C7043BDB776182EA9B5AD6BB7CC |
PackageDescription | Perl module to translate between XML and Perl based on XML schemas Many (professional) applications process XML messages based on a formal specification, expressed in XML Schemas. XML::Compile translates between XML and Perl with the help of such schemas. Your Perl program only handles a tree of nested HASHes and ARRAYs, and does not need to understand namespaces and other general XML and schema nastiness. |
PackageMaintainer | Debian Perl Group <pkg-perl-maintainers@lists.alioth.debian.org> |
PackageName | libxml-compile-perl |
PackageSection | perl |
PackageVersion | 1.63-2 |
SHA-1 | 0EE4F09A352EEBD07B905828E1E87901ED00031B |
SHA-256 | E373504B5EF8ECF5194F2A6D50E58DF460320D023640B41A9457A54958B42FFE |
Key | Value |
---|---|
MD5 | 970AE6D24A33BC359062D96EA720AAB6 |
PackageArch | noarch |
PackageDescription | Many (professional) applications process XML messages based on a formal specification, expressed in XML Schemas. XML::Compile translates between XML and Perl with the help of such schemas. Your Perl program only handles a tree of nested HASHes and ARRAYs, and does not need to understand namespaces and other general XML and schema nastiness. Three serious WARNINGS: * * |
PackageMaintainer | umeabot <umeabot> |
PackageName | perl-XML-Compile |
PackageRelease | 3.mga9 |
PackageVersion | 1.630.0 |
SHA-1 | 0FBBB89B10BF64ABACB68A7D335EC454BB882DDF |
SHA-256 | 679CDBA539EC028D36B9FCB6AD2794C251E3FDC5FBFA5B6BC6883E5C2DC858A5 |
Key | Value |
---|---|
MD5 | A501421CB861092E174BFAC521B30EF4 |
PackageArch | noarch |
PackageDescription | Many (professional) applications process XML messages based on a formal specification, expressed in XML Schemas. XML::Compile translates between XML and Perl with the help of such schemas. Your Perl program only handles a tree of nested HASHes and ARRAYs, and does not need to understand namespaces and other general XML and schema nastiness. Three serious WARNINGS: * The focus is on *data-centric XML*, which means that mixed elements are not handler automatically: you need to work with XML::LibXML nodes yourself, on these spots. * The *data is not strictly validated*, still a large number of compile-time errors can be reported. Values are checked quite thoroughly. Structure as well. * Imports and includes, as used in the schemas, are NOT performed automatically. Schema's and such are NOT collected from internet dynamically; you have to call XML::Compile::Schema::importDefinitions() explicitly with filenames of locally stored copies. Includes do only work if they have a targetNamespace defined, which is the same as that of the schema it is included into. |
PackageName | perl-XML-Compile |
PackageRelease | lp152.1.1 |
PackageVersion | 1.63 |
SHA-1 | 204E393FC4D981C5BF45AF74BD6FB6A27CCBA342 |
SHA-256 | 62DCE93917C6FB9EAD9A8A4F3F63F1BB290E1210F9A279B784FF680E33EAB211 |
Key | Value |
---|---|
MD5 | 7D993EE94589C42724463EC4D8E120AA |
PackageArch | noarch |
PackageDescription | Many (professional) applications process XML messages based on a formal specification, expressed in XML Schemas. XML::Compile translates between XML and Perl with the help of such schemas. Your Perl program only handles a tree of nested HASHes and ARRAYs, and does not need to understand namespaces and other general XML and schema nastiness. Three serious WARNINGS: * * |
PackageMaintainer | umeabot <umeabot> |
PackageName | perl-XML-Compile |
PackageRelease | 2.mga8 |
PackageVersion | 1.630.0 |
SHA-1 | 22C135D352A6E5DE4219BB6759C463B40B379901 |
SHA-256 | 0741C7E7AC01DB0684322FF02509CCF5EAFC4995E78C07DDD17B0BFAA0848180 |
Key | Value |
---|---|
MD5 | DFFE658C2EE844C3684CFF734F2B5B7A |
PackageArch | noarch |
PackageDescription | Many (professional) applications process XML messages based on a formal specification, expressed in XML Schemas. XML::Compile translates between XML and Perl with the help of such schemas. Your Perl program only handles a tree of nested HASHes and ARRAYs, and does not need to understand namespaces and other general XML and schema nastiness. Three serious WARNINGS: * The focus is on *data-centric XML*, which means that mixed elements are not handler automatically: you need to work with XML::LibXML nodes yourself, on these spots. * The *data is not strictly validated*, still a large number of compile-time errors can be reported. Values are checked quite thoroughly. Structure as well. * Imports and includes, as used in the schemas, are NOT performed automatically. Schema's and such are NOT collected from internet dynamically; you have to call XML::Compile::Schema::importDefinitions() explicitly with filenames of locally stored copies. Includes do only work if they have a targetNamespace defined, which is the same as that of the schema it is included into. |
PackageName | perl-XML-Compile |
PackageRelease | 1.47 |
PackageVersion | 1.63 |
SHA-1 | 25C2A5E26E61ADCC2BE9D993D3445392B1E5EB48 |
SHA-256 | 97A5D9379DB3E90FD276DDBEF04FCCD2F8F920300CA9D0389644ACD2CDA2417E |
Key | Value |
---|---|
MD5 | BC97E5CA482EEC1D7371D1672D77DABD |
PackageArch | noarch |
PackageDescription | Many (professional) applications process XML messages based on a formal specification, expressed in XML Schemas. XML::Compile translates between XML and Perl with the help of such schemas. Your Perl program only handles a tree of nested HASHes and ARRAYs, and does not need to understand namespaces and other general XML and schema nastiness. Three serious WARNINGS: * The focus is on *data-centric XML*, which means that mixed elements are not handler automatically: you need to work with XML::LibXML nodes yourself, on these spots. * The *data is not strictly validated*, still a large number of compile-time errors can be reported. Values are checked quite thoroughly. Structure as well. * Imports and includes, as used in the schemas, are NOT performed automatically. Schema's and such are NOT collected from internet dynamically; you have to call XML::Compile::Schema::importDefinitions() explicitly with filenames of locally stored copies. Includes do only work if they have a targetNamespace defined, which is the same as that of the schema it is included into. |
PackageName | perl-XML-Compile |
PackageRelease | 1.2 |
PackageVersion | 1.63 |
SHA-1 | 26D2CFC6C0C50B222F861C49145AFEC929B44FC8 |
SHA-256 | AEA8FF90A989E3AA9008413F748B63261BA7E857FF92976E283F715899F8192E |
Key | Value |
---|---|
MD5 | A54DA1E1F6577EF6A240E4ED493B10B4 |
PackageArch | noarch |
PackageDescription | Many (professional) applications process XML messages based on a formal specification, expressed in XML Schemas. XML::Compile translates between XML and Perl with the help of such schemas. Your Perl program only handles a tree of nested HASHes and ARRAYs, and does not need to understand namespaces and other general XML and schema nastiness. Three serious WARNINGS: * The focus is on *data-centric XML*, which means that mixed elements are not handler automatically: you need to work with XML::LibXML nodes yourself, on these spots. * The *data is not strictly validated*, still a large number of compile-time errors can be reported. Values are checked quite thoroughly. Structure as well. * Imports and includes, as used in the schemas, are NOT performed automatically. Schema's and such are NOT collected from internet dynamically; you have to call XML::Compile::Schema::importDefinitions() explicitly with filenames of locally stored copies. Includes do only work if they have a targetNamespace defined, which is the same as that of the schema it is included into. |
PackageName | perl-XML-Compile |
PackageRelease | lp153.1.10 |
PackageVersion | 1.63 |
SHA-1 | 3B75274485732C5FA0DFF7435197FF62D2EC6217 |
SHA-256 | 3B84B425EBC1F0480C22A90E6D36BF8D085A0AC0195BADE5799080DDC8984437 |
Key | Value |
---|---|
MD5 | 4D83E114DEE25AE03ADBBF61C46F6C5F |
PackageArch | noarch |
PackageDescription | Many (professional) applications process XML messages based on a formal specification, expressed in XML Schemas. XML::Compile translates between XML and Perl with the help of such schemas. Your Perl program only handles a tree of nested HASHes and ARRAYs, and does not need to understand namespaces and other general XML and schema nastiness. Three serious WARNINGS: * The focus is on *data-centric XML*, which means that mixed elements are not handler automatically: you need to work with XML::LibXML nodes yourself, on these spots. * The *data is not strictly validated*, still a large number of compile-time errors can be reported. Values are checked quite thoroughly. Structure as well. * Imports and includes, as used in the schemas, are NOT performed automatically. Schema's and such are NOT collected from internet dynamically; you have to call XML::Compile::Schema::importDefinitions() explicitly with filenames of locally stored copies. Includes do only work if they have a targetNamespace defined, which is the same as that of the schema it is included into. |
PackageName | perl-XML-Compile |
PackageRelease | lp150.1.1 |
PackageVersion | 1.63 |
SHA-1 | 3CEF37275AA142C890D6604ADF581BBC41AEB5A9 |
SHA-256 | A155FDCC14AFEFF192BC7258C9384C5608DBB0DA24B33D13A74FB7DE26E5AE9A |
Key | Value |
---|---|
MD5 | 86CFAFEC931D4070D92E19218FA59FA3 |
PackageArch | noarch |
PackageDescription | Many (professional) applications process XML messages based on a formal specification, expressed in XML Schemas. XML::Compile translates between XML and Perl with the help of such schemas. Your Perl program only handles a tree of nested HASHes and ARRAYs, and does not need to understand namespaces and other general XML and schema nastiness. Three serious WARNINGS: * The focus is on *data-centric XML*, which means that mixed elements are not handler automatically: you need to work with XML::LibXML nodes yourself, on these spots. * The *data is not strictly validated*, still a large number of compile-time errors can be reported. Values are checked quite thoroughly. Structure as well. * Imports and includes, as used in the schemas, are NOT performed automatically. Schema's and such are NOT collected from internet dynamically; you have to call XML::Compile::Schema::importDefinitions() explicitly with filenames of locally stored copies. Includes do only work if they have a targetNamespace defined, which is the same as that of the schema it is included into. |
PackageName | perl-XML-Compile |
PackageRelease | 1.1 |
PackageVersion | 1.63 |
SHA-1 | 541AB915BE8CE6AEAC98D45B7B80484F83CDBDA3 |
SHA-256 | AD96F3E7E48103525D51F6EC5549C6125B586A018A80BC6587546807618EE47C |
Key | Value |
---|---|
MD5 | BB75B074952253404593CD41FF7B2787 |
PackageArch | noarch |
PackageDescription | Many (professional) applications process XML messages based on a formal specification, expressed in XML Schemas. XML::Compile translates between XML and Perl with the help of such schemas. Your Perl program only handles a tree of nested HASHes and ARRAYs, and does not need to understand namespaces and other general XML and schema nastiness. Three serious WARNINGS: * The focus is on *data-centric XML*, which means that mixed elements are not handler automatically: you need to work with XML::LibXML nodes yourself, on these spots. * The *data is not strictly validated*, still a large number of compile-time errors can be reported. Values are checked quite thoroughly. Structure as well. * Imports and includes, as used in the schemas, are NOT performed automatically. Schema's and such are NOT collected from internet dynamically; you have to call XML::Compile::Schema::importDefinitions() explicitly with filenames of locally stored copies. Includes do only work if they have a targetNamespace defined, which is the same as that of the schema it is included into. |
PackageName | perl-XML-Compile |
PackageRelease | 1.38 |
PackageVersion | 1.63 |
SHA-1 | 6E8405978A17FA99FB4E095ECF273402B867C078 |
SHA-256 | 8AE5657129D61BEC48FFA4D4ED72476873DBDEA42B69647F294761216F77D6C4 |