apollo::cyber::common 命名空间参考

类
class	GlobalData

枚举
enum	FileType { TYPE_FILE , TYPE_DIR }

函数
std::string	GetEnv (const std::string &var_name, const std::string &default_value="")
const std::string	WorkRoot ()
bool	SetProtoToASCIIFile (const google::protobuf::Message &message, int file_descriptor)
bool	SetProtoToASCIIFile (const google::protobuf::Message &message, const std::string &file_name)
	Sets the content of the file specified by the file_name to be the ascii representation of the input protobuf.
bool	SetStringToASCIIFile (const std::string &content, const std::string &file_name)
	Sets the content of the file specified by the file_name to be the ascii representation of the input string.
bool	GetProtoFromASCIIFile (const std::string &file_name, google::protobuf::Message *message)
	Parses the content of the file specified by the file_name as ascii representation of protobufs, and merges the parsed content to the proto.
bool	SetProtoToBinaryFile (const google::protobuf::Message &message, const std::string &file_name)
	Sets the content of the file specified by the file_name to be the binary representation of the input protobuf.
bool	GetProtoFromBinaryFile (const std::string &file_name, google::protobuf::Message *message)
	Parses the content of the file specified by the file_name as binary representation of protobufs, and merges the parsed content to the proto.
bool	GetProtoFromFile (const std::string &file_name, google::protobuf::Message *message)
	Parses the content of the file specified by the file_name as a representation of protobufs, and merges the parsed content to the proto.
bool	GetProtoFromJsonFile (const std::string &file_name, google::protobuf::Message *message)
	Parses the content of the json file specified by the file_name as ascii representation of protobufs, and merges the parsed content to the proto.
bool	GetContent (const std::string &file_name, std::string *content)
	Get file content as string.
std::string	GetAbsolutePath (const std::string &prefix, const std::string &relative_path)
	Get absolute path by concatenating prefix and relative_path.
bool	PathExists (const std::string &path)
	Check if the path exists.
bool	PathIsAbsolute (const std::string &path)
bool	DirectoryExists (const std::string &directory_path)
	Check if the directory specified by directory_path exists and is indeed a directory.
std::vector< std::string >	Glob (const std::string &pattern)
	Expand path pattern to matched paths.
bool	CopyFile (const std::string &from, const std::string &to)
	Copy a file.
bool	CopyDir (const std::string &from, const std::string &to)
	Copy a directory.
bool	Copy (const std::string &from, const std::string &to)
	Copy a file or directory.
bool	EnsureDirectory (const std::string &directory_path)
	Check if a specified directory specified by directory_path exists.
bool	RemoveAllFiles (const std::string &directory_path)
	Remove all the files under a specified directory.
std::vector< std::string >	ListSubPaths (const std::string &directory_path, const unsigned char d_type=DT_DIR)
	List sub-paths.
size_t	FindPathByPattern (const std::string &base_path, const std::string &patt, const unsigned char d_type, const bool recursive, std::vector< std::string > *result_list)
	Find path with pattern
std::string	GetDirName (const std::string &path)
	get directory name of path
std::string	GetFileName (const std::string &path, const bool remove_extension)
bool	GetFilePathWithEnv (const std::string &path, const std::string &env_var, std::string *file_path)
	get file path, judgement priority:
std::string	GetCurrentPath ()
bool	GetType (const string &filename, FileType *type)
bool	DeleteFile (const string &filename)
bool	CreateDir (const string &dir)
bool	DeleteFile (const std::string &filename)
bool	GetType (const std::string &filename, FileType *type)
bool	CreateDir (const std::string &dir)
template<typename T >
bool	LoadConfig (const std::string &relative_path, T *config)
template<typename T >
T	UnixToGpsSeconds (T unix_seconds)
int64_t	UnixToGpsMicroseconds (int64_t unix_microseconds)
int64_t	UnixToGpsNanoseconds (int64_t unix_nanoseconds)
template<typename T >
T	GpsToUnixSeconds (T gps_seconds)
int64_t	GpsToUnixMicroseconds (int64_t gps_microseconds)
int64_t	GpsToUnixNanoseconds (int64_t gps_nanoseconds)
uint64_t	GpsToUnixMicroseconds (uint64_t gps_microseconds)
uint64_t	GpsToUnixNanoseconds (uint64_t gps_nanoseconds)
uint64_t	StringToUnixSeconds (const std::string &time_str, const std::string &format_str="%Y-%m-%d %H:%M:%S")
std::string	UnixSecondsToString (uint64_t unix_seconds, const std::string &format_str="%Y-%m-%d-%H:%M:%S")
std::size_t	Hash (const std::string &key)
template<typename Enum >
auto	ToInt (Enum const value) -> typename std::underlying_type< Enum >::type

