namespace_dir.hpp

Go to the documentation of this file.

#ifndef SAGA_PACKAGES_DATA_NAMESPACEDIR_HPP
#define SAGA_PACKAGES_DATA_NAMESPACEDIR_HPP

#if defined(__WAVE__) && defined(SAGA_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 2, line: 1, output: "preprocessed/namespace_dir.hpp")
#endif
//  Copyright (c) 2005-2008 Hartmut Kaiser
//  Copyright (c) 2005-2007 Andre Merzky (andre@merzky.net)
//  Copyright (c) 2007 Ole Weidner (oweidner@cct.lsu.edu)
// 
//  Distributed under the Boost Software License, Version 1.0. (See accompanying 
//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#if defined(__WAVE__) && defined(SAGA_CREATE_PREPROCESSED_FILES)
#pragma wave option(output: null)
#endif
// include stl
#include <string>

// include dependent spec sections
#include <saga/saga/call.hpp>
#include <saga/saga/base.hpp>
#include <saga/saga/session.hpp>
#include <saga/saga/task.hpp>
#include <saga/saga/permissions.hpp>
#include <saga/saga/url.hpp>

// include package config
#include <saga/saga/packages/namespace/config.hpp>
#include <saga/saga/packages/namespace/namespace_entry.hpp>

// suppress warnings about dependent classes not being exported from the dll
#if defined(BOOST_MSVC)
#pragma warning(push)
#pragma warning(disable: 4251 4231 4275 4660)
#endif

#ifdef SAGA_DEBUG
#include <saga/saga/packages/description/preprocessed/namespace_dir.hpp>
#else

#if defined(__WAVE__) && defined(SAGA_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 2, line: 1, output: "preprocessed/namespace_dir.hpp")
#endif
namespace saga
{
    namespace name_space {
    
