dunedaq::oks::OksFile Class Reference

Provides interface to the OKS XML schema and data files. More...

#include <file.hpp>

Collaboration diagram for dunedaq::oks::OksFile:

Classes
struct	SortByName

Public Types
enum	Mode { ReadOnly , ReadWrite }
enum	FileStatus { FileNotModified , FileModified , FileWasNotSaved , FileRemoved }
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

Public Member Functions
void	lock ()
	Lock OKS file.
void	unlock ()
	Unlock OKS file.
void	add_include_file (const std::string &name)
	Add include file.
void	remove_include_file (const std::string &name)
	Remove include file.
void	rename_include_file (const std::string &from, const std::string &to)
	Rename include file.
void	add_comment (const std::string &text, const std::string &author)
	Add new comment to file.
void	modify_comment (const std::string &creation_time, const std::string &text, const std::string &author)
void	remove_comment (const std::string &creation_time)
	Modify existing comment.
const std::map< std::string, oks::Comment * > &	get_comments () const
void	set_logical_name (const std::string &name)
	Set logical name of file.
void	set_type (const std::string &type)
	Set file type.
const std::string &	get_short_file_name () const
const std::string &	get_full_file_name () const
bool	is_repository_file () const
	Get information about repository, the file belongs to.
const std::string &	get_repository_name () const
	Get name of file inside repository.
const std::string &	get_well_formed_name () const
	Get well-formed file name.
const std::string &	get_lock_file () const
const std::string &	get_logical_name () const
const std::string &	get_type () const
const std::string &	get_oks_format () const
long	get_number_of_items () const
long	get_size () const
const std::string &	get_created_by () const
const boost::posix_time::ptime	get_creation_time () const
const std::string &	get_created_on () const
const std::string &	get_last_modified_by () const
const boost::posix_time::ptime	get_last_modification_time () const
const std::string &	get_last_modified_on () const
bool	is_locked () const
	Return lock status of OKS file.
bool	is_updated () const
	Return update status of OKS file.
bool	is_read_only () const
	Return read-only status of OKS file.
const std::list< std::string > &	get_include_files () const
	Get directly include files.
void	get_all_include_files (const OksKernel *kernel, std::set< OksFile * > &out)
	Get all include files.
FileStatus	get_status_of_file () const
	Return update status of file.
void	update_status_of_file (bool update_local=true, bool update_repository=true)
	Update status of file.
bool	get_lock_string (std::string &info) const
	Return lock status of OKS file and if the file is locked, get information string about process which locked the file.
bool	compare (const char *name) const
	Compare with another file.
const OksFile *	get_parent () const
	Return parent including given file.
OksFile *	check_parent (const OksFile *parent_h)
	Set given parent, if this file is not yet included.
	~OksFile () noexcept

Static Public Member Functions
static void	set_nolock_mode (bool nl)
static bool	compare (const char *file1_name, const char *file2_name)
	Compare two files.

Private Member Functions
	OksFile (const std::string &, const std::string &, const std::string &, const std::string &, OksKernel *)
OksFile &	operator= (const OksFile &)
	OksFile (const OksFile &f)
	OksFile (std::shared_ptr< OksXmlInputStream >, const std::string &, const std::string &, OksKernel *)
void	write (OksXmlOutputStream &)
void	set_updated ()
void	rename (const std::string &short_name, const std::string &full_name)
void	rename (const std::string &full_name)
void	create_lock_name ()
void	init_lock_name () const
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 &)

Private Attributes
std::string	p_short_name
std::string	p_full_name
std::string	p_repository_name
std::string	p_logical_name
std::string	p_type
std::string	p_oks_format
long	p_number_of_items
long	p_size
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
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 Private Attributes
static bool	p_nolock_mode = false
static const char	xml_file_header [] = "<?xml version=\"1.0\" encoding=\"ASCII\"?>"
static const char	xml_schema_file_dtd []
static const char	xml_data_file_dtd []
static const char	xml_info_tag [] = "info"
static const char	xml_include_tag [] = "include"
static const char	xml_file_tag [] = "file"
static const char	xml_comments_tag [] = "comments"
static const char	xml_comment_tag [] = "comment"

Friends
class	OksKernel
class	OksClass
class	OksObject
struct	OksLoadObjectsJob

Detailed Description

Provides interface to the OKS XML schema and data files.

An object of this class is used to read/write header part of OKS XML file, includes and comments. It allows to set update lock on file creating .oks-lock-$filename file: see lock() and unlock() methods. Also, the class provides methods to get many other properties of the file, e.g. status, access mode, repository information, number of stored items, size, etc.

Definition at line 340 of file file.hpp.

Member Typedef Documentation

IMap

std::unordered_map<OksFile *, Set, oks::hash_file_ptr, oks::equal_file_ptr> dunedaq::oks::OksFile::IMap

Definition at line 370 of file file.hpp.

Map

std::map<const std::string *, OksFile *, SortByName> dunedaq::oks::OksFile::Map

Definition at line 367 of file file.hpp.

Set

std::unordered_set<OksFile *, oks::hash_file_ptr, oks::equal_file_ptr> dunedaq::oks::OksFile::Set

Definition at line 369 of file file.hpp.

Member Enumeration Documentation

FileStatus

enum dunedaq::oks::OksFile::FileStatus

Enumerator
FileNotModified
FileModified
FileWasNotSaved
FileRemoved

Definition at line 354 of file file.hpp.

                    {
      FileNotModified,
      FileModified,
      FileWasNotSaved,
      FileRemoved
    };

Mode

enum dunedaq::oks::OksFile::Mode

Enumerator
ReadOnly
ReadWrite

Definition at line 349 of file file.hpp.

              {
      ReadOnly,
      ReadWrite
    };

Constructor & Destructor Documentation

~OksFile()

dunedaq::oks::OksFile::~OksFile ( )

noexcept

Definition at line 290 of file file.cpp.

{
  clear_comments();
}

OksFile() [1/3]

dunedaq::oks::OksFile::OksFile ( const std::string & s, const std::string & ln, const std::string & ft, const std::string & ff, OksKernel * k )

private

Definition at line 252 of file file.cpp.

                                                                                                                 :
 p_short_name               (s),
 p_full_name                (s),
 p_logical_name             (ln),
 p_type                     (ft),
 p_oks_format               (ff),
 p_number_of_items          (0),
 p_size                     (0),
 p_created_by               (OksKernel::get_user_name()),
 p_creation_time            (boost::posix_time::second_clock::universal_time()),
 p_created_on               (OksKernel::get_host_name()),
 p_last_modification_time   (p_creation_time),
 p_lock                     (),
 p_is_updated               (false),
 p_is_read_only             (true),
 p_last_modified            (0),
 p_repository_last_modified (0),
 p_is_on_disk               (false),
 p_included_by              (0),
 p_kernel                   (k)
{
  p_last_modified_on = p_created_on;
  p_last_modified_by = p_created_by;
  create_lock_name();
  check_repository();
}

OksFile() [2/3]

dunedaq::oks::OksFile::OksFile ( const OksFile & f )

inlineprivate

Definition at line 788 of file file.hpp.

{ *this = f; }

OksFile() [3/3]

dunedaq::oks::OksFile::OksFile ( std::shared_ptr< OksXmlInputStream > xmls, const std::string & sp, const std::string & fp, OksKernel * k )

private