变量
constexpr int32_t	UNIX_GPS_DIFF = 315964800
constexpr int64_t	ONE_MILLION = 1000000L
constexpr int64_t	ONE_BILLION = 1000000000L

枚举类型说明

FileType

enum apollo::cyber::common::FileType

枚举值
TYPE_FILE
TYPE_DIR

在文件 file.h 第 49 行定义.

{ TYPE_FILE, TYPE_DIR };

函数说明

Copy()

bool apollo::cyber::common::Copy	(	const std::string &	from,
		const std::string &	to
	)

Copy a file or directory.

参数

from	The path to copy from.
to	The path to copy to.

返回

If the action is successful.

在文件 file.cc 第 281 行定义.

                                                      {
  return DirectoryExists(from) ? CopyDir(from, to) : CopyFile(from, to);
}

CopyDir()

bool apollo::cyber::common::CopyDir	(	const std::string &	from,
		const std::string &	to
	)

Copy a directory.

参数

from	The path to copy from.
to	The path to copy to.

返回

If the action is successful.

在文件 file.cc 第 250 行定义.

                                                         {
  DIR *directory = opendir(from.c_str());
  if (directory == nullptr) {
    AERROR << "Cannot open directory " << from;
    return false;
  }
 
  bool ret = true;
  if (EnsureDirectory(to)) {
    struct dirent *entry;
    while ((entry = readdir(directory)) != nullptr) {
      // skip directory_path/. and directory_path/..
      if (!strcmp(entry->d_name, ".") || !strcmp(entry->d_name, "..")) {
        continue;
      }
      const std::string sub_path_from = from + "/" + entry->d_name;
      const std::string sub_path_to = to + "/" + entry->d_name;
      if (entry->d_type == DT_DIR) {
        ret &= CopyDir(sub_path_from, sub_path_to);
      } else {
        ret &= CopyFile(sub_path_from, sub_path_to);
      }
    }
  } else {
    AERROR << "Cannot create target directory " << to;
    ret = false;
  }
  closedir(directory);
  return ret;
}

CopyFile()

bool apollo::cyber::common::CopyFile	(	const std::string &	from,
		const std::string &	to
	)

Copy a file.

参数

from	The file path to copy from.
to	The file path to copy to.

返回

If the action is successful.

在文件 file.cc 第 224 行定义.

                                                          {
  std::ifstream src(from, std::ios::binary);
  if (!src) {
    AWARN << "Source path could not be normally opened: " << from;
    std::string command = "cp -r " + from + " " + to;
    ADEBUG << command;
    const int ret = std::system(command.c_str());
    if (ret == 0) {
      ADEBUG << "Copy success, command returns " << ret;
      return true;
    } else {
      ADEBUG << "Copy error, command returns " << ret;
      return false;
    }
  }
 
  std::ofstream dst(to, std::ios::binary);
  if (!dst) {
    AERROR << "Target path is not writable: " << to;
    return false;
  }
 
  dst << src.rdbuf();
  return true;
}

CreateDir() [1/2]

bool apollo::cyber::common::CreateDir

(

const std::string &

dir

)

CreateDir() [2/2]

bool apollo::cyber::common::CreateDir

(

const string &

dir

)

在文件 file.cc 第 538 行定义.

                                  {
  int ret = mkdir(dir.c_str(), S_IRWXU | S_IRWXG | S_IRWXO);
  if (ret != 0) {
    AWARN << "failed to create dir. [dir: " << dir
          << "] [err: " << strerror(errno) << "]";
    return false;
  }
  return true;
}

DeleteFile() [1/2]

bool apollo::cyber::common::DeleteFile

(

const std::string &

filename

)

DeleteFile() [2/2]

bool apollo::cyber::common::DeleteFile

(

const string &

filename

)

