]> https://gitweb.dealii.org/ - dealii-svn.git/commitdiff
Use a pointer to DataOut class in std::bind as this is the usual way of doing. This...
authorkronbichler <kronbichler@0785d39b-7218-0410-832d-ea1e28bc413d>
Tue, 29 Oct 2013 17:14:34 +0000 (17:14 +0000)
committerkronbichler <kronbichler@0785d39b-7218-0410-832d-ea1e28bc413d>
Tue, 29 Oct 2013 17:14:34 +0000 (17:14 +0000)
git-svn-id: https://svn.dealii.org/trunk@31484 0785d39b-7218-0410-832d-ea1e28bc413d

deal.II/include/deal.II/base/work_stream.h
deal.II/source/numerics/data_out.cc
deal.II/source/numerics/data_out_faces.cc
deal.II/source/numerics/data_out_rotation.cc

index 7c61f42113906af2a2b711c8631aa4f0480e3c4b..be3a6bd4103a41a5afe25839491fe6a0345b231f 100644 (file)
@@ -146,8 +146,7 @@ namespace WorkStream
 //  and that is available also as a fall-back whenever via boost or similar
 
     /**
-     * A class that creates a sequence of
-     * items from a range of iterators.
+     * A class that creates a sequence of items from a range of iterators.
      */
     template <typename Iterator,
              typename ScratchData,
@@ -156,11 +155,10 @@ namespace WorkStream
     {
     public:
       /**
-       * A data type that we use to identify
-       * items to be worked on. This is the structure
-       * that is passed around between the different parts of
-       * the WorkStream implementation to identify what needs
-       * to be done by the various stages of the pipeline.
+       * A data type that we use to identify items to be worked on. This is
+       * the structure that is passed around between the different parts of
+       * the WorkStream implementation to identify what needs to be done by
+       * the various stages of the pipeline.
        */
       struct ItemType
       {
@@ -272,8 +270,8 @@ namespace WorkStream
 
         /**
          * Default constructor.
-         * Initialize everything that doesn't
-         * have a default constructor itself.
+         * Initialize everything that doesn't have a default constructor
+         * itself.
          */
         ItemType ()
           :
@@ -285,12 +283,9 @@ namespace WorkStream
 
 
       /**
-       * Constructor. Take an iterator
-       * range, the size of a buffer that
-       * can hold items, and the sample
-       * additional data object that will
-       * be passed to each worker and
-       * copier function invokation.
+       * Constructor. Take an iterator range, the size of a buffer that can
+       * hold items, and the sample additional data object that will be passed
+       * to each worker and copier function invokation.
        */
       IteratorRangeToItemStream (const Iterator       &begin,
           const Iterator       &end,
@@ -725,9 +720,7 @@ namespace WorkStream
                    }
 
 
-                   // return an invalid
-                   // item since we are at
-                   // the end of the
+                   // return an invalid item since we are at the end of the
                    // pipeline
                    return 0;
                  }
@@ -735,9 +728,7 @@ namespace WorkStream
 
                private:
                  /**
-                  * Pointer to the function
-                  * that does the copying of
-                  * data.
+                  * Pointer to the function that does the copying of data.
                   */
                  const std_cxx1x::function<void (const CopyData &)> copier;
              };
@@ -750,58 +741,35 @@ namespace WorkStream
 
 
   /**
-   * This is the main function of the
-   * WorkStream concept, doing work as
-   * described in the introduction to this
-   * namespace.
+   * This is the main function of the WorkStream concept, doing work as
+   * described in the introduction to this namespace.
    *
-   * This is the function that can be used
-   * for worker and copier objects that are
-   * either pointers to non-member
-   * functions or objects that allow to be
-   * called with an operator(), for example
-   * objects created by std::bind.
+   * This is the function that can be used for worker and copier objects that
+   * are either pointers to non-member functions or objects that allow to be
+   * called with an operator(), for example objects created by std::bind.
    *
-   * The argument passed as @p end must be
-   * convertible to the same type as
-   * @p begin, but doesn't have to be of the
-   * same type itself. This allows to write
-   * code like
-   * <code>WorkStream().run(dof_handler.begin_active(),
-   * dof_handler.end(), ...</code> where
-   * the first is of type
-   * DoFHandler::active_cell_iterator
-   * whereas the second is of type
+   * The argument passed as @p end must be convertible to the same type as @p
+   * begin, but doesn't have to be of the same type itself. This allows to
+   * write code like <code>WorkStream().run(dof_handler.begin_active(),
+   * dof_handler.end(), ...</code> where the first is of type
+   * DoFHandler::active_cell_iterator whereas the second is of type
    * DoFHandler::raw_cell_iterator.
    *
-   * The two data types
-   * <tt>ScratchData</tt> and
-   * <tt>CopyData</tt> need to have a
-   * working copy
-   * constructor. <tt>ScratchData</tt>
-   * is only used in the
-   * <tt>worker</tt> function, while
-   * <tt>CopyData</tt> is the object
-   * passed from the <tt>worker</tt>
-   * to the <tt>copier</tt>.
+   * The two data types <tt>ScratchData</tt> and <tt>CopyData</tt> need to
+   * have a working copy constructor. <tt>ScratchData</tt> is only used in the
+   * <tt>worker</tt> function, while <tt>CopyData</tt> is the object passed
+   * from the <tt>worker</tt> to the <tt>copier</tt>.
    *
-   * The @p queue_length argument indicates
-   * the number of items that can be live
-   * at any given time. Each item consists
-   * of @p chunk_size elements of the input
-   * stream that will be worked on by the
-   * worker and copier functions one after
-   * the other on the same thread.
+   * The @p queue_length argument indicates the number of items that can be
+   * live at any given time. Each item consists of @p chunk_size elements of
+   * the input stream that will be worked on by the worker and copier
+   * functions one after the other on the same thread.
    *
-   * @note If your data objects are large,
-   * or their constructors are expensive,
-   * it is helpful to keep in mind
-   * that <tt>queue_length</tt>
-   * copies of the <tt>ScratchData</tt>
-   * object and
-   * <tt>queue_length*chunk_size</tt>
-   * copies of the <tt>CopyData</tt>
-   * object are generated.
+   * @note If your data objects are large, or their constructors are
+   * expensive, it is helpful to keep in mind that <tt>queue_length</tt>
+   * copies of the <tt>ScratchData</tt> object and
+   * <tt>queue_length*chunk_size</tt> copies of the <tt>CopyData</tt> object
+   * are generated.
    */
   template <typename Worker,
            typename Copier,
@@ -826,10 +794,8 @@ namespace WorkStream
             ExcMessage ("The chunk_size must be at least one."));
     (void)chunk_size; // removes -Wunused-parameter warning in optimized mode
 
-    // if no work then skip. (only use
-    // operator!= for iterators since we may
-    // not have an equality comparison
-    // operator)
+    // if no work then skip. (only use operator!= for iterators since we may
+    // not have an equality comparison operator)
     if (!(begin != end))
       return;
 
@@ -845,13 +811,15 @@ namespace WorkStream
 
         for (Iterator i=begin; i!=end; ++i)
           {
-            if (static_cast<const std_cxx1x::function<void (const Iterator &,
-                                                            ScratchData &,
-                                                            CopyData &)> >(worker))
-              worker (i, scratch_data, copy_data);
-            if (static_cast<const std_cxx1x::function<void (const CopyData &)> >
-                (copier))
-              copier (copy_data);
+            // need to check if the function is not the zero function. To
+            // check zero-ness, create a C++ function out of it and check that
+             if (static_cast<const std_cxx1x::function<void (const Iterator &,
+                                                             ScratchData &,
+                                                             CopyData &)>& >(worker))
+               worker (i, scratch_data, copy_data);
+             if (static_cast<const std_cxx1x::function<void (const CopyData &)>& >
+                 (copier))
+               copier (copy_data);
           }
       }
 #ifdef DEAL_II_WITH_THREADS
@@ -886,66 +854,42 @@ namespace WorkStream
 
 
   /**
-   * This is the main function of the
-   * WorkStream concept, doing work as
-   * described in the introduction to this
-   * namespace.
+   * This is the main function of the WorkStream concept, doing work as
+   * described in the introduction to this namespace.
    *
-   * This is the function that can be used
-   * for worker and copier objects that are
-   * either pointers to non-member
-   * functions or objects that allow to be
-   * called with an operator(), for example
-   * objects created by std::bind.
+   * This is the function that can be used for worker and copier objects that
+   * are either pointers to non-member functions or objects that allow to be
+   * called with an operator(), for example objects created by std::bind.
    *
-   * The argument passed as @p end must be
-   * convertible to the same type as
-   * @p begin, but doesn't have to be of the
-   * same type itself. This allows to write
-   * code like
-   * <code>WorkStream().run(dof_handler.begin_active(),
-   * dof_handler.end(), ...</code> where
-   * the first is of type
-   * DoFHandler::active_cell_iterator
-   * whereas the second is of type
+   * The argument passed as @p end must be convertible to the same type as @p
+   * begin, but doesn't have to be of the same type itself. This allows to
+   * write code like <code>WorkStream().run(dof_handler.begin_active(),
+   * dof_handler.end(), ...</code> where the first is of type
+   * DoFHandler::active_cell_iterator whereas the second is of type
    * DoFHandler::raw_cell_iterator.
    *
-   * The two data types
-   * <tt>ScratchData</tt> and
-   * <tt>CopyData</tt> need to have a
-   * working copy
-   * constructor. <tt>ScratchData</tt>
-   * is only used in the
-   * <tt>worker</tt> function, while
-   * <tt>CopyData</tt> is the object
-   * passed from the <tt>worker</tt>
-   * to the <tt>copier</tt>.
+   * The two data types <tt>ScratchData</tt> and <tt>CopyData</tt> need to
+   * have a working copy constructor. <tt>ScratchData</tt> is only used in the
+   * <tt>worker</tt> function, while <tt>CopyData</tt> is the object passed
+   * from the <tt>worker</tt> to the <tt>copier</tt>.
    *
-   * The @p get_conflict_indices argument, is a function
-   * that given an iterator computes the conflict indices
-   * necessary for the graph_coloring. Graph coloring is
-   * necessary to be able to copy the data in parallel. If
-   * the number of elements in some colors is less than
-   * @p chunk_size time multithread_info.n_threads(),
-   * these elements are aggregated and copied serially.
+   * The @p get_conflict_indices argument, is a function that given an
+   * iterator computes the conflict indices necessary for the
+   * graph_coloring. Graph coloring is necessary to be able to copy the data
+   * in parallel. If the number of elements in some colors is less than @p
+   * chunk_size time multithread_info.n_threads(), these elements are
+   * aggregated and copied serially.
    *
-   * The @p queue_length argument indicates
-   * the number of items that can be live
-   * at any given time. Each item consists
-   * of @p chunk_size elements of the input
-   * stream that will be worked on by the
-   * worker and copier functions one after
-   * the other on the same thread.
+   * The @p queue_length argument indicates the number of items that can be
+   * live at any given time. Each item consists of @p chunk_size elements of
+   * the input stream that will be worked on by the worker and copier
+   * functions one after the other on the same thread.
    *
-   * @note If your data objects are large,
-   * or their constructors are expensive,
-   * it is helpful to keep in mind
-   * that <tt>queue_length</tt>
-   * copies of the <tt>ScratchData</tt>
-   * object and
-   * <tt>queue_length*chunk_size</tt>
-   * copies of the <tt>CopyData</tt>
-   * object are generated.
+   * @note If your data objects are large, or their constructors are
+   * expensive, it is helpful to keep in mind that <tt>queue_length</tt>
+   * copies of the <tt>ScratchData</tt> object and
+   * <tt>queue_length*chunk_size</tt> copies of the <tt>CopyData</tt> object
+   * are generated.
    */
   template <typename Worker,
            typename Copier,
@@ -994,9 +938,9 @@ namespace WorkStream
            {
              if (static_cast<const std_cxx1x::function<void (const Iterator &,
                                                              ScratchData &,
-                                                             CopyData &)> >(worker))
+                                                             CopyData &)>& >(worker))
                worker (i, scratch_data, copy_data);
-             if (static_cast<const std_cxx1x::function<void (const CopyData &)> >
+             if (static_cast<const std_cxx1x::function<void (const CopyData &)>& >
                  (copier))
                copier (copy_data);
            }
@@ -1076,44 +1020,29 @@ namespace WorkStream
 
 
   /**
-   * This is the main function of the
-   * WorkStream concept, doing work as
-   * described in the introduction to this
-   * namespace.
+   * This is the main function of the WorkStream concept, doing work as
+   * described in the introduction to this namespace.
    *
-   * This is the function that can be
-   * used for worker and copier functions
+   * This is the function that can be used for worker and copier functions
    * that are member functions of a class.
    *
-   * The argument passed as @p end must be
-   * convertible to the same type as
-   * @p begin, but doesn't have to be of the
-   * same type itself. This allows to write
-   * code like
-   * <code>WorkStream().run(dof_handler.begin_active(),
-   * dof_handler.end(), ...</code> where
-   * the first is of type
-   * DoFHandler::active_cell_iterator
-   * whereas the second is of type
+   * The argument passed as @p end must be convertible to the same type as @p
+   * begin, but doesn't have to be of the same type itself. This allows to
+   * write code like <code>WorkStream().run(dof_handler.begin_active(),
+   * dof_handler.end(), ...</code> where the first is of type
+   * DoFHandler::active_cell_iterator whereas the second is of type
    * DoFHandler::raw_cell_iterator.
    *
-   * The @p queue_length argument indicates
-   * the number of items that can be live
-   * at any given time. Each item consists
-   * of @p chunk_size elements of the input
-   * stream that will be worked on by the
-   * worker and copier functions one after
-   * the other on the same thread.
+   * The @p queue_length argument indicates the number of items that can be
+   * live at any given time. Each item consists of @p chunk_size elements of
+   * the input stream that will be worked on by the worker and copier
+   * functions one after the other on the same thread.
    *
-   * @note If your data objects are large,
-   * or their constructors are expensive,
-   * it is helpful to keep in mind
-   * that <tt>queue_length</tt>
-   * copies of the <tt>ScratchData</tt>
-   * object and
-   * <tt>queue_length*chunk_size</tt>
-   * copies of the <tt>CopyData</tt>
-   * object are generated.
+   * @note If your data objects are large, or their constructors are
+   * expensive, it is helpful to keep in mind that <tt>queue_length</tt>
+   * copies of the <tt>ScratchData</tt> object and
+   * <tt>queue_length*chunk_size</tt> copies of the <tt>CopyData</tt> object
+   * are generated.
    */
   template <typename MainClass,
            typename Iterator,
@@ -1150,52 +1079,36 @@ namespace WorkStream
 
 
   /**
-   * This is the main function of the
-   * WorkStream concept, doing work as
-   * described in the introduction to this
-   * namespace.
+   * This is the main function of the WorkStream concept, doing work as
+   * described in the introduction to this namespace.
    *
-   * This is the function that can be
-   * used for worker and copier functions
+   * This is the function that can be used for worker and copier functions
    * that are member functions of a class.
    *
-   * The argument passed as @p end must be
-   * convertible to the same type as
-   * @p begin, but doesn't have to be of the
-   * same type itself. This allows to write
-   * code like
-   * <code>WorkStream().run(dof_handler.begin_active(),
-   * dof_handler.end(), ...</code> where
-   * the first is of type
-   * DoFHandler::active_cell_iterator
-   * whereas the second is of type
+   * The argument passed as @p end must be convertible to the same type as @p
+   * begin, but doesn't have to be of the same type itself. This allows to
+   * write code like <code>WorkStream().run(dof_handler.begin_active(),
+   * dof_handler.end(), ...</code> where the first is of type
+   * DoFHandler::active_cell_iterator whereas the second is of type
    * DoFHandler::raw_cell_iterator.
    *
-   * The @p get_conflict_indices argument, is a function
-   * that given an iterator computes the conflict indices
-   * necessary for the graph_coloring. Graph coloring is
-   * necessary to be able to copy the data in parallel. If
-   * the number of elements in some colors is less than
-   * @p chunk_size time multithread_info.n_threads(),
-   * these elements are aggregated and copied serially.
+   * The @p get_conflict_indices argument, is a function that given an
+   * iterator computes the conflict indices necessary for the
+   * graph_coloring. Graph coloring is necessary to be able to copy the data
+   * in parallel. If the number of elements in some colors is less than @p
+   * chunk_size time multithread_info.n_threads(), these elements are
+   * aggregated and copied serially.
    *
-   * The @p queue_length argument indicates
-   * the number of items that can be live
-   * at any given time. Each item consists
-   * of @p chunk_size elements of the input
-   * stream that will be worked on by the
-   * worker and copier functions one after
-   * the other on the same thread.
+   * The @p queue_length argument indicates the number of items that can be
+   * live at any given time. Each item consists of @p chunk_size elements of
+   * the input stream that will be worked on by the worker and copier
+   * functions one after the other on the same thread.
    *
-   * @note If your data objects are large,
-   * or their constructors are expensive,
-   * it is helpful to keep in mind
-   * that <tt>queue_length</tt>
-   * copies of the <tt>ScratchData</tt>
-   * object and
-   * <tt>queue_length*chunk_size</tt>
-   * copies of the <tt>CopyData</tt>
-   * object are generated.
+   * @note If your data objects are large, or their constructors are
+   * expensive, it is helpful to keep in mind that <tt>queue_length</tt>
+   * copies of the <tt>ScratchData</tt> object and
+   * <tt>queue_length*chunk_size</tt> copies of the <tt>CopyData</tt> object
+   * are generated.
    */
   template <typename MainClass,
            typename Iterator,
index 7546dc8ec6a5bddec8b5a0f704a87e8d90449ee1..816a41f320c7a5081d81ab73e06d77ced7f8ecaf 100644 (file)
@@ -458,7 +458,7 @@ void DataOut<dim,DH>::build_patches (const Mapping<DH::dimension,DH::space_dimen
     WorkStream::run (&all_cells[0],
                      &all_cells[0]+all_cells.size(),
                      std_cxx1x::bind(&DataOut<dim,DH>::build_one_patch,
-                                     *this, std_cxx1x::_1, std_cxx1x::_2, std_cxx1x::_3,
+                                     this, std_cxx1x::_1, std_cxx1x::_2, std_cxx1x::_3,
                                      curved_cell_region,std_cxx1x::ref(this->patches)),
                      std_cxx1x::bind(&internal::DataOut::copy<dim,DH::space_dimension>,
                                      std_cxx1x::_1),
index 4dd1ccec43c1030a05b4575b792bb4f6c3af4e9f..9f265672288e1eeb2531775620c070066f84be99 100644 (file)
@@ -332,7 +332,7 @@ void DataOutFaces<dim,DH>::build_patches (const Mapping<DH::dimension> &mapping,
   WorkStream::run (&all_faces[0],
                    &all_faces[0]+all_faces.size(),
                    std_cxx1x::bind(&DataOutFaces<dim,DH>::build_one_patch,
-                                   *this, std_cxx1x::_1, std_cxx1x::_2, std_cxx1x::_3),
+                                   this, std_cxx1x::_1, std_cxx1x::_2, std_cxx1x::_3),
                    std_cxx1x::bind(&internal::DataOutFaces::
                                    append_patch_to_list<dim,DH::space_dimension>,
                                    std_cxx1x::_1, std_cxx1x::ref(this->patches)),
index 5593d7a792004466a36531dece787cc44378f95b..5082a83008bdad5e388be9acd3a593f567cbcbfd 100644 (file)
@@ -474,7 +474,7 @@ void DataOutRotation<dim,DH>::build_patches (const unsigned int n_patches_per_ci
   WorkStream::run (&all_cells[0],
                    &all_cells[0]+all_cells.size(),
                    std_cxx1x::bind(&DataOutRotation<dim,DH>::build_one_patch,
-                                   *this, std_cxx1x::_1, std_cxx1x::_2, std_cxx1x::_3),
+                                   this, std_cxx1x::_1, std_cxx1x::_2, std_cxx1x::_3),
                    std_cxx1x::bind(&internal::DataOutRotation
                                    ::append_patch_to_list<dim,DH::space_dimension>,
                                    std_cxx1x::_1, std_cxx1x::ref(this->patches)),

In the beginning the Universe was created. This has made a lot of people very angry and has been widely regarded as a bad move.

Douglas Adams


Typeset in Trocchi and Trocchi Bold Sans Serif.