Definition at line 344 of file file.cpp.

                                                                                                               :
 p_short_name               (sp),
 p_full_name                (fp),
 p_oks_format               (_empty_str, sizeof(_empty_str)-1),
 p_creation_time            (boost::posix_time::not_a_date_time),
 p_last_modification_time   (boost::posix_time::not_a_date_time),
 p_lock                     (),
 p_is_updated               (false),
 p_is_read_only             (true),
 p_last_modified            (0),
 p_repository_last_modified (0),
 p_is_on_disk               (true),
 p_included_by              (0),
 p_kernel                   (k)
{
  const char * fname = "OksFile::OksFile()";
 
//  create_lock_name();
  check_repository();
 
 
    // check file header
 
  try {
 
      // skip an xml file header
 
    {
      const char * tag_start = xmls->get_tag_start();
 
      if(!oks::cmp_str4(tag_start, "?xml")) {
        xmls->throw_unexpected_tag(tag_start, "?xml");
      }
    }
 
      // skip possible tag attributes
 
    while(true) {
      OksXmlAttribute attr(*xmls);
 
        // check for close of tag
 
      if(
        oks::cmp_str1(attr.name(), ">") ||
        oks::cmp_str1(attr.name(), "/") ||
    oks::cmp_str1(attr.name(), "?")
      ) { break; }
 
        // check for start of info tag
 
      if(!oks::cmp_str7(attr.name(), "version") && !oks::cmp_str8(attr.name(), "encoding")) {
        if(!p_kernel->get_silence_mode()) {
          Oks::warning_msg(fname) << "  Unexpected attribute \'" << attr.name() << "\' in the xml file header. Either \'version\' or \'encoding\' is expected.\n";
        }
      }
    }
 
  }
  catch (oks::exception & e) {
    throw oks::FailedRead("an xml file header", e);
  }
  catch (std::exception & e) {
    throw oks::FailedRead("an xml file header", e.what());
  }
 
 
    // skip document type declaration and comments
 
  {
    while(true) {
      try {
        const char * dtd = xmls->get_tag();
        const char dtd_start[] = "<!DOCTYPE ";
        if(!strncmp(dtd_start, dtd, sizeof(dtd_start) - 1)) {
          break;
        }
      }
      catch (oks::exception & e) {
        throw oks::FailedRead("DTD section", e);
      }
      catch (std::exception & e) {
        throw oks::FailedRead("DTD section", e.what());
      }
    }
  }
 
 
    // skip
 
  try {
    xmls->store_position();
 
    const char * a_tag = xmls->get_tag();
 
    const char xml_stylesheet_start[] = "<?xml-stylesheet";
    if(strncmp(xml_stylesheet_start, a_tag, sizeof(xml_stylesheet_start) - 1)) {
      xmls->restore_position();
    }
  }
  catch (oks::exception & e) {
    throw oks::FailedRead("an xml-stylesheet tag or an oks tag", e);
  }
  catch (std::exception & e) {
    throw oks::FailedRead("an xml-stylesheet tag or an oks tag", e.what());
  }
 
    // read start-of-tag
 
  try {
    xmls->get_tag_start();
  }
  catch (oks::exception & e) {
    throw oks::FailedRead("tag", e);
  }
  catch (std::exception & e) {
    throw oks::FailedRead("tag", e.what());
  }
 
 
    // read info tag
 
  try {
    const char * tag_start = xmls->get_tag_start();
 
    if(!oks::cmp_str4(tag_start, xml_info_tag)) {
      xmls->throw_unexpected_tag(tag_start, xml_info_tag);
    }
  }
  catch (oks::exception & e) {
    throw oks::FailedRead("<info> tag", e);
  }
  catch (std::exception & e) {
    throw oks::FailedRead("<info> tag", e.what());
  }
 
 
  std::string oks_version;
 
 
    // read class attributes
 
  try {
    while(true) {
      OksXmlAttribute attr(*xmls);
 
        // check for close of tag
 
      if(oks::cmp_str1(attr.name(), ">") || oks::cmp_str1(attr.name(), "/")) { break; }
 
        // check for known info' attributes
 
      else if(oks::cmp_str4 (attr.name(), "name"))             p_logical_name.assign(attr.value(), attr.value_len());
      else if(oks::cmp_str4 (attr.name(), "type"))             p_type.assign(attr.value(), attr.value_len());
      else if(oks::cmp_str10(attr.name(), "oks-format"))       p_oks_format.assign(attr.value(), attr.value_len());
      else if(oks::cmp_str10(attr.name(), "created-by"))       p_created_by.assign(attr.value(), attr.value_len());
      else if(oks::cmp_str10(attr.name(), "created-on"))       p_created_on.assign(attr.value(), attr.value_len());
      else if(oks::cmp_str11(attr.name(), "oks-version"))      oks_version.assign(attr.value(), attr.value_len());
      else if(oks::cmp_str12(attr.name(), "num-of-items"))     p_number_of_items = atol(attr.value());
      else if(oks::cmp_str13(attr.name(), "creation-time"))    p_creation_time = oks::str2time(attr.value(), attr.value_len(), p_full_name.c_str());
      else if(oks::cmp_str15(attr.name(), "num-of-includes"))  continue; // ignore this value
      else if(oks::cmp_str16(attr.name(), "last-modified-by")) p_last_modified_by.assign(attr.value(), attr.value_len());
      else if(oks::cmp_str16(attr.name(), "last-modified-on")) p_last_modified_on.assign(attr.value(), attr.value_len());
      else if(!strcmp(attr.name(), "last-modification-time"))  p_last_modification_time = oks::str2time(attr.value(), attr.value_len(), p_full_name.c_str());
      else {
    p_oks_format.clear();
    xmls->throw_unexpected_tag(attr.name(), "info\'s tags");
      }
    }
  }
  catch(oks::exception & e) {
    throw oks::FailedRead("<info> tag attribute", e);
  }
  catch (std::exception & e) {
    throw oks::FailedRead("<info> tag attribute", e.what());
  }
 
    // read include and comments sections
  while(true) {
    xmls->store_position();
 
    bool read_include = false;
 
    try {
      const char * tag_start = xmls->get_tag_start();
      if(oks::cmp_str7(tag_start, xml_include_tag)) { read_include = true; }
      else if(oks::cmp_str8(tag_start, xml_comments_tag)) { read_include = false; }
      else { xmls->restore_position(); return; }
    }
    catch (oks::exception & e) {
      throw oks::FailedRead("a tag", e);
    }
    catch (std::exception & e) {
      throw oks::FailedRead("a tag", e.what());
    }
 
    if(read_include) {
      while(true) {
        try {
    
          {
        const char * tag_start = xmls->get_tag_start();
            if(!oks::cmp_str4(tag_start, xml_file_tag)) {
          if(!oks::cmp_str8(tag_start, "/include")) { xmls->throw_unexpected_tag(tag_start + 1, xml_file_tag); }
          break;
            }
          }
 
          while(true) {
            OksXmlAttribute attr(*xmls);
 
              // check for close of tag
            if(oks::cmp_str1(attr.name(), ">") || oks::cmp_str1(attr.name(), "/")) { break; }
 
              // check for known info' attributes
            else if(oks::cmp_str4(attr.name(), "path")) p_list_of_include_files.push_back(std::string(attr.value(),attr.value_len()));
            else {
              p_oks_format.clear();
          xmls->throw_unexpected_tag(attr.name(), "path");
            }
          }
 
        }
        catch (oks::exception & e) {
          throw oks::FailedRead("<file> tag", e);
        }
        catch (std::exception & e) {
          throw oks::FailedRead("<file> tag", e.what());
        }
      }
    }
    else {
      while(true) {
        try {
 
          {
        const char * tag_start = xmls->get_tag_start();
            if(!oks::cmp_str7(tag_start, xml_comment_tag)) {
          if(!oks::cmp_str9(tag_start, "/comments")) { xmls->throw_unexpected_tag(tag_start, xml_comment_tag); }
          return;
            }
          }
 
      std::unique_ptr<oks::Comment> comment( new oks::Comment() );
      std::string creation_time;
 
          while(true) {
            OksXmlAttribute attr(*xmls);
 
              // check for close of tag
            if(oks::cmp_str1(attr.name(), ">") || oks::cmp_str1(attr.name(), "/")) { break; }
 
              // check for known info' attributes
            else if(oks::cmp_str4 (attr.name(), "text"))          comment->p_text.assign(attr.value(), attr.value_len());
            else if(oks::cmp_str6 (attr.name(), "author"))        comment->p_author.assign(attr.value(), attr.value_len());
            else if(oks::cmp_str10(attr.name(), "created-by"))    comment->p_created_by.assign(attr.value(), attr.value_len());
            else if(oks::cmp_str10(attr.name(), "created-on"))    comment->p_created_on.assign(attr.value(), attr.value_len());
            else if(oks::cmp_str13(attr.name(), "creation-time")) creation_time.assign(attr.value(), attr.value_len());
            else {
              p_oks_format.clear();
          xmls->throw_unexpected_tag(attr.name(), "comment\'s tags");
            }
          }
 
          comment->validate(creation_time);
 
          if(p_comments.find(creation_time) != p_comments.end()) {
            std::ostringstream text;
            text << "The comment created at \'" << creation_time << "\' was already defined in this file";
            throw std::runtime_error(text.str().c_str());
          }
 
      p_comments[creation_time] = comment.release();
 
        }
        catch (oks::exception & e) {
          throw oks::FailedRead("<comment>", e);
        }
        catch (std::exception & e) {
          throw oks::FailedRead("<comment>", e.what());
        }
      }
    }
  }
}

