advert.hpp

Go to the documentation of this file.

#ifndef SAGA_PACKAGES_DATA_ADVERT_ADVERT_HPP
#define SAGA_PACKAGES_DATA_ADVERT_ADVERT_HPP

#if defined(__WAVE__) && defined(SAGA_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 2, line: 1, output: "preprocessed/advert.hpp")
#endif
//  Copyright (c) 2005-2009 Hartmut Kaiser
//  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(preserve: 0, output: null)
#endif

#if defined(_MSC_VER) && (_MSC_VER >= 1200)
#pragma once
#endif 

#include <string>
#include <vector>

#include <boost/utility/enable_if.hpp>
#include <boost/lexical_cast.hpp>

// include dependent spec sections
#include <saga/saga/util.hpp>
#include <saga/saga/base.hpp>
#include <saga/saga/types.hpp>
#include <saga/saga/session.hpp>
#include <saga/saga/call.hpp>
#include <saga/saga/detail/attribute.hpp>
#include <saga/saga/detail/monitorable.hpp>

#include <saga/saga/packages/namespace/namespace_entry.hpp>
#include <saga/saga/packages/advert/config.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/advert/preprocessed/advert.hpp>
#else

#if defined(__WAVE__) && defined(SAGA_CREATE_PREPROCESSED_FILES)
#pragma wave option(preserve: 2, line: 1, output: "preprocessed/advert.hpp")
#endif

#if !defined(SAGA_ADVERT_NO_DEPRECATED)
#define SAGA_ADVERT_DEPRECATED_MSG "This function is deprecated and will be removed in the future."
#endif

namespace saga
{
    namespace advert 
    {
        namespace metrics 
        {
            char const* const advert_modified = "advert.Modified";

            char const* const advert_deleted = "advert.Deleted";
        }

        enum flags 
        {
            Unknown         = /*  -1, */  saga::name_space::Unknown, 
            None            = /*   0, */  saga::name_space::None, 
            Overwrite       = /*   1, */  saga::name_space::Overwrite, 
            Recursive       = /*   2, */  saga::name_space::Recursive, 
            Dereference     = /*   4, */  saga::name_space::Dereference, 
            Create          = /*   8, */  saga::name_space::Create, 
            Exclusive       = /*  16, */  saga::name_space::Exclusive, 
            Lock            = /*  32, */  saga::name_space::Lock, 
            CreateParents   = /*  64, */  saga::name_space::CreateParents, 
            // 256, reserved for Truncate
            // 512,  reserved for Append 
            Read            =    512, 
            Write           =   1024, 
            ReadWrite       =   Read | Write 
            // 2048, reserved for Binary
        }; 

