${TEST_DIR}/dpl/src/colors.cpp
${TEST_DIR}/dpl/src/errno_string.cpp
${TEST_DIR}/dpl/src/exception.cpp
- ${TEST_DIR}/dpl/src/noncopyable.cpp
${TEST_DIR}/dpl/src/singleton.cpp
${TEST_DIR}/dpl/src/test_results_collector.cpp
${TEST_DIR}/dpl/src/test_runner.cpp
#include <dpl/abstract_input_output.h>
#include <dpl/exception.h>
-#include <dpl/noncopyable.h>
#include <memory>
#include <list>
};
private:
- struct Bucket :
- private Noncopyable {
+ struct Bucket {
const void *buffer;
const void *ptr;
size_t size;
BufferDeleter deleter,
void *userParam);
virtual ~Bucket();
+
+ Bucket(const Bucket &) = delete;
+ Bucket &operator=(const Bucket &) = delete;
+ Bucket(Bucket &&) = delete;
+ Bucket &operator=(const Bucket &&) = delete;
};
typedef std::list<Bucket *> BucketList;
+++ /dev/null
-/*
- * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/*
- * @file noncopyable
- * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
- * @version 1.0
- * @brief This file is the implementation file of noncopyable
- */
-#ifndef DPL_NONCOPYABLE_H
-#define DPL_NONCOPYABLE_H
-
-namespace VcoreDPL {
-class Noncopyable {
-private:
- Noncopyable(const Noncopyable &);
- const Noncopyable &operator=(const Noncopyable &);
-
-public:
- Noncopyable();
- virtual ~Noncopyable();
-};
-} // namespace VcoreDPL
-
-#endif // DPL_NONCOPYABLE_H
#ifndef DPL_SCOPED_RESOURCE_H
#define DPL_SCOPED_RESOURCE_H
-#include <dpl/noncopyable.h>
-
namespace VcoreDPL {
+
template<typename ClassPolicy>
-class ScopedResource :
- private Noncopyable {
+class ScopedResource {
public:
typedef typename ClassPolicy::Type ValueType;
typedef ScopedResource<ClassPolicy> ThisType;
-protected:
- ValueType m_value;
-
-public:
explicit ScopedResource(ValueType value) : m_value(value) { }
-
~ScopedResource()
{
ClassPolicy::Destroy(m_value);
}
+ ScopedResource(const ScopedResource &) = delete;
+ ScopedResource &operator=(const ScopedResource &) = delete;
+ ScopedResource(ScopedResource &&) = delete;
+ ScopedResource &operator=(ScopedResource &&) = delete;
+
ValueType Get() const
{
return m_value;
{
return m_value == ClassPolicy::NullValue();
}
+
+protected:
+ ValueType m_value;
+
};
} // namespace VcoreDPL
#ifndef DPL_TEST_RESULTS_COLLECTOR_H
#define DPL_TEST_RESULTS_COLLECTOR_H
-#include <dpl/noncopyable.h>
#include <dpl/availability.h>
#include <vector>
#include <list>
typedef std::shared_ptr<TestResultsCollectorBase>
TestResultsCollectorBasePtr;
-class TestResultsCollectorBase :
- private VcoreDPL::Noncopyable {
+class TestResultsCollectorBase {
public:
typedef TestResultsCollectorBase *(*CollectorConstructorFunc)();
typedef std::list<std::string> TestCaseIdList;
};
};
- virtual ~TestResultsCollectorBase() {}
+ TestResultsCollectorBase() = default;
+ virtual ~TestResultsCollectorBase() = default;
+
+ TestResultsCollectorBase(const TestResultsCollectorBase &) = delete;
+ TestResultsCollectorBase &operator=(const TestResultsCollectorBase &) = delete;
+ TestResultsCollectorBase(TestResultsCollectorBase &&) = delete;
+ TestResultsCollectorBase &operator=(TestResultsCollectorBase &&) = delete;
virtual bool Configure()
{
namespace VcoreDPL {
namespace Test {
-class PipeWrapper : VcoreDPL::Noncopyable {
+class PipeWrapper {
public:
enum Usage {
READONLY,
};
PipeWrapper();
+ virtual ~PipeWrapper();
+
+ PipeWrapper (const PipeWrapper &) = delete;
+ PipeWrapper &operator=(const PipeWrapper &) = delete;
+ PipeWrapper (PipeWrapper &&) = delete;
+ PipeWrapper &operator=(PipeWrapper &&) = delete;
bool isReady();
void setUsage(Usage usage);
- virtual ~PipeWrapper();
Status send(int code, std::string &message);
+++ /dev/null
-/*
- * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/*
- * @file noncopyable.cpp
- * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
- * @version 1.0
- * @brief This file is the implementation file of noncopyable
- */
-#include <stddef.h>
-#include <dpl/noncopyable.h>
-
-namespace VcoreDPL {
-Noncopyable::Noncopyable()
-{}
-
-Noncopyable::~Noncopyable()
-{}
-} // namespace VcoreDPL
SET(VCORE_SOURCES
${VCORE_DIR}/dpl/core/src/assert.cpp
${VCORE_DIR}/dpl/core/src/exception.cpp
- ${VCORE_DIR}/dpl/core/src/noncopyable.cpp
${VCORE_DIR}/dpl/core/src/singleton.cpp
${VCORE_DIR}/dpl/core/src/colors.cpp
+++ /dev/null
-/*
- * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/*
- * @file noncopyable
- * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
- * @version 1.0
- * @brief This file is the implementation file of noncopyable
- */
-#ifndef DPL_NONCOPYABLE_H
-#define DPL_NONCOPYABLE_H
-
-namespace VcoreDPL {
-class Noncopyable {
-private:
- Noncopyable(const Noncopyable &);
- const Noncopyable &operator=(const Noncopyable &);
-
-public:
- Noncopyable();
- virtual ~Noncopyable();
-};
-} // namespace VcoreDPL
-
-#endif // DPL_NONCOPYABLE_H
+++ /dev/null
-/*
- * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/*
- * @file noncopyable.cpp
- * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
- * @version 1.0
- * @brief This file is the implementation file of noncopyable
- */
-#include <stddef.h>
-#include <dpl/noncopyable.h>
-
-namespace VcoreDPL {
-Noncopyable::Noncopyable()
-{}
-
-Noncopyable::~Noncopyable()
-{}
-} // namespace VcoreDPL
#include <string>
#include <dpl/singleton.h>
-#include <dpl/noncopyable.h>
#include <dpl/log/abstract_log_provider.h>
* To switch logs into old style, export
* DPL_USE_OLD_STYLE_LOGS before application start
*/
-class LogSystem : private Noncopyable {
+class LogSystem {
public:
LogSystem();
virtual ~LogSystem();
+ LogSystem(const LogSystem &) = delete;
+ LogSystem &operator=(const LogSystem &) = delete;
+ LogSystem(LogSystem &&) = delete;
+ LogSystem &operator=(LogSystem &&) = delete;
+
AbstractLogProvider::LogLevel GetLogLevel() const
{
return m_level;
_WRT_ENGINE_SRC_INSTALLER_CORE_VALIDATION_CORE_CERTIFICATEIDENTIFICATOR_H_
#include <map>
-#include <dpl/noncopyable.h>
#include <vcore/Certificate.h>
#include <vcore/CertStoreType.h>
namespace ValidationCore {
-class CertificateIdentifier : public VcoreDPL::Noncopyable {
+class CertificateIdentifier {
public:
typedef std::map<Certificate::Fingerprint, CertStoreId::Set> FingerPrintMap;
- CertificateIdentifier()
- {
- }
- ~CertificateIdentifier()
- {
- }
+ CertificateIdentifier() = default;
+ ~CertificateIdentifier() = default;
+
+ CertificateIdentifier(const CertificateIdentifier &) = delete;
+ CertificateIdentifier &operator=(const CertificateIdentifier &) = delete;
+ CertificateIdentifier(CertificateIdentifier &&) = delete;
+ CertificateIdentifier &operator=(CertificateIdentifier &&) = delete;
void add(const Certificate::Fingerprint &fingerprint,
CertStoreId::Type domain)
#include <dpl/assert.h>
#include <openssl/x509v3.h>
#include <dpl/log/log.h>
-#include <dpl/noncopyable.h>
#include <openssl/ecdsa.h>
#include <openssl/evp.h>
#include <string>
#include <string.h>
-#include <dpl/noncopyable.h>
#include <openssl/ssl.h>
#include <vcore/Certificate.h>
namespace ValidationCore {
-class CertificateLoader : public VcoreDPL::Noncopyable {
+class CertificateLoader {
public:
+ CertificateLoader() = default;
+ virtual ~CertificateLoader() = default;
+
+ CertificateLoader(const CertificateLoader &) = delete;
+ CertificateLoader &operator=(const CertificateLoader &) = delete;
+ CertificateLoader(CertificateLoader &&) = delete;
+ CertificateLoader &operator=(CertificateLoader &&) = delete;
+
class CertificateLoaderComparator {
public:
virtual bool compare(X509 *x509cert) = 0;
- virtual ~CertificateLoaderComparator()
- {
- }
+ virtual ~CertificateLoaderComparator() = default;
};
enum CertificateLoaderResult {
UNKNOWN_ERROR
};
- CertificateLoader()
- {
- }
-
- virtual ~CertificateLoader()
- {
- }
-
CertificateLoaderResult loadCertificate(const std::string &storage,
CertificateLoaderComparator *cmp);
*/
#pragma once
-#include <dpl/noncopyable.h>
#include <dpl/singleton.h>
namespace ValidationCore {
-class CryptoInit : public VcoreDPL::Noncopyable {
+class CryptoInit {
public:
CryptoInit();
virtual ~CryptoInit();
+
+ CryptoInit(const CryptoInit &) = delete;
+ CryptoInit &operator=(const CryptoInit &) = delete;
+ CryptoInit(CryptoInit &&) = delete;
+ CryptoInit &operator=(CryptoInit &&) = delete;
};
typedef VcoreDPL::Singleton<CryptoInit> CryptoInitSingleton;
#ifndef _VALIDATION_CORE_REFERENCEVALIDATOR_H_
#define _VALIDATION_CORE_REFERENCEVALIDATOR_H_
-#include <dpl/noncopyable.h>
-
#include <vcore/SignatureData.h>
namespace ValidationCore {
-class ReferenceValidator : VcoreDPL::Noncopyable {
+class ReferenceValidator {
public:
enum Result {
NO_ERROR = 0,
};
ReferenceValidator(const std::string &dirpath);
-
virtual ~ReferenceValidator();
+ ReferenceValidator(const ReferenceValidator &) = delete;
+ ReferenceValidator &operator=(const ReferenceValidator &) = delete;
+ ReferenceValidator(ReferenceValidator &&) = delete;
+ ReferenceValidator &operator=(ReferenceValidator &&) = delete;
+
Result checkReferences(const SignatureData &signatureData);
Result checkOutbound(const std::string &linkPath, const std::string &appPath);
#include <xmlsec/keysmngr.h>
#include <dpl/exception.h>
-#include <dpl/noncopyable.h>
#include <dpl/singleton.h>
#include <vcore/Certificate.h>
#include <vcore/SignatureData.h>
namespace ValidationCore {
-class XmlSec : public VcoreDPL::Noncopyable {
+class XmlSec {
+
public:
+ XmlSec();
+ virtual ~XmlSec();
+
+ XmlSec(const XmlSec &) = delete;
+ XmlSec &operator=(const XmlSec &) = delete;
+ XmlSec(XmlSec &&) = delete;
+ XmlSec &operator=(XmlSec &&) = delete;
+
struct XmlSecContext {
/* You _must_ set one of the value: certificatePath or certificate. */
XmlSecContext()
void validateNoHash(XmlSecContext &context);
void validatePartialHash(XmlSecContext &context, const std::list<std::string> &targetUri);
-protected:
- XmlSec();
- ~XmlSec();
-
private:
enum class ValidateMode : int {
NORMAL,
projects / platform / core / security / cert-svc.git / commitdiff