file.hpp

Go to the documentation of this file.

 
#ifndef OKS_FILE_H
#define OKS_FILE_H
 
#include "oks/exceptions.hpp"
 
#include <string>
#include <list>
#include <set>
#include <map>
#include <memory>
 
#include <boost/date_time/posix_time/ptime.hpp>
 
#include <unordered_set>
#include <unordered_map>
 
 
namespace boost
{
  namespace interprocess
  {
    class file_lock;
  }
}
 
namespace dunedaq {
namespace oks {
 
class OksXmlOutputStream;
class OksXmlInputStream;
class OksKernel;
class OksFile;
 
  class FileLockError : public exception {
 
    public:
 
      FileLockError(const OksFile& file, bool lock_action, const std::string& reason) noexcept : exception (fill(file, lock_action, reason), 0) { }
 
      virtual ~FileLockError() noexcept { }
 
 
    private:
 
      static std::string fill(const OksFile& file, bool lock_action, const std::string& reason) noexcept;
 
  };
 
 
  class FileChangeError : public exception {
 
    public:
 
      FileChangeError(const OksFile& file, const std::string& action, const exception& reason) noexcept : exception (fill(file, action, reason.what()), reason.level() + 1) { }
 
      FileChangeError(const OksFile& file, const std::string& action, const std::string& reason) noexcept : exception (fill(file, action, reason), 0) { }
 
      virtual ~FileChangeError() noexcept { }
 
 
    private:
 
      static std::string fill(const OksFile& file, const std::string& action, const std::string& reason) noexcept;
 
  };
  
 
  class FileCompareError : public exception {
 
    public:
 
      FileCompareError(const std::string& src, const std::string& dest, const std::string& reason) noexcept : exception (fill(src, dest, reason), 0) { }
 
      virtual ~FileCompareError() noexcept { }
 
 
    private:
 
      static std::string fill(const std::string& src, const std::string& dest, const std::string& reason) noexcept;
 
  };
  
 
  class FailedAddInclude : public exception {
 
    public:
 
      FailedAddInclude(const OksFile& file, const std::string& include_name, const exception& reason) noexcept : exception (fill(file, include_name, reason.what()), reason.level() + 1) { }
 
      FailedAddInclude(const OksFile& file, const std::string& include_name, const std::string& reason) noexcept : exception (fill(file, include_name, reason), 0) { }
 
      virtual ~FailedAddInclude() noexcept { }
 
 
    private:
 
      static std::string fill(const OksFile& file, const std::string& include_name, const std::string& reason) noexcept;
 
  };
 
 
  class FailedRemoveInclude : public exception {
 
    public:
 
      FailedRemoveInclude(const OksFile& file, const std::string& include_name, const exception& reason) noexcept : exception (fill(file, include_name, reason.what()), reason.level() + 1) { }
 
      FailedRemoveInclude(const OksFile& file, const std::string& include_name, const std::string& reason) noexcept : exception (fill(file, include_name, reason), 0) { }
 
      virtual ~FailedRemoveInclude() noexcept { }
 
 
    private:
 
      static std::string fill(const OksFile& file, const std::string& include_name, const std::string& reason) noexcept;
 
  };
 
 
  class FailedRenameInclude : public exception {
 
    public:
 
      FailedRenameInclude(const OksFile& file, const std::string& from, const std::string& to, const exception& reason) noexcept : exception (fill(file, from, to, reason.what()), reason.level() + 1) { }
 
      FailedRenameInclude(const OksFile& file, const std::string& from, const std::string& to, const std::string& reason) noexcept : exception (fill(file, from, to, reason), 0) { }
 
      virtual ~FailedRenameInclude() noexcept { }
 
 
    private:
 
      static std::string fill(const OksFile& file, const std::string& from, const std::string& to, const std::string& reason) noexcept;
 
  };
 
 
  class FailedAddComment : public exception {
 
    public:
 
      FailedAddComment(const OksFile& file, const exception& reason) noexcept : exception (fill(file, reason.what()), reason.level() + 1) { }
 
      FailedAddComment(const OksFile& file, const std::string& reason) noexcept : exception (fill(file, reason), 0) { }
 
      virtual ~FailedAddComment() noexcept { }
 
 
    private:
 
      static std::string fill(const OksFile& file, const std::string& reason) noexcept;
 
  };
 
 
  class FailedRemoveComment : public exception {
 
    public:
 
