FM / locale

/usr/include/boost/locale

Name	Size	Mode	Actions
boundary/	-	0755	rm
boundary.hpp	597	0644	edit dl rm
collator.hpp	8594	0644	edit dl rm
config.hpp	1049	0644	edit dl rm
conversion.hpp	15404	0644	edit dl rm
date_time.hpp	47298	0644	edit dl rm
date_time_facet.hpp	11017	0644	edit dl rm
definitions.hpp	858	0644	edit dl rm
encoding.hpp	9790	0644	edit dl rm
encoding_errors.hpp	2053	0644	edit dl rm
encoding_utf.hpp	2838	0644	edit dl rm
format.hpp	18310	0644	edit dl rm
formatting.hpp	21487	0644	edit dl rm
generator.hpp	9565	0644	edit dl rm
generic_codecvt.hpp	24609	0644	edit dl rm
gnu_gettext.hpp	6317	0644	edit dl rm
hold_ptr.hpp	2483	0644	edit dl rm
info.hpp	3580	0644	edit dl rm
localization_backend.hpp	6795	0644	edit dl rm
message.hpp	28297	0644	edit dl rm
time_zone.hpp	1280	0644	edit dl rm
utf.hpp	13389	0644	edit dl rm
utf8_codecvt.hpp	1825	0644	edit dl rm
util.hpp	12963	0644	edit dl rm

Edit: /usr/include/boost/locale/hold_ptr.hpp (2483B)

namespace boost { 
namespace locale {
    ///
    /// \brief a smart pointer similar to std::auto_ptr but it is non-copyable and the
    /// underlying object has the same constness as the pointer itself (unlike an ordinary pointer).
    ///
    template<typename T>
    class hold_ptr {
        hold_ptr(hold_ptr const &other); // non copyable 
        hold_ptr const &operator=(hold_ptr const &other); // non assignable
    public:
        ///
        /// Create new empty pointer
        ///
        hold_ptr() : ptr_(0) {}
        ///
        /// Create a pointer that holds \a v, ownership is transferred to smart pointer
        ///
        explicit hold_ptr(T *v) : ptr_(v) {}

///
        /// Destroy smart pointer and the object it owns.
        ///
        ~hold_ptr() 
        {
            delete ptr_;
        }

///
        /// Get a const pointer to the object
        ///
        T const *get() const { return ptr_; }
        ///
        /// Get a mutable pointer to the object 
        ///
        T *get() { return ptr_; }

/// 
        /// Get a const reference to the object
        ///
        T const &operator *() const { return *ptr_; }
        /// 
        /// Get a mutable reference to the object
        ///
        T &operator *() { return *ptr_; }
        ///
        /// Get a const pointer to the object
        ///
        T const *operator->() const { return ptr_; }
        ///
        /// Get a mutable pointer to the object 
        ///
        T *operator->() { return ptr_; }

///
        /// Transfer an ownership on the pointer to user
        ///
        T *release() { T *tmp=ptr_; ptr_=0; return tmp; }

///
        /// Set new value to pointer, previous object is destroyed, ownership on new object is transferred
        ///
        void reset(T *p=0)
        {
            if(ptr_) delete ptr_;
            ptr_=p;
        }
        /// Swap two pointers
        void swap(hold_ptr &other)
        {
            T *tmp=other.ptr_;
            other.ptr_=ptr_;
            ptr_=tmp;
        }
    private:
        T *ptr_;
    };

} // locale
} // boost

#endif
// vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4

// // Copyright (c) 2010 Artyom Beilis (Tonkikh) // // 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) // #ifndef BOOST_LOCALE_HOLD_PTR_H #define BOOST_LOCALE_HOLD_PTR_H namespace boost { namespace locale { /// /// \brief a smart pointer similar to std::auto_ptr but it is non-copyable and the /// underlying object has the same constness as the pointer itself (unlike an ordinary pointer). /// template class hold_ptr { hold_ptr(hold_ptr const &other); // non copyable hold_ptr const &operator=(hold_ptr const &other); // non assignable public: /// /// Create new empty pointer /// hold_ptr() : ptr_(0) {} /// /// Create a pointer that holds \a v, ownership is transferred to smart pointer /// explicit hold_ptr(T *v) : ptr_(v) {} /// /// Destroy smart pointer and the object it owns. /// ~hold_ptr() { delete ptr_; } /// /// Get a const pointer to the object /// T const *get() const { return ptr_; } /// /// Get a mutable pointer to the object /// T *get() { return ptr_; } /// /// Get a const reference to the object /// T const &operator *() const { return *ptr_; } /// /// Get a mutable reference to the object /// T &operator *() { return *ptr_; } /// /// Get a const pointer to the object /// T const *operator->() const { return ptr_; } /// /// Get a mutable pointer to the object /// T *operator->() { return ptr_; } /// /// Transfer an ownership on the pointer to user /// T *release() { T *tmp=ptr_; ptr_=0; return tmp; } /// /// Set new value to pointer, previous object is destroyed, ownership on new object is transferred /// void reset(T *p=0) { if(ptr_) delete ptr_; ptr_=p; } /// Swap two pointers void swap(hold_ptr &other) { T *tmp=other.ptr_; other.ptr_=ptr_; ptr_=tmp; } private: T *ptr_; }; } // locale } // boost #endif // vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4