SphinxMessageConst.hpp

Go to the documentation of this file.

#ifndef SPHINX_MESSAGE_CONST_HPP
#define SPHINX_MESSAGE_CONST_HPP

namespace HCE
{
namespace sphinx
{
namespace message_const
{
//-----------------------------------------------------------------------------
  enum
  {
    LOAD_CONFIG_SUCCESS=0,
    HOST,
    PORT,
    INDEX,
    FILE_NOT_FOUND,
    FILE_NOT_OPEN,
    SEARCHD_MAX_MATCHES,
    SCHEMA_NAMES_SIZE,
    ATTRIBUTES_COUNT,
    EMPTY_LIST_OF_INDEX_FILES,
    LOAD_CONFIG_FAIL,
    EMPTY_RESULT_DATA,
    INCORRECT_JSON_TYPE,
    ERROR,
    ERROR_MSG,
    ERROR_CODE,
    SERIALIZE_OUTPUT_JSON_MESSAGE,
    GENERATE_DEFAULT_JSON,
    TRY_MAKE_INDEX_COMMAND,
    DOCUMENT_CONTENT_IS_EMPTY,
    INDEX_NAME,
    MAKE_INDEX_COMMAND_SUCCESS,
    TRY_MAKE_ADMIN_COMMAND,
    RECEIVED_EMPTY_COMMAND_STRING,
    UNKNOWN_COMMAND,
    MAKE_ADMIN_COMMAND_SUCCESS,
    FAILED_TO_CREATE_CLIENT,
    START_SEARCHD_READ_CONFIG,
    WAIT_START_SEARCHD,
    START_SEARCHD_FAIL,
    TRY_EASY_START,
    WAIT_STOP_SEARCHD,
    STOP_SEARCHD,
    INVALID_CLIENT_HANDLE,
    INVALID_FILTER,
    ADD_FILTER,
    INVALID_RANGE_OF_FILTER,
    UNKNOWN_FILTER_TYPE,
    SERVER_HOST_IS_EMPTY,
    SERVER_PORT_IS_NULL,
    SET_SERVER_SUCCESS,
    OPEN_CONNECTION_ERROR,
    EASY_START_SUCCESS,
    EASY_START_FALLEN,
    FIELD_ALREADY_EXIST,
    FIELD_NOT_FOUND,
    INDEX_ALREADY_EXIST,
    INDEX_NOT_FOUND,
    NOT_FOUND_IN_CONFIG,
    LIST_OF_INDEXES_IS_EMPTY,
    SEARCHD_ERROR,
    SEARCHD_WARNING,
    SEARCHD_STOPPED_PID_FILE_EXIST,
    SEARCHD_STOPPED_BUT_PID_FILE_EXIST,
    SEARCHD_NOT_ACTIVITY,
    FIELD_NOT_FOUND_IN_CURRENT_SCHEMA,
    GETTING_PARAMETERS_FAIL,
    ERROR_CLEAN_DIR,
    FOUND_INDEX_FILE,
    REMOVE_INDEX_FILE,
    REMOVE_FILE_FAIL,
    OPEN_DIR_FAIL,
    ERROR_GET_FILE_LIST,
    ERROR_GET_INDEX_LIST,
    EMPTY_DATA_DIR,
    TRY_OPEN_FILE_FAIL,
    TRY_USE_AS_DIRECTORY_WAS_CANCELED,
    CLOSE_DIR_FAIL,
    FOUND_FREE_ALLOWED_PORT,
    ERROR_GET_FREE_ALLOWED_PORT,
    ERROR_MAKE_CONFIG,
    MAKE_DIR_FAIL,
    DONT_CREATED_DIR,
//    DONT_CREATED_FILE,
    FOLDER_NOT_EXIST,
    FILE_NOT_EXIST,
    INVALID_DATA_CONTENT,
    INVALID_SCHEMA_CONTENT,
    COMMAND_LINE,
    INDEXATION_FAIL,
    BAD_BRANCH_NAME,
    MAKE_SOURCE_FAIL,
    MAKE_SOURCE,
    MAKE_INDEX,
    RECEIVED_EMPTY_LIST_BRANCHES
    // TODO
  };