在文件 file.cc 第 495 行定义.

                                        {
  if (!PathExists(filename)) {
    return true;
  }
  FileType type;
  if (!GetType(filename, &type)) {
    return false;
  }
  if (type == TYPE_FILE) {
    if (remove(filename.c_str()) != 0) {
      AERROR << "failed to remove file: " << filename;
      return false;
    }
    return true;
  }
  DIR *dir = opendir(filename.c_str());
  if (dir == nullptr) {
    AWARN << "failed to opendir: " << filename;
    return false;
  }
  dirent *dir_info = nullptr;
  while ((dir_info = readdir(dir)) != nullptr) {
    if (strcmp(dir_info->d_name, ".") == 0 ||
        strcmp(dir_info->d_name, "..") == 0) {
      continue;
    }
    string temp_file = filename + "/" + string(dir_info->d_name);
    FileType temp_type;
    if (!GetType(temp_file, &temp_type)) {
      AWARN << "failed to get file type: " << temp_file;
      closedir(dir);
      return false;
    }
    if (type == TYPE_DIR) {
      DeleteFile(temp_file);
    }
    remove(temp_file.c_str());
  }
  closedir(dir);
  remove(filename.c_str());
  return true;
}

DirectoryExists()

bool apollo::cyber::common::DirectoryExists

(

const std::string &

directory_path

)

Check if the directory specified by directory_path exists and is indeed a directory.

参数

directory_path

Directory path.

返回

If the directory specified by directory_path exists and is indeed a directory.

在文件 file.cc 第 207 行定义.

                                                      {
  struct stat info;
  return stat(directory_path.c_str(), &info) == 0 && (info.st_mode & S_IFDIR);
}

EnsureDirectory()

bool apollo::cyber::common::EnsureDirectory

(

const std::string &

directory_path

)

Check if a specified directory specified by directory_path exists.

If not, recursively create the directory (and its parents).

参数

directory_path

Directory path.

返回

If the directory does exist or its creation is successful.

在文件 file.cc 第 285 行定义.

                                                      {
  std::string path = directory_path;
  for (size_t i = 1; i < directory_path.size(); ++i) {
    if (directory_path[i] == '/') {
      // Whenever a '/' is encountered, create a temporary view from
      // the start of the path to the character right before this.
      path[i] = 0;
 
      if (mkdir(path.c_str(), S_IRWXU) != 0) {
        if (errno != EEXIST) {
          return false;
        }
      }
 
      // Revert the temporary view back to the original.
      path[i] = '/';
    }
  }
 
  // Make the final (full) directory.
  if (mkdir(path.c_str(), S_IRWXU) != 0) {
    if (errno != EEXIST) {
      return false;
    }
  }
 
  return true;
}

FindPathByPattern()

size_t apollo::cyber::common::FindPathByPattern	(	const std::string &	base_path,
		const std::string &	patt,
		const unsigned char	d_type,
		const bool	recursive,
		std::vector< std::string > *	result_list
	)

Find path with pattern

参数

base_path	search root
patt	pattern to compare with entry->d_name for filter
d_type	entry type for filter
recursive	search directory recursively
result_list	a vector reference for storing the search result

返回

the result count

在文件 file.cc 第 360 行定义.

                                                            {
  DIR *directory = opendir(base_path.c_str());
  size_t result_cnt = 0;
  if (directory == nullptr) {
    AWARN << "cannot open directory " << base_path;
    return result_cnt;
  }
  struct dirent *entry;
  for (entry = readdir(directory); entry != nullptr;
       entry = readdir(directory)) {
    std::string entry_path = base_path + "/" + std::string(entry->d_name);
    // skip `.` and `..`
    if (strcmp(entry->d_name, ".") != 0 && strcmp(entry->d_name, "..") != 0) {
      // TODO(liangjinping): support regex or glob or other pattern mode
      if ((patt == "" || strcmp(entry->d_name, patt.c_str()) == 0) &&
          entry->d_type == d_type) {
        // found
        result_list->emplace_back(entry_path);
        ++result_cnt;
      }
      if (recursive && (entry->d_type == DT_DIR)) {
        result_cnt +=
            FindPathByPattern(entry_path, patt, d_type, recursive, result_list);
      }
    }
  }
  closedir(directory);
  return result_cnt;
}

GetAbsolutePath()

std::string apollo::cyber::common::GetAbsolutePath	(	const std::string &	prefix,
		const std::string &	relative_path
	)

Get absolute path by concatenating prefix and relative_path.

返回

The absolute path.

