Change spelling of 'initialize' to American English (actual code and files)

UnitTests/Basics/hashes-test.cpp

@@ -41,7 +41,7 @@ struct CHashesSetup {
   CHashesSetup () {
     BOOST_TEST_MESSAGE("setup hashes");
 
-    TRI_InitialiseHashes();
+    TRI_InitializeHashes();
   }
 
   ~CHashesSetup () {

arangod/ApplicationServer/ApplicationServer.cpp

@@ -174,7 +174,7 @@ string const& ApplicationServer::getName () const {
 
 void ApplicationServer::setupLogging (bool threaded, bool daemon, bool backgrounded) {
   TRI_ShutdownLogging(false);
-  TRI_InitialiseLogging(threaded);
+  TRI_InitializeLogging(threaded);
 
   std::string severity("human");
 

arangod/Aql/ClusterBlocks.h

@@ -338,7 +338,7 @@ namespace triagens {
         std::vector<bool> _doneForClient;
 
 ////////////////////////////////////////////////////////////////////////////////
-/// @brief _ignoreInitCursor: should we really initialiseCursor? 
+/// @brief _ignoreInitCursor: should we really initializeCursor? 
 ////////////////////////////////////////////////////////////////////////////////
 
         bool _ignoreInitCursor;

arangod/Cluster/v8-cluster.cpp

@@ -1396,7 +1396,7 @@ static void JS_DisableDipatcherKickstarterServerState (const v8::FunctionCallbac
 /// @brief return whether the cluster is initialized
 ////////////////////////////////////////////////////////////////////////////////
 
-static void JS_InitialisedServerState (const v8::FunctionCallbackInfo<v8::Value>& args) {
+static void JS_InitializedServerState (const v8::FunctionCallbackInfo<v8::Value>& args) {
   TRI_V8_TRY_CATCH_BEGIN(isolate);
   v8::HandleScope scope(isolate);
 
@@ -2195,7 +2195,7 @@ void TRI_InitV8Cluster (v8::Isolate* isolate, v8::Handle<v8::Context> context) {
   TRI_AddMethodVocbase(isolate, rt, TRI_V8_ASCII_STRING("coordinatorConfig"), JS_CoordinatorConfigServerState);
   TRI_AddMethodVocbase(isolate, rt, TRI_V8_ASCII_STRING("disableDispatcherFrontend"), JS_DisableDipatcherFrontendServerState);
   TRI_AddMethodVocbase(isolate, rt, TRI_V8_ASCII_STRING("disableDispatcherKickstarter"), JS_DisableDipatcherKickstarterServerState);
-  TRI_AddMethodVocbase(isolate, rt, TRI_V8_ASCII_STRING("initialized"), JS_InitialisedServerState);
+  TRI_AddMethodVocbase(isolate, rt, TRI_V8_ASCII_STRING("initialized"), JS_InitializedServerState);
   TRI_AddMethodVocbase(isolate, rt, TRI_V8_ASCII_STRING("isCoordinator"), JS_IsCoordinatorServerState);
   TRI_AddMethodVocbase(isolate, rt, TRI_V8_ASCII_STRING("role"), JS_RoleServerState);
   TRI_AddMethodVocbase(isolate, rt, TRI_V8_ASCII_STRING("setLocalInfo"), JS_SetLocalInfoServerState, true);

arangod/FulltextIndex/fulltext-index.cpp

@@ -383,7 +383,7 @@ static uint32_t NodeNumAllocated (const node_t* const node) {
 /// @brief initialize a sub-node list with length information
 ////////////////////////////////////////////////////////////////////////////////
 
-static void InitialiseSubNodeList (void* data,
+static void InitializeSubNodeList (void* data,
                                    const uint32_t numAllocated,
                                    const uint32_t numFollowers) {
   uint8_t* head = (uint8_t*) data;
@@ -501,7 +501,7 @@ static bool ExtendSubNodeList (index_t* const idx,
     }
 
     // initialize the chunk of memory we just got
-    InitialiseSubNodeList(node->_followers, nextAllocated, numFollowers);
+    InitializeSubNodeList(node->_followers, nextAllocated, numFollowers);
 #if TRI_FULLTEXT_DEBUG
     idx->_memoryFollowers += nextSize;
 #endif
@@ -521,7 +521,7 @@ static bool ExtendSubNodeList (index_t* const idx,
     }
 
     // initialize the chunk of memory we just got
-    InitialiseSubNodeList(followers, nextAllocated, numFollowers);
+    InitializeSubNodeList(followers, nextAllocated, numFollowers);
 #if TRI_FULLTEXT_DEBUG
     idx->_memoryFollowers += nextSize;
     idx->_memoryFollowers -= oldSize;

arangod/Indexes/SkiplistIndex.cpp

@@ -812,7 +812,7 @@ SkiplistIterator* SkiplistIndex::lookup (TRI_index_operator_t* slOperator,
 
   results->initCursor();
 
-  // Finally initialise _cursor if the result is not empty:
+  // Finally initialize _cursor if the result is not empty:
   return results.release();
 }
 

arangod/RestServer/ArangoServer.cpp

@@ -58,7 +58,7 @@
 #include "Dispatcher/Dispatcher.h"
 #include "HttpServer/ApplicationEndpointServer.h"
 #include "HttpServer/AsyncJobManager.h"
-#include "Rest/InitialiseRest.h"
+#include "Rest/InitializeRest.h"
 #include "Rest/OperationMode.h"
 #include "Rest/Version.h"
 #include "RestHandler/RestAdminLogHandler.h"
@@ -433,7 +433,7 @@ void ArangoServer::buildApplicationServer () {
   _applicationServer->setUserConfigFile(".arango" + string(1, TRI_DIR_SEPARATOR_CHAR) + string(conf));
 
   // initialize the server's write ahead log
-  wal::LogfileManager::initialise(&_databasePath, _server);
+  wal::LogfileManager::initialize(&_databasePath, _server);
 
   // and add the feature to the application server
   _applicationServer->addFeature(wal::LogfileManager::instance());

arangod/RestServer/WindowsServiceUtils.cpp

@@ -33,7 +33,7 @@
 #include "Basics/messages.h"
 #include "Basics/logging.h"
 #include "Basics/tri-strings.h"
-#include "Rest/InitialiseRest.h"
+#include "Rest/InitializeRest.h"
 #include "Basics/files.h"
 #include "RestServer/ArangoServer.h"
 
@@ -548,21 +548,21 @@ void TRI_GlobalEntryFunction () {
   // If you familiar with Valgrind ... then this is not like that, however
   // you do get some similar functionality.
 
-  // res = initialiseWindows(TRI_WIN_INITIAL_SET_DEBUG_FLAG, 0);
+  // res = initializeWindows(TRI_WIN_INITIAL_SET_DEBUG_FLAG, 0);
 
-  res = initialiseWindows(TRI_WIN_INITIAL_SET_INVALID_HANLE_HANDLER, 0);
+  res = initializeWindows(TRI_WIN_INITIAL_SET_INVALID_HANLE_HANDLER, 0);
 
   if (res != 0) {
     _exit(EXIT_FAILURE);
   }
 
-  res = initialiseWindows(TRI_WIN_INITIAL_SET_MAX_STD_IO,(const char*)(&maxOpenFiles));
+  res = initializeWindows(TRI_WIN_INITIAL_SET_MAX_STD_IO,(const char*)(&maxOpenFiles));
 
   if (res != 0) {
     _exit(EXIT_FAILURE);
   }
 
-  res = initialiseWindows(TRI_WIN_INITIAL_WSASTARTUP_FUNCTION_CALL, 0);
+  res = initializeWindows(TRI_WIN_INITIAL_WSASTARTUP_FUNCTION_CALL, 0);
 
   if (res != 0) {
     _exit(EXIT_FAILURE);

arangod/RestServer/arangod.cpp

@@ -33,7 +33,7 @@
 #include "Basics/files.h"
 #include "Basics/logging.h"
 #include "Basics/messages.h"
-#include "Rest/InitialiseRest.h"
+#include "Rest/InitializeRest.h"
 #include "RestServer/ArangoServer.h"
 #include "Statistics/statistics.h"
 #include <signal.h>
@@ -108,9 +108,9 @@ int main (int argc, char* argv[]) {
 
   // initialize sub-systems
   TRI_GlobalEntryFunction();
-  TRIAGENS_REST_INITIALISE(argc, argv);
+  TRIAGENS_REST_INITIALIZE(argc, argv);
       
-  TRI_InitialiseStatistics();
+  TRI_InitializeStatistics();
 
   if (startAsService) {
     TRI_StartService(argc, argv);

arangod/Scheduler/Scheduler.cpp

@@ -78,7 +78,7 @@ Scheduler::Scheduler (size_t nrThreads)
   }
 
   // setup signal handlers
-  initialiseSignalHandlers();
+  initializeSignalHandlers();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -530,7 +530,7 @@ int Scheduler::checkInsertTask (Task const* task) {
 /// @brief initializes the signal handlers for the scheduler
 ////////////////////////////////////////////////////////////////////////////////
 
-void Scheduler::initialiseSignalHandlers () {
+void Scheduler::initializeSignalHandlers () {
 
 #ifdef _WIN32
   // Windows does not support POSIX signal handling

arangod/Scheduler/Scheduler.h

@@ -371,7 +371,7 @@ namespace triagens {
 /// @brief inialises the signal handlers for the scheduler
 ////////////////////////////////////////////////////////////////////////////////
 
-        static void initialiseSignalHandlers ();
+        static void initializeSignalHandlers ();
 
 // -----------------------------------------------------------------------------
 // --SECTION--                                                 private variables

arangod/Statistics/statistics.cpp

@@ -498,7 +498,7 @@ double TRI_StatisticsTime () {
 /// @brief module init function
 ////////////////////////////////////////////////////////////////////////////////
 
-void TRI_InitialiseStatistics () {
+void TRI_InitializeStatistics () {
   TRI_ServerStatistics._startTime = TRI_microtime();
 
   // .............................................................................

arangod/Statistics/statistics.h

@@ -326,7 +326,7 @@ double TRI_StatisticsTime (void);
 /// @brief module init function
 ////////////////////////////////////////////////////////////////////////////////
 
-void TRI_InitialiseStatistics (void);
+void TRI_InitializeStatistics (void);
 
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief shut down statistics

arangod/V8Server/ApplicationV8.cpp

@@ -1176,7 +1176,7 @@ bool ApplicationV8::prepareV8Instance (size_t i, bool useActions) {
 
   vector<string> files;
 
-  files.push_back("server/initialise.js");
+  files.push_back("server/initialize.js");
 
   v8::Isolate* isolate = v8::Isolate::New();
   

arangod/Wal/LogfileManager.cpp

@@ -222,7 +222,7 @@ LogfileManager* LogfileManager::instance () {
 /// @brief initialize the logfile manager instance
 ////////////////////////////////////////////////////////////////////////////////
 
-void LogfileManager::initialise (std::string* path,
+void LogfileManager::initialize (std::string* path,
                                  TRI_server_t* server) {
   TRI_ASSERT(Instance == nullptr);
 

arangod/Wal/LogfileManager.h

@@ -128,7 +128,7 @@ namespace triagens {
 /// @brief initialize the logfile manager instance
 ////////////////////////////////////////////////////////////////////////////////
 
-        static void initialise (std::string*,
+        static void initialize (std::string*,
                                 TRI_server_t*);
 
 // -----------------------------------------------------------------------------

arangod/Wal/Slots.cpp

@@ -190,7 +190,7 @@ SlotInfo Slots::nextUnused (uint32_t size) {
             // try again in next iteration
           }
           else if (status == Logfile::StatusType::EMPTY) {
-            // inititialise the empty logfile by writing a header marker
+            // initialize the empty logfile by writing a header marker
             int res = writeHeader(slot);
 
             if (res != TRI_ERROR_NO_ERROR) {
@@ -309,7 +309,7 @@ SlotInfo Slots::nextUnused (uint32_t size,
             // try again in next iteration
           }
           else if (status == Logfile::StatusType::EMPTY) {
-            // inititialise the empty logfile by writing a header marker
+            // initialize the empty logfile by writing a header marker
             int res = writeHeader(slot);
 
             if (res != TRI_ERROR_NO_ERROR) {
@@ -633,7 +633,7 @@ int Slots::closeLogfile (Slot::TickType& lastCommittedTick,
           // try again in next iteration
         }
         else if (status == Logfile::StatusType::EMPTY) {
-          // inititialise the empty logfile by writing a header marker
+          // initialize the empty logfile by writing a header marker
           int res = writeHeader(slot);
 
           if (res != TRI_ERROR_NO_ERROR) {

arangosh/Benchmark/arangob.cpp

@@ -44,7 +44,7 @@
 #include "Basics/terminal-utils.h"
 #include "Rest/Endpoint.h"
 #include "Rest/HttpRequest.h"
-#include "Rest/InitialiseRest.h"
+#include "Rest/InitializeRest.h"
 #include "SimpleHttpClient/SimpleHttpClient.h"
 #include "SimpleHttpClient/SimpleHttpResult.h"
 #include "Benchmark/BenchmarkCounter.h"
@@ -241,19 +241,19 @@ void arangobEntryFunction () {
   // If you familiar with valgrind ... then this is not like that, however
   // you do get some similar functionality.
   // ...........................................................................
-  //res = initialiseWindows(TRI_WIN_INITIAL_SET_DEBUG_FLAG, 0);
+  //res = initializeWindows(TRI_WIN_INITIAL_SET_DEBUG_FLAG, 0);
 
-  res = initialiseWindows(TRI_WIN_INITIAL_SET_INVALID_HANLE_HANDLER, 0);
+  res = initializeWindows(TRI_WIN_INITIAL_SET_INVALID_HANLE_HANDLER, 0);
   if (res != 0) {
     _exit(1);
   }
 
-  res = initialiseWindows(TRI_WIN_INITIAL_SET_MAX_STD_IO,(const char*)(&maxOpenFiles));
+  res = initializeWindows(TRI_WIN_INITIAL_SET_MAX_STD_IO,(const char*)(&maxOpenFiles));
   if (res != 0) {
     _exit(1);
   }
 
-  res = initialiseWindows(TRI_WIN_INITIAL_WSASTARTUP_FUNCTION_CALL, 0);
+  res = initializeWindows(TRI_WIN_INITIAL_WSASTARTUP_FUNCTION_CALL, 0);
   if (res != 0) {
     _exit(1);
   }
@@ -295,10 +295,10 @@ int main (int argc, char* argv[]) {
 
   arangobEntryFunction();
 
-  TRIAGENS_C_INITIALISE(argc, argv);
-  TRIAGENS_REST_INITIALISE(argc, argv);
+  TRIAGENS_C_INITIALIZE(argc, argv);
+  TRIAGENS_REST_INITIALIZE(argc, argv);
 
-  TRI_InitialiseLogging(false);
+  TRI_InitializeLogging(false);
 
   BaseClient.setEndpointString(Endpoint::getDefaultEndpoint());
 

arangosh/V8Client/arangodump.cpp

@@ -42,7 +42,7 @@
 #include "Basics/tri-strings.h"
 #include "Basics/terminal-utils.h"
 #include "Rest/Endpoint.h"
-#include "Rest/InitialiseRest.h"
+#include "Rest/InitializeRest.h"
 #include "Rest/HttpResponse.h"
 #include "Rest/SslInterface.h"
 #include "SimpleHttpClient/GeneralClientConnection.h"
@@ -231,19 +231,19 @@ void arangodumpEntryFunction () {
   // If you familiar with valgrind ... then this is not like that, however
   // you do get some similar functionality.
   // ...........................................................................
-  //res = initialiseWindows(TRI_WIN_INITIAL_SET_DEBUG_FLAG, 0);
+  //res = initializeWindows(TRI_WIN_INITIAL_SET_DEBUG_FLAG, 0);
 
-  res = initialiseWindows(TRI_WIN_INITIAL_SET_INVALID_HANLE_HANDLER, 0);
+  res = initializeWindows(TRI_WIN_INITIAL_SET_INVALID_HANLE_HANDLER, 0);
   if (res != 0) {
     _exit(1);
   }
 
-  res = initialiseWindows(TRI_WIN_INITIAL_SET_MAX_STD_IO,(const char*)(&maxOpenFiles));
+  res = initializeWindows(TRI_WIN_INITIAL_SET_MAX_STD_IO,(const char*)(&maxOpenFiles));
   if (res != 0) {
     _exit(1);
   }
 
-  res = initialiseWindows(TRI_WIN_INITIAL_WSASTARTUP_FUNCTION_CALL, 0);
+  res = initializeWindows(TRI_WIN_INITIAL_WSASTARTUP_FUNCTION_CALL, 0);
   if (res != 0) {
     _exit(1);
   }
@@ -1182,10 +1182,10 @@ int main (int argc, char* argv[]) {
 
   arangodumpEntryFunction();
 
-  TRIAGENS_C_INITIALISE(argc, argv);
-  TRIAGENS_REST_INITIALISE(argc, argv);
+  TRIAGENS_C_INITIALIZE(argc, argv);
+  TRIAGENS_REST_INITIALIZE(argc, argv);
 
-  TRI_InitialiseLogging(false);
+  TRI_InitializeLogging(false);
 
   // .............................................................................
   // set defaults

arangosh/V8Client/arangoimp.cpp

@@ -42,7 +42,7 @@
 #include "Basics/terminal-utils.h"
 #include "ImportHelper.h"
 #include "Rest/Endpoint.h"
-#include "Rest/InitialiseRest.h"
+#include "Rest/InitializeRest.h"
 #include "Rest/HttpResponse.h"
 #include "SimpleHttpClient/GeneralClientConnection.h"
 #include "SimpleHttpClient/SimpleHttpClient.h"
@@ -201,19 +201,19 @@ void arangoimpEntryFunction() {
   // If you familiar with valgrind ... then this is not like that, however
   // you do get some similar functionality.
   // ...........................................................................
-  //res = initialiseWindows(TRI_WIN_INITIAL_SET_DEBUG_FLAG, 0);
+  //res = initializeWindows(TRI_WIN_INITIAL_SET_DEBUG_FLAG, 0);
 
-  res = initialiseWindows(TRI_WIN_INITIAL_SET_INVALID_HANLE_HANDLER, 0);
+  res = initializeWindows(TRI_WIN_INITIAL_SET_INVALID_HANLE_HANDLER, 0);
   if (res != 0) {
     _exit(1);
   }
 
-  res = initialiseWindows(TRI_WIN_INITIAL_SET_MAX_STD_IO,(const char*)(&maxOpenFiles));
+  res = initializeWindows(TRI_WIN_INITIAL_SET_MAX_STD_IO,(const char*)(&maxOpenFiles));
   if (res != 0) {
     _exit(1);
   }
 
-  res = initialiseWindows(TRI_WIN_INITIAL_WSASTARTUP_FUNCTION_CALL, 0);
+  res = initializeWindows(TRI_WIN_INITIAL_WSASTARTUP_FUNCTION_CALL, 0);
   if (res != 0) {
     _exit(1);
   }
@@ -274,10 +274,10 @@ int main (int argc, char* argv[]) {
 
   arangoimpEntryFunction();
 
-  TRIAGENS_C_INITIALISE(argc, argv);
-  TRIAGENS_REST_INITIALISE(argc, argv);
+  TRIAGENS_C_INITIALIZE(argc, argv);
+  TRIAGENS_REST_INITIALIZE(argc, argv);
 
-  TRI_InitialiseLogging(false);
+  TRI_InitializeLogging(false);
 
   BaseClient.setEndpointString(Endpoint::getDefaultEndpoint());
 

arangosh/V8Client/arangorestore.cpp

@@ -42,7 +42,7 @@
 #include "Basics/terminal-utils.h"
 #include "Basics/tri-strings.h"
 #include "Rest/Endpoint.h"
-#include "Rest/InitialiseRest.h"
+#include "Rest/InitializeRest.h"
 #include "Rest/HttpResponse.h"
 #include "Rest/SslInterface.h"
 #include "SimpleHttpClient/GeneralClientConnection.h"
@@ -230,19 +230,19 @@ void arangorestoreEntryFunction () {
   // If you familiar with valgrind ... then this is not like that, however
   // you do get some similar functionality.
   // ...........................................................................
-  //res = initialiseWindows(TRI_WIN_INITIAL_SET_DEBUG_FLAG, 0);
+  //res = initializeWindows(TRI_WIN_INITIAL_SET_DEBUG_FLAG, 0);
 
-  res = initialiseWindows(TRI_WIN_INITIAL_SET_INVALID_HANLE_HANDLER, 0);
+  res = initializeWindows(TRI_WIN_INITIAL_SET_INVALID_HANLE_HANDLER, 0);
   if (res != 0) {
     _exit(1);
   }
 
-  res = initialiseWindows(TRI_WIN_INITIAL_SET_MAX_STD_IO,(const char*)(&maxOpenFiles));
+  res = initializeWindows(TRI_WIN_INITIAL_SET_MAX_STD_IO,(const char*)(&maxOpenFiles));
   if (res != 0) {
     _exit(1);
   }
 
-  res = initialiseWindows(TRI_WIN_INITIAL_WSASTARTUP_FUNCTION_CALL, 0);
+  res = initializeWindows(TRI_WIN_INITIAL_WSASTARTUP_FUNCTION_CALL, 0);
   if (res != 0) {
     _exit(1);
   }
@@ -880,10 +880,10 @@ int main (int argc, char* argv[]) {
 
   arangorestoreEntryFunction();
 
-  TRIAGENS_C_INITIALISE(argc, argv);
-  TRIAGENS_REST_INITIALISE(argc, argv);
+  TRIAGENS_C_INITIALIZE(argc, argv);
+  TRIAGENS_REST_INITIALIZE(argc, argv);
 
-  TRI_InitialiseLogging(false);
+  TRI_InitializeLogging(false);
 
   // .............................................................................
   // set defaults

arangosh/V8Client/arangosh.cpp

@@ -47,7 +47,7 @@
 #include "Basics/terminal-utils.h"
 #include "Basics/tri-strings.h"
 #include "Rest/Endpoint.h"
-#include "Rest/InitialiseRest.h"
+#include "Rest/InitializeRest.h"
 #include "Rest/HttpResponse.h"
 #include "Rest/Version.h"
 #include "SimpleHttpClient/SimpleHttpClient.h"
@@ -1902,21 +1902,21 @@ void arangoshEntryFunction() {
   // If you familiar with valgrind ... then this is not like that, however
   // you do get some similar functionality.
   // ...........................................................................
-  //res = initialiseWindows(TRI_WIN_INITIAL_SET_DEBUG_FLAG, 0);
+  //res = initializeWindows(TRI_WIN_INITIAL_SET_DEBUG_FLAG, 0);
 
-  res = initialiseWindows(TRI_WIN_INITIAL_SET_INVALID_HANLE_HANDLER, 0);
+  res = initializeWindows(TRI_WIN_INITIAL_SET_INVALID_HANLE_HANDLER, 0);
 
   if (res != 0) {
     _exit(1);
   }
 
-  res = initialiseWindows(TRI_WIN_INITIAL_SET_MAX_STD_IO,(const char*)(&maxOpenFiles));
+  res = initializeWindows(TRI_WIN_INITIAL_SET_MAX_STD_IO,(const char*)(&maxOpenFiles));
 
   if (res != 0) {
     _exit(1);
   }
 
-  res = initialiseWindows(TRI_WIN_INITIAL_WSASTARTUP_FUNCTION_CALL, 0);
+  res = initializeWindows(TRI_WIN_INITIAL_WSASTARTUP_FUNCTION_CALL, 0);
 
   if (res != 0) {
     _exit(1);
@@ -2308,10 +2308,10 @@ int main (int argc, char* args[]) {
 #endif
   arangoshEntryFunction();
 
-  TRIAGENS_C_INITIALISE(argc, args);
-  TRIAGENS_REST_INITIALISE(argc, args);
+  TRIAGENS_C_INITIALIZE(argc, args);
+  TRIAGENS_REST_INITIALIZE(argc, args);
 
-  TRI_InitialiseLogging(false);
+  TRI_InitializeLogging(false);
         
   {
     std::ostringstream foxxManagerHelp;

config/generateErrorfile.py

@@ -63,7 +63,7 @@ def genCFile(errors, filename):
          + "#include \"Basics/Common.h\"\n"\
          + "#include \"" + headerfile + "\"\n"\
          + "\n"\
-         + "void TRI_InitialiseErrorMessages () {\n"
+         + "void TRI_InitializeErrorMessages () {\n"
 
   # print individual errors
   for e in errors:
@@ -109,7 +109,7 @@ def genCHeaderFile(errors):
            + "/// @brief register all errors for ArangoDB\n"\
            + "////////////////////////////////////////////////////////////////////////////////\n"\
            + "\n"\
-           + "void TRI_InitialiseErrorMessages ();\n"\
+           + "void TRI_InitializeErrorMessages ();\n"\
            + "\n"
  
   # print individual errors

config/generateMimetypes.py

@@ -82,7 +82,7 @@ def genCHeaderFile(types):
            + "/// @brief initialize mimetypes\n"\
            + "////////////////////////////////////////////////////////////////////////////////\n"\
            + "\n"\
-           + "void TRI_InitialiseEntriesMimetypes ();\n"\
+           + "void TRI_InitializeEntriesMimetypes ();\n"\
            + "\n"\
            + "#endif\n"\
            + "\n"
@@ -103,7 +103,7 @@ def genCFile(types, filename):
          + "/// @brief initialize mimetypes\n"\
          + "////////////////////////////////////////////////////////////////////////////////\n"\
          + "\n"\
-         + "void TRI_InitialiseEntriesMimetypes () {\n"
+         + "void TRI_InitializeEntriesMimetypes () {\n"
 
   # print individual types
   for t in types:

js/apps/system/_admin/aardvark/APP/clusterFrontend/build/cluster.js

@@ -16591,7 +16591,7 @@ window.StatisticsCollection = Backbone.Collection.extend({
 
     initialize: function () {
       this.dygraphConfig = this.options.dygraphConfig;
-      this.d3NotInitialised = true;
+      this.d3NotInitialized = true;
       this.events["click .dashboard-sub-bar-menu-sign"] = this.showDetail.bind(this);
       this.events["mousedown .dygraph-rangesel-zoomhandle"] = this.stopUpdating.bind(this);
       this.events["mouseup .dygraph-rangesel-zoomhandle"] = this.startUpdating.bind(this);
@@ -17002,9 +17002,9 @@ window.StatisticsCollection = Backbone.Collection.extend({
           "bytesSentDistributionPercent", "bytesReceivedDistributionPercent"]
       };
 
-      if (this.d3NotInitialised) {
+      if (this.d3NotInitialized) {
           update = false;
-          this.d3NotInitialised = false;
+          this.d3NotInitialized = false;
       }
 
       _.each(Object.keys(barCharts), function (k) {

js/apps/system/_admin/aardvark/APP/frontend/js/views/dashboardView.js

@@ -163,7 +163,7 @@
 
     initialize: function () {
       this.dygraphConfig = this.options.dygraphConfig;
-      this.d3NotInitialised = true;
+      this.d3NotInitialized = true;
       this.events["click .dashboard-sub-bar-menu-sign"] = this.showDetail.bind(this);
       this.events["mousedown .dygraph-rangesel-zoomhandle"] = this.stopUpdating.bind(this);
       this.events["mouseup .dygraph-rangesel-zoomhandle"] = this.startUpdating.bind(this);
@@ -574,9 +574,9 @@
           "bytesSentDistributionPercent", "bytesReceivedDistributionPercent"]
       };
 
-      if (this.d3NotInitialised) {
+      if (this.d3NotInitialized) {
           update = false;
-          this.d3NotInitialised = false;
+          this.d3NotInitialized = false;
       }
 
       _.each(Object.keys(barCharts), function (k) {

js/apps/system/_admin/aardvark/APP/test/specs/views/dashboardViewSpec.js

@@ -780,7 +780,7 @@
         }
 
       ]};
-      view.d3NotInitialised = false;
+      view.d3NotInitialized = false;
       view.prepareD3Charts(true);
 
       expect(view.getCurrentSize).toHaveBeenCalledWith(

js/server/modules/org/arangodb/cluster.js

@@ -974,7 +974,7 @@ var role = function () {
 ////////////////////////////////////////////////////////////////////////////////
 
 var status = function () {
-  if (! isCluster() || ! global.ArangoServerState.initialised()) {
+  if (! isCluster() || ! global.ArangoServerState.initialized()) {
     return undefined;
   }
 
@@ -998,7 +998,7 @@ var isCoordinatorRequest = function (req) {
 ////////////////////////////////////////////////////////////////////////////////
 
 var handlePlanChange = function () {
-  if (! isCluster() || isCoordinator() || ! global.ArangoServerState.initialised()) {
+  if (! isCluster() || isCoordinator() || ! global.ArangoServerState.initialized()) {
     return;
   }
 

lib/Basics/AssociativeArray.h

@@ -114,7 +114,7 @@ namespace triagens {
 #else
             _table(0) {
 #endif
-          initialise(size);
+          initialize(size);
         }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -138,7 +138,7 @@ namespace triagens {
 #else
             _table(0) {
 #endif
-          initialise(size);
+          initialize(size);
         }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -247,7 +247,7 @@ namespace triagens {
 
         void clear () {
           delete[] _table;
-          initialise(_nrAlloc);
+          initialize(_nrAlloc);
         }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -260,7 +260,7 @@ namespace triagens {
           }
 
           delete[] _table;
-          initialise(_nrAlloc);
+          initialize(_nrAlloc);
         }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -566,7 +566,7 @@ namespace triagens {
 /// @brief initialize the internal table
 ////////////////////////////////////////////////////////////////////////////////
 
-        void initialise (uint64_t size) {
+        void initialize (uint64_t size) {
           _table = new ELEMENT[static_cast<unsigned int>(size)];
 
           for (uint64_t i = 0; i < size; i++) {

lib/Basics/InitializeBasics.cpp

@@ -27,7 +27,7 @@
 /// @author Copyright 2009-2013, triAGENS GmbH, Cologne, Germany
 ////////////////////////////////////////////////////////////////////////////////
 
-#include "Basics/InitialiseBasics.h"
+#include "Basics/InitializeBasics.h"
 
 #include "Basics/init.h"
 #include "Basics/error.h"
@@ -38,8 +38,8 @@
 
 namespace triagens {
   namespace basics {
-    void InitialiseBasics (int argv, char* argc[]) {
-      TRIAGENS_C_INITIALISE(argv, argc);
+    void InitializeBasics (int argv, char* argc[]) {
+      TRIAGENS_C_INITIALIZE(argv, argc);
 
       // use the rng so the linker does not remove it from the executable
       // we might need it later because .so files might refer to the symbols

lib/Basics/InitializeBasics.h

@@ -27,8 +27,8 @@
 /// @author Copyright 2009-2013, triAGENS GmbH, Cologne, Germany
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef ARANGODB_BASICS_INITIALISE_BASICS_H
-#define ARANGODB_BASICS_INITIALISE_BASICS_H 1
+#ifndef ARANGODB_BASICS_INITIALIZE_BASICS_H
+#define ARANGODB_BASICS_INITIALIZE_BASICS_H 1
 
 #include "Basics/Common.h"
 
@@ -44,7 +44,7 @@ namespace triagens {
 /// @brief initialize function
 ////////////////////////////////////////////////////////////////////////////////
 
-    extern void InitialiseBasics (int argv, char* argc[]);
+    extern void InitializeBasics (int argv, char* argc[]);
 
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief shutdown function
@@ -58,9 +58,9 @@ namespace triagens {
 /// @brief initialize
 ////////////////////////////////////////////////////////////////////////////////
 
-#define TRIAGENS_BASICS_INITIALISE(a,b)                 \
+#define TRIAGENS_BASICS_INITIALIZE(a,b)                 \
   do {                                                  \
-    triagens::basics::InitialiseBasics((a), (b));       \
+    triagens::basics::InitializeBasics((a), (b));       \
   } while (0)
 
 ////////////////////////////////////////////////////////////////////////////////

lib/Basics/SkipList.h

@@ -312,7 +312,7 @@ namespace triagens {
             for (lev = _start->_height; lev < newNode->_height; lev++) {
               pos[lev] = _start;
             }
-            // Note that _start is already initialised with nullptr to the top!
+            // Note that _start is already initialized with nullptr to the top!
             _start->_height = newNode->_height;
           }
 

lib/Basics/debugging.cpp

@@ -288,7 +288,7 @@ void TRI_ClearFailurePointsDebugging () {
 /// @brief initialize the debugging
 ////////////////////////////////////////////////////////////////////////////////
 
-void TRI_InitialiseDebugging () {
+void TRI_InitializeDebugging () {
   FailurePoints = nullptr;
   TRI_InitReadWriteLock(&FailurePointsLock);
 }

lib/Basics/debugging.h

@@ -147,7 +147,7 @@ void TRI_PrintBacktrace ();
 /// @brief initialize the debugging
 ////////////////////////////////////////////////////////////////////////////////
 
-void TRI_InitialiseDebugging (void);
+void TRI_InitializeDebugging (void);
 
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief shutdown the debugging

lib/Basics/error.cpp

@@ -55,7 +55,7 @@ tri_error_t;
 /// @brief already initialized
 ////////////////////////////////////////////////////////////////////////////////
 
-static bool Initialised = false;
+static bool Initialized = false;
 
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief holds the last error
@@ -307,8 +307,8 @@ char const* TRI_errno_string (int error) {
 /// @brief initializes the error messages
 ////////////////////////////////////////////////////////////////////////////////
 
-void TRI_InitialiseError () {
-  if (Initialised) {
+void TRI_InitializeError () {
+  if (Initialized) {
     return;
   }
 
@@ -319,7 +319,7 @@ void TRI_InitialiseError () {
                              EqualError,
                              0);
 
-  TRI_InitialiseErrorMessages();
+  TRI_InitializeErrorMessages();
 
 #if defined(TRI_GCC_THREAD_LOCAL_STORAGE) || defined(TRI_WIN32_THREAD_LOCAL_STORAGE)
   ErrorNumber._number = 0;
@@ -330,7 +330,7 @@ void TRI_InitialiseError () {
 #error no TLS
 #endif
 
-  Initialised = true;
+  Initialized = true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -340,7 +340,7 @@ void TRI_InitialiseError () {
 void TRI_ShutdownError () {
   size_t i;
 
-  if (! Initialised) {
+  if (! Initialized) {
     return;
   }
 
@@ -355,7 +355,7 @@ void TRI_ShutdownError () {
 
   TRI_DestroyAssociativePointer(&ErrorMessages);
 
-  Initialised = false;
+  Initialized = false;
 }
 
 // -----------------------------------------------------------------------------

lib/Basics/error.h

@@ -94,7 +94,7 @@ char const* TRI_errno_string (int);
 /// @brief initializes the error messages
 ////////////////////////////////////////////////////////////////////////////////
 
-void TRI_InitialiseError (void);
+void TRI_InitializeError (void);
 
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief shuts down the error messages

lib/Basics/files.cpp

@@ -74,7 +74,7 @@ using namespace std;
 /// @brief already initialized
 ////////////////////////////////////////////////////////////////////////////////
 
-static bool Initialised = false;
+static bool Initialized = false;
 
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief user-defined temporary path
@@ -209,8 +209,8 @@ static void RemoveAllLockedFiles (void) {
 /// @brief initializes some structures which are needed by the file functions
 ////////////////////////////////////////////////////////////////////////////////
 
-static void InitialiseLockFiles (void) {
-  if (Initialised) {
+static void InitializeLockFiles (void) {
+  if (Initialized) {
     return;
   }
 
@@ -225,7 +225,7 @@ static void InitialiseLockFiles (void) {
   TRI_InitReadWriteLock(&FileNamesLock);
 
   atexit(&RemoveAllLockedFiles);
-  Initialised = true;
+  Initialized = true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1154,7 +1154,7 @@ int TRI_CreateLockFile (char const* filename) {
   char* fn;
   int res;
 
-  InitialiseLockFiles();
+  InitializeLockFiles();
 
   if (0 <= LookupElementVectorString(&FileNames, filename)) {
     return TRI_ERROR_NO_ERROR;
@@ -1225,7 +1225,7 @@ int TRI_CreateLockFile (char const* filename) {
   int rv;
   int res;
 
-  InitialiseLockFiles();
+  InitializeLockFiles();
 
   if (0 <= LookupElementVectorString(&FileNames, filename)) {
     return TRI_ERROR_NO_ERROR;
@@ -1396,7 +1396,7 @@ int TRI_DestroyLockFile (char const* filename) {
   HANDLE fd;
   ssize_t n;
 
-  InitialiseLockFiles();
+  InitializeLockFiles();
   n = LookupElementVectorString(&FileNames, filename);
 
   if (n < 0) {
@@ -1425,7 +1425,7 @@ int TRI_DestroyLockFile (char const* filename) {
   int res;
   ssize_t n;
 
-  InitialiseLockFiles();
+  InitializeLockFiles();
   n = LookupElementVectorString(&FileNames, filename);
 
   if (n < 0) {
@@ -2449,7 +2449,7 @@ char* TRI_LocateConfigDirectory () {
 /// TODO: initialize logging here?
 ////////////////////////////////////////////////////////////////////////////////
 
-void TRI_InitialiseFiles (void) {
+void TRI_InitializeFiles (void) {
   // clear user-defined temp path
   TempPath = nullptr;
 }

lib/Basics/files.h

@@ -363,7 +363,7 @@ char* TRI_LocateConfigDirectory (void);
 /// @brief initialize the files subsystem
 ////////////////////////////////////////////////////////////////////////////////
 
-void TRI_InitialiseFiles (void);
+void TRI_InitializeFiles (void);
 
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief shutdown the files subsystem

lib/Basics/hashes.cpp

@@ -536,7 +536,7 @@ uint32_t TRI_Crc32HashString (char const* data) {
 /// @brief already initialized
 ////////////////////////////////////////////////////////////////////////////////
 
-static bool Initialised = false;
+static bool Initialized = false;
 
 // -----------------------------------------------------------------------------
 // --SECTION--                                                  public functions
@@ -546,14 +546,14 @@ static bool Initialised = false;
 /// @brief initializes the hashes components
 ////////////////////////////////////////////////////////////////////////////////
 
-void TRI_InitialiseHashes () {
-  if (Initialised) {
+void TRI_InitializeHashes () {
+  if (Initialized) {
     return;
   }
 
   GenerateCrc32Polynomial();
 
-  Initialised = true;
+  Initialized = true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -561,11 +561,11 @@ void TRI_InitialiseHashes () {
 ////////////////////////////////////////////////////////////////////////////////
 
 void TRI_ShutdownHashes () {
-  if (! Initialised) {
+  if (! Initialized) {
     return;
   }
 
-  Initialised = false;
+  Initialized = false;
 }
 
 // -----------------------------------------------------------------------------

lib/Basics/hashes.h

@@ -114,7 +114,7 @@ uint32_t TRI_Crc32HashString (char const*);
 /// @brief initializes the hashes components
 ////////////////////////////////////////////////////////////////////////////////
 
-void TRI_InitialiseHashes ();
+void TRI_InitializeHashes ();
 
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief shut downs the hashes components

lib/Basics/init.cpp

@@ -43,16 +43,16 @@
 /// @brief initialize function
 ////////////////////////////////////////////////////////////////////////////////
 
-void TRI_InitialiseC (int argc, char* argv[]) {
-  TRI_InitialiseMemory();
-  TRI_InitialiseDebugging();
-  TRI_InitialiseError();
-  TRI_InitialiseFiles();
-  TRI_InitialiseMimetypes();
-  TRI_InitialiseLogging(false);
-  TRI_InitialiseHashes();
-  TRI_InitialiseRandom();
-  TRI_InitialiseProcess(argc, argv);
+void TRI_InitializeC (int argc, char* argv[]) {
+  TRI_InitializeMemory();
+  TRI_InitializeDebugging();
+  TRI_InitializeError();
+  TRI_InitializeFiles();
+  TRI_InitializeMimetypes();
+  TRI_InitializeLogging(false);
+  TRI_InitializeHashes();
+  TRI_InitializeRandom();
+  TRI_InitializeProcess(argc, argv);
 }
 
 ////////////////////////////////////////////////////////////////////////////////

lib/Basics/init.h

@@ -40,7 +40,7 @@
 /// @brief initialize function
 ////////////////////////////////////////////////////////////////////////////////
 
-void TRI_InitialiseC (int argc, char* argv[]);
+void TRI_InitializeC (int argc, char* argv[]);
 
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief shutdown function
@@ -52,9 +52,9 @@ void TRI_ShutdownC (void);
 /// @brief initialize
 ////////////////////////////////////////////////////////////////////////////////
 
-#define TRIAGENS_C_INITIALISE(a,b)              \
+#define TRIAGENS_C_INITIALIZE(a,b)              \
   do {                                          \
-    TRI_InitialiseC((a), (b));                  \
+    TRI_InitializeC((a), (b));                  \
   } while (0)
 
 ////////////////////////////////////////////////////////////////////////////////

lib/Basics/logging.cpp

@@ -171,7 +171,7 @@ TRI_log_appender_t::~TRI_log_appender_t () {
 /// @brief already initialized
 ////////////////////////////////////////////////////////////////////////////////
 
-static volatile int Initialised = 0;
+static volatile int Initialized = 0;
 
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief shutdown function already installed
@@ -1815,12 +1815,12 @@ char const* TRI_GetFilenameLogging () {
 /// @brief initializes the logging components
 ////////////////////////////////////////////////////////////////////////////////
 
-void TRI_InitialiseLogging (bool threaded) {
-  if (Initialised > 0) {
+void TRI_InitializeLogging (bool threaded) {
+  if (Initialized > 0) {
     return;
   }
 
-  Initialised = 1;
+  Initialized = 1;
 
   UseFileBasedLogging = false;
   memset(FilesToLog, 0, sizeof(FilesToLog));
@@ -1856,8 +1856,8 @@ void TRI_InitialiseLogging (bool threaded) {
 ////////////////////////////////////////////////////////////////////////////////
 
 bool TRI_ShutdownLogging (bool clearBuffers) {
-  if (Initialised != 1) {
-    if (Initialised == 0) {
+  if (Initialized != 1) {
+    if (Initialized == 0) {
       return ThreadedLogging;
     }
     
@@ -1865,7 +1865,7 @@ bool TRI_ShutdownLogging (bool clearBuffers) {
     return false;
   }
 
-  Initialised = 1;
+  Initialized = 1;
 
   // logging is now inactive (this will terminate the logging thread)
   LoggingActive = 0;
@@ -1915,7 +1915,7 @@ bool TRI_ShutdownLogging (bool clearBuffers) {
     }
   }
 
-  Initialised = 0;
+  Initialized = 0;
 
   return ThreadedLogging;
 }
@@ -1943,7 +1943,7 @@ void TRI_ReopenLogging () {
 ////////////////////////////////////////////////////////////////////////////////
 
 void TRI_FlushLogging () {
-  if (Initialised != 1) {
+  if (Initialized != 1) {
     return;
   }
 

lib/Basics/logging.h

@@ -517,13 +517,13 @@ char const* TRI_GetFilenameLogging (void);
 /// TRI_ShutdownLogging.
 ////////////////////////////////////////////////////////////////////////////////
 
-void TRI_InitialiseLogging (bool threaded);
+void TRI_InitializeLogging (bool threaded);
 
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief shut downs the logging components
 ///
 /// Warning: This function call is not thread safe. Never mix it with
-/// TRI_InitialiseLogging.
+/// TRI_InitializeLogging.
 ////////////////////////////////////////////////////////////////////////////////
 
 bool TRI_ShutdownLogging (bool);

lib/Basics/memory-map-posix.cpp

@@ -83,7 +83,7 @@ int TRI_FlushMMFile (int fileDescriptor,
 ////////////////////////////////////////////////////////////////////////////////
 
 int TRI_MMFile (void* memoryAddress,
-                size_t numOfBytesToInitialise,
+                size_t numOfBytesToInitialize,
                 int memoryProtection,
                 int flags,
                 int fileDescriptor,
@@ -95,7 +95,7 @@ int TRI_MMFile (void* memoryAddress,
 
   *mmHandle = nullptr; // only useful for Windows
 
-  *result = mmap(memoryAddress, numOfBytesToInitialise, memoryProtection, flags, fileDescriptor, offsetRetyped);
+  *result = mmap(memoryAddress, numOfBytesToInitialize, memoryProtection, flags, fileDescriptor, offsetRetyped);
 
   if (*result != MAP_FAILED) {
     return TRI_ERROR_NO_ERROR;

lib/Basics/memory-map-win32.cpp

@@ -101,7 +101,7 @@ int TRI_FlushMMFile (int fileDescriptor,
 ////////////////////////////////////////////////////////////////////////////////
 
 int TRI_MMFile (void* memoryAddress, 
-                size_t numOfBytesToInitialise, 
+                size_t numOfBytesToInitialize, 
                 int memoryProtection,
                 int flags, 
                 int fileDescriptor, 
@@ -118,7 +118,7 @@ int TRI_MMFile (void* memoryAddress,
   // Set the high and low order 32 bits for using a 64 bit integer
   // ...........................................................................
 
-  mmLength.QuadPart = numOfBytesToInitialise;
+  mmLength.QuadPart = numOfBytesToInitialize;
 
   // ...........................................................................
   // Whenever we talk to the memory map functions, we require a file handle
@@ -240,7 +240,7 @@ int TRI_MMFile (void* memoryAddress,
   // ........................................................................
 
   //TODO: fix the viewProtection above *result = MapViewOfFile(*mmHandle, viewProtection, 0, 0, 0);
-  *result = MapViewOfFile(*mmHandle, FILE_MAP_ALL_ACCESS, 0, 0, numOfBytesToInitialise);
+  *result = MapViewOfFile(*mmHandle, FILE_MAP_ALL_ACCESS, 0, 0, numOfBytesToInitialize);
 
   // ........................................................................
   // The map view of file has failed.

lib/Basics/memory-map.h

@@ -76,7 +76,7 @@ int TRI_FlushMMFile (int fileDescriptor,
 ////////////////////////////////////////////////////////////////////////////////
 
 int TRI_MMFile (void* memoryAddress,
-                size_t numOfBytesToInitialise,
+                size_t numOfBytesToInitialize,
                 int memoryProtection,
                 int flags,
                 int fileDescriptor,

lib/Basics/memory.cpp

@@ -110,7 +110,7 @@ static void* CoreReserve;
 /// @brief whether or not the core was initialized
 ////////////////////////////////////////////////////////////////////////////////
 
-static int CoreInitialised = 0;
+static int CoreInitialized = 0;
 
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief configuration parameters for memory error tests
@@ -559,8 +559,8 @@ void* TRI_WrappedReallocate (void* ptr, long size) {
 /// @brief initialize memory subsystem
 ////////////////////////////////////////////////////////////////////////////////
 
-void TRI_InitialiseMemory () {
-  if (CoreInitialised == 0) {
+void TRI_InitializeMemory () {
+  if (CoreInitialized == 0) {
     static size_t const ReserveSize = 1024 * 1024 * 10;
 
     TriCoreMemZone._zid      = 0;
@@ -583,7 +583,7 @@ void TRI_InitialiseMemory () {
               (unsigned long long) ReserveSize);
     }
     else {
-      CoreInitialised = 1;
+      CoreInitialized = 1;
     }
   }
 }
@@ -593,9 +593,9 @@ void TRI_InitialiseMemory () {
 ////////////////////////////////////////////////////////////////////////////////
 
 void TRI_ShutdownMemory () {
-  if (CoreInitialised == 1) {
+  if (CoreInitialized == 1) {
     free(CoreReserve);
-    CoreInitialised = 0;
+    CoreInitialized = 0;
   }
 }
 

lib/Basics/memory.h

@@ -194,7 +194,7 @@ static inline void* TRI_Align64 (void* p) {
 /// @brief initialize memory subsystem
 ////////////////////////////////////////////////////////////////////////////////
 
-void TRI_InitialiseMemory (void);
+void TRI_InitializeMemory (void);
 
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief shut down memory subsystem

lib/Basics/mimetypes.cpp

@@ -57,7 +57,7 @@ mimetype_t;
 /// @brief already initialized
 ////////////////////////////////////////////////////////////////////////////////
 
-static bool Initialised = false;
+static bool Initialized = false;
 
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief the array of mimetypes
@@ -145,8 +145,8 @@ char* TRI_GetMimetype (const char* extension) {
 /// @brief initializes the mimetypes
 ////////////////////////////////////////////////////////////////////////////////
 
-void TRI_InitialiseMimetypes () {
-  if (Initialised) {
+void TRI_InitializeMimetypes () {
+  if (Initialized) {
     return;
   }
 
@@ -157,8 +157,8 @@ void TRI_InitialiseMimetypes () {
                              EqualMimetype,
                              0);
 
-  TRI_InitialiseEntriesMimetypes();
-  Initialised = true;
+  TRI_InitializeEntriesMimetypes();
+  Initialized = true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -168,7 +168,7 @@ void TRI_InitialiseMimetypes () {
 void TRI_ShutdownMimetypes () {
   size_t i;
 
-  if (! Initialised) {
+  if (! Initialized) {
     return;
   }
 
@@ -184,7 +184,7 @@ void TRI_ShutdownMimetypes () {
 
   TRI_DestroyAssociativePointer(&Mimetypes);
 
-  Initialised = false;
+  Initialized = false;
 }
 
 // -----------------------------------------------------------------------------

lib/Basics/mimetypes.h

@@ -66,7 +66,7 @@ char* TRI_GetMimetype (const char*);
 /// @brief initializes mimetypes
 ////////////////////////////////////////////////////////////////////////////////
 
-void TRI_InitialiseMimetypes (void);
+void TRI_InitializeMimetypes (void);
 
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief shuts down mimetypes

lib/Basics/process-utils.cpp

@@ -1414,7 +1414,7 @@ static uint64_t GetPhysicalMemory () {
 /// @brief initializes the process components
 ////////////////////////////////////////////////////////////////////////////////
 
-void TRI_InitialiseProcess (int argc, char* argv[]) {
+void TRI_InitializeProcess (int argc, char* argv[]) {
   TRI_PhysicalMemory = GetPhysicalMemory();
 
   if (ProcessName != nullptr) {

lib/Basics/process-utils.h

@@ -210,7 +210,7 @@ bool TRI_KillExternalProcess (TRI_external_id_t pid);
 /// @brief initializes the process components
 ////////////////////////////////////////////////////////////////////////////////
 
-void TRI_InitialiseProcess (int argc, char* argv[]);
+void TRI_InitializeProcess (int argc, char* argv[]);
 
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief shut downs the process components

lib/Basics/random.cpp

@@ -39,7 +39,7 @@
 /// @brief already initialized
 ////////////////////////////////////////////////////////////////////////////////
 
-static bool Initialised = false;
+static bool Initialized = false;
 
 // -----------------------------------------------------------------------------
 // --SECTION--                                                 private functions
@@ -148,14 +148,14 @@ uint32_t TRI_UInt32Random (void) {
 /// @brief initializes the random components
 ////////////////////////////////////////////////////////////////////////////////
 
-void TRI_InitialiseRandom (void) {
-  if (Initialised) {
+void TRI_InitializeRandom (void) {
+  if (Initialized) {
     return;
   }
 
   TRI_srandom(SeedRandom());
 
-  Initialised = true;
+  Initialized = true;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -163,11 +163,11 @@ void TRI_InitialiseRandom (void) {
 ////////////////////////////////////////////////////////////////////////////////
 
 void TRI_ShutdownRandom (void) {
-  if (! Initialised) {
+  if (! Initialized) {
     return;
   }
 
-  Initialised = false;
+  Initialized = false;
 }
 
 // -----------------------------------------------------------------------------

lib/Basics/random.h

@@ -65,7 +65,7 @@ uint32_t TRI_UInt32Random (void);
 /// @brief initializes the random components
 ////////////////////////////////////////////////////////////////////////////////
 
-void TRI_InitialiseRandom (void);
+void TRI_InitializeRandom (void);
 
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief shuts down the random components

lib/Basics/voc-errors.cpp

@@ -5,7 +5,7 @@
 #include "Basics/Common.h"
 #include "./lib/Basics/voc-errors.h"
 
-void TRI_InitialiseErrorMessages () {
+void TRI_InitializeErrorMessages () {
   REG_ERROR(ERROR_NO_ERROR, "no error");
   REG_ERROR(ERROR_FAILED, "failed");
   REG_ERROR(ERROR_SYS_ERROR, "system error");

lib/Basics/voc-errors.h

@@ -671,7 +671,7 @@
 /// @brief register all errors for ArangoDB
 ////////////////////////////////////////////////////////////////////////////////
 
-void TRI_InitialiseErrorMessages ();
+void TRI_InitializeErrorMessages ();
 
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief 0: ERROR_NO_ERROR

lib/Basics/voc-mimetypes.cpp

@@ -9,7 +9,7 @@
 /// @brief initialize mimetypes
 ////////////////////////////////////////////////////////////////////////////////
 
-void TRI_InitialiseEntriesMimetypes () {
+void TRI_InitializeEntriesMimetypes () {
   TRI_RegisterMimetype("gif", "image/gif", false);
   TRI_RegisterMimetype("jpg", "image/jpg", false);
   TRI_RegisterMimetype("png", "image/png", false);

lib/Basics/voc-mimetypes.h

@@ -6,7 +6,7 @@
 /// @brief initialize mimetypes
 ////////////////////////////////////////////////////////////////////////////////
 
-void TRI_InitialiseEntriesMimetypes ();
+void TRI_InitializeEntriesMimetypes ();
 
 #endif
 

lib/Basics/win-utils.cpp

@@ -199,7 +199,7 @@ int finaliseWindows (const TRI_win_finalise_e finaliseWhat,
   return -1;
 }
 
-int initialiseWindows (const TRI_win_initialise_e initialiseWhat,
+int initializeWindows (const TRI_win_initialize_e initializeWhat,
                        const char* data) {
 
   // ............................................................................
@@ -207,7 +207,7 @@ int initialiseWindows (const TRI_win_initialise_e initialiseWhat,
   // it may be NULL (and will be in most cases)
   // ............................................................................
 
-  switch (initialiseWhat) {
+  switch (initializeWhat) {
 
     case TRI_WIN_INITIAL_SET_DEBUG_FLAG: {
       _CrtSetDbgFlag(_CrtSetDbgFlag(_CRTDBG_LEAK_CHECK_DF)|_CRTDBG_CHECK_ALWAYS_DF);

lib/Basics/win-utils.h

@@ -49,10 +49,10 @@ typedef enum {
   TRI_WIN_INITIAL_SET_MAX_STD_IO,
   TRI_WIN_INITIAL_WSASTARTUP_FUNCTION_CALL
 }
-TRI_win_initialise_e;
+TRI_win_initialize_e;
 
 int finaliseWindows (const TRI_win_finalise_e, const char*);
-int initialiseWindows (const TRI_win_initialise_e, const char*);
+int initializeWindows (const TRI_win_initialize_e, const char*);
 
 // .............................................................................
 // windows equivalent of ftruncate (the truncation of an open file) is

lib/CMakeLists.txt

@@ -63,7 +63,7 @@ add_library(
     Basics/fpconv.cpp
     Basics/hashes.cpp
     Basics/init.cpp
-    Basics/InitialiseBasics.cpp
+    Basics/InitializeBasics.cpp
     Basics/json.cpp
     Basics/json-utilities.cpp
     Basics/JsonHelper.cpp
@@ -112,7 +112,7 @@ add_library(
     Rest/EndpointIpV6.cpp
     Rest/HttpRequest.cpp
     Rest/HttpResponse.cpp
-    Rest/InitialiseRest.cpp
+    Rest/InitializeRest.cpp
     Rest/SslInterface.cpp
     Rest/Version.cpp
     Utilities/DummyShell.cpp

lib/Makefile.files

@@ -30,7 +30,7 @@ lib_libarango_a_SOURCES = \
 	lib/Basics/fpconv.cpp \
 	lib/Basics/hashes.cpp \
 	lib/Basics/init.cpp \
-	lib/Basics/InitialiseBasics.cpp \
+	lib/Basics/InitializeBasics.cpp \
 	lib/Basics/json.cpp \
 	lib/Basics/json-utilities.cpp \
 	lib/Basics/JsonHelper.cpp \
@@ -85,7 +85,7 @@ lib_libarango_a_SOURCES = \
 	lib/Rest/EndpointUnixDomain.cpp \
 	lib/Rest/HttpRequest.cpp \
 	lib/Rest/HttpResponse.cpp \
-	lib/Rest/InitialiseRest.cpp \
+	lib/Rest/InitializeRest.cpp \
 	lib/Rest/SslInterface.cpp \
 	lib/Rest/Version.cpp \
 	lib/Utilities/DummyShell.cpp \

lib/Rest/InitializeRest.cpp

@@ -27,7 +27,7 @@
 /// @author Copyright 2009-2013, triAGENS GmbH, Cologne, Germany
 ////////////////////////////////////////////////////////////////////////////////
 
-#include "InitialiseRest.h"
+#include "InitializeRest.h"
 
 #include <openssl/ssl.h>
 #include <openssl/err.h>
@@ -42,7 +42,7 @@
 
 #include "Basics/locks.h"
 #include "Basics/logging.h"
-#include "Basics/InitialiseBasics.h"
+#include "Basics/InitializeBasics.h"
 #include "Basics/threads.h"
 #include "Rest/HttpResponse.h"
 #include "Rest/Version.h"
@@ -134,8 +134,8 @@ namespace {
 
 namespace triagens {
   namespace rest {
-    void InitialiseRest (int argc, char* argv[]) {
-      TRIAGENS_BASICS_INITIALISE(argc, argv);
+    void InitializeRest (int argc, char* argv[]) {
+      TRIAGENS_BASICS_INITIALIZE(argc, argv);
 
       SSL_library_init();
       SSL_load_error_strings();
@@ -144,7 +144,7 @@ namespace triagens {
 
       opensslSetup();
 
-      Version::initialise();
+      Version::initialize();
     }
 
 

lib/Rest/InitializeRest.h

@@ -27,8 +27,8 @@
 /// @author Copyright 2009-2013, triAGENS GmbH, Cologne, Germany
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifndef ARANGODB_REST_INITIALISE_REST_H
-#define ARANGODB_REST_INITIALISE_REST_H 1
+#ifndef ARANGODB_REST_INITIALIZE_REST_H
+#define ARANGODB_REST_INITIALIZE_REST_H 1
 
 #include "Basics/Common.h"
 
@@ -44,7 +44,7 @@ namespace triagens {
 /// @brief initialize function
 ////////////////////////////////////////////////////////////////////////////////
 
-    extern void InitialiseRest (int argc, char* argv[]);
+    extern void InitializeRest (int argc, char* argv[]);
 
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief shutdown function
@@ -58,9 +58,9 @@ namespace triagens {
 /// @brief initialize
 ////////////////////////////////////////////////////////////////////////////////
 
-#define TRIAGENS_REST_INITIALISE(a,b)           \
+#define TRIAGENS_REST_INITIALIZE(a,b)           \
   do {                                          \
-    triagens::rest::InitialiseRest((a), (b));   \
+    triagens::rest::InitializeRest((a), (b));   \
   } while (0)
 
 ////////////////////////////////////////////////////////////////////////////////

lib/Rest/Version.cpp

@@ -54,7 +54,7 @@ using namespace triagens::rest;
 /// @brief initialize
 ////////////////////////////////////////////////////////////////////////////////
 
-void Version::initialise () {
+void Version::initialize () {
   if (! Values.empty()) {
     return;
   }

lib/Rest/Version.h

@@ -73,7 +73,7 @@ namespace triagens {
 /// @brief initialize
 ////////////////////////////////////////////////////////////////////////////////
 
-        static void initialise ();
+        static void initialize ();
 
 ////////////////////////////////////////////////////////////////////////////////
 /// @brief get numeric server version