DataStatus.h

// -*- indent-tabs-mode: nil -*-

#ifndef __ARC_DATASTATUS_H__
#define __ARC_DATASTATUS_H__

#include <iostream>
#include <string>
#include <errno.h>

#include <arc/StringConv.h>
#include <arc/Utils.h>

namespace Arc {
  
#define DataStatusRetryableBase (100)

#define DataStatusErrnoBase 1000
#define EARCTRANSFERTIMEOUT  (DataStatusErrnoBase + 1) // Transfer timed out
#define EARCCHECKSUM         (DataStatusErrnoBase + 2) // Checksum mismatch
#define EARCLOGIC            (DataStatusErrnoBase + 3) // Bad logic, eg calling StartWriting on a
                                                       // DataPoint currently reading
#define EARCRESINVAL         (DataStatusErrnoBase + 4) // All results obtained from a service are invalid
#define EARCSVCTMP           (DataStatusErrnoBase + 5) // Temporary service error
#define EARCSVCPERM          (DataStatusErrnoBase + 6) // Permanent service error
#define EARCUIDSWITCH        (DataStatusErrnoBase + 7) // Error switching uid
#define EARCREQUESTTIMEOUT   (DataStatusErrnoBase + 8) // Request made to remote service timed out
#define EARCOTHER            (DataStatusErrnoBase + 9) // Other / unknown error

#define DataStatusErrnoMax EARCOTHER


  class DataStatus {

  public:


    enum DataStatusType {
      // Order is important! Must be kept synchronised with status_string[]

      Success,

      ReadAcquireError,

      WriteAcquireError,

      ReadResolveError,

      WriteResolveError,

      ReadStartError,

      WriteStartError,

      ReadError,

      WriteError,

      TransferError,

      ReadStopError,

      WriteStopError,

      PreRegisterError,

      PostRegisterError,

      UnregisterError,

      CacheError,

      CredentialsExpiredError,

      DeleteError,

      NoLocationError,

      LocationAlreadyExistsError,

      NotSupportedForDirectDataPointsError,

      UnimplementedError,

      IsReadingError,

      IsWritingError,

      CheckError,

      ListError,
      ListNonDirError,

      StatError,
      StatNotPresentError,

      NotInitializedError,

      SystemError,
    
      StageError,
      
      InconsistentMetadataError,
 
      ReadPrepareError,

      ReadPrepareWait,

      WritePrepareError,

      WritePrepareWait,

      ReadFinishError,

      WriteFinishError,

      CreateDirectoryError,

      RenameError,

      SuccessCached,
      
      SuccessCancelled,

      GenericError,

      UnknownError,

      // These Retryable error codes are deprecated but kept for backwards
      // compatibility. They will be removed in a future major release.
      // Instead of these codes the corresponding non-retryable code should be
      // used with an errno, and this is used to determine whether the error is
      // retryable.
      ReadAcquireErrorRetryable = DataStatusRetryableBase+ReadAcquireError, 
      WriteAcquireErrorRetryable = DataStatusRetryableBase+WriteAcquireError, 
      ReadResolveErrorRetryable = DataStatusRetryableBase+ReadResolveError, 
      WriteResolveErrorRetryable = DataStatusRetryableBase+WriteResolveError, 
      ReadStartErrorRetryable = DataStatusRetryableBase+ReadStartError, 
      WriteStartErrorRetryable = DataStatusRetryableBase+WriteStartError, 
      ReadErrorRetryable = DataStatusRetryableBase+ReadError, 
      WriteErrorRetryable = DataStatusRetryableBase+WriteError, 
      TransferErrorRetryable = DataStatusRetryableBase+TransferError, 
      ReadStopErrorRetryable = DataStatusRetryableBase+ReadStopError, 
      WriteStopErrorRetryable = DataStatusRetryableBase+WriteStopError, 
      PreRegisterErrorRetryable = DataStatusRetryableBase+PreRegisterError, 
      PostRegisterErrorRetryable = DataStatusRetryableBase+PostRegisterError, 
      UnregisterErrorRetryable = DataStatusRetryableBase+UnregisterError, 
      CacheErrorRetryable = DataStatusRetryableBase+CacheError, 
      DeleteErrorRetryable = DataStatusRetryableBase+DeleteError, 
      CheckErrorRetryable = DataStatusRetryableBase+CheckError, 
      ListErrorRetryable = DataStatusRetryableBase+ListError, 
      StatErrorRetryable = DataStatusRetryableBase+StatError, 
      StageErrorRetryable = DataStatusRetryableBase+StageError, 
      ReadPrepareErrorRetryable = DataStatusRetryableBase+ReadPrepareError, 
      WritePrepareErrorRetryable = DataStatusRetryableBase+WritePrepareError, 
      ReadFinishErrorRetryable = DataStatusRetryableBase+ReadFinishError, 
      WriteFinishErrorRetryable = DataStatusRetryableBase+WriteFinishError, 
      CreateDirectoryErrorRetryable = DataStatusRetryableBase+CreateDirectoryError, 
      RenameErrorRetryable = DataStatusRetryableBase+RenameError, 
      GenericErrorRetryable = DataStatusRetryableBase+GenericError 
   };


    DataStatus(const DataStatusType& status, std::string desc="")
      : status(status), Errno(0), desc(desc) {
      if (!Passed()) Errno = EARCOTHER;
    }


    DataStatus(const DataStatusType& status, int error_no, const std::string& desc="")
      : status(status), Errno(error_no), desc(desc) {}

    DataStatus()
      : status(Success), Errno(0), desc("") {}

    bool operator==(const DataStatusType& s) {
      return status == s;
    }
    bool operator==(const DataStatus& s) {
      return status == s.status;
    }
  
    bool operator!=(const DataStatusType& s) {
      return status != s;
    }
    bool operator!=(const DataStatus& s) {
      return status != s.status;
    }


    DataStatus& operator=(const DataStatusType& s) {
      status = s;
      Errno = 0;
      if (!Passed()) Errno = EARCOTHER;
      desc.clear();
      return *this;
    }

    DataStatus& operator=(const DataStatus& s) {
      status = s.status;
      Errno = s.Errno;
      desc = s.desc;
      return *this;
    }

    bool operator!() const {
      return (status != Success) && (status != SuccessCached);
    }
    operator bool() const {
      return (status == Success) || (status == SuccessCached);
    }

    bool Passed() const {
      return ((status == Success) || (status == NotSupportedForDirectDataPointsError) ||
              (status == ReadPrepareWait) || (status == WritePrepareWait) ||
              (status == SuccessCached) || (status == SuccessCancelled));
    }
  

    bool Retryable() const;

    DataStatusType GetStatus() const {
      return status;
    }

    void SetErrno(int error_no) {
      Errno = error_no;
    }
  
    int GetErrno() const {
      return Errno;
    }

    std::string GetStrErrno() const;

    void SetDesc(const std::string& d) {
      desc = trim(d);
    }
    
    std::string GetDesc() const {
      return desc;
    }

    operator std::string(void) const;

  private:
  
    DataStatusType status;
    int Errno;
    std::string desc;

  };


  inline std::ostream& operator<<(std::ostream& o, const DataStatus& d) {
    return (o << ((std::string)d));
  }
} // namespace Arc


#endif // __ARC_DATASTATUS_H__