在文件 file.cc 第 179 行定义.

                                                            {
  if (relative_path.empty()) {
    return prefix;
  }
  // If prefix is empty or relative_path is already absolute.
  if (prefix.empty() || relative_path.front() == '/') {
    return relative_path;
  }
 
  if (prefix.back() == '/') {
    return prefix + relative_path;
  }
  return prefix + "/" + relative_path;
}

GetContent()

bool apollo::cyber::common::GetContent	(	const std::string &	file_name,
		std::string *	content
	)

Get file content as string.

参数

file_name	The name of the file to read content.
content	The file content.

返回

If the action is successful.

在文件 file.cc 第 167 行定义.

                                                                {
  std::ifstream fin(file_name);
  if (!fin) {
    return false;
  }
 
  std::stringstream str_stream;
  str_stream << fin.rdbuf();
  *content = str_stream.str();
  return true;
}

GetCurrentPath()

std::string apollo::cyber::common::GetCurrentPath

(

)

在文件 file.cc 第 474 行定义.

                           {
  char tmp[PATH_MAX];
  return getcwd(tmp, sizeof(tmp)) ? std::string(tmp) : std::string("");
}

GetDirName()

std::string apollo::cyber::common::GetDirName

(

const std::string &

path

)

get directory name of path

参数

path

返回

dirname of path

在文件 file.cc 第 392 行定义.

                                            {
  std::string::size_type end = path.rfind('/');
  if (end == std::string::npos) {
    // not found, return current dir
    return ".";
  }
  return path.substr(0, end);
}

GetEnv()

std::string apollo::cyber::common::GetEnv ( const std::string &  var_name, const std::string &  default_value = ""  )

inline

在文件 environment.h 第 29 行定义.

                                                               {
  const char* var = std::getenv(var_name.c_str());
  if (var == nullptr) {
    AWARN << "Environment variable [" << var_name << "] not set, fallback to "
          << default_value;
    return default_value;
  }
  return std::string(var);
}

GetFileName()

std::string apollo::cyber::common::GetFileName	(	const std::string &	path,
		const bool	remove_extension
	)

在文件 file.cc 第 401 行定义.

                                                                          {
  std::string::size_type start = path.rfind('/');
  if (start == std::string::npos) {
    start = 0;
  } else {
    // Move to the next char after '/'.
    ++start;
  }
 
  std::string::size_type end = std::string::npos;
  if (remove_extension) {
    end = path.rfind('.');
    // The last '.' is found before last '/', ignore.
    if (end != std::string::npos && end < start) {
      end = std::string::npos;
    }
  }
  const auto len = (end != std::string::npos) ? end - start : end;
  return path.substr(start, len);
}

GetFilePathWithEnv()

bool apollo::cyber::common::GetFilePathWithEnv	(	const std::string &	path,
		const std::string &	env_var,
		std::string *	file_path
	)

get file path, judgement priority:

1. absolute path.
2. relative path starts with '.'.
3. add environment variable prefix before the path.
4. a common relative path.

参数

path	input file path string.
env_var	environment var string.
file_path	the output file path.

返回

if no valid path found, return false.

在文件 file.cc 第 422 行定义.

                                              {
  if (path.empty()) {
    return false;
  }
  if (PathIsAbsolute(path)) {
    // an absolute path
    *file_path = path;
    return PathExists(path);
  }
 
  bool relative_path_exists = false;
  if (PathExists(path)) {
    // relative path exists
    *file_path = path;
    relative_path_exists = true;
  }
  if (path.front() == '.') {
    // relative path but not exist.
    return relative_path_exists;
  }
 
  const char *var = std::getenv(env_var.c_str());
  if (var == nullptr) {
    AWARN << "GetFilePathWithEnv: env " << env_var << " not found.";
    return relative_path_exists;
  }
  std::string env_path = std::string(var);
 
  // search by environment variable
  size_t begin = 0;
  size_t index;
  do {
    index = env_path.find(':', begin);
    auto p = env_path.substr(begin, index - begin);
    if (p.empty()) {
      continue;
    }
    if (p.back() != '/') {
      p += '/' + path;
    } else {
      p += path;
    }
    if (PathExists(p)) {
      *file_path = p;
      return true;
    }
    begin = index + 1;
  } while (index != std::string::npos);
  return relative_path_exists;
}

GetProtoFromASCIIFile()