Member Function Documentation

add_comment()

void dunedaq::oks::OksFile::add_comment	(	const std::string &	text,
		const std::string &	author )

Add new comment to file.

The method allows to add text description to the file.

Parameters

text	the description; must not be empty
author	the author's description, e.g. first and last names, the e-mail address, etc.

Exceptions

In	case of problems (e.g. empty text) the method throws oks::exception.

Definition at line 669 of file file.cpp.

{
  try {
    lock();
  }
  catch(oks::exception& ex) {
    throw oks::FailedAddComment(*this, ex);
  }
 
  boost::posix_time::ptime now = boost::posix_time::second_clock::universal_time();
  std::string creation_time = boost::posix_time::to_iso_string(now);
 
  try {
    std::unique_ptr<oks::Comment> comment( new oks::Comment(text, author) );
    comment->validate();
 
    oks::Comment *& x(p_comments[creation_time]);
 
    if(x == 0)
      {
        x = comment.release();
      }
    else
      {
        x->p_text += "\n-----\n";
        x->p_text.append(text);
      }
  }
  catch(std::exception & ex) {
    throw oks::FailedAddComment(*this, ex.what());
  }
 
  p_is_updated = true;
}

add_include_file()

void dunedaq::oks::OksFile::add_include_file

(

const std::string &

name

)

Add include file.

The method adds include file to given one. To load included file it is necessary to save the file and load it again.

Parameters

name	name of include file to be added

Exceptions

In	case of problems (e.g. cannot lock file) the method throws oks::exception.

Definition at line 1194 of file file.cpp.

{
    // check if the file was already included
  if(find_include_file(s) != p_list_of_include_files.end()) { return; }
 
    // lock file
  try {
    lock();
  }
  catch(oks::exception& ex) {
    throw oks::FailedAddInclude(*this, s, ex);
  }
 
    // try to find path to include and load it
  try {
    std::string path = p_kernel->get_file_path(s, this);
    p_kernel->k_load_file(path, true, this, 0);
  }
  catch(std::exception& ex) {
    throw oks::FailedAddInclude(*this, s, ex.what());
  }
 
    // add include and mark file as updated
  p_list_of_include_files.push_back(s);
  p_is_updated = true;
}

check_parent()

OksFile * dunedaq::oks::OksFile::check_parent

(

const OksFile *

parent_h

)

Set given parent, if this file is not yet included.

Parameters

parent_h

parent file

Returns

this file.

Definition at line 1183 of file file.cpp.

{
  if(p_included_by == 0 && parent_h != 0) {
    p_included_by = parent_h;
  }
 
  return this;
}

check_repository()

void dunedaq::oks::OksFile::check_repository ( )

private

Definition at line 915 of file file.cpp.

{
//  if(size_t len = OksKernel::get_repository_root().size()) {
//    if(p_full_name.size() > len && p_full_name.substr(0, len) == OksKernel::get_repository_root()) {
//      p_repository = GlobalRepository;
//      p_repository_name = p_full_name.substr(len + 1);
//      TLOG_DEBUG( 3 ) << "file \'" << p_full_name << "\' comes from user repository [\'" << p_repository_name << "\']";
//      return;
//    }
//  }
 
  const std::string& s(p_kernel->get_user_repository_root());
  if(size_t len = s.size()) {
    if(p_full_name.size() > len && p_full_name.substr(0, len) == s) {
//      p_repository = UserRepository;
      p_repository_name = p_full_name.substr(len + 1);
 
      TLOG_DEBUG( 3 ) << "file \'" << p_full_name << "\' comes from user repository [\'" << p_repository_name << "\']" ;
      return;
 
//      std::string repository_file = OksKernel::get_repository_root() + '/' + p_repository_name;
//
//      struct stat buf;
//      if(stat(repository_file.c_str(), &buf) == 0) {
//        TLOG_DEBUG( 3 ) << "file \'" << p_full_name << "\' comes from user repository [\'" << p_repository_name << "\']" ;
//        return;
//      }
//      else {
//        TLOG_DEBUG( 3 ) << "file \'" << p_full_name << "\' is found in user repository [\'" << p_repository_name << "\'] but does not exist in global one [\'" << OksKernel::get_repository_root() << "\']" ;
//      }
    }
  }
 
  TLOG_DEBUG( 3 ) << "file \'" << p_full_name << "\' is not in a repository" ;
//  p_repository = NoneRepository;
  p_repository_name.clear();
}

clear_comments()

void dunedaq::oks::OksFile::clear_comments ( )

privatenoexcept

Definition at line 280 of file file.cpp.

{
  for(std::map<std::string, oks::Comment *>::iterator i = p_comments.begin(); i != p_comments.end(); ++i) {
    delete i->second;
  }
 
  p_comments.clear();
}

compare() [1/2]

bool dunedaq::oks::OksFile::compare ( const char * file1_name, const char * file2_name )

static

Compare two files.

Parameters

file1_name	name of first file
file2_name	name of second file

Returns

false => files are different; true => files are equal

Exceptions

In	case of problems the method throws oks::exception.

Definition at line 1514 of file file.cpp.