        class SAGA_ADVERT_PACKAGE_EXPORT entry 
          : public saga::name_space::entry,
            public saga::detail::attribute<entry>
        {
        protected:

            friend class saga::impl::advert;

            friend struct saga::detail::attribute<entry>; 
            typedef saga::detail::attribute<entry> attribute_base;
            typedef saga::name_space::entry::monitorable_base monitorable_base;

            TR1::shared_ptr <saga::impl::advert> get_impl_sp(void) const;
            saga::impl::advert* get_impl (void) const;
            explicit entry(saga::impl::advert *impl);

        private:
            // factory
            SAGA_CALL_CREATE_PRIV_3(session const&, saga::url const&, int)

            SAGA_CALL_PRIV_1(store_object, saga::object)
            SAGA_CALL_PRIV_0(retrieve_object)
            SAGA_CALL_PRIV_1(retrieve_object, saga::session)
            SAGA_CALL_PRIV_1(store_string, std::string)
            SAGA_CALL_PRIV_0(retrieve_string)

            template <typename Tag, typename T>
            saga::task store_object_or_string (Tag, T const& object, boost::mpl::true_)
            {
                return store_objectpriv(object, Tag());
            }

            template <typename Tag, typename T>
            saga::task store_object_or_string (Tag, T const& object, boost::mpl::false_)
            {
                return store_stringpriv(
                    boost::lexical_cast<std::string>(object), Tag()); 
            }

        public:
            entry (saga::session const& s, saga::url url, int mode = Read);

            explicit entry (saga::url url, int mode = Read);

            explicit entry (saga::object const& other);

            entry (void);

            ~entry (void);

            static entry create(session const& s, saga::url const& url, 
                int mode = Read)
            {
                return entry(s, url, mode);
            }
            SAGA_CALL_CREATE_3_DEF_1(session const&, saga::url const&, int, Read)

            static entry create(saga::url const& url, int mode = Read)
            {
                return entry(url, mode);
            }
            template <typename Tag>
            static saga::task create(saga::url const& url, int mode = Read)
            {
                return create<Tag>(detail::get_the_session(), url, mode);
            }

            entry &operator= (saga::object const& object);

            void store_object (saga::object object) 
            { 
                saga::task t = store_objectpriv(object, saga::task_base::Sync()); 
                t.get_result ();
            }

            template <typename T>
            typename boost::disable_if<detail::has_sync_tag<T> >::type
            store_object (T const& object) 
            { 
                typedef boost::mpl::bool_<
                    detail::is_saga_object<T>::value> is_saga_object;
                saga::task t = store_object_or_string(saga::task_base::Sync(), 
                    object, is_saga_object());
                t.get_result();
            }
            template <typename Tag, typename T>
            typename boost::enable_if<detail::has_sync_tag<Tag>, saga::task>::type
            store_object (T const& object)
            {
                typedef boost::mpl::bool_<
                    detail::is_saga_object<T>::value> is_saga_object;
                return store_object_or_string(Tag(), object, is_saga_object());
            }

            saga::object retrieve_object() 
            { 
                saga::task t = retrieve_objectpriv (saga::task_base::Sync()); 
                return t.get_result<saga::object>();
            }
//            SAGA_CALL_PUB_0_DEF_0(retrieve_object)
            template <typename Tag>
            typename boost::enable_if<detail::has_sync_tag<Tag>, saga::task>::type
            retrieve_object()
            { 
                return retrieve_objectpriv(Tag()); 
            }

            template <typename T>
            T& retrieve_object(
                typename boost::disable_if<detail::has_sync_tag<T> >::type* = 0) 
            { 
                saga::task t = retrieve_stringpriv (saga::task_base::Sync()); 
                return t.get_result<T>();
            }
            template <typename T, typename Tag>
            typename boost::disable_if<detail::has_sync_tag<T>, saga::task>::type
            retrieve_object() 
            {
                return retrieve_stringpriv(Tag());
            }

            saga::object retrieve_object (saga::session const& s) 
            { 
                saga::task t = retrieve_objectpriv(s, saga::task_base::Sync()); 
                return t.get_result<saga::object>();
            }
            template <typename Tag>
            typename boost::enable_if<detail::has_sync_tag<Tag>, saga::task>::type
            retrieve_object(saga::session const& s)
            { 
                return retrieve_objectpriv(s, Tag()); 
            }

#if !defined(SAGA_ADVERT_NO_DEPRECATED)


            SAGA_DEPRECATED(SAGA_ADVERT_DEPRECATED_MSG) 
            void store_string (std::string str) 
            { 
                saga::task t = store_stringpriv(str, saga::task_base::Sync()); 
                t.get_result ();
            }
//             SAGA_CALL_PUB_1_DEF_0(store_string, std::string)
            template <typename Tag>
            SAGA_DEPRECATED(SAGA_ADVERT_DEPRECATED_MSG) 
            saga::task store_string(std::string str) 
            {
                return store_stringpriv(str, Tag());
            }

            SAGA_DEPRECATED(SAGA_ADVERT_DEPRECATED_MSG) 
            std::string retrieve_string (void) 
            { 
                saga::task t = retrieve_stringpriv (saga::task_base::Sync()); 
                return t.get_result<std::string>();
            }
//             SAGA_CALL_PUB_0_DEF_0(retrieve_string)
            template <typename Tag>
            SAGA_DEPRECATED(SAGA_ADVERT_DEPRECATED_MSG) 
            saga::task retrieve_string()
            { 
                return retrieve_stringpriv(Tag()); 
            }
#endif

        }; // class advert
    } // namespace advert
} // namespace saga

#undef SAGA_ADVERT_DEPRECATED_MSG

#if defined(__WAVE__) && defined(SAGA_CREATE_PREPROCESSED_FILES)
#pragma wave option(output: null)
#endif

#endif // !defined(SAGA_DEBUG)

// re-enable warnings about dependent classes not being exported from the dll
#if defined(BOOST_MSVC)
#pragma warning(pop)
#endif

#endif // !defined(SAGA_PACKAGES_DATA_ADVERT_ADVERT_HPP)