lib/space/automap.cc

Go to the documentation of this file.

//
// nis-util - NIS Administration Utilities
// Copyright (C) 2012 Peter Miller
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or (at
// your option) any later version.
//
// This program 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, see <http://www.gnu.org/licenses/>.
//

#include <lib/space/automap/functor/save.h>
#include <lib/space/automap/functor/tee.h>
#include <lib/output/file.h>
#include <lib/space/automap.h>
#include <lib/space/hosts/slurp.h>


space_automap::~space_automap()
{
}


space_automap::space_automap(const rcstring &a_filename) :
    space(a_filename)
{
    discard_blank_lines();
    discard_comments();
    discard_backslash_newline();
}


space_automap::pointer
space_automap::create(const rcstring &filename)
{
    return pointer(new space_automap(filename));
}


void
space_automap::read_and_process(void)
{
    space_automap_functor_save save(this);
    parse(save, NULL);
}


void
space_automap::read_and_process(space_automap_functor &func,
    const space_hosts_slurp *hosts)
{
    space_automap_functor_save save(this);
    space_automap_functor_tee chimera(save, func);
    parse(chimera, hosts);
}


void
space_automap::walk(space_automap_functor &func)
{
    for
    (
        content_t::const_iterator it = content.begin();
        it != content.end();
        ++it
    )
    {
        func(it->second);
    }
}


void
space_automap::insert(const space_automap_row::pointer &rp)
{
    rcstring key = rp->get_mount_point().get_mount_point();
    space_automap_row::pointer qr = query(key);
    if (qr)
    {
        error
        (
            rp->get_mount_point().get_source_location(),
            "duplicate %s definition...",
            key.quote_c().c_str()
        );
        error
        (
            qr->get_mount_point().get_source_location(),
            "...here is the first %s definition",
            key.quote_c().c_str()
        );
    }
    else
    {
        content.insert(content_t::value_type(key, rp));
    }
}


space_automap_row::pointer
space_automap::query(const rcstring &key)
    const
{
    content_t::const_iterator it = content.find(key);
    if (it == content.end())
        return space_automap_row::pointer();
    return it->second;
}


void
space_automap::insert_sub(const space_automap_row::pointer &rp)
{
    rcstring key = rp->get_mount_point().get_mount_point();
    space_automap_row::pointer qr = query_sub(key);
    if (qr)
    {
        error
        (
            rp->get_mount_point().get_source_location(),
            "duplicate %s definition...",
            key.quote_c().c_str()
        );
        error
        (
            qr->get_mount_point().get_source_location(),
            "...here is the first %s definition",
            key.quote_c().c_str()
        );
    }
    else
    {
        content_sub.insert(content_t::value_type(key, rp));
    }
}


space_automap_row::pointer
space_automap::query_sub(const rcstring &key)
    const
{
    content_t::const_iterator it = content_sub.find(key);
    if (it == content_sub.end())
        return space_automap_row::pointer();
    return it->second;
}


void
space_automap::print(void)
    const
{
    print(get_file_name());
}


void
space_automap::print(const rcstring &a_filename)
    const
{
    output::pointer op = output_file::create(a_filename);
    // FIXME: use a functor
    for
    (
        content_t::const_iterator it = content.begin();
        it != content.end();
        ++it
    )
    {
        space_automap_row::pointer rp = it->second;
        rp->print(op);
    }
}


bool
space_automap::empty(void)
    const
{
    return content.empty();
}


space_automap::keys_t
space_automap::get_keys(void)
    const
{
    keys_t result;
    for
    (
        content_t::const_iterator it = content.begin();
        it != content.end();
        ++it
    )
    {
        space_automap_row::pointer rp = it->second;
        result.push_back(rp->get_mount_point());
    }
    return result;
}


// vim: set ts=8 sw=4 et :