{
  std::ifstream f1(file1_name);
  std::ifstream f2(file2_name);
 
  if (!f1)
    {
      throw oks::FileCompareError(file1_name, file2_name, "cannot open file");
    }
 
  if (!f2)
    {
      throw oks::FileCompareError(file2_name, file1_name, "cannot open file");
    }
 
  std::string line1;
  std::string line2;
 
  while (true)
    {
      if (f1.eof() && f2.eof())
        {
          return true;
        }
 
      std::getline(f1, line1);
      std::getline(f2, line2);
 
      if ((line1 != line2) && (is_not_info(line1) || is_not_info(line2)))
        {
          return false;
        }
    }
 
  return true;
}

compare() [2/2]

bool dunedaq::oks::OksFile::compare ( const char * name ) const

inline

Compare with another file.

Parameters

name	name of file to compare with

Returns

false => files are different; true => files are equal

Exceptions

In	case of problems the method throws oks::exception.

Definition at line 708 of file file.hpp.

{ return compare(p_full_name.c_str(), name); }

create_lock_name()

void dunedaq::oks::OksFile::create_lock_name ( )

private

Definition at line 954 of file file.cpp.

{
  p_lock_file_name = p_full_name;
 
  std::string::size_type idx = p_lock_file_name.find_last_of('/');
  if(idx == std::string::npos) p_lock_file_name = "./";
  else p_lock_file_name.erase(idx+1);
 
  const char _prefix_str[] = ".oks-lock-";
  p_lock_file_name.append(_prefix_str, sizeof(_prefix_str)-1);
 
  idx = p_full_name.find_last_of('/');
  std::string::size_type len(p_full_name.size());
  if(idx == std::string::npos) {
    idx = 0;
  }
  else {
    idx++;
    len -= idx;
  }
 
  p_lock_file_name.append(p_full_name, idx, len);
  p_lock_file_name.append(".txt");
}

find_include_file()

std::list< std::string >::iterator dunedaq::oks::OksFile::find_include_file ( const std::string & s )

private

Definition at line 1172 of file file.cpp.

{
  std::list<std::string>::iterator i = p_list_of_include_files.begin();
 
  for(;i != p_list_of_include_files.end(); ++i) {if(*i == s) break;}
 
  return i;
}

get_all_include_files()

void dunedaq::oks::OksFile::get_all_include_files	(	const OksKernel *	kernel,
		std::set< OksFile * > &	out )

Get all include files.

Parameters

kernel	OKS kernel
out	set of all files included explicitly and implicitly by given file

Definition at line 1466 of file file.cpp.

{
  const OksFile::Map & schema_files = kernel->schema_files();
  const OksFile::Map & data_files = kernel->data_files();
 
  for(std::list<std::string>::iterator i = p_list_of_include_files.begin(); i != p_list_of_include_files.end(); ++i) {
    std::string s = kernel->get_file_path(*i, this);
    if(s.size()) {
      OksFile::Map::const_iterator j = data_files.find(&s);
      if(j != data_files.end()) {
        if(out.find(j->second) != out.end()) { continue; }
        out.insert(j->second);
      }
      else {
        j = schema_files.find(&s);
        if(j != schema_files.end()) {
          if(out.find(j->second) != out.end()) { continue; }
          out.insert(j->second);
        }
        else {
          continue;
        }
      }
 
      j->second->get_all_include_files(kernel, out);
    }
  }
}

get_comment()

oks::Comment * dunedaq::oks::OksFile::get_comment ( const std::string & creation_time )

privatenoexcept

Definition at line 705 of file file.cpp.

{
  std::map<std::string, oks::Comment *>::const_iterator i = p_comments.find(creation_time);
  return (i == p_comments.end()) ? 0: i->second;
}

get_comments()

const std::map< std::string, oks::Comment * > & dunedaq::oks::OksFile::get_comments ( ) const

inline

Get all comments of file.

Definition at line 489 of file file.hpp.

{return p_comments;}

get_created_by()

const std::string & dunedaq::oks::OksFile::get_created_by ( ) const

inline

Return name of user who created this file.

Definition at line 583 of file file.hpp.

{return p_created_by;}

get_created_on()

const std::string & dunedaq::oks::OksFile::get_created_on ( ) const

inline

Return name of host where the file was created.

Definition at line 593 of file file.hpp.

{return p_created_on;}

get_creation_time()

const boost::posix_time::ptime dunedaq::oks::OksFile::get_creation_time ( ) const

inline

Return timestamp when file was created.

Definition at line 588 of file file.hpp.

{return p_creation_time;}

get_full_file_name()

const std::string & dunedaq::oks::OksFile::get_full_file_name ( ) const

inline

Return real file name (replacing all software links)

Definition at line 523 of file file.hpp.

{return p_full_name;}

get_include_files()

const std::list< std::string > & dunedaq::oks::OksFile::get_include_files ( ) const

inline

Get directly include files.

Returns

list of file names included by given file

Definition at line 640 of file file.hpp.

{return p_list_of_include_files;}

get_last_modification_time()

const boost::posix_time::ptime dunedaq::oks::OksFile::get_last_modification_time ( ) const

inline

Return timestamp when file was modified last time using OKS tools.

Definition at line 603 of file file.hpp.

{return p_last_modification_time;}

get_last_modified_by()

const std::string & dunedaq::oks::OksFile::get_last_modified_by ( ) const

inline

Return name of user who modified the file last time using OKS tools.

Definition at line 598 of file file.hpp.

{return p_last_modified_by;}

get_last_modified_on()

const std::string & dunedaq::oks::OksFile::get_last_modified_on ( ) const

inline

Return name of host where the file was modified last time using OKS tools.

Definition at line 608 of file file.hpp.

{return p_last_modified_on;}

get_lock_file()

const std::string & dunedaq::oks::OksFile::get_lock_file ( ) const

inline

Definition at line 565 of file file.hpp.

{ init_lock_name(); return p_lock_file_name; }

get_lock_string()

bool dunedaq::oks::OksFile::get_lock_string

(

std::string &

info

)

const

Return lock status of OKS file and if the file is locked, get information string about process which locked the file.

The method method also works for files locked by external process contrary to the is_locked() method.

Parameters

info	out parameter containing info about process locked this file

Returns

true, if the file is locked and false otherwise

Definition at line 984 of file file.cpp.

{
  init_lock_name();
 
  lock_file_contents.clear();
 
  const char * lock_name = p_lock_file_name.c_str();
  struct stat buf;
 
  if(stat(lock_name, &buf) == 0) {
    std::ifstream f(lock_name);
 
    if(f.good()) {
      std::getline(f, lock_file_contents);
      return true;
    }
    else {
      lock_file_contents = "unknown [cannot read lock file \'";
      lock_file_contents += p_lock_file_name;
      lock_file_contents += "\']";
      return true;
    }
  }
 
  return false;
}

get_logical_name()

const std::string & dunedaq::oks::OksFile::get_logical_name ( ) const

inline

Definition at line 566 of file file.hpp.

{return p_logical_name;}

get_number_of_items()

long dunedaq::oks::OksFile::get_number_of_items ( ) const

inline

Return number of classes in schema file, or number of objects in data file.

Definition at line 573 of file file.hpp.

{return p_number_of_items;}

get_oks_format()

const std::string & dunedaq::oks::OksFile::get_oks_format ( ) const

inline

Definition at line 568 of file file.hpp.