      FailedRemoveComment(const OksFile& file, const std::string& creation_time, const exception& reason) noexcept : exception (fill(file, creation_time, reason.what()), reason.level() + 1) { }
 
      FailedRemoveComment(const OksFile& file, const std::string& creation_time, const std::string& reason) noexcept : exception (fill(file, creation_time, reason), 0) { }
 
      virtual ~FailedRemoveComment() noexcept { }
 
 
    private:
 
      static std::string fill(const OksFile& file, const std::string& creation_time, const std::string& reason) noexcept;
 
  };
 
 
  class FailedChangeComment : public exception {
 
    public:
 
      FailedChangeComment(const OksFile& file, const std::string& creation_time, const exception& reason) noexcept : exception (fill(file, creation_time, reason.what()), reason.level() + 1) { }
 
      FailedChangeComment(const OksFile& file, const std::string& creation_time, const std::string& reason) noexcept : exception (fill(file, creation_time, reason), 0) { }
 
      virtual ~FailedChangeComment() noexcept { }
 
 
    private:
 
      static std::string fill(const OksFile& file, const std::string& creation_time, const std::string& reason) noexcept;
 
  };
 
 
  class Comment {
 
    friend class OksFile;
 
    private:
 
      Comment() noexcept { ; }
 
      Comment(const std::string& text, const std::string& author);
 
      Comment(const oks::Comment& src) noexcept;
 
 
    public:
 
      const std::string& get_created_by() const { return p_created_by; }
 
      const std::string& get_author() const { return p_author; }
 
      const std::string& get_created_on() const { return p_created_on; }
 
      const std::string& get_text() const { return p_text; }
 
      void validate(const std::string& creation_time);
 
      void validate();
 
 
    private:
 
      std::string p_created_by;
      std::string p_author;
      std::string p_created_on;
      std::string p_text;
 
  };
 
  struct hash_file_ptr
  {
    inline size_t operator() ( const OksFile * x ) const {
      return reinterpret_cast<size_t>(x);
    }
  };
 
  struct equal_file_ptr
  {
    inline bool operator()(const OksFile * __x, const OksFile * __y) const {
      return (__x == __y);
    }
  };
 
 
class OksFile {
 
  friend class OksKernel;
  friend class OksClass;
  friend class OksObject;
  friend struct OksLoadObjectsJob;
 
  public:
 
    enum Mode {
      ReadOnly,
      ReadWrite
    };
 
    enum FileStatus {
      FileNotModified,
      FileModified,
      FileWasNotSaved,
      FileRemoved
    };
 
    struct SortByName {
      bool operator() (const std::string * s1, const std::string * s2) const {
        return *s1 < *s2;
      }
    };
 
    typedef std::map<const std::string *, OksFile *, SortByName> Map;
 
    typedef std::unordered_set<OksFile *, oks::hash_file_ptr, oks::equal_file_ptr> Set;
    typedef std::unordered_map<OksFile *, Set, oks::hash_file_ptr, oks::equal_file_ptr> IMap;
 
    void lock();
 
  // Nasty hack to allow code generation on the fly without locking
  // file. Off by default
  static void set_nolock_mode(bool nl) {p_nolock_mode = nl;}
 
 
 
    void unlock();
 
 
    void add_include_file(const std::string& name);
 
 
    void remove_include_file(const std::string& name);
 
 
    void rename_include_file(const std::string& from, const std::string& to);
 
 
    void add_comment(const std::string& text, const std::string& author);
 
 
    void modify_comment(const std::string& creation_time, const std::string& text, const std::string& author);
 
 
    void remove_comment(const std::string& creation_time);
 
 
    const std::map<std::string, oks::Comment *>& get_comments() const {return p_comments;}
 
 
    void set_logical_name(const std::string& name);
 
 
    void set_type(const std::string& type);
 
 
    const std::string& get_short_file_name() const {return p_short_name;}
 
 
    const std::string& get_full_file_name() const {return p_full_name;}
 
 
    bool is_repository_file() const;
 
 
    const std::string& get_repository_name() const {return p_repository_name;}
 
 
    const std::string&
    get_well_formed_name() const
      {
        return (!p_repository_name.empty() ? p_repository_name : p_full_name);
      }
 
