Menu
▾
▴
[Nscldaq-cvscommits] SF.net SVN: nscldaq:[4893] branches/11.1-conversion-dev/utilities
|
From: <jr...@us...> - 2015-07-06 20:55:08
|
Revision: 4893
http://sourceforge.net/p/nscldaq/code/4893
Author: jrtomps
Date: 2015-07-06 20:55:05 +0000 (Mon, 06 Jul 2015)
Log Message:
-----------
Implements fixes for version 8
Modified Paths:
--------------
branches/11.1-conversion-dev/utilities/Buffer/BufferPtr.h
branches/11.1-conversion-dev/utilities/Buffer/ByteBuffer.cpp
branches/11.1-conversion-dev/utilities/Buffer/ByteBuffer.h
branches/11.1-conversion-dev/utilities/Buffer/Deserializer.h
branches/11.1-conversion-dev/utilities/Buffer/bytebuffertest.cpp
branches/11.1-conversion-dev/utilities/Buffer/deserializertest.cpp
branches/11.1-conversion-dev/utilities/Buffer/translatorptrtest.cpp
branches/11.1-conversion-dev/utilities/conversion/Makefile.am
branches/11.1-conversion-dev/utilities/conversion/TestRunner.cpp
branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CControlBuffer.cpp
branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CControlBuffer.h
branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CPhysicsEventBuffer.cpp
branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CPhysicsEventBuffer.h
branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CRawBuffer.cpp
branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CRawBuffer.h
branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CScalerBuffer.cpp
branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CStandardBodyParser.cpp
branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CTextBuffer.cpp
branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CTextBuffer.h
branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/Makefile.am
branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/bheader.h
branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/ccontrolbuffertest.cpp
branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/ctextbuffertest.cpp
branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/format_casttest.cpp
branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/physicseventtest.cpp
branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/rawbuffertest.cpp
branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/scalerbuffertest.cpp
branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/standardbodyparsertest.cpp
Added Paths:
-----------
branches/11.1-conversion-dev/utilities/conversion/CTransform8p0to10p0.cpp
branches/11.1-conversion-dev/utilities/conversion/CTransform8p0to10p0.h
branches/11.1-conversion-dev/utilities/conversion/ctransform8p0to10p0tests.cpp
Modified: branches/11.1-conversion-dev/utilities/Buffer/BufferPtr.h
===================================================================
--- branches/11.1-conversion-dev/utilities/Buffer/BufferPtr.h 2015-07-02 14:12:43 UTC (rev 4892)
+++ branches/11.1-conversion-dev/utilities/Buffer/BufferPtr.h 2015-07-06 20:55:05 UTC (rev 4893)
@@ -245,7 +245,7 @@
*/
inline BufferPtr<T> operator+(std::size_t Offset)
{
- return BufferPtr<T>(m_iter+Offset*sizeof(T));
+ return BufferPtr<T>(m_iter+Offset*sizeof(T), m_swapper);
}
@@ -260,7 +260,7 @@
*/
inline BufferPtr<T> operator-(std::size_t Offset)
{
- return BufferPtr<T>(m_iter-Offset*sizeof(T));
+ return BufferPtr<T>(m_iter-Offset*sizeof(T), m_swapper);
}
inline difference_type operator-(const BufferPtr<T>& rhs)
Modified: branches/11.1-conversion-dev/utilities/Buffer/ByteBuffer.cpp
===================================================================
--- branches/11.1-conversion-dev/utilities/Buffer/ByteBuffer.cpp 2015-07-02 14:12:43 UTC (rev 4892)
+++ branches/11.1-conversion-dev/utilities/Buffer/ByteBuffer.cpp 2015-07-06 20:55:05 UTC (rev 4893)
@@ -1,105 +1,3 @@
-#include "ByteBuffer.h"
-using namespace DAQ::Buffer;
-
-static ByteBuffer& loadBuffer(ByteBuffer& buffer, const char* beg, const char* end)
-{
- // make sure we only allocate once the memory we need
- buffer.reserve(buffer.size() + (end - beg));
-
- // copy the data using a back_inserter (calls push_back when assigning),
- // so that the buffer is properly sized when the copy is completed.
- std::copy(beg, end, std::back_inserter(buffer));
-
- return buffer;
-}
-
-
-ByteBuffer& operator<<(ByteBuffer& buffer, std::uint8_t value)
-{
- buffer.push_back(value);
- return buffer;
-}
-
-ByteBuffer& operator<<(ByteBuffer& buffer, std::int8_t value)
-{
- buffer.push_back(value);
- return buffer;
-}
-
-ByteBuffer& operator<<(ByteBuffer& buffer, std::uint16_t value)
-{
- // the char* can always refer to another type
- const char* beg = reinterpret_cast<const char*>(&value);
- const char* end = beg + sizeof(value);
-
- return loadBuffer(buffer, beg, end);
-}
-
-ByteBuffer& operator<<(ByteBuffer& buffer, std::int16_t value)
-{
- // the char* can always refer to another type
- const char* beg = reinterpret_cast<const char*>(&value);
- const char* end = beg + sizeof(value);
-
- return loadBuffer(buffer, beg, end);
-}
-
-ByteBuffer& operator<<(ByteBuffer& buffer, std::uint32_t value)
-{
- // the char* can always refer to another type
- const char* beg = reinterpret_cast<const char*>(&value);
- const char* end = beg + sizeof(value);
-
- return loadBuffer(buffer, beg, end);
-}
-
-ByteBuffer& operator<<(ByteBuffer& buffer, std::int32_t value)
-{
- // the char* can always refer to another type
- const char* beg = reinterpret_cast<const char*>(&value);
- const char* end = beg + sizeof(value);
-
- return loadBuffer(buffer, beg, end);
-}
-
-ByteBuffer& operator<<(ByteBuffer& buffer, std::uint64_t value)
-{
- // the char* can always refer to another type
- const char* beg = reinterpret_cast<const char*>(&value);
- const char* end = beg + sizeof(value);
-
- return loadBuffer(buffer, beg, end);
-}
-
-ByteBuffer& operator<<(ByteBuffer& buffer, std::int64_t value)
-{
- // the char* can always refer to another type
- const char* beg = reinterpret_cast<const char*>(&value);
- const char* end = beg + sizeof(value);
-
- return loadBuffer(buffer, beg, end);
-}
-
-ByteBuffer& operator<<(ByteBuffer& buffer, const ByteBuffer& rhs)
-{
- buffer.insert(buffer.end(), rhs.begin(), rhs.end());
-
- return buffer;
-}
-
-ByteBuffer& operator<<(ByteBuffer& buffer, const std::string& rhs)
-{
- buffer.insert(buffer.end(), rhs.begin(), rhs.end());
-
- return buffer;
-}
-
-ByteBuffer& operator<<(ByteBuffer& buffer, const char* rhs)
-{
- buffer << std::string(rhs) << uint8_t(0);
-
- return buffer;
-}
Modified: branches/11.1-conversion-dev/utilities/Buffer/ByteBuffer.h
===================================================================
--- branches/11.1-conversion-dev/utilities/Buffer/ByteBuffer.h 2015-07-02 14:12:43 UTC (rev 4892)
+++ branches/11.1-conversion-dev/utilities/Buffer/ByteBuffer.h 2015-07-06 20:55:05 UTC (rev 4893)
@@ -8,17 +8,58 @@
#include <string>
#include <iterator>
+#include <iostream>
+
namespace DAQ
{
namespace Buffer
{
- using ByteBuffer = std::vector<unsigned char>;
+ using ByteBuffer = std::vector<std::uint8_t>;
} // end of Buffer
} // end of DAQ
+
+
+template<class T>
+DAQ::Buffer::ByteBuffer& operator<<(DAQ::Buffer::ByteBuffer& buffer,
+ const T& value)
+{
+ // the char* can always refer to another type
+ const char* beg = reinterpret_cast<const char*>(&value);
+ const char* end = beg + sizeof(value);
+
+ // make sure we only allocate once the memory we need
+ buffer.reserve(buffer.size() + (end - beg));
+
+ // copy the data using a back_inserter (calls push_back when assigning),
+ // so that the buffer is properly sized when the copy is completed.
+ std::copy(beg, end, std::back_inserter(buffer));
+
+ return buffer;
+}
+
+template<> inline
+DAQ::Buffer::ByteBuffer& operator<<(DAQ::Buffer::ByteBuffer& buffer,
+ const std::string& rhs)
+{
+ buffer << std::uint16_t(rhs.size());
+ buffer.insert(buffer.end(), rhs.begin(), rhs.end());
+
+ return buffer;
+}
+
+template<> inline
+DAQ::Buffer::ByteBuffer& operator<<(DAQ::Buffer::ByteBuffer& buffer,
+ const DAQ::Buffer::ByteBuffer& rhs)
+{
+ buffer.insert(buffer.end(), rhs.begin(), rhs.end());
+
+ return buffer;
+}
+
/*!
* \brief Data insertion using a vector
*/
@@ -42,41 +83,39 @@
return buffer;
}
-extern
-DAQ::Buffer::ByteBuffer& operator<<(DAQ::Buffer::ByteBuffer& buffer,
- std::uint8_t value);
-extern
-DAQ::Buffer::ByteBuffer& operator<<(DAQ::Buffer::ByteBuffer& buffer,
- std::int8_t value);
-extern
-DAQ::Buffer::ByteBuffer& operator<<(DAQ::Buffer::ByteBuffer& buffer,
- std::uint16_t value);
-extern
-DAQ::Buffer::ByteBuffer& operator<<(DAQ::Buffer::ByteBuffer& buffer,
- std::int16_t value);
+inline DAQ::Buffer::ByteBuffer& operator<<(DAQ::Buffer::ByteBuffer& buffer,
+ const char* rhs)
+{
+ std::size_t length = strlen(rhs);
-extern
+ buffer.insert(buffer.end(), rhs, rhs+length);
+
+ // even lengths have a \0\0 trailer while odd lengths have \0
+ if ((length % 2)==0) buffer << uint16_t(0);
+ else buffer << uint8_t(0);
+
+ return buffer;
+}
+
+template<class T, std::size_t N>
DAQ::Buffer::ByteBuffer& operator<<(DAQ::Buffer::ByteBuffer& buffer,
- std::uint32_t value);
-extern
-DAQ::Buffer::ByteBuffer& operator<<(DAQ::Buffer::ByteBuffer& buffer,
- std::int32_t value);
-extern
-DAQ::Buffer::ByteBuffer& operator<<(DAQ::Buffer::ByteBuffer& buffer,
- std::uint64_t value);
-extern
-DAQ::Buffer::ByteBuffer& operator<<(DAQ::Buffer::ByteBuffer& buffer,
- std::int64_t value);
-extern
-DAQ::Buffer::ByteBuffer& operator<<(DAQ::Buffer::ByteBuffer& buffer,
- const DAQ::Buffer::ByteBuffer& rhs);
+ const T (&arr)[N]) {
+ for (std::size_t i=0; i<N; ++i) {
+ buffer << arr[i];
+ }
-extern
+ return buffer;
+}
+
+template<class T, std::size_t N>
DAQ::Buffer::ByteBuffer& operator<<(DAQ::Buffer::ByteBuffer& buffer,
- const std::string& string);
+ const std::array<T,N>& array) {
+ for (auto & element : array) {
+ buffer << element;
+ }
-extern
-DAQ::Buffer::ByteBuffer& operator<<(DAQ::Buffer::ByteBuffer& buffer,
- const char* string);
+ return buffer;
+}
+
#endif
Modified: branches/11.1-conversion-dev/utilities/Buffer/Deserializer.h
===================================================================
--- branches/11.1-conversion-dev/utilities/Buffer/Deserializer.h 2015-07-02 14:12:43 UTC (rev 4892)
+++ branches/11.1-conversion-dev/utilities/Buffer/Deserializer.h 2015-07-06 20:55:05 UTC (rev 4893)
@@ -54,7 +54,7 @@
m_fail = true;
} else {
- type = m_swapper.copyAs<T>(m_get);
+ m_swapper.interpretAs<T>(m_get, type);
m_get = end;
}
@@ -68,6 +68,26 @@
return type;
}
+ template<typename T>
+ void extract(T* begin, T* end) {
+ auto itend = m_get + std::distance(begin, end)*sizeof(T);
+
+ // do not allow to go past the end
+ if (itend > m_end) {
+ m_eof = true;
+ m_fail = true;
+ } else {
+
+ while (begin != end) {
+ m_swapper.interpretAs<T>(m_get, *begin);
+ ++begin;
+ ++m_get;
+ }
+ m_get = itend;
+ }
+
+ };
+
void clear() {
m_fail = false;
m_eof = false;
Modified: branches/11.1-conversion-dev/utilities/Buffer/bytebuffertest.cpp
===================================================================
--- branches/11.1-conversion-dev/utilities/Buffer/bytebuffertest.cpp 2015-07-02 14:12:43 UTC (rev 4892)
+++ branches/11.1-conversion-dev/utilities/Buffer/bytebuffertest.cpp 2015-07-06 20:55:05 UTC (rev 4893)
@@ -25,6 +25,11 @@
CPPUNIT_TEST(insert32_1);
CPPUNIT_TEST(insert64_0);
CPPUNIT_TEST(insert64_1);
+ CPPUNIT_TEST(insertArr_0);
+ CPPUNIT_TEST(insertArr_1);
+ CPPUNIT_TEST(insertString_0);
+ CPPUNIT_TEST(insertConstCharPtr_0);
+ CPPUNIT_TEST(insertConstCharPtr_1);
CPPUNIT_TEST_SUITE_END();
public:
@@ -154,6 +159,75 @@
}
+ void insertArr_0() {
+ ByteBuffer buffer;
+
+ std::int16_t test[4] = {0, 1, 2, 3};
+ buffer << test;
+
+ ByteBuffer expected = {0, 0, 1, 0, 2, 0, 3, 0};
+ CPPUNIT_ASSERT_EQUAL_MESSAGE("int16t [4] insert stores the correct values",
+ expected, buffer);
+
+ }
+
+ void insertArr_1() {
+
+ std::string m_title = "my test title";
+// m_title.resize(80, ' ');
+ char title[13];
+ std::copy(m_title.begin(), m_title.end(), title);
+
+ ByteBuffer buffer;
+
+// std::uint8_t test[4] = {'a','b','c','d'};
+ buffer << title;
+
+ cout << buffer << endl;
+// CPPUNIT_ASSERT_EQUAL_MESSAGE("uint8_t [4] insert stores the correct values",
+// expected, buffer);
+
+// CPPUNIT_ASSERT_EQUAL_MESSAGE("uint8_t [4] insert 4 values",
+// size_t(4), buffer.size());
+
+ }
+
+ void insertString_0() {
+ ByteBuffer buffer;
+
+ std::string mystr("the");
+ buffer << mystr;
+
+ ByteBuffer expected = {3, 0, 't', 'h', 'e'};
+ CPPUNIT_ASSERT_EQUAL_MESSAGE("string insert stores the correct values",
+ expected, buffer);
+
+ }
+
+ void insertConstCharPtr_0() {
+ ByteBuffer buffer;
+
+ const char* msg = "a";
+ buffer << msg;
+
+ ByteBuffer expected = {'a', 0};
+ CPPUNIT_ASSERT_EQUAL_MESSAGE("const char* insert stores the correct value for odd msg",
+ expected, buffer);
+
+ }
+
+ void insertConstCharPtr_1() {
+ ByteBuffer buffer;
+
+ const char* msg = "ab";
+ buffer << msg;
+
+ ByteBuffer expected = {'a', 'b', 0, 0};
+
+ CPPUNIT_ASSERT_EQUAL_MESSAGE("const char* insert stores the correct value for even msg",
+ expected, buffer);
+
+ }
};
CPPUNIT_TEST_SUITE_REGISTRATION(bytebuffertest);
Modified: branches/11.1-conversion-dev/utilities/Buffer/deserializertest.cpp
===================================================================
--- branches/11.1-conversion-dev/utilities/Buffer/deserializertest.cpp 2015-07-02 14:12:43 UTC (rev 4892)
+++ branches/11.1-conversion-dev/utilities/Buffer/deserializertest.cpp 2015-07-06 20:55:05 UTC (rev 4893)
@@ -26,6 +26,8 @@
CPPUNIT_TEST(extract_1);
CPPUNIT_TEST(extract_2);
CPPUNIT_TEST(extract_3);
+ CPPUNIT_TEST(extract_4);
+ CPPUNIT_TEST(extract_5);
CPPUNIT_TEST(eof_0);
CPPUNIT_TEST_SUITE_END();
@@ -94,6 +96,50 @@
std::uint32_t(0xffffffff), value );
}
+ void extract_4 () {
+ ByteBuffer buffer;
+ buffer.push_back('a');
+ buffer.push_back('b');
+ buffer.push_back('c');
+ buffer.push_back('d');
+
+ Deserializer<ByteBuffer> stream(buffer);
+
+ char arr[4];
+ stream.extract(arr);
+
+ CPPUNIT_ASSERT_EQUAL_MESSAGE("Extracting string array makes sense",
+ char('a'), arr[0]);
+ CPPUNIT_ASSERT_EQUAL_MESSAGE("Extracting string array makes sense",
+ char('b'), arr[1]);
+ CPPUNIT_ASSERT_EQUAL_MESSAGE("Extracting string array makes sense",
+ char('c'), arr[2]);
+ CPPUNIT_ASSERT_EQUAL_MESSAGE("Extracting string array makes sense",
+ char('d'), arr[3]);
+ }
+
+ void extract_5 () {
+ ByteBuffer buffer;
+ buffer.push_back('a');
+ buffer.push_back('b');
+ buffer.push_back('c');
+ buffer.push_back('d');
+
+ Deserializer<ByteBuffer> stream(buffer);
+
+ char arr[4];
+ stream.extract(arr, arr+4);
+
+ CPPUNIT_ASSERT_EQUAL_MESSAGE("Extracting string array makes sense",
+ char('a'), arr[0]);
+ CPPUNIT_ASSERT_EQUAL_MESSAGE("Extracting string array makes sense",
+ char('b'), arr[1]);
+ CPPUNIT_ASSERT_EQUAL_MESSAGE("Extracting string array makes sense",
+ char('c'), arr[2]);
+ CPPUNIT_ASSERT_EQUAL_MESSAGE("Extracting string array makes sense",
+ char('d'), arr[3]);
+ }
+
void eof_0 () {
ByteBuffer buffer;
buffer.push_back(1);
Modified: branches/11.1-conversion-dev/utilities/Buffer/translatorptrtest.cpp
===================================================================
--- branches/11.1-conversion-dev/utilities/Buffer/translatorptrtest.cpp 2015-07-02 14:12:43 UTC (rev 4892)
+++ branches/11.1-conversion-dev/utilities/Buffer/translatorptrtest.cpp 2015-07-06 20:55:05 UTC (rev 4893)
@@ -26,6 +26,7 @@
CPPUNIT_TEST(copyConstruct_1);
CPPUNIT_TEST(copyConstruct_2);
CPPUNIT_TEST(copyConstruct_3);
+ CPPUNIT_TEST(moveConstruct_0);
CPPUNIT_TEST(assign_0);
CPPUNIT_TEST(assign_1);
CPPUNIT_TEST(assign_2);
@@ -40,11 +41,15 @@
CPPUNIT_TEST(predecrement_0);
CPPUNIT_TEST(add_0);
CPPUNIT_TEST(add_1);
+ CPPUNIT_TEST(add_2);
CPPUNIT_TEST(sub_0);
CPPUNIT_TEST(sub_1);
CPPUNIT_TEST(sub_2);
+ CPPUNIT_TEST(sub_3);
CPPUNIT_TEST(addequal_0);
+ CPPUNIT_TEST(addequal_1);
CPPUNIT_TEST(subequal_0);
+ CPPUNIT_TEST(subequal_1);
CPPUNIT_TEST(lessThan_0);
CPPUNIT_TEST(lessThan_1);
CPPUNIT_TEST(greaterThan_0);
@@ -104,6 +109,15 @@
CPPUNIT_ASSERT_EQUAL_MESSAGE("Generalized copy maintains swapping status",
true, ptr2.getSwapper().isSwappingBytes());
}
+
+ void moveConstruct_0 () {
+
+ BufferPtr<uint64_t> ptr2(BufferPtr<uint8_t>(m_buffer.begin(), DAQ::BO::CByteSwapper(true)));
+
+ CPPUNIT_ASSERT_EQUAL_MESSAGE("Generalized copy maintains swapping status",
+ true, ptr2.getSwapper().isSwappingBytes());
+ }
+
void assign_0() {
BufferPtr<uint8_t> ptr(m_buffer.begin());
@@ -228,6 +242,16 @@
}
+ void add_2() {
+ BufferPtr<int8_t> ptr(m_buffer.begin(), true);
+
+ auto newPtr = ptr + 5;
+
+ CPPUNIT_ASSERT_EQUAL_MESSAGE("Addition returns ptr with same swapping semantics",
+ true, newPtr.getSwapper().isSwappingBytes());
+
+ }
+
void sub_0() {
BufferPtr<int8_t> ptr(m_buffer.begin());
@@ -262,6 +286,16 @@
}
+ void sub_3() {
+ BufferPtr<int8_t> ptr(m_buffer.begin(), true);
+
+ auto newPtr = ptr + 5;
+
+ CPPUNIT_ASSERT_EQUAL_MESSAGE("Subtraction returns ptr with same swapping semantics",
+ true, newPtr.getSwapper().isSwappingBytes());
+
+ }
+
void addequal_0 () {
BufferPtr<int32_t> ptr(m_buffer.begin());
@@ -273,6 +307,16 @@
}
+ void addequal_1 () {
+ BufferPtr<int32_t> ptr(m_buffer.begin(), true);
+
+ ptr += 2;
+
+ CPPUNIT_ASSERT_EQUAL_MESSAGE("+= maintains swapping",
+ true, ptr.getSwapper().isSwappingBytes());
+
+ }
+
void subequal_0 () {
BufferPtr<int32_t> ptr(m_buffer.begin());
@@ -284,6 +328,17 @@
}
+ void subequal_1 () {
+ BufferPtr<int32_t> ptr(m_buffer.begin(), true);
+
+ ptr -= 2;
+
+ CPPUNIT_ASSERT_EQUAL_MESSAGE("-= maintains swapping",
+ true, ptr.getSwapper().isSwappingBytes());
+
+ }
+
+
void lessThan_0 () {
BufferPtr<int32_t> ptr(m_buffer.begin());
BufferPtr<int32_t> ptr2(m_buffer.begin()+2);
Added: branches/11.1-conversion-dev/utilities/conversion/CTransform8p0to10p0.cpp
===================================================================
--- branches/11.1-conversion-dev/utilities/conversion/CTransform8p0to10p0.cpp (rev 0)
+++ branches/11.1-conversion-dev/utilities/conversion/CTransform8p0to10p0.cpp 2015-07-06 20:55:05 UTC (rev 4893)
@@ -0,0 +1,116 @@
+#include "CTransform8p0to10p0.h"
+
+#include <NSCLDAQ8/DataFormatV8.h>
+#include <NSCLDAQ8/CRawBuffer.h>
+#include <NSCLDAQ8/CScalerBuffer.h>
+#include <NSCLDAQ8/CPhysicsEventBuffer.h>
+#include <NSCLDAQ8/CControlBuffer.h>
+#include <NSCLDAQ8/CTextBuffer.h>
+#include <NSCLDAQ8/format_cast.h>
+
+#include <NSCLDAQ10/CRingItem.h>
+#include <NSCLDAQ10/CRingScalerItem.h>
+#include <NSCLDAQ10/CRingStateChangeItem.h>
+#include <NSCLDAQ10/CRingTextItem.h>
+#include <NSCLDAQ10/CPhysicsEventItem.h>
+
+#include <string>
+#include <stdexcept>
+#include <chrono>
+
+using namespace std;
+
+namespace DAQ {
+ namespace Transform {
+
+ CTransform8p0to10p0::FinalType CTransform8p0to10p0::operator ()(const InitialType& item)
+ {
+
+ switch (item.getHeader().type) {
+ case V8::SCALERBF:
+ case V8::SNAPSCBF:
+ return transformScaler(item);
+ break;
+ case V8::BEGRUNBF:
+ case V8::ENDRUNBF:
+ case V8::PAUSEBF:
+ case V8::RESUMEBF:
+ return transformControl(item);
+ break;
+ case V8::DATABF:
+ return transformPhysicsEvent(item);
+ break;
+ case V8::STATEVARBF:
+ case V8::RUNVARBF:
+ case V8::PKTDOCBF:
+ case V8::PARAMDESCRIP:
+ return transformText(item);
+ break;
+ default:
+ std::string errmsg("CTransform8p0to10p0::dispatch()");
+ errmsg += "Unsupported type (" + to_string(item.type()) + ") found";
+ throw std::runtime_error(errmsg);
+ break;
+ }
+
+ return NSCLDAQ10::CRingItem(1);
+ }
+
+
+ NSCLDAQ10::CRingScalerItem CTransform8p0to10p0::transformScaler(const InitialType &item)
+ {
+ using namespace std::chrono;
+
+ auto sclrBuf = V8::format_cast<V8::CScalerBuffer>(item);
+
+ NSCLDAQ10::CRingScalerItem newItem(sclrBuf.getOffsetBegin(),
+ sclrBuf.getOffsetEnd(),
+ system_clock::to_time_t(system_clock::now()),
+ sclrBuf.getScalers());
+
+ return newItem;
+ }
+
+ NSCLDAQ10::CRingStateChangeItem CTransform8p0to10p0::transformControl(const InitialType &item)
+ {
+ auto ctlBuf = V8::format_cast<V8::CControlBuffer>(item);
+ return NSCLDAQ10::CRingItem(NSCLDAQ10::BEGIN_RUN);
+ }
+
+ NSCLDAQ10::CPhysicsEventItem CTransform8p0to10p0::transformPhysicsEvent(const InitialType &item)
+ {
+ auto evtBuf = V8::format_cast<V8::CPhysicsEventBuffer>(item);
+
+ // make sure that we construct a physics event big enough to handle any V8 buffer
+ NSCLDAQ10::CPhysicsEventItem v10item(NSCLDAQ10::PHYSICS_EVENT, V8::gBufferSize);
+
+ char* pBody = reinterpret_cast<char*>(v10item.getBodyPointer());
+ auto v8Buffer = evtBuf.at(0)->getBuffer();
+ pBody = std::copy(v8Buffer.begin(), v8Buffer.end(), pBody);
+ v10item.setBodyCursor(pBody);
+ v10item.updateSize();
+ return v10item;
+ }
+
+ NSCLDAQ10::CRingTextItem CTransform8p0to10p0::transformText(const InitialType &item)
+ {
+ auto textBuf = V8::format_cast<V8::CTextBuffer>(item);
+
+ uint32_t v10type;
+ V8::BufferTypes v8type = textBuf.getHeader().type;
+ if (v8type == V8::STATEVARBF || v8type == V8::RUNVARBF) {
+ v10type = NSCLDAQ10::MONITORED_VARIABLES;
+ } else if (v8type == V8::PKTDOCBF) {
+ v10type = NSCLDAQ10::PACKET_TYPES;
+ } else {
+ std::string errmsg("CTransform8p0to10p0::transformText() ");
+ errmsg += "No known conversion of version 8 text type " + to_string(v8type) + " ";
+ errmsg += "to a version 10 text type";
+ throw std::runtime_error(errmsg);
+ }
+
+ NSCLDAQ10::CRingTextItem textItem(v10type, textBuf.getStrings());
+ return textItem;
+ }
+ } // namespace Transform
+} // namespace DAQ
Added: branches/11.1-conversion-dev/utilities/conversion/CTransform8p0to10p0.h
===================================================================
--- branches/11.1-conversion-dev/utilities/conversion/CTransform8p0to10p0.h (rev 0)
+++ branches/11.1-conversion-dev/utilities/conversion/CTransform8p0to10p0.h 2015-07-06 20:55:05 UTC (rev 4893)
@@ -0,0 +1,49 @@
+#ifndef DAQ_TRANSFORM_CTRANSFORM8P0TO10P0_H
+#define DAQ_TRANSFORM_CTRANSFORM8P0TO10P0_H
+
+#include <ByteBuffer.h>
+#include <cstdint>
+
+namespace NSCLDAQ10 {
+ class CRingItem;
+ class CRingScalerItem;
+ class CRingTextItem;
+ class CPhysicsEventItem;
+ class CRingStateChangeItem;
+}
+
+namespace DAQ {
+
+ namespace V8 {
+ class CRawBuffer;
+ class ScalerBuffer;
+
+ std::size_t gBufferSize = 8192;
+ }
+
+ namespace Transform {
+
+ class CTransform8p0to10p0
+ {
+ public:
+ typedef typename DAQ::V8::CRawBuffer InitialType;
+ typedef typename NSCLDAQ10::CRingItem FinalType;
+
+ public:
+ CTransform8p0to10p0(std::size_t bufferSize) {
+ DAQ::V8::gBufferSize = bufferSize;
+ }
+
+ FinalType operator()(const InitialType& type);
+
+ NSCLDAQ10::CRingScalerItem transformScaler(const InitialType& item);
+ NSCLDAQ10::CRingStateChangeItem transformControl(const InitialType& item);
+ NSCLDAQ10::CPhysicsEventItem transformPhysicsEvent(const InitialType &item);
+ NSCLDAQ10::CRingTextItem transformText(const InitialType& item);
+
+ };
+
+ } // namespace Transform
+} // namespace DAQ
+
+#endif // DAQ_TRANSFORM_CTRANSFORM8P0TO10P0_H
Modified: branches/11.1-conversion-dev/utilities/conversion/Makefile.am
===================================================================
--- branches/11.1-conversion-dev/utilities/conversion/Makefile.am 2015-07-02 14:12:43 UTC (rev 4892)
+++ branches/11.1-conversion-dev/utilities/conversion/Makefile.am 2015-07-06 20:55:05 UTC (rev 4893)
@@ -2,6 +2,7 @@
libConversion_la_SOURCES = CTransformMediator.h \
CTransformMediator.hpp \
+ CTransform8p0to10p0.cpp \
CTransform10p0to11p0.cpp \
CTransform11p0to10p0.cpp \
CTransformFactory.cpp \
@@ -10,6 +11,7 @@
#CTransform11p0to11p0.cpp
include_HEADERS = CTransformMediator.h \
+ CTransform8p0to10p0.h \
CTransform10p0to11p0.h \
CTransform11p0to10p0.h \
CTransformFactory.h \
@@ -19,6 +21,8 @@
# CTransform11p0to11p0.h
libConversion_la_CXXFLAGS = -I@srcdir@ \
+ -I@top_srcdir@/utilities/format \
+ -I@top_srcdir@/utilities/format/NSCLDAQ8 \
-I@top_srcdir@/utilities/format/NSCLDAQ10 \
-I@top_srcdir@/utilities/format/NSCLDAQ11 \
-I@top_srcdir@/utilities/filter \
@@ -32,12 +36,14 @@
noinst_PROGRAMS = unittests testApp
unittests_SOURCES = TestRunner.cpp \
+ ctransform8p0to10p0tests.cpp \
ctransform10p0to11p0tests.cpp \
ctransform11p0to10p0tests.cpp \
ctransformfactorytests.cpp
unittests_LDADD = -L$(libdir) $(CPPUNIT_LDFLAGS) \
@top_builddir@/utilities/conversion/libConversion.la \
+ @top_builddir@/utilities/format/NSCLDAQ8/libdataformatv8.la \
@top_builddir@/utilities/format/NSCLDAQ10/libdataformatv10.la \
@top_builddir@/utilities/format/NSCLDAQ11/libdataformatv11.la \
@top_builddir@/utilities/IO/libdaqio.la \
@@ -46,6 +52,7 @@
@LIBEXCEPTION_LDFLAGS@
unittests_CPPFLAGS= -I@srcdir@ \
+ -I@top_srcdir@/utilities/format/NSCLDAQ8 \
-I@top_srcdir@/utilities/format/NSCLDAQ10 \
-I@top_srcdir@/utilities/format/NSCLDAQ11 \
-I@top_srcdir@/utilities/filter \
@@ -67,6 +74,7 @@
testApp_SOURCES = Main.h Main.cpp
testApp_LDADD = @builddir@/libConversion.la \
+ @top_builddir@/utilities/format/NSCLDAQ8/libdataformatv8.la \
@top_builddir@/utilities/format/NSCLDAQ10/libdataformatv10.la \
@top_builddir@/utilities/format/NSCLDAQ11/libdataformatv11.la \
@top_builddir@/utilities/filter/libfilter.la \
@@ -74,6 +82,7 @@
@top_builddir@/utilities/FormattedIO/libdaqformatio.la
testApp_CPPFLAGS = -I@srcdir@ \
+ -I@top_srcdir@/utilities/format/NSCLDAQ8 \
-I@top_srcdir@/utilities/format/NSCLDAQ10 \
-I@top_srcdir@/utilities/format/NSCLDAQ11 \
-I@top_srcdir@/utilities/filter \
Modified: branches/11.1-conversion-dev/utilities/conversion/TestRunner.cpp
===================================================================
--- branches/11.1-conversion-dev/utilities/conversion/TestRunner.cpp 2015-07-02 14:12:43 UTC (rev 4892)
+++ branches/11.1-conversion-dev/utilities/conversion/TestRunner.cpp 2015-07-06 20:55:05 UTC (rev 4893)
@@ -42,4 +42,5 @@
}
+
int gpTCLApplication = 0;
Added: branches/11.1-conversion-dev/utilities/conversion/ctransform8p0to10p0tests.cpp
===================================================================
--- branches/11.1-conversion-dev/utilities/conversion/ctransform8p0to10p0tests.cpp (rev 0)
+++ branches/11.1-conversion-dev/utilities/conversion/ctransform8p0to10p0tests.cpp 2015-07-06 20:55:05 UTC (rev 4893)
@@ -0,0 +1,319 @@
+
+#include <cppunit/Asserter.h>
+#include <cppunit/extensions/HelperMacros.h>
+#include "Asserts.h"
+
+#include <NSCLDAQ8/CScalerBuffer.h>
+#include <NSCLDAQ10/CRingScalerItem.h>
+
+#include <NSCLDAQ8/CControlBuffer.h>
+#include <NSCLDAQ10/CRingStateChangeItem.h>
+
+#include <NSCLDAQ8/CPhysicsEventBuffer.h>
+#include <NSCLDAQ10/CPhysicsEventItem.h>
+
+#include <NSCLDAQ8/CTextBuffer.h>
+#include <NSCLDAQ10/CRingTextItem.h>
+
+#include <NSCLDAQ8/DataFormatV8.h>
+#include <NSCLDAQ10/DataFormatV10.h>
+
+#include <NSCLDAQ8/format_cast.h>
+#include <DebugUtils.h>
+
+#define private public
+#define protected public
+#include <CTransform8p0to10p0.h>
+#undef protected
+#undef private
+
+#include <iterator>
+#include <algorithm>
+
+using namespace std;
+
+using namespace DAQ;
+
+
+
+class CTransform8p0to10p0Tests_Scaler : public CppUnit::TestFixture
+{
+private:
+ V8::bheader m_header;
+ Transform::CTransform8p0to10p0 m_transform;
+ vector<uint32_t> m_scalers;
+ NSCLDAQ10::CRingScalerItem m_item;
+ std::uint32_t m_offsetBegin;
+ std::uint32_t m_offsetEnd;
+
+public:
+ CPPUNIT_TEST_SUITE(CTransform8p0to10p0Tests_Scaler);
+ CPPUNIT_TEST(scaler_0);
+ CPPUNIT_TEST(scaler_1);
+ CPPUNIT_TEST(scaler_2);
+ CPPUNIT_TEST(scaler_4);
+ CPPUNIT_TEST(scaler_5);
+ CPPUNIT_TEST_SUITE_END();
+
+public:
+ CTransform8p0to10p0Tests_Scaler() : m_header(), m_transform(8192),
+ m_scalers(), m_item(NSCLDAQ10::INCREMENTAL_SCALERS),
+ m_offsetBegin(0), m_offsetEnd(0) {}
+
+ void setUp() {
+ m_transform = Transform::CTransform8p0to10p0(8192);
+
+ m_header.type = V8::SCALERBF;
+ m_header.nevt = 16;
+ m_header.nwds = 33; // i think this includes the size of the header?
+ m_header.ssignature = V8::BOM16;
+ m_header.lsignature = V8::BOM32;
+
+ m_scalers = vector<uint32_t>(16);
+ iota(m_scalers.begin(), m_scalers.end(), 0);
+
+ m_offsetBegin = 0x1234;
+ m_offsetEnd = 0x5678;
+ V8::CScalerBuffer scaler(m_header, m_offsetBegin, m_offsetEnd, m_scalers);
+
+ m_item = m_transform( V8::format_cast<V8::CRawBuffer>(scaler) );
+
+ }
+ void tearDown() {
+ }
+
+protected:
+ void scaler_0() {
+ CPPUNIT_ASSERT_EQUAL_MESSAGE("Type transforms to INCREMENTAL_SCALERS",
+ NSCLDAQ10::INCREMENTAL_SCALERS, m_item.type());
+ }
+
+ void scaler_1() {
+ CPPUNIT_ASSERT_EQUAL_MESSAGE("Interval offset begin value is preserved",
+ m_offsetBegin, m_item.getStartTime());
+ }
+
+ void scaler_2() {
+ CPPUNIT_ASSERT_EQUAL_MESSAGE("Interval offset end value is preserved",
+ m_offsetEnd, m_item.getEndTime());
+ }
+
+// void scaler_3() {
+// CPPUNIT_ASSERT_EQUAL_MESSAGE("Timestamp is what we demand to be returned",
+// DEFAULT_TSTAMP, m_item.getTimestamp());
+// }
+
+ void scaler_4() {
+ CPPUNIT_ASSERT_EQUAL_MESSAGE("scaler count must be the same as m_header.nevt",
+ std::uint32_t(m_header.nevt), m_item.getScalerCount());
+ }
+
+ void scaler_5() {
+ CPPUNIT_ASSERT_EQUAL_MESSAGE("scaler values must be the same",
+ m_scalers, m_item.getScalers());
+ }
+
+};
+
+CPPUNIT_TEST_SUITE_REGISTRATION(CTransform8p0to10p0Tests_Scaler);
+
+
+
+ ///////////////////////////////////////////////////////////////////////////
+
+ class CTransform8p0to10p0Tests_Text : public CppUnit::TestFixture
+ {
+
+ public:
+ CPPUNIT_TEST_SUITE(CTransform8p0to10p0Tests_Text);
+ CPPUNIT_TEST(Text_0);
+ //CPPUNIT_TEST(Text_1);
+ CPPUNIT_TEST(Text_2);
+ CPPUNIT_TEST(Text_4);
+ CPPUNIT_TEST(Text_5);
+ CPPUNIT_TEST(Text_6);
+ CPPUNIT_TEST(Text_7);
+ CPPUNIT_TEST_SUITE_END();
+
+ public:
+ V8::bheader m_header;
+ NSCLDAQ10::CRingTextItem v10item;
+ Transform::CTransform8p0to10p0 m_transform;
+ std::vector<std::string> m_strings;
+
+ public:
+ // We need to define a default constructor b/c the CRingTextItem classes
+ // do not define a default constructor.
+ CTransform8p0to10p0Tests_Text() : v10item(NSCLDAQ10::MONITORED_VARIABLES, {}),
+ m_transform(8192),
+ m_strings() {}
+
+ void setUp()
+ {
+ m_transform = Transform::CTransform8p0to10p0(V8::gBufferSize);
+
+ m_header.type = V8::PKTDOCBF;
+ m_header.nevt = 7;
+ m_header.nwds = 35; // i think this includes the size of the header?
+ m_header.ssignature = V8::BOM16;
+ m_header.lsignature = V8::BOM32;
+
+ m_strings = {"why", "did", "the", "chicken", "cross", "the", "road?"};
+ uint16_t nTotalWords = 1;
+ for (auto & str : m_strings ) {
+ nTotalWords += str.size() + 1;
+ }
+
+ V8::CTextBuffer text(m_header, m_strings);
+
+ v10item = m_transform( V8::format_cast<V8::CRawBuffer>(text) );
+ }
+
+ void tearDown() {
+
+ }
+
+ void Text_0()
+ {
+ CPPUNIT_ASSERT_EQUAL_MESSAGE("Text item must have 0 as its time offset",
+ uint32_t(0), v10item.getTimeOffset());
+ }
+
+// not sure how to test the next one b/c it depends on the output of the time() function.
+ // I could play tricks with the include path, but that is non trivial.
+// void Text_1()
+// {
+// CPPUNIT_ASSERT_EQUAL_MESSAGE("Text item must have expected timestamp",
+// now, v10item.getTimestamp());
+// }
+
+ void Text_2()
+ {
+ CPPUNIT_ASSERT_EQUAL_MESSAGE("Text item string count is same as header.nevt",
+ uint32_t(m_header.nevt), v10item.getStringCount());
+ }
+
+ void Text_4()
+ {
+ auto strings = v10item.getStrings();
+ for (std::size_t i=0; i<strings.size(); ++i) {
+ CPPUNIT_ASSERT_EQUAL_MESSAGE("Text string must be the same",
+ m_strings.at(i), strings.at(i));
+ }
+ }
+
+ void Text_5()
+ {
+
+ CPPUNIT_ASSERT_EQUAL_MESSAGE("PKTDOCBF --> PACKET_TYPES",
+ NSCLDAQ10::PACKET_TYPES, v10item.type());
+ }
+ void Text_6()
+ {
+ m_header.type = V8::RUNVARBF;
+ m_header.nevt = 16;
+ m_header.nwds = 33; // i think this includes the size of the header?
+ m_header.ssignature = V8::BOM16;
+ m_header.lsignature = V8::BOM32;
+
+ m_strings = {"why", "did", "the", "chicken", "cross", "the", "road?"};
+
+ V8::CTextBuffer text(m_header, m_strings);
+
+ v10item = m_transform( V8::format_cast<V8::CRawBuffer>(text) );
+ CPPUNIT_ASSERT_EQUAL_MESSAGE("RUNVARBF --> MONITORED_VARIABLES",
+ NSCLDAQ10::MONITORED_VARIABLES, v10item.type());
+
+ }
+
+ void Text_7()
+ {
+ m_header.type = V8::STATEVARBF;
+ m_header.nevt = 16;
+ m_header.nwds = 33; // i think this includes the size of the header?
+ m_header.ssignature = V8::BOM16;
+ m_header.lsignature = V8::BOM32;
+
+ m_strings = {"why", "did", "the", "chicken", "cross", "the", "road?"};
+
+ V8::CTextBuffer text(m_header, m_strings);
+
+ v10item = m_transform( V8::format_cast<V8::CRawBuffer>(text) );
+ CPPUNIT_ASSERT_EQUAL_MESSAGE("STATEVARBF --> MONITORED_VARIABLES",
+ NSCLDAQ10::MONITORED_VARIABLES, v10item.type());
+ }
+
+ };
+ CPPUNIT_TEST_SUITE_REGISTRATION(CTransform8p0to10p0Tests_Text);
+
+
+ class CTransform8p0to10p0Tests_PhysicsEvent : public CppUnit::TestFixture
+ {
+
+ public:
+ CPPUNIT_TEST_SUITE(CTransform8p0to10p0Tests_PhysicsEvent);
+ CPPUNIT_TEST(Event_0);
+ CPPUNIT_TEST(Event_1);
+ CPPUNIT_TEST_SUITE_END();
+
+ public:
+ V8::bheader m_header;
+ NSCLDAQ10::CPhysicsEventItem v10item;
+ Transform::CTransform8p0to10p0 m_transform;
+ Buffer::ByteBuffer m_body;
+
+ public:
+ // We need to define a default constructor b/c the CRingTextItem classes
+ // do not define a default constructor.
+ CTransform8p0to10p0Tests_PhysicsEvent()
+ : v10item(8192),
+ m_transform(8192),
+ m_body() {}
+
+ void setUp()
+ {
+ m_transform = Transform::CTransform8p0to10p0(V8::gBufferSize);
+
+ m_header.type = V8::DATABF;
+ m_header.buffmt = V8::StandardVsn;
+ m_header.nevt = 1;
+ m_header.nwds = 18; // i think this includes the size of the header?
+ m_header.ssignature = V8::BOM16;
+ m_header.lsignature = V8::BOM32;
+
+ std::vector<std::uint16_t> body({2, 1234});
+
+ m_body = Buffer::ByteBuffer(8192);
+ m_body << body;
+
+ V8::CPhysicsEventBuffer event(m_header, body);
+
+ v10item = m_transform( V8::format_cast<V8::CRawBuffer>(event) );
+ }
+
+ void tearDown() {
+
+ }
+
+ void Event_0()
+ {
+ CPPUNIT_ASSERT_EQUAL_MESSAGE("DATABF --> PHYSICS_EVENT",
+ NSCLDAQ10::PHYSICS_EVENT, v10item.type());
+ }
+
+ void Event_1()
+ {
+ const char* pBody =reinterpret_cast<const char*>(v10item.getBodyPointer());
+
+ // copy the body into something safer and easier to work with
+ Buffer::ByteBuffer body(pBody, pBody+v10item.getBodySize());
+
+ CPPUNIT_ASSERT_EQUAL_MESSAGE("Physics event body remains the same",
+ m_body, body);
+ }
+
+ };
+ CPPUNIT_TEST_SUITE_REGISTRATION(CTransform8p0to10p0Tests_PhysicsEvent);
+
+
+
Modified: branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CControlBuffer.cpp
===================================================================
--- branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CControlBuffer.cpp 2015-07-02 14:12:43 UTC (rev 4892)
+++ branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CControlBuffer.cpp 2015-07-06 20:55:05 UTC (rev 4893)
@@ -1,7 +1,8 @@
#include "CControlBuffer.h"
#include <CRawBuffer.h>
-#include <BufferPtr.h>
+#include <Deserializer.h>
#include <stdexcept>
+#include <typeinfo>
namespace DAQ {
namespace V8 {
@@ -21,38 +22,38 @@
CControlBuffer::CControlBuffer(const CRawBuffer &rawBuf)
: m_header(rawBuf.getHeader()), m_title(), m_offset(), m_time()
{
- Buffer::BufferPtr<std::uint8_t> p8(rawBuf.getBuffer().begin(), m_header.mustSwap());
+ Buffer::Deserializer<Buffer::ByteBuffer> databuf(rawBuf.getBuffer(),
+ rawBuf.bufferNeedsSwap());
- p8 += 16*sizeof(std::uint16_t); // skip over buffer header
+ // skip header
+ std::uint16_t discard;
+ for (std::size_t i=0; i<16; ++i) databuf >> discard;
- // create the title
- setTitle(std::string(p8, p8+80));
+ // extract the title
+ uint8_t title[80];
+ databuf.extract(title, title+80);
+ m_title.assign(title, title+80);
- // skip over the title
- p8 += 80;
-
- // the next piece is a 32-bit integer, extract it
- Buffer::BufferPtr<std::uint32_t> p32(p8);
- m_offset = *p32++;
-
- // the remainder are all 16-bit words, create 16-bit pointer, and
- // extract the data
- Buffer::BufferPtr<std::uint16_t> p16(p32);
- m_time.month = *p16++;
- m_time.day = *p16++;
- m_time.year = *p16++;
- m_time.hours = *p16++;
- m_time.min = *p16++;
- m_time.sec = *p16++;
- m_time.tenths = *p16++;
+ databuf >> m_offset;
+ databuf >> m_time.month;
+ databuf >> m_time.day;
+ databuf >> m_time.year;
+ databuf >> m_time.hours;
+ databuf >> m_time.min;
+ databuf >> m_time.sec;
+ databuf >> m_time.tenths;
}
void CControlBuffer::toRawBuffer(CRawBuffer &buffer) const
{
+ bheader header = m_header;
+ header.nwds = 65;
+ header.nevt = 0;
+
Buffer::ByteBuffer tmpBuf;
- tmpBuf << m_header;
- tmpBuf << m_title; // need to accommodate the 80 character size
+ tmpBuf << header;
+ tmpBuf.insert(tmpBuf.end(), m_title.begin(), m_title.end());
tmpBuf << m_offset;
tmpBuf << m_time;
@@ -66,7 +67,7 @@
throw std::runtime_error("CControlBuffer::CControlBuffer() title cannot exceed 80 characters");
} else {
m_title = title;
- m_title.resize(80, '\0');
+ m_title.resize(80, ' ');
}
}
Modified: branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CControlBuffer.h
===================================================================
--- branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CControlBuffer.h 2015-07-02 14:12:43 UTC (rev 4892)
+++ branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CControlBuffer.h 2015-07-06 20:55:05 UTC (rev 4893)
@@ -28,7 +28,7 @@
bheader getHeader() const { return m_header; }
- BufferTypes type() const { return m_header.type; }
+ BufferTypes type() const { return BufferTypes(m_header.type); }
void toRawBuffer(CRawBuffer &buffer) const;
void setTitle(const std::string& title);
Modified: branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CPhysicsEventBuffer.cpp
===================================================================
--- branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CPhysicsEventBuffer.cpp 2015-07-02 14:12:43 UTC (rev 4892)
+++ branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CPhysicsEventBuffer.cpp 2015-07-06 20:55:05 UTC (rev 4893)
@@ -45,9 +45,11 @@
////////////////////////////////////////////////////////////////////////////
CPhysicsEventBuffer::CPhysicsEventBuffer(const bheader &header,
- const std::vector<std::uint16_t>& body)
+ const std::vector<std::uint16_t>& body,
+ bool mustSwap)
: m_header(header),
- m_body()
+ m_body(),
+ m_mustSwap(mustSwap)
{
Buffer::ByteBuffer buffer;
buffer << body;
@@ -56,7 +58,8 @@
CPhysicsEventBuffer::CPhysicsEventBuffer(const CRawBuffer &rawBuffer)
: m_header(rawBuffer.getHeader()),
- m_body()
+ m_body(),
+ m_mustSwap(rawBuffer.bufferNeedsSwap())
{
if (m_header.type != DATABF) {
std::string errmsg = "CPhysicsEventBuffer::CPhysicsEventBuffer(CRawBuffer const&) ";
@@ -110,8 +113,8 @@
Buffer::ByteBuffer::const_iterator end)
{
CStandardBodyParser parser;
- Buffer::BufferPtr<uint16_t> begPtr(beg, m_header.mustSwap());
- Buffer::BufferPtr<uint16_t> endPtr(end, m_header.mustSwap());
+ Buffer::BufferPtr<uint16_t> begPtr(beg, m_mustSwap);
+ Buffer::BufferPtr<uint16_t> endPtr(end, m_mustSwap);
m_body = parser(m_header.nevt, begPtr, endPtr);
}
@@ -140,12 +143,25 @@
return m_body.end();
}
+ // because I don't know how to properly swap the body of a physics event, I
+ // have to send the entire buffer back unswapped.
void CPhysicsEventBuffer::toRawBuffer(CRawBuffer &buffer) const
{
Buffer::ByteBuffer newbuf;
- newbuf << m_header;
+ bheader header = m_header;
+// std::uint16_t nShorts = 16; // size of bheader
+// for (auto& pEvent : m_body) {
+// nShorts += pEvent->getNTotalShorts();
+// }
+// header.nwds = nShorts;
+// header.nevt = m_body.size();
+ if (m_mustSwap) {
+ swapBytesOfHeaderInPlace(header);
+ }
+ newbuf << header;
+
for (auto& pEvent : m_body) {
newbuf << pEvent->getBuffer();
}
@@ -153,5 +169,24 @@
buffer.setBuffer(newbuf);
}
+
+ void CPhysicsEventBuffer::swapBytesOfHeaderInPlace(bheader &header) const
+ {
+ BO::swapBytes(header.nwds);
+ BO::swapBytes(header.type);
+ BO::swapBytes(header.cks);
+ BO::swapBytes(header.run);
+ BO::swapBytes(header.seq);
+ BO::swapBytes(header.nevt);
+ BO::swapBytes(header.nlam);
+ BO::swapBytes(header.cpu);
+ BO::swapBytes(header.nbit);
+ BO::swapBytes(header.buffmt);
+ BO::swapBytes(header.ssignature);
+ BO::swapBytes(header.lsignature);
+ BO::swapBytes(header.unused[0]);
+ BO::swapBytes(header.unused[1]);
+ }
+
} // namespace V8
} // namespace DAQ
Modified: branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CPhysicsEventBuffer.h
===================================================================
--- branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CPhysicsEventBuffer.h 2015-07-02 14:12:43 UTC (rev 4892)
+++ branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CPhysicsEventBuffer.h 2015-07-06 20:55:05 UTC (rev 4893)
@@ -60,6 +60,8 @@
Buffer::ByteBuffer& getBuffer() { return m_buffer;}
const Buffer::ByteBuffer& getBuffer() const { return m_buffer;}
+
+ bool dataNeedsSwap() const { return m_needsSwap; }
};
@@ -90,12 +92,14 @@
private:
bheader m_header;
Body m_body;
+ bool m_mustSwap;
public:
// Canonical methods
- CPhysicsEventBuffer() : m_header(), m_body() {}
+ CPhysicsEventBuffer() : m_header(), m_body(), m_mustSwap(false) {}
CPhysicsEventBuffer(const bheader& header,
- const std::vector<std::uint16_t>& body);
+ const std::vector<std::uint16_t>& body,
+ bool mustSwap=false);
CPhysicsEventBuffer(const CRawBuffer& rawBuffer);
CPhysicsEventBuffer(const CPhysicsEventBuffer& rhs);
@@ -123,6 +127,7 @@
Buffer::ByteBuffer::const_iterator end);
void parseStandardBody(Buffer::ByteBuffer::const_iterator beg,
Buffer::ByteBuffer::const_iterator end);
+ void swapBytesOfHeaderInPlace(bheader& header) const;
};
Modified: branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CRawBuffer.cpp
===================================================================
--- branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CRawBuffer.cpp 2015-07-02 14:12:43 UTC (rev 4892)
+++ branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CRawBuffer.cpp 2015-07-06 20:55:05 UTC (rev 4893)
@@ -1,5 +1,6 @@
#include "CRawBuffer.h"
#include <BufferPtr.h>
+#include <Deserializer.h>
namespace DAQ
{
@@ -8,7 +9,7 @@
CRawBuffer::CRawBuffer(size_t size)
- : m_parsedHeader(), m_unparsedBuffer()
+ : m_parsedHeader(), m_unparsedBuffer(), m_bytesNeededSwap(false)
{
m_unparsedBuffer.reserve(size);
}
@@ -18,10 +19,6 @@
return m_parsedHeader;
}
-//Buffer::ByteBuffer& CRawBuffer::getBuffer()
-//{ return m_unparsedBuffer; }
-
-
const Buffer::ByteBuffer& CRawBuffer::getBuffer() const
{ return m_unparsedBuffer; }
@@ -30,28 +27,19 @@
{
m_unparsedBuffer = buffer;
- Buffer::BufferPtr<uint16_t> p16(m_unparsedBuffer.begin(), false);
- Buffer::BufferPtr<uint32_t> p32 = p16;
+ // parse the header first assuming native byte orderig
+ parseHeader(buffer, false);
- m_parsedHeader.nwds = *p16++;
- m_parsedHeader.type = BufferTypes(*p16++);
- m_parsedHeader.cks = *p16++;
- m_parsedHeader.run = *p16++;
- p32 = p16++;
- m_parsedHeader.seq = *p32++;
- p16 = p32;
- m_parsedHeader.nevt = *p16++;
- m_parsedHeader.nlam = *p16++;
- m_parsedHeader.cpu = *p16++;
- m_parsedHeader.nbit = *p16++;
- m_parsedHeader.buffmt = BufferVersion(*p16++);
- m_parsedHeader.ssignature = *p16++;
- p32 = p16++;
- m_parsedHeader.lsignature = *p32++;
- p16 = p32;
- m_parsedHeader.unused[0] = *p16++;
- m_parsedHeader.unused[1] = *p16++;
+ // now ask whether it should have been swapped
+ if (m_parsedHeader.mustSwap()) {
+ // oops. bytes should have been swapped, flag this and reparse header
+ m_bytesNeededSwap = true;
+ parseHeader(buffer, true);
+
+ } else {
+ m_bytesNeededSwap = false;
+ }
}
void CRawBuffer::toRawBuffer(CRawBuffer &buffer) const
@@ -59,5 +47,29 @@
buffer.setBuffer(getBuffer());
}
+void CRawBuffer::parseHeader(const Buffer::ByteBuffer &buffer, bool swap)
+{
+ Buffer::Deserializer<Buffer::ByteBuffer> bufstream(buffer,
+ swap);
+
+ std::uint16_t tmp16;
+ bufstream >> m_parsedHeader.nwds;
+ bufstream >> tmp16;
+ m_parsedHeader.type = BufferTypes(tmp16);
+ bufstream >> m_parsedHeader.cks;
+ bufstream >> m_parsedHeader.run;
+ bufstream >> m_parsedHeader.seq;
+ bufstream >> m_parsedHeader.nevt;
+ bufstream >> m_parsedHeader.nlam;
+ bufstream >> m_parsedHeader.cpu;
+ bufstream >> m_parsedHeader.nbit;
+ bufstream >> tmp16;
+ m_parsedHeader.buffmt = BufferVersion(tmp16);
+ bufstream >> m_parsedHeader.ssignature;
+ bufstream >> m_parsedHeader.lsignature;
+ bufstream >> m_parsedHeader.unused[0];
+ bufstream >> m_parsedHeader.unused[1];
+}
+
} // end of V8
} // end of DAQ
Modified: branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CRawBuffer.h
===================================================================
--- branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CRawBuffer.h 2015-07-02 14:12:43 UTC (rev 4892)
+++ branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CRawBuffer.h 2015-07-06 20:55:05 UTC (rev 4893)
@@ -14,6 +14,7 @@
private:
bheader m_parsedHeader;
Buffer::ByteBuffer m_unparsedBuffer;
+ bool m_bytesNeededSwap;
public:
CRawBuffer(std::size_t size = gBufferSize);
@@ -22,10 +23,14 @@
BufferTypes type() const { return GENERIC; }
void toRawBuffer(CRawBuffer &buffer) const;
-// Buffer::ByteBuffer& getBuffer();
const Buffer::ByteBuffer& getBuffer() const;
void setBuffer(const Buffer::ByteBuffer& buffer);
+
+ bool bufferNeedsSwap() const { return m_bytesNeededSwap; }
+
+ private:
+ void parseHeader(const Buffer::ByteBuffer& buffer, bool swap);
};
} // end of V8
Modified: branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CScalerBuffer.cpp
===================================================================
--- branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CScalerBuffer.cpp 2015-07-02 14:12:43 UTC (rev 4892)
+++ branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CScalerBuffer.cpp 2015-07-06 20:55:05 UTC (rev 4893)
@@ -2,6 +2,7 @@
#include "CRawBuffer.h"
#include <ByteBuffer.h>
#include <BufferPtr.h>
+#include <Deserializer.h>
using namespace std;
@@ -27,32 +28,36 @@
throw std::runtime_error(errmsg);
}
- // need to skip over the 32-byte buffer header
- auto bodyBegin = rawBuffer.getBuffer().begin() + 16*sizeof(std::uint16_t);
- Buffer::BufferPtr<uint8_t> p8(bodyBegin, m_header.mustSwap());
+ Buffer::Deserializer<Buffer::ByteBuffer> buffer(rawBuffer.getBuffer(),
+ rawBuffer.bufferNeedsSwap());
- Buffer::BufferPtr<uint32_t> p32 = p8;
- m_offsetEnd = *p32;
- p8 += 10;
+ // skip the header b/c we obtained it from the RawBuffer already
+ uint16_t discard;
+ for (std::size_t i=0; i<16; ++i) buffer >> discard;
- p32 = p8;
- m_offsetBegin = *p32;
- p8 += 10;
+ buffer >> m_offsetEnd;
+ buffer >> discard;
+ buffer >> discard;
+ buffer >> discard;
+ buffer >> m_offsetBegin;
+ buffer >> discard;
+ buffer >> discard;
+ buffer >> discard;
- p32 = p8;
-
+ std::uint32_t value;
m_scalers.reserve(m_header.nevt);
for (std::size_t index=0; index<m_header.nevt; ++index) {
- m_scalers.push_back(*p32++);
+ buffer >> value;
+ m_scalers.push_back(value);
}
-
}
CScalerBuffer::CScalerBuffer(const bheader &header, std::uint32_t offsetBegin,
std::uint32_t offsetEnd,
const std::vector<uint32_t> &scalers)
- : m_header(header), m_offsetBegin(offsetBegin),
+ : m_header(header),
+ m_offsetBegin(offsetBegin),
m_offsetEnd(offsetEnd), m_scalers(scalers)
{}
@@ -64,6 +69,10 @@
{
vector<uint8_t> empty(6);
+ bheader header = m_header;
+ header.nwds = 16 + 6 + 2*m_scalers.size();
+ header.nevt = m_scalers.size();
+
Buffer::ByteBuffer newbuf;
newbuf << m_header;
newbuf << m_offsetEnd;
Modified: branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CStandardBodyParser.cpp
===================================================================
--- branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CStandardBodyParser.cpp 2015-07-02 14:12:43 UTC (rev 4892)
+++ branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CStandardBodyParser.cpp 2015-07-06 20:55:05 UTC (rev 4893)
@@ -13,7 +13,6 @@
{
vector<shared_ptr<CPhysicsEvent> > events;
-// while (beg != end) {
for (std::size_t index=0; (beg!=end) && (index<nEvents); ++index) {
auto result = parseOne(beg, end);
Modified: branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CTextBuffer.cpp
===================================================================
--- branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CTextBuffer.cpp 2015-07-02 14:12:43 UTC (rev 4892)
+++ branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CTextBuffer.cpp 2015-07-06 20:55:05 UTC (rev 4893)
@@ -21,11 +21,12 @@
{
validateTypeToConstructFrom(); // throws if bad
- std::uint16_t totalBytes = extractTotalBytes(rawBuf.getBuffer());
+ std::uint16_t totalShorts = extractTotalShorts(rawBuf.getBuffer(),
+ rawBuf.bufferNeedsSwap());
// locate beginning of body (i.e. skip the 16-word header)
- auto beg = rawBuf.getBuffer().begin() + 16*sizeof(std::uint16_t);
- auto deadEnd = beg + totalBytes;
+ auto beg = rawBuf.getBuffer().begin() + 16*sizeof(std::uint16_t);
+ auto deadEnd = beg + totalShorts*sizeof(std::uint16_t);
validateDeadEndMeaningful(deadEnd, rawBuf.getBuffer().end());
@@ -42,9 +43,14 @@
void CTextBuffer::toRawBuffer(CRawBuffer &buffer) const
{
+ // make sure that the number of words are correctly computed
+
+ bheader header = m_header;
+ header.nwds = 16+totalShorts();
+
Buffer::ByteBuffer buf;
- buf << m_header;
- buf << totalBytes();
+ buf << header;
+ buf << totalShorts();
for (auto& str : m_strings) {
buf << str.c_str();
}
@@ -52,20 +58,31 @@
buffer.setBuffer(buf);
}
- std::uint16_t CTextBuffer::totalBytes() const
+ std::uint16_t CTextBuffer::totalShorts() const
{
- std::uint16_t totalBytes = sizeof(std::uint16_t);
+ std::uint32_t nBytes = totalBytes();
+ return ((nBytes%2)==0) ? nBytes/2 : (nBytes+1)/2;
+ }
+
+ std::uint32_t CTextBuffer::totalBytes() const
+ {
+ std::uint32_t totalBytes = sizeof(std::uint16_t);
+
for (auto& element : m_strings) {
- totalBytes += element.size() + 1;
+ if ((element.size() % 2) == 0) {
+ totalBytes += element.size() + 2;
+ } else {
+ totalBytes += element.size() + 1;
+ }
}
return totalBytes;
}
-
- std::uint16_t CTextBuffer::extractTotalBytes(const Buffer::ByteBuffer &buffer) const
+
+ std::uint16_t CTextBuffer::extractTotalShorts(const Buffer::ByteBuffer &buffer, bool needsSwap) const
{
- Buffer::BufferPtr<std::uint16_t> pSize(buffer.begin(), m_header.mustSwap());
+ Buffer::BufferPtr<std::uint16_t> pSize(buffer.begin(), needsSwap);
pSize += 16; // skip over 16 shorts
return *pSize;
}
@@ -97,15 +114,32 @@
void CTextBuffer::parseStringsFromBuffer(Buffer::ByteBuffer::const_iterator beg,
Buffer::ByteBuffer::const_iterator end) {
+
+ auto origBeg = beg;
auto begEnd = beg;
- while (beg != end) {
-
+ // the +1 check is because the char padding skip can jump by 1 or 2
+ while ((beg != end) && (beg != end+1)) {
begEnd = std::find(beg, end, '\0');
m_strings.push_back(std::string(beg, begEnd));
- beg = begEnd+1;
+ beg = skipNullCharPadding(beg, begEnd);
}
}
- } // namespace V8
+
+ Buffer::ByteBuffer::const_iterator
+ CTextBuffer::skipNullCharPadding(Buffer::ByteBuffer::const_iterator beg,
+ Buffer::ByteBuffer::const_iterator begEnd)
+ {
+ Buffer::ByteBuffer::const_iterator startNextStr;
+ if ((std::distance(beg, begEnd)%2)==0) {
+ startNextStr = begEnd+2;
+ } else {
+ startNextStr = begEnd+1;
+ }
+
+ return startNextStr;
+ }
+
+ } // namespace V8
} // namespace DAQ
Modified: branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CTextBuffer.h
===================================================================
--- branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CTextBuffer.h 2015-07-02 14:12:43 UTC (rev 4892)
+++ branches/11.1-conversion-dev/utilities/format/NSCLDAQ8/CTextBuffer.h 2015-07-06 20:55:05 UTC (rev 4893)
@@ -29,21 +29,24 @@
~CTextBuffer() {}
bheader getHeader() const { return m_header; }
- BufferTypes type() const { return m_header.type; }
+ BufferTypes type() const { return BufferTypes(m_header.type); }
void toRawBuffer(CRawBuffer &buffer) const;
std::vector<std::string>& getStrings() {return m_strings; }
std::vector<std::string> getStrings() const { return m_strings; }
- std::uint16_t totalBytes() const;
+ std::uint32_t totalBytes() const;
+ std::uint16_t totalShorts() const;
private:
void validateTypeToConstructFrom();
void validateDeadEndMeaningful(Buffer::ByteBuffer::const_iterator deadEnd,
Buffer::ByteBuffer::const_iterator bufferEnd);
- std::uint16_t extractTotalBytes(const Buffer::ByteBuffer& buffer) const;
+ std::uint16_t extractTotalShorts(const Buffer::ByteBuffer& buffer, bool needsSwap) const;
void parseStringsFromBuffer(Buffer::ByteBuffer::const_iterator beg,
- Buffer::ByteBuffer::const_iterator end);
+ Buffer::ByteBuffer::const_iterator end);
+ Buffer::ByteBuffer::const_iterator skipNullCharPadding(Buffer::ByteBuffer...
[truncated message content] |