/* 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/name.hh>

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

void expose_name()
{
    static pp::register_exception<p::PackageNamePartError>
        PackageNamePartError("PackageNamePartError");
    static pp::register_exception<p::CategoryNamePartError>
        CategoryNamePartError("CategoryNamePartError");
    static pp::register_exception<p::QualifiedPackageNameError>
        QualifiedPackageNameError("QualifiedPackageNameError");
    static pp::register_exception<p::UseFlagNameError>
        UseFlagNameError("UseFlagNameError");
    static pp::register_exception<p::SlotNameError>
        SlotNameError("SlotNameError");
    static pp::register_exception<p::RepositoryNameError>
        RepositoryNameError("RepositoryNameError");
    static pp::register_exception<p::KeywordNameError>
        KeywordNameError("KeywordNameError");
    static pp::register_exception<p::SetNameError>
        SetNameError("SetNameError");

    pp::class_validated<p::PackageNamePart>
        pnp("PackageNamePart",
                "Holds a string that is a valid name for the package part of a QualifiedPackageName."
           );
    pp::register_shared_ptrs_to_python<p::PackageNamePart>();

    pp::class_collection<p::PackageNamePartCollection>
        pnpc("PackageNamePartCollection",
                "Iterable collection of PackageNamePart instances."
            );

    pp::class_validated<p::CategoryNamePart>
        cnp("CategoryNamePart",
                "Holds a string that is a valid name for the category part of a QualifiedPackageName."
           );
    // CategoryNamePart + PackageNamePart = QualifiedPackageName
    cnp.def(bp::self + bp::other<p::PackageNamePart>());
    pp::register_shared_ptrs_to_python<p::CategoryNamePart>();

    pp::class_collection<p::CategoryNamePartCollection>
        cnpc("CategoryNamePartCollection",
                "Iterable collection of CategoryNamePart instances."
            );

    pp::class_validated<p::UseFlagName>
        ufn("UseFlagName",
                "Holds a string that is a valid name for a USE flag."
           );

    pp::class_collection<p::UseFlagNameCollection>
        ufnc("UseFlagNameCollection",
                "Iterable collection of UseFlagName instances."
            );

    pp::class_validated<p::SlotName>
        sln("SlotName",
                "Holds a string that is a valid name for a SLOT."
           );
    pp::register_shared_ptrs_to_python<p::SlotName>();

    pp::class_validated<p::RepositoryName>
        rn("RepositoryName",
                "Holds a string that is a valid name for a Repository."
          );
    pp::register_shared_ptrs_to_python<p::RepositoryName>();

    pp::class_collection<p::RepositoryNameCollection>
        rnc("RepositoryNameCollection",
                "Iterable collection of RepositoryName instances."
            );

    pp::class_validated<p::KeywordName>
        kn("KeywordName",
                "Holds a string that is a valid name for a KEYWORD."
          );

    pp::class_validated<p::SetName>
        stn("SetName",
                "Holds a string that is a valid name for a set."
           );

    pp::class_collection<p::SetNameCollection>
        sc("SetNameCollection",
                "Iterable of SetName\n"
                "A collection of set names."
          );

    pp::register_shared_ptrs_to_python<p::QualifiedPackageName>();
    bp::class_<p::QualifiedPackageName>
        qpn("QualifiedPackageName",
                "Represents a category plus package name.",
                bp::init<const std::string &>("__init__(string)")
           );
    qpn.def(bp::init<const p::CategoryNamePart &, const p::PackageNamePart &>());
    qpn.def_readwrite("category", &p::QualifiedPackageName::category);
    qpn.def_readwrite("package", &p::QualifiedPackageName::package);
    qpn.def("__cmp__", &p::QualifiedPackageName::compare);
    qpn.def(bp::self_ns::str(bp::self));
    bp::implicitly_convertible<std::string, p::QualifiedPackageName>();

    pp::class_collection<p::QualifiedPackageNameCollection>
        qpnc("QualifiedPackageNameCollection",
                "Iterable collection of QualifiedPackageName instances."
            );

    bp::enum_<p::UseFlagState>
        ufs("UseFlagState");
    ufs.value("UNSPECIFIED", p::use_unspecified);
    ufs.value("DISABLED", p::use_disabled);
    ufs.value("ENABLED", p::use_enabled);
}