From cb2ca12d2de4bf15c534a8db25992c502084f176 Mon Sep 17 00:00:00 2001 From: Srecko Date: Thu, 16 May 2024 18:56:30 +0200 Subject: [PATCH] move Jsoncpp within jsoncollector namespace to avoid clash with the newer version of the library included by tensorflow several unused files removed --- .../Utilities/interface/EvFDaqDirector.h | 8 +- EventFilter/Utilities/interface/features.h | 2 + EventFilter/Utilities/interface/forwards.h | 2 + .../Utilities/interface/json_batchallocator.h | 2 + EventFilter/Utilities/interface/reader.h | 3 +- EventFilter/Utilities/interface/value.h | 4 +- EventFilter/Utilities/interface/writer.h | 2 + .../Utilities/src/json_internalarray.icc | 321 ------------- .../Utilities/src/json_internalmap.icc | 424 ------------------ EventFilter/Utilities/src/json_reader.cpp | 2 + EventFilter/Utilities/src/json_value.cpp | 6 +- EventFilter/Utilities/src/json_writer.cpp | 2 + .../plugins/HLTriggerJSONMonitoring.cc | 2 + .../plugins/L1TriggerJSONMonitoring.cc | 2 + 14 files changed, 27 insertions(+), 755 deletions(-) delete mode 100644 EventFilter/Utilities/src/json_internalarray.icc delete mode 100644 EventFilter/Utilities/src/json_internalmap.icc diff --git a/EventFilter/Utilities/interface/EvFDaqDirector.h b/EventFilter/Utilities/interface/EvFDaqDirector.h index 86a7bc103a378..921c612bfbd84 100644 --- a/EventFilter/Utilities/interface/EvFDaqDirector.h +++ b/EventFilter/Utilities/interface/EvFDaqDirector.h @@ -40,12 +40,12 @@ namespace edm { class ProcessContext; } // namespace edm -namespace Json { - class Value; -} - namespace jsoncollector { class DataPointDefinition; + + namespace Json { + class Value; + } } namespace edm { diff --git a/EventFilter/Utilities/interface/features.h b/EventFilter/Utilities/interface/features.h index f0b48cf2ebfde..7f9739267996c 100644 --- a/EventFilter/Utilities/interface/features.h +++ b/EventFilter/Utilities/interface/features.h @@ -3,6 +3,7 @@ #include "forwards.h" +namespace jsoncollector { namespace Json { /** \brief Configuration passed to reader and writer. @@ -37,5 +38,6 @@ namespace Json { }; } // namespace Json +} // namespace jsoncollector #endif // CPPTL_JSON_FEATURES_H_INCLUDED diff --git a/EventFilter/Utilities/interface/forwards.h b/EventFilter/Utilities/interface/forwards.h index 60fff6a9f286f..dde7efdf46913 100644 --- a/EventFilter/Utilities/interface/forwards.h +++ b/EventFilter/Utilities/interface/forwards.h @@ -3,6 +3,7 @@ #include "config.h" +namespace jsoncollector { namespace Json { // writer.h @@ -34,5 +35,6 @@ namespace Json { #endif // #ifdef JSON_VALUE_USE_INTERNAL_MAP } // namespace Json +} // namespace jsoncollector #endif // JSON_FORWARDS_H_INCLUDED diff --git a/EventFilter/Utilities/interface/json_batchallocator.h b/EventFilter/Utilities/interface/json_batchallocator.h index f43f4a4007fa7..a66532b75675d 100644 --- a/EventFilter/Utilities/interface/json_batchallocator.h +++ b/EventFilter/Utilities/interface/json_batchallocator.h @@ -6,6 +6,7 @@ #ifndef JSONCPP_DOC_EXCLUDE_IMPLEMENTATION +namespace jsoncollector { namespace Json { /* Fast memory allocator. @@ -106,6 +107,7 @@ namespace Json { }; } // namespace Json +} //namespace jsoncollector #endif // ifndef JSONCPP_DOC_INCLUDE_IMPLEMENTATION diff --git a/EventFilter/Utilities/interface/reader.h b/EventFilter/Utilities/interface/reader.h index 57069c12bccba..bfc0c042930a9 100644 --- a/EventFilter/Utilities/interface/reader.h +++ b/EventFilter/Utilities/interface/reader.h @@ -8,6 +8,7 @@ #include #include +namespace jsoncollector { namespace Json { /** \brief Unserialize a JSON document into a Value. @@ -167,5 +168,5 @@ namespace Json { std::istream &operator>>(std::istream &, Value &); } // namespace Json - +} // namespace jsoncollector #endif // CPPTL_JSON_READER_H_INCLUDED diff --git a/EventFilter/Utilities/interface/value.h b/EventFilter/Utilities/interface/value.h index 723899a2d43be..3c0c8a399d8e3 100644 --- a/EventFilter/Utilities/interface/value.h +++ b/EventFilter/Utilities/interface/value.h @@ -16,6 +16,8 @@ /** \brief JSON (JavaScript Object Notation). */ + +namespace jsoncollector { namespace Json { /** \brief Type of the value held by a Value object. @@ -957,5 +959,5 @@ class DefaultValueArrayAllocator : public ValueArrayAllocator }; } // namespace Json - +} // namespace jsoncollector #endif // CPPTL_JSON_H_INCLUDED diff --git a/EventFilter/Utilities/interface/writer.h b/EventFilter/Utilities/interface/writer.h index f48b35f67d578..9dbde0852ec63 100644 --- a/EventFilter/Utilities/interface/writer.h +++ b/EventFilter/Utilities/interface/writer.h @@ -6,6 +6,7 @@ #include #include +namespace jsoncollector { namespace Json { class Value; @@ -164,5 +165,6 @@ namespace Json { std::ostream &operator<<(std::ostream &, const Value &root); } // namespace Json +} // namespace jsoncollector #endif // JSON_WRITER_H_INCLUDED diff --git a/EventFilter/Utilities/src/json_internalarray.icc b/EventFilter/Utilities/src/json_internalarray.icc deleted file mode 100644 index 99d7698afd9df..0000000000000 --- a/EventFilter/Utilities/src/json_internalarray.icc +++ /dev/null @@ -1,321 +0,0 @@ -// included by json_value.cpp -// everything is within Json namespace - -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// class ValueInternalArray -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// - -ValueArrayAllocator::~ValueArrayAllocator() {} - -// ////////////////////////////////////////////////////////////////// -// class DefaultValueArrayAllocator -// ////////////////////////////////////////////////////////////////// -#ifdef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR -class DefaultValueArrayAllocator : public ValueArrayAllocator { -public: // overridden from ValueArrayAllocator - virtual ~DefaultValueArrayAllocator() {} - - virtual ValueInternalArray *newArray() { return new ValueInternalArray(); } - - virtual ValueInternalArray *newArrayCopy(const ValueInternalArray &other) { return new ValueInternalArray(other); } - - virtual void destructArray(ValueInternalArray *array) { delete array; } - - virtual void reallocateArrayPageIndex(Value **&indexes, - ValueInternalArray::PageIndex &indexCount, - ValueInternalArray::PageIndex minNewIndexCount) { - ValueInternalArray::PageIndex newIndexCount = (indexCount * 3) / 2 + 1; - if (minNewIndexCount > newIndexCount) - newIndexCount = minNewIndexCount; - void *newIndexes = realloc(indexes, sizeof(Value *) * newIndexCount); - if (!newIndexes) - throw std::bad_alloc(); - indexCount = newIndexCount; - indexes = static_cast(newIndexes); - } - virtual void releaseArrayPageIndex(Value **indexes, ValueInternalArray::PageIndex indexCount) { - if (indexes) - free(indexes); - } - - virtual Value *allocateArrayPage() { - return static_cast(malloc(sizeof(Value) * ValueInternalArray::itemsPerPage)); - } - - virtual void releaseArrayPage(Value *value) { - if (value) - free(value); - } -}; - -#else // #ifdef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR -/// @todo make this thread-safe (lock when accessign batch allocator) -class DefaultValueArrayAllocator : public ValueArrayAllocator { -public: // overridden from ValueArrayAllocator - virtual ~DefaultValueArrayAllocator() {} - - virtual ValueInternalArray *newArray() { - ValueInternalArray *array = arraysAllocator_.allocate(); - new (array) ValueInternalArray(); // placement new - return array; - } - - virtual ValueInternalArray *newArrayCopy(const ValueInternalArray &other) { - ValueInternalArray *array = arraysAllocator_.allocate(); - new (array) ValueInternalArray(other); // placement new - return array; - } - - virtual void destructArray(ValueInternalArray *array) { - if (array) { - array->~ValueInternalArray(); - arraysAllocator_.release(array); - } - } - - virtual void reallocateArrayPageIndex(Value **&indexes, - ValueInternalArray::PageIndex &indexCount, - ValueInternalArray::PageIndex minNewIndexCount) { - ValueInternalArray::PageIndex newIndexCount = (indexCount * 3) / 2 + 1; - if (minNewIndexCount > newIndexCount) - newIndexCount = minNewIndexCount; - void *newIndexes = realloc(indexes, sizeof(Value *) * newIndexCount); - if (!newIndexes) - throw std::bad_alloc(); - indexCount = newIndexCount; - indexes = static_cast(newIndexes); - } - virtual void releaseArrayPageIndex(Value **indexes, ValueInternalArray::PageIndex indexCount) { - if (indexes) - free(indexes); - } - - virtual Value *allocateArrayPage() { return static_cast(pagesAllocator_.allocate()); } - - virtual void releaseArrayPage(Value *value) { - if (value) - pagesAllocator_.release(value); - } - -private: - BatchAllocator arraysAllocator_; - BatchAllocator pagesAllocator_; -}; -#endif // #ifdef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR - -static ValueArrayAllocator *&arrayAllocator() { - static DefaultValueArrayAllocator defaultAllocator; - static ValueArrayAllocator *arrayAllocator = &defaultAllocator; - return arrayAllocator; -} - -static struct DummyArrayAllocatorInitializer { - DummyArrayAllocatorInitializer() { - arrayAllocator(); // ensure arrayAllocator() statics are initialized before main(). - } -} dummyArrayAllocatorInitializer; - -// ////////////////////////////////////////////////////////////////// -// class ValueInternalArray -// ////////////////////////////////////////////////////////////////// -bool ValueInternalArray::equals(const IteratorState &x, const IteratorState &other) { - return x.array_ == other.array_ && x.currentItemIndex_ == other.currentItemIndex_ && - x.currentPageIndex_ == other.currentPageIndex_; -} - -void ValueInternalArray::increment(IteratorState &it) { - JSON_ASSERT_MESSAGE( - it.array_ && (it.currentPageIndex_ - it.array_->pages_) * itemsPerPage + it.currentItemIndex_ != it.array_->size_, - "ValueInternalArray::increment(): moving iterator beyond end"); - ++(it.currentItemIndex_); - if (it.currentItemIndex_ == itemsPerPage) { - it.currentItemIndex_ = 0; - ++(it.currentPageIndex_); - } -} - -void ValueInternalArray::decrement(IteratorState &it) { - JSON_ASSERT_MESSAGE(it.array_ && it.currentPageIndex_ == it.array_->pages_ && it.currentItemIndex_ == 0, - "ValueInternalArray::decrement(): moving iterator beyond end"); - if (it.currentItemIndex_ == 0) { - it.currentItemIndex_ = itemsPerPage - 1; - --(it.currentPageIndex_); - } else { - --(it.currentItemIndex_); - } -} - -Value &ValueInternalArray::unsafeDereference(const IteratorState &it) { - return (*(it.currentPageIndex_))[it.currentItemIndex_]; -} - -Value &ValueInternalArray::dereference(const IteratorState &it) { - JSON_ASSERT_MESSAGE( - it.array_ && (it.currentPageIndex_ - it.array_->pages_) * itemsPerPage + it.currentItemIndex_ < it.array_->size_, - "ValueInternalArray::dereference(): dereferencing invalid iterator"); - return unsafeDereference(it); -} - -void ValueInternalArray::makeBeginIterator(IteratorState &it) const { - it.array_ = const_cast(this); - it.currentItemIndex_ = 0; - it.currentPageIndex_ = pages_; -} - -void ValueInternalArray::makeIterator(IteratorState &it, ArrayIndex index) const { - it.array_ = const_cast(this); - it.currentItemIndex_ = index % itemsPerPage; - it.currentPageIndex_ = pages_ + index / itemsPerPage; -} - -void ValueInternalArray::makeEndIterator(IteratorState &it) const { makeIterator(it, size_); } - -ValueInternalArray::ValueInternalArray() : pages_(0), size_(0), pageCount_(0) {} - -ValueInternalArray::ValueInternalArray(const ValueInternalArray &other) : pages_(0), pageCount_(0), size_(other.size_) { - PageIndex minNewPages = other.size_ / itemsPerPage; - arrayAllocator()->reallocateArrayPageIndex(pages_, pageCount_, minNewPages); - JSON_ASSERT_MESSAGE(pageCount_ >= minNewPages, "ValueInternalArray::reserve(): bad reallocation"); - IteratorState itOther; - other.makeBeginIterator(itOther); - Value *value; - for (ArrayIndex index = 0; index < size_; ++index, increment(itOther)) { - if (index % itemsPerPage == 0) { - PageIndex pageIndex = index / itemsPerPage; - value = arrayAllocator()->allocateArrayPage(); - pages_[pageIndex] = value; - } - new (value) Value(dereference(itOther)); - } -} - -ValueInternalArray &ValueInternalArray::operator=(const ValueInternalArray &other) { - ValueInternalArray temp(other); - swap(temp); - return *this; -} - -ValueInternalArray::~ValueInternalArray() { - // destroy all constructed items - IteratorState it; - IteratorState itEnd; - makeBeginIterator(it); - makeEndIterator(itEnd); - for (; !equals(it, itEnd); increment(it)) { - Value *value = &dereference(it); - value->~Value(); - } - // release all pages - PageIndex lastPageIndex = size_ / itemsPerPage; - for (PageIndex pageIndex = 0; pageIndex < lastPageIndex; ++pageIndex) - arrayAllocator()->releaseArrayPage(pages_[pageIndex]); - // release pages index - arrayAllocator()->releaseArrayPageIndex(pages_, pageCount_); -} - -void ValueInternalArray::swap(ValueInternalArray &other) { - Value **tempPages = pages_; - pages_ = other.pages_; - other.pages_ = tempPages; - ArrayIndex tempSize = size_; - size_ = other.size_; - other.size_ = tempSize; - PageIndex tempPageCount = pageCount_; - pageCount_ = other.pageCount_; - other.pageCount_ = tempPageCount; -} - -void ValueInternalArray::clear() { - ValueInternalArray dummy; - swap(dummy); -} - -void ValueInternalArray::resize(ArrayIndex newSize) { - if (newSize == 0) - clear(); - else if (newSize < size_) { - IteratorState it; - IteratorState itEnd; - makeIterator(it, newSize); - makeIterator(itEnd, size_); - for (; !equals(it, itEnd); increment(it)) { - Value *value = &dereference(it); - value->~Value(); - } - PageIndex pageIndex = (newSize + itemsPerPage - 1) / itemsPerPage; - PageIndex lastPageIndex = size_ / itemsPerPage; - for (; pageIndex < lastPageIndex; ++pageIndex) - arrayAllocator()->releaseArrayPage(pages_[pageIndex]); - size_ = newSize; - } else if (newSize > size_) - resolveReference(newSize); -} - -void ValueInternalArray::makeIndexValid(ArrayIndex index) { - // Need to enlarge page index ? - if (index >= pageCount_ * itemsPerPage) { - PageIndex minNewPages = (index + 1) / itemsPerPage; - arrayAllocator()->reallocateArrayPageIndex(pages_, pageCount_, minNewPages); - JSON_ASSERT_MESSAGE(pageCount_ >= minNewPages, "ValueInternalArray::reserve(): bad reallocation"); - } - - // Need to allocate new pages ? - ArrayIndex nextPageIndex = (size_ % itemsPerPage) != 0 ? size_ - (size_ % itemsPerPage) + itemsPerPage : size_; - if (nextPageIndex <= index) { - PageIndex pageIndex = nextPageIndex / itemsPerPage; - PageIndex pageToAllocate = (index - nextPageIndex) / itemsPerPage + 1; - for (; pageToAllocate-- > 0; ++pageIndex) - pages_[pageIndex] = arrayAllocator()->allocateArrayPage(); - } - - // Initialize all new entries - IteratorState it; - IteratorState itEnd; - makeIterator(it, size_); - size_ = index + 1; - makeIterator(itEnd, size_); - for (; !equals(it, itEnd); increment(it)) { - Value *value = &dereference(it); - new (value) Value(); // Construct a default value using placement new - } -} - -Value &ValueInternalArray::resolveReference(ArrayIndex index) { - if (index >= size_) - makeIndexValid(index); - return pages_[index / itemsPerPage][index % itemsPerPage]; -} - -Value *ValueInternalArray::find(ArrayIndex index) const { - if (index >= size_) - return 0; - return &(pages_[index / itemsPerPage][index % itemsPerPage]); -} - -ValueInternalArray::ArrayIndex ValueInternalArray::size() const { return size_; } - -int ValueInternalArray::distance(const IteratorState &x, const IteratorState &y) { return indexOf(y) - indexOf(x); } - -ValueInternalArray::ArrayIndex ValueInternalArray::indexOf(const IteratorState &iterator) { - if (!iterator.array_) - return ArrayIndex(-1); - return ArrayIndex((iterator.currentPageIndex_ - iterator.array_->pages_) * itemsPerPage + iterator.currentItemIndex_); -} - -int ValueInternalArray::compare(const ValueInternalArray &other) const { - int sizeDiff(size_ - other.size_); - if (sizeDiff != 0) - return sizeDiff; - - for (ArrayIndex index = 0; index < size_; ++index) { - int diff = pages_[index / itemsPerPage][index % itemsPerPage].compare( - other.pages_[index / itemsPerPage][index % itemsPerPage]); - if (diff != 0) - return diff; - } - return 0; -} diff --git a/EventFilter/Utilities/src/json_internalmap.icc b/EventFilter/Utilities/src/json_internalmap.icc deleted file mode 100644 index c41ed1a62dddb..0000000000000 --- a/EventFilter/Utilities/src/json_internalmap.icc +++ /dev/null @@ -1,424 +0,0 @@ -// included by json_value.cpp -// everything is within Json namespace - -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// class ValueInternalMap -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// -// ////////////////////////////////////////////////////////////////// - -/** \internal MUST be safely initialized using memset( this, 0, sizeof(ValueInternalLink) ); - * This optimization is used by the fast allocator. - */ -ValueInternalLink::ValueInternalLink() : previous_(0), next_(0) {} - -ValueInternalLink::~ValueInternalLink() { - for (int index = 0; index < itemPerLink; ++index) { - if (!items_[index].isItemAvailable()) { - if (!items_[index].isMemberNameStatic()) - free(keys_[index]); - } else - break; - } -} - -ValueMapAllocator::~ValueMapAllocator() {} - -#ifdef JSON_USE_SIMPLE_INTERNAL_ALLOCATOR -class DefaultValueMapAllocator : public ValueMapAllocator { -public: // overridden from ValueMapAllocator - virtual ValueInternalMap *newMap() { return new ValueInternalMap(); } - - virtual ValueInternalMap *newMapCopy(const ValueInternalMap &other) { return new ValueInternalMap(other); } - - virtual void destructMap(ValueInternalMap *map) { delete map; } - - virtual ValueInternalLink *allocateMapBuckets(unsigned int size) { return new ValueInternalLink[size]; } - - virtual void releaseMapBuckets(ValueInternalLink *links) { delete[] links; } - - virtual ValueInternalLink *allocateMapLink() { return new ValueInternalLink(); } - - virtual void releaseMapLink(ValueInternalLink *link) { delete link; } -}; -#else -/// @todo make this thread-safe (lock when accessign batch allocator) -class DefaultValueMapAllocator : public ValueMapAllocator { -public: // overridden from ValueMapAllocator - virtual ValueInternalMap *newMap() { - ValueInternalMap *map = mapsAllocator_.allocate(); - new (map) ValueInternalMap(); // placement new - return map; - } - - virtual ValueInternalMap *newMapCopy(const ValueInternalMap &other) { - ValueInternalMap *map = mapsAllocator_.allocate(); - new (map) ValueInternalMap(other); // placement new - return map; - } - - virtual void destructMap(ValueInternalMap *map) { - if (map) { - map->~ValueInternalMap(); - mapsAllocator_.release(map); - } - } - - virtual ValueInternalLink *allocateMapBuckets(unsigned int size) { return new ValueInternalLink[size]; } - - virtual void releaseMapBuckets(ValueInternalLink *links) { delete[] links; } - - virtual ValueInternalLink *allocateMapLink() { - ValueInternalLink *link = linksAllocator_.allocate(); - memset(link, 0, sizeof(ValueInternalLink)); - return link; - } - - virtual void releaseMapLink(ValueInternalLink *link) { - link->~ValueInternalLink(); - linksAllocator_.release(link); - } - -private: - BatchAllocator mapsAllocator_; - BatchAllocator linksAllocator_; -}; -#endif - -static ValueMapAllocator *&mapAllocator() { - static DefaultValueMapAllocator defaultAllocator; - static ValueMapAllocator *mapAllocator = &defaultAllocator; - return mapAllocator; -} - -static struct DummyMapAllocatorInitializer { - DummyMapAllocatorInitializer() { - mapAllocator(); // ensure mapAllocator() statics are initialized before main(). - } -} dummyMapAllocatorInitializer; - -// h(K) = value * K >> w ; with w = 32 & K prime w.r.t. 2^32. - -/* -use linked list hash map. -buckets array is a container. -linked list element contains 6 key/values. (memory = (16+4) * 6 + 4 = 124) -value have extra state: valid, available, deleted -*/ - -ValueInternalMap::ValueInternalMap() : buckets_(0), tailLink_(0), bucketsSize_(0), itemCount_(0) {} - -ValueInternalMap::ValueInternalMap(const ValueInternalMap &other) - : buckets_(0), tailLink_(0), bucketsSize_(0), itemCount_(0) { - reserve(other.itemCount_); - IteratorState it; - IteratorState itEnd; - other.makeBeginIterator(it); - other.makeEndIterator(itEnd); - for (; !equals(it, itEnd); increment(it)) { - bool isStatic; - const char *memberName = key(it, isStatic); - const Value &aValue = value(it); - resolveReference(memberName, isStatic) = aValue; - } -} - -ValueInternalMap &ValueInternalMap::operator=(const ValueInternalMap &other) { - ValueInternalMap dummy(other); - swap(dummy); - return *this; -} - -ValueInternalMap::~ValueInternalMap() { - if (buckets_) { - for (BucketIndex bucketIndex = 0; bucketIndex < bucketsSize_; ++bucketIndex) { - ValueInternalLink *link = buckets_[bucketIndex].next_; - while (link) { - ValueInternalLink *linkToRelease = link; - link = link->next_; - mapAllocator()->releaseMapLink(linkToRelease); - } - } - mapAllocator()->releaseMapBuckets(buckets_); - } -} - -void ValueInternalMap::swap(ValueInternalMap &other) { - ValueInternalLink *tempBuckets = buckets_; - buckets_ = other.buckets_; - other.buckets_ = tempBuckets; - ValueInternalLink *tempTailLink = tailLink_; - tailLink_ = other.tailLink_; - other.tailLink_ = tempTailLink; - BucketIndex tempBucketsSize = bucketsSize_; - bucketsSize_ = other.bucketsSize_; - other.bucketsSize_ = tempBucketsSize; - BucketIndex tempItemCount = itemCount_; - itemCount_ = other.itemCount_; - other.itemCount_ = tempItemCount; -} - -void ValueInternalMap::clear() { - ValueInternalMap dummy; - swap(dummy); -} - -ValueInternalMap::BucketIndex ValueInternalMap::size() const { return itemCount_; } - -bool ValueInternalMap::reserveDelta(BucketIndex growth) { return reserve(itemCount_ + growth); } - -bool ValueInternalMap::reserve(BucketIndex newItemCount) { - if (!buckets_ && newItemCount > 0) { - buckets_ = mapAllocator()->allocateMapBuckets(1); - bucketsSize_ = 1; - tailLink_ = &buckets_[0]; - } - // BucketIndex idealBucketCount = (newItemCount + ValueInternalLink::itemPerLink) / ValueInternalLink::itemPerLink; - return true; -} - -const Value *ValueInternalMap::find(const char *key) const { - if (!bucketsSize_) - return 0; - HashKey hashedKey = hash(key); - BucketIndex bucketIndex = hashedKey % bucketsSize_; - for (const ValueInternalLink *current = &buckets_[bucketIndex]; current != 0; current = current->next_) { - for (BucketIndex index = 0; index < ValueInternalLink::itemPerLink; ++index) { - if (current->items_[index].isItemAvailable()) - return 0; - if (strcmp(key, current->keys_[index]) == 0) - return ¤t->items_[index]; - } - } - return 0; -} - -Value *ValueInternalMap::find(const char *key) { - const ValueInternalMap *constThis = this; - return const_cast(constThis->find(key)); -} - -Value &ValueInternalMap::resolveReference(const char *key, bool isStatic) { - HashKey hashedKey = hash(key); - if (bucketsSize_) { - BucketIndex bucketIndex = hashedKey % bucketsSize_; - ValueInternalLink **previous = 0; - BucketIndex index; - for (ValueInternalLink *current = &buckets_[bucketIndex]; current != 0; - previous = ¤t->next_, current = current->next_) { - for (index = 0; index < ValueInternalLink::itemPerLink; ++index) { - if (current->items_[index].isItemAvailable()) - return setNewItem(key, isStatic, current, index); - if (strcmp(key, current->keys_[index]) == 0) - return current->items_[index]; - } - } - } - - reserveDelta(1); - return unsafeAdd(key, isStatic, hashedKey); -} - -void ValueInternalMap::remove(const char *key) { - HashKey hashedKey = hash(key); - if (!bucketsSize_) - return; - BucketIndex bucketIndex = hashedKey % bucketsSize_; - for (ValueInternalLink *link = &buckets_[bucketIndex]; link != 0; link = link->next_) { - BucketIndex index; - for (index = 0; index < ValueInternalLink::itemPerLink; ++index) { - if (link->items_[index].isItemAvailable()) - return; - if (strcmp(key, link->keys_[index]) == 0) { - doActualRemove(link, index, bucketIndex); - return; - } - } - } -} - -void ValueInternalMap::doActualRemove(ValueInternalLink *link, BucketIndex index, BucketIndex bucketIndex) { - // find last item of the bucket and swap it with the 'removed' one. - // set removed items flags to 'available'. - // if last page only contains 'available' items, then desallocate it (it's empty) - ValueInternalLink *&lastLink = getLastLinkInBucket(index); - BucketIndex lastItemIndex = 1; // a link can never be empty, so start at 1 - for (; lastItemIndex < ValueInternalLink::itemPerLink; ++lastItemIndex) // may be optimized with dicotomic search - { - if (lastLink->items_[lastItemIndex].isItemAvailable()) - break; - } - - BucketIndex lastUsedIndex = lastItemIndex - 1; - Value *valueToDelete = &link->items_[index]; - Value *valueToPreserve = &lastLink->items_[lastUsedIndex]; - if (valueToDelete != valueToPreserve) - valueToDelete->swap(*valueToPreserve); - if (lastUsedIndex == 0) // page is now empty - { // remove it from bucket linked list and delete it. - ValueInternalLink *linkPreviousToLast = lastLink->previous_; - if (linkPreviousToLast != 0) // can not deleted bucket link. - { - mapAllocator()->releaseMapLink(lastLink); - linkPreviousToLast->next_ = 0; - lastLink = linkPreviousToLast; - } - } else { - Value dummy; - valueToPreserve->swap(dummy); // restore deleted to default Value. - valueToPreserve->setItemUsed(false); - } - --itemCount_; -} - -ValueInternalLink *&ValueInternalMap::getLastLinkInBucket(BucketIndex bucketIndex) { - if (bucketIndex == bucketsSize_ - 1) - return tailLink_; - ValueInternalLink *&previous = buckets_[bucketIndex + 1].previous_; - if (!previous) - previous = &buckets_[bucketIndex]; - return previous; -} - -Value &ValueInternalMap::setNewItem(const char *key, bool isStatic, ValueInternalLink *link, BucketIndex index) { - char *duplicatedKey = valueAllocator()->makeMemberName(key); - ++itemCount_; - link->keys_[index] = duplicatedKey; - link->items_[index].setItemUsed(); - link->items_[index].setMemberNameIsStatic(isStatic); - return link->items_[index]; // items already default constructed. -} - -Value &ValueInternalMap::unsafeAdd(const char *key, bool isStatic, HashKey hashedKey) { - JSON_ASSERT_MESSAGE(bucketsSize_ > 0, "ValueInternalMap::unsafeAdd(): internal logic error."); - BucketIndex bucketIndex = hashedKey % bucketsSize_; - ValueInternalLink *&previousLink = getLastLinkInBucket(bucketIndex); - ValueInternalLink *link = previousLink; - BucketIndex index; - for (index = 0; index < ValueInternalLink::itemPerLink; ++index) { - if (link->items_[index].isItemAvailable()) - break; - } - if (index == ValueInternalLink::itemPerLink) // need to add a new page - { - ValueInternalLink *newLink = mapAllocator()->allocateMapLink(); - index = 0; - link->next_ = newLink; - previousLink = newLink; - link = newLink; - } - return setNewItem(key, isStatic, link, index); -} - -ValueInternalMap::HashKey ValueInternalMap::hash(const char *key) const { - HashKey hash = 0; - while (*key) - hash += *key++ * 37; - return hash; -} - -int ValueInternalMap::compare(const ValueInternalMap &other) const { - int sizeDiff(itemCount_ - other.itemCount_); - if (sizeDiff != 0) - return sizeDiff; - // Strict order guaranty is required. Compare all keys FIRST, then compare values. - IteratorState it; - IteratorState itEnd; - makeBeginIterator(it); - makeEndIterator(itEnd); - for (; !equals(it, itEnd); increment(it)) { - if (!other.find(key(it))) - return 1; - } - - // All keys are equals, let's compare values - makeBeginIterator(it); - for (; !equals(it, itEnd); increment(it)) { - const Value *otherValue = other.find(key(it)); - int valueDiff = value(it).compare(*otherValue); - if (valueDiff != 0) - return valueDiff; - } - return 0; -} - -void ValueInternalMap::makeBeginIterator(IteratorState &it) const { - it.map_ = const_cast(this); - it.bucketIndex_ = 0; - it.itemIndex_ = 0; - it.link_ = buckets_; -} - -void ValueInternalMap::makeEndIterator(IteratorState &it) const { - it.map_ = const_cast(this); - it.bucketIndex_ = bucketsSize_; - it.itemIndex_ = 0; - it.link_ = 0; -} - -bool ValueInternalMap::equals(const IteratorState &x, const IteratorState &other) { - return x.map_ == other.map_ && x.bucketIndex_ == other.bucketIndex_ && x.link_ == other.link_ && - x.itemIndex_ == other.itemIndex_; -} - -void ValueInternalMap::incrementBucket(IteratorState &iterator) { - ++iterator.bucketIndex_; - JSON_ASSERT_MESSAGE(iterator.bucketIndex_ <= iterator.map_->bucketsSize_, - "ValueInternalMap::increment(): attempting to iterate beyond end."); - if (iterator.bucketIndex_ == iterator.map_->bucketsSize_) - iterator.link_ = 0; - else - iterator.link_ = &(iterator.map_->buckets_[iterator.bucketIndex_]); - iterator.itemIndex_ = 0; -} - -void ValueInternalMap::increment(IteratorState &iterator) { - JSON_ASSERT_MESSAGE(iterator.map_, "Attempting to iterator using invalid iterator."); - ++iterator.itemIndex_; - if (iterator.itemIndex_ == ValueInternalLink::itemPerLink) { - JSON_ASSERT_MESSAGE(iterator.link_ != 0, "ValueInternalMap::increment(): attempting to iterate beyond end."); - iterator.link_ = iterator.link_->next_; - if (iterator.link_ == 0) - incrementBucket(iterator); - } else if (iterator.link_->items_[iterator.itemIndex_].isItemAvailable()) { - incrementBucket(iterator); - } -} - -void ValueInternalMap::decrement(IteratorState &iterator) { - if (iterator.itemIndex_ == 0) { - JSON_ASSERT_MESSAGE(iterator.map_, "Attempting to iterate using invalid iterator."); - if (iterator.link_ == &iterator.map_->buckets_[iterator.bucketIndex_]) { - JSON_ASSERT_MESSAGE(iterator.bucketIndex_ > 0, "Attempting to iterate beyond beginning."); - --(iterator.bucketIndex_); - } - iterator.link_ = iterator.link_->previous_; - iterator.itemIndex_ = ValueInternalLink::itemPerLink - 1; - } -} - -const char *ValueInternalMap::key(const IteratorState &iterator) { - JSON_ASSERT_MESSAGE(iterator.link_, "Attempting to iterate using invalid iterator."); - return iterator.link_->keys_[iterator.itemIndex_]; -} - -const char *ValueInternalMap::key(const IteratorState &iterator, bool &isStatic) { - JSON_ASSERT_MESSAGE(iterator.link_, "Attempting to iterate using invalid iterator."); - isStatic = iterator.link_->items_[iterator.itemIndex_].isMemberNameStatic(); - return iterator.link_->keys_[iterator.itemIndex_]; -} - -Value &ValueInternalMap::value(const IteratorState &iterator) { - JSON_ASSERT_MESSAGE(iterator.link_, "Attempting to iterate using invalid iterator."); - return iterator.link_->items_[iterator.itemIndex_]; -} - -int ValueInternalMap::distance(const IteratorState &x, const IteratorState &y) { - int offset = 0; - IteratorState it = x; - while (!equals(it, y)) - increment(it); - return offset; -} diff --git a/EventFilter/Utilities/src/json_reader.cpp b/EventFilter/Utilities/src/json_reader.cpp index efc9802860836..31c3748b64b44 100644 --- a/EventFilter/Utilities/src/json_reader.cpp +++ b/EventFilter/Utilities/src/json_reader.cpp @@ -11,6 +11,7 @@ #pragma warning(disable : 4996) // disable warning about strdup being deprecated. #endif +namespace jsoncollector { namespace Json { // Implementation of class Features @@ -677,3 +678,4 @@ namespace Json { } } // namespace Json +} // namespace jsoncollector diff --git a/EventFilter/Utilities/src/json_value.cpp b/EventFilter/Utilities/src/json_value.cpp index 1b9ad73dc9906..4dca618e212fe 100644 --- a/EventFilter/Utilities/src/json_value.cpp +++ b/EventFilter/Utilities/src/json_value.cpp @@ -19,6 +19,7 @@ if (!(condition)) \ throw std::runtime_error(message); +namespace jsoncollector { namespace Json { const Value Value::null; @@ -104,10 +105,6 @@ namespace Json { // ////////////////////////////////////////////////////////////////// // ////////////////////////////////////////////////////////////////// // ////////////////////////////////////////////////////////////////// -#ifdef JSON_VALUE_USE_INTERNAL_MAP -#include "json_internalarray.icc" -#include "json_internalmap.icc" -#endif // JSON_VALUE_USE_INTERNAL_MAP #include "json_valueiterator.icc" @@ -1293,3 +1290,4 @@ namespace Json { } } // namespace Json +} //namespace jsoncollector diff --git a/EventFilter/Utilities/src/json_writer.cpp b/EventFilter/Utilities/src/json_writer.cpp index 99aff7b3607b9..139061e856304 100644 --- a/EventFilter/Utilities/src/json_writer.cpp +++ b/EventFilter/Utilities/src/json_writer.cpp @@ -11,6 +11,7 @@ #pragma warning(disable : 4996) // disable warning about strdup being deprecated. #endif +namespace jsoncollector { namespace Json { static bool isControlCharacter(char ch) { return ch > 0 && ch <= 0x1F; } @@ -640,3 +641,4 @@ namespace Json { } } // namespace Json +} // namespace jsoncollector diff --git a/HLTrigger/JSONMonitoring/plugins/HLTriggerJSONMonitoring.cc b/HLTrigger/JSONMonitoring/plugins/HLTriggerJSONMonitoring.cc index 33d6a07b94c3e..ab41f29efae70 100644 --- a/HLTrigger/JSONMonitoring/plugins/HLTriggerJSONMonitoring.cc +++ b/HLTrigger/JSONMonitoring/plugins/HLTriggerJSONMonitoring.cc @@ -39,6 +39,8 @@ //the special paths which are affected //a standard path logic goes "trigger type -> l1 seed -> prescale -> other selection" +using namespace jsoncollector; + struct HLTriggerJSONMonitoringData { // variables accumulated event by event in each stream struct stream { diff --git a/HLTrigger/JSONMonitoring/plugins/L1TriggerJSONMonitoring.cc b/HLTrigger/JSONMonitoring/plugins/L1TriggerJSONMonitoring.cc index 572d22dab0049..dc10beb5a8754 100644 --- a/HLTrigger/JSONMonitoring/plugins/L1TriggerJSONMonitoring.cc +++ b/HLTrigger/JSONMonitoring/plugins/L1TriggerJSONMonitoring.cc @@ -31,6 +31,8 @@ #include "FWCore/ServiceRegistry/interface/Service.h" #include "FWCore/Utilities/interface/Adler32Calculator.h" +using namespace jsoncollector; + struct L1TriggerJSONMonitoringData { // special values for prescale index checks static constexpr const int kPrescaleUndefined = -2;