pegasus/src/Pegasus/Common/AsyncOpNode.h - diff

Return to AsyncOpNode.h CVS log

Up to [Pegasus] / pegasus / src / Pegasus / Common

Diff for /pegasus/src/Pegasus/Common/AsyncOpNode.h between version 1.1 and 1.1.2.3

version 1.1, 2001/10/17 16:02:45

version 1.1.2.3, 2001/10/25 15:41:00

Line 0

Line 1

//%///////////-*-c++-*-//////////////////////////////////////////////////////

// Permission is hereby granted, free of charge, to any person obtaining a copy

// of this software and associated documentation files (the "Software"), to

// deal in the Software without restriction, including without limitation the

// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or

// sell copies of the Software, and to permit persons to whom the Software is

// furnished to do so, subject to the following conditions:

// THE ABOVE COPYRIGHT NOTICE AND THIS PERMISSION NOTICE SHALL BE INCLUDED IN

// ALL COPIES OR SUBSTANTIAL PORTIONS OF THE SOFTWARE. THE SOFTWARE IS PROVIDED

// "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT

// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR

// PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT

// HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN

// ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

//==============================================================================

// Author: Mike Day (mdday@us.ibm.com)

// Modified By:

//%/////////////////////////////////////////////////////////////////////////////

#ifndef Pegasus_AsyncOpNode_h

#define Pegasus_AsyncOpNode_h

#include <Pegasus/Common/IPC.h>

#include <Pegasus/Common/DQueue.h>

#include <Pegasus/Common/Config.h>

#include <Pegasus/Common/Message.h>

#include <Pegasus/Common/ResponseHandler.h>

PEGASUS_NAMESPACE_BEGIN

class PEGASUS_COMMON_LINKAGE AsyncOpFlags

{

public:

static const Uint32 UNKNOWN;

static const Uint32 DELIVER;

static const Uint32 RESERVE;

static const Uint32 PROCESSING;

static const Uint32 COMPLETE;

static const Uint32 INTERVAL_REPEAT;;

static const Uint32 INDICATION;

static const Uint32 REMOTE;

static const Uint32 LOCAL_OUT_OF_PROC;

};

class PEGASUS_COMMON_LINKAGE AsyncOpState

{

public:

static const Uint32 NORMAL;

static const Uint32 PHASED;

static const Uint32 PARTIAL;

static const Uint32 TIMEOUT;

static const Uint32 SINGLE;

static const Uint32 MULTIPLE;

static const Uint32 TOTAL;

};

enum ResponseHandlerType

{

UNDEFINED,

CIM_CLASS,

CIM_INSTANCE,

CIM_OBJECT,

CIM_OBJECT_WITH_PATH,

CIM_VALUE,

CIM_INDICATION,

CIM_REFERENCE

};

// ok, create a wrapper facade around the responsehandler,

// include type info and acces functions,

// use static casting to retrieve from array<object_type>

class PEGASUS_COMMON_LINKAGE AsyncOpNode

{

public:

AsyncOpNode(void) { }

virtual ~AsyncOpNode(void) { }

//-------- Pure Virtual Methods --------//

// clear the node so it can be reused

virtual void reset(void) throw(IPCException) = 0;

virtual Boolean operator == (const void *key) const = 0;

virtual Boolean operator == (const AsyncOpNode & node) const = 0;

virtual Boolean timeout(void) throw(IPCException) = 0;

virtual void notify(const void *key,

OperationContext *context,

Uint32 flag,

Uint32 state) throw(IPCException) = 0;

virtual void put_req_context(OperationContext *context) throw(IPCException) = 0;

virtual void put_proc_context(OperationContext *context) throw(IPCException)= 0;

virtual void put_completion_context(OperationContext *context) throw(IPCException) = 0;

virtual OperationContext *take_req_context(void) throw(IPCException) = 0;

virtual OperationContext *take_proc_context(void) throw(IPCException) = 0;

virtual OperationContext *take_completion_context(void) throw(IPCException) = 0;

virtual void put_request(Message *request) throw(IPCException) = 0;

virtual Message *take_request(void) throw(IPCException) = 0;

virtual void put_response(Message *response) throw(IPCException) = 0;

virtual Message *take_response(void) throw(IPCException) = 0;

virtual void set_state_bits(Uint32 bits) throw(IPCException) = 0;

virtual void clear_state_bits(Uint32 bits) throw(IPCException) = 0;

virtual Uint32 get_state(void) throw(IPCException) = 0;

virtual Boolean test_state_bit(Uint32 mask) throw(IPCException) = 0;

virtual void set_flag_bits(Uint32 bits) throw(IPCException) = 0;

virtual void clear_flag_bits(Uint32 bits) throw(IPCException) = 0;

virtual Uint32 get_flag_bits(void) throw(IPCException) = 0;

virtual Boolean test_flag_bit(Uint32 mask) throw(IPCException) = 0;

virtual void set_lifetime(struct timeval *lifetime) throw(IPCException) = 0;

virtual Boolean check_lifetime(void) const throw(IPCException) = 0;

virtual void lock(void) throw(IPCException) = 0;

virtual void unlock(void) throw(IPCException) = 0;

virtual void check_owner(void) throw(IPCException) = 0;

virtual ResponseHandlerType get_rh_type(void) = 0;

virtual Boolean is_child(void) = 0;

virtual Uint32 is_parent(void) = 0;

virtual Boolean is_my_child(AsyncOpNode *myself) = 0;

virtual void make_orphan( AsyncOpNode *parent) = 0;

virtual Uint32 get_total_operations(void) = 0;

virtual Uint32 get_completed_operations(void) = 0;

};

PEGASUS_NAMESPACE_END

#endif //Pegasus_AsyncOpNode_h

Legend:

Removed from v.1.1
changed lines
	Added in v.1.1.2.3

No CVS admin address has been configured