crew Namespace Reference

Data Structures
class	JsonExport
struct	Part
struct	PConfig
struct	Section

Typedefs
using	Parts = std::vector< Part >
using	Source = Part
using	KeyValues = std::unordered_map< std::string, std::string >
using	Sections = std::vector< Section >

Functions
bool	read_ini (const std::string &path, PConfig &config)
	Read config as ini file, return false if failed.
bool	write_ini (std::ostream &os, const PConfig &config)
	Write config as ini file, return false if failed.
bool	write_json (std::ostream &os, const PConfig &config)
	Write config as json file, return false if failed.
Sections	read_ini (const char *data, size_t length)
	Reads Config INI from null terminated string and return Sections.
Sections	read_ini (const std::string &path)
	Reads Config INI from file and return Sections.
void	write_ini (std::ostream &os, const Sections &sections)
	Write Config INI with Sections to ostream.
void	write_ini (const std::string &path, const Sections &sections)
	Write Config INI with Sections to file, throw if failed.
Section	find (const Sections &sections, const std::string &name)
	Find a section with name, empty section if not found.
std::string	find (const Section &section, const std::string &key)
	Find a key-value pair from key and return value, empty string if not found.
void	dump (std::ostream &os, const Sections &sections)
	Dump content of sections.

Typedef Documentation

KeyValues

using crew::KeyValues = typedef std::unordered_map<std::string, std::string>

Definition at line 28 of file PConfigIni.h.

Parts

using crew::Parts = typedef std::vector<Part>

Definition at line 34 of file PConfig.h.

Sections

using crew::Sections = typedef std::vector<Section>

Definition at line 36 of file PConfigIni.h.

Source

using crew::Source = typedef Part

Definition at line 35 of file PConfig.h.

Function Documentation

dump()

void crew::dump	(	std::ostream &	os,
		const Sections &	sections
	)

Dump content of sections.

Definition at line 25 of file PConfigIniDump.cpp.

{
  for (auto &section : sections)
  {
    os << "[" << section.name << "]" << std::endl;
    for (auto &item : section.items)
    {
      os << item.first << "=" << item.second << std::endl;
    }
    os << std::endl;
  }
}

Referenced by operator<<().

find() [1/2]

std::string crew::find	(	const Section &	section,
		const std::string &	key
	)

Find a key-value pair from key and return value, empty string if not found.

Definition at line 215 of file PConfigIni.cpp.

{
  for (auto &item : section.items)
  {
    if (item.first == key)
      return item.second;
  }
  return "";
}

References crew::Section::items.

find() [2/2]

Section crew::find	(	const Sections &	sections,
		const std::string &	name
	)

Find a section with name, empty section if not found.

Definition at line 204 of file PConfigIni.cpp.

{
  for (auto &section : sections)
  {
    if (section.name == name)
      return section;
  }
  Section not_found;
  return not_found;
}

Referenced by read_ini().

read_ini() [1/3]

Sections crew::read_ini	(	const char *	data,
		size_t	length
	)

Reads Config INI from null terminated string and return Sections.

Definition at line 59 of file PConfigIni.cpp.

{
  assert(data != nullptr);
  assert(length > 0);
 
  auto buffer = std::vector<char>();
  buffer.reserve(length + 1);
  char *pbuffer = buffer.data();
  memcpy(pbuffer, data, length);
  // add null at end to be sure
  *(pbuffer + length) = 0;
 
  Sections sections;
  Section section;
 
  std::string string_line;
 
  const char *delim = "\r\n";
  const char *one_line = std::strtok(pbuffer, delim);
  while (one_line != nullptr)
  {
    if (*one_line == '[')
    {
      if (!section.name.empty())
      {
        sections.push_back(section);
      }
      section.name.clear();
      section.items.clear();
 
      string_line = one_line + 1;
      auto pos = string_line.find(']');
      assert(pos != std::string::npos);
      if (pos != std::string::npos)
      {
        section.name = string_line.substr(0, pos);
      }
    }
    else if (*one_line == '#' || *one_line == ';')
    {
      // Comment line, do nothing
    }
    else if (*one_line) // string legnth is not 0
    {
      if (section.name.empty())
        throw std::runtime_error("Invalid INI file");
 
      string_line = one_line;
      auto pos = string_line.find('=');
      assert(pos != std::string::npos);
      if (pos != std::string::npos)
      {
        auto key = string_line.substr(0, pos);
        auto val = string_line.substr(pos + 1);
        key = filter_escape(key);
        section.items.emplace(key, val);
      }
    }
 
    one_line = std::strtok(nullptr, delim);
  }
  if (!section.name.empty())
  {
    sections.push_back(section);
  }
 
  return sections;
}

