//Object Transaction Service, v1.4 - OMG IDL Summary File
//Object Management Group, Inc.
//
//Copyright 1997, BEA Systems
//Copyright 1994-1996, Groupe Bull
//Copyright 1994-1996, IBM
//Copyright 1994-1996, ICL plc
//Copyright 1994-1996, Iona Technologies, Ltd.
//Copyright 1994-1996, Novell, Inc.
//Copyright 2003, Object Management Group, Inc.
//Copyright 1995-1996, Sun Microsystems, Inc.
//Copyright 1994-1996, SunSoft, Inc.
//Copyright 1994-1996, Tandem Computers, Inc.
//Copyright 1994-1996, Tivoli Systems, Inc.
//Copyright 1994-1996, Transarc Corporation
//
//The companies listed above have granted to the Object Management Group, Inc. 
//(OMG) a nonexclusive, royalty-free, paid up, worldwide license to copy and 
//distribute this document and to modify this document and distribute copies of 
//the modified version. Each of the copyright holders listed above has agreed 
//that no person shall be deemed to have infringed the copyright in the included 
//material of any such copyright holder by reason of having used the 
//specification set forth herein or having conformed any computer software to 
//the specification. 
//
//This file contains OMG IDL from the Object Transaction Service, v1.4 //specification. OMG regularly publishes a summary file that contains all the //"code" parts of an OMG formal document. Every formal document line that is //IDL, PIDL, or language code is included in the summary file. The reason for //such a listing is to give readers an electronic version of the "code" so that //they can extract pieces of it. Readers might want to test an example, include //it in their own code, or use it for documentation purposes. Having the code //lines available electronically means there is less likelihood of a //transcription error. 


//CosTransactions Module

#include <orb.idl>
module CosTransactions {
// DATATYPES 
enum Status {
	StatusActive,
	StatusMarkedRollback,
	StatusPrepared,
	StatusCommitted,
	StatusRolledBack,
	StatusUnknown,
	StatusNoTransaction,
	StatusPreparing,
	StatusCommitting,
	StatusRollingBack
};

enum Vote {
	VoteCommit,
	VoteRollback,
	VoteReadOnly
};

typedef unsigned short TransactionPolicyValue;
// TransactionPolicyValue definitions are deprecated and replaced //
// with new InvocationPolicy and OTSPolicy definitions. They are //
// retained for backward compatibility. //
const TransactionPolicyValue    Allows_shared = 0;
const TransactionPolicyValue    Allows_none = 1;
const TransactionPolicyValue    Requires_shared = 2;
const TransactionPolicyValue    Allows_unshared = 3;
const TransactionPolicyValue    Allows_either = 4;
const TransactionPolicyValue    Requires_unshared = 5;
const TransactionPolicyValue    Requires_either = 6; 

// Forward references for interfaces defined later in module
local interface Current;
interface TransactionFactory;
interface Control;
interface Terminator;
interface Coordinator;
interface RecoveryCoordinator;
interface Resource;
interface Synchronization;
interface SubtransactionAwareResource;

// TransactionalObject has been deprecated.
interface TransactionalObject;

// Structure definitions
struct otid_t {
	long formatID; /*format identifier. 0 is OSI TP */
	long bqual_length;
	sequence <octet> tid;
};

struct TransIdentity {
	Coordinator coord;
	Terminator term;
	otid_t otid;
};
struct PropagationContext {
	unsigned long timeout;
	TransIdentity current;
	sequence <TransIdentity> parents;
	any implementation_specific_data;
};

// Heuristic exceptions
exception HeuristicRollback {};
exception HeuristicCommit {};
exception HeuristicMixed {};
exception HeuristicHazard {};

// Other transaction-specific exceptions
exception SubtransactionsUnavailable {};
exception NotSubtransaction {};
exception Inactive {};
exception NotPrepared {};
exception NoTransaction {};
exception InvalidControl {};
exception Unavailable {};
exception SynchronizationUnavailable {};

// Current transaction 
local interface Current : CORBA::Current {
	void begin()
		raises(SubtransactionsUnavailable);
	void commit(in boolean report_heuristics)
		raises(
			NoTransaction,
			HeuristicMixed,
			HeuristicHazard
		);
	void rollback()
		raises(NoTransaction);
	void rollback_only()
		raises(NoTransaction);
	Status get_status();
	string get_transaction_name();
	void set_timeout(in unsigned long seconds);
	unsigned long get_timeout ();
	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
		);
	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();
};

// TransactionalObject has been deprecated
// and replaced by the OTSPolicy component
// Synchronization will use the OTSPolicy of ADAPTS
// Inheritance from TransactionalObject is for backward compatability/

interface Synchronization : TransactionalObject {
	void before_completion();
	void after_completion(in Status s);
};

interface SubtransactionAwareResource : Resource {
	void commit_subtransaction(in Coordinator parent);
	void rollback_subtransaction();
};

// TransactionalObject has been deprecated.
interface TransactionalObject {
};

const CORBA::PolicyType    TransactionPolicyType = 46;

interface TransactionPolicy : CORBA::Policy {
	readonly attribute TransactionPolicyValue tpv;
};

typedef unsigned short InvocationPolicyValue;

const InvocationPolicyValue EITHER = 0;
const InvocationPolicyValue SHARED = 1;
const InvocationPolicyValue UNSHARED =2;

typedef unsigned short OTSPolicyValue;

const OTSPolicyValue REQUIRES = 1;
const OTSPolicyValue FORBIDS =2;
const OTSPolicyValue ADAPTS =3;

typedef unsigned short NonTxTargetPolicyValue;

const NonTxTargetPolicyValue PREVENT = 0;
const NonTxTargetPolicyValue PERMIT = 1;

const CORBA::PolicyType INVOCATION_POLICY_TYPE = 55;

interface InvocationPolicy : CORBA::Policy {
	readonly attribute InvocationPolicyValue ipv;
};

const CORBA::PolicyType OTS_POLICY_TYPE = 56;

interface OTSPolicy : CORBA::Policy {
	readonly attribute OTSPolicyValue tpv;
};

// Deprecated
const CORBA::PolicyType NON_TX_TARGET_POLICY_TYPE = 57;

// Deprecated
interface NonTxTargetPolicy : CORBA::Policy {
	readonly attribute NonTxTargetPolicyValue tpv;
};

}; // End of CosTransactions Module

//CosTSPortability Module
// Commented out, CORBA::Environment does not exist
/* module CosTSPortability { // PIDL
	typedef long ReqId;

	interface Sender {
		void sending_request(in ReqId id,
			out CosTransactions::PropagationContext ctx);
		void received_reply(in ReqId id,
			in CosTransactions::PropagationContext ctx, 
			in CORBA::Environment env);
	};

	interface Receiver {
		void received_request(in ReqId id,
			in CosTransactions::PropagationContext ctx);
		void sending_reply(in ReqId id,
			out CosTransactions::PropagationContext ctx);
	};
}; */

//CosTSInteroperation Module
#include <orb.idl>
#include <IOP.idl>
module CosTSInteroperation {

	const IOP::ComponentId TAG_TRANSACTION_POLICY=26;

	struct TransactionPolicyComponent {
		CosTransactions::TransactionPolicyValue       tpv;
	};

	const IOP::ComponentId TAG_OTS_POLICY= 31; 

	const IOP::ComponentId TAG_INV_POLICY= 32;
};