{return p_oks_format;}

get_parent()

const OksFile * dunedaq::oks::OksFile::get_parent ( ) const

inline

Return parent including given file.

Returns

parent file; can be NULL.

Definition at line 717 of file file.hpp.

{ return p_included_by; }

get_repository_name()

const std::string & dunedaq::oks::OksFile::get_repository_name ( ) const

inline

Get name of file inside repository.

For example, if TDAQ_DB_REPOSITORY="/db/v15", and the file name is "/db/v15/common/params.data.xml", the file's repository name will be "common/params.data.xml".

Definition at line 550 of file file.hpp.

{return p_repository_name;}

get_short_file_name()

const std::string & dunedaq::oks::OksFile::get_short_file_name ( ) const

inline

Definition at line 518 of file file.hpp.

{return p_short_name;}

get_size()

long dunedaq::oks::OksFile::get_size ( ) const

inline

Return length of file in bytes.

Definition at line 578 of file file.hpp.

{return p_size;}

get_status_of_file()

OksFile::FileStatus dunedaq::oks::OksFile::get_status_of_file

(

)

const

Return update status of file.

The file can be in one of the following states:

• NotModified - file is not modified
• FileModified - file is modified in memory
• FileWasNotSaved - file was created, but not saved yet (only exists in memory)
• FileRemoved - file was removed by external process after load in memory
• FileRepositoryModified - repository file was modified (given file comes from user repository)
• FileRepositoryRemoved - repository file was removed (given file comes from user repository)

Definition at line 1413 of file file.cpp.

{
  if(p_is_on_disk == false) {
    return FileWasNotSaved;
  }
  else {
    struct stat buf;
 
    if(stat(p_full_name.c_str(), &buf) != 0) {
      return FileRemoved;
    }
 
    if(buf.st_mtime != p_last_modified) {
      return FileModified;
    }
 
//    if(get_repository() == UserRepository) {
//      std::string full_repository_name = make_repository_name();
//
//      if(!full_repository_name.empty()) {
//        if(stat(full_repository_name.c_str(), &buf) != 0) {
//          return FileRepositoryRemoved;
//        }
//
//        if(buf.st_mtime != p_repository_last_modified) {
//          return FileRepositoryModified;
//        }
//      }
//    }
  }
 
  return FileNotModified;
}

get_type()

const std::string & dunedaq::oks::OksFile::get_type ( ) const

inline

Definition at line 567 of file file.hpp.

{return p_type;}

get_well_formed_name()

const std::string & dunedaq::oks::OksFile::get_well_formed_name ( ) const

inline

Get well-formed file name.

In particular, strip repository root prefix.

Definition at line 560 of file file.hpp.

      {
        return (!p_repository_name.empty() ? p_repository_name : p_full_name);
      }

init_lock_name()

void dunedaq::oks::OksFile::init_lock_name ( ) const

inlineprivate

Definition at line 798 of file file.hpp.

{ if(p_lock_file_name.empty()) const_cast<OksFile*>(this)->create_lock_name(); }

is_locked()

bool dunedaq::oks::OksFile::is_locked ( ) const

inline

Return lock status of OKS file.

Returns

true, if the file is locked by given process and false otherwise

Definition at line 616 of file file.hpp.

{return (p_lock != nullptr);}

is_read_only()

bool dunedaq::oks::OksFile::is_read_only ( ) const

inline

Return read-only status of OKS file.

Returns

true, if the file is read-only for given process and false otherwise

Definition at line 632 of file file.hpp.

{return p_is_read_only;}

is_repository_file()

bool dunedaq::oks::OksFile::is_repository_file

(

)

const

Get information about repository, the file belongs to.

If the global database repository is set (e.g. TDAQ_DB_REPOSITORY is defined) and the file is stored on it, the method returns GlobalRepository. If the user database repository is set (e.g. TDAQ_DB_USER_REPOSITORY is defined) and the file is stored on it, the method returns UserRepository. Otherwise file does not belong to any repository and the method returns NoneRepository.

The file's repository can be changed using OksKernel::checkout() and OksKernel::release() methods: they move file between global and user repositories. If file is removed in global repository, while it is stored on the user one, its repository should be changed using unset_repository() method.

Definition at line 909 of file file.cpp.

{
  return (!p_kernel->get_user_repository_root().empty());
}

is_updated()

bool dunedaq::oks::OksFile::is_updated ( ) const

inline

Return update status of OKS file.

Returns

true, if the file is updated by given process and false otherwise

Definition at line 624 of file file.hpp.

{return p_is_updated;}

lock()

void dunedaq::oks::OksFile::lock

(

)

Lock OKS file.

The method locks OKS file: for file .../file.xml the lock file .../.oks-file.xml is created. The lock file contains information about process locking it and remains exclusive while process created it is alive.

Exceptions

In	case of problems (e.g. file was already locked) the method throws oks::exception.

Definition at line 1012 of file file.cpp.

{
  if (p_nolock_mode) {
    // Nasty hack to allow code generation on the fly without locking
    // file. Just return without locking!
    return;
  }
 
  init_lock_name();
 
  if (p_lock != nullptr)
    {
      return;
    }
 
 
    // check that the file is not read-only
 
    {
      struct stat buf;
 
      if (stat(p_full_name.c_str(), &buf) == 0)
        {
          if (OksKernel::check_read_only(this) == true)
            {
              throw oks::FileLockError(*this, true, "file is read-only");
            }
        }
    }
 
 
    // check lock and report problem if it exists and cannot be reset
 
    {
      std::string lock_file_contents;
 
      if (get_lock_string(lock_file_contents))
        {
          try
            {
              boost::interprocess::file_lock lock(p_lock_file_name.c_str());
 
              if (lock.try_lock() == false)
                {
                  std::ostringstream text;
                  text << "file is already locked by \"" << lock_file_contents << '\"';
                  throw oks::FileLockError(*this, true, text.str());
                }
              else
                {
                  try
                    {
                      lock.unlock();
                    }
                  catch (const boost::interprocess::interprocess_exception& ex)
                    {
                      std::ostringstream text;
                      text << "boost::interprocess::unlock() failed: \"" << ex.what() << '\"';
                      throw oks::FileLockError(*this, false, text.str());
                    }
 
                  if (!p_kernel->get_silence_mode())
                    {
                      Oks::warning_msg("OksFile::lock()") << "Remove obsolete lock of file \'" << p_full_name << "\' created by \n\"" << lock_file_contents << "\"\n";
                    }
 
                  if (unlink(p_lock_file_name.c_str()) != 0)
                    {
                      std::ostringstream text;
                      text << "failed to remove lock file \'" << p_lock_file_name << "\':\n" << oks::strerror(errno);
                      throw oks::FileLockError(*this, false, text.str());
                    }
                }
            }
          catch (const boost::interprocess::interprocess_exception& ex)
            {
              std::ostringstream text;
              text << "boost::interprocess::try_lock() failed: \"" << ex.what() << '\"';
              throw oks::FileLockError(*this, false, text.str());
            }
        }
    }
 
 
    // write lock file
 
    {
      std::ofstream f(p_lock_file_name.c_str());
 
      if (!f.good())
        {
          std::ostringstream text;
          text << "failed to create lock file \'" << p_lock_file_name << '\'';
          throw oks::FileLockError(*this, true, text.str());
        }
 
      try
        {
          boost::posix_time::ptime now(boost::posix_time::second_clock::universal_time());
          f << "process " << getpid() << " on " << OksKernel::get_host_name() << " started by " << OksKernel::get_user_name() << " at " << boost::posix_time::to_simple_string(now) << " (UTC)" << std::endl;
          f.flush();
          f.close();
        }
      catch (std::exception& ex)
        {
          std::ostringstream text;
          text << "failed to write lock file \'" << p_lock_file_name << "\': " << ex.what();
          throw oks::FileLockError(*this, true, text.str());
        }
    }
 
 
  try
    {
      p_lock.reset(new boost::interprocess::file_lock(p_lock_file_name.c_str()));
 
      if (p_lock->try_lock() == false)
        {
          throw std::runtime_error("file is locked by another process");
        }
    }
  catch (const std::exception& ex)
    {
      std::ostringstream text;
      text << "boost::interprocess::try_lock() failed: \"" << ex.what() << '\"';
      p_lock.reset();
      throw oks::FileLockError(*this, false, text.str());
    }
}

