#ifndef COSTRANSACTIONS_IDL_

#define COSTRANSACTIONS_IDL_

module CosTransactions

{

    enum Status { StatusActive, StatusMarkedRollback, StatusPrepared,

        StatusCommitted, StatusRolledback, StatusUnknown,

           StatusPreparing, StatusCommitting, StatusRollingBack,

        StatusNoTransaction };


    enum Vote { VoteCommit, VoteRollback, VoteReadOnly };

    // Standard exceptions - some Orb supports them

exception TransactionRequired {};

exception TransactionRolledBack {};

exception InvalidTransaction {};

    // Heuristic exceptions

exception HeuristicRollback {};

       exception HeuristicCommit {};

       exception HeuristicMixed {};

       exception HeuristicHazard {};

    // Exception from ORB

exception WrongTransaction {};

    // Other transaction related exceptions

exception SubtransactionsUnavailable {};

exception NotSubtransaction {};

exception Inactive {};

exception NotPrepared {};

exception NoTransaction {};

exception InvalidControl {};

exception Unavailable {};

exception SynchronizationUnavailable {};

    // Forward references for later interfaces

interface Control;

interface Terminator;

interface Coordinator;

interface Resource;

interface RecoveryCoordinator;

interface SubtransactionAwareResource;

interface TransactionFactory;

interface TransactionalObject;

interface Current;

interface Synchronization;

    // Formally part of CosTSInteroperation

struct otid_t

{

    long formatID;

    long bequal_length;

    sequence <octet> tid;

};

struct TransIdentity

       {

           Coordinator coord;

       Terminator term;

           otid_t otid;

       };

struct PropagationContext

      {

       unsigned long timeout;

          TransIdentity currentTransaction;

       sequence <TransIdentity> parents;

       any implementation_specific_data;

      };

      interface Current : CORBA::Current

      {

       void begin () raises (SubtransactionsUnavailable);

       void commit (in boolean report_heuristics) raises (NoTransaction, HeuristicMixed, HeuristicHazard, TransactionRolledBack);

       void rollback () raises (NoTransaction);

       void rollback_only () raises (NoTransaction);


       Status get_status ();

       string get_transaction_name ();

       void set_timeout (in unsigned long seconds);


       Control get_control ();

       Control suspend ();

       void resume (in Control which) raises (InvalidControl);

      };

interface TransactionFactory

      {

       Control create (in unsigned long time_out);

           Control recreate (in PropagationContext ctx);

      };

interface Control

      {

       Terminator get_terminator () raises (Unavailable);

       Coordinator get_coordinator () raises (Unavailable);

      };

interface Terminator

      {

       void commit (in boolean report_heuristics) raises (HeuristicMixed, HeuristicHazard, TransactionRolledBack);

       void rollback ();

      };

      interface Coordinator

      {

       Status get_status ();

       Status get_parent_status ();

       Status get_top_level_status ();


       boolean is_same_transaction (in Coordinator tc);

       boolean is_related_transaction (in Coordinator tc);

       boolean is_ancestor_transaction (in Coordinator tc);

       boolean is_descendant_transaction (in Coordinator tc);

       boolean is_top_level_transaction ();


           unsigned long hash_transaction ();

       unsigned long hash_top_level_tran ();


       RecoveryCoordinator register_resource (in Resource r) raises (Inactive);

       void register_synchronization (in Synchronization sync) raises (Inactive, SynchronizationUnavailable);

       void register_subtran_aware (in SubtransactionAwareResource r) raises (Inactive, NotSubtransaction);


       void rollback_only () raises (Inactive);


       string get_transaction_name ();


       Control create_subtransaction () raises (SubtransactionsUnavailable, Inactive);


       PropagationContext get_txcontext () raises (Unavailable);

      };

      interface RecoveryCoordinator

      {

       Status replay_completion (in Resource r) raises (NotPrepared);

      };

interface Resource

       {

       Vote prepare () raises (HeuristicMixed, HeuristicHazard);

       void rollback () raises (HeuristicCommit, HeuristicMixed, HeuristicHazard);

       void commit () raises (NotPrepared, HeuristicRollback, HeuristicMixed, HeuristicHazard);

       void commit_one_phase () raises (HeuristicHazard);

       void forget ();

      };

interface SubtransactionAwareResource : Resource

      {

       void commit_subtransaction (in Coordinator parent);

       void rollback_subtransaction ();

      };

interface TransactionalObject

      {

      };   

interface Synchronization : TransactionalObject

      {

       void before_completion ();

       void after_completion (in Status s);

      };

};

#endif

#ifndef ARJUNAOTS_IDL_

#define ARJUNAOTS_IDL_


#include <idl/CosTransactions.idl>

module ArjunaOTS

{

    exception ActiveTransaction {};

    exception BadControl {};

    exception Destroyed {};

    exception ActiveThreads {};

    exception InterpositionFailed {};


    interface UidCoordinator : CosTransactions::Coordinator

    {

   readonly attribute string uid;

   readonly attribute string topLevelUid;

    };

    interface ActionControl : CosTransactions::Control

    {

        CosTransactions::Control getParentControl ()

                                                raises (CosTransactions::Unavailable,

                                                  CosTransactions::NotSubtransaction);

        void destroy () raises (ActiveTransaction, ActiveThreads, BadControl,

                                Destroyed);

    };


    interface ArjunaSubtranAwareResource : 

                                     CosTransactions::SubtransactionAwareResource

    {

   CosTransactions::Vote prepare_subtransaction ();

    };

    interface ArjunaTransaction : UidCoordinator, CosTransactions::Terminator

    {

    };


    interface OTSAbstractRecord : ArjunaSubtranAwareResource

    {

        readonly attribute long typeId;

        readonly attribute string uid;


        boolean propagateOnAbort ();

        boolean propagateOnCommit ();


        boolean saveRecord ();


        void merge (in OTSAbstractRecord record);

        void alter (in OTSAbstractRecord record);


        boolean shouldAdd (in OTSAbstractRecord record);

        boolean shouldAlter (in OTSAbstractRecord record);

        boolean shouldMerge (in OTSAbstractRecord record);

        boolean shouldReplace (in OTSAbstractRecord record);

    };

};