bool apollo::cyber::common::GetProtoFromASCIIFile	(	const std::string &	file_name,
		google::protobuf::Message *	message
	)

Parses the content of the file specified by the file_name as ascii representation of protobufs, and merges the parsed content to the proto.

参数

file_name	The name of the file to parse whose content.
message	The proto to carry the parsed content in the specified file.

返回

If the action is successful.

在文件 file.cc 第 89 行定义.

                                                           {
  using google::protobuf::TextFormat;
  using google::protobuf::io::FileInputStream;
  using google::protobuf::io::ZeroCopyInputStream;
  int file_descriptor = open(file_name.c_str(), O_RDONLY);
  if (file_descriptor < 0) {
    AERROR << "Failed to open file " << file_name << " in text mode.";
    // Failed to open;
    return false;
  }
 
  ZeroCopyInputStream *input = new FileInputStream(file_descriptor);
  bool success = TextFormat::Parse(input, message);
  if (!success) {
    AERROR << "Failed to parse file " << file_name << " as text proto.";
  }
  delete input;
  close(file_descriptor);
  return success;
}

GetProtoFromBinaryFile()

bool apollo::cyber::common::GetProtoFromBinaryFile	(	const std::string &	file_name,
		google::protobuf::Message *	message
	)

Parses the content of the file specified by the file_name as binary representation of protobufs, and merges the parsed content to the proto.

参数

file_name	The name of the file to parse whose content.
message	The proto to carry the parsed content in the specified file.

返回

If the action is successful.

在文件 file.cc 第 118 行定义.

                                                            {
  std::fstream input(file_name, std::ios::in | std::ios::binary);
  if (!input.good()) {
    AERROR << "Failed to open file " << file_name << " in binary mode.";
    return false;
  }
  if (!message->ParseFromIstream(&input)) {
    AERROR << "Failed to parse file " << file_name << " as binary proto.";
    return false;
  }
  return true;
}

GetProtoFromFile()

bool apollo::cyber::common::GetProtoFromFile	(	const std::string &	file_name,
		google::protobuf::Message *	message
	)

Parses the content of the file specified by the file_name as a representation of protobufs, and merges the parsed content to the proto.

参数

file_name	The name of the file to parse whose content.
message	The proto to carry the parsed content in the specified file.

返回

If the action is successful.

在文件 file.cc 第 132 行定义.

                                                      {
  if (!PathExists(file_name)) {
    AERROR << "File [" << file_name << "] does not exist! ";
    return false;
  }
  // Try the binary parser first if it's much likely a binary proto.
  static const std::string kBinExt = ".bin";
  if (std::equal(kBinExt.rbegin(), kBinExt.rend(), file_name.rbegin())) {
    return GetProtoFromBinaryFile(file_name, message) ||
           GetProtoFromASCIIFile(file_name, message);
  }
 
  return GetProtoFromASCIIFile(file_name, message) ||
         GetProtoFromBinaryFile(file_name, message);
}

GetProtoFromJsonFile()

bool apollo::cyber::common::GetProtoFromJsonFile	(	const std::string &	file_name,
		google::protobuf::Message *	message
	)

Parses the content of the json file specified by the file_name as ascii representation of protobufs, and merges the parsed content to the proto.

参数

file_name	The name of the file to parse whose content.
message	The proto to carry the parsed content in the specified file.

返回

If the action is successful.

在文件 file.cc 第 149 行定义.

                                                          {
  using google::protobuf::util::JsonParseOptions;
  using google::protobuf::util::JsonStringToMessage;
  std::ifstream ifs(file_name);
  if (!ifs.is_open()) {
    AERROR << "Failed to open file " << file_name;
    return false;
  }
  nlohmann::json Json;
  ifs >> Json;
  ifs.close();
  JsonParseOptions options;
  options.ignore_unknown_fields = true;
  google::protobuf::util::Status dump_status;
  return (JsonStringToMessage(Json.dump(), message, options).ok());
}

GetType() [1/2]

bool apollo::cyber::common::GetType	(	const std::string &	filename,
		FileType *	type
	)

GetType() [2/2]

bool apollo::cyber::common::GetType	(	const string &	filename,
		FileType *	type
	)