make_repository_name()

std::string dunedaq::oks::OksFile::make_repository_name ( ) const

private

Definition at line 1378 of file file.cpp.

{
  std::string name;
 
  if(!OksKernel::get_repository_root().empty()) {
    name = OksKernel::get_repository_root() + '/' + get_repository_name();
  }
 
  return name;
}

modify_comment()

void dunedaq::oks::OksFile::modify_comment	(	const std::string &	creation_time,
		const std::string &	text,
		const std::string &	author )

/brief Modify existing comment.

The method allows to modify already existing comment.

/param creation_time the time-stamp when comment was created ( returned by get_comments() ) /param text the description; must not be empty /param author the author's description, e.g. first and last names, the e-mail address, etc.

Exceptions

In	case of problems (e.g. empty text, cannot find comment created at given time) the method throws oks::exception.

Definition at line 712 of file file.cpp.

{
  if(oks::Comment * comment = get_comment(creation_time)) {
    try {
      lock();
    }
    catch(oks::exception& ex) {
      throw oks::FailedChangeComment(*this, creation_time, ex);
    }
 
    std::string saved_author(comment->p_author);
    std::string saved_text(comment->p_text);
 
    comment->p_author = author;
    comment->p_text = text;
 
    try {
      comment->validate();
    }
    catch(std::exception& ex) {
      comment->p_author = saved_author;
      comment->p_text = saved_text;
      throw oks::FailedChangeComment(*this, creation_time, ex.what());
    }
 
    p_is_updated = true;
  }
  else {
    throw oks::FailedChangeComment(*this, creation_time, "cannot find comment");
  }
}

operator=()

OksFile & dunedaq::oks::OksFile::operator= ( const OksFile & f )

private

Definition at line 296 of file file.cpp.

{
  if (&f != this)
    {
      p_list_of_include_files.clear();
      clear_comments();
 
      p_short_name = f.p_short_name;
      p_full_name = f.p_full_name;
//      p_repository = f.p_repository;
      p_repository_name = f.p_repository_name;
      p_logical_name = f.p_logical_name;
      p_type = f.p_type;
      p_oks_format = f.p_oks_format;
      p_number_of_items = f.p_number_of_items;
      p_size = f.p_size;
      p_created_by = f.p_created_by;
      p_creation_time = f.p_creation_time;
      p_created_on = f.p_created_on;
      p_last_modified_by = f.p_last_modified_by;
      p_last_modification_time = f.p_last_modification_time;
      p_last_modified_on = f.p_last_modified_on;
      p_open_mode = f.p_open_mode;
      p_is_updated = f.p_is_updated;
      p_lock = f.p_lock;
      p_is_read_only = f.p_is_read_only;
      p_lock_file_name = f.p_lock_file_name;
      p_list_of_include_files = f.p_list_of_include_files;
      p_last_modified = f.p_last_modified;
      p_repository_last_modified = f.p_repository_last_modified;
      p_is_on_disk = f.p_is_on_disk;
      p_included_by = f.p_included_by;
      p_kernel = f.p_kernel;
 
      for (const auto& i : f.p_comments)
        {
          p_comments[i.first] = new oks::Comment(*i.second);
        }
    }
 
  return *this;
}

remove_comment()

void dunedaq::oks::OksFile::remove_comment

(

const std::string &

creation_time

)

Modify existing comment.

The method allows to erase already existing comment.

Parameters

creation_time

the timestamp when comment was created ( returned by get_comments() )

Exceptions

In	case of problems (e.g. cannot find comment created at given time, cannot lock file) the method throws oks::exception.

Definition at line 746 of file file.cpp.

{
  if(oks::Comment * comment = get_comment(creation_time)) {
    try {
      lock();
    }
    catch(oks::exception& ex) {
      throw oks::FailedRemoveComment(*this, creation_time, ex);
    }
 
    delete comment;
    p_comments.erase(creation_time);
    p_is_updated = true;
  }
  else {
    throw oks::FailedRemoveComment(*this, creation_time, "cannot find comment");
  }
}

remove_include_file()

void dunedaq::oks::OksFile::remove_include_file

(

const std::string &

name

)

Remove include file.

The method removes include file from given one. The name of the file to be removed has to be exactly the same as passed to the add_include_file() or as it appears in the include section of OKS xml file. To unload included file it is necessary to save the file and load it again.

Parameters

name	name of include file to be removed

Exceptions

In	case of problems (e.g. cannot lock file, include does not exist) the method throws oks::exception.

Definition at line 1223 of file file.cpp.

{
    // search included file
  std::list<std::string>::iterator i = find_include_file(s);
 
    // check if the file was included
  if(i == p_list_of_include_files.end()) {
    throw oks::FailedRemoveInclude(*this, s, "there is no such include file");
  }
 
    // lock file
  try {
    lock();
  }
  catch(oks::exception& ex) {
    throw oks::FailedRemoveInclude(*this, s, ex);
  }
 
    // remove include and mark file as updated
  p_list_of_include_files.erase(i);
  p_is_updated = true;
 
    // close file, if it is not referenced by others
  p_kernel->k_close_dangling_includes();
}

rename() [1/2]

void dunedaq::oks::OksFile::rename ( const std::string & full_name )

private

Definition at line 1458 of file file.cpp.

{
  p_full_name = full_name;
  create_lock_name();
  update_status_of_file();
}

rename() [2/2]

void dunedaq::oks::OksFile::rename ( const std::string & short_name, const std::string & full_name )

private

Definition at line 1449 of file file.cpp.

{
  p_short_name = short_name;
  p_full_name = full_name;
  create_lock_name();
  check_repository();
}

rename_include_file()

void dunedaq::oks::OksFile::rename_include_file	(	const std::string &	from,
		const std::string &	to )

Rename include file.

The method renames already included file. To re-load new file it is necessary to save the file and load it again.

Parameters

from	exact name of already included file
to	new name of include

Exceptions

In	case of problems (e.g. cannot lock file, no such include file) the method throws oks::exception.

Definition at line 1251 of file file.cpp.

{
  if(old_s == new_s) return;
 
  std::list<std::string>::iterator i1 = find_include_file(old_s);
  std::list<std::string>::iterator i2 = find_include_file(new_s);
 
  if(i1 == p_list_of_include_files.end()) {
    throw oks::FailedRenameInclude(*this, old_s, new_s, "there is no such include file");
  }
 
  if(i2 != p_list_of_include_files.end()) {
    throw oks::FailedRenameInclude(*this, old_s, new_s, "file with new name is already included");
  }
 
  try {
    lock();
  }
  catch(oks::exception& ex) {
    throw oks::FailedRenameInclude(*this, old_s, new_s, ex);
  }
 
  (*i1) = new_s;
  p_is_updated = true;
}

