Hawkin
/
arangodb
mirror of https://gitee.com/bigwinds/arangodb
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

removed uncalled functions

This commit is contained in:
Jan Steemann 2015-08-12 19:46:25 +02:00
parent 33c2e9a8cc
commit f6f10dbd45
9 changed files with 0 additions and 256 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
UnitTests/Basics/vector-test.cpp
View File

@ -490,40 +490,6 @@ BOOST_AUTO_TEST_CASE (tst_set) {
VECTOR_DESTROY
}
////////////////////////////////////////////////////////////////////////////////
/// @brief test copy
////////////////////////////////////////////////////////////////////////////////
BOOST_AUTO_TEST_CASE (tst_copy) {
VECTOR_INIT
void* r = 0;
int a = 1;
int b = 2;
int c = 3;
int d = 4;
TRI_vector_t* v2;
TRI_PushBackVector(&v1, &a);
TRI_PushBackVector(&v1, &b);
TRI_PushBackVector(&v1, &c);
TRI_PushBackVector(&v1, &d);
v2 = TRI_CopyVector(TRI_CORE_MEM_ZONE, &v1);
VECTOR_DESTROY
BOOST_CHECK_EQUAL((size_t) 4, TRI_LengthVector(v2));
BOOST_CHECK_EQUAL(1, *(int*) TRI_AtVector(v2, 0));
BOOST_CHECK_EQUAL(2, *(int*) TRI_AtVector(v2, 1));
BOOST_CHECK_EQUAL(3, *(int*) TRI_AtVector(v2, 2));
BOOST_CHECK_EQUAL(4, *(int*) TRI_AtVector(v2, 3));
BOOST_CHECK_EQUAL(r, TRI_AtVector(v2, 4));
TRI_FreeVector(TRI_CORE_MEM_ZONE, v2);
}
////////////////////////////////////////////////////////////////////////////////
/// @brief test modifications
////////////////////////////////////////////////////////////////////////////////
@ -536,8 +502,6 @@ BOOST_AUTO_TEST_CASE (tst_value_modifications) {
int c = 3;
int d = 4;
TRI_vector_t* v2;
TRI_PushBackVector(&v1, &a);
TRI_PushBackVector(&v1, &b);
TRI_PushBackVector(&v1, &c);
@ -548,7 +512,6 @@ BOOST_AUTO_TEST_CASE (tst_value_modifications) {
BOOST_CHECK_EQUAL(3, *(int*) TRI_AtVector(&v1, 2));
BOOST_CHECK_EQUAL(4, *(int*) TRI_AtVector(&v1, 3));
v2 = TRI_CopyVector(TRI_CORE_MEM_ZONE, &v1);
a = 99;
b = 42;
c = -1;
@ -560,13 +523,6 @@ BOOST_AUTO_TEST_CASE (tst_value_modifications) {
BOOST_CHECK_EQUAL(4, *(int*) TRI_AtVector(&v1, 3));
VECTOR_DESTROY
BOOST_CHECK_EQUAL(1, *(int*) TRI_AtVector(v2, 0));
BOOST_CHECK_EQUAL(2, *(int*) TRI_AtVector(v2, 1));
BOOST_CHECK_EQUAL(3, *(int*) TRI_AtVector(v2, 2));
BOOST_CHECK_EQUAL(4, *(int*) TRI_AtVector(v2, 3));
TRI_FreeVector(TRI_CORE_MEM_ZONE, v2);
}
////////////////////////////////////////////////////////////////////////////////

32
arangod/VocBase/datafile.cpp
View File

@ -1896,38 +1896,6 @@ TRI_datafile_t* TRI_OpenDatafile (char const* filename,
return datafile;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief opens an existing, possibly corrupt datafile
////////////////////////////////////////////////////////////////////////////////
TRI_datafile_t* TRI_ForcedOpenDatafile (char const* filename) {
// this function must not be called for non-physical datafiles
TRI_ASSERT(filename != nullptr);
TRI_datafile_t* datafile = OpenDatafile(filename, true);
if (datafile == nullptr) {
return nullptr;
}
// check the current marker
bool ok = CheckDatafile(datafile, true);
if (! ok) {
LOG_ERROR("datafile '%s' is corrupt", datafile->getName(datafile));
}
// change to read-write if no footer has been found
else {
if (! datafile->_isSealed) {
datafile->_state = TRI_DF_STATE_WRITE;
TRI_ProtectMMFile(datafile->_data, datafile->_maximalSize, PROT_READ | PROT_WRITE, datafile->_fd, &datafile->_mmHandle);
}
}
return datafile;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief closes a datafile and all memory regions
////////////////////////////////////////////////////////////////////////////////

6
arangod/VocBase/datafile.h
View File

@ -712,12 +712,6 @@ bool TRI_IterateDatafile (TRI_datafile_t*,
TRI_datafile_t* TRI_OpenDatafile (char const*,
bool);
////////////////////////////////////////////////////////////////////////////////
/// @brief opens an existing, possible corrupt datafile read-write
////////////////////////////////////////////////////////////////////////////////
TRI_datafile_t* TRI_ForcedOpenDatafile (char const*);
////////////////////////////////////////////////////////////////////////////////
/// @brief closes a datafile and all memory regions
////////////////////////////////////////////////////////////////////////////////

20
arangod/VocBase/server.cpp
View File

@ -2500,26 +2500,6 @@ TRI_vocbase_t* TRI_UseDatabaseServer (TRI_server_t* server,
return vocbase;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief lookup a database by its id
////////////////////////////////////////////////////////////////////////////////
TRI_vocbase_t* TRI_LookupDatabaseByIdServer (TRI_server_t* server,
TRI_voc_tick_t id) {
auto unuser(server->_databasesProtector.use());
auto theLists = server->_databasesLists.load();
for (auto& p : theLists->_databases) {
TRI_vocbase_t* vocbase = p.second;
if (vocbase->_id == id) {
return vocbase;
}
}
return nullptr;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief lookup a database by its name
////////////////////////////////////////////////////////////////////////////////

7
arangod/VocBase/server.h
View File

@ -240,13 +240,6 @@ TRI_vocbase_t* TRI_UseCoordinatorDatabaseServer (TRI_server_t*,
TRI_vocbase_t* TRI_UseDatabaseServer (TRI_server_t*,
char const*);
////////////////////////////////////////////////////////////////////////////////
/// @brief lookup a database by its id
////////////////////////////////////////////////////////////////////////////////
TRI_vocbase_t* TRI_LookupDatabaseByIdServer (TRI_server_t*,
TRI_voc_tick_t);
////////////////////////////////////////////////////////////////////////////////
/// @brief lookup a database by its name
////////////////////////////////////////////////////////////////////////////////

32
lib/Basics/structures.cpp
View File

@ -64,38 +64,6 @@ void TRI_FreeBlob (TRI_memory_zone_t* zone, TRI_blob_t* blob) {
// --SECTION-- public functions
// -----------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////
/// @brief copies a blob
////////////////////////////////////////////////////////////////////////////////
TRI_blob_t* TRI_CopyBlob (TRI_memory_zone_t* zone, TRI_blob_t const* src) {
TRI_blob_t* dst;
dst = (TRI_blob_t*) TRI_Allocate(zone, sizeof(TRI_blob_t), false);
if (dst == nullptr) {
return nullptr;
}
if (src->length == 0 || src->data == nullptr) {
dst->length = 0;
dst->data = nullptr;
}
else {
dst->length = src->length;
dst->data = static_cast<char*>(TRI_Allocate(zone, dst->length, false));
if (dst->data == nullptr) {
TRI_Free(zone, dst);
return nullptr;
}
memcpy(dst->data, src->data, src->length);
}
return dst;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief copies a blob into given destination
////////////////////////////////////////////////////////////////////////////////

6
lib/Basics/structures.h
View File

@ -103,12 +103,6 @@ void TRI_FreeBlob (TRI_memory_zone_t*, TRI_blob_t*);
// --SECTION-- public functions
// -----------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////
/// @brief copies a blob
////////////////////////////////////////////////////////////////////////////////
TRI_blob_t* TRI_CopyBlob (TRI_memory_zone_t*, TRI_blob_t const* src);
////////////////////////////////////////////////////////////////////////////////
/// @brief copies a blob into given destination
////////////////////////////////////////////////////////////////////////////////

95
lib/Basics/vector.cpp
View File

@ -138,43 +138,6 @@ int TRI_ReserveVector (TRI_vector_t* vector,
return TRI_ERROR_NO_ERROR;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief copies a vector
////////////////////////////////////////////////////////////////////////////////
TRI_vector_t* TRI_CopyVector (TRI_memory_zone_t* zone,
TRI_vector_t const* vector) {
TRI_vector_t* copy = static_cast<TRI_vector_t*>(TRI_Allocate(zone, sizeof(TRI_vector_t), false));
if (copy == nullptr) {
return nullptr;
}
copy->_elementSizeX = vector->_elementSizeX;
copy->_memoryZoneX = TRI_MemoryZoneId(zone);
if (vector->_capacityX == 0) {
copy->_buffer = nullptr;
copy->_lengthX = 0;
copy->_capacityX = 0;
}
else {
copy->_buffer = static_cast<char*>(TRI_Allocate(zone, static_cast<size_t>(vector->_lengthX * vector->_elementSizeX), false));
if (copy->_buffer == nullptr) {
TRI_Free(zone, copy);
return nullptr;
}
copy->_capacityX = vector->_lengthX;
copy->_lengthX = vector->_lengthX;
memcpy(copy->_buffer, vector->_buffer, static_cast<size_t>(vector->_lengthX * vector->_elementSizeX));
}
return copy;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief adjusts the length of the vector
////////////////////////////////////////////////////////////////////////////////
@ -695,64 +658,6 @@ void TRI_FreeVectorString (TRI_memory_zone_t* zone, TRI_vector_string_t* vector)
// --SECTION-- public functions
// -----------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////
/// @brief copies a vector and all its strings
////////////////////////////////////////////////////////////////////////////////
TRI_vector_string_t* TRI_CopyVectorString (TRI_memory_zone_t* zone,
TRI_vector_string_t const* vector) {
TRI_vector_string_t* copy = static_cast<TRI_vector_string_t*>(TRI_Allocate(zone, sizeof(TRI_vector_t), false));
if (copy == nullptr) {
return nullptr;
}
copy->_memoryZone = zone;
if (vector->_capacity == 0) {
copy->_buffer = nullptr;
copy->_length = 0;
copy->_capacity = 0;
}
else {
char** ptr;
char** end;
char** qtr;
copy->_buffer = static_cast<char**>(TRI_Allocate(zone, vector->_length * sizeof(char*), false));
if (copy->_buffer == nullptr) {
TRI_Free(zone, copy);
return nullptr;
}
copy->_capacity = vector->_length;
copy->_length = vector->_length;
ptr = vector->_buffer;
end = vector->_buffer + vector->_length;
qtr = copy->_buffer;
for (; ptr < end; ++ptr, ++qtr) {
*qtr = TRI_DuplicateStringZ(zone, *ptr);
if (*qtr == nullptr) {
char** xtr = copy->_buffer;
for (; xtr < qtr; ++xtr) {
TRI_Free(zone, *xtr);
}
TRI_Free(zone, copy->_buffer);
TRI_Free(zone, copy);
return nullptr;
}
}
}
return copy;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief adds an element at the end
////////////////////////////////////////////////////////////////////////////////

14
lib/Basics/vector.h
View File

@ -107,13 +107,6 @@ static inline size_t TRI_LengthVector (TRI_vector_t const* vector) {
int TRI_ReserveVector (TRI_vector_t*,
size_t);
////////////////////////////////////////////////////////////////////////////////
/// @brief copies a vector
////////////////////////////////////////////////////////////////////////////////
TRI_vector_t* TRI_CopyVector (TRI_memory_zone_t*,
TRI_vector_t const*);
////////////////////////////////////////////////////////////////////////////////
/// @brief adjusts the length of the vector
////////////////////////////////////////////////////////////////////////////////
@ -349,13 +342,6 @@ void TRI_FreeVectorString (TRI_memory_zone_t*, TRI_vector_string_t*);
// --SECTION-- public functions
// -----------------------------------------------------------------------------
////////////////////////////////////////////////////////////////////////////////
/// @brief copies a vector and all its strings
////////////////////////////////////////////////////////////////////////////////
TRI_vector_string_t* TRI_CopyVectorString (TRI_memory_zone_t*,
TRI_vector_string_t const*);
////////////////////////////////////////////////////////////////////////////////
/// @brief returns length of vector
////////////////////////////////////////////////////////////////////////////////