在文件 file.cc 第 479 行定义.

                                                     {
  struct stat stat_buf;
  if (lstat(filename.c_str(), &stat_buf) != 0) {
    return false;
  }
  if (S_ISDIR(stat_buf.st_mode) != 0) {
    *type = TYPE_DIR;
  } else if (S_ISREG(stat_buf.st_mode) != 0) {
    *type = TYPE_FILE;
  } else {
    AWARN << "failed to get type: " << filename;
    return false;
  }
  return true;
}

Glob()

std::vector< std::string > apollo::cyber::common::Glob

(

const std::string &

pattern

)

Expand path pattern to matched paths.

参数

pattern

Path pattern, which may contain wildcards [?*].

返回

Matched path list.

在文件 file.cc 第 212 行定义.

                                                    {
  glob_t globs = {};
  std::vector<std::string> results;
  if (glob(pattern.c_str(), GLOB_TILDE, nullptr, &globs) == 0) {
    for (size_t i = 0; i < globs.gl_pathc; ++i) {
      results.emplace_back(globs.gl_pathv[i]);
    }
  }
  globfree(&globs);
  return results;
}

GpsToUnixMicroseconds() [1/2]

int64_t apollo::cyber::common::GpsToUnixMicroseconds ( int64_t  gps_microseconds )

inline

在文件 time_conversion.h 第 95 行定义.

                                                               {
  return GpsToUnixSeconds(gps_microseconds / ONE_MILLION) * ONE_MILLION +
         gps_microseconds % ONE_MILLION;
}

GpsToUnixMicroseconds() [2/2]

uint64_t apollo::cyber::common::GpsToUnixMicroseconds ( uint64_t  gps_microseconds )

inline

在文件 time_conversion.h 第 105 行定义.

                                                                 {
  return GpsToUnixSeconds(gps_microseconds / ONE_MILLION) * ONE_MILLION +
         gps_microseconds % ONE_MILLION;
}

GpsToUnixNanoseconds() [1/2]

int64_t apollo::cyber::common::GpsToUnixNanoseconds ( int64_t  gps_nanoseconds )

inline

在文件 time_conversion.h 第 100 行定义.

                                                             {
  return GpsToUnixSeconds(gps_nanoseconds / ONE_BILLION) * ONE_BILLION +
         gps_nanoseconds % ONE_BILLION;
}

GpsToUnixNanoseconds() [2/2]

uint64_t apollo::cyber::common::GpsToUnixNanoseconds ( uint64_t  gps_nanoseconds )

inline

在文件 time_conversion.h 第 110 行定义.

                                                               {
  return GpsToUnixSeconds(gps_nanoseconds / ONE_BILLION) * ONE_BILLION +
         gps_nanoseconds % ONE_BILLION;
}

GpsToUnixSeconds()

template<typename T >

T apollo::cyber::common::GpsToUnixSeconds

(

T

gps_seconds

)

在文件 time_conversion.h 第 85 行定义.

                                  {
  for (size_t i = 0; i < LEAP_SECONDS.size(); ++i) {
    T result = gps_seconds + (UNIX_GPS_DIFF - LEAP_SECONDS[i].second);
    if ((int32_t)result >= LEAP_SECONDS[i].first) {
      return result;
    }
  }
  return static_cast<T>(0);
}

Hash()

std::size_t apollo::cyber::common::Hash ( const std::string &  key )

inline

在文件 util.h 第 27 行定义.

                                            {
  return std::hash<std::string>{}(key);
}

ListSubPaths()

std::vector< std::string > apollo::cyber::common::ListSubPaths	(	const std::string &	directory_path,
		const unsigned char	d_type = DT_DIR
	)

List sub-paths.

参数

directory_path	Directory path.
d_type	Sub-path type, DT_DIR for directory, or DT_REG for file.

返回

A vector of sub-paths, without the directory_path prefix.

在文件 file.cc 第 339 行定义.

                                                                  {
  std::vector<std::string> result;
  DIR *directory = opendir(directory_path.c_str());
  if (directory == nullptr) {
    AERROR << "Cannot open directory " << directory_path;
    return result;
  }
 
  struct dirent *entry;
  while ((entry = readdir(directory)) != nullptr) {
    // Skip "." and "..".
    if (entry->d_type == d_type && strcmp(entry->d_name, ".") != 0 &&
        strcmp(entry->d_name, "..") != 0) {
      result.emplace_back(entry->d_name);
    }
  }
  closedir(directory);
  return result;
}

LoadConfig()

template<typename T >

bool apollo::cyber::common::LoadConfig	(	const std::string &	relative_path,
		T *	config
	)