set_logical_name()

void dunedaq::oks::OksFile::set_logical_name

(

const std::string &

name

)

Set logical name of file.

The logical name can be associated by user with the file, e.g. to describe its purpose.

Parameters

name	the logical name

Exceptions

In	case of problems (e.g. cannot lock file) the method throws oks::exception.

Definition at line 1279 of file file.cpp.

{
  if(s == p_logical_name) return;
 
  try {
    lock();
  }
  catch(oks::exception& ex) {
    throw oks::FileChangeError(*this, "set logical name", ex);
  }
 
  p_logical_name = s;
  p_is_updated = true;
}

set_nolock_mode()

static void dunedaq::oks::OksFile::set_nolock_mode ( bool nl )

inlinestatic

Definition at line 385 of file file.hpp.

{p_nolock_mode = nl;}

set_type()

void dunedaq::oks::OksFile::set_type

(

const std::string &

type

)

Set file type.

The type can be associated by user with the file, e.g. to describe its contents.

Parameters

name

the type

Exceptions

In	case of problems (e.g. cannot lock file) the method throws oks::exception.

Definition at line 1296 of file file.cpp.

{
  if(s == p_type) return;
 
  try {
    lock();
  }
  catch(oks::exception& ex) {
    throw oks::FileChangeError(*this, "set type", ex);
  }
 
  p_type = s;
  p_is_updated = true;
}

set_updated()

void dunedaq::oks::OksFile::set_updated ( )

inlineprivate

Definition at line 793 of file file.hpp.

{p_is_updated = true;} // in-memory

unlock()

void dunedaq::oks::OksFile::unlock

(

)

Unlock OKS file.

The method removes lock created by lock() method. check_repository

Exceptions

In	case of problems (e.g. cannot unlink lock file) the method throws oks::exception.

Definition at line 1143 of file file.cpp.

{
  if (p_lock == nullptr)
    return;
 
  try
    {
      p_lock->unlock();
    }
  catch (const boost::interprocess::interprocess_exception& ex)
    {
      std::ostringstream text;
      text << "boost::interprocess::unlock() failed: \"" << ex.what() << '\"';
      p_lock.reset();
      throw oks::FileLockError(*this, false, text.str());
    }
 
  p_lock.reset();
 
  if (unlink(p_lock_file_name.c_str()) != 0 && errno != ENOENT)
    {
      std::ostringstream text;
      text << "failed to remove lock file \'" << p_lock_file_name << "\':\n" << oks::strerror(errno);
      throw oks::FileLockError(*this, false, text.str());
    }
}

update_status_of_file()

void dunedaq::oks::OksFile::update_status_of_file	(	bool	update_local = true,
		bool	update_repository = true )

Update status of file.

Parameters

update_local	if true, update last-modified timestamp of local file
update_repository	if true, update last-modified timestamp of repository file

Definition at line 1391 of file file.cpp.

{
  struct stat buf;
 
  if(update_local == true && p_is_on_disk == true) {
 
    if(stat(p_full_name.c_str(), &buf) == 0) {
      p_last_modified = buf.st_mtime;
    }
  }
 
  if(update_repository == true /*&& get_repository() == UserRepository*/) {
    std::string full_repository_name = make_repository_name();
 
    if(!full_repository_name.empty() && stat(full_repository_name.c_str(), &buf) == 0) {
      p_repository_last_modified = buf.st_mtime;
    }
  }
}

write()

void dunedaq::oks::OksFile::write ( OksXmlOutputStream & xmls )

private

Definition at line 767 of file file.cpp.

{
  const static std::string __data("data");
  const static std::string __schema("schema");
 
  try
    {
      const char __oks_data[] = "oks-data";
      const char __oks_schema[] = "oks-schema";
 
      const char * id(__oks_data);
      long id_len(sizeof(__oks_data) - 1);
      const char * dtd(xml_data_file_dtd);
      long dtd_len(sizeof(xml_data_file_dtd) - 1);
 
      if (p_oks_format != __data)
        {
          if (p_oks_format == __schema)
            {
              id = __oks_schema;
              id_len = sizeof(__oks_schema) - 1;
              dtd = xml_schema_file_dtd;
              dtd_len = sizeof(xml_schema_file_dtd) - 1;
            }
          else
            {
              throw std::runtime_error("bad oks format");
            }
        }
 
        {
          const char __hdr_start[] = "\n\n<!-- ";
          const char __hdr_end[] = " version 2.2 -->\n\n\n";
 
          std::string header(xml_file_header, sizeof(xml_file_header) - 1);
          header.append(__hdr_start, sizeof(__hdr_start) - 1);
          header.append(id, id_len);
          header.append(__hdr_end, sizeof(__hdr_end) - 1);
          header.append(dtd, dtd_len);
 
          xmls.put_raw(header.c_str(), header.size());
          xmls.put_raw('\n');
          xmls.put_raw('\n');
        }
 
      xmls.put_start_tag(id, id_len);
 
      xmls.put_raw('>');
      xmls.put_raw('\n');
      xmls.put_raw('\n');
 
      // "creation-time" may not be filled
 
      std::string created_c_str;
      if (!p_creation_time.is_not_a_date_time())
        {
          created_c_str = boost::posix_time::to_iso_string(p_creation_time);
        }
 
      // get last-modified information
 
      if (p_repository_name.empty())
        {
          p_last_modification_time = boost::posix_time::second_clock::universal_time();
          p_last_modified_by = OksKernel::get_user_name();
          p_last_modified_on = OksKernel::get_host_name();
        }
 
      std::string last_modified_c_str = boost::posix_time::to_iso_string(p_last_modification_time);
 
      xmls.put_start_tag(xml_info_tag, sizeof(xml_info_tag) - 1);
      xmls.put_attribute("name", sizeof("name") - 1, p_logical_name.c_str());
      xmls.put_attribute("type", sizeof("type") - 1, p_type.c_str());
      xmls.put_attribute("num-of-items", sizeof("num-of-items") - 1, p_number_of_items);
      xmls.put_attribute("oks-format", sizeof("oks-format") - 1, p_oks_format.c_str());
      xmls.put_attribute("oks-version", sizeof("oks-version") - 1, OksKernel::GetVersion());
      xmls.put_attribute("created-by", sizeof("created-by") - 1, p_created_by.c_str());
      xmls.put_attribute("created-on", sizeof("created-on") - 1, p_created_on.c_str());
      if (!created_c_str.empty())
        xmls.put_attribute("creation-time", sizeof("creation-time") - 1, created_c_str.c_str());
      if (p_repository_name.empty())
        {
          xmls.put_attribute("last-modified-by", sizeof("last-modified-by") - 1, p_last_modified_by.c_str());
          xmls.put_attribute("last-modified-on", sizeof("last-modified-on") - 1, p_last_modified_on.c_str());
          xmls.put_attribute("last-modification-time", sizeof("last-modification-time") - 1, last_modified_c_str.c_str());
        }
      xmls.put_end_tag();
 
      if (!p_list_of_include_files.empty())
        {
          xmls.put_raw('\n');
          xmls.put_start_tag(xml_include_tag, sizeof(xml_include_tag) - 1);
 
          xmls.put_raw('>');
          xmls.put_raw('\n');
 
          for (const auto& i : p_list_of_include_files)
            {
              xmls.put_raw(' ');
              xmls.put_start_tag(xml_file_tag, sizeof(xml_file_tag) - 1);
              xmls.put_attribute("path", sizeof("path") - 1, i.c_str());
              xmls.put_end_tag();
            }
 
          xmls.put_last_tag(xml_include_tag, sizeof(xml_include_tag) - 1);
          xmls.put_raw('\n');
        }
 
      if (!p_comments.empty())
        {
          xmls.put_start_tag(xml_comments_tag, sizeof(xml_comments_tag) - 1);
 
          xmls.put_raw('>');
          xmls.put_raw('\n');
 
          for (const auto& i : p_comments)
            {
              xmls.put_raw(' ');
              xmls.put_start_tag(xml_comment_tag, sizeof(xml_comment_tag) - 1);
              xmls.put_attribute("creation-time", sizeof("creation-time") - 1, i.first.c_str());
              xmls.put_attribute("created-by", sizeof("created-by") - 1, i.second->p_created_by.c_str());
              xmls.put_attribute("created-on", sizeof("created-on") - 1, i.second->p_created_on.c_str());
              xmls.put_attribute("author", sizeof("author") - 1, i.second->p_author.c_str());
              xmls.put_attribute("text", sizeof("text") - 1, i.second->p_text.c_str());
              xmls.put_end_tag();
            }
 
          xmls.put_last_tag(xml_comments_tag, sizeof(xml_comments_tag) - 1);
          xmls.put_raw('\n');
        }
 
      xmls.put_raw('\n');
    }
  catch (std::exception& ex)
    {
      throw oks::FailedSave("oks-file", p_full_name, ex.what());
    }
 
  p_is_on_disk = true;
}

