TaskInfo.h

//========================================================================================
// 
// $File$
// 
// Owner: Florin Trofin
// 
// $Author$
// 
// $DateTime$
// 
// $Revision$
// 
// $Change$
// 
// Copyright 1997-2010 Adobe Systems Incorporated. All rights reserved.
// 
// NOTICE: All information contained herein is, and remains
// the property of Adobe Systems Incorporated and its suppliers,
// if any. The intellectual and technical concepts contained
// herein are proprietary to Adobe Systems Incorporated and its
// suppliers and may be covered by U.S. and Foreign Patents,
// patents in process, and are protected by trade secret or copyright law.
// Dissemination of this information or reproduction of this material
// is strictly forbidden unless prior written permission is obtained
// from Adobe Systems Incorporated.
// 
//========================================================================================

#ifndef __TASKINFO_H__
#define __TASKINFO_H__

#include <utility>
#include <boost/intrusive_ptr.hpp>
#include <boost/operators.hpp>
#include "AsyncWork.h"
#include "PMString.h"
#include <adobe/move.hpp>


struct AsyncWorkPacketJobSpec;

class IDTask;
class MemXferBytes;
// We need intrusive_ptr instead of shared_ptr because of size constraints (intrusive_ptr has the same size as T*)
typedef boost::intrusive_ptr<IDTask> IDTaskPtr;


//---------------------------------------------------------------------------------------
struct AlertMessage
{
 enum AlertType { kGenericMsg,
 kInformationMsg,
 kWarningMsg, 
 kErrorMsg
 };
 
 AlertMessage()
 : fAlertType(kGenericMsg)
 {
 }
 
 AlertMessage(AlertType type, PMString const& message)
 : fAlertType(type), fMessage(message)
 {
 }
 
 AlertType fAlertType; 
 PMString fMessage; 
};

typedef std::vector<AlertMessage> AlertMessageQueue;

//---------------------------------------------------------------------------------------
class IErrorState;

struct ErrorStateInfo
{
 ErrorStateInfo() : fCode(kSuccess), fErrorInfoClass(kInvalidClass)
 {}

 explicit ErrorStateInfo(IErrorState* errState);
 void WriteErrorInfoToBuffer(IPMUnknown* errorInfo);

 IPMUnknown* ReadErrorInfoFromBuffer() const;
 
 ErrorCode fCode; 
 PMString fString; 
 PMString fContext; 
 boost::shared_ptr<MemXferBytes> fErrorInfoBuffer; 
 ClassID fErrorInfoClass; 
};

//---------------------------------------------------------------------------------------

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

class TaskProgressInfo
{
public:
 typedef std::pair<uint32, uint32> ProgressRange;
 
 struct ProgressData
 {
 ProgressData() : fRange(0, 0), fPercentage(0.0), fCurrentPosition(0) 
 {}
 
 PMString fTaskStatusText; 
 ProgressRange fRange; 
 PMReal fPercentage; 
 uint32 fCurrentPosition; 
 };
 
 // Constructor
 TaskProgressInfo()
 {}
 
 bool GetCurrentData(ProgressData& data) const;
 
 // Convenience accessors
 inline PMString GetTaskStatusText() const
 {
 ProgressData data;
 GetCurrentData(data);
 return data.fTaskStatusText;
 }

 inline ProgressRange GetRange() const
 {
 ProgressData data;
 GetCurrentData(data);
 return data.fRange;
 }
 
 inline uint32 GetCurrentPosition() const
 {
 ProgressData data;
 GetCurrentData(data);
 return data.fCurrentPosition;
 }

 inline PMReal GetTaskCompletionPercentage() const
 {
 ProgressData data;
 GetCurrentData(data);
 return data.fPercentage;
 }
 
private:
 friend class IDTaskAccessor;
 
 void SetRange(ProgressRange range);
 
 void SetCurrentPosition(uint32 pos);
 
 void SetTaskCompletionPercentage(PMReal percentage);
 
 ProgressData fData; 
 IDThreading::spin_mutex fDataLock; 
};

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

class TaskStatusInfo
{
public:
 
 enum TaskState
 {
 kQueued = 0x0, 
 kRunning = 0x1, 
 kFinishing = 0x2, 
 kCompleted = 0x3, 
 kCancelling = 0x4, 
 kCancelled = 0x5, 
 kWaiting = 0x6, 
 kForceKilled = 0x7, 
 };
 
 struct StatusData
 {
 StatusData() : fCurrentState(kQueued), fWasCancelled(false)
 {}
 
 ErrorStateInfo fExitErrorStateInfo; 
 AlertMessageQueue fAlertMessageQueue; 
 TaskState fCurrentState; 
 bool fWasCancelled; 
 };
 
 TaskStatusInfo()
 {}
 
 TaskState GetCurrentState() const;
 
 ErrorStateInfo GetTaskExitErrorStateInfo() const;
 
 AlertMessageQueue GetAlertMessages() const;

 void ClearAlertMessages();

 bool WasCancelled() const;
 
 StatusData GetCurrentData() const;
 
private:
 friend class IDTaskAccessor;
 
 /* ---------- Called only internally -----------------*/
 
 void SetState(TaskState newState);
 
 void AppendAlert(const AlertMessage& msg);
 
 void SetExitErrorStateInfo(const ErrorStateInfo &info);

 // Sets the internal state to cancelled
 void Cancel();
 
 StatusData fStatusData; 
 IDThreading::spin_mutex fDataLock; 
};



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

class TaskInfo : boost::equality_comparable<TaskInfo, TaskInfo>
{
public:
 
 typedef AsyncWorkPacketID TaskID;
 explicit TaskInfo(const IDTaskPtr& myTask);
 explicit TaskInfo(IDTask& myTask);
 TaskInfo();
 ~TaskInfo();
 TaskInfo(const TaskInfo& other);

 TaskInfo(adobe::move_from<TaskInfo> other);
 
 TaskInfo& operator=(TaskInfo other);
 

 TaskID GetID() const;

 bool GetTaskStatusData(TaskStatusInfo::StatusData& data) const;
 
 bool GetTaskProgressData(TaskProgressInfo::ProgressData& data) const; 
 
 const AsyncWorkPacketJobSpec& GetJobSpec() const;
 
 PMString GetName() const;

 TaskStatusInfo::TaskState GetCurrentState() const; 

 void ClearAlertMessages();

 PMReal GetTaskCompletionPercentage() const;

 AlertMessageQueue GetAlertMessages() const;

 ErrorStateInfo GetTaskExitErrorStateInfo() const;

 bool WasCancelled() const;

 inline bool IsValid() const
 {
 return fTask != nil;
 }
 
 
 void Cancel();
 
 TaskStatusInfo::TaskState WaitForTask();
 

 // Operators:
 friend inline void swap(TaskInfo& left, TaskInfo& right)
 {
 swap(left.fTask, right.fTask);
 }
 
 friend inline bool operator==(TaskInfo const& left, TaskInfo const& right)
 {
 return left.GetID() == right.GetID();
 }
 
private:
 
 IDTaskPtr fTask; 
};

// specialize adobe::type_info<> to avoid typeid problems across DLL boundaries
ADOBE_NAME_TYPE_0("taskinfo:indesign:adobe",TaskInfo);

#endif // __TASKINFO_H__