在文件 file.h 第 265 行定义.

                                                           {
  CHECK_NOTNULL(config);
  // todo: get config base relative path
  std::string actual_config_path;
  if (!GetFilePathWithEnv(relative_path, "APOLLO_CONF_PATH",
                          &actual_config_path)) {
    AERROR << "conf file [" << relative_path
           << "] is not found in APOLLO_CONF_PATH";
    return false;
  }
  AINFO << "load conf file: " << actual_config_path;
  return GetProtoFromFile(actual_config_path, config);
}

PathExists()

bool apollo::cyber::common::PathExists

(

const std::string &

path

)

Check if the path exists.

参数

path	a file name, such as /a/b/c.txt

返回

If the path exists.

在文件 file.cc 第 195 行定义.

                                       {
  struct stat info;
  return stat(path.c_str(), &info) == 0;
}

PathIsAbsolute()

bool apollo::cyber::common::PathIsAbsolute

(

const std::string &

path

)

在文件 file.cc 第 200 行定义.

                                           {
  if (path.empty()) {
    return false;
  }
  return path.front() == '/';
}

RemoveAllFiles()

bool apollo::cyber::common::RemoveAllFiles

(

const std::string &

directory_path

)

Remove all the files under a specified directory.

Note that sub-directories are NOT affected.

参数

directory_path

Directory path.

返回

If the action is successful.

在文件 file.cc 第 314 行定义.

                                                     {
  DIR *directory = opendir(directory_path.c_str());
  if (directory == nullptr) {
    AERROR << "Cannot open directory " << directory_path;
    return false;
  }
 
  struct dirent *file;
  while ((file = readdir(directory)) != nullptr) {
    // skip directory_path/. and directory_path/..
    if (!strcmp(file->d_name, ".") || !strcmp(file->d_name, "..")) {
      continue;
    }
    // build the path for each file in the folder
    std::string file_path = directory_path + "/" + file->d_name;
    if (unlink(file_path.c_str()) < 0) {
      AERROR << "Fail to remove file " << file_path << ": " << strerror(errno);
      closedir(directory);
      return false;
    }
  }
  closedir(directory);
  return true;
}

SetProtoToASCIIFile() [1/2]

bool apollo::cyber::common::SetProtoToASCIIFile	(	const google::protobuf::Message &	message,
		const std::string &	file_name
	)

Sets the content of the file specified by the file_name to be the ascii representation of the input protobuf.

参数

message	The proto to output to the specified file.
file_name	The name of the target file to set the content.

返回

If the action is successful.

在文件 file.cc 第 59 行定义.

                                                     {
  int fd = open(file_name.c_str(), O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU);
  if (fd < 0) {
    AERROR << "Unable to open file " << file_name << " to write.";
    return false;
  }
  return SetProtoToASCIIFile(message, fd);
}

SetProtoToASCIIFile() [2/2]

bool apollo::cyber::common::SetProtoToASCIIFile	(	const google::protobuf::Message &	message,
		int	file_descriptor
	)

在文件 file.cc 第 43 行定义.

                                              {
  using google::protobuf::TextFormat;
  using google::protobuf::io::FileOutputStream;
  using google::protobuf::io::ZeroCopyOutputStream;
  if (file_descriptor < 0) {
    AERROR << "Invalid file descriptor.";
    return false;
  }
  ZeroCopyOutputStream *output = new FileOutputStream(file_descriptor);
  bool success = TextFormat::Print(message, output);
  delete output;
  close(file_descriptor);
  return success;
}

SetProtoToBinaryFile()

bool apollo::cyber::common::SetProtoToBinaryFile	(	const google::protobuf::Message &	message,
		const std::string &	file_name
	)

Sets the content of the file specified by the file_name to be the binary representation of the input protobuf.

参数

message	The proto to output to the specified file.
file_name	The name of the target file to set the content.

返回

If the action is successful.

在文件 file.cc 第 111 行定义.

                                                      {
  std::fstream output(file_name,
                      std::ios::out | std::ios::trunc | std::ios::binary);
  return message.SerializeToOstream(&output);
}

SetStringToASCIIFile()

bool apollo::cyber::common::SetStringToASCIIFile	(	const std::string &	content,
		const std::string &	file_name
	)

Sets the content of the file specified by the file_name to be the ascii representation of the input string.

参数