Friends And Related Symbol Documentation

OksClass

friend class OksClass

friend

Definition at line 343 of file file.hpp.

OksKernel

friend class OksKernel

friend

Definition at line 342 of file file.hpp.

OksLoadObjectsJob

friend struct OksLoadObjectsJob

friend

Definition at line 345 of file file.hpp.

OksObject

friend class OksObject

friend

Definition at line 344 of file file.hpp.

Member Data Documentation

p_comments

std::map<std::string, oks::Comment *> dunedaq::oks::OksFile::p_comments

private

Definition at line 761 of file file.hpp.

p_created_by

std::string dunedaq::oks::OksFile::p_created_by

private

Definition at line 747 of file file.hpp.

p_created_on

std::string dunedaq::oks::OksFile::p_created_on

private

Definition at line 749 of file file.hpp.

p_creation_time

boost::posix_time::ptime dunedaq::oks::OksFile::p_creation_time

private

Definition at line 748 of file file.hpp.

p_full_name

std::string dunedaq::oks::OksFile::p_full_name

private

Definition at line 740 of file file.hpp.

p_included_by

const OksFile* dunedaq::oks::OksFile::p_included_by

private

Definition at line 763 of file file.hpp.

p_is_on_disk

bool dunedaq::oks::OksFile::p_is_on_disk

private

Definition at line 762 of file file.hpp.

p_is_read_only

bool dunedaq::oks::OksFile::p_is_read_only

private

Definition at line 757 of file file.hpp.

p_is_updated

bool dunedaq::oks::OksFile::p_is_updated

private

Definition at line 756 of file file.hpp.

p_kernel

OksKernel* dunedaq::oks::OksFile::p_kernel

private

Definition at line 764 of file file.hpp.

p_last_modification_time

boost::posix_time::ptime dunedaq::oks::OksFile::p_last_modification_time

private

Definition at line 751 of file file.hpp.

p_last_modified

time_t dunedaq::oks::OksFile::p_last_modified

private

Definition at line 759 of file file.hpp.

p_last_modified_by

std::string dunedaq::oks::OksFile::p_last_modified_by

private

Definition at line 750 of file file.hpp.

p_last_modified_on

std::string dunedaq::oks::OksFile::p_last_modified_on

private

Definition at line 752 of file file.hpp.

p_list_of_include_files

std::list<std::string> dunedaq::oks::OksFile::p_list_of_include_files

private

Definition at line 758 of file file.hpp.

p_lock

std::shared_ptr<boost::interprocess::file_lock> dunedaq::oks::OksFile::p_lock

private

Definition at line 754 of file file.hpp.

p_lock_file_name

std::string dunedaq::oks::OksFile::p_lock_file_name

private

Definition at line 755 of file file.hpp.

p_logical_name

std::string dunedaq::oks::OksFile::p_logical_name

private

Definition at line 742 of file file.hpp.

p_nolock_mode

bool dunedaq::oks::OksFile::p_nolock_mode = false

staticprivate

Definition at line 737 of file file.hpp.

p_number_of_items

long dunedaq::oks::OksFile::p_number_of_items

private

Definition at line 745 of file file.hpp.

p_oks_format

std::string dunedaq::oks::OksFile::p_oks_format

private

Definition at line 744 of file file.hpp.

p_open_mode

Mode dunedaq::oks::OksFile::p_open_mode

private

Definition at line 753 of file file.hpp.

p_repository_last_modified

time_t dunedaq::oks::OksFile::p_repository_last_modified

private

Definition at line 760 of file file.hpp.

p_repository_name

std::string dunedaq::oks::OksFile::p_repository_name

private

Definition at line 741 of file file.hpp.

p_short_name

std::string dunedaq::oks::OksFile::p_short_name

private

Definition at line 739 of file file.hpp.

p_size

long dunedaq::oks::OksFile::p_size

private

Definition at line 746 of file file.hpp.

p_type

std::string dunedaq::oks::OksFile::p_type

private

Definition at line 743 of file file.hpp.

xml_comment_tag

const char dunedaq::oks::OksFile::xml_comment_tag = "comment"

staticprivate

Definition at line 773 of file file.hpp.

xml_comments_tag

const char dunedaq::oks::OksFile::xml_comments_tag = "comments"

staticprivate

Definition at line 772 of file file.hpp.

xml_data_file_dtd

const char dunedaq::oks::OksFile::xml_data_file_dtd

staticprivate

Definition at line 768 of file file.hpp.

xml_file_header

const char dunedaq::oks::OksFile::xml_file_header = "<?xml version=\"1.0\" encoding=\"ASCII\"?>"

staticprivate

Definition at line 766 of file file.hpp.

xml_file_tag

const char dunedaq::oks::OksFile::xml_file_tag = "file"

staticprivate

Definition at line 771 of file file.hpp.

xml_include_tag

const char dunedaq::oks::OksFile::xml_include_tag = "include"

staticprivate

Definition at line 770 of file file.hpp.

xml_info_tag

const char dunedaq::oks::OksFile::xml_info_tag = "info"

staticprivate

Definition at line 769 of file file.hpp.

xml_schema_file_dtd

const char dunedaq::oks::OksFile::xml_schema_file_dtd

staticprivate

Definition at line 767 of file file.hpp.

---

The documentation for this class was generated from the following files:

• /github/workspace/dunedaq/sourcecode/oks/include/oks/file.hpp
• /github/workspace/dunedaq/sourcecode/oks/src/file.cpp