    class SAGA_NAMESPACE_PACKAGE_EXPORT directory 
        : public entry
    {
    
    protected:

        TR1::shared_ptr <saga::impl::namespace_dir> get_impl() const;
        typedef saga::name_space::entry::monitorable_base monitorable_base;
     
    private:
        // navigation/query methods
        SAGA_CALL_PRIV_1(change_dir, saga::url);
        SAGA_CALL_CONST_PRIV_2(list, std::string, int);
        SAGA_CALL_CONST_PRIV_2(find, std::string, int);

        SAGA_CALL_CONST_PRIV_1(read_link,  saga::url);
        SAGA_CALL_CONST_PRIV_1(exists, saga::url);
        SAGA_CALL_CONST_PRIV_1(is_dir, saga::url);
        SAGA_CALL_CONST_PRIV_1(is_entry, saga::url);
        SAGA_CALL_CONST_PRIV_1(is_link, saga::url);

        // Deal with entries by entry number
        SAGA_CALL_CONST_PRIV_0(get_num_entries)
        SAGA_CALL_CONST_PRIV_1(get_entry, std::size_t);

        // entry management methods
        SAGA_CALL_PRIV_3(copy, saga::url, saga::url, int);
        SAGA_CALL_PRIV_3(link, saga::url, saga::url, int);
        SAGA_CALL_PRIV_3(move, saga::url, saga::url, int);
        SAGA_CALL_PRIV_2(remove, saga::url, int);
        SAGA_CALL_PRIV_2(make_dir, saga::url, int);

        // open methods
        SAGA_CALL_PRIV_2(open, saga::url, int);
        SAGA_CALL_PRIV_2(open_dir, saga::url, int);

        // management methods - wild card versions
        SAGA_CALL_PRIV_3(copy, std::string, saga::url, int);
        SAGA_CALL_PRIV_3(link, std::string, saga::url, int);
        SAGA_CALL_PRIV_3(move, std::string, saga::url, int);
        SAGA_CALL_PRIV_2(remove, std::string, int);

        // permissions with flags
        SAGA_CALL_PRIV_4(permissions_allow, saga::url, std::string, int, int)
        SAGA_CALL_PRIV_4(permissions_deny, saga::url, std::string, int, int)
        SAGA_CALL_PRIV_4(permissions_allow, std::string, std::string, int, int)
        SAGA_CALL_PRIV_4(permissions_deny, std::string, std::string, int, int)

    protected:

        directory (saga::impl::namespace_dir *);
         
    public:
        directory (session const& s, saga::url url, int mode = Read,
                       saga::object::type t = saga::object::NSDirectory);

        explicit directory (saga::url url, int mode = Read,
            saga::object::type t = saga::object::NSDirectory);
            
        explicit directory (saga::object const& o);
        
        directory (void);
        
        ~directory (void);

        directory &operator= (saga::object const& o);

        void change_dir (saga::url target)
        {
            change_dirpriv(target, saga::task_base::Sync());
        }
        SAGA_CALL_PUB_1_DEF_0(change_dir, saga::url);
        
        std::vector<saga::url> list (std::string pattern = "*", 
            int flags = saga::name_space::None) const
        {
            saga::task t = listpriv(pattern, flags, saga::task_base::Sync());
            return t.get_result<std::vector<saga::url> >();
        }
        SAGA_CALL_CONST_PUB_2_DEF_2(list, std::string, 
            "*", int, saga::name_space::None);
        
        std::vector<saga::url> find (std::string pattern, 
            int flags = saga::name_space::Recursive) const
        {
            saga::task t = findpriv(pattern, flags, saga::task_base::Sync());
            return t.get_result<std::vector<saga::url> >();
        }
        SAGA_CALL_CONST_PUB_2_DEF_1(find, std::string, 
            int, saga::name_space::Recursive);

        saga::url read_link (saga::url url) const
        {
            saga::task t = read_linkpriv(url, saga::task_base::Sync());
            return t.get_result<saga::url>();
        }
        SAGA_CALL_CONST_PUB_1_DEF_0(read_link, saga::url);
        
        bool exists (saga::url url) const
        {
            saga::task t = existspriv(url, saga::task_base::Sync());
            return t.get_result<bool>();
        }
        SAGA_CALL_CONST_PUB_1_DEF_0(exists, saga::url)
        
        
        bool is_dir (saga::url url) const
        {
            saga::task t = is_dirpriv(url, saga::task_base::Sync());
            return t.get_result<bool>();
        }
        SAGA_CALL_CONST_PUB_1_DEF_0(is_dir, saga::url)
        
        
        bool is_entry (saga::url url) const
        {
            saga::task t = is_entrypriv(url, saga::task_base::Sync());
            return t.get_result<bool>();
        }
        SAGA_CALL_CONST_PUB_1_DEF_0(is_entry, saga::url)
        
        
        bool is_link (saga::url url) const
        {
            saga::task t = is_linkpriv(url, saga::task_base::Sync());
            return t.get_result<bool>();
        }
        SAGA_CALL_CONST_PUB_1_DEF_0 (is_link, saga::url)

        // make base class functions available as well
        using entry::read_link;
        using entry::is_dir;
        using entry::is_entry;
        using entry::is_link;

        std::size_t get_num_entries (void) const
        {
            saga::task t = get_num_entriespriv(saga::task_base::Sync());
            return t.get_result<std::size_t>();
        }
        SAGA_CALL_CONST_PUB_0_DEF_0(get_num_entries)
        
        
        saga::url get_entry (std::size_t entry) const
        {
            saga::task t = get_entrypriv(entry, saga::task_base::Sync());
            return t.get_result<saga::url>();
        }
        SAGA_CALL_CONST_PUB_1_DEF_0(get_entry, unsigned int)

        void copy (saga::url source_url, saga::url dest_url, 
            int flags = saga::name_space::None)
        {
            copypriv(source_url, dest_url, flags, saga::task_base::Sync());
        }
        SAGA_CALL_PUB_3_DEF_1 (copy, saga::url, saga::url, int, 
            saga::name_space::None)
        
        
        void copy (std::string source_url, saga::url dest_url, 
            int flags = saga::name_space::None)
        {
            copypriv(source_url, dest_url, flags, saga::task_base::Sync());
        }
        SAGA_CALL_PUB_3_DEF_1 (copy, std::string, saga::url, int, 
            saga::name_space::None)
        
        
        void copy (char const * source_url, saga::url dest_url,
            int flags = saga::name_space::None)
        {
            copypriv(std::string(source_url), dest_url, flags, saga::task_base::Sync());
        }
        template <class Tag>
        saga::task copy (char const * source_url, saga::url dest_url,
            int flags = saga::name_space::None)
        {
            return copypriv(std::string(source_url), dest_url, flags, Tag());
        }

        void link (saga::url source_url, saga::url dest_url, 
            int flags = saga::name_space::None)
        {
            linkpriv(source_url, dest_url, flags, saga::task_base::Sync());
        }
        SAGA_CALL_PUB_3_DEF_1(link, saga::url, saga::url, int, 
            saga::name_space::None)
        
        
        void link (std::string source_url, saga::url dest_url, 
            int flags = saga::name_space::None)
        {
            linkpriv(source_url, dest_url, flags, saga::task_base::Sync());
        }
        SAGA_CALL_PUB_3_DEF_1(link, std::string, saga::url, int, 
            saga::name_space::None)
        
        
        void link (char const * source_url, saga::url dest_url,
            int flags = saga::name_space::None)
        {
            linkpriv(std::string(source_url), dest_url, flags, saga::task_base::Sync());
        }
        template <class Tag>
        saga::task link (char const * source_url, saga::url dest_url,
            int flags = saga::name_space::None)
        {
            return linkpriv(std::string(source_url), dest_url, flags, Tag());
        }

        void move (saga::url source_url, saga::url dest_url, 
            int flags = saga::name_space::None)
        {
            movepriv(source_url, dest_url, flags, saga::task_base::Sync());
        }
        SAGA_CALL_PUB_3_DEF_1(move, saga::url, saga::url, int, 
            saga::name_space::None)
        
        
        void move (std::string source_url, saga::url dest_url, 
            int flags = saga::name_space::None)
        {
            movepriv(source_url, dest_url, flags, saga::task_base::Sync());
        }
        SAGA_CALL_PUB_3_DEF_1(move, std::string, saga::url, int, 
            saga::name_space::None)
        
        
        void move (char const * source_url, saga::url dest_url,
            int flags = saga::name_space::None)
        {
            movepriv(std::string(source_url), dest_url, flags, saga::task_base::Sync());
        }
        template <class Tag>
        saga::task move (char const * source_url, saga::url dest_url,
            int flags = saga::name_space::None)
        {
            return movepriv(std::string(source_url), dest_url, flags, Tag());
        }

        void remove (saga::url url, int flags = saga::name_space::None)
        {
            removepriv(url, flags, saga::task_base::Sync());
        }
        SAGA_CALL_PUB_2_DEF_1(remove, saga::url, int, saga::name_space::None)

        void remove (std::string url, int flags = saga::name_space::None)
        {
            removepriv(url, flags, saga::task_base::Sync());
        }
        SAGA_CALL_PUB_2_DEF_1(remove, std::string, int, saga::name_space::None)

        void remove (char const * url, int flags = saga::name_space::None)
        {
            removepriv(std::string(url), flags, saga::task_base::Sync());
        }
        template <class Tag>
        saga::task remove (char const * url, int flags = saga::name_space::None)
        {
            return removepriv(std::string(url), flags, Tag());
        }

        // make base class functions available as well
        using entry::copy;
        using entry::link;
        using entry::move;
        using entry::remove;

        void make_dir (saga::url url, 
            int flags = saga::name_space::None)
        {
            make_dirpriv(url, flags, saga::task_base::Sync());
        }
        SAGA_CALL_PUB_2_DEF_1(make_dir, saga::url, int, saga::name_space::None)

        saga::name_space::entry open (saga::url url, 
            int flags = saga::name_space::None)
        {
            saga::task t = openpriv(url, flags, saga::task_base::Sync());
            return t.get_result<saga::name_space::entry>();
        }
        SAGA_CALL_PUB_2_DEF_1(open, saga::url, int, saga::name_space::Read)
        
        
        saga::name_space::directory open_dir (saga::url url, 
                                              int flags = saga::name_space::Read)
        {
            saga::task t = open_dirpriv(url, flags, saga::task_base::Sync());
            return t.get_result<saga::name_space::directory>();
        }
        SAGA_CALL_PUB_2_DEF_1(open_dir, saga::url, int, saga::name_space::Read)

        // make base class functions available as well
        using entry::permissions_allow;
        using entry::permissions_deny;

        void permissions_allow (saga::url target, std::string id, 
            int perm, int flags = None)
        {
            permissions_allowpriv(target, id, perm, flags, saga::task_base::Sync());
        }
        SAGA_CALL_PUB_4_DEF_1 (permissions_allow, saga::url, std::string, 
            int, int, None)

        void permissions_deny (saga::url target, std::string id, 
            int perm, int flags = None)
        {
            permissions_denypriv(target, id, perm, flags, saga::task_base::Sync());
        }
        SAGA_CALL_PUB_4_DEF_1 (permissions_deny, saga::url, std::string, 
            int, int, None)

        void permissions_allow (std::string target, std::string id, 
            int perm, int flags = None)
        {
            permissions_allowpriv(target, id, perm, flags, saga::task_base::Sync());
        }
        SAGA_CALL_PUB_4_DEF_1 (permissions_allow, std::string, std::string, 
            int, int, None)

        void permissions_deny (std::string target, std::string id, 
            int perm, int flags = None)
        {
            permissions_denypriv(target, id, perm, flags, saga::task_base::Sync());
        }
        SAGA_CALL_PUB_4_DEF_1 (permissions_deny, std::string, std::string, 
            int, int, None)

        void permissions_allow (char const * target, std::string id,
                int perm, int flags = None)
        {
            permissions_allowpriv(std::string(target), id, perm, flags,
                saga::task_base::Sync());
        }
        template <class Tag>
        saga::task permissions_allow (char const * target, std::string id,
                int perm, int flags = None)
        {
            return permissions_allowpriv(std::string(target), id, perm, flags,
                Tag());
        }

        void permissions_deny (char const * target, std::string id,
                int perm, int flags = None)
        {
            permissions_denypriv(std::string(target), id, perm, flags,
                saga::task_base::Sync());
        }
        template <class Tag>
        saga::task permissions_deny (char const * target, std::string id,
                int perm, int flags = None)
        {
            return permissions_denypriv(std::string(target), id, perm, flags,
                Tag());
        }
    };
    
}} // saga::namespace_dir

#endif // !defined(SAGA_DEBUG)

#if defined(__WAVE__) && defined(SAGA_CREATE_PREPROCESSED_FILES)
#pragma wave option(output: null)
#endif
// re-enable warnings about dependent classes not being exported from the dll
#if defined(BOOST_MSVC)
#pragma warning(pop)
#endif

#endif // SAGA_PACKAGES_DATA_NAMESPACEDIR_HPP

---