References crew::Section::items, and crew::Section::name.

read_ini() [2/3]

Sections crew::read_ini

(

const std::string &

path

)

Reads Config INI from file and return Sections.

Definition at line 128 of file PConfigIni.cpp.

{
  foder::FileLoader file_loader{path};
  // load will throw if error while opening
  auto ini_data = file_loader.load();
 
  return read_ini(ini_data.data(), ini_data.size());
}

References foder::FileLoader::load(), and read_ini().

read_ini() [3/3]

bool crew::read_ini	(	const std::string &	path,
		PConfig &	config
	)

Read config as ini file, return false if failed.

Definition at line 121 of file PConfig.cpp.

{
  auto sections = crew::read_ini(path);
 
  auto section_source = crew::find(sections, "source");
  auto section_models = crew::find(sections, "models");
  if (section_source.name != "source" || section_models.name != "models")
  {
    return false;
  }
 
  if (!read_part(section_source, pconfig.source))
  {
    return false;
  }
 
  // get models list
  std::vector<std::string> models;
  for (int32_t i = 1;; ++i)
  {
    std::string item = "m" + std::to_string(i);
    std::string model = crew::find(section_models, item);
    if (model.empty())
      break;
 
    models.push_back(model);
  }
 
  for (auto &model : models)
  {
    auto section_model = crew::find(sections, model);
 
    Part part;
    if (!read_part(section_model, part))
    {
      return false;
    }
    pconfig.parts.push_back(part);
  }
 
  return true;
}

References find(), crew::PConfig::parts, read_ini(), and crew::PConfig::source.

Referenced by prunner::PModelsRunner::load_config(), partee::read(), read_ini(), and read_ini().

write_ini() [1/3]

void crew::write_ini	(	const std::string &	path,
		const Sections &	sections
	)

Write Config INI with Sections to file, throw if failed.

Definition at line 190 of file PConfigIni.cpp.

{
  std::ofstream fs(filepath.c_str(), std::ofstream::binary | std::ofstream::trunc);
  if (not fs.good())
  {
    std::string msg = "Failed to create file: " + filepath;
    throw std::runtime_error(msg);
  }
 
  write_ini(fs, sections);
 
  fs.close();
}

References write_ini().

write_ini() [2/3]

bool crew::write_ini	(	std::ostream &	os,
		const PConfig &	config
	)

Write config as ini file, return false if failed.

Definition at line 164 of file PConfig.cpp.

{
  crew::Sections sections;
 
  // make [source]
  crew::Section section_source;
  section_source.name = "source";
  section_source.items["file"] = pconfig.source.model_file;
  part_to_section_io(pconfig.source, section_source);
  sections.push_back(section_source);
 
  // make [models]
  crew::Section section_models;
  section_models.name = "models";
  uint32_t idx = 1;
  for (auto &part : pconfig.parts)
  {
    std::string key = "m" + std::to_string(idx);
    section_models.items[key] = part.model_file;
    idx++;
  }
  sections.push_back(section_models);
 
  for (auto &part : pconfig.parts)
  {
    // make circle model section
    crew::Section section_model;
    section_model.name = part.model_file;
    section_model.items["file"] = part.model_file;
    part_to_section_io(part, section_model);
    sections.push_back(section_model);
  }
 
  write_ini(os, sections);
 
  return true;
}

References crew::Section::items, crew::Part::model_file, crew::Section::name, crew::PConfig::parts, crew::PConfig::source, and write_ini().

Referenced by write_ini(), and write_ini().

write_ini() [3/3]

void crew::write_ini	(	std::ostream &	os,
		const Sections &	sections
	)

Write Config INI with Sections to ostream.

Definition at line 177 of file PConfigIni.cpp.

{
  std::stringstream ss;
 
  auto processed = insert_escape(sections);
 
  ss << processed;
 
  std::string strss = ss.str();
 
  os.write(strss.c_str(), strss.length());
}

write_json()

bool crew::write_json	(	std::ostream &	os,
		const PConfig &	config
	)

Write config as json file, return false if failed.

Definition at line 202 of file PConfig.cpp.

{
  crew::JsonExport je(os);
 
  je.open_brace();
  {
    je.open_brace("source");
    write_part(je, pconfig.source);
    je.close_brace(true);
  }
  {
    je.open_bracket("parts");
    write_parts(je, pconfig.parts);
    je.close_bracket(false);
  }
  je.close_brace(false);
 
  return true;
}

References crew::JsonExport::close_brace(), crew::JsonExport::close_bracket(), crew::JsonExport::open_brace(), crew::JsonExport::open_bracket(), crew::PConfig::parts, and crew::PConfig::source.