/* vim: set sw=4 sts=4 et foldmethod=syntax : */

/*
 * Copyright (c) 2007 Piotr Jaroszyński <peper@gentoo.org>
 *
 * This file is part of the Paludis package manager. Paludis is free software;
 * you can redistribute it and/or modify it under the terms of the GNU General
 * Public License version 2, as published by the Free Software Foundation.
 *
 * Paludis is distributed in the hope that it will be useful, but WITHOUT ANY
 * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License along with
 * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
 * Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <paludis_python.hh>

#include <paludis/version_metadata.hh>

namespace p = paludis;
namespace pp = paludis::python;
namespace bp = boost::python;

void expose_version_metadata()
{
    bp::register_ptr_to_python<std::tr1::shared_ptr<const p::VersionMetadata> >();
    bp::class_<p::VersionMetadata, boost::noncopyable>
        vm("VersionMetadata",
                "Version metadata.",
                bp::no_init
          );
    vm.def_readonly("slot", &p::VersionMetadata::slot,
            "[ro] SlotName"
            );
    vm.def_readonly("homepage", &p::VersionMetadata::homepage,
            "[ro] string"
            );
    vm.def_readonly("description", &p::VersionMetadata::description,
            "[ro] string"
            );
    vm.def_readonly("eapi", &p::VersionMetadata::eapi,
            "[ro] string"
            );
    //vm.add_property("ebuild_interface", bp::make_getter(&p::VersionMetadata::ebuild_interface,
    //            bp::return_internal_reference<1>()),
    //        "[ro] EbuildInterface"
    //        );
    vm.def_readonly("ebuild_interface", &p::VersionMetadata::ebuild_interface,
            "[ro] EbuildInterface"
            );
    vm.def_readonly("ebin_interface", &p::VersionMetadata::ebin_interface,
            "[ro] EbinInterface"
            );
    vm.def_readonly("cran_interface", &p::VersionMetadata::cran_interface,
            "[ro] CRANInterface"
            );
    vm.def_readonly("deps_interface", &p::VersionMetadata::deps_interface,
            "[ro] DepsInterface"
            );
    vm.def_readonly("origins_interface", &p::VersionMetadata::origins_interface,
            "[ro] OriginsInterface"
            );
    vm.def_readonly("virtual_interface", &p::VersionMetadata::virtual_interface,
            "[ro] VirtualInterface"
            );
    vm.def_readonly("license_interface", &p::VersionMetadata::license_interface,
            "[ro] LicenseInterface"
            );

    bp::register_ptr_to_python<p::VersionMetadataEbuildInterface *>();
    bp::class_<p::VersionMetadataEbuildInterface, boost::noncopyable>
        ebuild_i("VersionMetadataEbuildInterface",
                "Version metadata for ebuilds.",
                bp::no_init
                );
    ebuild_i.def_readonly("provide_string", &p::VersionMetadataEbuildInterface::provide_string,
            "[ro] string"
            );
    ebuild_i.def_readonly("src_uri_string", &p::VersionMetadataEbuildInterface::src_uri_string,
            "[ro] string"
            );
    ebuild_i.def_readonly("restrict_string", &p::VersionMetadataEbuildInterface::restrict_string,
            "[ro] string"
            );
    ebuild_i.def_readonly("keywords_string", &p::VersionMetadataEbuildInterface::keywords_string,
            "[ro] string"
            );
    ebuild_i.def_readonly("eclass_keywords", &p::VersionMetadataEbuildInterface::eclass_keywords,
            "[ro] string"
            );
    ebuild_i.def_readonly("iuse", &p::VersionMetadataEbuildInterface::iuse,
            "[ro] string"
            );
    ebuild_i.def_readonly("inherited", &p::VersionMetadataEbuildInterface::inherited,
            "[ro] string"
            );

    bp::register_ptr_to_python<p::VersionMetadataEbinInterface *>();
    bp::class_<p::VersionMetadataEbinInterface, boost::noncopyable>
        ebin_i("VersionMetadataEbinInterface",
                "Version metadata for Ebins.",
                bp::no_init
              );
    ebin_i.def_readonly("bin_uri_string", &p::VersionMetadataEbinInterface::bin_uri_string,
            "[ro] string"
            );

    bp::register_ptr_to_python<p::VersionMetadataCRANInterface *>();
    bp::class_<p::VersionMetadataCRANInterface, boost::noncopyable>
        cran_i("VersionMetadataCRANInterface",
                "Version metadata for CRAN packages.",
                bp::no_init
                );
    cran_i.def_readonly("keywords", &p::VersionMetadataCRANInterface::keywords,
            "[ro] string"
            );
    cran_i.def_readonly("package", &p::VersionMetadataCRANInterface::package,
            "[ro] string"
            );
    cran_i.def_readonly("version", &p::VersionMetadataCRANInterface::version,
            "[ro] string"
            );

    bp::register_ptr_to_python<p::VersionMetadataDepsInterface *>();
    bp::class_<p::VersionMetadataDepsInterface, boost::noncopyable>
        deps_i("VersionMetadataDepsInterface",
                "Dependency data for VersionMetadata.",
                bp::no_init
                );
    deps_i.def_readonly("build_depend_string", &p::VersionMetadataDepsInterface::build_depend_string,
            "[ro] string"
            );
    deps_i.def_readonly("run_depend_string", &p::VersionMetadataDepsInterface::run_depend_string,
            "[ro] string"
            );
    deps_i.def_readonly("post_depend_string", &p::VersionMetadataDepsInterface::post_depend_string,
            "[ro] string"
            );
    deps_i.def_readonly("suggested_depend_string", &p::VersionMetadataDepsInterface::suggested_depend_string,
            "[ro] string"
            );
    deps_i.add_property("build_depend", &p::VersionMetadataDepsInterface::build_depend,
            "[ro] DepSpec"
            );
    deps_i.add_property("run_depend", &p::VersionMetadataDepsInterface::run_depend,
            "[ro] DepSpec"
            );
    deps_i.add_property("post_depend", &p::VersionMetadataDepsInterface::post_depend,
            "[ro] DepSpec"
            );
    deps_i.add_property("suggested_depend", &p::VersionMetadataDepsInterface::suggested_depend,
            "[ro] DepSpec"
            );

    bp::register_ptr_to_python<p::VersionMetadataOriginsInterface *>();
    bp::class_<p::VersionMetadataOriginsInterface, boost::noncopyable>
        origins_i("VersionMetadataOriginsInterface",
                "Origins data for VersionMetadata.",
                bp::no_init
                );
    origins_i.add_property("source", bp::make_getter(&p::VersionMetadataOriginsInterface::source,
                bp::return_value_policy<bp::return_by_value>()),
            "[ro] PackageDatabaseEntry"
            );
    origins_i.add_property("binary", bp::make_getter(&p::VersionMetadataOriginsInterface::binary,
                bp::return_value_policy<bp::return_by_value>()),
            "[ro] PackageDatabaseEntry"
            );

    bp::register_ptr_to_python<p::VersionMetadataVirtualInterface *>();
    bp::class_<p::VersionMetadataVirtualInterface, boost::noncopyable>
        virtual_i("VersionMetadataVirtualInterface",
                "Version metadata for virtual packages.",
                bp::no_init
                );
    virtual_i.def_readonly("virtual_for", &p::VersionMetadataVirtualInterface::virtual_for,
            "[ro] PackageDatabaseEntry"
            );

    bp::register_ptr_to_python<p::VersionMetadataLicenseInterface *>();
    bp::class_<p::VersionMetadataLicenseInterface, boost::noncopyable>
        license_i("VersionMetadataLicenseInterface",
                "License data for VersionMetadata.",
                bp::no_init
                );
    license_i.def_readonly("license_string", &p::VersionMetadataLicenseInterface::license_string,
            "[ro] string"
            );
}