  const char delimiter = ':';
  const char space = ' ';
  const char point = '.';

  const std::string loadConfigSuccess =  "LOAD CONFIG SUCCESS";
  const std::string host = "HOST";
  const std::string port = "PORT";
  const std::string index = "INDEX";
  const std::string fileNotFound = "File not found";
  const std::string fileNotOpen = "File not open";
  const std::string searchdMaxMatches = "SEARCHD MAX MATCHES";
  const std::string schemaNamesSize = "SCHEMA NAMES SIZE";
  const std::string attributesCount = "ATTRIBUTES COUNT";
  const std::string emptyListOfindexFiles = "Empty list of index files";
  const std::string loadConfigFail = "LOAD CONFIG FAIL";
  const std::string emptyResultData = "Empty result data";
  const std::string incorrectJSONType = "Incorrect JSON type";
  const std::string error = "Error";
  const std::string errorMsg = "ErrorMsg";
  const std::string errorCode = "ErrorCode";
  const std::string serializeOutputJsonMessage = "Serialize OutputJsonMessage";
  const std::string generateDefaultJSON = "Generate default JSON";
  const std::string tryMakeIndexCommand =  "TRY MAKE INDEX COMMAND";
  const std::string documentContentIsEmpty = "Document content is empty";
  const std::string indexName = "INDEX NAME";
  const std::string makeIndexCommandSuccess =  "!!! MAKE INDEX COMMAND SUCCESS !!!";
  const std::string tryMakeAdminCommand = "TRY MAKE ADMIN COMMAND";
  const std::string receivedEmptyCommandString = "Received empty command string";
  const std::string unknownCommand = "Unknown command";
  const std::string makeAdminCommandSuccess = "!!! MAKE ADMIN COMMAND SUCCESS !!!";
  const std::string failedToCreateClient = "Failed to create client";
  const std::string startSearchdReadConfig = "startSearchd read config";
  const std::string waitStartSearchd = "!!! WAIT START SEARCHD !!!";
  const std::string startSearchdFail = "Start searchd fail";
  const std::string tryEasyStart = "TRY EASY START";
  const std::string waitStopSearchd = "!!! WAIT STOP SEARCHD !!!";
  const std::string stopSearchd = "STOP SEARCHD";
  const std::string invalidClientHandle = "Invalid client handle";
  const std::string invalidFilter = "Invalid filter";
  const std::string addFilter = "Add filter";
  const std::string invalidRangeOfFilter = "Invalid range of filter";
  const std::string unknownFilterType = "Unknown filter type";
  const std::string serverHostIsEmpty = "Server host is empty";
  const std::string serverPortIsNull = "Server port is null";
  const std::string setServerSuccess = "!!! SET SERVER SUCCESS !!!";
  const std::string openConnectionError = "Open connection error";
  const std::string easyStartSuccess =  "!!! EASY START SUCCESS !!!";
  const std::string easyStartFallen = "!!! EASY START FALLEN !!!";
  const std::string fieldAlreadyExist = "Field already exist";
  const std::string fieldNotFound = "Field not found";
  const std::string indexAlreadyExist = "Index already exist";
  const std::string indexNotFound = "Index not found";
  const std::string notFoundInConfig = "NOT FOUND IN CONFIG";
  const std::string listOfIndexesIsEmpty = "List of indexes is empty, check initialization";
  const std::string searchdError = "SEARCHD ERROR";
  const std::string searchdWarning = "SEARCHD WARNING";
  const std::string searchdStoppedPidFileExist = "Searchd stopped. Pid file exist = ";
  const std::string searchdStoppedButPidFileExist = "Searchd stoped but pid file exist";
  const std::string searchdNotActivity = "Searchd not activity";
  const std::string fieldNotFoundInCurrentSchema = "Field not found in current schema";
  const std::string gettingParametersFail = "Getting parameters fail";
  const std::string errorCleanDir = "ERROR CLEAN DIR";
  const std::string foundIndexFile = "FOUND INDEX FILE";
  const std::string removeIndexFile = "REMOVE INDEX FILE";
  const std::string removeFileFail = "Remove file fail";
  const std::string openDirFail = "Open dir fail";
  const std::string errorGetFileList = "ERROR GET FILE LIST";
  const std::string errorGetIndexList = "ERROR GET INDEX LIST";
  const std::string emptyDataDir = "Empty data dir";
  const std::string tryOpenFileFail = "Try open file fail";
  const std::string tryUseAsDirectoryWasCanceled = "Try use as directory was canceled...";
  const std::string closeDirFail = "Close dir fail";
  const std::string foundFreeAllowedPort = "FOUND FREE ALLOWED PORT";
  const std::string errorGetFreeAllowedPort = "ERROR GET FREE ALLOWED PORT";
  const std::string errorMakeConfig = "ERROR MAKE CONFIG";
  const std::string makeDirFail = "Make dir fail";
  const std::string dontCreatedDir = "Don't created directory";
//  const std::string dontCreatedFile = "Don't created file";
  const std::string folderNotExist = "Forder not exist";
  const std::string fileNotExist = "File not exist";
  const std::string invalidDataContent = "Invalid data content";
  const std::string invalidSchemaContent = "Invalid schema content";
  const std::string commandLine = "COMMAND LINE";
  const std::string indexationFail = "Indexation fail";
  const std::string badBranchName = "Bad branch name";
  const std::string makeSourceFail = "Make source fail";
  const std::string makeSource = "MAKE SOURCE";
  const std::string makeIndex = "MAKE INDEX";
  const std::string receivedEmptyListOfBranches = "Received empty list of branches";
  // TODO
  const std::vector<std::pair<unsigned int, std::string> > messages =
  {
      { LOAD_CONFIG_SUCCESS, loadConfigSuccess },
      { HOST, host },
      { PORT, port },
      { INDEX, index },
      { FILE_NOT_FOUND, fileNotFound },
      { FILE_NOT_OPEN, fileNotOpen },
      { SEARCHD_MAX_MATCHES, searchdMaxMatches },
      { SCHEMA_NAMES_SIZE, schemaNamesSize },
      { ATTRIBUTES_COUNT, attributesCount },
      { EMPTY_LIST_OF_INDEX_FILES, emptyListOfindexFiles },
      { LOAD_CONFIG_FAIL, loadConfigFail },
      { EMPTY_RESULT_DATA, emptyResultData },
      { INCORRECT_JSON_TYPE, incorrectJSONType },
      { ERROR, error },
      { ERROR_MSG, errorMsg },
      { ERROR_CODE, errorCode },
      { SERIALIZE_OUTPUT_JSON_MESSAGE, serializeOutputJsonMessage },
      { GENERATE_DEFAULT_JSON, generateDefaultJSON },
      { TRY_MAKE_INDEX_COMMAND, tryMakeIndexCommand },
      { DOCUMENT_CONTENT_IS_EMPTY, documentContentIsEmpty },
      { INDEX_NAME, indexName },
      { MAKE_INDEX_COMMAND_SUCCESS, makeIndexCommandSuccess },
      { TRY_MAKE_ADMIN_COMMAND, tryMakeAdminCommand },
      { RECEIVED_EMPTY_COMMAND_STRING, receivedEmptyCommandString },
      { UNKNOWN_COMMAND, unknownCommand },
      { MAKE_ADMIN_COMMAND_SUCCESS, makeAdminCommandSuccess },
      { FAILED_TO_CREATE_CLIENT, failedToCreateClient },
      { START_SEARCHD_READ_CONFIG, startSearchdReadConfig },
      { WAIT_START_SEARCHD, waitStartSearchd },
      { START_SEARCHD_FAIL, startSearchdFail },
      { TRY_EASY_START, tryEasyStart },
      { WAIT_STOP_SEARCHD, waitStopSearchd },
      { STOP_SEARCHD, stopSearchd },
      { INVALID_CLIENT_HANDLE, invalidClientHandle },
      { INVALID_FILTER, invalidFilter },
      { ADD_FILTER, addFilter },
      { INVALID_RANGE_OF_FILTER, invalidRangeOfFilter },
      { UNKNOWN_FILTER_TYPE, unknownFilterType },
      { SERVER_HOST_IS_EMPTY, serverHostIsEmpty },
      { SERVER_PORT_IS_NULL, serverPortIsNull },
      { SET_SERVER_SUCCESS, setServerSuccess },
      { OPEN_CONNECTION_ERROR, openConnectionError },
      { EASY_START_SUCCESS, easyStartSuccess },
      { EASY_START_FALLEN, easyStartFallen },
      { FIELD_ALREADY_EXIST, fieldAlreadyExist },
      { FIELD_NOT_FOUND, fieldNotFound },
      { INDEX_ALREADY_EXIST, indexAlreadyExist },
      { INDEX_NOT_FOUND, indexNotFound },
      { NOT_FOUND_IN_CONFIG, notFoundInConfig },
      { LIST_OF_INDEXES_IS_EMPTY, listOfIndexesIsEmpty },
      { SEARCHD_ERROR, searchdError },
      { SEARCHD_WARNING, searchdWarning },
      { SEARCHD_STOPPED_PID_FILE_EXIST, searchdStoppedPidFileExist },
      { SEARCHD_STOPPED_BUT_PID_FILE_EXIST, searchdStoppedButPidFileExist },
      { SEARCHD_NOT_ACTIVITY, searchdNotActivity },
      { FIELD_NOT_FOUND_IN_CURRENT_SCHEMA, fieldNotFoundInCurrentSchema },
      { GETTING_PARAMETERS_FAIL, gettingParametersFail },
      { ERROR_CLEAN_DIR, errorCleanDir },
      { FOUND_INDEX_FILE, foundIndexFile },
      { REMOVE_INDEX_FILE, removeIndexFile },
      { REMOVE_FILE_FAIL, removeFileFail },
      { OPEN_DIR_FAIL, openDirFail },
      { ERROR_GET_FILE_LIST, errorGetFileList },
      { ERROR_GET_INDEX_LIST, errorGetIndexList },
      { EMPTY_DATA_DIR, emptyDataDir },
      { TRY_OPEN_FILE_FAIL, tryOpenFileFail },
      { TRY_USE_AS_DIRECTORY_WAS_CANCELED, tryUseAsDirectoryWasCanceled },
      { CLOSE_DIR_FAIL, closeDirFail },
      { FOUND_FREE_ALLOWED_PORT, foundFreeAllowedPort },
      { ERROR_GET_FREE_ALLOWED_PORT, errorGetFreeAllowedPort },
      { ERROR_MAKE_CONFIG, errorMakeConfig },
      { MAKE_DIR_FAIL, makeDirFail },
      { DONT_CREATED_DIR, dontCreatedDir },
//      { DONT_CREATED_FILE, dontCreatedFile },
      { FOLDER_NOT_EXIST, folderNotExist },
      { FILE_NOT_EXIST, fileNotExist },
      { INVALID_DATA_CONTENT, invalidDataContent },
      { INVALID_SCHEMA_CONTENT, invalidSchemaContent },
      { COMMAND_LINE, commandLine },
      { INDEXATION_FAIL, indexationFail },
      { BAD_BRANCH_NAME, badBranchName },
      { MAKE_SOURCE_FAIL, makeSourceFail },
      { MAKE_SOURCE, makeSource },
      { MAKE_INDEX, makeIndex },
      { RECEIVED_EMPTY_LIST_BRANCHES, receivedEmptyListOfBranches }

      // TODO
  };
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
} // namespace message_const
} // namespace sphinx
} // namespace HCE
#endif // SPHINX_MESSAGE_CONST_HPP