C++ DataChunk类代码示例

int WINAPI WinMain (
	__in HINSTANCE hInstance,
	__in_opt HINSTANCE hPrevInstance,
	__in LPSTR lpCmdLine,
	__in int nShowCmd
	)
{
	appPath = lpCmdLine;

#if 0
	DynamicMessageHelper file;
	if (file.Read("data\\TestAnimHandlers\\BinHandlers\\SpinXYZ,ffd",true))
	{
		ARMCore armTest;
		DataChunk memory;
		memory.Allocate(file.GetBufferSize());
		memcpy(memory.mData,file.GetBuffer(),file.GetBufferSize());
		armTest.WriteMemory(0x10000,file.GetBuffer(),file.GetBufferSize());

		// Get the frame code offset from the loaded handler
		unsigned int offset;
		file >> offset;
		armTest.SetPC(0x80000000 | 0x10000 + offset);
		armTest.SetRegister(0,6);
		armTest.Execute();
	}

Status
chunkDecode(DataChunk &result, const std::string &in)
{
    // The string must be a multiple of the chunk size:
    if (in.size() % Chars)
        return ABC_ERROR(ABC_CC_ParseError, "Bad encoding");

    DataChunk out;
    out.reserve(Bytes * (in.size() / Chars));

    constexpr unsigned shift = 8 * Bytes / Chars; // Bits per character
    uint16_t buffer = 0; // Bits waiting to be written out, MSB first
    int bits = 0; // Number of bits currently in the buffer
    auto i = in.begin();
    while (i != in.end())
    {
        // Read one character from the string:
        int value = Decode(*i);
        if (value < 0)
            break;
        ++i;

        // Append the bits to the buffer:
        buffer |= value << (16 - bits - shift);
        bits += shift;

        // Write out some bits if the buffer has a byte's worth:
        if (8 <= bits)
        {
            out.push_back(buffer >> 8);
            buffer <<= 8;
            bits -= 8;
        }
    }

void DataContainer::Allocate() {

	// Check that memory has not been allocated
	if (m_pAllocatedMemory != NULL) {
		_EXCEPTIONT("Attempting Allocate() on attached DataContainer");
	}

	// Allocate memory as one contiguous chunk
	size_t sTotalByteSize = GetTotalByteSize();

	m_pAllocatedMemory =
		reinterpret_cast<unsigned char*>(malloc(sTotalByteSize));

	if (m_pAllocatedMemory == NULL) {
		_EXCEPTIONT("Out of memory");
	}

	// Initialize allocated memory to zero
	memset(m_pAllocatedMemory, 0, sTotalByteSize);

	// Assign memory to DataChunks
	unsigned char * pAccumulated = m_pAllocatedMemory;

	for (size_t i = 0; i < m_vecDataChunks.size(); i++) {
		DataChunk * pDataChunk =
			reinterpret_cast<DataChunk*>(m_vecDataChunks[i]);

		pDataChunk->AttachToData(
			reinterpret_cast<void *>(pAccumulated));

#pragma message "Alignment may be an issue here on 32-bit systems"
		pAccumulated += pDataChunk->GetByteSize();
	}
}

void StreamDataTest::test_isValid()
{
    {
        // Use Case:
        // Stream Data invalid, no associated data
        // expect invalid
        StreamData sd("",(void*)0,10);
        CPPUNIT_ASSERT( ! sd.isValid() );
    }
    {
        // Use Case:
        // Stream Data valid, no associated data
        // expect valid
        StreamData sd("",(void*)1000,10);
        CPPUNIT_ASSERT( sd.isValid() );
    }
    {
        // Use Case:
        // Stream Data is valid, but associate Data is not
        // expect invalid
        DataChunk d;
        {
            StreamData sd("",(void*)1000,10);
            CPPUNIT_ASSERT( ! d.isValid() );
            CPPUNIT_ASSERT( sd.isValid() );
            boost::shared_ptr<DataChunk> ld( new DataChunk("test", &d) );
            sd.addAssociatedData( ld );
            CPPUNIT_ASSERT( ! sd.isValid() );
        }
    }
}

    static void* WorkerThreadLoop(void * workerThread) {

        WorkerThread* thread = static_cast<WorkerThread*>(workerThread);

        int sum = 0;

        unsigned t0 = clock();

        while(true) {
            // Get next task
            DataChunk data = thread->mDataSource->GetDataChunk();
            if(data.GetSize() == 0) break;

            // Execute task
            for(int i = 0; i < data.GetSize(); i++) {
                usleep(1000);
                sum += data[i];
            }
        }

        thread->mResultData->AddResult(sum);
        printf("%s: Thread is done:%d sum:%d time:%lu\n", __func__, thread->mTID, sum, clock() - t0);

        return NULL;
    }

/*! \param Offset Offset from the start of the KLV value from which to start reading
 *  \param Size Number of bytes to read, if -1 all available bytes will be read (which could be billions!)
 *  \return The number of bytes read
 *
 *  DRAGONS: This base function may be called from derived class objects to get base behaviour.
 *           It is therefore vital that the function does not call any "virtual" KLVObject
 *           functions, directly or indirectly.
 */
size_t KLVObject::Base_ReadDataFrom(DataChunk &Buffer, Position Offset, size_t Size /*=-1*/)
{
	// Delagate to ReadHandler if defined
	if(ReadHandler) return ReadHandler->ReadData(Buffer, this, Offset, Size);

	if(Source.Offset < 0)
	{
		error("Call to KLVObject::Base_ReadDataFrom() with no read handler defined and DataBase undefined\n");
		return 0;
	}

	if(!Source.File)
	{
		error("Call to KLVObject::Base_ReadDataFrom() with no read handler defined and source file not set\n");
		return 0;
	}

	// Initially plan to read all the bytes available
	Length BytesToRead = Source.OuterLength - Offset;

	// Limit to specified size if > 0 and if < available
	if( (Size > 0) && (Size < BytesToRead)) BytesToRead = Size;

	// Don't do anything if nothing to read
	if(BytesToRead <= 0) 
	{
		Buffer.Resize(0);
		return 0;
	}

	// Sanity check the size of this read
	if((sizeof(size_t) < 8) && (BytesToRead > 0xffffffff))
	{
		error("Tried to read > 4GBytes, but this platform can only handle <= 4GByte chunks\n");
		return 0;
	}

	// Seek to the start of the requested data
	Source.File->Seek(Source.Offset + Source.KLSize + Offset);

	// Resize the chunk
	// Discarding old data first (by setting Size to 0) prevents old data being 
	// copied needlessly if the buffer is reallocated to increase its size
	Buffer.Size = 0;
	Buffer.Resize(static_cast<size_t>(BytesToRead));

	// Read into the buffer (only as big as the buffer is!)
	size_t Bytes = Source.File->Read(Buffer.Data, Buffer.Size);

	// Resize the buffer if something odd happened (such as an early end-of-file)
	if(Bytes != static_cast<size_t>(BytesToRead)) Buffer.Resize(Bytes);

	return Bytes;
}

Status
randomData(DataChunk &result, size_t size)
{
    DataChunk out;
    out.resize(size);

    if (!RAND_bytes(out.data(), out.size()))
        return ABC_ERROR(ABC_CC_Error, "Random data generation failed");

    result = std::move(out);
    return Status();
}

DataChunk
buildData(std::initializer_list<DataSlice> slices)
{
    size_t size = 0;
    for (auto slice: slices)
        size += slice.size();

    DataChunk out;
    out.reserve(size);
    for (auto slice: slices)
        out.insert(out.end(), slice.begin(), slice.end());
    return out;
}

/*-----------------------------------------------------------------------------
  Append data to the SSL/TLS stream and handle packet framing.
-----------------------------------------------------------------------------*/
void SSLStream::Append(const DataChunk& chunk) {
  if (process_data_) {
    size_t len = chunk.GetLength();
    const char * buff = chunk.GetData();
  
    while (len && buff) {
      size_t copy_bytes = 0;

      // are we starting a new frame?
      if (message_size_ < 0) {
        // see if we can at least copy over the size of the initial frame
        size_t needed = sizeof(SSL_HEADER) - message_len_;
        copy_bytes = min(needed, len);
        if (copy_bytes) {
          memcpy(&message_[message_len_], buff, copy_bytes);
          message_len_ += (int)copy_bytes;
          len -= copy_bytes;
          buff += copy_bytes;
        }

        // see if we have a header to parse and get the actual message size
        if (message_len_ >= sizeof(SSL_HEADER)) {
          SSL_HEADER * header = (SSL_HEADER *)message_;
          message_size_ = htons(header->record_length) + sizeof(SSL_HEADER);
        }
      }

      // see if we have bytes remaining in the current message
      if (message_size_ > 0 &&
          message_len_ < message_size_ &&
          len > 0 &&
          buff) {
        copy_bytes = min(message_size_ - message_len_, (__int32)len);
        memcpy(&message_[message_len_], buff, copy_bytes);
        message_len_ += (int)copy_bytes;
        len -= copy_bytes;
        buff += copy_bytes;
      }

      // see if we have a full message
      if (message_size_ == message_len_) {
        ProcessMessage();

        // reset state for the next message
        message_size_ = -1;
        message_len_ = 0;
      }
    }
  }
}

TEST_F(testsDataChunk, DefaultConstructor) {
    DataChunk empty;
    EXPECT_TRUE(empty.isReferencing(NULL));
    EXPECT_TRUE(empty.getData() == NULL);
    EXPECT_TRUE(empty.getSize() == 0);
    DataChunk emptyRef;
    emptyRef.reference(empty);
    EXPECT_TRUE(emptyRef.isReferencing(NULL));
    EXPECT_TRUE(emptyRef.getData() == NULL);
    EXPECT_TRUE(emptyRef.getSize() == 0);
    EXPECT_TRUE(emptyRef == empty);
}

Status
watcherBridgeRawTx(Wallet &self, const char *szTxID,
    DataChunk &result)
{
    Watcher *watcher = nullptr;
    ABC_CHECK(watcherFind(watcher, self));

    bc::hash_digest txid;
    if (!bc::decode_hash(txid, szTxID))
        return ABC_ERROR(ABC_CC_ParseError, "Bad txid");
    auto tx = watcher->find_tx(txid);
    result.resize(satoshi_raw_size(tx));
    bc::satoshi_save(tx, result.begin());

    return Status();
}

void DataContainer::Detach() {

	for (size_t i = 0; i < m_vecDataChunks.size(); i++) {
		DataChunk * pDataChunk =
			reinterpret_cast<DataChunk *>(m_vecDataChunks[i]);

		pDataChunk->Detach();
	}

	if ((m_fOwnsData) && (m_pAllocatedMemory != NULL)) {
		free(m_pAllocatedMemory);
	}

	m_fOwnsData = true;
	m_pAllocatedMemory = NULL;
}

namespace testDataChunk {
const char* threadsBuffer = "Threads";
const int nbThreads = 50;

int makeDataChunks(const int nbLoop, DataChunk& output) {
    int ret = 0;
    for (int i = 0; i < nbLoop; i++) {
        DataChunk chunk(threadsBuffer);
        ret = chunk.toInt();
        EXPECT_TRUE(chunk.isReferencing(threadsBuffer));
        output.reference(chunk);
    }
    return ret;
}

static std::promise<int> promises[nbThreads];
static std::future<int> futures[nbThreads];

DataChunk sharedData;

void detach_threads() {
    const int nbDataChunk = 1000;
    for (int i = 0; i < nbThreads; i++) {
        promises[i] = std::promise<int>();
        futures[i] = promises[i].get_future();
        std::thread([](std::promise<int>& p) {p.set_value(makeDataChunks(nbDataChunk,sharedData));},
                std::ref(promises[i])).detach();
    }
}

void wait_futures() {
    for (int i = 0; i < nbThreads; i++) {
        futures[i].wait();
        ASSERT_TRUE(sharedData.isReferencing(threadsBuffer));
        ASSERT_TRUE(futures[i].get() == sharedData.toInt());
    }
}

class KeyValueNode {
    public:
        KeyValueNode(const DataChunk&& key, const DataChunk&& data) :
                key(std::move(key)), data(std::move(data)) {
        }

        const DataChunk& getKey() {
            return key;
        }
        const DataChunk& getData() {
            return data;
        }
        void setData(const DataChunk& d) {
            data.reference(d);
        }
    private:
        DataChunk key;
        DataChunk data;
};

} // namespace testDataChunk

size_t DataContainer::GetTotalByteSize() const {
	
	// Get the accumulated size of all DataChunks
	size_t sAccumulated = 0;

	for (size_t i = 0; i < m_vecDataChunks.size(); i++) {
		DataChunk * pDataChunk =
			reinterpret_cast<DataChunk*>(m_vecDataChunks[i]);

		// Verify byte alignment
		size_t sByteSize = pDataChunk->GetByteSize();
		if (sByteSize % sizeof(size_t) != 0) {
			_EXCEPTIONT("Misaligned array detected in DataContainer");
		}
		sAccumulated += sByteSize;
	}

	return sAccumulated;
}

void Compressor::apply(DataChunk& samples){
    switch( samples.getFormat()->bitsPerSample()/8){
        case 2:
            maxint =32767;break;
        case 1:
            maxint = 127;
            break;
    }
    b = (1.0-a2)*maxint;
    DiskreteEffect::apply(samples);
}