    const std::string& get_lock_file() const { init_lock_name(); return p_lock_file_name; }
    const std::string& get_logical_name() const {return p_logical_name;}
    const std::string& get_type() const {return p_type;}
    const std::string& get_oks_format() const {return p_oks_format;}
 
 
    long get_number_of_items() const {return p_number_of_items;}
 
 
    long get_size() const {return p_size;}
 
 
    const std::string& get_created_by() const {return p_created_by;}
 
 
    const boost::posix_time::ptime get_creation_time() const {return p_creation_time;}
 
 
    const std::string& get_created_on() const {return p_created_on;}
 
 
    const std::string& get_last_modified_by() const {return p_last_modified_by;}
 
 
    const boost::posix_time::ptime get_last_modification_time() const {return p_last_modification_time;}
 
 
    const std::string& get_last_modified_on() const {return p_last_modified_on;}
 
 
    bool is_locked() const {return (p_lock != nullptr);}
 
 
    bool is_updated() const {return p_is_updated;}
 
 
    bool is_read_only() const {return p_is_read_only;}
 
 
    const std::list<std::string>& get_include_files() const {return p_list_of_include_files;}
 
 
    void get_all_include_files(const OksKernel * kernel, std::set<OksFile *>& out);
 
    FileStatus get_status_of_file() const;
 
 
    void update_status_of_file(bool update_local = true, bool update_repository = true);
  
 
    bool get_lock_string(std::string& info) const;
 
 
    static bool compare(const char * file1_name, const char * file2_name);
 
 
    bool compare(const char * name) const { return compare(p_full_name.c_str(), name); }
 
 
    const OksFile * get_parent() const { return p_included_by; }
 
 
    OksFile * check_parent(const OksFile * parent_h);
 
 
 
  public:
 
    ~OksFile() noexcept;
 
 
  private:
  static bool p_nolock_mode; // Nasty hack mode
 
    std::string p_short_name;  // short path to file
    std::string p_full_name;   // path which is used to open file
    std::string p_repository_name; // the name of file inside repository
    std::string p_logical_name;// name of file, e.g. "Control Workstations"
    std::string p_type;        // type of file, e.g. "DCS"
    std::string p_oks_format;  // format of file: "data" or "schema"
    long p_number_of_items;    // number of objects or classes
    long p_size;               // size of file in bytes
    std::string p_created_by;
    boost::posix_time::ptime p_creation_time;
    std::string p_created_on;
    std::string p_last_modified_by;
    boost::posix_time::ptime p_last_modification_time;
    std::string p_last_modified_on;
    Mode p_open_mode;
    std::shared_ptr<boost::interprocess::file_lock> p_lock;
    std::string p_lock_file_name; // lock file
    bool p_is_updated;
    bool p_is_read_only;
    std::list<std::string> p_list_of_include_files;
    time_t p_last_modified;
    time_t p_repository_last_modified;
    std::map<std::string, oks::Comment *> p_comments;
    bool p_is_on_disk;
    const OksFile * p_included_by;
    OksKernel * p_kernel;
 
    static const char xml_file_header[];
    static const char xml_schema_file_dtd[];
    static const char xml_data_file_dtd[];
    static const char xml_info_tag[];
    static const char xml_include_tag[];
    static const char xml_file_tag[];
    static const char xml_comments_tag[];
    static const char xml_comment_tag[];
 
 
      // only to be used by the friends
 
    OksFile(
      const std::string&,  // file full path
      const std::string&,  // file logical name
      const std::string&,  // file type
      const std::string&,  // file oks-format
      OksKernel *
    );
 
    OksFile& operator=(const OksFile &);
 
    OksFile(const OksFile &f) { *this = f; }
 
    OksFile(std::shared_ptr<OksXmlInputStream>, const std::string&, const std::string&, OksKernel *);
    void write(OksXmlOutputStream&);
 
    void set_updated() {p_is_updated = true;} // in-memory
 
    void rename(const std::string& short_name, const std::string& full_name);
    void rename(const std::string& full_name);  // repository rename
    void create_lock_name();
    void init_lock_name() const { if(p_lock_file_name.empty()) const_cast<OksFile*>(this)->create_lock_name(); }
    void check_repository();
 
    std::string make_repository_name() const;
 
    oks::Comment * get_comment(const std::string& creation_time) noexcept;
 
    void clear_comments() noexcept;
 
    std::list<std::string>::iterator find_include_file(const std::string&);
 
};
 
std::ostream& operator<<(std::ostream&, const OksFile&);
std::ostream& operator<<(std::ostream&, const oks::Comment&);
 
} // namespace oks
} // namespace dunedaq
#endif