NfsExports.hpp

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                                                                      |
|                     _     _   _   _     __     _                     |
|                    | |   | | | \_/ |   /  \   | |                    |
|                    | |   | | | |_| |  / /\ \  | |                    |
|                    | |__ | | | | | | / ____ \ | |__                  |
|                    |____||_| |_| |_|/ /    \ \|____|                 |
|                                                                      |
|                             nfs-server library                       |
|                                                                      |
|                                         (C) SUSE Linux Products GmbH |
|                                         (C) Novell, Inc.             |
\----------------------------------------------------------------------/

  File:       NfsExports.hpp

  Author:     Marius Tomaschewski, Chakravarthi P
  Maintainer: Chakravarthi P

/-*/
#ifndef   LIMAL_NFS_SERVER_NFS_EXPORTS_HPP
#define   LIMAL_NFS_SERVER_NFS_EXPORTS_HPP

#include <limal/nfs-server/config.h>
#include <blocxx/String.hpp>
#include <blocxx/Array.hpp>
#include <blocxx/List.hpp>
#include <blocxx/Map.hpp>


// -------------------------------------------------------------------
namespace LIMAL_NAMESPACE
{
namespace NFS_SERVER_NAMESPACE
{


// -------------------------------------------------------------------
class ExportOption
{
public:
        ExportOption();

        ExportOption(const blocxx::String &name,
                     const blocxx::String &value);

        ExportOption(const blocxx::String &option);

        ExportOption(const ExportOption &option);

        ~ExportOption();

        bool                    empty() const;

        blocxx::String          toString()  const;

        blocxx::String          getName()  const;

        blocxx::String          getValue() const;

        void                    setName(const blocxx::String &name);

        void                    setValue(const blocxx::String &value);

        void                    setOption(const blocxx::String &option);

#ifndef SWIG
        friend bool
        operator == (const ExportOption & o1, const ExportOption & o2);

        friend bool
        operator <  (const ExportOption & o1, const ExportOption & o2);
#endif

private:
        blocxx::String  m_name;
        blocxx::String  m_value;
};


// -------------------------------------------------------------------
typedef blocxx::List<ExportOption>      ExportOptions;


// -------------------------------------------------------------------
class ExportClient
{
public:
        ExportClient();

        ExportClient(const ExportClient   &client);

        ExportClient(const blocxx::String &client,
                     const ExportOptions  &options);

        ExportClient(const blocxx::String &client,
                     const blocxx::String &options);

        ExportClient(const blocxx::String &clientAndOpts);

        ~ExportClient();

        bool                    empty() const;

        blocxx::String          toString() const;

        blocxx::String          getClient() const;

        ExportOptions           getOptions() const;

        blocxx::String          getOptionsString() const;

        void                    setClient (const blocxx::String &client);

        void                    setOptions(const ExportOptions  &options);

        void                    setOptions(const blocxx::String  &options);

        static
        ExportOptions           parseOptions(const blocxx::String &options);

#ifndef SWIG
        friend bool
        operator == (const ExportClient &c1, const ExportClient &c2);

        friend bool
        operator <  (const ExportClient &c1, const ExportClient &c2);
#endif

private:
        blocxx::String  m_client;
        ExportOptions   m_options;
};


// -------------------------------------------------------------------
typedef blocxx::List<ExportClient>      ExportClients;


// -------------------------------------------------------------------
typedef blocxx::Array<blocxx::String>   ExportComment;


// -------------------------------------------------------------------
class ExportEntry
{
public:
        ExportEntry();

        ExportEntry(const ExportEntry &entry);


        ExportEntry(const blocxx::String &path,
                    const ExportClients  &clients);

        ExportEntry(const blocxx::String &path,
                    const ExportClients  &clients,
                    const ExportComment  &comment);

        ~ExportEntry();

        bool                    empty() const;

        blocxx::String          toString() const;

        blocxx::StringArray     toStringArray() const;

        blocxx::String          getPath() const;

        ExportClients           getClients() const;

        ExportComment           getComment() const;

        void                    setPath(const blocxx::String &path);

        void                    setClients(const ExportClients  &clients);

        void                    setComment(const ExportComment &comment);

        bool                    addClient(const ExportClient &client);

        bool                    removeClient(const blocxx::String &cname);

        bool                    removeClient(const ExportClient   &client);

        void                    removeClients();

#ifndef SWIG
        friend bool
        operator == (const ExportEntry &e1, const ExportEntry &e2);

        friend bool
        operator <  (const ExportEntry &e1, const ExportEntry &e2);
#endif

private:
        blocxx::String  m_path;
        ExportClients   m_clients;
        ExportComment   m_comment;
};


// -------------------------------------------------------------------
typedef blocxx::List<ExportEntry>       ExportEntries;
typedef blocxx::List<blocxx::String>    ExportPaths;


// -------------------------------------------------------------------
class Exports
{
public:
        enum CommentType
        {
                E_LEADING,
                E_TRAILING
        };

        Exports();

        Exports(const Exports &exports);

        Exports(const ExportEntries &entries);

        ~Exports();

        ExportPaths             getPaths() const;

        ExportClients           getClients(const blocxx::String &path) const;

        ExportEntries           getEntries(const blocxx::String &path) const;

        ExportEntries           getEntries() const;

        ExportComment           getComment(CommentType type) const;

        void                    setEntries(const ExportEntries &entries);

        void                    setComment(const ExportComment &comment,
                                           CommentType         type);

        void                    addEntry(const ExportEntry     &entry);


private:
        ExportEntries m_entries;
        ExportComment l_comment;
        ExportComment t_comment;

};


// -------------------------------------------------------------------
}      // End of NFS_SERVER_NAMESPACE
}      // End of LIMAL_NAMESPACE

#endif // LIMAL_NFS_SERVER_NFS_EXPORTS_HPP
// vim: set ts=8 sts=8 sw=8 ai noet: