Transaction.hpp

/*------------------------------------------------------------------------*/
/*                 Copyright 2010 Sandia Corporation.                     */
/*  Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive   */
/*  license for use of this work by or on behalf of the U.S. Government.  */
/*  Export of this program may require a license from the                 */
/*  United States Government.                                             */
/*------------------------------------------------------------------------*/


#ifndef stk_mesh_Transaction_hpp
#define stk_mesh_Transaction_hpp


#include <set>
#include <vector>
#include <iosfwd>


namespace stk{
namespace mesh {

class Bucket;
class BulkData;
class Entity;
class Part;


//----------------------------------------------------------------------
class Transaction
{
  public:
    /* \brief The following are the variable type and valid values for
     * defining the type of transaction bucket.
     */
    typedef unsigned char                State;
    enum { NOT_IN_TRANSACTION = 0 , MODIFIED = 1, INSERTED = 2, DELETED = 3 };

    /* \brief There are two different types of transactions:
     * incremental and bulk.  This can be set when reseting a
     * transaction.
     */
    enum TransactionType { INCREMENTAL = 1 , BULK = 2 };

  public:
    typedef std::vector<Bucket *>                 BucketList;

    typedef std::vector<BucketList>               BucketListByType;

    typedef std::set<Part *>                      PartSet;


    std::ostream & print_stream ( std::ostream &os ) const;

    const BucketList & get_modified_buckets ( unsigned type ) const { return m_modified[type]; }



    const BucketList & get_deleted_buckets ( unsigned type ) const { return m_deleted[type]; }

    const BucketList & get_inserted_buckets ( unsigned type ) const { return m_inserted[type]; }


    void get_parts_with_modified_entities ( PartVector &pv ) const
    {
      translate_partset_to_partvector ( m_modified_parts , pv );
    }

    void get_parts_with_deleted_entities ( PartVector &pv ) const
    {
      translate_partset_to_partvector ( m_deleted_parts , pv );
    }

    void get_parts_with_inserted_entities ( PartVector &pv ) const
    {
      translate_partset_to_partvector ( m_inserted_parts , pv );
    }

  private:

    void      print_proc_transaction ( unsigned , std::ostream & ) const;
    void  print_transaction ( unsigned , std::ostream & ) const;
    void  print_bucket_list ( const BucketList & , std::ostream & ) const;

    Transaction ();
    Transaction ( BulkData & , TransactionType );
    Transaction & operator = ( const Transaction & );
   ~Transaction ();

    void allocate_bucket_lists ();

    TransactionType     m_transaction_type;

    BulkData           &m_bulk_data;
    BucketListByType    m_modified;
    BucketListByType    m_deleted;
    BucketListByType    m_inserted;

    PartSet            m_modified_parts;
    PartSet            m_deleted_parts;
    PartSet            m_inserted_parts;

    std::set<Entity *>   m_to_delete;


    void   flush_deletes ();

    void   reset ( TransactionType type = BULK );
    void   flush ();


    void   modify_sole_entity ( Entity &e );

    void   modify_entity ( Entity & e );

    void   insert_entity ( Entity & e );

    void   delete_entity ( Entity & e );

    void   purge_map ( BucketListByType & );

    void   purge_and_erase_map ( BucketListByType & );

    Bucket *get_unfilled_transaction_bucket ( const unsigned *const , EntityRank , BucketList & , State );

    template <class ENTITY>
    Bucket *get_unfilled_transaction_bucket ( const ENTITY &e , BucketList &bm , State s )
     { return get_unfilled_transaction_bucket ( e.bucket().key() , e.entity_rank() , bm , s ); }

    void   add_entity_to_transaction_bucket ( Entity & , Bucket * );

    void   swap_entity_between_transaction_buckets ( Entity & , BucketList & , BucketList & , State );

    void   remove_entity_from_bucket ( Entity & , BucketList & );


    void   add_parts_to_partset ( Entity & , PartSet & );

    void   translate_partset_to_partvector ( const PartSet & , PartVector & ) const;

    // BulkData needs access to modify_entity, insert_entity, and
    // delete_entity.
    friend class BulkData;
    friend std::ostream & operator<< ( std::ostream &os , const Transaction &rhs );

};

inline std::ostream &operator<< ( std::ostream &os , const Transaction &rhs )
{
  return rhs.print_stream ( os );
}

/*
 * \}
 */

}
}



#endif