DataPoint.h

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

// Summary page for libarcdata doxygen module
// Enclosed in Arc namespace so automatic linking to other classes works
namespace Arc {
} // namespace Arc

#ifndef __ARC_DATAPOINT_H__
#define __ARC_DATAPOINT_H__

#include <list>
#include <set>
#include <string>

#include <arc/DateTime.h>
#include <arc/URL.h>
#include <arc/UserConfig.h>
#include <arc/data/DataStatus.h>
#include <arc/data/FileInfo.h>
#include <arc/data/URLMap.h>
#include <arc/loader/Loader.h>
#include <arc/loader/Plugin.h>

namespace Arc {

  class Logger;
  class DataBuffer;
  class DataCallback;
  class XMLNode;
  class CheckSum;


  class DataPoint
    : public Plugin {
  public:


    typedef void(*Callback3rdParty)(unsigned long long int bytes_transferred);


    enum DataPointAccessLatency {
      ACCESS_LATENCY_ZERO,
      ACCESS_LATENCY_SMALL,
      ACCESS_LATENCY_LARGE
    };

    enum DataPointInfoType {
      INFO_TYPE_MINIMAL = 0,  
      INFO_TYPE_NAME = 1,     
      INFO_TYPE_TYPE = 2,     
      INFO_TYPE_TIMES = 4,    
      INFO_TYPE_CONTENT = 8,  
      INFO_TYPE_ACCESS = 16,  
      INFO_TYPE_STRUCT = 32,  
      INFO_TYPE_REST = 64,    
      INFO_TYPE_ALL = 127     
    };


    static DataStatus Transfer3rdParty(const URL& source, const URL& destination,
                                       const UserConfig& usercfg, Callback3rdParty callback = NULL);

    virtual ~DataPoint();

    virtual const URL& GetURL() const;

    virtual const UserConfig& GetUserConfig() const;


    virtual bool SetURL(const URL& url);

    virtual std::string str() const;

    virtual operator bool() const;

    virtual bool operator!() const;


    virtual DataStatus PrepareReading(unsigned int timeout,
                                      unsigned int& wait_time);


    virtual DataStatus PrepareWriting(unsigned int timeout,
                                      unsigned int& wait_time);


    virtual DataStatus StartReading(DataBuffer& buffer) = 0;


    virtual DataStatus StartWriting(DataBuffer& buffer,
                                    DataCallback *space_cb = NULL) = 0;


    virtual DataStatus StopReading() = 0;


    virtual DataStatus StopWriting() = 0;


    virtual DataStatus FinishReading(bool error = false);


    virtual DataStatus FinishWriting(bool error = false);


    virtual DataStatus Check(bool check_meta) = 0;

    virtual DataStatus Remove() = 0;


    virtual DataStatus Stat(FileInfo& file, DataPointInfoType verb = INFO_TYPE_ALL) = 0;


    virtual DataStatus Stat(std::list<FileInfo>& files,
                            const std::list<DataPoint*>& urls,
                            DataPointInfoType verb = INFO_TYPE_ALL) = 0;


    virtual DataStatus List(std::list<FileInfo>& files, DataPointInfoType verb = INFO_TYPE_ALL) = 0;


    virtual DataStatus CreateDirectory(bool with_parents=false) = 0;


    virtual DataStatus Rename(const URL& newurl) = 0;


    virtual void ReadOutOfOrder(bool v) = 0;

    virtual bool WriteOutOfOrder() = 0;


    virtual void SetAdditionalChecks(bool v) = 0;

    virtual bool GetAdditionalChecks() const = 0;


    virtual void SetSecure(bool v) = 0;

    virtual bool GetSecure() const = 0;


    virtual void Passive(bool v) = 0;


    virtual DataStatus GetFailureReason(void) const;


    virtual void Range(unsigned long long int start = 0,
                       unsigned long long int end = 0) = 0;


    virtual DataStatus Resolve(bool source) = 0;


    virtual DataStatus Resolve(bool source, const std::list<DataPoint*>& urls) = 0;

    virtual bool Registered() const = 0;


    virtual DataStatus PreRegister(bool replication, bool force = false) = 0;


    virtual DataStatus PostRegister(bool replication) = 0;


    virtual DataStatus PreUnregister(bool replication) = 0;


    virtual DataStatus Unregister(bool all) = 0;

    virtual bool CheckSize() const;

    virtual void SetSize(const unsigned long long int val);

    virtual unsigned long long int GetSize() const;

    virtual bool CheckCheckSum() const;

    virtual void SetCheckSum(const std::string& val);

    virtual const std::string& GetCheckSum() const;

    virtual const std::string DefaultCheckSum() const;

    virtual bool CheckModified() const;

    virtual void SetModified(const Time& val);

    virtual const Time& GetModified() const;

    virtual bool CheckValid() const;

    virtual void SetValid(const Time& val);

    virtual const Time& GetValid() const;

    virtual void SetAccessLatency(const DataPointAccessLatency& latency);

    virtual DataPointAccessLatency GetAccessLatency() const;

    virtual long long int BufSize() const = 0;

    virtual int BufNum() const = 0;

    virtual bool Cache() const;

    virtual bool Local() const = 0;

    virtual bool ReadOnly() const = 0;

    virtual int GetTries() const;

    virtual void SetTries(const int n);

    virtual void NextTry();

    virtual bool RequiresCredentials() const;

    virtual bool IsIndex() const = 0;

    virtual bool IsStageable() const;

    virtual bool AcceptsMeta() const = 0;

    virtual bool ProvidesMeta() const = 0;


    virtual void SetMeta(const DataPoint& p);


    virtual bool CompareMeta(const DataPoint& p) const;


    virtual std::vector<URL> TransferLocations() const;

    virtual const URL& CurrentLocation() const = 0;


    virtual const std::string& CurrentLocationMetadata() const = 0;

    virtual DataPoint* CurrentLocationHandle() const = 0;


    virtual DataStatus CompareLocationMetadata() const = 0;
    

    virtual bool NextLocation() = 0;

    virtual bool LocationValid() const = 0;

    virtual bool LastLocation() = 0;

    virtual bool HaveLocations() const = 0;


    virtual DataStatus AddLocation(const URL& url,
                                   const std::string& meta) = 0;

    virtual DataStatus RemoveLocation() = 0;

    virtual DataStatus RemoveLocations(const DataPoint& p) = 0;

    virtual DataStatus ClearLocations() = 0;


    virtual int AddCheckSumObject(CheckSum *cksum) = 0;

    virtual const CheckSum* GetCheckSumObject(int index) const = 0;


    virtual void SortLocations(const std::string& pattern,
                               const URLMap& url_map) = 0;


    virtual void AddURLOptions(const std::map<std::string, std::string>& options);

  protected:
    URL url;
    const UserConfig usercfg;

    // attributes
    unsigned long long int size;
    std::string checksum;
    Time modified;
    Time valid;
    DataPointAccessLatency access_latency;
    int triesleft;
    DataStatus failure_code; /* filled by callback methods */
    bool cache;
    bool stageable;
    std::set<std::string> valid_url_options;

    static Logger logger;


    DataPoint(const URL& url, const UserConfig& usercfg, PluginArgument* parg);


    virtual DataStatus Transfer3rdParty(const URL& source, const URL& destination, Callback3rdParty callback = NULL);
  };

  class DataPointLoader
    : public Loader {
  private:
    DataPointLoader();
    ~DataPointLoader();
    DataPoint* load(const URL& url, const UserConfig& usercfg);
    friend class DataHandle;
  };
  class DataPointPluginArgument
    : public PluginArgument {
  public:
    DataPointPluginArgument(const URL& url, const UserConfig& usercfg)
      : url(url),
        usercfg(usercfg) {}
    ~DataPointPluginArgument() {}
    operator const URL&() {
      return url;
    }
    operator const UserConfig&() {
      return usercfg;
    }
  private:
    const URL& url;
    const UserConfig& usercfg;
  };
} // namespace Arc

#endif // __ARC_DATAPOINT_H__