mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2025-12-21 14:07:08 +00:00
09f3f9b41a
The class NonCopyable is, like the name says, supposed to disallow
copying. But should it allow moving?
For a long time, NonCopyable used to not allow moving. (It declared
a deleted copy constructor and assigment operator without declaring
a move constructor and assignment operator, making the compiler
implicitly delete the move constructor and assignment operator.)
That's fine if the classes that inherit from NonCopyable don't need
to be movable or if writing the move constructor and assignment
operator by hand is fine, but that's not the case for all classes,
as I discovered when I was working on the DirectoryBlob PR.
Because of that, I decided to make NonCopyable movable in c7602cc,
allowing me to use NonCopyable in DirectoryBlob.h. That was however
an unfortunate decision, because some of the classes that inherit
from NonCopyable have incorrect behavior when moved by default-
generated move constructors and assignment operators, and do not
explicitly delete the move constructors and assignment operators,
relying on NonCopyable being non-movable.
So what can we do about this? There are four solutions that I can
think of:
1. Make NonCopyable non-movable and tell DirectoryBlob to suck it.
2. Keep allowing moving NonCopyable, and expect that classes that
don't support moving will delete the move constructor and
assignment operator manually. Not only is this inconsistent
(having classes disallow copying one way and disallow moving
another way), but deleting the move constructor and assignment
operator manually is too easy to forget compared to how tricky
the resulting problems are.
3. Have one "MovableNonCopyable" and one "NonMovableNonCopyable".
It works, but it feels rather silly...
4. Don't have a NonCopyable class at all. Considering that deleting
the copy constructor and assignment operator only takes two lines
of code, I don't see much of a reason to keep NonCopyable. I
suppose that there was more of a point in having NonCopyable back
in the pre-C++11 days, when it wasn't possible to use "= delete".
I decided to go with the fourth one (like the commit title says).
The implementation of the commit is fairly straight-forward, though
I would like to point out that I skipped adding "= delete" lines
for classes whose only reason for being uncopyable is that they
contain uncopyable classes like File::IOFile and std::unique_ptr,
because the compiler makes such classes uncopyable automatically.
75 lines
2.6 KiB
C++
75 lines
2.6 KiB
C++
// Copyright 2014 Dolphin Emulator Project
|
|
// Licensed under GPLv2+
|
|
// Refer to the license.txt file included.
|
|
|
|
#pragma once
|
|
|
|
#include <memory>
|
|
#include <string>
|
|
|
|
#include "Common/CommonTypes.h"
|
|
|
|
class PCAP;
|
|
|
|
namespace DSP
|
|
{
|
|
// An interface used to capture and log structured data about internal DSP
|
|
// data transfers.
|
|
//
|
|
// Note: these calls are done within the DSP emulator in critical paths and at
|
|
// a high frequency. Implementations must try and avoid blocking for too long.
|
|
class DSPCaptureLogger
|
|
{
|
|
public:
|
|
virtual ~DSPCaptureLogger() {}
|
|
// Accesses (reads or writes) to memory mapped registers (external
|
|
// interface, also known as IFX). These are always 16 bits accesses.
|
|
virtual void LogIFXRead(u16 address, u16 read_value) = 0;
|
|
virtual void LogIFXWrite(u16 address, u16 written_value) = 0;
|
|
|
|
// DMAs to/from main memory from/to DSP memory. We let the interpretation
|
|
// of the "control" field to the layer that analyze the logs and do not
|
|
// perform our own interpretation of it. Thus there is only one call which
|
|
// is used for DRAM/IRAM in any direction (to/from DSP).
|
|
//
|
|
// Length is expressed in bytes, not DSP words.
|
|
virtual void LogDMA(u16 control, u32 gc_address, u16 dsp_address, u16 length, const u8* data) = 0;
|
|
};
|
|
|
|
// A dummy implementation of a capture logger that does nothing. This is the
|
|
// default implementation used by the DSP emulator.
|
|
//
|
|
// Can also be inherited from if you want to only override part of the methods.
|
|
class DefaultDSPCaptureLogger : public DSPCaptureLogger
|
|
{
|
|
public:
|
|
void LogIFXRead(u16 address, u16 read_value) override {}
|
|
void LogIFXWrite(u16 address, u16 written_value) override {}
|
|
void LogDMA(u16 control, u32 gc_address, u16 dsp_address, u16 length, const u8* data) override {}
|
|
};
|
|
|
|
// A capture logger implementation that logs to PCAP files in a custom
|
|
// packet-based format.
|
|
class PCAPDSPCaptureLogger final : public DSPCaptureLogger
|
|
{
|
|
public:
|
|
// Automatically creates a writeable file (truncate existing file).
|
|
PCAPDSPCaptureLogger(const std::string& pcap_filename);
|
|
// Takes ownership of pcap.
|
|
PCAPDSPCaptureLogger(PCAP* pcap);
|
|
PCAPDSPCaptureLogger(std::unique_ptr<PCAP>&& pcap);
|
|
|
|
void LogIFXRead(u16 address, u16 read_value) override { LogIFXAccess(true, address, read_value); }
|
|
void LogIFXWrite(u16 address, u16 written_value) override
|
|
{
|
|
LogIFXAccess(false, address, written_value);
|
|
}
|
|
void LogDMA(u16 control, u32 gc_address, u16 dsp_address, u16 length, const u8* data) override;
|
|
|
|
private:
|
|
void LogIFXAccess(bool read, u16 address, u16 value);
|
|
|
|
std::unique_ptr<PCAP> m_pcap;
|
|
};
|
|
} // namespace DSP
|