content	The string to output to the specified file.
file_name	The name of the target file to set the content.

返回

If the action is successful.

在文件 file.cc 第 69 行定义.

                                                      {
  int fd = open(file_name.c_str(), O_WRONLY | O_CREAT | O_TRUNC, S_IRWXU);
  if (fd < 0) {
    AERROR << "Unable to open file " << file_name << " to write.";
    return false;
  }
  // Write the string data to the file
  ssize_t bytes_written = write(fd, content.c_str(), content.size());
  if (bytes_written < 0) {
    AERROR << "Failed to write to file.";
    close(fd);  // Ensure the file descriptor is closed even on error
    return false;
  }
 
  close(fd);  // Close the file descriptor
 
  return true;
}

StringToUnixSeconds()

uint64_t apollo::cyber::common::StringToUnixSeconds ( const std::string &  time_str, const std::string &  format_str = "%Y-%m-%d %H:%M:%S"  )

inline

在文件 time_conversion.h 第 115 行定义.

                                              :%M:%S") {
  tm tmp_time;
  strptime(time_str.c_str(), format_str.c_str(), &tmp_time);
  tmp_time.tm_isdst = -1;
  time_t time = mktime(&tmp_time);
  return static_cast<uint64_t>(time);
}

ToInt()

template<typename Enum >

auto apollo::cyber::common::ToInt

(

Enum const

value

)

-> typename std::underlying_type<Enum>::type

在文件 util.h 第 32 行定义.

                                                                      {
  return static_cast<typename std::underlying_type<Enum>::type>(value);
}

UnixSecondsToString()

std::string apollo::cyber::common::UnixSecondsToString ( uint64_t  unix_seconds, const std::string &  format_str = "%Y-%m-%d-%H:%M:%S"  )

inline

在文件 time_conversion.h 第 125 行定义.

                                              :%M:%S") {
  std::time_t t = unix_seconds;
  struct tm ptm;
  struct tm* ret = localtime_r(&t, &ptm);
  if (ret == nullptr) {
    return std::string("");
  }
  uint32_t length = 64;
  std::vector<char> buff(length, '\0');
  strftime(buff.data(), length, format_str.c_str(), ret);
  return std::string(buff.data());
}

UnixToGpsMicroseconds()

int64_t apollo::cyber::common::UnixToGpsMicroseconds ( int64_t  unix_microseconds )

inline

在文件 time_conversion.h 第 74 行定义.

                                                                {
  return UnixToGpsSeconds(unix_microseconds / ONE_MILLION) * ONE_MILLION +
         unix_microseconds % ONE_MILLION;
}

UnixToGpsNanoseconds()

int64_t apollo::cyber::common::UnixToGpsNanoseconds ( int64_t  unix_nanoseconds )

inline

在文件 time_conversion.h 第 79 行定义.

                                                              {
  return UnixToGpsSeconds(unix_nanoseconds / ONE_BILLION) * ONE_BILLION +
         unix_nanoseconds % ONE_BILLION;
}

UnixToGpsSeconds()

template<typename T >

T apollo::cyber::common::UnixToGpsSeconds

(

T

unix_seconds

)

在文件 time_conversion.h 第 65 行定义.

                                   {
  for (size_t i = 0; i < LEAP_SECONDS.size(); ++i) {
    if (unix_seconds >= LEAP_SECONDS[i].first) {
      return unix_seconds - (UNIX_GPS_DIFF - LEAP_SECONDS[i].second);
    }
  }
  return static_cast<T>(0);
}

WorkRoot()

const std::string apollo::cyber::common::WorkRoot ( )

inline

在文件 environment.h 第 40 行定义.

                                  {
  std::string work_root = GetEnv("CYBER_PATH");
  if (work_root.empty()) {
    work_root = "/apollo/cyber";
  }
  return work_root;
}

变量说明

ONE_BILLION

constexpr int64_t apollo::cyber::common::ONE_BILLION = 1000000000L

constexpr

在文件 time_conversion.h 第 62 行定义.

ONE_MILLION

constexpr int64_t apollo::cyber::common::ONE_MILLION = 1000000L

constexpr

在文件 time_conversion.h 第 60 行定义.

UNIX_GPS_DIFF

constexpr int32_t apollo::cyber::common::UNIX_GPS_DIFF = 315964800

constexpr

在文件 time_conversion.h 第 58 行定义.