class ApiInterface {
public:
ApiInterface() = default;
- virtual ~ApiInterface() = default;
+ virtual ~ApiInterface() {};
virtual int setPolicies(const std::map<PolicyBucketId, std::vector<Policy>> &insertOrUpdate,
const std::map<PolicyBucketId, std::vector<PolicyKey>> &remove) noexcept = 0;
public:
Logic();
- virtual ~Logic() = default;
+ virtual ~Logic() {};
virtual int setPolicies(const std::map<PolicyBucketId, std::vector<Policy>> &insertOrUpdate,
const std::map<PolicyBucketId, std::vector<PolicyKey>> &remove) noexcept;
class ApiInterface {
public:
ApiInterface() = default;
- virtual ~ApiInterface() = default;
+ virtual ~ApiInterface() {};
virtual int check(const std::string &client, const std::string &session,
const std::string &user, const std::string &privilege) = 0;
class ResultGetterInterface {
public:
virtual int requestResult(const PolicyKey &key, PolicyResult &result) noexcept = 0;
- virtual ~ResultGetterInterface() = default;
+ virtual ~ResultGetterInterface() {};
};
class InterpreterInterface {
virtual bool isUsable(const PolicyResult &result) noexcept = 0;
virtual int toResult(const PolicyResult &result) noexcept = 0;
- virtual ~InterpreterInterface() = default;
+ virtual ~InterpreterInterface() {};
};
class PluginCache {
m_plugins.clear();
}
- virtual ~PluginCache() = default;
+ virtual ~PluginCache() {};
protected:
std::map<PolicyType, InterpreterInterfacePtr> m_plugins;
public:
Logic();
- virtual ~Logic() = default;
+ virtual ~Logic() {};
virtual int check(const std::string &client, const std::string &session,
const std::string &user, const std::string &privilege) noexcept;
class BucketDeserializationException : public DatabaseException {
public:
BucketDeserializationException(const PolicyBucketId &bucketId) : m_bucketId(bucketId) {}
+ ~BucketDeserializationException() noexcept {};
const std::string message(void) const {
if (m_message.empty()) {
public:
BucketNotExistsException() = delete;
BucketNotExistsException(const PolicyBucketId &bucketId) : m_bucketId(bucketId) {}
- virtual ~BucketNotExistsException() = default;
+ virtual ~BucketNotExistsException() noexcept {};
virtual const std::string message(void) const {
return "BucketNotExistsException";
class BucketRecordCorruptedException : public Exception {
public:
BucketRecordCorruptedException(void) = delete;
- virtual ~BucketRecordCorruptedException(void) = default;
+ virtual ~BucketRecordCorruptedException() noexcept {};
BucketRecordCorruptedException(const std::string &line)
: m_lineNumber(0), m_line(line) {}
class BucketSerializationException : public DatabaseException {
public:
BucketSerializationException(const PolicyBucketId &bucketId) : m_bucketId(bucketId) {}
+ ~BucketSerializationException() noexcept {};
const std::string message(void) const {
if (m_message.empty()) {
class CannotCreateFileException : public DatabaseException {
public:
CannotCreateFileException(const std::string &filename) : m_filename(filename) {};
- virtual ~CannotCreateFileException() = default;
+ virtual ~CannotCreateFileException() noexcept {};
const std::string message(void) const {
if (m_message.empty()) {
class DefaultBucketDeletionException : public Exception {
public:
DefaultBucketDeletionException() = default;
- virtual ~DefaultBucketDeletionException() = default;
+ virtual ~DefaultBucketDeletionException() noexcept {};
virtual const std::string message(void) const {
return "DefaultBucketDeletionException";
m_whatMsg = stream.str();
}
- virtual ~DescriptorNotExistsException() = default;
+ virtual ~DescriptorNotExistsException() noexcept {};
virtual const std::string message(void) const {
return m_whatMsg;
m_backtrace = Backtrace::getBacktrace();
}
- virtual ~Exception() = default;
+ virtual ~Exception() noexcept {};
virtual const char *what(void) const noexcept {
if(m_whatMessage.empty()) {
class FileNotFoundException : public DatabaseException {
public:
FileNotFoundException(const std::string &filename) : m_filename(filename) {};
- virtual ~FileNotFoundException() = default;
+ virtual ~FileNotFoundException() noexcept {};
const std::string message(void) const {
if (m_message.empty()) {
class InitException : public Exception {
public:
InitException() = default;
- virtual ~InitException() = default;
+ virtual ~InitException() noexcept {};
virtual const std::string message(void) const {
return "InitException";
}
- virtual ~InvalidProtocolException() = default;
+ virtual ~InvalidProtocolException() noexcept {};
virtual const std::string message(void) const {
return m_whatMessage;
class NotImplementedException : public Exception {
public:
NotImplementedException() = default;
- virtual ~NotImplementedException() = default;
+ virtual ~NotImplementedException() noexcept {};
virtual const std::string message(void) const {
return "NotImplementedException";
+ std::string(">");
}
- virtual ~NullPointerException() = default;
+ virtual ~NullPointerException() noexcept {};
virtual const std::string message(void) const {
return m_whatMsg;
m_whatMsg = stream.str();
}
- virtual ~OutOfDataException() = default;
+ virtual ~OutOfDataException() noexcept {};
virtual const std::string message(void) const {
return m_whatMsg;
m_whatMessage = stream.str();
}
- virtual ~PluginNotFoundException() = default;
+ virtual ~PluginNotFoundException() noexcept {};
virtual const std::string message(void) const {
return m_whatMessage;
class ServerConnectionErrorException : public Exception {
public:
ServerConnectionErrorException() = default;
- virtual ~ServerConnectionErrorException() = default;
+ virtual ~ServerConnectionErrorException() noexcept {};
virtual const std::string message(void) const {
return "ServerConnectionError";
}
m_whatMessage = stream.str();
}
- virtual ~UnexpectedErrorException() = default;
+ virtual ~UnexpectedErrorException() noexcept {};
virtual const std::string message(void) const {
return m_whatMessage;
class Protocol : public RequestTaker, public ResponseTaker {
public:
Protocol() = default;
- virtual ~Protocol() = default;
+ virtual ~Protocol() {};
virtual ProtocolPtr clone(void) = 0;
public:
ProtocolFrame(ProtocolFrameHeaderPtr frameHeader, BinaryQueuePtr headerContent);
- virtual ~ProtocolFrame() = default;
+ virtual ~ProtocolFrame() {};
ProtocolFrameHeaderPtr frameHeader(void) {
return m_frameHeader;
public:
ProtocolFrameHeader(BinaryQueuePtr headerContent = nullptr);
- virtual ~ProtocolFrameHeader() = default;
+ virtual ~ProtocolFrameHeader() {};
virtual void read(size_t num, void *bytes);
virtual void write(size_t num, const void *bytes);
public:
virtual void read(size_t num, void *bytes) = 0;
virtual void write(size_t num, const void *bytes) = 0;
- virtual ~IStream() = default;
+ virtual ~IStream() {};
};
// Serializable interface
/* ISerializable(){};
* ISerializable(IStream&){}; */
virtual void serialize(IStream &) const = 0;
- virtual ~ISerializable() = default;
+ virtual ~ISerializable() {};
};
struct ProtocolSerialization {
Request(sequenceNumber), m_key(key) {
}
- virtual ~CheckRequest() = default;
+ virtual ~CheckRequest() {};
const PolicyKey &key(void) const {
return m_key;
Request(sequenceNumber), m_bucketId(bucketId), m_result(result) {
}
- virtual ~InsertOrUpdateBucketRequest() = default;
+ virtual ~InsertOrUpdateBucketRequest() {};
const PolicyBucketId &bucketId(void) const {
return m_bucketId;
: Request(sequenceNumber), m_bucketId(bucketId) {
}
- virtual ~RemoveBucketRequest() = default;
+ virtual ~RemoveBucketRequest() {};
const PolicyBucketId &bucketId(void) const {
return m_bucketId;
public:
Request(ProtocolFrameSequenceNumber sequenceNumber) : m_sequenceNumber(sequenceNumber) {
}
- virtual ~Request() = default;
+ virtual ~Request() {};
virtual void execute(RequestPtr self, RequestTakerPtr taker,
RequestContextPtr context) const = 0;
class RequestTaker {
public:
RequestTaker() = default;
- virtual ~RequestTaker() = default;
+ virtual ~RequestTaker() {};
virtual void execute(RequestContextPtr context, CheckRequestPtr request);
virtual void execute(RequestContextPtr context, InsertOrUpdateBucketRequestPtr request);
m_removePolicies(removePolicies) {
}
- virtual ~SetPoliciesRequest() = default;
+ virtual ~SetPoliciesRequest() {};
const std::map<PolicyBucketId, std::vector<Policy>> &policiesToBeInsertedOrUpdated(void) const {
return m_insertOrUpdatePolicies;
SignalRequest(struct signalfd_siginfo sigInfo) : Request(0), m_sigInfo(sigInfo) {
}
- virtual ~SignalRequest() = default;
+ virtual ~SignalRequest() {};
virtual void execute(RequestPtr self, RequestTakerPtr taker, RequestContextPtr context) const;
Response(sequenceNumber), m_resultRef(result) {
}
- virtual ~CheckResponse() = default;
+ virtual ~CheckResponse() {};
virtual void execute(ResponsePtr self, ResponseTakerPtr taker,
RequestContextPtr context) const;
Response(sequenceNumber), m_code(code) {
}
- virtual ~CodeResponse() = default;
+ virtual ~CodeResponse() {};
virtual void execute(ResponsePtr self, ResponseTakerPtr taker,
RequestContextPtr context) const;
public:
Response(ProtocolFrameSequenceNumber sequenceNumber) : m_sequenceNumber(sequenceNumber) {
};
- virtual ~Response() = default;
+ virtual ~Response() {};
virtual void execute(ResponsePtr self, ResponseTakerPtr taker,
RequestContextPtr context) const = 0;
class ResponseTaker {
public:
ResponseTaker() = default;
- virtual ~ResponseTaker() = default;
+ virtual ~ResponseTaker() {};
virtual void execute(RequestContextPtr context, CheckResponsePtr response);
virtual void execute(RequestContextPtr context, CodeResponsePtr response);
public:
SocketClient(const std::string &socketPath, ProtocolPtr protocol);
- virtual ~SocketClient() = default;
+ virtual ~SocketClient() {};
//returns pointer to response
// or nullptr when connection to cynara service is lost
public:
InMemoryStorageBackend(const std::string &path) : m_dbPath(path) {
}
- virtual ~InMemoryStorageBackend() = default;
+ virtual ~InMemoryStorageBackend() {};
virtual void load(void);
virtual void save(void);
BucketStreamOpener;
StorageSerializer(std::shared_ptr<std::ostream> os);
- virtual ~StorageSerializer() = default;
+ virtual ~StorageSerializer() {};
virtual void dump(const Buckets &buckets,
BucketStreamOpener streamOpener);
class BucketDeserializerFixture : public ::testing::Test {
public:
- virtual ~BucketDeserializerFixture() = default;
+ virtual ~BucketDeserializerFixture() {};
PolicyPtr createPolicy(const PolicyKey &pk, const PolicyResult &pr) {
return std::make_shared<Policy>(pk, pr);
class StorageSerializerFixture : public ::testing::Test {
public:
- virtual ~StorageSerializerFixture() = default;
+ virtual ~StorageSerializerFixture() {};
Cynara::Buckets buckets;
FakeStreamForBucketId fakeStreamOpener;