return (*(pfilefunc->zfile_func64.zopen64_file)) (pfilefunc->zfile_func64.opaque,filename,mode);
else
{
+ if (pfilefunc->zopen32_file == NULL)
+ return NULL;
return (*(pfilefunc->zopen32_file))(pfilefunc->zfile_func64.opaque,(const char*)filename,mode);
}
}
else
{
uLong offsetTruncated = (uLong)offset;
- if (offsetTruncated != offset)
+ if (offsetTruncated != offset || pfilefunc->zseek32_file == NULL)
return -1;
else
return (*(pfilefunc->zseek32_file))(pfilefunc->zfile_func64.opaque,filestream,offsetTruncated,origin);
return (*(pfilefunc->zfile_func64.ztell64_file)) (pfilefunc->zfile_func64.opaque,filestream);
else
{
+ if (pfilefunc->ztell32_file == NULL)
+ return (ZPOS64_T)-1;
uLong tell_uLong = (*(pfilefunc->ztell32_file))(pfilefunc->zfile_func64.opaque,filestream);
if ((tell_uLong) == ((uLong)-1))
return (ZPOS64_T)-1;
#ifdef unix
# include <unistd.h>
# include <utime.h>
+# include <sys/stat.h>
#else
# include <direct.h>
# include <io.h>
uInt size_buf;
unz_file_info64 file_info;
- uLong ratio=0;
err = unzGetCurrentFileInfo64(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0);
if (err!=UNZ_OK)
uLong i;
unz_global_info64 gi;
int err;
- FILE* fout=NULL;
err = unzGetGlobalInfo64(uf,&gi);
if (err!=UNZ_OK)
int opt_overwrite;
const char* password;
{
- int err = UNZ_OK;
if (unzLocateFile(uf,filename,CASESENSITIVITY)!=UNZ_OK)
{
printf("file %s not found in the zipfile\n",filename);
if(pFile != NULL)
{
- int n = fseeko64(pFile, 0, SEEK_END);
+ (void)fseeko64(pFile, 0, SEEK_END);
pos = ftello64(pFile);
((argv[i][1]>='0') || (argv[i][1]<='9'))) &&
(strlen(argv[i]) == 2)))
{
- FILE * fin;
+ FILE * fin = NULL;
int size_read;
const char* filenameinzip = argv[i];
const char *savefilenameinzip;
if (fpZip != NULL && fpOut != NULL) {
int entries = 0;
uLong totalBytes = 0;
- char header[30];
+ char header[30] = {0,};
char filename[256];
char extra[1024];
int offset = 0;
int is64bitOpenFunction)
{
unz64_s us;
- unz64_s *s;
+ memset(&us,0,sizeof(unz64_s));
+
+ unz64_s *s = NULL;
ZPOS64_T central_pos;
uLong uL;
{
zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def;
+ zlib_filefunc64_32_def_fill.zopen32_file = NULL;
zlib_filefunc64_32_def_fill.ztell32_file = NULL;
zlib_filefunc64_32_def_fill.zseek32_file = NULL;
return unzOpenInternal(path, &zlib_filefunc64_32_def_fill, 1);
{
zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def;
+ zlib_filefunc64_32_def_fill.zopen32_file = NULL;
zlib_filefunc64_32_def_fill.ztell32_file = NULL;
zlib_filefunc64_32_def_fill.zseek32_file = NULL;
return zipOpen3(pathname, append, globalcomment, &zlib_filefunc64_32_def_fill);
SET(TARGET_CUSTOM_HANDLER_DAO_RW_LIB "wrt-commons-custom-handler-dao-rw")
SET(TARGET_CUSTOM_HANDLER_DAO_RO_LIB "wrt-commons-custom-handler-dao-ro")
SET(TARGET_SECURITY_ORIGIN_DAO_LIB "wrt-commons-security-origin-dao")
+SET(TARGET_CERTIFICATE_DAO_LIB "wrt-commons-certificate-dao")
SET(TARGET_DPL_UTILS_EFL "lib${PROJECT_NAME}-utils-efl")
SET(TARGET_DPL_ENCRYPTION "lib${PROJECT_NAME}-encryption")
ADD_SUBDIRECTORY(utils)
ADD_SUBDIRECTORY(support)
ADD_SUBDIRECTORY(encryption)
+ADD_SUBDIRECTORY(certificate_dao)
# See the License for the specific language governing permissions and
# limitations under the License.
#
-# @file CMakeLists.txt
-# @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
-# @version 1.0
+# @file CMakeLists.txt
+# @author Leerang Song (leerang.song@samsung.com)
# @brief
#
-SET(TESTS_DPL_DIR "${TESTS_DIR}/dpl")
+configure_and_install_pkg(wrt-commons-certificate-dao.pc)
-ADD_SUBDIRECTORY(core)
-ADD_SUBDIRECTORY(db)
-ADD_SUBDIRECTORY(dbus)
-ADD_SUBDIRECTORY(event)
-#ADD_SUBDIRECTORY(localization) TODO localization mockups need to be fixed
-ADD_SUBDIRECTORY(utils)
--- /dev/null
+prefix=/usr
+exec_prefix=${prefix}
+
+libdir=${prefix}/lib
+includedir=${prefix}/include
+Name: wrt-commons-certificate-dao
+Description: wrt-commons-certificate-dao
+
+Version: @VERSION@
+Requires: dpl-efl
+Libs: -lwrt-commons-certificate-dao -L${libdir}
+Cflags: -I${includedir}/dpl-efl
${TARGET_DPL_EFL}
)
-TARGET_LINK_LIBRARIES(${TARGET_DPL_ENCRYPTION} -L./libs -lcal)
+TARGET_LINK_LIBRARIES(${TARGET_DPL_ENCRYPTION} "-ldukgenerator" )
+TARGET_LINK_LIBRARIES(${TARGET_DPL_ENCRYPTION} "-lcryptsvc" )
# Target library properties
SET_TARGET_PROPERTIES(${TARGET_DPL_ENCRYPTION} PROPERTIES
+wrt-commons (0.2.105) unstable; urgency=low
+
+ * Update unmerged source code
+ * app uri passing by localization
+ * Implement privilege for usermedia permission
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Thu, 14 Mar 2013 11:24:56 +0900
+
+wrt-commons (0.2.104) unstable; urgency=low
+
+ * Revert "Add encrypt/decrypt API from trust zone"
+
+ -- Soyoung Kim <sy037.kim@samsung.com> Mon, 11 Mar 2013 19:46:44 +0900
+
+wrt-commons (0.2.103) unstable; urgency=low
+
+ * Update tizen version to 2.1
+ * Replaced VARCHAR with TEXT in databases
+ * Path class for DPL + tests
+ * Implement certificate confirm popup
+ * Add encrypt/decrypt API from trust zone
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Fri, 08 Mar 2013 17:17:26 +0900
+
+wrt-commons (0.2.102) unstable; urgency=low
+
+ * DPL path join for class Path to be introduced
+ * tests - Return value not used
+ * Fix App-control Supports : Registration routine was added
+ * Remove web storage & filesystem usage code
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Thu, 07 Mar 2013 09:03:04 +0900
+
+wrt-commons (0.2.101) unstable; urgency=low
+
+ * CSP report only support
+
+ -- Jihoon Chung <jihoon.chung@samsung.com> Wed, 06 Mar 2013 19:22:11 +0900
+
+wrt-commons (0.2.100) unstable; urgency=low
+
+ * Prepare database for additional appservice parameter
+ * Enable DPL::Localization tests
+ * Fix warnings shown by cppcheck for wrt-commons
+
+ -- leerang <leerang.song@samsung.com> Thu, 28 Feb 2013 12:53:01 +0900
+
+wrt-commons (0.2.99) unstable; urgency=low
+
+ * Unused fields in WidgetRegisterInfo
+ * Implement tizen privilege for w3c API
+ * Renaming tests binaries
+ * Fixed buildrequires dukgenerator to dukgenerator-devel
+ * Modify to get encryption key requested by osp security team
+ * Localization tests move
+ * Compilation Warnings - Part 3
+
+ -- leerang <leerang.song@samsung.com> Fri, 22 Feb 2013 14:54:21 +0900
+
+wrt-commons (0.2.98) unstable; urgency=low
+
+ * wrt_commons_reset.sh fix
+ * User agent database update
+ * Compilation warnings. Deprecated code. Part 1
+ * Add function get appid from pkgid
+ * Source code formating unification
+ * Compilation warnings. Part 2
+ * Fix to test framework.
+ * DPL testcase description moved from wrt-extra
+
+ -- Soyoung Kim <sy037.kim@samsung.com> Fri, 08 Feb 2013 18:18:31 +0900
+
+wrt-commons (0.2.97) unstable; urgency=low
+
+ * Support for "process per testcase" framework.
+ * Prepare database to support CSP policy for whole widget.
+ * minizip prevent issues fixes
+
+ -- Tae-Jeong Lee <taejeong.lee@samsung.com> Wed, 06 Feb 2013 21:32:00 +0900
+
+wrt-commons (0.2.96) unstable; urgency=low
+
+ * Add specific fields to config parser struct for livebox
+
+ * Git : framework/web/wrt-commons
+ * Tag : wrt-commons_0.2.96
+
+ -- Yunchan Cho <yunchan.cho@samsung.com> Wed, 30 Jan 2013 17:09:01 +0900
+
+wrt-commons (0.2.95) unstable; urgency=low
+
+ * Change pkgname to appid and add package id PART 1.
+ * change pkgname to appid PART 2.
+ * Change pkgname to appid Part 3.
+
+ -- Soyoung Kim <sy037.kim@samsung.com> Mon, 28 Jan 2013 17:41:56 +0900
+
+wrt-commons (0.2.94) unstable; urgency=low
+
+ * Revert "Change pkgname to appid and add package id PART 1."
+ * Revert "change pkgname to appid PART 2."
+ * Fix build break in tests after API has been changed.
+
+ -- Tae-Jeong Lee <taejeong.lee@samsung.com> Fri, 25 Jan 2013 22:32:36 +0900
+
wrt-commons (0.2.93) unstable; urgency=low
- * Change DPL::WaitableHandleWatchSupport's destructor not to call DPL:Aassert explicitly.
+ * Changed PkgName type from Optional<String> to String PART 5
+ * Support for GCC 4.7
+ * Removing hard-coding in ORDER BY statement
+ * Fixing saving locale for each icon
+ * Singleton guard thread removal
+ * Change pkgname to appid and add package id PART 1.
+ * change pkgname to appid PART 2.
- -- Yunchan Cho <yunchan.cho@samsung.com> Sat, 02 Feb 2013 17:25:09 +0900
+ -- Soyoung Kim <sy037.kim@samsung.com> Thu, 24 Jan 2013 15:53:03 +0900
wrt-commons (0.2.92) unstable; urgency=low
if [ -f ${WRT_DB} ]
then
- PKG_NAME_SET=$(sqlite3 $WRT_DB 'select pkgname from WidgetInfo;')
- for pkgname in $PKG_NAME_SET
+ PKG_NAME_SET=$(sqlite3 $WRT_DB 'select tizen_appid from WidgetInfo;')
+ for appid in $PKG_NAME_SET
do
- rm -rf ${WIDGET_EXEC_PATH}${pkgname}
- widget_desktop_file="${WIDGET_DESKTOP_PATH}${pkgname}.desktop";
+ pkgId=`echo "$appid" | cut -f1 -d"."`
+ rm -rf ${WIDGET_EXEC_PATH}${pkgId}
+ widget_desktop_file="${WIDGET_DESKTOP_PATH}${appid}.desktop";
if [ -f ${widget_desktop_file} ]; then
rm -f $widget_desktop_file;
fi
}
public:
+ MyThread() :
+ m_rpcUnixClient(NULL),
+ m_rpcFakeClient(NULL),
+ m_connections(0),
+ m_sentData(0),
+ m_receivedData(0)
+ {}
+
virtual ~MyThread()
{
// Always quit thread
ADD_SUBDIRECTORY(auto_save_dao)
ADD_SUBDIRECTORY(security_origin_dao)
ADD_SUBDIRECTORY(custom_handler_dao)
+ADD_SUBDIRECTORY(certificate_dao)
include(utils/config.cmake)
include(localization/config.cmake)
include(support/config.cmake)
DPL::Mutex g_autoSaveDbQueriesMutex;
DPL::DB::ThreadDatabaseSupport Interface::m_autoSavedbInterface(
- AUTOSAVE_DB_DATABASE, AUTOSAVE_DB_FLAGS);
+ AUTOSAVE_DB_DATABASE, AUTOSAVE_DB_FLAGS);
using namespace AutoSaveDB::Interface;
namespace AutoSaveDB {
-
#define SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN Try
#define SQL_CONNECTION_EXCEPTION_HANDLER_END(message) \
AutoSaveDAO::AutoSaveDAO() :
AutoSaveDAOReadOnly()
-{
-}
+{}
AutoSaveDAO::~AutoSaveDAO()
-{
-}
+{}
void AutoSaveDAO::attachDatabaseRW(void)
{
m_autoSavedbInterface.DetachFromThread();
}
-void AutoSaveDAO::setAutoSaveSubmitFormData(const DPL::String &url,
- const SubmitFormData &submitFormData)
+void AutoSaveDAO::setAutoSaveSubmitFormData(
+ const DPL::String &url,
+ const SubmitFormData &
+ submitFormData)
{
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
}
#undef SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
#undef SQL_CONNECTION_EXCEPTION_HANDLER_END
-
} // namespace AutoSaveDB
using namespace DPL::DB::ORM::autosave;
using namespace AutoSaveDB::Interface;
-
namespace AutoSaveDB {
-
#define SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN Try
#define SQL_CONNECTION_EXCEPTION_HANDLER_END(message) \
}
AutoSaveDAOReadOnly::AutoSaveDAOReadOnly()
-{
-}
+{}
AutoSaveDAOReadOnly::~AutoSaveDAOReadOnly()
-{
-}
+{}
void AutoSaveDAOReadOnly::attachDatabaseRO(void)
{
{
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- AUTOSAVE_DB_SELECT(select, AutoSaveSubmitFormElement, &m_autoSavedbInterface);
+ AUTOSAVE_DB_SELECT(select,
+ AutoSaveSubmitFormElement,
+ &m_autoSavedbInterface);
select->Where(Equals<AutoSaveSubmitFormElement::address>(url));
AutoSaveSubmitFormElement::Select::RowList rows = select->GetRowList();
#undef SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
#undef SQL_CONNECTION_EXCEPTION_HANDLER_END
-
} // namespace AutoSaveDB
#include <wrt-commons/auto-save-dao/common_dao_types.h>
#include <dpl/log/log.h>
-namespace AutoSaveDB {
-} // namespace AutoSaveDB
+namespace AutoSaveDB {} // namespace AutoSaveDB
#include <wrt-commons/auto-save-dao/common_dao_types.h>
namespace AutoSaveDB {
-
class AutoSaveDAOReadOnly
{
public:
* This method gets Autofill for Webkit
*/
static SubmitFormData getAutoSaveSubmitFormData(
- const DPL::String &url);
-
+ const DPL::String &url);
};
-
} // namespace AutoSaveDB
#endif // _AUTO_SAVE_DAO_READ_ONLY_H_
#include <wrt-commons/auto-save-dao-ro/auto_save_dao_read_only.h>
namespace AutoSaveDB {
-
class AutoSaveDAO : public AutoSaveDAOReadOnly
{
public:
* This method sets Autofill for Webkit
*/
static void setAutoSaveSubmitFormData(
- const DPL::String& url, const SubmitFormData &submitFormData);
+ const DPL::String& url, const SubmitFormData &submitFormData);
};
-
} // namespace AutoSaveDB
#endif // _AUTO_SAVE_DAO_H_
extern DPL::Mutex g_autoSaveDbQueriesMutex;
#define AUTOSAVE_DB_INTERNAL(tlsCommand, InternalType, interface) \
- static DPL::ThreadLocalVariable<InternalType> *tlsCommand ## Ptr = NULL; \
+ static DPL::ThreadLocalVariable<InternalType> *tlsCommand##Ptr = NULL; \
{ \
DPL::Mutex::ScopedLock lock(&g_autoSaveDbQueriesMutex); \
- if (!tlsCommand ## Ptr) { \
+ if (!tlsCommand##Ptr) { \
static DPL::ThreadLocalVariable<InternalType> tmp; \
- tlsCommand ## Ptr = &tmp; \
+ tlsCommand##Ptr = &tmp; \
} \
} \
- DPL::ThreadLocalVariable<InternalType> &tlsCommand = *tlsCommand ## Ptr; \
+ DPL::ThreadLocalVariable<InternalType> &tlsCommand = *tlsCommand##Ptr; \
if (tlsCommand.IsNull()) { tlsCommand = InternalType(interface); }
#define AUTOSAVE_DB_SELECT(name, type, interface) \
namespace AutoSaveDB {
namespace Interface {
-
extern DPL::DB::ThreadDatabaseSupport m_autoSavedbInterface;
-
} // namespace Interface
} // namespace AutoSaveDB
#include <dpl/string.h>
namespace AutoSaveDB {
-
struct SubmitFormElement
{
DPL::String key;
DPL::String value;
SubmitFormElement()
- {
- }
+ {}
SubmitFormElement(
const DPL::String& keyData,
const DPL::String& valueData) :
key(keyData),
value(valueData)
- {
- }
+ {}
bool operator== (const SubmitFormElement& other) const
{
return (!DPL::StringCompare(key, other.key) &&
- !DPL::StringCompare(value, other.value));
+ !DPL::StringCompare(value, other.value));
}
bool operator!= (const SubmitFormElement& other) const
}
};
typedef std::list<SubmitFormElement> SubmitFormData;
-
} // namespace AutoSaveDB
#endif /* SHARE_COMMON_DAO_TYPES_H_ */
--- /dev/null
+SET(TARGET_CERTIFICATE_DAO_DB "Sqlite3DbCertificate")
+
+ADD_CUSTOM_COMMAND( OUTPUT .certificate.db
+ COMMAND rm -f ${CMAKE_CURRENT_BINARY_DIR}/.certificate.db
+ COMMAND gcc -Wall -I${PROJECT_SOURCE_DIR}/modules/db/include -I${PROJECT_SOURCE_DIR}/modules/certificate_dao/orm -E ${PROJECT_SOURCE_DIR}/modules/certificate_dao/orm/certificate_db_sql_generator.h | grep --invert-match "^#" > ${CMAKE_CURRENT_BINARY_DIR}/certificate_db.sql
+ COMMAND sqlite3 ${CMAKE_CURRENT_BINARY_DIR}/.certificate.db ".read ${CMAKE_CURRENT_BINARY_DIR}/certificate_db.sql" || rm -f ${CMAKE_CURRENT_BINARY_DIR}/.certificate.db
+ DEPENDS ${PROJECT_SOURCE_DIR}/modules/certificate_dao/orm/certificate_db_sql_generator.h ${PROJECT_SOURCE_DIR}/modules/certificate_dao/orm/certificate_db
+ )
+
+ADD_CUSTOM_COMMAND( OUTPUT .certificate.db-journal
+ COMMAND touch
+ ARGS ${CMAKE_CURRENT_BINARY_DIR}/.certificate.db-journal
+ )
+
+ADD_CUSTOM_TARGET(${TARGET_CERTIFICATE_DAO_DB} ALL DEPENDS .certificate.db .certificate.db-journal)
+INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/certificate_db.sql DESTINATION share/wrt-engine/)
+
+###############################################################################
+
+INCLUDE(FindPkgConfig)
+
+PKG_CHECK_MODULES(CERTIFICATE_DAO_DEPS
+ glib-2.0
+ REQUIRED)
+
+SET(CERTIFICATE_DAO_INCLUDE_DIRS
+ ${PROJECT_SOURCE_DIR}/modules/certificate_dao/include
+ ${PROJECT_SOURCE_DIR}/modules/certificate_dao/orm
+ ${PROJECT_SOURCE_DIR}/modules/core/include
+ ${PROJECT_SOURCE_DIR}/modules/db/include
+ ${PROJECT_SOURCE_DIR}/modules/log/include
+ ${PROJECT_SOURCE_DIR}/modules/widget_dao/include
+)
+
+SET(CERTIFICATE_DAO_SOURCES
+ dao/certificate_dao_types.cpp
+ dao/certificate_dao.cpp
+ dao/certificate_database.cpp
+)
+
+INCLUDE_DIRECTORIES(SYSTEM ${CERTIFICATE_DAO_DEPS_INCLUDE_DIRS} )
+INCLUDE_DIRECTORIES(${CERTIFICATE_DAO_INCLUDE_DIRS})
+
+ADD_LIBRARY(${TARGET_CERTIFICATE_DAO_LIB} SHARED ${CERTIFICATE_DAO_SOURCES})
+SET_TARGET_PROPERTIES(${TARGET_CERTIFICATE_DAO_LIB} PROPERTIES SOVERSION ${API_VERSION} VERSION ${VERSION})
+TARGET_LINK_LIBRARIES(${TARGET_CERTIFICATE_DAO_LIB} ${TARGET_DPL_EFL} ${TARGET_DPL_DB_EFL} ${TARGET_WRT_DAP_RO_LIB} ${CERTIFICATE_DAO_DEPS_LIBRARIES})
+ADD_DEPENDENCIES(${TARGET_CERTIFICATE_DAO_LIB} ${TARGET_CERTIFICATE_DAO_DB})
+
+INSTALL(TARGETS ${TARGET_CERTIFICATE_DAO_LIB} DESTINATION lib)
+
+INSTALL(FILES
+ include/wrt-commons/certificate-dao/certificate_dao_types.h
+ include/wrt-commons/certificate-dao/certificate_database.h
+ include/wrt-commons/certificate-dao/certificate_dao.h
+ DESTINATION include/dpl-efl/wrt-commons/certificate-dao
+)
+
--- /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 certificate_dao.cpp
+ * @author Leerang Song (leerang.song@samsung.com)
+ * @version 1.0
+ * @brief This file contains the definition of certificate dao class.
+ */
+
+#include <wrt-commons/certificate-dao/certificate_dao.h>
+#include <wrt-commons/certificate-dao/certificate_database.h>
+#include <wrt-commons/certificate-dao/certificate_dao_types.h>
+#include <orm_generator_certificate.h>
+#include <dpl/foreach.h>
+#include <dpl/wrt-dao-ro/widget_dao_read_only.h>
+#include <dpl/wrt-dao-ro/WrtDatabase.h>
+#include <dpl/wrt-dao-ro/widget_config.h>
+#include <dpl/wrt-dao-ro/global_config.h>
+#include <dpl/wrt-dao-ro/common_dao_types.h>
+#include <sys/stat.h>
+#include <fstream>
+
+using namespace DPL::DB::ORM;
+using namespace DPL::DB::ORM::certificate;
+
+namespace CertificateDB {
+#define SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN Try
+
+#define SQL_CONNECTION_EXCEPTION_HANDLER_END(message) \
+ Catch(DPL::DB::SqlConnection::Exception::Base) { \
+ LogError(message); \
+ ReThrowMsg(CertificateDAO::Exception::DatabaseError, \
+ message); \
+ }
+
+namespace {
+DPL::DB::SqlConnection::Flag::Option CERTIFICATE_DB_OPTION =
+ DPL::DB::SqlConnection::Flag::RW;
+DPL::DB::SqlConnection::Flag::Type CERTIFICATE_DB_TYPE =
+ DPL::DB::SqlConnection::Flag::UseLucene;
+const char* const CERTIFICATE_DB_NAME = ".certificate.db";
+const char* const CERTIFICATE_DB_SQL_PATH =
+ "/usr/share/wrt-engine/certificate_db.sql";
+const char* const CERTIFICATE_DATABASE_JOURNAL_FILENAME = "-journal";
+
+const int WEB_APPLICATION_UID = 5000;
+const int WEB_APPLICATION_GUID = 5000;
+
+std::string createDatabasePath(const WrtDB::WidgetPkgName &pkgName)
+{
+ std::stringstream filename;
+
+ filename << WrtDB::WidgetConfig::GetWidgetPersistentStoragePath(pkgName)
+ << "/"
+ << CERTIFICATE_DB_NAME;
+ return filename.str();
+}
+
+std::string createDatabasePath(int widgetHandle)
+{
+ using namespace DPL::DB::ORM;
+ using namespace WrtDB::WidgetConfig;
+ using namespace WrtDB::GlobalConfig;
+
+ WrtDB::TizenAppId appid;
+
+ Try
+ {
+ appid = WrtDB::WidgetDAOReadOnly::getTzAppId(widgetHandle);
+ }
+ Catch(DPL::DB::SqlConnection::Exception::Base) {
+ LogError("Failed to get database Path");
+ }
+ return createDatabasePath(appid);
+}
+
+void checkDatabase(std::string databasePath)
+{
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ if (databasePath.empty()) {
+ ThrowMsg(CertificateDAO::Exception::DatabaseError,
+ "Wrong database Path is passed");
+ }
+
+ struct stat buffer;
+ if (stat(databasePath.c_str(), &buffer) != 0) {
+ //Create fresh database
+ LogInfo("Creating database " << databasePath);
+
+ std::fstream file;
+ file.open(CERTIFICATE_DB_SQL_PATH, std::ios_base::in);
+ if (!file) {
+ ThrowMsg(CertificateDAO::Exception::DatabaseError,
+ "Fail to get database Path");
+ }
+
+ std::stringstream ssBuffer;
+ ssBuffer << file.rdbuf();
+
+ file.close();
+
+ DPL::DB::SqlConnection con(databasePath,
+ CERTIFICATE_DB_TYPE,
+ CERTIFICATE_DB_OPTION);
+ con.ExecCommand(ssBuffer.str().c_str());
+ }
+
+ if(chown(databasePath.c_str(),
+ WEB_APPLICATION_UID,
+ WEB_APPLICATION_GUID) != 0)
+ {
+ ThrowMsg(CertificateDAO::Exception::DatabaseError,
+ "Fail to change uid/guid");
+ }
+ std::string databaseJournal =
+ databasePath + CERTIFICATE_DATABASE_JOURNAL_FILENAME;
+ if(chown(databaseJournal.c_str(),
+ WEB_APPLICATION_UID,
+ WEB_APPLICATION_GUID) != 0)
+ {
+ ThrowMsg(CertificateDAO::Exception::DatabaseError,
+ "Fail to change uid/guid");
+ }
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Fail to get database Path")
+}
+}
+
+CertificateDAO::CertificateDAO(const WrtDB::WidgetPkgName &pkgName) :
+ m_certificateDBPath(createDatabasePath(pkgName)),
+ m_certificateDBInterface(m_certificateDBPath, CERTIFICATE_DB_TYPE)
+{
+ checkDatabase(m_certificateDBPath);
+ m_certificateDBInterface.AttachToThread(CERTIFICATE_DB_OPTION);
+}
+
+CertificateDAO::~CertificateDAO()
+{
+ m_certificateDBInterface.DetachFromThread();
+}
+
+CertificateDataList CertificateDAO::getCertificateDataList(void)
+{
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ CertificateDataList list;
+ CERTIFICATE_DB_SELECT(select,
+ CertificateInfo,
+ &m_certificateDBInterface);
+ typedef std::list<CertificateInfo::Row> RowList;
+ RowList rowList = select->GetRowList();
+
+ FOREACH(it, rowList) {
+ list.push_back(
+ CertificateDataPtr(
+ new CertificateData(it->Get_certificate())));
+ }
+ return list;
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get data list")
+}
+
+Result CertificateDAO::getResult(
+ const CertificateData &certificateData)
+{
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ CERTIFICATE_DB_SELECT(select,
+ CertificateInfo,
+ &m_certificateDBInterface);
+ select->Where(
+ Equals<CertificateInfo::certificate>(certificateData.certificate));
+ CertificateInfo::Select::RowList rows = select->GetRowList();
+
+ if (rows.empty()) {
+ return RESULT_UNKNOWN;
+ }
+ CertificateInfo::Row row = rows.front();
+ return static_cast<Result>(row.Get_result());
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END(
+ "Failed to get result for security certiInfo")
+}
+
+void CertificateDAO::setCertificateData(const CertificateData &certificateData,
+ const Result result)
+{
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ ScopedTransaction transaction(&m_certificateDBInterface);
+ CertificateInfo::Row row;
+ row.Set_certificate(certificateData.certificate);
+ row.Set_result(result);
+
+ if (true == hasResult(certificateData)) {
+ CERTIFICATE_DB_UPDATE(update,
+ CertificateInfo,
+ &m_certificateDBInterface);
+ update->Values(row);
+ update->Execute();
+ } else {
+ CERTIFICATE_DB_INSERT(insert,
+ CertificateInfo,
+ &m_certificateDBInterface);
+ insert->Values(row);
+ insert->Execute();
+ }
+ transaction.Commit();
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Fail to set security certiInfo data")
+}
+
+void CertificateDAO::removeCertificateData(
+ const CertificateData &certificateData)
+{
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ ScopedTransaction transaction(&m_certificateDBInterface);
+
+ if (true == hasResult(certificateData)) {
+ CERTIFICATE_DB_DELETE(del,
+ CertificateInfo,
+ &m_certificateDBInterface)
+ del->Where(
+ Equals<CertificateInfo::certificate>(certificateData.certificate));
+ del->Execute();
+ transaction.Commit();
+ }
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Fail to set certiInfo data")
+}
+
+void CertificateDAO::removeCertificateData(const Result result)
+{
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ ScopedTransaction transaction(&m_certificateDBInterface);
+ CERTIFICATE_DB_DELETE(del,
+ CertificateInfo,
+ &m_certificateDBInterface)
+ del->Where(Equals<CertificateInfo::result>(result));
+ del->Execute();
+ transaction.Commit();
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Fail to remove data by result")
+}
+
+bool CertificateDAO::hasResult(const CertificateData &certificateData)
+{
+ Result res = getResult(certificateData);
+ return (res != RESULT_UNKNOWN);
+}
+
+#undef SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+#undef SQL_CONNECTION_EXCEPTION_HANDLER_END
+} // namespace CertificateDB
--- /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 certificate_dao_types.cpp
+ * @author Leerang Song (leerang.song@samsung.com)
+ * @version 1.0
+ * @brief This file contains the implementation of
+ * common data types for certificate.db
+ */
+
+#include <wrt-commons/certificate-dao/certificate_dao_types.h>
+#include <dpl/log/log.h>
+
+namespace CertificateDB {
+
+} // namespace CertificateDB
--- /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.
+ */
+
+#include <wrt-commons/certificate-dao/certificate_database.h>
+
+DPL::Mutex g_certificateDBQueriesMutex;
--- /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 certificate_dao.h
+ * @author Leerang Song (leerang.song@samsung.com)
+ * @version 1.0
+ * @brief This file contains the declaration of certificate dao
+ */
+#ifndef _CERTIFICATE_DAO_H_
+#define _CERTIFICATE_DAO_H_
+
+#include <dpl/db/thread_database_support.h>
+#include <wrt-commons/certificate-dao/certificate_dao_types.h>
+#include <dpl/wrt-dao-ro/common_dao_types.h>
+
+namespace CertificateDB {
+class CertificateDAO
+{
+ public:
+ class Exception
+ {
+ public:
+ DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
+ DECLARE_EXCEPTION_TYPE(Base, DatabaseError)
+ DECLARE_EXCEPTION_TYPE(Base, DataNotExist)
+ };
+
+ explicit CertificateDAO(const WrtDB::WidgetPkgName &pkgName);
+ virtual ~CertificateDAO();
+ CertificateDataList getCertificateDataList();
+ Result getResult(const CertificateData &certificateData);
+ void setCertificateData(const CertificateData &certificateData,
+ const Result result);
+ void removeCertificateData(const CertificateData &certificateData);
+ void removeCertificateData(const Result result);
+
+ private:
+ std::string m_certificateDBPath;
+ DPL::DB::ThreadDatabaseSupport m_certificateDBInterface;
+ bool hasResult(const CertificateData &certificateData);
+};
+
+typedef std::shared_ptr<CertificateDAO> CertificateDAOPtr;
+} // namespace CertificateDB
+
+#endif // _CERTIFICATE_DAO_H_
\ No newline at end of file
--- /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 certificate_dao_types.h
+ * @author Leerang Song (leerang.song@samsung.com)
+ * @version 1.0
+ * @brief This file contains the declaration of
+ * common data types for certificate database.
+ */
+#ifndef _CERTIFICATE_DAO_TYPES_H_
+#define _CERTIFICATE_DAO_TYPES_H_
+
+#include <list>
+#include <memory>
+#include <dpl/string.h>
+
+namespace CertificateDB {
+
+enum Result
+{
+ RESULT_UNKNOWN = 0,
+ RESULT_ALLOW_ONCE,
+ RESULT_DENY_ONCE,
+ RESULT_ALLOW_ALWAYS,
+ RESULT_DENY_ALWAYS
+};
+
+struct CertificateData
+{
+ DPL::String certificate;
+
+ CertificateData(const DPL::String& certi) :
+ certificate(certi)
+ {}
+
+ bool operator== (const CertificateData& other) const
+ {
+ return !(certificate == other.certificate);
+ }
+
+ bool operator!= (const CertificateData& other) const
+ {
+ return !(*this == other);
+ }
+};
+
+typedef std::shared_ptr<CertificateData> CertificateDataPtr;
+typedef std::list<CertificateDataPtr> CertificateDataList;
+} // namespace CertificateDB
+
+#endif // _CERTIFICATE_DAO_TYPES_H_
\ No newline at end of file
--- /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.
+ */
+
+#ifndef _CERTIFICATE_DATABASE_H_
+#define _CERTIFICATE_DATABASE_H_
+
+#include <dpl/thread.h>
+#include <dpl/mutex.h>
+
+extern DPL::Mutex g_certificateDBQueriesMutex;
+
+#define CERTIFICATE_DB_INTERNAL(tlsCommand, InternalType, interface) \
+ static DPL::ThreadLocalVariable<InternalType> *tlsCommand##Ptr = NULL; \
+ { \
+ DPL::Mutex::ScopedLock lock(&g_certificateDBQueriesMutex); \
+ if (!tlsCommand##Ptr) { \
+ static DPL::ThreadLocalVariable<InternalType> tmp; \
+ tlsCommand##Ptr = &tmp; \
+ } \
+ } \
+ DPL::ThreadLocalVariable<InternalType> &tlsCommand = *tlsCommand##Ptr; \
+ if (tlsCommand.IsNull()) { tlsCommand = InternalType(interface); }
+
+#define CERTIFICATE_DB_SELECT(name, type, interface) \
+ CERTIFICATE_DB_INTERNAL(name, type::Select, interface)
+
+#define CERTIFICATE_DB_INSERT(name, type, interface) \
+ CERTIFICATE_DB_INTERNAL(name, type::Insert, interface)
+
+#define CERTIFICATE_DB_UPDATE(name, type, interface) \
+ CERTIFICATE_DB_INTERNAL(name, type::Update, interface)
+
+#define CERTIFICATE_DB_DELETE(name, type, interface) \
+ CERTIFICATE_DB_INTERNAL(name, type::Delete, interface)
+
+#endif // _CERTIFICATE_DATABASE_H_
+
--- /dev/null
+SQL(BEGIN TRANSACTION;)
+
+CREATE_TABLE(CertificateInfo)
+ COLUMN_NOT_NULL(certificate, TEXT,DEFAULT '')
+ COLUMN_NOT_NULL(result, INT, DEFAULT 0)
+ TABLE_CONSTRAINTS(PRIMARY KEY(certificate))
+CREATE_TABLE_END()
+
+SQL(COMMIT;)
--- /dev/null
+DATABASE_START(certificate)
+
+#include "certificate_db"
+
+DATABASE_END()
--- /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 certificate_db_sql_generator.h
+ * @author Leerang Song (leerang.song@samsung.com)
+ * @version 1.0
+ * @brief Macro definitions for generating the SQL
+ * input file from database definition.
+ */
+
+//Do not include this file directly! It is used only for SQL code generation.
+#include <dpl/db/orm_macros.h>
+
+#include "certificate_db_definitions"
--- /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.
+ */
+
+#ifndef _ORM_GENERATOR_CERTIFICATE_H_
+#define _ORM_GENERATOR_CERTIFICATE_H_
+
+#define ORM_GENERATOR_DATABASE_NAME certificate_db_definitions
+#include <dpl/db/orm_generator.h>
+#undef ORM_GENERATOR_DATABASE_NAME
+
+#endif // _ORM_GENERATOR_CERTIFICATE_H_
\ No newline at end of file
${PROJECT_SOURCE_DIR}/modules/core/src/once.cpp
${PROJECT_SOURCE_DIR}/modules/core/src/read_write_mutex.cpp
${PROJECT_SOURCE_DIR}/modules/core/src/recursive_mutex.cpp
+ ${PROJECT_SOURCE_DIR}/modules/core/src/scoped_dir.cpp
${PROJECT_SOURCE_DIR}/modules/core/src/serialization.cpp
${PROJECT_SOURCE_DIR}/modules/core/src/single_instance.cpp
${PROJECT_SOURCE_DIR}/modules/core/src/singleton.cpp
${PROJECT_SOURCE_DIR}/modules/core/include/dpl/scoped_resource.h
${PROJECT_SOURCE_DIR}/modules/core/include/dpl/scoped_array.h
${PROJECT_SOURCE_DIR}/modules/core/include/dpl/scoped_close.h
+ ${PROJECT_SOURCE_DIR}/modules/core/include/dpl/scoped_dir.h
${PROJECT_SOURCE_DIR}/modules/core/include/dpl/scoped_fclose.h
${PROJECT_SOURCE_DIR}/modules/core/include/dpl/scoped_free.h
${PROJECT_SOURCE_DIR}/modules/core/include/dpl/scoped_ptr.h
${PROJECT_SOURCE_DIR}/modules/core/include/dpl/singleton.h
${PROJECT_SOURCE_DIR}/modules/core/include/dpl/singleton_impl.h
${PROJECT_SOURCE_DIR}/modules/core/include/dpl/singleton_safe_impl.h
+ ${PROJECT_SOURCE_DIR}/modules/core/include/dpl/static_block.h
${PROJECT_SOURCE_DIR}/modules/core/include/dpl/string.h
${PROJECT_SOURCE_DIR}/modules/core/include/dpl/sstream.h
${PROJECT_SOURCE_DIR}/modules/core/include/dpl/task.h
#include <dpl/exception.h>
#include <memory>
-namespace DPL
-{
+namespace DPL {
class BinaryQueue;
typedef std::auto_ptr<BinaryQueue> BinaryQueueAutoPtr;
class AbstractInput
{
-public:
+ public:
class Exception
{
- public:
+ public:
DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, ReadFailed)
};
-public:
+ public:
virtual ~AbstractInput() {}
/**
#include <dpl/abstract_input.h>
#include <dpl/abstract_output.h>
-namespace DPL
+namespace DPL {
+class AbstractInputOutput :
+ public AbstractInput,
+ public AbstractOutput
{
-class AbstractInputOutput
- : public AbstractInput,
- public AbstractOutput
-{
-public:
+ public:
virtual ~AbstractInputOutput() {}
};
-
} // namespace DPL
#endif // DPL_ABSTRACT_INPUT_OUTPUT_H
#include <dpl/exception.h>
#include <memory>
-namespace DPL
-{
+namespace DPL {
class BinaryQueue;
typedef std::auto_ptr<BinaryQueue> BinaryQueueAutoPtr;
class AbstractOutput
{
-public:
+ public:
class Exception
{
- public:
+ public:
DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, WriteFailed)
};
-public:
+ public:
virtual ~AbstractOutput() {}
/**
*
* @param[in] buffer Input buffer with data to be written
* @param[in] bufferSize Maximum number of bytes to write from buffer
- * @return Number of bytes success successfuly written or zero if output is blocked
+ * @return Number of bytes success successfuly written or zero if output is
+ * blocked
* @throw WriteFailed
*/
virtual size_t Write(const BinaryQueue &buffer, size_t bufferSize) = 0;
#include <dpl/waitable_handle.h>
#include <dpl/abstract_input.h>
-namespace DPL
+namespace DPL {
+class AbstractWaitableInput :
+ public AbstractInput
{
-
-class AbstractWaitableInput
- : public AbstractInput
-{
-public:
+ public:
virtual ~AbstractWaitableInput() {}
virtual WaitableHandle WaitableReadHandle() const = 0;
};
-
} // namespace DPL
#endif // DPL_ABSTRACT_WAITABLE_INPUT_H
#include <dpl/waitable_event.h>
#include <dpl/abstract_input.h>
-namespace DPL
+namespace DPL {
+class AbstractWaitableInputAdapter :
+ public AbstractWaitableInput
{
-
-class AbstractWaitableInputAdapter
- : public AbstractWaitableInput
-{
-private:
+ private:
AbstractInput *m_input;
WaitableEvent m_waitableEvent;
-public:
+ public:
explicit AbstractWaitableInputAdapter(AbstractInput *input);
virtual BinaryQueueAutoPtr Read(size_t size);
virtual WaitableHandle WaitableReadHandle() const;
};
-
} // namespace DPL
#endif // DPL_ABSTRACT_WAITABLE_INPUT_ADAPTER_H
#include <dpl/abstract_waitable_input.h>
#include <dpl/abstract_waitable_output.h>
-namespace DPL
+namespace DPL {
+class AbstractWaitableInputOutput :
+ public AbstractWaitableInput,
+ public AbstractWaitableOutput
{
-
-class AbstractWaitableInputOutput
- : public AbstractWaitableInput,
- public AbstractWaitableOutput
-{
-public:
+ public:
virtual ~AbstractWaitableInputOutput() {}
};
-
} // namespace DPL
#endif // DPL_ABSTRACT_WAITABLE_INPUT_OUTPUT_H
#include <dpl/abstract_waitable_output_adapter.h>
#include <dpl/abstract_input_output.h>
-namespace DPL
+namespace DPL {
+class AbstractWaitableInputOutputAdapter :
+ public AbstractWaitableInputAdapter,
+ public AbstractWaitableOutputAdapter
{
-
-class AbstractWaitableInputOutputAdapter
- : public AbstractWaitableInputAdapter,
- public AbstractWaitableOutputAdapter
-{
-public:
- explicit AbstractWaitableInputOutputAdapter(AbstractInputOutput *inputOutput);
+ public:
+ explicit AbstractWaitableInputOutputAdapter(
+ AbstractInputOutput *inputOutput);
};
-
} // namespace DPL
#endif // DPL_ABSTRACT_WAITABLE_INPUT_OUTPUT_ADAPTER_H
#include <dpl/abstract_output.h>
#include <dpl/waitable_handle.h>
-namespace DPL
+namespace DPL {
+class AbstractWaitableOutput :
+ public AbstractOutput
{
-
-class AbstractWaitableOutput
- : public AbstractOutput
-{
-public:
+ public:
virtual ~AbstractWaitableOutput() {}
virtual WaitableHandle WaitableWriteHandle() const = 0;
};
-
} // namespace DPL
#endif // DPL_ABSTRACT_WAITABLE_OUTPUT_H
#include <dpl/waitable_event.h>
#include <dpl/abstract_output.h>
-namespace DPL
+namespace DPL {
+class AbstractWaitableOutputAdapter :
+ public AbstractWaitableOutput
{
-
-class AbstractWaitableOutputAdapter
- : public AbstractWaitableOutput
-{
-private:
+ private:
AbstractOutput *m_output;
WaitableEvent m_waitableEvent;
-public:
+ public:
explicit AbstractWaitableOutputAdapter(AbstractOutput *output);
virtual size_t Write(const BinaryQueue &buffer, size_t bufferSize);
virtual WaitableHandle WaitableWriteHandle() const;
};
-
} // namespace DPL
#endif // DPL_ABSTRACT_WAITABLE_OUTPUT_ADAPTER_H
#include <dpl/exception.h>
#include <string>
-namespace DPL
-{
+namespace DPL {
class Address
{
-public:
+ public:
class Exception
{
- public:
+ public:
DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, InvalidAddress)
};
-private:
+ private:
std::string m_address;
unsigned short m_port;
-public:
+ public:
Address();
Address(const std::string &address);
Address(const std::string &address, unsigned short port);
bool operator<(const Address &addr) const;
};
-
} // namespace DPL
#endif // DPL_ADDRESS_H
* @file aligned.h
* @author Lukasz Wrzosek (l.wrzosek@samsung.com)
* @version 1.0
- * @brief This file is the implementation file of aligned attribute from gcc
+ * @brief This file is the implementation file of aligned attribute from
+ * gcc
*/
#ifndef DPL_ALIGNED_H
#define DPL_ALIGNED_H
#include <dpl/atomic.h>
#include <string>
-namespace DPL
-{
+namespace DPL {
class Application
{
-public:
+ public:
class Exception
{
- public:
+ public:
DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, TooManyInstances)
DECLARE_EXCEPTION_TYPE(Base, FrameworkError)
};
-private:
+ private:
static int app_create(void *data);
static int app_terminate(void *data);
static int app_pause(void *data);
static int app_resume(void *data);
static int app_reset(bundle *b, void *data);
-protected:
+ protected:
int m_argc;
char **m_argv;
std::string m_applicationName;
virtual void OnLowBattery();
virtual void OnLanguageChanged();
-public:
- Application(int argc, char **argv, const std::string &applicationName, bool showMainWindow = true);
+ public:
+ Application(int argc,
+ char **argv,
+ const std::string &applicationName,
+ bool showMainWindow = true);
virtual ~Application();
/**
* @brief Execute application and start message processing
*/
virtual int Exec();
-
+
/*
* @brief Sends quit message to application message loop
*/
class ApplicationExt : public Application
{
-public:
- ApplicationExt(int argc, char **argv, const std::string &applicationName, bool showMainWindow = true);
+ public:
+ ApplicationExt(int argc,
+ char **argv,
+ const std::string &applicationName,
+ bool showMainWindow = true);
virtual ~ApplicationExt();
/**
* @brief Sends quit message to application message loop
*/
virtual void Quit();
-private:
+
+ private:
static DPL::Atomic m_useCount;
};
-
} // namespace DPL
#endif // DPL_APPLICATION_H
#include <tuple>
#include <utility>
-namespace DPL
-{
+namespace DPL {
enum class ExtraArgsInsertPolicy
{
/**
ArgsE && ... extra)
{
return _ApplyDispatchByPolicy<insertPolicy>::
- template Apply<Result>(op, t, std::forward<ArgsE>(extra) ...);
+
template Apply<Result>(op, t, std::forward<ArgsE>(extra) ...);
}
template<size_t N, size_t M>
Args && ... args)
{
return _ApplyTuple<N - 1, M>::
- template Apply<Result>(op,
- t1,
- t2,
- std::get<N - 1>(t1),
- std::forward<Args>(args) ...);
+ template Apply<Result>(op,
+ t1,
+ t2,
+ std::get<N - 1>(t1),
+
std::forward<Args>(args) ...);
}
};
Args && ... args)
{
return _ApplyTuple<0, M - 1>::
- template Apply<Result>(op,
- t1,
- t2,
- std::get<M - 1>(t2),
- std::forward<Args>(args) ...);
+ template Apply<Result>(op,
+ t1,
+ t2,
+ std::get<M - 1>(t2),
+
std::forward<Args>(args) ...);
}
};
typename ... ArgsT,
typename ... Args>
static Result Apply(Operation op,
- const std::tuple<ArgsT ...>& t,
- Args && ... args)
+
const std::tuple<ArgsT ...>& t,
+ Args && ... args)
{
return _ApplyArgs<N - 1>::
- template Apply<Result>(op,
- t,
- std::get<N - 1>(t),
-
std::forward<Args>(args) ...);
+ template Apply<Result>(op,
+ t,
+ std::get<N - 1>(t),
+ std::forward<Args>(args) ...);
}
};
ArgsE && ... extra)
{
return _ApplyArgs<sizeof ... (ArgsT)>::
- template Apply<Result>(op,
- t,
-
std::forward<ArgsE>(extra) ...);
+ template Apply<Result>(op,
+ t,
+ std::forward<ArgsE>(extra) ...);
}
};
ArgsE && ... extra)
{
return _ApplyTuple<sizeof ... (ArgsT), sizeof ... (ArgsE)>::
- template Apply<Result>(op,
- t,
- std::make_tuple(std::forward<ArgsE>(extra) ...));
+ template Apply<Result>(op,
+ t,
+ std::make_tuple(std::forward<ArgsE>(
+ extra) ...));
}
};
} // namespace DPL
#include <dpl/noreturn.h>
-namespace DPL
-{
+namespace DPL {
// Assertion handler procedure
// Do not call directly
// Always use Assert macro
-DPL_NORETURN void AssertProc(const char *condition, const char *file, int line, const char *function);
+DPL_NORETURN void AssertProc(const char *condition,
+ const char *file,
+ int line,
+ const char *function);
} // namespace DPL
-#define Assert(Condition) do { if (!(Condition)) DPL::AssertProc(#Condition, __FILE__, __LINE__, __FUNCTION__); } while (0)
+#define Assert(Condition) do { if (!(Condition)) { DPL::AssertProc(#Condition, \
+ __FILE__, \
+ __LINE__, \
+ __FUNCTION__); \
+ } } while (0)
#endif // DPL_ASSERT_H
#pragma GCC system_header
#include <glib.h>
-namespace DPL
-{
+namespace DPL {
class Atomic
{
-public:
+ public:
typedef gint ValueType;
-private:
+ private:
volatile ValueType m_value;
-public:
+ public:
Atomic(ValueType value = static_cast<ValueType>(0));
ValueType ExchangeAndAdd(ValueType value);
#define DECLARE_DELETER(type, function) \
template <> \
struct UniversalFree <type> { \
- void universal_free(type *ptr){ \
+ void universal_free(type * ptr){ \
if (ptr) { \
function(ptr); } \
} \
public:
AutoPtr(T *ptr) :
m_data(ptr)
- {
- }
+ {}
AutoPtr(const AutoPtr<T> &second)
{
#include <memory>
#include <list>
-namespace DPL
-{
+namespace DPL {
/**
* Binary stream implemented as constant size bucket list
*
* @todo Add optimized implementation for FlattenConsume
*/
-class BinaryQueue
- : public AbstractInputOutput
+class BinaryQueue :
+ public AbstractInputOutput
{
-public:
+ public:
class Exception
{
- public:
+ public:
DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, OutOfData)
};
- typedef void (*BufferDeleter)(const void *buffer, size_t bufferSize, void *userParam);
- static void BufferDeleterFree(const void *buffer, size_t bufferSize, void *userParam);
+ typedef void (*BufferDeleter)(const void *buffer, size_t bufferSize,
+ void *userParam);
+ static void BufferDeleterFree(const void *buffer,
+ size_t bufferSize,
+ void *userParam);
class BucketVisitor
{
- public:
+ public:
/**
* Destructor
*/
virtual void OnVisitBucket(const void *buffer, size_t bufferSize) = 0;
};
-private:
- struct Bucket
- : private Noncopyable
+ private:
+ struct Bucket :
+ private Noncopyable
{
const void *buffer;
const void *ptr;
BufferDeleter deleter;
void *param;
- Bucket(const void *buffer, size_t bufferSize, BufferDeleter deleter, void *userParam);
+ Bucket(const void *buffer,
+ size_t bufferSize,
+ BufferDeleter deleter,
+ void *userParam);
virtual ~Bucket();
};
class BucketVisitorCall
{
- private:
+ private:
BucketVisitor *m_visitor;
- public:
+ public:
BucketVisitorCall(BucketVisitor *visitor);
virtual ~BucketVisitorCall();
void operator()(Bucket *bucket) const;
};
-public:
+ public:
/**
* Construct empty binary queue
*/
* @return none
* @param[in] buffer Pointer to data buffer
* @param[in] bufferSize Number of bytes available in buffer
- * @param[in] deleter Pointer to deleter procedure used to free provided buffer
+ * @param[in] deleter Pointer to deleter procedure used to free provided
+ * buffer
* @param[in] userParam User parameter passed to deleter routine
* @exception std::bad_alloc Cannot allocate memory to hold additional data
*/
- void AppendUnmanaged(const void *buffer, size_t bufferSize, BufferDeleter deleter = &BinaryQueue::BufferDeleterFree, void *userParam = NULL);
+ void AppendUnmanaged(
+ const void *buffer,
+ size_t bufferSize,
+ BufferDeleter deleter =
+ &BinaryQueue::BufferDeleterFree,
+ void *userParam = NULL);
/**
* Append copy of other binary queue to the end of this binary queue
*
* @return none
- * @param[in] other Constant reference to other binary queue to copy data from
+ * @param[in] other Constant reference to other binary queue to copy data
+ * from
* @exception std::bad_alloc Cannot allocate memory to hold additional data
* @warning One cannot assume that bucket structure is preserved during copy
*/
* @file char_traits.h
* @author Piotr Marcinkiewicz (p.marcinkiew@samsung.com)
* @version 1.0
- * @brief Char traits are used to create basic_string extended with additional features
- * Current char traits could be extended in feature to boost performance
+ * @brief Char traits are used to create basic_string extended with
+ * additional features
+ * Current char traits could be extended in feature to boost
+ * performance
*/
#ifndef DPL_CHAR_TRAITS
#define DPL_CHAR_TRAITS
#include <algorithm>
#include <dpl/exception.h>
-namespace DPL
-{
-
+namespace DPL {
typedef std::char_traits<wchar_t> CharTraits;
-
} // namespace DPL
#endif // DPL_CHAR_TRAITS
#ifndef DPL_COLORS_H
#define DPL_COLORS_H
-namespace DPL
-{
-
-namespace Colors
-{
-
-namespace Text
-{
-
+namespace DPL {
+namespace Colors {
+namespace Text {
extern const char* BOLD_GREEN_BEGIN;
extern const char* BOLD_GREEN_END;
extern const char* PURPLE_BEGIN;
extern const char* BOLD_GOLD_END;
extern const char* BOLD_WHITE_BEGIN;
extern const char* BOLD_WHITE_END;
-
} //namespace Text
-namespace Html
-{
-
+namespace Html {
extern const char* BOLD_GREEN_BEGIN;
extern const char* BOLD_GREEN_END;
extern const char* PURPLE_BEGIN;
extern const char* BOLD_GOLD_END;
extern const char* BOLD_WHITE_BEGIN;
extern const char* BOLD_WHITE_END;
-
} //namespace Html
-
} //namespace Colors
-
} //namespace DPL
#endif /* DPL_COLORS_H */
#include <dpl/abstract_waitable_output.h>
#include <dpl/exception.h>
-namespace DPL
-{
+namespace DPL {
/**
* Copy failed exception
*/
*
* @param[in] input Abstract waitable input to copy from
* @param[in] output Abstract waitable output to copy to
- * @throw CopyFailed An error occurred while copying. Look into exception trace for details.
+ * @throw CopyFailed An error occurred while copying. Look into exception trace
+ * for details.
*/
void Copy(AbstractWaitableInput *input, AbstractWaitableOutput *output);
/**
- * Copy exactly totalBytes bytes abstract waitable input to abstract waitable output
+ * Copy exactly totalBytes bytes abstract waitable input to abstract waitable
+ * output
*
* @param[in] input Abstract waitable input to copy from
* @param[in] output Abstract waitable output to copy to
- * @throw CopyFailed An error occurred while copying. Look into exception trace for details.
+ * @throw CopyFailed An error occurred while copying. Look into exception trace
+ * for details.
*/
-void Copy(AbstractWaitableInput *input, AbstractWaitableOutput *output, size_t totalBytes);
+void Copy(AbstractWaitableInput *input,
+ AbstractWaitableOutput *output,
+ size_t totalBytes);
} // namespace DPL
#endif // DPL_COPY_H
#include <dpl/noncopyable.h>
#include <dpl/assert.h>
-namespace DPL
-{
+namespace DPL {
template<typename Class>
class EnableSharedFromThis : private Noncopyable
{
-
-private:
+ private:
// A weak pointer to shared counter
SharedCounter *m_counter;
Class *m_ptr;
-public:
+ public:
DPL::SharedPtr<Class> SharedFromThis()
{
Assert(m_counter != NULL && "Pointer is not shared!");
m_ptr = ptr;
}
- EnableSharedFromThis()
- : m_counter(NULL),
- m_ptr(NULL)
- {
- }
+ EnableSharedFromThis() :
+ m_counter(NULL),
+ m_ptr(NULL)
+ {}
virtual ~EnableSharedFromThis()
- {
- }
+ {}
};
} // namespace DPL
#include <string>
#include <cerrno>
-namespace DPL
-{
+namespace DPL {
DECLARE_EXCEPTION_TYPE(DPL::Exception, InvalidErrnoValue)
std::string GetErrnoString(int error = errno);
#include <cstdlib>
#include <sstream>
-namespace DPL
-{
+namespace DPL {
void LogUnhandledException(const std::string &str);
-void LogUnhandledException(const std::string &str, const char *filename, int line, const char *function);
+void LogUnhandledException(const std::string &str,
+ const char *filename,
+ int line,
+ const char *function);
}
-namespace DPL
-{
+namespace DPL {
class Exception
{
-private:
+ private:
static unsigned int m_exceptionCount;
static Exception* m_lastException;
static void (*m_terminateHandler)();
static void AddRef(Exception* exception)
{
- if (!m_exceptionCount)
- m_terminateHandler = std::set_terminate(&TerminateHandler);
+ if (!m_exceptionCount) {
+ m_terminateHandler = std::set_terminate(&TerminateHandler);
+ }
++m_exceptionCount;
m_lastException = exception;
static void UnRef(Exception* e)
{
- if (m_lastException == e)
+ if (m_lastException == e) {
m_lastException = NULL;
+ }
--m_exceptionCount;
- if (!m_exceptionCount)
- {
+ if (!m_exceptionCount) {
std::set_terminate(m_terminateHandler);
m_terminateHandler = NULL;
}
static void TerminateHandler()
{
- if (m_lastException != NULL)
- {
+ if (m_lastException != NULL) {
DisplayKnownException(*m_lastException);
abort();
- }
- else
- {
+ } else {
DisplayUnknownException();
abort();
}
std::string m_function;
int m_line;
-protected:
+ protected:
std::string m_message;
std::string m_className;
-public:
+ public:
static std::string KnownExceptionToString(const Exception &e)
{
std::ostringstream message;
- message << "\033[1;5;31m\n=== Unhandled DPL exception occurred ===\033[m\n\n";
+ message <<
+ "\033[1;5;31m\n=== Unhandled DPL exception occurred ===\033[m\n\n";
message << "\033[1;33mException trace:\033[m\n\n";
message << e.DumpToString();
message << "\033[1;31m\n=== Will now abort ===\033[m\n";
static std::string UnknownExceptionToString()
{
std::ostringstream message;
- message << "\033[1;5;31m\n=== Unhandled non-DPL exception occurred ===\033[m\n\n";
- message << "\033[1;31m\n=== Will now abort ===\033[m\n";
+ message <<
+ "\033[1;5;31m\n=== Unhandled non-DPL exception occurred ===\033[m\n\n";
+ message << "\033[1;31m\n=== Will now abort ===\033[m\n";
return message.str();
}
Exception(const Exception &other)
{
// Deep copy
- if (other.m_reason != NULL)
+ if (other.m_reason != NULL) {
m_reason = new Exception(*other.m_reason);
- else
+ } else {
m_reason = NULL;
+ }
m_message = other.m_message;
m_path = other.m_path;
const Exception &operator =(const Exception &other)
{
- if (this == &other)
+ if (this == &other) {
return *this;
+ }
// Deep copy
- if (other.m_reason != NULL)
+ if (other.m_reason != NULL) {
m_reason = new Exception(*other.m_reason);
- else
+ } else {
m_reason = NULL;
+ }
m_message = other.m_message;
m_path = other.m_path;
return *this;
}
- Exception(const char *path, const char *function, int line, const std::string &message)
- : m_reason(NULL),
- m_path(path),
- m_function(function),
- m_line(line),
- m_message(message)
+ Exception(const char *path,
+ const char *function,
+ int line,
+ const std::string &message) :
+ m_reason(NULL),
+ m_path(path),
+ m_function(function),
+ m_line(line),
+ m_message(message)
{
AddRef(this);
}
- Exception(const char *path, const char *function, int line, const Exception &reason, const std::string &message)
- : m_reason(new Exception(reason)),
- m_path(path),
- m_function(function),
- m_line(line),
- m_message(message)
+ Exception(const char *path,
+ const char *function,
+ int line,
+ const Exception &reason,
+ const std::string &message) :
+ m_reason(new Exception(reason)),
+ m_path(path),
+ m_function(function),
+ m_line(line),
+ m_message(message)
{
AddRef(this);
}
virtual ~Exception() throw()
{
- if (m_reason != NULL)
- {
+ if (m_reason != NULL) {
delete m_reason;
m_reason = NULL;
}
void Dump() const
{
// Show reason first
- if (m_reason != NULL)
+ if (m_reason != NULL) {
m_reason->Dump();
+ }
// Afterward, dump exception
const char *file = strchr(m_path.c_str(), '/');
- if (file == NULL)
+ if (file == NULL) {
file = m_path.c_str();
- else
+ } else {
++file;
+ }
printf("\033[0;36m[%s:%i]\033[m %s() \033[4;35m%s\033[m: %s\033[m\n",
file, m_line,
std::string DumpToString() const
{
std::string ret;
- if (m_reason != NULL)
+ if (m_reason != NULL) {
ret = m_reason->DumpToString();
+ }
const char *file = strchr(m_path.c_str(), '/');
- if (file == NULL)
+ if (file == NULL) {
file = m_path.c_str();
- else
+ } else {
++file;
+ }
char buf[1024];
- snprintf(buf, sizeof(buf), "\033[0;36m[%s:%i]\033[m %s() \033[4;35m%s\033[m: %s\033[m\n",
- file, m_line,
- m_function.c_str(),
- m_className.c_str(),
- m_message.empty() ? "<EMPTY>" : m_message.c_str());
-
- buf[sizeof(buf)-1] = '\n';
+ snprintf(buf,
+ sizeof(buf),
+ "\033[0;36m[%s:%i]\033[m %s() \033[4;35m%s\033[m: %s\033[m\n",
+ file,
+ m_line,
+ m_function.c_str(),
+ m_className.c_str(),
+ m_message.empty() ? "<EMPTY>" : m_message.c_str());
+
+ buf[sizeof(buf) - 1] = '\n';
ret += buf;
return ret;
std::ostringstream dplLoggingStream; \
dplLoggingStream << Message; \
throw ClassName(__FILE__, __FUNCTION__, __LINE__, dplLoggingStream.str()); \
- }while(0)
+ } while (0)
#define ReThrow(ClassName) \
throw ClassName(__FILE__, __FUNCTION__, __LINE__, _rethrown_exception)
#define ReThrowMsg(ClassName, Message) \
- throw ClassName(__FILE__, __FUNCTION__, __LINE__, _rethrown_exception, Message)
+ throw ClassName(__FILE__, \
+ __FUNCTION__, \
+ __LINE__, \
+ _rethrown_exception, \
+ Message)
#define Catch(ClassName) \
catch (const ClassName &_rethrown_exception)
#define DECLARE_EXCEPTION_TYPE(BaseClass, Class) \
- class Class \
- : public BaseClass \
+ class Class : \
+ public BaseClass \
{ \
- public: \
- Class(const char *path, const char *function, int line, const std::string &message = std::string()) \
- : BaseClass(path, function, line, message) \
+ public: \
+ Class(const char *path, \
+ const char *function, \
+ int line, \
+ const std::string & message = std::string()) : \
+ BaseClass(path, function, line, message) \
{ \
BaseClass::m_className = #Class; \
} \
\
- Class(const char *path, const char *function, int line, const DPL::Exception &reason, const std::string &message = std::string()) \
- : BaseClass(path, function, line, reason, message) \
+ Class(const char *path, \
+ const char *function, \
+ int line, \
+ const DPL::Exception & reason, \
+ const std::string & message = std::string()) : \
+ BaseClass(path, function, line, reason, message) \
{ \
BaseClass::m_className = #Class; \
} \
abort(); \
}
-namespace DPL
-{
-namespace CommonException
-{
+namespace DPL {
+namespace CommonException {
/**
* Internal exception definitions
*
* Usually, exception trace with internal error includes
* important messages.
*/
-DECLARE_EXCEPTION_TYPE(Exception, InternalError) ///< Unexpected error from underlying libraries or kernel
+DECLARE_EXCEPTION_TYPE(Exception, InternalError) ///< Unexpected error from
+ // underlying libraries or
+ // kernel
}
}
#include <dpl/3rdparty/fastdelegate/FastDelegate.h>
#include <dpl/3rdparty/fastdelegate/FastDelegateBind.h>
-namespace DPL
-{
+namespace DPL {
using namespace fastdelegate;
} // namespace DPL
#include <dpl/exception.h>
#include <dpl/abstract_waitable_input.h>
-namespace DPL
+namespace DPL {
+class FileInput :
+ private Noncopyable,
+ public AbstractWaitableInput
{
-class FileInput
- : private Noncopyable,
- public AbstractWaitableInput
-{
-public:
+ public:
class Exception
{
- public:
+ public:
DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, OpenFailed)
DECLARE_EXCEPTION_TYPE(Base, CloseFailed)
};
-protected:
+ protected:
int m_fd;
-public:
+ public:
FileInput();
FileInput(const std::string &fileName);
virtual ~FileInput();
#include <dpl/exception.h>
#include <dpl/abstract_waitable_output.h>
-namespace DPL
+namespace DPL {
+class FileOutput :
+ private Noncopyable,
+ public AbstractWaitableOutput
{
-class FileOutput
- : private Noncopyable,
- public AbstractWaitableOutput
-{
-public:
+ public:
class Exception
{
- public:
+ public:
DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, OpenFailed)
DECLARE_EXCEPTION_TYPE(Base, CloseFailed)
};
-protected:
+ protected:
int m_fd;
-public:
+ public:
FileOutput();
FileOutput(const std::string &fileName);
virtual ~FileOutput();
* @author Bartosz Janiak (b.janiak@samsung.com)
* @author Lukasz Wrzosek (l.wrzosek@samsung.com)
* @version 1.0
- * @brief This file is the implementation file of foreach macro for stl containers
+ * @brief This file is the implementation file of foreach macro for stl
+ * containers
*/
#ifndef DPL_FOREACH_H
#define DPL_FOREACH_H
#include <dpl/preprocessor.h>
-namespace DPL
-{
-namespace Private
-{
-
+namespace DPL {
+namespace Private {
/*
* Used to detect type of valid reference to value object.
*/
{
return(t);
}
-
-
} //Private
} //DPL
-
#define DPL_FOREACH_IMPL(temporaryName, iterator, container) \
__typeof__ (DPL::Private::ValueReference((container))) & \
temporaryName = (container); \
- for (__typeof__ (temporaryName.begin()) iterator = \
+ for (__typeof__ (temporaryName.begin())iterator = \
temporaryName.begin(); \
(iterator) != temporaryName.end(); ++iterator)
#define FOREACH(iterator, container) \
DPL_FOREACH_IMPL( \
DPL_MACRO_CONCAT(foreachContainerReference, __COUNTER__), \
- iterator, \
- container)
+ iterator, \
+ container)
#endif // DPL_FOREACH_H
#ifndef DPL_GENERIC_EVENT_H
#define DPL_GENERIC_EVENT_H
-namespace DPL
-{
-
+namespace DPL {
class EventSender
{
-public:
- explicit EventSender(void *sender)
- : m_sender(sender)
- {
- }
+ public:
+ explicit EventSender(void *sender) :
+ m_sender(sender)
+ {}
void* GetSender() const
{
return m_sender;
}
-private:
+ private:
void *m_sender;
};
class GenericEvent
{
-protected:
+ protected:
void *m_sender;
-public:
- explicit GenericEvent(const EventSender &sender)
- : m_sender(sender.GetSender())
- {
- }
+ public:
+ explicit GenericEvent(const EventSender &sender) :
+ m_sender(sender.GetSender())
+ {}
virtual ~GenericEvent()
- {
- }
+ {}
void *GetSender() const
{
}
};
-class GenericEvent0
- : public GenericEvent
+class GenericEvent0 :
+ public GenericEvent
{
-public:
- explicit GenericEvent0(const EventSender &sender)
- : GenericEvent(sender)
- {
- }
+ public:
+ explicit GenericEvent0(const EventSender &sender) :
+ GenericEvent(sender)
+ {}
virtual ~GenericEvent0()
- {
- }
-
+ {}
};
template<typename Arg0Type>
-class GenericEvent1
- : public GenericEvent0
+class GenericEvent1 :
+ public GenericEvent0
{
-public:
+ public:
typedef Arg0Type Arg0;
-protected:
+ protected:
Arg0 m_arg0;
-public:
- explicit GenericEvent1(const EventSender &sender)
- : GenericEvent0(sender)
- {
- }
+ public:
+ explicit GenericEvent1(const EventSender &sender) :
+ GenericEvent0(sender)
+ {}
- GenericEvent1(Arg0 arg0, const EventSender &sender)
- : GenericEvent0(sender),
- m_arg0(arg0)
- {
- }
+ GenericEvent1(Arg0 arg0, const EventSender &sender) :
+ GenericEvent0(sender),
+ m_arg0(arg0)
+ {}
virtual ~GenericEvent1()
- {
- }
+ {}
Arg0 GetArg0() const
{
};
template<typename Arg0Type, typename Arg1Type>
-class GenericEvent2
-
: public GenericEvent1<Arg0Type>
+class GenericEvent2 :
+ public GenericEvent1<Arg0Type>
{
-public:
+ public:
typedef Arg0Type Arg0;
typedef Arg1Type Arg1;
-protected:
+ protected:
Arg1 m_arg1;
-public:
- explicit GenericEvent2(const EventSender &sender)
- : GenericEvent1<Arg0Type>(sender)
- {
- }
+ public:
+ explicit GenericEvent2(const EventSender &sender) :
+ GenericEvent1<Arg0Type>(sender)
+ {}
- GenericEvent2(Arg0 arg0, Arg1 arg1, const EventSender &sender)
- : GenericEvent1<Arg0Type>(arg0, sender),
- m_arg1(arg1)
- {
- }
+ GenericEvent2(Arg0 arg0, Arg1 arg1, const EventSender &sender) :
+ GenericEvent1<Arg0Type>(arg0, sender),
+ m_arg1(arg1)
+ {}
virtual ~GenericEvent2()
- {
- }
+ {}
Arg1 GetArg1() const
{
};
template<typename Arg0Type, typename Arg1Type, typename Arg2Type>
-class GenericEvent3
-
: public GenericEvent2<Arg0Type, Arg1Type>
+class GenericEvent3 :
+ public GenericEvent2<Arg0Type, Arg1Type>
{
-public:
+ public:
typedef Arg0Type Arg0;
typedef Arg1Type Arg1;
typedef Arg2Type Arg2;
-protected:
+ protected:
Arg2 m_arg2;
-public:
- explicit GenericEvent3(const EventSender &sender)
- : GenericEvent2<Arg0Type, Arg1Type>(sender)
- {
- }
+ public:
+ explicit GenericEvent3(const EventSender &sender) :
+ GenericEvent2<Arg0Type, Arg1Type>(sender)
+ {}
- GenericEvent3(Arg0 arg0, Arg1 arg1, Arg2 arg2, const EventSender &sender)
- : GenericEvent2<Arg0Type, Arg1Type>(arg0, arg1, sender),
- m_arg2(arg2)
- {
- }
+ GenericEvent3(Arg0 arg0, Arg1 arg1, Arg2 arg2, const EventSender &sender) :
+ GenericEvent2<Arg0Type, Arg1Type>(arg0, arg1, sender),
+ m_arg2(arg2)
+ {}
virtual ~GenericEvent3()
- {
- }
+ {}
Arg2 GetArg2() const
{
}
};
-template<typename Arg0Type, typename Arg1Type, typename Arg2Type, typename Arg3Type>
-class GenericEvent4
- : public GenericEvent3<Arg0Type, Arg1Type, Arg2Type>
+template<typename Arg0Type, typename Arg1Type, typename Arg2Type,
+ typename Arg3Type>
+class GenericEvent4 :
+ public GenericEvent3<Arg0Type, Arg1Type, Arg2Type>
{
-public:
+ public:
typedef Arg0Type Arg0;
typedef Arg1Type Arg1;
typedef Arg2Type Arg2;
typedef Arg3Type Arg3;
-protected:
+ protected:
Arg3 m_arg3;
-public:
- explicit GenericEvent4(const EventSender &sender)
- : GenericEvent3<Arg0Type, Arg1Type, Arg2Type>(sender)
- {
- }
+ public:
+ explicit GenericEvent4(const EventSender &sender) :
+ GenericEvent3<Arg0Type, Arg1Type, Arg2Type>(sender)
+ {}
- GenericEvent4(Arg0 arg0, Arg1 arg1, Arg2 arg2, Arg3 arg3, const EventSender &sender)
- : GenericEvent3<Arg0Type, Arg1Type, Arg2Type>(arg0, arg1, arg2, sender),
- m_arg3(arg3)
- {
- }
+ GenericEvent4(Arg0 arg0,
+ Arg1 arg1,
+ Arg2 arg2,
+ Arg3 arg3,
+ const EventSender &sender) :
+ GenericEvent3<Arg0Type, Arg1Type, Arg2Type>(arg0, arg1, arg2, sender),
+ m_arg3(arg3)
+ {}
virtual ~GenericEvent4()
- {
- }
+ {}
Arg3 GetArg3() const
{
}
};
-template<typename Arg0Type, typename Arg1Type, typename Arg2Type, typename Arg3Type, typename Arg4Type>
-class GenericEvent5
- : public GenericEvent4<Arg0Type, Arg1Type, Arg2Type, Arg3Type>
+template<typename Arg0Type, typename Arg1Type, typename Arg2Type,
+ typename Arg3Type, typename Arg4Type>
+class GenericEvent5 :
+ public GenericEvent4<Arg0Type, Arg1Type, Arg2Type, Arg3Type>
{
-public:
+ public:
typedef Arg0Type Arg0;
typedef Arg1Type Arg1;
typedef Arg2Type Arg2;
typedef Arg3Type Arg3;
typedef Arg4Type Arg4;
-protected:
+ protected:
Arg4 m_arg4;
-public:
- explicit GenericEvent5(const EventSender &sender)
- : GenericEvent4<Arg0Type, Arg1Type, Arg2Type, Arg3Type>(sender)
- {
- }
-
- GenericEvent5(Arg0 arg0, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, const EventSender &sender)
- : GenericEvent4<Arg0Type, Arg1Type, Arg2Type, Arg3Type>(arg0, arg1, arg2, arg3, sender),
- m_arg4(arg4)
- {
- }
+ public:
+ explicit GenericEvent5(const EventSender &sender) :
+ GenericEvent4<Arg0Type, Arg1Type, Arg2Type, Arg3Type>(sender)
+ {}
+
+ GenericEvent5(Arg0 arg0,
+ Arg1 arg1,
+ Arg2 arg2,
+ Arg3 arg3,
+ Arg4 arg4,
+ const EventSender &sender) :
+ GenericEvent4<Arg0Type, Arg1Type, Arg2Type, Arg3Type>(arg0, arg1, arg2,
+ arg3, sender),
+ m_arg4(arg4)
+ {}
virtual ~GenericEvent5()
- {
- }
+ {}
Arg4 GetArg4() const
{
}
};
-template<typename Arg0Type, typename Arg1Type, typename Arg2Type, typename Arg3Type, typename Arg4Type, typename Arg5Type>
-class GenericEvent6
- : public GenericEvent5<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type>
+template<typename Arg0Type, typename Arg1Type, typename Arg2Type,
+ typename Arg3Type, typename Arg4Type, typename Arg5Type>
+class GenericEvent6 :
+ public GenericEvent5<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type>
{
-public:
+ public:
typedef Arg0Type Arg0;
typedef Arg1Type Arg1;
typedef Arg2Type Arg2;
typedef Arg4Type Arg4;
typedef Arg5Type Arg5;
-protected:
+ protected:
Arg5 m_arg5;
-public:
- explicit GenericEvent6(const EventSender &sender)
- : GenericEvent5<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type>(sender)
- {
- }
-
- GenericEvent6(Arg0 arg0, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5, const EventSender &sender)
- : GenericEvent5<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type>(arg0, arg1, arg2, arg3, arg4, sender),
- m_arg5(arg5)
- {
- }
+ public:
+ explicit GenericEvent6(const EventSender &sender) :
+ GenericEvent5<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type>(sender)
+ {}
+
+ GenericEvent6(Arg0 arg0,
+ Arg1 arg1,
+ Arg2 arg2,
+ Arg3 arg3,
+ Arg4 arg4,
+ Arg5 arg5,
+ const EventSender &sender) :
+ GenericEvent5<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type>(arg0,
+ arg1,
+ arg2,
+ arg3,
+ arg4,
+ sender),
+ m_arg5(arg5)
+ {}
virtual ~GenericEvent6()
- {
- }
+ {}
Arg5 GetArg5() const
{
}
};
-template<typename Arg0Type, typename Arg1Type, typename Arg2Type, typename Arg3Type, typename Arg4Type, typename Arg5Type, typename Arg6Type>
-class GenericEvent7
- : public GenericEvent6<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type, Arg5Type>
+template<typename Arg0Type, typename Arg1Type, typename Arg2Type,
+ typename Arg3Type, typename Arg4Type, typename Arg5Type,
+ typename Arg6Type>
+class GenericEvent7 :
+ public GenericEvent6<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type,
+ Arg5Type>
{
-public:
+ public:
typedef Arg0Type Arg0;
typedef Arg1Type Arg1;
typedef Arg2Type Arg2;
typedef Arg5Type Arg5;
typedef Arg6Type Arg6;
-protected:
+ protected:
Arg6 m_arg6;
-public:
- explicit GenericEvent7(const EventSender &sender)
- : GenericEvent6<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type, Arg5Type>(sender)
- {
- }
-
- GenericEvent7(Arg0 arg0, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5, Arg6 arg6, const EventSender &sender)
- : GenericEvent6<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type, Arg5Type>(arg0, arg1, arg2, arg3, arg4, arg5, sender),
- m_arg6(arg6)
- {
- }
+ public:
+ explicit GenericEvent7(const EventSender &sender) :
+ GenericEvent6<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type,
+ Arg5Type>(sender)
+ {}
+
+ GenericEvent7(Arg0 arg0,
+ Arg1 arg1,
+ Arg2 arg2,
+ Arg3 arg3,
+ Arg4 arg4,
+ Arg5 arg5,
+ Arg6 arg6,
+ const EventSender &sender) :
+ GenericEvent6<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type,
+ Arg5Type>(arg0, arg1, arg2, arg3, arg4, arg5, sender),
+ m_arg6(arg6)
+ {}
virtual ~GenericEvent7()
- {
- }
+ {}
Arg6 GetArg6() const
{
}
};
-template<typename Arg0Type, typename Arg1Type, typename Arg2Type, typename Arg3Type, typename Arg4Type, typename Arg5Type, typename Arg6Type, typename Arg7Type>
-class GenericEvent8
- : public GenericEvent7<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type, Arg5Type, Arg6Type>
+template<typename Arg0Type, typename Arg1Type, typename Arg2Type,
+ typename Arg3Type, typename Arg4Type, typename Arg5Type,
+ typename Arg6Type,
+ typename Arg7Type>
+class GenericEvent8 :
+ public GenericEvent7<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type,
+ Arg5Type, Arg6Type>
{
-public:
+ public:
typedef Arg0Type Arg0;
typedef Arg1Type Arg1;
typedef Arg2Type Arg2;
typedef Arg6Type Arg6;
typedef Arg7Type Arg7;
-protected:
+ protected:
Arg7 m_arg7;
-public:
- explicit GenericEvent8(const EventSender &sender)
- : GenericEvent7<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type, Arg5Type, Arg6Type>(sender)
- {
- }
-
- GenericEvent8(Arg0 arg0, Arg1 arg1, Arg2 arg2, Arg3 arg3, Arg4 arg4, Arg5 arg5, Arg6 arg6, Arg7 arg7, const EventSender &sender)
- : GenericEvent7<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type, Arg5Type, Arg6Type>(arg0, arg1, arg2, arg3, arg4, arg5, arg6, sender),
- m_arg7(arg7)
- {
- }
+ public:
+ explicit GenericEvent8(const EventSender &sender) :
+ GenericEvent7<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type,
+ Arg5Type, Arg6Type>(sender)
+ {}
+
+ GenericEvent8(Arg0 arg0,
+ Arg1 arg1,
+ Arg2 arg2,
+ Arg3 arg3,
+ Arg4 arg4,
+ Arg5 arg5,
+ Arg6 arg6,
+ Arg7 arg7,
+ const EventSender &sender) :
+ GenericEvent7<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type,
+ Arg5Type, Arg6Type>(arg0, arg1, arg2, arg3, arg4, arg5,
+ arg6, sender),
+ m_arg7(arg7)
+ {}
virtual ~GenericEvent8()
- {
- }
+ {}
Arg7 GetArg7() const
{
return m_arg7;
}
};
-
} // namespace DPL
#define DECLARE_GENERIC_EVENT_0(ClassName) \
- class ClassName \
- : public DPL::GenericEvent0 \
+ class ClassName : \
+ public DPL::GenericEvent0 \
{ \
- public: \
- explicit ClassName(const DPL::EventSender &sender = DPL::EventSender(NULL)) \
- : DPL::GenericEvent0(sender) \
+ public: \
+ explicit ClassName(const DPL::EventSender & sender = \
+ DPL::EventSender(NULL)) : \
+ DPL::GenericEvent0(sender) \
{ \
} \
};
#define DECLARE_GENERIC_EVENT_1(ClassName, Arg0Type) \
- class ClassName \
-
: public DPL::GenericEvent1<Arg0Type> \
+ class ClassName : \
+ public DPL::GenericEvent1<Arg0Type> \
{ \
- public: \
- explicit ClassName(const DPL::EventSender &sender = DPL::EventSender(NULL)) \
- : DPL::GenericEvent1<Arg0Type>(sender) \
+ public: \
+ explicit ClassName(const DPL::EventSender & sender = \
+ DPL::EventSender(NULL)) : \
+ DPL::GenericEvent1<Arg0Type>(sender) \
{ \
} \
\
explicit ClassName(Arg0Type arg0, \
- const DPL::EventSender &sender = DPL::EventSender(NULL)) \
- : DPL::GenericEvent1<Arg0Type>(arg0, sender) \
+ const DPL::EventSender & sender = \
+ DPL::EventSender(NULL)) : \
+ DPL::GenericEvent1<Arg0Type>(arg0, sender) \
{ \
} \
};
#define DECLARE_GENERIC_EVENT_2(ClassName, Arg0Type, Arg1Type) \
- class ClassName \
-
: public DPL::GenericEvent2<Arg0Type, Arg1Type> \
+ class ClassName : \
+ public DPL::GenericEvent2<Arg0Type, Arg1Type> \
{ \
- public: \
- explicit ClassName(const DPL::EventSender &sender = DPL::EventSender(NULL)) \
- : DPL::GenericEvent2<Arg0Type, Arg1Type>(sender) \
+ public: \
+ explicit ClassName(const DPL::EventSender & sender = \
+ DPL::EventSender(NULL)) : \
+ DPL::GenericEvent2<Arg0Type, Arg1Type>(sender) \
{ \
} \
\
ClassName(Arg0Type arg0, Arg1Type arg1, \
- const DPL::EventSender &sender = DPL::EventSender(NULL)) \
-
: DPL::GenericEvent2<Arg0Type, Arg1Type>(arg0, arg1, sender) \
+ const DPL::EventSender & sender = DPL::EventSender(NULL)) : \
+ DPL::GenericEvent2<Arg0Type, Arg1Type>(arg0, arg1, sender) \
{ \
} \
};
#define DECLARE_GENERIC_EVENT_3(ClassName, Arg0Type, Arg1Type, Arg2Type) \
- class ClassName \
-
: public DPL::GenericEvent3<Arg0Type, Arg1Type, Arg2Type> \
+ class ClassName : \
+ public DPL::GenericEvent3<Arg0Type, Arg1Type, Arg2Type> \
{ \
- public: \
- explicit ClassName(const DPL::EventSender &sender = DPL::EventSender(NULL)) \
- : DPL::GenericEvent3<Arg0Type, Arg1Type, Arg2Type>(sender) \
+ public: \
+ explicit ClassName(const DPL::EventSender & sender = \
+ DPL::EventSender(NULL)) : \
+ DPL::GenericEvent3<Arg0Type, Arg1Type, Arg2Type>(sender) \
{ \
} \
\
ClassName(Arg0Type arg0, Arg1Type arg1, Arg2Type arg2, \
- const DPL::EventSender &sender = DPL::EventSender(NULL)) \
- : DPL::GenericEvent3<Arg0Type, Arg1Type, Arg2Type>(arg0, arg1, arg2, sender) \
+ const DPL::EventSender & sender = DPL::EventSender(NULL)) : \
+ DPL::GenericEvent3<Arg0Type, Arg1Type, Arg2Type>(arg0, \
+ arg1, \
+ arg2, \
+ sender) \
{ \
} \
};
-#define DECLARE_GENERIC_EVENT_4(ClassName, Arg0Type, Arg1Type, Arg2Type, Arg3Type) \
- class ClassName \
- : public DPL::GenericEvent4<Arg0Type, Arg1Type, Arg2Type, Arg3Type> \
+#define DECLARE_GENERIC_EVENT_4(ClassName, \
+ Arg0Type, \
+ Arg1Type, \
+ Arg2Type, \
+ Arg3Type) \
+ class ClassName : \
+ public DPL::GenericEvent4<Arg0Type, Arg1Type, Arg2Type, Arg3Type> \
{ \
- public: \
- explicit ClassName(const DPL::EventSender &sender = DPL::EventSender(NULL)) \
- : DPL::GenericEvent4<Arg0Type, Arg1Type, Arg2Type, Arg3Type>(sender) \
+ public: \
+ explicit ClassName(const DPL::EventSender & sender = \
+ DPL::EventSender(NULL)) : \
+ DPL::GenericEvent4<Arg0Type, Arg1Type, Arg2Type, Arg3Type>(sender) \
{ \
} \
\
ClassName(Arg0Type arg0, Arg1Type arg1, Arg2Type arg2, Arg3Type arg3, \
- const DPL::EventSender &sender = DPL::EventSender(NULL)) \
- : DPL::GenericEvent4<Arg0Type, Arg1Type, Arg2Type, Arg3Type>(arg0, arg1, arg2, arg3, sender) \
+ const DPL::EventSender & sender = DPL::EventSender(NULL)) : \
+ DPL::GenericEvent4<Arg0Type, Arg1Type, Arg2Type, Arg3Type>(arg0, \
+ arg1, \
+ arg2, \
+ arg3, \
+ sender) \
{ \
} \
};
-#define DECLARE_GENERIC_EVENT_5(ClassName, Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type) \
- class ClassName \
- : public DPL::GenericEvent5<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type> \
+#define DECLARE_GENERIC_EVENT_5(ClassName, \
+ Arg0Type, \
+ Arg1Type, \
+ Arg2Type, \
+ Arg3Type, \
+ Arg4Type) \
+ class ClassName : \
+ public DPL::GenericEvent5<Arg0Type, Arg1Type, Arg2Type, Arg3Type, \
+ Arg4Type> \
{ \
- public: \
- explicit ClassName(const DPL::EventSender &sender = DPL::EventSender(NULL)) \
- : DPL::GenericEvent5<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type>(sender) \
+ public: \
+ explicit ClassName(const DPL::EventSender & sender = \
+ DPL::EventSender(NULL)) : \
+ DPL::GenericEvent5<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type>( \
+ sender) \
{ \
} \
\
- ClassName(Arg0Type arg0, Arg1Type arg1, Arg2Type arg2, Arg3Type arg3, Arg4Type arg4, \
- const DPL::EventSender &sender = DPL::EventSender(NULL)) \
- : DPL::GenericEvent5<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type>(arg0, arg1, arg2, arg3, arg4, sender) \
+ ClassName(Arg0Type arg0, \
+ Arg1Type arg1, \
+ Arg2Type arg2, \
+ Arg3Type arg3, \
+ Arg4Type arg4, \
+ const DPL::EventSender & sender = DPL::EventSender(NULL)) : \
+ DPL::GenericEvent5<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type>( \
+ arg0, \
+ arg1, \
+ arg2, \
+ arg3, \
+ arg4, \
+ sender) \
{ \
} \
};
-#define DECLARE_GENERIC_EVENT_6(ClassName, Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type, Arg5Type) \
- class ClassName \
- : public DPL::GenericEvent6<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type, Arg5Type> \
+#define DECLARE_GENERIC_EVENT_6(ClassName, \
+ Arg0Type, \
+ Arg1Type, \
+ Arg2Type, \
+ Arg3Type, \
+ Arg4Type, \
+ Arg5Type) \
+ class ClassName : \
+ public DPL::GenericEvent6<Arg0Type, Arg1Type, Arg2Type, Arg3Type, \
+ Arg4Type, Arg5Type> \
{ \
- public: \
- explicit ClassName(const DPL::EventSender &sender = DPL::EventSender(NULL)) \
- : DPL::GenericEvent6<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type, Arg5Type>(sender) \
+ public: \
+ explicit ClassName(const DPL::EventSender & sender = \
+ DPL::EventSender(NULL)) : \
+ DPL::GenericEvent6<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type, \
+ Arg5Type>(sender) \
{ \
} \
\
- ClassName(Arg0Type arg0, Arg1Type arg1, Arg2Type arg2, Arg3Type arg3, Arg4Type arg4, Arg5Type arg5, \
- const DPL::EventSender &sender = DPL::EventSender(NULL)) \
- : DPL::GenericEvent6<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type, Arg5Type>(arg0, arg1, arg2, arg3, arg4, arg5, sender) \
+ ClassName(Arg0Type arg0, \
+ Arg1Type arg1, \
+ Arg2Type arg2, \
+ Arg3Type arg3, \
+ Arg4Type arg4, \
+ Arg5Type arg5, \
+ const DPL::EventSender & sender = DPL::EventSender(NULL)) : \
+ DPL::GenericEvent6<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type, \
+ Arg5Type>(arg0, \
+ arg1, \
+ arg2, \
+ arg3, \
+ arg4, \
+ arg5, \
+ sender) \
{ \
} \
};
-#define DECLARE_GENERIC_EVENT_7(ClassName, Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type, Arg5Type, Arg6Type) \
- class ClassName \
- : public DPL::GenericEvent7<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type, Arg5Type, Arg6Type> \
+#define DECLARE_GENERIC_EVENT_7(ClassName, \
+ Arg0Type, \
+ Arg1Type, \
+ Arg2Type, \
+ Arg3Type, \
+ Arg4Type, \
+ Arg5Type, \
+ Arg6Type) \
+ class ClassName : \
+ public DPL::GenericEvent7<Arg0Type, Arg1Type, Arg2Type, Arg3Type, \
+ Arg4Type, Arg5Type, Arg6Type> \
{ \
- public: \
- explicit ClassName(const DPL::EventSender &sender = DPL::EventSender(NULL)) \
- : DPL::GenericEvent7<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type, Arg5Type, Arg6Type>(sender) \
+ public: \
+ explicit ClassName(const DPL::EventSender & sender = \
+ DPL::EventSender(NULL)) : \
+ DPL::GenericEvent7<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type, \
+ Arg5Type, Arg6Type>(sender) \
{ \
} \
\
- ClassName(Arg0Type arg0, Arg1Type arg1, Arg2Type arg2, Arg3Type arg3, Arg4Type arg4, Arg5Type arg5, Arg6Type arg6, \
- const DPL::EventSender &sender = DPL::EventSender(NULL)) \
- : DPL::GenericEvent7<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type, Arg5Type, Arg6Type>(arg0, arg1, arg2, arg3, arg4, arg5, arg6, sender) \
+ ClassName(Arg0Type arg0, \
+ Arg1Type arg1, \
+ Arg2Type arg2, \
+ Arg3Type arg3, \
+ Arg4Type arg4, \
+ Arg5Type arg5, \
+ Arg6Type arg6, \
+ const DPL::EventSender & sender = DPL::EventSender(NULL)) : \
+ DPL::GenericEvent7<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type, \
+ Arg5Type, Arg6Type>(arg0, \
+ arg1, \
+ arg2, \
+ arg3, \
+ arg4, \
+ arg5, \
+ arg6, \
+ sender) \
{ \
} \
};
-#define DECLARE_GENERIC_EVENT_8(ClassName, Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type, Arg5Type, Arg6Type, Arg7Type) \
- class ClassName \
- : public DPL::GenericEvent8<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type, Arg5Type, Arg6Type, Arg7Type> \
+#define DECLARE_GENERIC_EVENT_8(ClassName, \
+ Arg0Type, \
+ Arg1Type, \
+ Arg2Type, \
+ Arg3Type, \
+ Arg4Type, \
+ Arg5Type, \
+ Arg6Type, \
+ Arg7Type) \
+ class ClassName : \
+ public DPL::GenericEvent8<Arg0Type, Arg1Type, Arg2Type, Arg3Type, \
+ Arg4Type, Arg5Type, Arg6Type, Arg7Type> \
{ \
- public: \
- explicit ClassName(const DPL::EventSender &sender = DPL::EventSender(NULL)) \
- : DPL::GenericEvent8<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type, Arg5Type, Arg6Type, Arg7Type>(sender) \
+ public: \
+ explicit ClassName(const DPL::EventSender & sender = \
+ DPL::EventSender(NULL)) : \
+ DPL::GenericEvent8<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type, \
+ Arg5Type, Arg6Type, Arg7Type>(sender) \
{ \
} \
\
- ClassName(Arg0Type arg0, Arg1Type arg1, Arg2Type arg2, Arg3Type arg3, Arg4Type arg4, Arg5Type arg5, Arg6Type arg6, Arg7Type arg7, \
- const DPL::EventSender &sender = DPL::EventSender(NULL)) \
- : DPL::GenericEvent8<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type, Arg5Type, Arg6Type, Arg7Type>(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7, sender) \
+ ClassName(Arg0Type arg0, \
+ Arg1Type arg1, \
+ Arg2Type arg2, \
+ Arg3Type arg3, \
+ Arg4Type arg4, \
+ Arg5Type arg5, \
+ Arg6Type arg6, \
+ Arg7Type arg7, \
+ const DPL::EventSender & sender = DPL::EventSender(NULL)) : \
+ DPL::GenericEvent8<Arg0Type, Arg1Type, Arg2Type, Arg3Type, Arg4Type, \
+ Arg5Type, Arg6Type, Arg7Type>(arg0, \
+ arg1, \
+ arg2, \
+ arg3, \
+ arg4, \
+ arg5, \
+ arg6, \
+ arg7, \
+ sender) \
{ \
} \
};
#include <sstream>
-namespace DPL
-{
+namespace DPL {
template<typename TargetType, typename SourceType>
TargetType lexical_cast(const SourceType &data)
{
#include <dpl/framework_efl.h>
#include <list>
-namespace DPL
+namespace DPL {
+class Main :
+ public WaitableHandleWatchSupport
{
-class Main
- : public WaitableHandleWatchSupport
-{
-public:
+ public:
class Exception
{
- public:
+ public:
DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, CreateFailed)
};
-protected:
+ protected:
Ecore_Fd_Handler *m_invokerHandler;
- static Eina_Bool StaticDispatchInvoker(void *data, Ecore_Fd_Handler *fd_handler);
- static Eina_Bool StaticDispatchReadWatcher(void *data, Ecore_Fd_Handler *fd_handler);
- static Eina_Bool StaticDispatchWriteWatcher(void *data, Ecore_Fd_Handler *fd_handler);
+ static Eina_Bool StaticDispatchInvoker(void *data,
+ Ecore_Fd_Handler *fd_handler);
+ static Eina_Bool StaticDispatchReadWatcher(void *data,
+ Ecore_Fd_Handler *fd_handler);
+ static Eina_Bool StaticDispatchWriteWatcher(void *data,
+ Ecore_Fd_Handler *fd_handler);
typedef std::list<Ecore_Fd_Handler *> EcoreFdHandlerList;
#ifdef DPL_ENABLE_GLIB_LOOP_INTEGRATION_WORKAROUND
// GLIB loop intergration workaround
- typedef int (*EcoreSelectType)(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
+ typedef int (*EcoreSelectType)(int nfds, fd_set *readfds, fd_set *writefds,
+ fd_set *exceptfds, struct timeval *timeout);
EcoreSelectType m_oldEcoreSelect;
- static int EcoreSelectInterceptor(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
+ static int EcoreSelectInterceptor(int nfds,
+ fd_set *readfds,
+ fd_set *writefds,
+ fd_set *exceptfds,
+ struct timeval *timeout);
#endif // DPL_ENABLE_GLIB_LOOP_INTEGRATION_WORKAROUND
-public:
+ public:
explicit Main();
virtual ~Main();
};
#include <dpl/exception.h>
#include <pthread.h>
-namespace DPL
+namespace DPL {
+class Mutex :
+ private Noncopyable
{
-class Mutex
- : private Noncopyable
-{
-public:
- class ScopedLock
- : private Noncopyable
+ public:
+ class ScopedLock :
+ private Noncopyable
{
- private:
+ private:
Mutex *m_mutex;
- public:
+ public:
explicit ScopedLock(Mutex *mutex);
~ScopedLock();
};
class Exception
{
- public:
+ public:
DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, CreateFailed)
DECLARE_EXCEPTION_TYPE(Base, LockFailed)
DECLARE_EXCEPTION_TYPE(Base, UnlockFailed)
};
-private:
+ private:
mutable pthread_mutex_t m_mutex;
void Lock() const;
void Unlock() const;
-public:
+ public:
Mutex();
~Mutex();
};
-
} // namespace DPL
#endif // DPL_MUTEX_H
#include <dpl/exception.h>
-namespace DPL
-{
+namespace DPL {
class NamedBasePipe
{
-public:
+ public:
class Exception
{
- public:
+ public:
DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, AlreadyExist)
DECLARE_EXCEPTION_TYPE(Base, CreateFailed)
DECLARE_EXCEPTION_TYPE(Base, DestroyFailed)
};
-public:
+ public:
virtual ~NamedBasePipe();
static void Create(const std::string &fileName);
#include <dpl/named_base_pipe.h>
#include <dpl/file_input.h>
-namespace DPL
-{
-class NamedInputPipe
- : public NamedBasePipe,
- public FileInput
+namespace DPL {
+class NamedInputPipe :
+ public NamedBasePipe,
+ public FileInput
{};
} // namespace DPL
#include <dpl/abstract_waitable_output.h>
#include <dpl/named_base_pipe.h>
-namespace DPL
+namespace DPL {
+class NamedOutputPipe :
+ private Noncopyable,
+ public NamedBasePipe,
+ public AbstractWaitableOutput
{
-class NamedOutputPipe
- : private Noncopyable,
- public NamedBasePipe,
- public AbstractWaitableOutput
-{
-public:
+ public:
class Exception
{
- public:
+ public:
DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, OpenFailed)
DECLARE_EXCEPTION_TYPE(Base, CloseFailed)
};
-protected:
+ protected:
int m_fifo;
-public:
+ public:
NamedOutputPipe();
virtual ~NamedOutputPipe();
#ifndef DPL_NONCOPYABLE_H
#define DPL_NONCOPYABLE_H
-namespace DPL
-{
+namespace DPL {
class Noncopyable
{
-private:
+ private:
Noncopyable(const Noncopyable &);
const Noncopyable &operator=(const Noncopyable &);
-public:
+
+ public:
Noncopyable();
virtual ~Noncopyable();
};
-
} // namespace DPL
#endif // DPL_NONCOPYABLE_H
#include <dpl/atomic.h>
#include <dpl/mutex.h>
-namespace DPL
+namespace DPL {
+class Once :
+ private Noncopyable
{
-class Once
- : private Noncopyable
-{
-public:
+ public:
typedef FastDelegate<void ()> Delegate;
void Call(Delegate delegate);
-private:
+ private:
Atomic m_atomic;
Mutex m_mutex;
};
#include <dpl/exception.h>
-namespace DPL
-{
-
+namespace DPL {
template <typename Type>
class Optional
{
class Exception
{
- public:
+ public:
DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, NullReference)
};
-public:
+ public:
Optional() :
m_null(true),
m_value()
- {
- }
+ {}
Optional(const Type& t) :
m_null(false),
m_value(t)
- {
- }
+ {}
bool IsNull() const
{
Type& operator*()
{
- if (m_null) Throw(typename Exception::NullReference);
+ if (m_null) {
+ Throw(typename Exception::NullReference);
+ }
return m_value;
}
const Type& operator*() const
{
- if (m_null) Throw(typename Exception::NullReference);
+ if (m_null) {
+ Throw(typename Exception::NullReference);
+ }
return m_value;
}
const Type* operator->() const
{
- if (m_null) Throw(typename Exception::NullReference);
+ if (m_null) {
+ Throw(typename Exception::NullReference);
+ }
return &m_value;
}
Type* operator->()
{
- if (m_null) Throw(typename Exception::NullReference);
+ if (m_null) {
+ Throw(typename Exception::NullReference);
+ }
return &m_value;
}
bool operator==(const Optional<Type>& aSecond) const
{
- return LogicalOperator<true>(*this, aSecond, std::equal_to<Type>(), std::equal_to<bool>());
+ return LogicalOperator<true>(*this, aSecond,
+ std::equal_to<Type>(), std::equal_to<bool>());
}
bool operator==(const Type& aSecond) const
bool operator<(const Optional<Type>& aSecond) const
{
- return LogicalOperator<false>(*this, aSecond, std::less<Type>(), std::less<bool>());
+ return LogicalOperator<false>(*this, aSecond,
+ std::less<Type>(), std::less<bool>());
}
bool operator>(const Optional<Type>& aSecond) const
{
- return LogicalOperator<false>(*this, aSecond, std::greater<Type>(), std::greater<bool>());
+ return LogicalOperator<false>(*this, aSecond,
+ std::greater<Type>(), std::greater<bool>());
}
bool operator<=(const Optional<Type>& aSecond) const
static Optional<Type> Null;
-private:
+ private:
bool m_null;
Type m_value;
template <bool taEquality, typename taComparator, typename taNullComparator>
- static bool LogicalOperator(const Optional<Type>& aFirst, const Optional<Type>& aSecond,
- taComparator aComparator, taNullComparator aNullComparator)
+ static bool LogicalOperator(const Optional<Type>& aFirst,
+ const Optional<Type>& aSecond,
+ taComparator aComparator,
+ taNullComparator aNullComparator)
{
- if (aFirst.m_null == aSecond.m_null)
- {
- if (aFirst.m_null)
- {
+ if (aFirst.m_null == aSecond.m_null) {
+ if (aFirst.m_null) {
return taEquality;
+ } else {
+ return aComparator(aFirst.m_value, aSecond.m_value);
}
- else
- {
- return aComparator(aFirst.m_value, aSecond.m_value);
- }
- }
- else
- {
+ } else {
return aNullComparator(aFirst.m_null, aSecond.m_null);
}
}
template<typename Type>
Optional<Type> Optional<Type>::Null = Optional<Type>();
-
} //namespace DPL
template<typename Type>
-std::ostream& operator<<(std::ostream& aStream, const DPL::Optional<Type>& aOptional)
+std::ostream& operator<<(std::ostream& aStream,
+ const DPL::Optional<Type>& aOptional)
{
- if (aOptional.IsNull())
- {
+ if (aOptional.IsNull()) {
return aStream << "null optional";
- }
- else
- {
+ } else {
return aStream << *aOptional;
}
}
#include <dpl/string.h>
#include <dpl/optional.h>
-namespace DPL
-{
-
+namespace DPL {
typedef Optional<String> OptionalString;
typedef Optional<int> OptionalInt;
typedef Optional<bool> OptionalBool;
typedef Optional<float> OptionalFloat;
-
} //namespace DPL
#endif /* DPL_OPTIONAL_TYPEDEFS_H */
#define DPL_MACRO_CONCAT_IMPL(x, y) x##y
#define DPL_MACRO_CONCAT(x, y) DPL_MACRO_CONCAT_IMPL(x, y)
-#endif//DPL_PREPROCESSOR_H
+#endif //DPL_PREPROCESSOR_H
#include <dpl/exception.h>
#include <pthread.h>
-namespace DPL
+namespace DPL {
+class ReadWriteMutex :
+ private Noncopyable
{
-class ReadWriteMutex
- : private Noncopyable
-{
-public:
- class ScopedReadLock
- : private Noncopyable
+ public:
+ class ScopedReadLock :
+ private Noncopyable
{
- private:
+ private:
ReadWriteMutex *m_mutex;
- public:
+ public:
ScopedReadLock(ReadWriteMutex *mutex);
virtual ~ScopedReadLock();
};
- class ScopedWriteLock
- : private Noncopyable
+ class ScopedWriteLock :
+ private Noncopyable
{
- private:
+ private:
ReadWriteMutex *m_mutex;
- public:
+ public:
ScopedWriteLock(ReadWriteMutex *mutex);
virtual ~ScopedWriteLock();
};
class Exception
{
- public:
+ public:
DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, CreateFailed)
DECLARE_EXCEPTION_TYPE(Base, DestroyFailed)
DECLARE_EXCEPTION_TYPE(Base, UnlockFailed)
};
-private:
+ private:
mutable pthread_rwlock_t m_rwlock;
void ReadLock() const;
void WriteLock() const;
void Unlock() const;
-public:
+ public:
explicit ReadWriteMutex();
virtual ~ReadWriteMutex();
};
-
} // namespace DPL
#endif // DPL_READ_WRITE_MUTEX_H
#include <dpl/exception.h>
#include <pthread.h>
-namespace DPL
+namespace DPL {
+class RecursiveMutex :
+ private Noncopyable
{
-class RecursiveMutex
- : private Noncopyable
-{
-public:
- class ScopedLock
- : private Noncopyable
+ public:
+ class ScopedLock :
+ private Noncopyable
{
- private:
+ private:
RecursiveMutex *m_mutex;
- public:
+ public:
ScopedLock(RecursiveMutex *mutex);
virtual ~ScopedLock();
};
class Exception
{
- public:
+ public:
DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, CreateFailed)
DECLARE_EXCEPTION_TYPE(Base, DestroyFailed)
DECLARE_EXCEPTION_TYPE(Base, UnlockFailed)
};
-private:
+ private:
mutable pthread_mutex_t m_mutex;
void Lock() const;
void Unlock() const;
-public:
+ public:
explicit RecursiveMutex();
virtual ~RecursiveMutex();
};
-
} // namespace DPL
#endif // DPL_RECURSIVE_MUTEX_H
#include <dpl/assert.h>
#include <dpl/scoped_resource.h>
-namespace DPL
-{
+namespace DPL {
template<typename Class>
struct ScopedArrayPolicy
{
typedef Class* Type;
- static Type NullValue() { return NULL; }
- static void Destroy(Type ptr) { delete [] ptr; }
+ static Type NullValue()
+ {
+ return NULL;
+ }
+ static void Destroy(Type ptr)
+ {
+ delete[] ptr;
+ }
};
template<typename Class>
#include <dpl/scoped_resource.h>
#include <dpl/errno_string.h>
-namespace DPL
-{
+namespace DPL {
struct ScopedClosePolicy
{
typedef int Type;
- static Type NullValue() { return -1; }
+ static Type NullValue()
+ {
+ return -1;
+ }
static void Destroy(Type handle)
{
- if (handle != -1)
- {
- if (TEMP_FAILURE_RETRY(::fsync(handle)) == -1)
- {
+ if (handle != -1) {
+ if (TEMP_FAILURE_RETRY(::fsync(handle)) == -1) {
std::string errString = GetErrnoString();
LogPedantic("Failed to fsync scoped close error: "
<< errString);
}
- if (::close(handle) == -1)
- {
+ if (::close(handle) == -1) {
std::string errString = GetErrnoString();
LogPedantic("Failed to scoped close error: "
<< errString);
--- /dev/null
+/*
+ * Copyright (c) 2013 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 scoped_dir.h
+ * @author Iwanek Tomasz (t.iwanek@smasung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of scoped directory existence
+ */
+
+#ifndef DPL_SCOPED_DIR_H
+#define DPL_SCOPED_DIR_H
+
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <string>
+#include <dpl/scoped_resource.h>
+
+namespace DPL {
+
+struct ScopedDirPolicy
+{
+ typedef std::string Type;
+ static Type NullValue();
+ static void Destroy(Type ptr);
+};
+
+class ScopedDir : public ScopedResource<ScopedDirPolicy>
+{
+ typedef ScopedDirPolicy Policy;
+ typedef ScopedResource<Policy> BaseType;
+
+ public:
+ explicit ScopedDir(const std::string & str = Policy::NullValue(), mode_t mode = S_IRWXU|S_IRGRP|S_IXGRP);
+};
+} // namespace DPL
+
+#endif // DPL_SCOPED_DIR_H
#ifndef DPL_SCOPED_FCLOSE_H
#define DPL_SCOPED_FCLOSE_H
-
#include <unistd.h>
#include <cerrno>
#include <cstdio>
#include <dpl/scoped_resource.h>
#include <dpl/errno_string.h>
-namespace DPL
-{
+namespace DPL {
struct ScopedFClosePolicy
{
typedef FILE* Type;
- static Type NullValue() { return NULL; }
+ static Type NullValue()
+ {
+ return NULL;
+ }
static void Destroy(Type file)
{
- if (file != NULL)
- {
+ if (file != NULL) {
// Try to flush first
- if (TEMP_FAILURE_RETRY(fflush(file)) != 0)
- {
+ if (TEMP_FAILURE_RETRY(fflush(file)) != 0) {
std::string errString = GetErrnoString();
LogPedantic("Failed to fflush scoped fclose error: "
<< errString);
}
// fclose cannot be retried, try to close once
- if (fclose(file) != 0)
- {
+ if (fclose(file) != 0) {
std::string errString = GetErrnoString();
LogPedantic("Failed scoped fclose error: " << errString);
}
#include <dpl/scoped_resource.h>
-namespace DPL
-{
+namespace DPL {
template<typename Class>
struct ScopedFreePolicy
{
typedef Class* Type;
- static Type NullValue() { return NULL; }
- static void Destroy(Type ptr) { free(ptr); }
+ static Type NullValue()
+ {
+ return NULL;
+ }
+ static void Destroy(Type ptr)
+ {
+ free(ptr);
+ }
};
template<typename Memory>
#include <dpl/scoped_resource.h>
#include <dpl/assert.h>
-namespace DPL
-{
-
+namespace DPL {
struct ScopedGPointerPolicy
{
typedef gpointer Type;
public:
explicit ScopedGPointer(typename Policy::Type pointer =
- Policy::NullValue()) :
+ Policy::NullValue()) :
BaseType(pointer)
- {
- }
+ {}
Class *operator->() const throw()
{
return *static_cast<Class *>(this->m_value);
}
};
-
} // namespace DPL
#endif // DPL_SCOPED_GPOINTER_H
#include <dpl/scoped_resource.h>
#include <dpl/assert.h>
-namespace DPL
-{
+namespace DPL {
template<typename Class>
struct ScopedPtrPolicy
{
typedef Class* Type;
- static Type NullValue() { return NULL; }
- static void Destroy(Type ptr) { delete ptr; }
+ static Type NullValue()
+ {
+ return NULL;
+ }
+ static void Destroy(Type ptr)
+ {
+ delete ptr;
+ }
};
template<typename Class, typename ClassPolicy = ScopedPtrPolicy<Class> >
#include <dpl/noncopyable.h>
-namespace DPL
-{
+namespace DPL {
template<typename ClassPolicy>
-class ScopedResource
- : private Noncopyable
+class ScopedResource :
+ private Noncopyable
{
public:
typedef typename ClassPolicy::Type ValueType;
ClassPolicy::Destroy(m_value);
}
- ValueType Get() const { return m_value; }
+ ValueType Get() const
+ {
+ return m_value;
+ }
void Reset(ValueType value = ClassPolicy::NullValue())
{
{
return m_value == ClassPolicy::NullValue();
}
-
};
} // namespace DPL
#include <semaphore.h>
#include <string>
-namespace DPL
+namespace DPL {
+class Semaphore :
+ private Noncopyable
{
-class Semaphore
- : private Noncopyable
-{
-public:
- class ScopedLock
- : private Noncopyable
+ public:
+ class ScopedLock :
+ private Noncopyable
{
- private:
+ private:
Semaphore *m_semaphore;
- public:
+ public:
explicit ScopedLock(Semaphore *semaphore);
~ScopedLock();
};
class Exception
{
- public:
+ public:
DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, CreateFailed)
DECLARE_EXCEPTION_TYPE(Base, LockFailed)
DECLARE_EXCEPTION_TYPE(Base, RemoveFailed)
};
-private:
+ private:
enum Type
{
Type_Unnamed,
sem_t *InternalGet() const;
void InternalDestroy();
-public:
+ public:
/**
* decrement the semaphore counter
*/
*/
void Unlock() const;
- /**
+ /**
* Remove a named semaphore
*
* @param fileName Name of the semaphore
#include <map>
namespace DPL {
-
// Abstract data stream buffer
-class IStream {
+class IStream
+{
public:
virtual void Read(size_t num, void * bytes) = 0;
virtual void Write(size_t num, const void * bytes) = 0;
- virtual ~IStream(){};
+ virtual ~IStream(){}
};
// Serializable interface
-class ISerializable {
+class ISerializable
+{
public:
-/* ISerializable(){};
- ISerializable(IStream&){}; */
+ /* ISerializable(){};
+ * ISerializable(IStream&){}; */
virtual void Serialize(IStream &) const = 0;
- virtual ~ISerializable(){};
+ virtual ~ISerializable(){}
};
struct Serialization {
-// serialization
-// normal functions
+ // serialization
+ // normal functions
-// ISerializable objects
-static void Serialize(IStream& stream, const ISerializable& object){
- object.Serialize(stream);
-}
-static void Serialize(IStream& stream, const ISerializable* const object){
- object->Serialize(stream);
-}
+ // ISerializable objects
+ static void Serialize(IStream& stream, const ISerializable& object)
+ {
+ object.Serialize(stream);
+ }
+ static void Serialize(IStream& stream, const ISerializable* const object)
+ {
+ object->Serialize(stream);
+ }
-// unsigned int
-static void Serialize(IStream& stream, const unsigned value){
- stream.Write(sizeof(value),&value);
-}
-static void Serialize(IStream& stream, const unsigned* const value){
- stream.Write(sizeof(*value),value);
-}
+ // unsigned int
+ static void Serialize(IStream& stream, const unsigned value)
+ {
+ stream.Write(sizeof(value), &value);
+ }
+ static void Serialize(IStream& stream, const unsigned* const value)
+ {
+ stream.Write(sizeof(*value), value);
+ }
-// int
-static void Serialize(IStream& stream, const int value){
- stream.Write(sizeof(value),&value);
-}
-static void Serialize(IStream& stream, const int* const value){
- stream.Write(sizeof(*value),value);
-}
+ // int
+ static void Serialize(IStream& stream, const int value)
+ {
+ stream.Write(sizeof(value), &value);
+ }
+ static void Serialize(IStream& stream, const int* const value)
+ {
+ stream.Write(sizeof(*value), value);
+ }
-// bool
-static void Serialize(IStream& stream, const bool value){
- stream.Write(sizeof(value),&value);
-}
-static void Serialize(IStream& stream, const bool* const value){
- stream.Write(sizeof(*value),value);
-}
+ // bool
+ static void Serialize(IStream& stream, const bool value)
+ {
+ stream.Write(sizeof(value), &value);
+ }
+ static void Serialize(IStream& stream, const bool* const value)
+ {
+ stream.Write(sizeof(*value), value);
+ }
-// std::string
-static void Serialize(IStream& stream, const std::string& str){
- int length = str.size();
- stream.Write(sizeof(length),&length);
- stream.Write(length,str.c_str());
-}
-static void Serialize(IStream& stream, const std::string* const str){
- int length = str->size();
- stream.Write(sizeof(length),&length);
- stream.Write(length,str->c_str());
-}
+ // std::string
+ static void Serialize(IStream& stream, const std::string& str)
+ {
+ int length = str.size();
+ stream.Write(sizeof(length), &length);
+ stream.Write(length, str.c_str());
+ }
+ static void Serialize(IStream& stream, const std::string* const str)
+ {
+ int length = str->size();
+ stream.Write(sizeof(length), &length);
+ stream.Write(length, str->c_str());
+ }
-// STL templates
+ // STL templates
-// std::list
-template <typename T>
-static void Serialize(IStream& stream, const std::list<T>& list){
- int length = list.size();
- stream.Write(sizeof(length),&length);
- for(typename std::list<T>::const_iterator list_iter = list.begin();
- list_iter != list.end(); list_iter++)
- {
- Serialize(stream, *list_iter);
- }
-}
-template <typename T>
-static void Serialize(IStream& stream, const std::list<T>* const list){
- Serialize(stream,*list);
-}
+ // std::list
+ template <typename T>
+ static void Serialize(IStream& stream, const std::list<T>& list)
+ {
+ int length = list.size();
+ stream.Write(sizeof(length), &length);
+ for (typename std::list<T>::const_iterator list_iter = list.begin();
+ list_iter != list.end(); list_iter++)
+ {
+ Serialize(stream, *list_iter);
+ }
+ }
+ template <typename T>
+ static void Serialize(IStream& stream, const std::list<T>* const list)
+ {
+ Serialize(stream, *list);
+ }
-// std::vector
-template <typename T>
-static void Serialize(IStream& stream, const std::vector<T>& vec){
- int length = vec.size();
- stream.Write(sizeof(length),&length);
- for(typename std::vector<T>::const_iterator vec_iter = vec.begin();
- vec_iter != vec.end(); vec_iter ++)
- {
- Serialize(stream, *vec_iter);
- }
-}
-template <typename T>
-static void Serialize(IStream& stream, const std::vector<T>* const vec){
- Serialize(stream,*vec);
-}
+ // std::vector
+ template <typename T>
+ static void Serialize(IStream& stream, const std::vector<T>& vec)
+ {
+ int length = vec.size();
+ stream.Write(sizeof(length), &length);
+ for (typename std::vector<T>::const_iterator vec_iter = vec.begin();
+ vec_iter != vec.end(); vec_iter++)
+ {
+ Serialize(stream, *vec_iter);
+ }
+ }
+ template <typename T>
+ static void Serialize(IStream& stream, const std::vector<T>* const vec)
+ {
+ Serialize(stream, *vec);
+ }
-// std::pair
-template <typename A, typename B>
-static void Serialize(IStream& stream, const std::pair<A,B>& p){
- Serialize(stream, p.first);
- Serialize(stream, p.second);
-}
-template <typename A, typename B>
-static void Serialize(IStream& stream, const std::pair<A,B>* const p){
- Serialize(stream,*p);
-}
+ // std::pair
+ template <typename A, typename B>
+ static void Serialize(IStream& stream, const std::pair<A, B>& p)
+ {
+ Serialize(stream, p.first);
+ Serialize(stream, p.second);
+ }
+ template <typename A, typename B>
+ static void Serialize(IStream& stream, const std::pair<A, B>* const p)
+ {
+ Serialize(stream, *p);
+ }
-// std::map
-template <typename K, typename T>
-static void Serialize(IStream& stream, const std::map<K,T>& map){
- int length = map.size();
- stream.Write(sizeof(length),&length);
- typename std::map<K,T>::const_iterator it;
- for (it = map.begin(); it != map.end(); ++it) {
- Serialize(stream,(*it).first);
- Serialize(stream,(*it).second);
- }
-}
-template <typename K, typename T>
-static void Serialize(IStream& stream, const std::map<K,T>* const map){
- Serialize(stream,*map);
-}
+ // std::map
+ template <typename K, typename T>
+ static void Serialize(IStream& stream, const std::map<K, T>& map)
+ {
+ int length = map.size();
+ stream.Write(sizeof(length), &length);
+ typename std::map<K, T>::const_iterator it;
+ for (it = map.begin(); it != map.end(); ++it) {
+ Serialize(stream, (*it).first);
+ Serialize(stream, (*it).second);
+ }
+ }
+ template <typename K, typename T>
+ static void Serialize(IStream& stream, const std::map<K, T>* const map)
+ {
+ Serialize(stream, *map);
+ }
}; // struct Serialization
struct Deserialization {
-// deserialization
-// normal functions
+ // deserialization
+ // normal functions
-// ISerializable objects
-// T instead of ISerializable is needed to call proper constructor
-template <typename T>
-static void Deserialize(IStream& stream, T& object){
- object = T(stream);
-}
-template <typename T>
-static void Deserialize(IStream& stream, T*& object){
- object = new T(stream);
-}
+ // ISerializable objects
+ // T instead of ISerializable is needed to call proper constructor
+ template <typename T>
+ static void Deserialize(IStream& stream, T& object)
+ {
+ object = T(stream);
+ }
+ template <typename T>
+ static void Deserialize(IStream& stream, T*& object)
+ {
+ object = new T(stream);
+ }
-// unsigned int
-static void Deserialize(IStream& stream, unsigned& value){
- stream.Read(sizeof(value),&value);
-}
-static void Deserialize(IStream& stream, unsigned*& value){
- value = new unsigned;
- stream.Read(sizeof(*value),value);
-}
+ // unsigned int
+ static void Deserialize(IStream& stream, unsigned& value)
+ {
+ stream.Read(sizeof(value), &value);
+ }
+ static void Deserialize(IStream& stream, unsigned*& value)
+ {
+ value = new unsigned;
+ stream.Read(sizeof(*value), value);
+ }
-// int
-static void Deserialize(IStream& stream, int& value){
- stream.Read(sizeof(value),&value);
-}
-static void Deserialize(IStream& stream, int*& value){
- value = new int;
- stream.Read(sizeof(*value),value);
-}
+ // int
+ static void Deserialize(IStream& stream, int& value)
+ {
+ stream.Read(sizeof(value), &value);
+ }
+ static void Deserialize(IStream& stream, int*& value)
+ {
+ value = new int;
+ stream.Read(sizeof(*value), value);
+ }
-// bool
-static void Deserialize(IStream& stream, bool& value){
- stream.Read(sizeof(value),&value);
-}
-static void Deserialize(IStream& stream, bool*& value){
- value = new bool;
- stream.Read(sizeof(*value),value);
-}
+ // bool
+ static void Deserialize(IStream& stream, bool& value)
+ {
+ stream.Read(sizeof(value), &value);
+ }
+ static void Deserialize(IStream& stream, bool*& value)
+ {
+ value = new bool;
+ stream.Read(sizeof(*value), value);
+ }
-// std::string
-static void Deserialize(IStream& stream, std::string& str){
- int length;
- stream.Read(sizeof(length),&length);
- char * buf = new char[length+1];
- stream.Read(length,buf);
- buf[length] = 0;
- str = std::string(buf);
- delete [] buf;
-}
-static void Deserialize(IStream& stream, std::string*& str){
- int length;
- stream.Read(sizeof(length),&length);
- char * buf = new char[length+1];
- stream.Read(length,buf);
- buf[length] = 0;
- str = new std::string(buf);
- delete [] buf;
-}
+ // std::string
+ static void Deserialize(IStream& stream, std::string& str)
+ {
+ int length;
+ stream.Read(sizeof(length), &length);
+ char * buf = new char[length + 1];
+ stream.Read(length, buf);
+ buf[length] = 0;
+ str = std::string(buf);
+ delete[] buf;
+ }
+ static void Deserialize(IStream& stream, std::string*& str)
+ {
+ int length;
+ stream.Read(sizeof(length), &length);
+ char * buf = new char[length + 1];
+ stream.Read(length, buf);
+ buf[length] = 0;
+ str = new std::string(buf);
+ delete[] buf;
+ }
-// STL templates
+ // STL templates
-// std::list
-template <typename T>
-static void Deserialize(IStream& stream, std::list<T>& list){
- int length;
- stream.Read(sizeof(length),&length);
- for (int i = 0; i < length; ++i) {
- T obj;
- Deserialize(stream, obj);
- list.push_back(obj);
- }
-}
-template <typename T>
-static void Deserialize(IStream& stream, std::list<T>*& list){
- list = new std::list<T>;
- Deserialize(stream,*list);
-}
+ // std::list
+ template <typename T>
+ static void Deserialize(IStream& stream, std::list<T>& list)
+ {
+ int length;
+ stream.Read(sizeof(length), &length);
+ for (int i = 0; i < length; ++i) {
+ T obj;
+ Deserialize(stream, obj);
+ list.push_back(obj);
+ }
+ }
+ template <typename T>
+ static void Deserialize(IStream& stream, std::list<T>*& list)
+ {
+ list = new std::list<T>;
+ Deserialize(stream, *list);
+ }
-// std::vector
-template <typename T>
-static void Deserialize(IStream& stream, std::vector<T>& vec){
- int length;
- stream.Read(sizeof(length),&length);
- for (int i = 0; i < length; ++i) {
- T obj;
- Deserialize(stream, obj);
- vec.push_back(obj);
- }
-}
-template <typename T>
-static void Deserialize(IStream& stream, std::vector<T>*& vec){
- vec = new std::vector<T>;
- Deserialize(stream,*vec);
-}
+ // std::vector
+ template <typename T>
+ static void Deserialize(IStream& stream, std::vector<T>& vec)
+ {
+ int length;
+ stream.Read(sizeof(length), &length);
+ for (int i = 0; i < length; ++i) {
+ T obj;
+ Deserialize(stream, obj);
+ vec.push_back(obj);
+ }
+ }
+ template <typename T>
+ static void Deserialize(IStream& stream, std::vector<T>*& vec)
+ {
+ vec = new std::vector<T>;
+ Deserialize(stream, *vec);
+ }
-// std::pair
-template <typename A, typename B>
-static void Deserialize(IStream& stream, std::pair<A,B>& p){
- Deserialize(stream, p.first);
- Deserialize(stream, p.second);
-}
-template <typename A, typename B>
-static void Deserialize(IStream& stream, std::pair<A,B>*& p){
- p = new std::pair<A,B>;
- Deserialize(stream,*p);
-}
+ // std::pair
+ template <typename A, typename B>
+ static void Deserialize(IStream& stream, std::pair<A, B>& p)
+ {
+ Deserialize(stream, p.first);
+ Deserialize(stream, p.second);
+ }
+ template <typename A, typename B>
+ static void Deserialize(IStream& stream, std::pair<A, B>*& p)
+ {
+ p = new std::pair<A, B>;
+ Deserialize(stream, *p);
+ }
-// std::map
-template <typename K, typename T>
-static void Deserialize(IStream& stream, std::map<K,T>& map){
- int length;
- stream.Read(sizeof(length),&length);
- for (int i = 0; i < length; ++i) {
- K key;
- T obj;
- Deserialize(stream,key);
- Deserialize(stream,obj);
- map[key] = obj;
- }
-}
-template <typename K, typename T>
-static void Deserialize(IStream& stream, std::map<K,T>*& map){
- map = new std::map<K,T>;
- Deserialize(stream,*map);
-}
+ // std::map
+ template <typename K, typename T>
+ static void Deserialize(IStream& stream, std::map<K, T>& map)
+ {
+ int length;
+ stream.Read(sizeof(length), &length);
+ for (int i = 0; i < length; ++i) {
+ K key;
+ T obj;
+ Deserialize(stream, key);
+ Deserialize(stream, obj);
+ map[key] = obj;
+ }
+ }
+ template <typename K, typename T>
+ static void Deserialize(IStream& stream, std::map<K, T>*& map)
+ {
+ map = new std::map<K, T>;
+ Deserialize(stream, *map);
+ }
}; // struct Deserialization
-
} // namespace DPL
#endif // SERIALIZATION_H
#include <stddef.h>
#include <dpl/assert.h>
-namespace DPL
-{
+namespace DPL {
struct StaticPointerCastTag {};
struct ConstPointerCastTag {};
struct DynamicPointerCastTag {};
struct SharedCounter
{
- SharedCounter()
- : ref(1)
- {
- }
+ SharedCounter() :
+ ref(1)
+ {}
Atomic ref;
};
class EnableSharedFromThis;
template<typename Other>
-inline void _Internal_AcceptSharedPtr(SharedCounter *counter, Other *other, EnableSharedFromThis<Other> *otherBase)
+inline void _Internal_AcceptSharedPtr(SharedCounter *counter,
+ Other *other,
+ EnableSharedFromThis<Other> *otherBase)
{
otherBase->_Internal_AcceptSharedPtr(counter, other);
}
{
template<typename Other>
AnyPointer(Other *)
- {
- }
+ {}
};
inline void _Internal_AcceptSharedPtr(SharedCounter *, AnyPointer, AnyPointer)
-{
-}
+{}
template<typename Class>
class SharedPtr
{
-public:
+ public:
typedef Class ValueType;
typedef SharedPtr<Class> ThisType;
-private:
+ private:
SharedCounter *m_counter;
Class *m_ptr;
// Attention: R-Value const cast
m_counter = const_cast<SharedCounter *>(counter);
- if (m_counter != NULL)
+ if (m_counter != NULL) {
++m_counter->ref;
+ }
}
void DetachCounter()
{
- if (m_counter)
- {
- if (!--m_counter->ref)
- {
+ if (m_counter) {
+ if (!--m_counter->ref) {
delete m_ptr;
delete m_counter;
}
}
}
-public:
- SharedPtr()
- : m_counter(NULL),
- m_ptr(NULL)
- {
- }
+ public:
+ SharedPtr() :
+ m_counter(NULL),
+ m_ptr(NULL)
+ {}
- explicit SharedPtr(Class *ptr)
- : m_counter(NULL),
- m_ptr(ptr)
+ explicit SharedPtr(Class *ptr) :
+ m_counter(NULL),
+ m_ptr(ptr)
{
- if (m_ptr != NULL)
- {
+ if (m_ptr != NULL) {
m_counter = new SharedCounter();
_Internal_AcceptSharedPtr(m_counter, m_ptr, m_ptr);
}
}
- SharedPtr(const SharedPtr &other)
- : m_counter(NULL),
- m_ptr(other.m_ptr)
+ SharedPtr(const SharedPtr &other) :
+ m_counter(NULL),
+ m_ptr(other.m_ptr)
{
AttachCounter(other.m_counter);
}
- SharedPtr(SharedCounter *counter, Class *ptr)
- : m_counter(NULL),
- m_ptr(ptr)
+ SharedPtr(SharedCounter *counter, Class *ptr) :
+ m_counter(NULL),
+ m_ptr(ptr)
{
AttachCounter(counter);
}
friend class SharedPtr;
template<typename Other>
- SharedPtr(const SharedPtr<Other> &other, const StaticPointerCastTag &)
- : m_counter(NULL),
- m_ptr(NULL)
+ SharedPtr(const SharedPtr<Other> &other, const StaticPointerCastTag &) :
+ m_counter(NULL),
+ m_ptr(NULL)
{
m_ptr = static_cast<Class *>(other.m_ptr);
AttachCounter(other.m_counter);
}
template<typename Other>
- SharedPtr(const SharedPtr<Other> &other, const ConstPointerCastTag &)
- : m_counter(NULL),
- m_ptr(NULL)
+ SharedPtr(const SharedPtr<Other> &other, const ConstPointerCastTag &) :
+ m_counter(NULL),
+ m_ptr(NULL)
{
m_ptr = const_cast<Class *>(other.m_ptr);
AttachCounter(other.m_counter);
}
template<typename Other>
- SharedPtr(const SharedPtr<Other> &other, const DynamicPointerCastTag &)
- : m_counter(NULL),
- m_ptr(NULL)
+ SharedPtr(const SharedPtr<Other> &other, const DynamicPointerCastTag &) :
+ m_counter(NULL),
+ m_ptr(NULL)
{
Class *ptr = dynamic_cast<Class *>(other.Get());
- if (ptr == NULL)
+ if (ptr == NULL) {
return;
+ }
m_ptr = ptr;
AttachCounter(other.m_counter);
{
DetachCounter();
- if (ptr != NULL)
- {
+ if (ptr != NULL) {
m_ptr = ptr;
m_counter = new SharedCounter();
_Internal_AcceptSharedPtr(m_counter, m_ptr, m_ptr);
SharedPtr &operator=(const SharedPtr &other)
{
- if (this != &other)
- {
+ if (this != &other) {
DetachCounter();
m_ptr = other.m_ptr;
AttachCounter(other.m_counter);
Atomic::ValueType GetUseCount() const
{
- if (m_counter == NULL)
+ if (m_counter == NULL) {
return Atomic::ValueType(0);
+ }
return m_counter->ref;
}
}
template<typename First, typename Second>
-inline bool operator ==(const SharedPtr<First> &first, const SharedPtr<Second> &second)
+inline bool operator ==(const SharedPtr<First> &first,
+ const SharedPtr<Second> &second)
{
return first.Get() == second.Get();
}
template<typename First, typename Second>
-inline bool operator !=(const SharedPtr<First> &first, const SharedPtr<Second> &second)
+inline bool operator !=(const SharedPtr<First> &first,
+ const SharedPtr<Second> &second)
{
return first.Get() != second.Get();
}
template<typename First, typename Second>
-inline bool operator <(const SharedPtr<First> &first, const SharedPtr<Second> &second)
+inline bool operator <(const SharedPtr<First> &first,
+ const SharedPtr<Second> &second)
{
return first.Get() < second.Get();
}
template<typename First, typename Second>
-inline bool operator >(const SharedPtr<First> &first, const SharedPtr<Second> &second)
+inline bool operator >(const SharedPtr<First> &first,
+ const SharedPtr<Second> &second)
{
return first.Get() > second.Get();
}
template<typename First, typename Second>
-inline bool operator <=(const SharedPtr<First> &first, const SharedPtr<Second> &second)
+inline bool operator <=(const SharedPtr<First> &first,
+ const SharedPtr<Second> &second)
{
return first.Get() <= second.Get();
}
template<typename First, typename Second>
-inline bool operator >=(const SharedPtr<First> &first, const SharedPtr<Second> &second)
+inline bool operator >=(const SharedPtr<First> &first,
+ const SharedPtr<Second> &second)
{
return first.Get() >= second.Get();
}
-
} // namespace DPL
#endif // DPL_SHARED_PTR_H
#include <dpl/exception.h>
#include <string>
-namespace DPL
+namespace DPL {
+class SingleInstance :
+ private Noncopyable
{
-class SingleInstance
- : private Noncopyable
-{
-public:
+ public:
class Exception
{
- public:
+ public:
DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, LockError)
DECLARE_EXCEPTION_TYPE(Base, ReleaseError)
};
-private:
+ private:
bool m_locked;
int m_fdLock;
-public:
+ public:
SingleInstance();
virtual ~SingleInstance();
#include <dpl/thread.h>
#include <dpl/assert.h>
-namespace DPL
-{
+namespace DPL {
template<typename Class>
-class Singleton
- : private Class
+class Singleton :
+ private Class
{
//
// Note:
// make Class' default constructor protected
//
-private:
+ private:
Singleton()
- {
- }
+ {}
typedef Optional<Thread *> OptionalThreadPtr;
- OptionalThreadPtr m_guard;
static Singleton &InternalInstance();
-public:
+ public:
virtual ~Singleton()
- {
- }
+ {}
static Class &Instance();
-
- // Thread guarding
- static void SetThreadGuard(Thread *thread);
- static void ResetThreadGuard();
};
-
} // namespace DPL
#endif // DPL_SINGLETON_H
* singleton_safe_impl.h if possible.
*/
-namespace DPL
-{
-
+namespace DPL {
template<typename Class>
Singleton<Class>& Singleton<Class>::InternalInstance()
{
Class &Singleton<Class>::Instance()
{
Singleton<Class>& instance = Singleton<Class>::InternalInstance();
-
- if (!!instance.m_guard)
- {
- Assert(Thread::GetCurrentThread() == *instance.m_guard &&
- "Singleton thread guard failed. A forbidden call from foreign thread was detected!");
- }
-
return instance;
}
-
-// Thread guarding
-template<typename Class>
-void Singleton<Class>::SetThreadGuard(Thread *thread)
-{
- Singleton<Class>& instance = Singleton<Class>::InternalInstance();
- instance.m_guard = OptionalThreadPtr(thread);
-}
-
-template<typename Class>
-void Singleton<Class>::ResetThreadGuard()
-{
- Singleton<Class>& instance = Singleton<Class>::InternalInstance();
- instance.m_guard = OptionalThreadPtr::Null;
-}
-
} // namespace DPL
#define IMPLEMENT_SINGLETON(Type) \
-template DPL::Singleton<Type>& DPL::Singleton<Type>::InternalInstance(); \
-template Type& DPL::Singleton<Type>::Instance(); \
-template void DPL::Singleton<Type>::SetThreadGuard(DPL::Thread *thread); \
-template void DPL::Singleton<Type>::ResetThreadGuard();
+ template DPL::Singleton<Type>&DPL::Singleton<Type>::InternalInstance(); \
+ template Type & DPL::Singleton<Type>::Instance(); \
#endif // DPL_SINGLETON_IMPL_H
#define DPL_SINGLETON_SAFE_IMPL_H
#define IMPLEMENT_SAFE_SINGLETON(Class) \
-namespace DPL { \
-template<> \
-Singleton<Class>& Singleton<Class>::InternalInstance() \
-{ \
- static Singleton<Class> instance; \
- return instance; \
-} \
+ namespace DPL { \
+ template<> \
+ Singleton<Class>&Singleton<Class>::InternalInstance() \
+ { \
+ static Singleton<Class> instance; \
+ return instance; \
+ } \
\
-template<> \
-Class &Singleton<Class>::Instance() \
-{ \
- Singleton<Class>& instance = Singleton<Class>::InternalInstance(); \
- if (!!instance.m_guard) \
- { \
- Assert(Thread::GetCurrentThread() == *instance.m_guard && \
- "Singleton thread guard failed. A forbidden call from foreign thread was detected!");\
- } \
- return instance; \
-} \
+ template<> \
+ Class & Singleton<Class>::Instance() \
+ { \
+ Singleton<Class>& instance = Singleton<Class>::InternalInstance(); \
+ return instance; \
+ } \
\
-template<> \
-void Singleton<Class>::SetThreadGuard(Thread *thread) \
-{ \
- Singleton<Class>& instance = Singleton<Class>::InternalInstance(); \
- instance.m_guard = OptionalThreadPtr(thread); \
-} \
- \
-template<> \
-void Singleton<Class>::ResetThreadGuard() \
-{ \
- Singleton<Class>& instance = Singleton<Class>::InternalInstance(); \
- instance.m_guard = OptionalThreadPtr::Null; \
-} \
-template Singleton<Class>& Singleton<Class>::InternalInstance(); \
-template Class& Singleton<Class>::Instance(); \
-template void Singleton<Class>::SetThreadGuard(Thread *thread); \
-template void Singleton<Class>::ResetThreadGuard(); \
-} // namespace DPL
-
+ template Singleton<Class>&Singleton<Class>::InternalInstance(); \
+ template Class & Singleton<Class>::Instance(); \
+ } // namespace DPL
#endif // DPL_SINGLETON_SAFE_IMPL_H
#include <sstream>
#include <dpl/string.h>
-namespace DPL
-{
-
+namespace DPL {
// @brief DPL IStringStream
typedef std::basic_istringstream<CharTraits::char_type,
CharTraits> IStringStream;
// @brief DPL OStringStream
typedef std::basic_ostringstream<CharTraits::char_type,
CharTraits> OStringStream;
-
} //namespace DPL
-
#endif // DPL_CORE_INCLUDE_SSTREAM_H_
--- /dev/null
+/*
+ * Copyright (c) 2013 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 static_block.h
+ * @author Iwanek Tomasz (t.iwanek@samsung.com)
+ * @version 1.0
+ */
+#ifndef STATIC_BLOCK_H
+#define STATIC_BLOCK_H
+
+#include <dpl/preprocessor.h>
+
+//NOTE: order of static initialization of blocks is not specified
+
+// to be used only outside class of function scopes
+#define STATIC_BLOCK_IMPL( UNIQUE ) \
+ static void DPL_MACRO_CONCAT( _staticBlock , UNIQUE() ); \
+ static int DPL_MACRO_CONCAT( _staticBlockInitAssurence , UNIQUE ) = []() -> int \
+ { \
+ (void) DPL_MACRO_CONCAT( _staticBlockInitAssurence , UNIQUE ); \
+ DPL_MACRO_CONCAT( _staticBlock , UNIQUE() ); \
+ return 0; \
+ }(); \
+ void DPL_MACRO_CONCAT( _staticBlock , UNIQUE() ) \
+
+#define STATIC_BLOCK \
+ STATIC_BLOCK_IMPL( __COUNTER__ ) \
+
+//for class implementation
+#define STATIC_BLOCK_CLASS( classname, methodname ) STATIC_BLOCK { classname::methodname(); }
+
+#endif // STATIC_BLOCK_H
#include <dpl/char_traits.h>
#include <string>
#include <ostream>
+#include <numeric>
-namespace DPL
-{
+namespace DPL {
// @brief DPL string
typedef std::basic_string<wchar_t, CharTraits> String;
// @brief String exception class
class StringException
{
-public:
+ public:
DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
// @brief Invalid init for UTF8 to UTF32 converter
//@brief Splits the string into substrings.
//@param[in] str Input string
-//@param[in] delimiters array or string containing a sequence of substring delimiters. Can be also a single delimiter character.
+//@param[in] delimiters array or string containing a sequence of substring
+// delimiters. Can be also a single delimiter character.
//@param[in] it InserterIterator that is used to save the generated substrings.
template<typename StringType, typename Delimiters, typename InserterIterator>
-void Tokenize(const StringType& str, const Delimiters& delimiters, InserterIterator it, bool ignoreEmpty = false)
+void Tokenize(const StringType& str,
+ const Delimiters& delimiters,
+ InserterIterator it,
+ bool ignoreEmpty = false)
{
typename StringType::size_type nextSearchStart = 0;
typename StringType::size_type pos;
typename StringType::size_type length;
- while ( true )
- {
+ while (true) {
pos = str.find_first_of(delimiters, nextSearchStart);
- length = ((pos == StringType::npos) ? str.length() : pos) - nextSearchStart;
+ length =
+ ((pos == StringType::npos) ? str.length() : pos) - nextSearchStart;
- if ( !ignoreEmpty || length > 0 )
- {
+ if (!ignoreEmpty || length > 0) {
*it = str.substr(nextSearchStart, length);
it++;
}
- if ( pos == StringType::npos )
+ if (pos == StringType::npos) {
return;
+ }
nextSearchStart = pos + 1;
}
}
+namespace Utils {
+
+template<typename T> class ConcatFunc : public std::binary_function<T, T, T>
+{
+public:
+ explicit ConcatFunc(const T & val) : m_delim(val) {}
+ T operator()(const T & arg1, const T & arg2) const
+ {
+ return arg1 + m_delim + arg2;
+ }
+private:
+ T m_delim;
+};
+
+}
+
+template<typename ForwardIterator>
+typename ForwardIterator::value_type Join(ForwardIterator begin, ForwardIterator end, typename ForwardIterator::value_type delim)
+{
+ typedef typename ForwardIterator::value_type value;
+ if(begin == end) return value();
+ Utils::ConcatFunc<value> func(delim);
+ ForwardIterator init = begin;
+ return std::accumulate(++begin, end, *init, func);
+}
+
} //namespace DPL
std::ostream& operator<<(std::ostream& aStream, const DPL::String& aString);
#include <algorithm>
#include <list>
-namespace DPL
-{
+namespace DPL {
class TaskList;
-class Task
- : private Noncopyable
+class Task :
+ private Noncopyable
{
-public:
+ public:
virtual ~Task() {}
virtual bool NextStep() = 0;
};
template<typename Impl>
-class TaskDecl
- : public Task
+class TaskDecl :
+ public Task
{
-protected:
+ protected:
typedef void (Impl::*Step)();
-private:
+ private:
typedef std::list<Step> StepList;
StepList m_steps;
Impl *m_impl;
bool m_running;
-protected:
+ protected:
void AddStep(Step step)
{
Assert(!m_running && "AddStep is not allowed after calling NextStep!");
- Assert(m_steps.end() == std::find(m_steps.begin(), m_steps.end(), step) && "The same step started twice is not supported");
+ Assert(m_steps.end() == std::find(m_steps.begin(),
+ m_steps.end(),
+ step) &&
+ "The same step started twice is not supported");
m_steps.push_back(step);
m_nextStep = m_steps.begin();
}
void AddAbortStep(Step step)
{
- Assert(!m_running && "AddAbortStep is not allowed after calling NextStep!");
- Assert(m_abortSteps.end() == std::find(m_abortSteps.begin(), m_abortSteps.end(), step) && "The same step started twice is not supported");
+ Assert(
+ !m_running && "AddAbortStep is not allowed after calling NextStep!");
+ Assert(m_abortSteps.end() ==
+ std::find(m_abortSteps.begin(),
+ m_abortSteps.end(),
+ step) &&
+ "The same step started twice is not supported");
m_abortSteps.push_front(step);
}
void SwitchToStep(Step step)
{
- /// @TODO There can be problem here if user sets the same method two times in task list.
- typename StepList::iterator i = std::find(m_steps.begin(), m_steps.end(), step);
+ /// @TODO There can be problem here if user sets the same method two
+ // times in task list.
+ typename StepList::iterator i = std::find(m_steps.begin(),
+ m_steps.end(), step);
Assert(i != m_steps.end());
m_nextStep = i;
m_switched = true;
Step GetCurrentStep() const
{
- if(m_currentStep == m_steps.end())
+ if (m_currentStep == m_steps.end()) {
return NULL;
+ }
return *m_currentStep;
}
-public:
- TaskDecl(Impl *impl)
- : m_switched(false),
- m_impl(impl),
- m_running(false)
+ public:
+ TaskDecl(Impl *impl) :
+ m_switched(false),
+ m_impl(impl),
+ m_running(false)
{
Assert(this == m_impl);
m_currentStep = m_steps.end();
{
m_running = true;
- Assert(m_nextStep != m_steps.end() && "Step list is empty or all steps done");
+ Assert(
+ m_nextStep != m_steps.end() &&
+ "Step list is empty or all steps done");
m_switched = false;
m_currentStep = m_nextStep;
- if (m_switched)
+ if (m_switched) {
return true;
- else
+ } else {
return ++m_nextStep != m_steps.end();
+ }
}
bool Abort()
m_steps.clear();
- if (m_abortSteps.empty())
+ if (m_abortSteps.empty()) {
return false;
+ }
- FOREACH (it, m_abortSteps)
- m_steps.push_back(*it);
+ FOREACH(it, m_abortSteps)
+ m_steps.push_back(*it);
m_nextStep = m_steps.begin();
#include <dpl/task.h>
#include <list>
-namespace DPL
+namespace DPL {
+class TaskList :
+ public Task
{
-class TaskList
- : public Task
-{
-private:
+ private:
typedef std::list<Task *> Tasks;
Tasks m_tasks;
bool m_running;
-protected:
+ protected:
void AddTask(Task *task);
void SwitchToTask(Task *task);
-public:
+ public:
TaskList();
virtual ~TaskList();
#include <list>
#include <map>
-namespace DPL
+namespace DPL {
+class Thread :
+ private Noncopyable,
+ public WaitableHandleWatchSupport
{
-class Thread
- : private Noncopyable,
- public WaitableHandleWatchSupport
-{
-public:
+ public:
class Exception
{
- public:
+ public:
DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, CreateFailed)
DECLARE_EXCEPTION_TYPE(Base, DestroyFailed)
typedef void (*EventDeleteProc)(void *event, void *userParam);
typedef void (*EventDispatchProc)(void *event, void *userParam);
-protected:
+ protected:
/**
* Main thread entry
* The method is intended to be overloaded with custom code.
*/
int Exec();
-private:
+ private:
struct InternalEvent
{
void *event;
InternalEvent(void *eventArg,
void *userParamArg,
EventDispatchProc eventDispatchProcArg,
- EventDeleteProc eventDeleteProcArg)
- : event(eventArg),
- userParam(userParamArg),
- eventDispatchProc(eventDispatchProcArg),
- eventDeleteProc(eventDeleteProcArg)
- {
- }
+ EventDeleteProc eventDeleteProcArg) :
+ event(eventArg),
+ userParam(userParamArg),
+ eventDispatchProc(eventDispatchProcArg),
+ eventDeleteProc(eventDeleteProcArg)
+ {}
};
- struct InternalTimedEvent
- : InternalEvent
+ struct InternalTimedEvent :
+ InternalEvent
{
unsigned long dueTimeMiliseconds;
unsigned long registerTimeMiliseconds;
unsigned long dueTimeMilisecondsArg,
unsigned long registerTimeMilisecondsArg,
EventDispatchProc eventDispatchProcArg,
- EventDeleteProc eventDeleteProcArg)
- : InternalEvent(eventArg,
- userParamArg,
- eventDispatchProcArg,
- eventDeleteProcArg),
- dueTimeMiliseconds(dueTimeMilisecondsArg),
- registerTimeMiliseconds(registerTimeMilisecondsArg)
- {
- }
+ EventDeleteProc eventDeleteProcArg) :
+ InternalEvent(eventArg,
+ userParamArg,
+ eventDispatchProcArg,
+ eventDeleteProcArg),
+ dueTimeMiliseconds(dueTimeMilisecondsArg),
+ registerTimeMiliseconds(registerTimeMilisecondsArg)
+ {}
bool operator<(const InternalTimedEvent &other)
{
- return registerTimeMiliseconds + dueTimeMiliseconds > other.registerTimeMiliseconds + other.dueTimeMiliseconds;
+ return registerTimeMiliseconds + dueTimeMiliseconds >
+ other.registerTimeMiliseconds + other.dueTimeMiliseconds;
}
};
static void *StaticThreadEntry(void *param);
-public:
+ public:
explicit Thread();
virtual ~Thread();
/**
* Low-level event push, usually used only by EventSupport
*/
- void PushEvent(void *event, EventDispatchProc eventDispatchProc, EventDeleteProc eventDeleteProc, void *userParam);
+ void PushEvent(void *event,
+ EventDispatchProc eventDispatchProc,
+ EventDeleteProc eventDeleteProc,
+ void *userParam);
/**
* Low-level timed event push, usually used only by EventSupport
*/
- void PushTimedEvent(void *event, double dueTimeSeconds, EventDispatchProc eventDispatchProc, EventDeleteProc eventDeleteProc, void *userParam);
+ void PushTimedEvent(void *event,
+ double dueTimeSeconds,
+ EventDispatchProc eventDispatchProc,
+ EventDeleteProc eventDeleteProc,
+ void *userParam);
/**
* Sleep for a number of seconds
// (process can become non-responsive)
// TODO further investigation is required.
template<typename Type>
-class ThreadLocalVariable
- : public Noncopyable
+class ThreadLocalVariable :
+ public Noncopyable
{
-public:
+ public:
typedef Type ValueType;
class Exception
{
- public:
+ public:
DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, NullReference)
DECLARE_EXCEPTION_TYPE(Base, KeyCreateFailed)
};
-private:
+ private:
pthread_key_t m_key;
struct ManagedValue
{
// Destroy underlying type
ManagedValue *instance = static_cast<ManagedValue *>(specific);
- if(instance->guardKey.IsNull())
- {
+ if (instance->guardKey.IsNull()) {
delete instance;
- }
- else
- {
+ } else {
int result = pthread_setspecific(*(instance->guardKey), instance);
Assert(result == 0 &&
ManagedValue *instance =
static_cast<ManagedValue *>(pthread_getspecific(m_key));
- if (!instance)
- {
+ if (!instance) {
// Check if it is allowed to instantiate
- if (!allowInstantiate)
+ if (!allowInstantiate) {
Throw(typename Exception::NullReference);
+ }
// checking, if specific data is created for Main thread
// If yes, pthread_exit(NULL) is required
- if (!g_TLSforMainCreated)
- {
- if (Thread::IsMainThread())
- {
+ if (!g_TLSforMainCreated) {
+ if (Thread::IsMainThread()) {
g_TLSforMainCreated = true;
atexit(&MainThreadExitClean);
}
return instance->value;
}
-public:
+ public:
ThreadLocalVariable()
{
int result = pthread_key_create(&m_key, &InternalDestroy);
if (result != 0) {
ThrowMsg(typename Exception::KeyCreateFailed,
- "Failed to allocate thread local variable: " << result);
+ "Failed to allocate thread local variable: " << result);
}
}
ManagedValue *specific =
static_cast<ManagedValue *>(pthread_getspecific(m_key));
- if (!specific)
+ if (!specific) {
return;
+ }
// TODO Should be an assert? is it developers fault to Reset Guarded
// value?
#include <cstddef>
-namespace DPL
-{
+namespace DPL {
class TypeListGuard
{
-public:
+ public:
template<size_t Index>
struct Element
{
template<typename HeadType, typename TailType>
class TypeList
{
-private:
+ private:
class DummyClass
- {
- };
+ {};
template<typename List, size_t Enum>
- struct TypeCounter : public TypeCounter<typename List::Tail, Enum+1>
- {
- };
+ struct TypeCounter : public TypeCounter<typename List::Tail, Enum + 1>
+ {};
template<size_t Enum>
struct TypeCounter<TypeListGuard, Enum>
static const size_t Size = Enum;
};
-public:
+ public:
typedef TailType Tail;
typedef HeadType Head;
typedef TypeList<HeadType, TailType> ThisType;
static const size_t Size = TypeCounter<ThisType, 0>::Size;
};
-template<typename T1 = TypeListGuard, typename T2 = TypeListGuard,
- typename T3 = TypeListGuard, typename T4 = TypeListGuard,
- typename T5 = TypeListGuard, typename T6 = TypeListGuard,
- typename T7 = TypeListGuard, typename T8 = TypeListGuard,
- typename T9 = TypeListGuard, typename T10 = TypeListGuard,
+template<typename T1 = TypeListGuard, typename T2 = TypeListGuard,
+ typename T3 = TypeListGuard, typename T4 = TypeListGuard,
+ typename T5 = TypeListGuard, typename T6 = TypeListGuard,
+ typename T7 = TypeListGuard, typename T8 = TypeListGuard,
+ typename T9 = TypeListGuard, typename T10 = TypeListGuard,
typename T11 = TypeListGuard, typename T12 = TypeListGuard,
typename T13 = TypeListGuard, typename T14 = TypeListGuard,
typename T15 = TypeListGuard, typename T16 = TypeListGuard,
{
typedef TypeList<T1,
typename TypeListDecl<
- T2, T3, T4, T5, T6, T7, T8,
- T9, T10, T11, T12, T13, T14, T15,
+ T2, T3, T4, T5, T6, T7, T8,
+ T9, T10, T11, T12, T13, T14, T15,
T16, T17, T18, T19, T20, T21, T22,
T23, T24, T25, T26, T27, T28, T29,
T30, T31, T32, T33, T34, T35, T36,
#include <cstring>
-namespace DPL
-{
+namespace DPL {
template<typename TargetType, typename SourceType>
TargetType union_cast(const SourceType &data)
{
* @file unused.h
* @author Lukasz Wrzosek (l.wrzosek@samsung.com)
* @version 1.0
- * @brief This file is the implementation file of unused attribute from gcc
+ * @brief This file is the implementation file of unused attribute from
+ * gcc
*/
#ifndef DPL_UNUSED_H
#define DPL_UNUSED_H
#include <dpl/exception.h>
#include <vector>
-namespace DPL
+namespace DPL {
+class WaitableEvent :
+ private Noncopyable
{
-
-class WaitableEvent
- : private Noncopyable
-{
-public:
+ public:
class Exception
{
- public:
+ public:
DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, CreateFailed)
DECLARE_EXCEPTION_TYPE(Base, DestroyFailed)
DECLARE_EXCEPTION_TYPE(Base, ResetFailed)
};
-private:
+ private:
int m_pipe[2];
-public:
+ public:
WaitableEvent();
virtual ~WaitableEvent();
void Signal() const;
void Reset() const;
};
-
} // namespace DPL
#endif // DPL_WAITABLE_EVENT_H
#include <dpl/exception.h>
#include <vector>
-namespace DPL
-{
-
+namespace DPL {
/**
* Waitable unix wait handle definition
*/
*/
class WaitMode
{
-public:
+ public:
enum Type
{
Read, ///< Wait for readability state changes
/**
* Waitable handle list ex
*/
-typedef std::vector<std::pair<WaitableHandle, WaitMode::Type> > WaitableHandleListEx;
+typedef std::vector<std::pair<WaitableHandle,
+ WaitMode::Type> > WaitableHandleListEx;
/**
* Waitable handle index list
* @return Signaled waitable handle index list
* @throw WaitFailed Fatal error occurred while waiting for signal
*/
-WaitableHandleIndexList WaitForSingleHandle(WaitableHandle handle, unsigned long miliseconds = 0xFFFFFFFF);
+WaitableHandleIndexList WaitForSingleHandle(
+ WaitableHandle handle,
+ unsigned long miliseconds =
+ 0xFFFFFFFF);
/**
* Wait for single handle
* @return Signaled waitable handle index list
* @throw WaitFailed Fatal error occurred while waiting for signal
*/
-WaitableHandleIndexList WaitForSingleHandle(WaitableHandle handle, WaitMode::Type mode, unsigned long miliseconds = 0xFFFFFFFF);
+WaitableHandleIndexList WaitForSingleHandle(
+ WaitableHandle handle,
+ WaitMode::Type mode,
+ unsigned long miliseconds =
+ 0xFFFFFFFF);
/**
* Wait for multiple handles readability
* @return Signaled waitable handle index list
* @throw WaitFailed Fatal error occurred while waiting for signal
*/
-WaitableHandleIndexList WaitForMultipleHandles(const WaitableHandleList &handleList, unsigned long miliseconds = 0xFFFFFFFF);
+WaitableHandleIndexList WaitForMultipleHandles(
+ const WaitableHandleList &handleList,
+ unsigned long miliseconds = 0xFFFFFFFF);
/**
* Wait for multiple handles readability
* @return Signaled waitable handle index list
* @throw WaitFailed Fatal error occurred while waiting for signal
*/
-WaitableHandleIndexList WaitForMultipleHandles(const WaitableHandleListEx &handleListEx, unsigned long miliseconds = 0xFFFFFFFF);
-
+WaitableHandleIndexList WaitForMultipleHandles(
+ const WaitableHandleListEx &handleListEx,
+ unsigned long miliseconds = 0xFFFFFFFF);
} // namespace DPL
#endif // DPL_WAITABLE_HANDLE_H
* @file waitable_handle_watch_support.h
* @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
* @version 1.0
- * @brief This file is the implementation file of waitable handle watch support
+ * @brief This file is the implementation file of waitable handle watch
+ * support
*/
#ifndef DPL_WAITABLE_HANDLE_WATCH_SUPPORT_H
#define DPL_WAITABLE_HANDLE_WATCH_SUPPORT_H
#include <list>
#include <map>
-namespace DPL
-{
-
+namespace DPL {
class Thread;
class WaitableHandleWatchSupport
{
-public:
+ public:
class WaitableHandleListener
{
- public:
+ public:
virtual ~WaitableHandleListener() {}
- virtual void OnWaitableHandleEvent(WaitableHandle waitableHandle, WaitMode::Type mode) = 0;
+ virtual void OnWaitableHandleEvent(WaitableHandle waitableHandle,
+ WaitMode::Type mode) = 0;
};
-protected:
+ protected:
// Invoker waitable handle
// Signaled by Add/Remove methods
// After being signaled one must call Handle invoke to reset invoker
// Invoke direct invoker
virtual void HandleDirectInvoker() = 0;
-private:
+ private:
// Waitable event watchers
struct WaitableHandleWatcher
{
WaitableHandleListener *listener;
WaitMode::Type mode;
- WaitableHandleWatcher(WaitableHandleListener *l, WaitMode::Type m)
- : listener(l),
- mode(m)
- {
- }
+ WaitableHandleWatcher(WaitableHandleListener *l, WaitMode::Type m) :
+ listener(l),
+ mode(m)
+ {}
};
typedef std::list<WaitableHandleWatcher> WaitableHandleListenerList;
size_t readListenersCount;
size_t writeListenersCount;
- WaitableHandleWatchers()
- : readListenersCount(0),
- writeListenersCount(0)
- {
- }
+ WaitableHandleWatchers() :
+ readListenersCount(0),
+ writeListenersCount(0)
+ {}
};
- typedef std::map<WaitableHandle, WaitableHandleWatchers> WaitableHandleWatchersMap;
+ typedef std::map<WaitableHandle,
+ WaitableHandleWatchers> WaitableHandleWatchersMap;
// Waitable event watch support
mutable RecursiveMutex m_watchersMutex;
// Invoke call
void CommitInvoker();
-public:
+ public:
/**
* Constructor
*/
* @return none
* @see WaitMode::Type
*/
- void AddWaitableHandleWatch(WaitableHandleListener *listener, WaitableHandle waitableHandle, WaitMode::Type mode);
+ void AddWaitableHandleWatch(WaitableHandleListener *listener,
+ WaitableHandle waitableHandle,
+ WaitMode::Type mode);
/**
* Remove listener for specific waitable event
* @return none
* @see WaitMode::Type
*/
- void RemoveWaitableHandleWatch(WaitableHandleListener *listener, WaitableHandle waitableHandle, WaitMode::Type mode);
+ void RemoveWaitableHandleWatch(WaitableHandleListener *listener,
+ WaitableHandle waitableHandle,
+ WaitMode::Type mode);
/**
* Retrieve inherited context
*/
static WaitableHandleWatchSupport *InheritedContext();
};
-
} // namespace DPL
#endif // DPL_WAITABLE_HANDLE_WATCH_SUPPORT_H
#include <vector>
#include <string>
-namespace DPL
+namespace DPL {
+class ZipInput :
+ private Noncopyable
{
-class ZipInput
- : private Noncopyable
-{
-public:
+ public:
class Exception
{
- public:
+ public:
DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, OpenFailed)
DECLARE_EXCEPTION_TYPE(Base, ReadGlobalInfoFailed)
std::string comment;
// File information
- off64_t compressedSize; //< compressed size
- off64_t uncompressedSize; //< uncompressed size
-
- FileInfo()
- : handle(),
- name(),
- comment(),
- compressedSize(0),
- uncompressedSize(0)
- {
- }
+ off64_t compressedSize; //< compressed size
+ off64_t uncompressedSize; //< uncompressed size
+
+ FileInfo() :
+ handle(),
+ name(),
+ comment(),
+ compressedSize(0),
+ uncompressedSize(0)
+ {}
FileInfo(const FileHandle &handleArg,
const std::string &nameArg,
const std::string &commentArg,
const off64_t &compressedSizeArg,
- const off64_t &uncompressedSizeArg)
- : handle(handleArg),
- name(nameArg),
- comment(commentArg),
- compressedSize(compressedSizeArg),
- uncompressedSize(uncompressedSizeArg)
- {
- }
+ const off64_t &uncompressedSizeArg) :
+ handle(handleArg),
+ name(nameArg),
+ comment(commentArg),
+ compressedSize(compressedSizeArg),
+ uncompressedSize(uncompressedSizeArg)
+ {}
};
- class File
- : public DPL::AbstractInput
+ class File :
+ public DPL::AbstractInput
{
- private:
+ private:
void *m_file;
friend class ZipInput;
File(class Device *device, FileHandle handle);
- public:
+ public:
~File();
virtual DPL::BinaryQueueAutoPtr Read(size_t size);
};
-private:
- class Device *m_device;
+ private:
+ class Device * m_device;
void *m_masterFile;
size_t m_numberOfFiles;
void ReadGlobalComment(void *masterFile);
void ReadInfos(void *masterFile);
-public:
+ public:
typedef FileInfoList::const_iterator const_iterator;
typedef FileInfoList::const_reverse_iterator const_reverse_iterator;
typedef FileInfoList::size_type size_type;
-public:
+ public:
/**
* Open zip file from file
*/
* @file abstract_waitable_input_adapter.cpp
* @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
* @version 1.0
- * @brief This file is the implementation file of abstract waitable input adapter
+ * @brief This file is the implementation file of abstract waitable input
+ * adapter
*/
#include <stddef.h>
#include <dpl/abstract_waitable_input_adapter.h>
-namespace DPL
-{
-
+namespace DPL {
AbstractWaitableInputAdapter::AbstractWaitableInputAdapter(AbstractInput *input)
- : m_input(input)
+ :
+ m_input(input)
{
m_waitableEvent.Signal();
}
{
return m_waitableEvent.GetHandle();
}
-
} // namespace DPL
* @file abstract_waitable_input_output_adapter.cpp
* @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
* @version 1.0
- * @brief This file is the implementation file of abstract waitable input output adapter
+ * @brief This file is the implementation file of abstract waitable input
+ * output adapter
*/
#include <stddef.h>
#include <dpl/abstract_waitable_input_output_adapter.h>
-namespace DPL
-{
-
-AbstractWaitableInputOutputAdapter::AbstractWaitableInputOutputAdapter(AbstractInputOutput *inputOutput)
- : AbstractWaitableInputAdapter(inputOutput),
- AbstractWaitableOutputAdapter(inputOutput)
-{
-}
-
+namespace DPL {
+AbstractWaitableInputOutputAdapter::AbstractWaitableInputOutputAdapter(
+ AbstractInputOutput *inputOutput) :
+ AbstractWaitableInputAdapter(inputOutput),
+ AbstractWaitableOutputAdapter(inputOutput)
+{}
} // namespace DPL
* @file abstract_waitable_output_adapter.cpp
* @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
* @version 1.0
- * @brief This file is the implementation file of abstract waitable output adapter
+ * @brief This file is the implementation file of abstract waitable output
+ * adapter
*/
#include <stddef.h>
#include <dpl/abstract_waitable_output_adapter.h>
-namespace DPL
-{
-
-AbstractWaitableOutputAdapter::AbstractWaitableOutputAdapter(AbstractOutput *output)
- : m_output(output)
+namespace DPL {
+AbstractWaitableOutputAdapter::AbstractWaitableOutputAdapter(
+ AbstractOutput *output) :
+ m_output(output)
{
m_waitableEvent.Signal();
}
-size_t AbstractWaitableOutputAdapter::Write(const BinaryQueue &buffer, size_t bufferSize)
+size_t AbstractWaitableOutputAdapter::Write(const BinaryQueue &buffer,
+ size_t bufferSize)
{
return m_output->Write(buffer, bufferSize);
}
{
return m_waitableEvent.GetHandle();
}
-
} // namespace DPL
#include <sstream>
#include <dpl/assert.h>
-namespace DPL
-{
-Address::Address()
- : m_port(0)
-{
-}
+namespace DPL {
+Address::Address() :
+ m_port(0)
+{}
-Address::Address(const std::string &address)
- : m_address(address),
- m_port(0)
-{
-}
+Address::Address(const std::string &address) :
+ m_address(address),
+ m_port(0)
+{}
-Address::Address(const std::string &address, unsigned short port)
- : m_address(address),
- m_port(port)
-{
-}
+Address::Address(const std::string &address, unsigned short port) :
+ m_address(address),
+ m_port(port)
+{}
Address::~Address()
-{
-}
+{}
std::string Address::GetAddress() const
{
{
return ToString() < addr.ToString();
}
-
} // namespace DPL
static DPL::Application *g_application = NULL;
} // namespace anonymous
-namespace DPL
-{
+namespace DPL {
int Application::app_create(void *data)
{
- Application *This
=static_cast<Application *>(data);
+ Application *This
= static_cast<Application *>(data);
This->OnCreate();
return 0;
}
int Application::app_terminate(void *data)
{
- Application *This
=static_cast<Application *>(data);
+ Application *This
= static_cast<Application *>(data);
This->OnTerminate();
return 0;
}
int Application::app_pause(void *data)
{
- Application *This
=static_cast<Application *>(data);
+ Application *This
= static_cast<Application *>(data);
This->OnPause();
return 0;
}
int Application::app_resume(void *data)
{
- Application *This
=static_cast<Application *>(data);
+ Application *This
= static_cast<Application *>(data);
This->OnResume();
return 0;
}
int Application::app_reset(bundle *b, void *data)
{
- Application *This
=static_cast<Application *>(data);
+ Application *This
= static_cast<Application *>(data);
This->OnReset(b);
return 0;
}
Application::Application(int argc, char** argv,
const std::string& applicationName,
- bool showMainWindow)
- : m_argc(argc),
- m_argv(argv),
- m_applicationName(applicationName),
- m_mainWindowVisible(showMainWindow)
-{
- if (g_application != NULL)
- ThrowMsg(Exception::TooManyInstances, "Only single instance of Application allowed at one time!");
+ bool showMainWindow) :
+ m_argc(argc),
+ m_argv(argv),
+ m_applicationName(applicationName),
+ m_mainWindowVisible(showMainWindow)
+{
+ if (g_application != NULL) {
+ ThrowMsg(Exception::TooManyInstances,
+ "Only single instance of Application allowed at one time!");
+ }
g_application = this;
}
ops.pause = app_pause;
ops.resume = app_resume;
ops.reset = app_reset;
- ops.data=this;
+ ops.data = this;
- int result = appcore_efl_main(m_applicationName.c_str(), &m_argc, &m_argv, &ops);
+ int result = appcore_efl_main(
+ m_applicationName.c_str(), &m_argc, &m_argv, &ops);
LogPedantic("Exited application framework");
DPL::Atomic ApplicationExt::m_useCount(0);
-ApplicationExt::ApplicationExt(int argc, char** argv, const std::string& applicationName, bool showMainWindow) :
+ApplicationExt::ApplicationExt(int argc,
+ char** argv,
+ const std::string& applicationName,
+ bool showMainWindow) :
Application(argc, argv, applicationName, showMainWindow)
-{
-}
+{}
ApplicationExt::~ApplicationExt()
-{
-}
+{}
int ApplicationExt::Exec()
{
- if (0 == m_useCount.CompareAndExchange(0, 1))
- {
+ if (0 == m_useCount.CompareAndExchange(0, 1)) {
return Application::Exec();
- }
- else
- {
+ } else {
elm_run();
}
return 0;
#include <dpl/log/log.h>
#include <cstdlib>
-namespace DPL
-{
-void AssertProc(const char *condition, const char *file, int line, const char *function)
+namespace DPL {
+void AssertProc(const char *condition,
+ const char *file,
+ int line,
+ const char *function)
{
#define INTERNAL_LOG(message) \
do \
DPL::Log::LogSystemSingleton::Instance().Pedantic( \
platformLog.str().c_str(), \
__FILE__, __LINE__, __FUNCTION__); \
- } while (0)
+ } \
+ while (0)
// Try to log failed assertion to log system
Try
{
- INTERNAL_LOG("################################################################################");
- INTERNAL_LOG("### DPL assertion failed! ###");
- INTERNAL_LOG("################################################################################");
+ INTERNAL_LOG(
+ "################################################################################");
+ INTERNAL_LOG(
+ "### DPL assertion failed! ###");
+ INTERNAL_LOG(
+ "################################################################################");
INTERNAL_LOG("### Condition: " << condition);
INTERNAL_LOG("### File: " << file);
INTERNAL_LOG("### Line: " << line);
INTERNAL_LOG("### Function: " << function);
- INTERNAL_LOG("################################################################################");
- }
- catch (Exception)
- {
+ INTERNAL_LOG(
+ "################################################################################");
+ } catch (Exception) {
// Just ignore possible double errors
}
#include <stddef.h>
#include <dpl/atomic.h>
-namespace DPL
-{
-Atomic::Atomic(ValueType value)
- : m_value(value)
-{
-}
+namespace DPL {
+Atomic::Atomic(ValueType value) :
+ m_value(value)
+{}
Atomic::ValueType Atomic::ExchangeAndAdd(ValueType value)
{
- return g_atomic_int_exchange_and_add(const_cast<gint* >(&m_value), value);
+ return g_atomic_int_add(const_cast<gint* >(&m_value), value);
}
bool Atomic::CompareAndExchange(ValueType oldValue, ValueType newValue)
{
- return g_atomic_int_compare_and_exchange(const_cast<gint* >(&m_value), oldValue, newValue);
+ return g_atomic_int_compare_and_exchange(const_cast<gint* >(&m_value),
+ oldValue,
+ newValue);
}
bool Atomic::operator--()
#include <cstring>
#include <new>
-namespace DPL
-{
-BinaryQueue::BinaryQueue()
- : m_size(0)
-{
-}
+namespace DPL {
+BinaryQueue::BinaryQueue() :
+ m_size(0)
+{}
-BinaryQueue::BinaryQueue(const BinaryQueue &other)
- : m_size(0)
+BinaryQueue::BinaryQueue(const BinaryQueue &other) :
+ m_size(0)
{
AppendCopyFrom(other);
}
const BinaryQueue &BinaryQueue::operator=(const BinaryQueue &other)
{
- if (this != &other)
- {
+ if (this != &other) {
Clear();
AppendCopyFrom(other);
}
// To speed things up, always copy as one bucket
void *bufferCopy = malloc(other.m_size);
- if (bufferCopy == NULL)
+ if (bufferCopy == NULL) {
throw std::bad_alloc();
+ }
- try
- {
+ try {
other.Flatten(bufferCopy, other.m_size);
AppendUnmanaged(bufferCopy, other.m_size, &BufferDeleterFree, NULL);
- }
- catch (const std::bad_alloc &)
- {
+ } catch (const std::bad_alloc &) {
// Free allocated memory
free(bufferCopy);
throw;
void BinaryQueue::AppendMoveFrom(BinaryQueue &other)
{
// Copy all buckets
- std::copy(other.m_buckets.begin(), other.m_buckets.end(), std::back_inserter(m_buckets));
+ std::copy(other.m_buckets.begin(),
+ other.m_buckets.end(), std::back_inserter(m_buckets));
m_size += other.m_size;
// Clear other, but do not free memory
void *bufferCopy = malloc(bufferSize);
// Check if allocation succeded
- if (bufferCopy == NULL)
+ if (bufferCopy == NULL) {
throw std::bad_alloc();
+ }
// Copy user data
memcpy(bufferCopy, buffer, bufferSize);
- try
- {
+ try {
// Try to append new bucket
AppendUnmanaged(bufferCopy, bufferSize, &BufferDeleterFree, NULL);
- }
- catch (const std::bad_alloc &)
- {
+ } catch (const std::bad_alloc &) {
// Free allocated memory
free(bufferCopy);
throw;
}
}
-void BinaryQueue::AppendUnmanaged(const void* buffer, size_t bufferSize, BufferDeleter deleter, void* userParam)
+void BinaryQueue::AppendUnmanaged(const void* buffer,
+ size_t bufferSize,
+ BufferDeleter deleter,
+ void* userParam)
{
// Do not attach empty buckets
- if (bufferSize == 0)
- {
+ if (bufferSize == 0) {
deleter(buffer, bufferSize, userParam);
return;
}
void BinaryQueue::Consume(size_t size)
{
// Check parameters
- if (size > m_size)
+ if (size > m_size) {
Throw(Exception::OutOfData);
+ }
size_t bytesLeft = size;
// Consume data and/or remove buckets
- while (bytesLeft > 0)
- {
+ while (bytesLeft > 0) {
// Get consume size
size_t count = std::min(bytesLeft, m_buckets.front()->left);
- m_buckets.front()->ptr = static_cast<const char *>(m_buckets.front()->ptr) + count;
+ m_buckets.front()->ptr =
+ static_cast<const char *>(m_buckets.front()->ptr) + count;
m_buckets.front()->left -= count;
bytesLeft -= count;
m_size -= count;
- if (m_buckets.front()->left == 0)
- {
+ if (m_buckets.front()->left == 0) {
DeleteBucket(m_buckets.front());
m_buckets.pop_front();
}
void BinaryQueue::Flatten(void *buffer, size_t bufferSize) const
{
// Check parameters
- if (bufferSize == 0)
+ if (bufferSize == 0) {
return;
+ }
- if (bufferSize > m_size)
+ if (bufferSize > m_size) {
Throw(Exception::OutOfData);
+ }
size_t bytesLeft = bufferSize;
void *ptr = buffer;
Assert(m_buckets.end() != bucketIterator);
// Flatten data
- while (bytesLeft > 0)
- {
+ while (bytesLeft > 0) {
// Get consume size
size_t count = std::min(bytesLeft, (*bucketIterator)->left);
delete bucket;
}
-void BinaryQueue::BufferDeleterFree(const void* data, size_t dataSize, void* userParam)
+void BinaryQueue::BufferDeleterFree(const void* data,
+ size_t dataSize,
+ void* userParam)
{
(void)dataSize;
(void)userParam;
free(const_cast<void *>(data));
}
-BinaryQueue::Bucket::Bucket(const void* data, size_t dataSize, BufferDeleter dataDeleter, void* userParam)
- : buffer(data),
- ptr(data),
- size(dataSize),
- left(dataSize),
- deleter(dataDeleter),
- param(userParam)
+BinaryQueue::Bucket::Bucket(const void* data,
+ size_t dataSize,
+ BufferDeleter dataDeleter,
+ void* userParam) :
+ buffer(data),
+ ptr(data),
+ size(dataSize),
+ left(dataSize),
+ deleter(dataDeleter),
+ param(userParam)
{
Assert(data != NULL);
Assert(deleter != NULL);
}
BinaryQueue::BucketVisitor::~BucketVisitor()
-{
-}
+{}
-BinaryQueue::BucketVisitorCall::BucketVisitorCall(BucketVisitor *visitor)
- : m_visitor(visitor)
-{
-}
+BinaryQueue::BucketVisitorCall::BucketVisitorCall(BucketVisitor *visitor) :
+ m_visitor(visitor)
+{}
BinaryQueue::BucketVisitorCall::~BucketVisitorCall()
-{
-}
+{}
void BinaryQueue::BucketVisitorCall::operator()(Bucket *bucket) const
{
ScopedFree<void> bufferCopy(malloc(available));
- if (!bufferCopy)
+ if (!bufferCopy) {
throw std::bad_alloc();
+ }
BinaryQueueAutoPtr result(new BinaryQueue());
Flatten(bufferCopy.Get(), available);
- result->AppendUnmanaged(bufferCopy.Get(), available, &BufferDeleterFree, NULL);
+ result->AppendUnmanaged(
+ bufferCopy.Get(), available, &BufferDeleterFree, NULL);
bufferCopy.Release();
Consume(available);
* @file char_traits.cpp
* @author Piotr Marcinkiewicz (p.marcinkiew@samsung.com)
* @version 1.0
- * @biref Char traits are used to create basic_string extended with additional features
- * Current char traits could be extended in feature to boost performance
+ * @biref Char traits are used to create basic_string extended with
+ * additional features
+ * Current char traits could be extended in feature to boost
+ * performance
*/
#include <stddef.h>
#include <dpl/char_traits.h>
#include <stddef.h>
#include <dpl/colors.h>
-
-namespace DPL
-{
-
-namespace Colors
-{
-
-namespace Text
-{
-
+namespace DPL {
+namespace Colors {
+namespace Text {
const char* BOLD_GREEN_BEGIN = "\033[1;32m";
const char* BOLD_GREEN_END = "\033[m";
const char* RED_BEGIN = "\033[0;31m";
const char* BOLD_GOLD_END = "\033[m";
const char* BOLD_WHITE_BEGIN = "\033[1;37m";
const char* BOLD_WHITE_END = "\033[m";
-
} //namespace Text
-namespace Html
-{
-
+namespace Html {
const char* BOLD_GREEN_BEGIN = "<font color=\"green\"><b>";
const char* BOLD_GREEN_END = "</b></font>";
const char* PURPLE_BEGIN = "<font color=\"purple\"><b>";
const char* BOLD_GOLD_END = "</b></font>";
const char* BOLD_WHITE_BEGIN = "<font color=\"white\"><b>";
const char* BOLD_WHITE_END = "</b></font>";
-
} //namespace Html
-
} //namespace Colors
-
} //namespace DPL
#include <dpl/waitable_handle.h>
#include <dpl/binary_queue.h>
-namespace DPL
-{
+namespace DPL {
namespace // anonymous
{
const size_t DEFAULT_COPY_BUFFER_SIZE = 16768;
{
Try
{
- while (true)
- {
+ while (true) {
BinaryQueueAutoPtr buffer;
- while (true)
- {
+ while (true) {
// Try to get data immediately
buffer = input->Read(DEFAULT_COPY_BUFFER_SIZE);
// Do we need to wait for data ?
- if (!buffer.get())
- {
- WaitForSingleHandle(input->WaitableReadHandle(), WaitMode::Read);
+ if (!buffer.get()) {
+ WaitForSingleHandle(
+ input->WaitableReadHandle(), WaitMode::Read);
continue;
}
- if (buffer->Empty())
+ if (buffer->Empty()) {
return; // Done
-
+ }
// Ok, to process
break;
}
// Write out all data
- while (!buffer->Empty())
- {
+ while (!buffer->Empty()) {
// Try to write all data immediately
size_t count = output->Write(*buffer, buffer->Size());
// Do we need to wait for writing data ?
- if (count == 0)
- {
- WaitForSingleHandle(output->WaitableWriteHandle(), WaitMode::Write);
+ if (count == 0) {
+ WaitForSingleHandle(
+ output->WaitableWriteHandle(), WaitMode::Write);
continue;
}
}
}
}
- Catch (DPL::Exception)
+ Catch(DPL::Exception)
{
ReThrow(CopyFailed);
}
}
-void Copy(AbstractWaitableInput *input, AbstractWaitableOutput *output, size_t totalBytes)
+void Copy(AbstractWaitableInput *input,
+ AbstractWaitableOutput *output,
+ size_t totalBytes)
{
Try
{
size_t bytesLeft = totalBytes;
- while (bytesLeft > 0)
- {
+ while (bytesLeft > 0) {
BinaryQueueAutoPtr buffer;
// Copy at most left bytes
- size_t bytesToCopy = bytesLeft > DEFAULT_COPY_BUFFER_SIZE ? DEFAULT_COPY_BUFFER_SIZE : bytesLeft;
+ size_t bytesToCopy = bytesLeft >
+ DEFAULT_COPY_BUFFER_SIZE ? DEFAULT_COPY_BUFFER_SIZE : bytesLeft;
- while (true)
- {
+ while (true) {
// Try to get data immediately
buffer = input->Read(bytesToCopy);
// Do we need to wait for data ?
- if (!buffer.get())
- {
- WaitForSingleHandle(input->WaitableReadHandle(), WaitMode::Read);
+ if (!buffer.get()) {
+ WaitForSingleHandle(
+ input->WaitableReadHandle(), WaitMode::Read);
continue;
}
- if (buffer->Empty())
+ if (buffer->Empty()) {
ThrowMsg(CopyFailed, "Unexpected end of abstract input");
+ }
// Ok, to process
break;
}
// Write out all data
- while (!buffer->Empty())
- {
+ while (!buffer->Empty()) {
// Try to write all data immediately
size_t count = output->Write(*buffer, buffer->Size());
// Do we need to wait for writing data ?
- if (count == 0)
- {
- WaitForSingleHandle(output->WaitableWriteHandle(), WaitMode::Write);
+ if (count == 0) {
+ WaitForSingleHandle(
+ output->WaitableWriteHandle(), WaitMode::Write);
continue;
}
}
}
}
- Catch (DPL::Exception)
+ Catch(DPL::Exception)
{
ReThrow(CopyFailed);
}
#include <cerrno>
#include <stdexcept>
-namespace DPL
-{
+namespace DPL {
namespace // anonymous
{
const size_t DEFAULT_ERRNO_STRING_SIZE = 32;
size_t size = DEFAULT_ERRNO_STRING_SIZE;
char *buffer = NULL;
- for (;;)
- {
+ for (;;) {
// Add one extra characted for end of string null value
char *newBuffer = static_cast<char *>(::realloc(buffer, size + 1));
- if (!newBuffer)
- {
+ if (!newBuffer) {
// Failed to realloc
::free(buffer);
throw std::bad_alloc();
::memset(buffer, 0, size + 1);
// Try to retrieve error string
-#if (_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600) && ! _GNU_SOURCE
+#if (_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600) && !_GNU_SOURCE
// The XSI-compliant version of strerror_r() is provided if:
int result = ::strerror_r(error, buffer, size);
- if (result == 0)
- {
+ if (result == 0) {
ScopedFree<char> scopedBufferFree(buffer);
return std::string(buffer);
}
// Otherwise, the GNU-specific version is provided.
char *result = ::strerror_r(error, buffer, size);
- if (result != NULL)
- {
+ if (result != NULL) {
ScopedFree<char> scopedBufferFree(buffer);
return std::string(result);
}
#endif
// Interpret errors
- switch (errno)
- {
+ switch (errno) {
case EINVAL:
// We got an invalid errno value
- ::free(buffer);
+ ::free(buffer);
ThrowMsg(InvalidErrnoValue, "Invalid errno value: " << error);
case ERANGE:
#include <dpl/log/log.h>
#include <cstdio>
-namespace DPL
-{
+namespace DPL {
Exception* Exception::m_lastException = NULL;
unsigned int Exception::m_exceptionCount = 0;
void (*Exception::m_terminateHandler)() = NULL;
LogPedantic(str);
}
-void LogUnhandledException(const std::string &str, const char *filename, int line, const char *function)
+void LogUnhandledException(const std::string &str,
+ const char *filename,
+ int line,
+ const char *function)
{
// Logging to console
std::ostringstream msg;
- msg << "\033[1;5;31m\n=== [" << filename << ":" << line << "] " << function << " ===\033[m";
+ msg << "\033[1;5;31m\n=== [" << filename << ":" << line << "] " <<
+ function << " ===\033[m";
msg << str;
printf("%s\n", msg.str().c_str());
// Logging to dlog
- DPL::Log::LogSystemSingleton::Instance().Error(str.c_str(), filename, line, function);
+ DPL::Log::LogSystemSingleton::Instance().Error(
+ str.c_str(), filename, line, function);
}
} // namespace DPL
#include <fcntl.h>
#include <errno.h>
-namespace DPL
-{
-
+namespace DPL {
namespace // anonymous
{
const size_t DEFAULT_READ_BUFFER_SIZE = 4096;
} // namespace anonymous
-FileInput::FileInput()
- : m_fd(-1)
-{
-}
+FileInput::FileInput() :
+ m_fd(-1)
+{}
-FileInput::FileInput(const std::string& fileName)
- : m_fd(-1)
+FileInput::FileInput(const std::string& fileName) :
+ m_fd(-1)
{
Open(fileName);
}
int fd = TEMP_FAILURE_RETRY(open(fileName.c_str(), O_RDONLY | O_NONBLOCK));
// Throw an exception if an error occurred
- if (fd == -1)
+ if (fd == -1) {
ThrowMsg(Exception::OpenFailed, fileName);
+ }
// Close if any existing
Close();
void FileInput::Close()
{
- if (m_fd == -1)
+ if (m_fd == -1) {
return;
+ }
- if (TEMP_FAILURE_RETRY(close(m_fd)) == -1)
+ if (TEMP_FAILURE_RETRY(close(m_fd)) == -1) {
Throw(Exception::CloseFailed);
+ }
m_fd = -1;
BinaryQueueAutoPtr FileInput::Read(size_t size)
{
- size_t bytesToRead = size > DEFAULT_READ_BUFFER_SIZE ? DEFAULT_READ_BUFFER_SIZE : size;
+ size_t bytesToRead = size >
+ DEFAULT_READ_BUFFER_SIZE ? DEFAULT_READ_BUFFER_SIZE : size;
// Malloc default read buffer size
// It is unmanaged, so it can be then attached directly to binary queue
void *buffer = malloc(bytesToRead);
- if (buffer == NULL)
+ if (buffer == NULL) {
throw std::bad_alloc();
+ }
LogPedantic("Trying to read " << bytesToRead << " bytes");
LogPedantic("Read " << result << " bytes from file");
- if (result > 0)
- {
+ if (result > 0) {
// Succedded to read socket data
BinaryQueueAutoPtr binaryQueue(new BinaryQueue());
// Append unmanaged memory
- binaryQueue->AppendUnmanaged(buffer, result, &BinaryQueue::BufferDeleterFree, NULL);
+ binaryQueue->AppendUnmanaged(buffer,
+ result,
+ &BinaryQueue::BufferDeleterFree,
+ NULL);
// Return buffer
return binaryQueue;
- }
- else if (result == 0)
- {
+ } else if (result == 0) {
// Socket was gracefuly closed
free(buffer);
// Return empty buffer
return BinaryQueueAutoPtr(new BinaryQueue());
- }
- else
- {
+ } else {
// Must first save errno value, because it may be altered
int lastErrno = errno;
#include <fcntl.h>
#include <errno.h>
-namespace DPL
-{
-FileOutput::FileOutput()
- : m_fd(-1)
-{
-}
+namespace DPL {
+FileOutput::FileOutput() :
+ m_fd(-1)
+{}
-FileOutput::FileOutput(const std::string& fileName)
- : m_fd(-1)
+FileOutput::FileOutput(const std::string& fileName) :
+ m_fd(-1)
{
Open(fileName);
}
void FileOutput::Open(const std::string& fileName)
{
// Open non-blocking
- int fd = TEMP_FAILURE_RETRY(open(fileName.c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_NONBLOCK, 0664));
+ int fd =
+ TEMP_FAILURE_RETRY(open(fileName.c_str(), O_WRONLY | O_CREAT |
+ O_TRUNC |
+ O_NONBLOCK, 0664));
// Throw an exception if an error occurred
- if (fd == -1)
+ if (fd == -1) {
ThrowMsg(Exception::OpenFailed, fileName);
+ }
// Close if any existing
Close();
void FileOutput::Close()
{
- if (m_fd == -1)
+ if (m_fd == -1) {
return;
+ }
- if (TEMP_FAILURE_RETRY(close(m_fd)) == -1)
+ if (TEMP_FAILURE_RETRY(close(m_fd)) == -1) {
Throw(Exception::CloseFailed);
+ }
m_fd = -1;
size_t FileOutput::Write(const BinaryQueue &buffer, size_t bufferSize)
{
// Adjust write size
- if (bufferSize > buffer.Size())
+ if (bufferSize > buffer.Size()) {
bufferSize = buffer.Size();
+ }
// FIXME: User write visitor to write !
// WriteVisitor visitor
LogPedantic("Wrote " << result << " bytes to file");
- if (result > 0)
- {
+ if (result > 0) {
// Successfuly written some bytes
return static_cast<size_t>(result);
- }
- else if (result == 0)
- {
+ } else if (result == 0) {
// This is abnormal result
- ThrowMsg(CommonException::InternalError, "Invalid write result, 0 bytes written");
- }
- else
- {
+ ThrowMsg(CommonException::InternalError,
+ "Invalid write result, 0 bytes written");
+ } else {
// Interpret error result
// FIXME: Handle errno
Throw(AbstractOutput::Exception::WriteFailed);
IMPLEMENT_SINGLETON(DPL::Main)
-namespace DPL
-{
+namespace DPL {
namespace // anonymous
{
// Late EFL event handling
Main::Main()
#ifdef DPL_ENABLE_GLIB_LOOP_INTEGRATION_WORKAROUND
- // GLIB loop intergration workaround
+// GLIB loop intergration workaround
: m_oldEcoreSelect(NULL)
#endif // DPL_ENABLE_GLIB_LOOP_INTEGRATION_WORKAROUND
{
#endif // DPL_ENABLE_GLIB_LOOP_INTEGRATION_WORKAROUND
// Register event invoker
- m_invokerHandler = ecore_main_fd_handler_add(WaitableHandleWatchSupport::WaitableInvokerHandle(),
- ECORE_FD_READ, &StaticDispatchInvoker, this, NULL, NULL);
-
- if (m_invokerHandler == NULL)
+ m_invokerHandler = ecore_main_fd_handler_add(
+ WaitableHandleWatchSupport::WaitableInvokerHandle(),
+ ECORE_FD_READ,
+ &StaticDispatchInvoker,
+ this,
+ NULL,
+ NULL);
+
+ if (m_invokerHandler == NULL) {
ThrowMsg(Exception::CreateFailed, "Failed to register invoker handler!");
+ }
// It is impossible that there exist watchers at this time
// No need to add watchers
Main::~Main()
{
// Remove any watchers
- for (EcoreFdHandlerList::iterator iterator = m_readWatchersList.begin(); iterator != m_readWatchersList.end(); ++iterator)
+ for (EcoreFdHandlerList::iterator iterator = m_readWatchersList.begin();
+ iterator != m_readWatchersList.end();
+ ++iterator)
+ {
ecore_main_fd_handler_del(*iterator);
+ }
m_readWatchersList.clear();
- for (EcoreFdHandlerList::iterator iterator = m_writeWatchersList.begin(); iterator != m_writeWatchersList.end(); ++iterator)
+ for (EcoreFdHandlerList::iterator iterator = m_writeWatchersList.begin();
+ iterator != m_writeWatchersList.end();
+ ++iterator)
+ {
ecore_main_fd_handler_del(*iterator);
+ }
m_writeWatchersList.clear();
Assert(This != NULL);
// Late EFL event handling
- if (g_lateMain == NULL)
- {
+ if (g_lateMain == NULL) {
LogPedantic("WARNING: Late EFL invoker dispatch!");
- }
- else
- {
+ } else {
This->DispatchInvoker();
}
return ECORE_CALLBACK_RENEW;
}
-Eina_Bool Main::StaticDispatchReadWatcher(void* data, Ecore_Fd_Handler* fd_handler)
+Eina_Bool Main::StaticDispatchReadWatcher(void* data,
+ Ecore_Fd_Handler* fd_handler)
{
LogPedantic("Static ECORE dispatch read watcher");
Assert(This != NULL);
// Late EFL event handling
- if (g_lateMain == NULL)
- {
+ if (g_lateMain == NULL) {
LogPedantic("WARNING: Late EFL read watcher dispatch!");
- }
- else
- {
- This->DispatchReadWatcher(static_cast<WaitableHandle>(ecore_main_fd_handler_fd_get(fd_handler)));
+ } else {
+ This->DispatchReadWatcher(static_cast<WaitableHandle>(
+ ecore_main_fd_handler_fd_get(fd_handler)));
}
return ECORE_CALLBACK_RENEW;
}
-Eina_Bool Main::StaticDispatchWriteWatcher(void* data, Ecore_Fd_Handler* fd_handler)
+Eina_Bool Main::StaticDispatchWriteWatcher(void* data,
+ Ecore_Fd_Handler* fd_handler)
{
LogPedantic("Static ECORE dispatch write watcher");
Assert(This != NULL);
// Late EFL event handling
- if (g_lateMain == NULL)
- {
+ if (g_lateMain == NULL) {
LogPedantic("WARNING: Late EFL write watcher dispatch!");
- }
- else
- {
- This->DispatchWriteWatcher(static_cast<WaitableHandle>(ecore_main_fd_handler_fd_get(fd_handler)));
+ } else {
+ This->DispatchWriteWatcher(static_cast<WaitableHandle>(
+ ecore_main_fd_handler_fd_get(fd_handler)));
}
return ECORE_CALLBACK_RENEW;
void Main::ReloadWatchList()
{
- LogPedantic("Reloading watch list... (" << m_readWatchersList.size() << " + " << m_writeWatchersList.size() << ")");
+ LogPedantic(
+ "Reloading watch list... (" << m_readWatchersList.size() << " + " <<
+ m_writeWatchersList.size() << ")");
// Reload list of watchers
- WaitableHandleListEx waitableWatcherHandles = WaitableHandleWatchSupport::WaitableWatcherHandles();
+ WaitableHandleListEx waitableWatcherHandles =
+ WaitableHandleWatchSupport::WaitableWatcherHandles();
// Remove not existing read watchers
EcoreFdHandlerList::iterator watchersIterator = m_readWatchersList.begin();
WaitableHandleListEx::iterator handlesIterator;
- while (watchersIterator != m_readWatchersList.end())
- {
+ while (watchersIterator != m_readWatchersList.end()) {
bool found = false;
- for (handlesIterator = waitableWatcherHandles.begin(); handlesIterator != waitableWatcherHandles.end(); ++handlesIterator)
+ for (handlesIterator = waitableWatcherHandles.begin();
+ handlesIterator != waitableWatcherHandles.end();
+ ++handlesIterator)
{
if (handlesIterator->second == WaitMode::Read &&
- handlesIterator->first == static_cast<WaitableHandle>(ecore_main_fd_handler_fd_get(*watchersIterator)))
+ handlesIterator->first ==
+ static_cast<WaitableHandle>(ecore_main_fd_handler_fd_get(*
+ watchersIterator)))
{
found = true;
break;
}
}
- if (!found)
- {
+ if (!found) {
// Unregister handler
ecore_main_fd_handler_del(*watchersIterator);
m_readWatchersList.erase(watchersIterator);
watchersIterator = next;
- }
- else
- {
+ } else {
++watchersIterator;
}
}
// Remove not existing write watchers
watchersIterator = m_writeWatchersList.begin();
- while (watchersIterator != m_writeWatchersList.end())
- {
+ while (watchersIterator != m_writeWatchersList.end()) {
bool found = false;
- for (handlesIterator = waitableWatcherHandles.begin(); handlesIterator != waitableWatcherHandles.end(); ++handlesIterator)
+ for (handlesIterator = waitableWatcherHandles.begin();
+ handlesIterator != waitableWatcherHandles.end();
+ ++handlesIterator)
{
if (handlesIterator->second == WaitMode::Write &&
- handlesIterator->first == static_cast<WaitableHandle>(ecore_main_fd_handler_fd_get(*watchersIterator)))
+ handlesIterator->first ==
+ static_cast<WaitableHandle>(ecore_main_fd_handler_fd_get(*
+ watchersIterator)))
{
found = true;
break;
}
}
- if (!found)
- {
+ if (!found) {
// Unregister handler
ecore_main_fd_handler_del(*watchersIterator);
m_writeWatchersList.erase(watchersIterator);
watchersIterator = next;
- }
- else
- {
+ } else {
++watchersIterator;
}
}
// Add new read/write watchers
- for (handlesIterator = waitableWatcherHandles.begin(); handlesIterator != waitableWatcherHandles.end(); ++handlesIterator)
+ for (handlesIterator = waitableWatcherHandles.begin();
+ handlesIterator != waitableWatcherHandles.end();
+ ++handlesIterator)
{
- if (handlesIterator->second == WaitMode::Read)
- {
+ if (handlesIterator->second == WaitMode::Read) {
bool found = false;
- for (watchersIterator = m_readWatchersList.begin(); watchersIterator != m_readWatchersList.end(); ++watchersIterator)
+ for (watchersIterator = m_readWatchersList.begin();
+ watchersIterator != m_readWatchersList.end();
+ ++watchersIterator)
{
- if (handlesIterator->first == static_cast<WaitableHandle>(ecore_main_fd_handler_fd_get(*watchersIterator)))
+ if (handlesIterator->first ==
+ static_cast<WaitableHandle>(ecore_main_fd_handler_fd_get(*
+ watchersIterator)))
{
found = true;
break;
}
}
- if (!found)
- {
- Ecore_Fd_Handler *handler = ecore_main_fd_handler_add(handlesIterator->first,
- ECORE_FD_READ, &StaticDispatchReadWatcher, this, NULL, NULL);
- if (handler == NULL)
- ThrowMsg(Exception::CreateFailed, "Failed to register read watcher handler!");
+ if (!found) {
+ Ecore_Fd_Handler *handler = ecore_main_fd_handler_add(
+ handlesIterator->first,
+ ECORE_FD_READ,
+ &StaticDispatchReadWatcher,
+ this,
+ NULL,
+ NULL);
+ if (handler == NULL) {
+ ThrowMsg(Exception::CreateFailed,
+ "Failed to register read watcher handler!");
+ }
// Push new watcher to list
m_readWatchersList.push_back(handler);
}
- }
- else if (handlesIterator->second == WaitMode::Write)
- {
+ } else if (handlesIterator->second == WaitMode::Write) {
bool found = false;
- for (watchersIterator = m_writeWatchersList.begin(); watchersIterator != m_writeWatchersList.end(); ++watchersIterator)
+ for (watchersIterator = m_writeWatchersList.begin();
+ watchersIterator != m_writeWatchersList.end();
+ ++watchersIterator)
{
- if (handlesIterator->first == static_cast<WaitableHandle>(ecore_main_fd_handler_fd_get(*watchersIterator)))
+ if (handlesIterator->first ==
+ static_cast<WaitableHandle>(ecore_main_fd_handler_fd_get(*
+ watchersIterator)))
{
found = true;
break;
}
}
- if (!found)
- {
- Ecore_Fd_Handler *handler = ecore_main_fd_handler_add(handlesIterator->first,
- ECORE_FD_WRITE, &StaticDispatchWriteWatcher, this, NULL, NULL);
- if (handler == NULL)
- ThrowMsg(Exception::CreateFailed, "Failed to register write watcher handler!");
+ if (!found) {
+ Ecore_Fd_Handler *handler = ecore_main_fd_handler_add(
+ handlesIterator->first,
+ ECORE_FD_WRITE,
+ &StaticDispatchWriteWatcher,
+ this,
+ NULL,
+ NULL);
+ if (handler == NULL) {
+ ThrowMsg(Exception::CreateFailed,
+ "Failed to register write watcher handler!");
+ }
// Push new watcher to list
m_writeWatchersList.push_back(handler);
}
- }
- else
- {
+ } else {
Assert(0);
}
}
- LogPedantic("Watch list reloaded (" << m_readWatchersList.size() << " + " << m_writeWatchersList.size() << ")");
+ LogPedantic(
+ "Watch list reloaded (" << m_readWatchersList.size() << " + " <<
+ m_writeWatchersList.size() << ")");
}
void Main::DispatchReadWatcher(WaitableHandle waitableHandle)
#ifdef DPL_ENABLE_GLIB_LOOP_INTEGRATION_WORKAROUND
// GLIB loop intergration workaround
-int Main::EcoreSelectInterceptor(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout)
+int Main::EcoreSelectInterceptor(int nfds,
+ fd_set *readfds,
+ fd_set *writefds,
+ fd_set *exceptfds,
+ struct timeval *timeout)
{
- // We have to check error code here and make another try because of some glib error's.
+ // We have to check error code here and make another try because of some
+ // glib error's.
fd_set rfds, wfds, efds;
memcpy(&rfds, readfds, sizeof(fd_set));
memcpy(&wfds, writefds, sizeof(fd_set));
memcpy(&efds, exceptfds, sizeof(fd_set));
- int ret = MainSingleton::Instance().m_oldEcoreSelect(nfds, readfds, writefds, exceptfds, timeout);
+ int ret = MainSingleton::Instance().m_oldEcoreSelect(nfds,
+ readfds,
+ writefds,
+ exceptfds,
+ timeout);
- if (ret == -1)
- {
+ if (ret == -1) {
// Check each descriptor to see if it is valid
- for (int i = 0; i < nfds; i++)
- {
- if (FD_ISSET(i, readfds) || FD_ISSET(i, writefds) || FD_ISSET(i, exceptfds))
+ for (int i = 0; i < nfds; i++) {
+ if (FD_ISSET(i,
+ readfds) ||
+ FD_ISSET(i, writefds) || FD_ISSET(i, exceptfds))
{
// Try to get descriptor flags
int result = fcntl(i, F_GETFL);
- if (result == -1)
- {
- if (errno == EBADF)
- {
+ if (result == -1) {
+ if (errno == EBADF) {
// This a bad descriptor. Remove all occurrences of it.
- if (FD_ISSET(i, readfds))
- {
- LogPedantic("GLIB_LOOP_INTEGRATION_WORKAROUND: Bad read descriptor: " << i);
+ if (FD_ISSET(i, readfds)) {
+ LogPedantic(
+ "GLIB_LOOP_INTEGRATION_WORKAROUND: Bad read descriptor: "
+ << i);
FD_CLR(i, readfds);
}
- if (FD_ISSET(i, writefds))
- {
- LogPedantic("GLIB_LOOP_INTEGRATION_WORKAROUND: Bad write descriptor: " << i);
+ if (FD_ISSET(i, writefds)) {
+ LogPedantic(
+ "GLIB_LOOP_INTEGRATION_WORKAROUND: Bad write descriptor: "
+ << i);
FD_CLR(i, writefds);
}
- if (FD_ISSET(i, exceptfds))
- {
- LogPedantic("GLIB_LOOP_INTEGRATION_WORKAROUND: Bad exception descriptor: " << i);
+ if (FD_ISSET(i, exceptfds)) {
+ LogPedantic(
+ "GLIB_LOOP_INTEGRATION_WORKAROUND: Bad exception descriptor: "
+ << i);
FD_CLR(i, exceptfds);
}
- }
- else
- {
+ } else {
// Unexpected error
Assert(0);
}
}
}
- LogPedantic("GLIB_LOOP_INTEGRATION_WORKAROUND: Bad read descriptor. Retrying with default select.");
+ LogPedantic(
+ "GLIB_LOOP_INTEGRATION_WORKAROUND: Bad read descriptor. Retrying with default select.");
//Retry with old values and return new error
memcpy(readfds, &rfds, sizeof(fd_set));
tm.tv_sec = 0;
tm.tv_usec = 10;
- if (timeout)
+ if (timeout) {
ret = select(nfds, readfds, writefds, exceptfds, &tm);
- else
+ } else {
ret = select(nfds, readfds, writefds, exceptfds, NULL);
+ }
}
return ret;
#include <dpl/log/log.h>
#include <errno.h>
-namespace DPL
-{
+namespace DPL {
Mutex::Mutex()
{
- if (pthread_mutex_init(&m_mutex, NULL) != 0)
- {
+ if (pthread_mutex_init(&m_mutex, NULL) != 0) {
int error = errno;
LogPedantic("Failed to create mutex. Errno: " << error);
ThrowMsg(Exception::CreateFailed,
- "Failed to create mutex. Errno: " << error);
+ "Failed to create mutex. Errno: " << error);
}
}
Mutex::~Mutex()
{
- if (pthread_mutex_destroy(&m_mutex) != 0)
- {
+ if (pthread_mutex_destroy(&m_mutex) != 0) {
int error = errno;
LogPedantic("Failed to destroy mutex. Errno: " << error);
void Mutex::Lock() const
{
- if (pthread_mutex_lock(&m_mutex) != 0)
- {
+ if (pthread_mutex_lock(&m_mutex) != 0) {
int error = errno;
LogPedantic("Failed to lock mutex. Errno: " << error);
ThrowMsg(Exception::LockFailed,
- "Failed to lock mutex. Errno: " << error);
+ "Failed to lock mutex. Errno: " << error);
}
}
void Mutex::Unlock() const
{
- if (pthread_mutex_unlock(&m_mutex) != 0)
- {
+ if (pthread_mutex_unlock(&m_mutex) != 0) {
int error = errno;
LogPedantic("Failed to unlock mutex. Errno: " << error);
ThrowMsg(Exception::UnlockFailed,
- "Failed to unlock mutex. Errno: " << error);
+ "Failed to unlock mutex. Errno: " << error);
}
}
-Mutex::ScopedLock::ScopedLock(Mutex *mutex)
- : m_mutex(mutex)
+Mutex::ScopedLock::ScopedLock(Mutex *mutex) :
+ m_mutex(mutex)
{
Assert(mutex != NULL);
m_mutex->Lock();
{
m_mutex->Unlock();
}
- Catch (Mutex::Exception::UnlockFailed)
+ Catch(Mutex::Exception::UnlockFailed)
{
LogPedantic("Failed to leave mutex scoped lock");
}
#include <fcntl.h>
#include <errno.h>
-namespace DPL
-{
+namespace DPL {
namespace // anonymous
{
const mode_t FIFO_MODE = 0600;
} // namespace anonymous
NamedBasePipe::~NamedBasePipe()
-{
-}
+{}
void NamedBasePipe::Create(const std::string &pipeName)
{
// Create new fifo
int status = mkfifo(pipeName.c_str(), FIFO_MODE);
- if (status == -1)
- {
+ if (status == -1) {
// Ignore error it it already exists
- if (errno == EEXIST)
+ if (errno == EEXIST) {
ThrowMsg(Exception::AlreadyExist, pipeName);
- else
+ } else {
ThrowMsg(Exception::CreateFailed, pipeName);
+ }
}
}
#include <fcntl.h>
#include <errno.h>
-namespace DPL
-{
-NamedOutputPipe::NamedOutputPipe()
- : m_fifo(-1)
-{
-}
+namespace DPL {
+NamedOutputPipe::NamedOutputPipe() :
+ m_fifo(-1)
+{}
NamedOutputPipe::~NamedOutputPipe()
{
// Then open it for reading or writing
int fifo = TEMP_FAILURE_RETRY(open(pipeName.c_str(), O_WRONLY | O_NONBLOCK));
- if (fifo == -1)
+ if (fifo == -1) {
ThrowMsg(Exception::OpenFailed, pipeName);
+ }
m_fifo = fifo;
}
void NamedOutputPipe::Close()
{
- if (m_fifo == -1)
+ if (m_fifo == -1) {
return;
+ }
- if (TEMP_FAILURE_RETRY(close(m_fifo)) == -1)
+ if (TEMP_FAILURE_RETRY(close(m_fifo)) == -1) {
Throw(Exception::CloseFailed);
+ }
m_fifo = -1;
}
size_t NamedOutputPipe::Write(const BinaryQueue &buffer, size_t bufferSize)
{
// Adjust write size
- if (bufferSize > buffer.Size())
+ if (bufferSize > buffer.Size()) {
bufferSize = buffer.Size();
+ }
// FIXME: User write visitor to write !
// WriteVisitor visitor
ScopedFree<void> flattened(malloc(bufferSize));
buffer.Flatten(flattened.Get(), bufferSize);
- ssize_t result = TEMP_FAILURE_RETRY(write(m_fifo, flattened.Get(), bufferSize));
+ ssize_t result =
+ TEMP_FAILURE_RETRY(write(m_fifo, flattened.Get(), bufferSize));
- if (result > 0)
- {
+ if (result > 0) {
// Successfuly written some bytes
return static_cast<size_t>(result);
- }
- else if (result == 0)
- {
+ } else if (result == 0) {
// This is abnormal result
- ThrowMsg(CommonException::InternalError, "Invalid socket write result, 0 bytes written");
- }
- else
- {
+ ThrowMsg(CommonException::InternalError,
+ "Invalid socket write result, 0 bytes written");
+ } else {
// Interpret error result
// FIXME: Handle errno
Throw(AbstractOutput::Exception::WriteFailed);
#include <stddef.h>
#include <dpl/noncopyable.h>
-namespace DPL
-{
+namespace DPL {
Noncopyable::Noncopyable()
-{
-}
+{}
Noncopyable::~Noncopyable()
-{
-}
+{}
} // namespace DPL
#include <stddef.h>
#include <dpl/once.h>
-namespace DPL
-{
+namespace DPL {
void Once::Call(Delegate delegate)
{
// First chance test
- if (m_atomic == 1)
+ if (m_atomic == 1) {
return;
+ }
// Enter mutex
Mutex::ScopedLock lock(&m_mutex);
// Second chance test
- if (m_atomic == 1)
+ if (m_atomic == 1) {
return;
+ }
// Initialization: call delegate
delegate();
#include <dpl/read_write_mutex.h>
#include <dpl/assert.h>
-namespace DPL
-{
+namespace DPL {
ReadWriteMutex::ReadWriteMutex()
{
- if (pthread_rwlock_init(&m_rwlock, NULL) != 0)
+ if (pthread_rwlock_init(&m_rwlock, NULL) != 0) {
Throw(Exception::CreateFailed);
+ }
}
ReadWriteMutex::~ReadWriteMutex()
{
- if (pthread_rwlock_destroy(&m_rwlock) != 0)
+ if (pthread_rwlock_destroy(&m_rwlock) != 0) {
Throw(Exception::DestroyFailed);
+ }
}
void ReadWriteMutex::ReadLock() const
{
- if (pthread_rwlock_rdlock(&m_rwlock) != 0)
+ if (pthread_rwlock_rdlock(&m_rwlock) != 0) {
Throw(Exception::ReadLockFailed);
+ }
}
void ReadWriteMutex::WriteLock() const
{
- if (pthread_rwlock_wrlock(&m_rwlock) != 0)
+ if (pthread_rwlock_wrlock(&m_rwlock) != 0) {
Throw(Exception::WriteLockFailed);
+ }
}
void ReadWriteMutex::Unlock() const
{
- if (pthread_rwlock_unlock(&m_rwlock) != 0)
+ if (pthread_rwlock_unlock(&m_rwlock) != 0) {
Throw(Exception::UnlockFailed);
+ }
}
-ReadWriteMutex::ScopedReadLock::ScopedReadLock(ReadWriteMutex *mutex)
- : m_mutex(mutex)
+ReadWriteMutex::ScopedReadLock::ScopedReadLock(ReadWriteMutex *mutex) :
+ m_mutex(mutex)
{
Assert(mutex != NULL);
m_mutex->ReadLock();
m_mutex->Unlock();
}
-ReadWriteMutex::ScopedWriteLock::ScopedWriteLock(ReadWriteMutex *mutex)
- : m_mutex(mutex)
+ReadWriteMutex::ScopedWriteLock::ScopedWriteLock(ReadWriteMutex *mutex) :
+ m_mutex(mutex)
{
Assert(mutex != NULL);
m_mutex->WriteLock();
#include <dpl/recursive_mutex.h>
#include <dpl/assert.h>
-namespace DPL
-{
+namespace DPL {
RecursiveMutex::RecursiveMutex()
{
pthread_mutexattr_t attr;
pthread_mutexattr_init(&attr);
pthread_mutexattr_settype(&attr, PTHREAD_MUTEX_RECURSIVE);
- if (pthread_mutex_init(&m_mutex, &attr) != 0)
+ if (pthread_mutex_init(&m_mutex, &attr) != 0) {
Throw(Exception::CreateFailed);
+ }
}
RecursiveMutex::~RecursiveMutex()
{
- if (pthread_mutex_destroy(&m_mutex) != 0)
+ if (pthread_mutex_destroy(&m_mutex) != 0) {
Throw(Exception::DestroyFailed);
+ }
}
void RecursiveMutex::Lock() const
{
- if (pthread_mutex_lock(&m_mutex) != 0)
+ if (pthread_mutex_lock(&m_mutex) != 0) {
Throw(Exception::LockFailed);
+ }
}
void RecursiveMutex::Unlock() const
{
- if (pthread_mutex_unlock(&m_mutex) != 0)
+ if (pthread_mutex_unlock(&m_mutex) != 0) {
Throw(Exception::UnlockFailed);
+ }
}
-RecursiveMutex::ScopedLock::ScopedLock(RecursiveMutex *mutex)
- : m_mutex(mutex)
+RecursiveMutex::ScopedLock::ScopedLock(RecursiveMutex *mutex) :
+ m_mutex(mutex)
{
Assert(mutex != NULL);
m_mutex->Lock();
--- /dev/null
+/*
+ * Copyright (c) 2013 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 scoped_dir.cpp
+ * @author Iwanek Tomasz (t.iwanek@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation scoped directory
+ */
+#include <dpl/scoped_dir.h>
+#include <dpl/log/log.h>
+
+#include <fts.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+namespace {
+
+bool removeRecusive(const char * path)
+{
+ FTS *fts;
+ FTSENT *ftsent;
+ bool rv = true;
+ char * const paths[] = { const_cast<char * const>(path), NULL };
+ if ((fts = fts_open(paths, FTS_PHYSICAL | FTS_NOCHDIR, NULL)) == NULL) {
+ return false;
+ }
+ while ((ftsent = fts_read(fts)) != NULL) {
+ switch (ftsent->fts_info) {
+ case FTS_D:
+ break;
+ case FTS_DP:
+ if (rmdir(ftsent->fts_accpath) != 0) {
+ rv = false;
+ }
+ break;
+ case FTS_DC:
+ case FTS_F:
+ case FTS_NSOK:
+ case FTS_SL:
+ case FTS_SLNONE:
+ case FTS_DEFAULT:
+ if (unlink(ftsent->fts_accpath) != 0) {
+ rv = false;
+ }
+ break;
+ case FTS_NS:
+ rv = false;
+ break;
+ case FTS_DOT:
+ case FTS_DNR:
+ case FTS_ERR:
+ default:
+ rv = false;
+ break;
+ }
+ }
+ if (fts_close(fts) == -1) {
+ rv = false;
+ }
+ return rv;
+}
+
+}
+
+namespace DPL {
+
+ScopedDirPolicy::Type ScopedDirPolicy::NullValue()
+{
+ return std::string();
+}
+
+void ScopedDirPolicy::Destroy(Type str)
+{
+ if(!str.empty())
+ {
+ bool status = removeRecusive(str.c_str());
+ if(!status)
+ {
+ LogError("Error while removing recursively: " << str);
+ }
+ }
+}
+
+ScopedDir::ScopedDir(const std::string & str, mode_t mode) : BaseType(str)
+{
+ if(!str.empty())
+ {
+ mkdir(str.c_str(), mode);
+ }
+}
+
+} // namespace DPL
+
#include <fcntl.h>
#include <unistd.h>
-namespace DPL
-{
+namespace DPL {
void Semaphore::Remove(const std::string &fileName)
{
if (sem_unlink(fileName.c_str()) == -1) {
int error = errno;
LogPedantic("Failed to unlink semaphore. Errno: " << error);
ThrowMsg(Exception::RemoveFailed,
- "Failed to unlink semaphore. Errno: " << error);
+ "Failed to unlink semaphore. Errno: " << error);
}
}
LogPedantic("Failed to create semaphore. Errno: " << error);
ThrowMsg(Exception::CreateFailed,
- "Failed to create semaphore. Errno: " << error);
+ "Failed to create semaphore. Errno: " << error);
}
m_type = Type_Unnamed;
sem_t *semaphore;
- do
- {
- if (allowCreate)
- {
- if (exclusiveCreate)
- {
+ do {
+ if (allowCreate) {
+ if (exclusiveCreate) {
semaphore = sem_open(fileName.c_str(),
O_CREAT | O_EXCL,
permissions,
static_cast<unsigned>(maxLockCount));
- }
- else
- {
+ } else {
semaphore = sem_open(fileName.c_str(),
O_CREAT,
permissions,
static_cast<unsigned>(maxLockCount));
}
- }
- else
- {
+ } else {
semaphore = sem_open(fileName.c_str(), 0);
}
- }
- while (semaphore == SEM_FAILED && errno == EINTR);
+ } while (semaphore == SEM_FAILED && errno == EINTR);
- if (semaphore == SEM_FAILED)
- {
+ if (semaphore == SEM_FAILED) {
int error = errno;
LogPedantic("Failed to create semaphore '" << fileName
- << "'. Errno: " << error);
+ << "'. Errno: " << error);
ThrowMsg(Exception::CreateFailed,
"Failed to create semaphore '" << fileName
- << "'. Errno: " << error);
+ << "'. Errno: " << error);
}
m_semaphore.named.handle = semaphore;
m_semaphore.named.name = strdup(fileName.c_str()); // May be NULL
- if (m_semaphore.named.name == NULL)
+ if (m_semaphore.named.name == NULL) {
LogPedantic("Out of memory while duplicating semaphore name");
+ }
m_semaphore.named.unlinkOnDestroy = unlinkOnDestroy;
sem_t *Semaphore::InternalGet() const
{
- switch (m_type)
- {
- case Type_Unnamed:
- return &m_semaphore.unnamed.handle;
+ switch (m_type) {
+ case Type_Unnamed:
+ return &m_semaphore.unnamed.handle;
- case Type_Named:
- return m_semaphore.named.handle;
+ case Type_Named:
+ return m_semaphore.named.handle;
- default:
- Assert(false && "Invalid type");
+ default:
+ Assert(false && "Invalid type");
}
return NULL;
void Semaphore::InternalDestroy()
{
- switch (m_type)
- {
- case Type_Unnamed:
- if (sem_destroy(&m_semaphore.unnamed.handle) == -1)
- {
- int error = errno;
+ switch (m_type) {
+ case Type_Unnamed:
+ if (sem_destroy(&m_semaphore.unnamed.handle) == -1) {
+ int error = errno;
- LogPedantic("Failed to destroy semaphore. Errno: " << error);
- }
- break;
+ LogPedantic("Failed to destroy semaphore. Errno: " << error);
+ }
+ break;
+
+ case Type_Named:
+ if (sem_close(m_semaphore.named.handle) == -1) {
+ int error = errno;
+
+ LogPedantic("Failed to close semaphore. Errno: " << error);
+ }
- case Type_Named:
- if (sem_close(m_semaphore.named.handle) == -1)
+ if (m_semaphore.named.name != NULL) {
+ // Unlink named semaphore
+ if (m_semaphore.named.unlinkOnDestroy &&
+ sem_unlink(m_semaphore.named.name) == -1)
{
int error = errno;
- LogPedantic("Failed to close semaphore. Errno: " << error);
+ LogPedantic("Failed to unlink semaphore. Errno: "
+ << error);
}
- if (m_semaphore.named.name != NULL)
- {
- // Unlink named semaphore
- if (m_semaphore.named.unlinkOnDestroy &&
- sem_unlink(m_semaphore.named.name) == -1)
- {
- int error = errno;
-
- LogPedantic("Failed to unlink semaphore. Errno: "
- << error);
- }
-
- // Free name
- free(m_semaphore.named.name);
- }
- break;
+ // Free name
+ free(m_semaphore.named.name);
+ }
+ break;
- default:
- Assert(false && "Invalid type");
+ default:
+ Assert(false && "Invalid type");
}
}
void Semaphore::Lock() const
{
- if (TEMP_FAILURE_RETRY(sem_wait(InternalGet())) != 0)
- {
+ if (TEMP_FAILURE_RETRY(sem_wait(InternalGet())) != 0) {
int error = errno;
LogPedantic("Failed to lock semaphore. Errno: " << error);
ThrowMsg(Exception::LockFailed,
- "Failed to lock semaphore. Errno: " << error);
+ "Failed to lock semaphore. Errno: " << error);
}
}
void Semaphore::Unlock() const
{
- if (sem_post(InternalGet()) != 0)
- {
+ if (sem_post(InternalGet()) != 0) {
int error = errno;
LogPedantic("Failed to unlock semaphore. Errno: " << error);
ThrowMsg(Exception::UnlockFailed,
- "Failed to unlock semaphore. Errno: " << error);
+ "Failed to unlock semaphore. Errno: " << error);
}
}
-Semaphore::ScopedLock::ScopedLock(Semaphore *semaphore)
- : m_semaphore(semaphore)
+Semaphore::ScopedLock::ScopedLock(Semaphore *semaphore) :
+ m_semaphore(semaphore)
{
Assert(semaphore != NULL);
m_semaphore->Lock();
{
m_semaphore->Unlock();
}
- Catch (Semaphore::Exception::UnlockFailed)
+ Catch(Semaphore::Exception::UnlockFailed)
{
LogPedantic("Failed to leave semaphore scoped lock");
}
#include <errno.h>
#include <dpl/assert.h>
-namespace DPL
-{
+namespace DPL {
namespace // anonumous
{
const char *LOCK_PREFIX_PATH = "/tmp/dpl_single_instance_";
}
-SingleInstance::SingleInstance()
- : m_locked(false),
- m_fdLock(-1)
-{
-}
+SingleInstance::SingleInstance() :
+ m_locked(false),
+ m_fdLock(-1)
+{}
SingleInstance::~SingleInstance()
{
lock.l_len = 1;
// Open lock file
- m_fdLock = TEMP_FAILURE_RETRY(open((std::string(LOCK_PREFIX_PATH) + lockName).c_str(), O_WRONLY | O_CREAT, 0666));
+ m_fdLock =
+ TEMP_FAILURE_RETRY(open((std::string(LOCK_PREFIX_PATH) +
+ lockName).c_str(),
+ O_WRONLY | O_CREAT, 0666));
- if (m_fdLock == -1)
+ if (m_fdLock == -1) {
ThrowMsg(Exception::LockError, "Cannot open single instance lock file!");
+ }
// Lock file
int result = TEMP_FAILURE_RETRY(fcntl(m_fdLock, F_SETLK, &lock));
// Was the instance successfuly locked ?
- if (result == 0)
- {
+ if (result == 0) {
LogPedantic("Instance locked: " << lockName);
// It is locked now
return true;
}
- if (errno == EACCES || errno == EAGAIN)
- {
+ if (errno == EACCES || errno == EAGAIN) {
LogPedantic("Instance is already running: " << lockName);
return false;
}
void SingleInstance::Release()
{
- if (!m_locked)
+ if (!m_locked) {
return;
+ }
LogPedantic("Unlocking single instance");
int result = TEMP_FAILURE_RETRY(fcntl(m_fdLock, F_SETLK, &lock));
// Was the instance successfuly unlocked ?
- if (result == -1)
- ThrowMsg(Exception::LockError, "Cannot unlock single instance lock file!");
+ if (result == -1) {
+ ThrowMsg(Exception::LockError,
+ "Cannot unlock single instance lock file!");
+ }
// Close lock file
- if (TEMP_FAILURE_RETRY(close(m_fdLock)) == -1)
- ThrowMsg(Exception::LockError, "Cannot close single instance lock file!");
+ if (TEMP_FAILURE_RETRY(close(m_fdLock)) == -1) {
+ ThrowMsg(Exception::LockError,
+ "Cannot close single instance lock file!");
+ }
m_fdLock = -1;
#include <unicode/ustring.h>
// TODO: Completely move to ICU
-namespace DPL
-{
+namespace DPL {
namespace //anonymous
{
class ASCIIValidator
{
const std::string& m_TestedString;
-public:
+ public:
ASCIIValidator(const std::string& aTestedString);
void operator()(char aCharacter) const;
};
-ASCIIValidator::ASCIIValidator(const std::string& aTestedString)
- : m_TestedString(aTestedString)
-{
-}
+ASCIIValidator::ASCIIValidator(const std::string& aTestedString) :
+ m_TestedString(aTestedString)
+{}
void ASCIIValidator::operator()(char aCharacter) const
{
// Check for ASCII data range
- if (aCharacter <= 0)
- {
- ThrowMsg(StringException::InvalidASCIICharacter,
- "invalid character code " << static_cast<int>(aCharacter)
- << " from string [" << m_TestedString
- << "] passed as ASCII");
+ if (aCharacter <= 0) {
+ ThrowMsg(
+ StringException::InvalidASCIICharacter,
+ "invalid character code " << static_cast<int>(aCharacter)
+ << " from string [" <<
+ m_TestedString
+ << "] passed as ASCII");
}
}
String FromUTF8String(const std::string& aIn)
{
- if (aIn.empty())
-
+ if (aIn.empty()) {
return String();
+ }
size_t inbytes = aIn.size();
// oldsize - letters in UTF-8 string
// end - end character for UTF-32 (\0)
// bom - Unicode header in front of string (0xfeff)
- size_t outbytes = sizeof(wchar_t)*(inbytes + 2);
+ size_t outbytes = sizeof(wchar_t) * (inbytes + 2);
std::vector<wchar_t> output(inbytes + 2, 0);
size_t outbytesleft = outbytes;
// but during conversion from UTF32 uses internaly wchar_t
char* outbuf = reinterpret_cast<char*>(&output[0]);
- iconv_t iconvHandle = iconv_open("UTF-32","UTF-8");
+ iconv_t iconvHandle = iconv_open("UTF-32", "UTF-8");
- if (gc_IconvOperError == iconvHandle)
- {
+ if (gc_IconvOperError == iconvHandle) {
int error = errno;
ThrowMsg(StringException::IconvInitErrorUTF8ToUTF32,
"error: " << GetErrnoString(error));
}
- size_t iconvRet = iconv(iconvHandle, &inbuf, &inbytes, &outbuf, &outbytesleft);
+ size_t iconvRet = iconv(iconvHandle,
+ &inbuf,
+ &inbytes,
+ &outbuf,
+ &outbytesleft);
iconv_close(iconvHandle);
- if (gc_IconvConvertError == iconvRet)
- {
+ if (gc_IconvConvertError == iconvRet) {
ThrowMsg(StringException::IconvConvertErrorUTF8ToUTF32,
"iconv failed for " << "UTF-32 <- UTF-8" << "error: "
- << GetErrnoString());
+ << GetErrnoString());
}
// Ignore BOM in front of UTF-32
std::string ToUTF8String(const DPL::String& aIn)
{
- if (aIn.empty())
-
+ if (aIn.empty()) {
return std::string();
+ }
size_t inbytes = aIn.size() * sizeof(wchar_t);
size_t outbytes = inbytes + sizeof(char);
// wstring returns wchar_t but iconv expects char*
// iconv internally is processing input as wchar_t
- char* inbuf = reinterpret_cast<char*>(const_cast<wchar_t*>(aIn.c_str()));
+ char* inbuf = reinterpret_cast<char*>(const_cast<wchar_t*>(aIn.c_str()));
std::vector<char> output(inbytes, 0);
char* outbuf = &output[0];
size_t outbytesleft = outbytes;
- iconv_t iconvHandle = iconv_open("UTF-8","UTF-32");
+ iconv_t iconvHandle = iconv_open("UTF-8", "UTF-32");
- if (gc_IconvOperError == iconvHandle)
- {
+ if (gc_IconvOperError == iconvHandle) {
ThrowMsg(StringException::IconvInitErrorUTF32ToUTF8,
"iconv_open failed for " << "UTF-8 <- UTF-32"
- << "error: " << GetErrnoString());
+ << "error: " << GetErrnoString());
}
- size_t iconvRet = iconv(iconvHandle, &inbuf, &inbytes, &outbuf, &outbytesleft);
+ size_t iconvRet = iconv(iconvHandle,
+ &inbuf,
+ &inbytes,
+ &outbuf,
+ &outbytesleft);
iconv_close(iconvHandle);
- if (gc_IconvConvertError == iconvRet)
- {
+ if (gc_IconvConvertError == iconvRet) {
ThrowMsg(StringException::IconvConvertErrorUTF32ToUTF8,
"iconv failed for " << "UTF-8 <- UTF-32"
- << "error: " << GetErrnoString());
+ << "error: " << GetErrnoString());
}
return &output[0];
{
// What buffer size is ok ?
LogPedantic("ICU: Output buffer size: " << size);
- }
- else
- {
+ } else {
ThrowMsg(StringException::ICUInvalidCharacterFound,
"ICU: Failed to retrieve output string size. Error: "
<< error);
-1,
&error);
- if (!U_SUCCESS(error))
- {
+ if (!U_SUCCESS(error)) {
ThrowMsg(StringException::ICUInvalidCharacterFound,
"ICU: Failed to convert string. Error: " << error);
}
ScopedArray<UChar> leftICU(ConvertToICU(left));
ScopedArray<UChar> rightICU(ConvertToICU(right));
- if (caseInsensitive)
- {
+ if (caseInsensitive) {
return static_cast<int>(u_strcasecmp(leftICU.Get(), rightICU.Get(), 0));
- }
- else
- {
+ } else {
return static_cast<int>(u_strcmp(leftICU.Get(), rightICU.Get()));
}
}
#include <dpl/task_list.h>
#include <dpl/assert.h>
-namespace DPL
-{
-TaskList::TaskList()
- : m_switched(false),
- m_running(false)
+namespace DPL {
+TaskList::TaskList() :
+ m_switched(false),
+ m_running(false)
{
m_currentTask = m_tasks.end();
}
TaskList::~TaskList()
{
- for (Tasks::iterator i = m_tasks.begin(); i != m_tasks.end(); ++i)
+ for (Tasks::iterator i = m_tasks.begin(); i != m_tasks.end(); ++i) {
delete *i;
+ }
}
void TaskList::AddTask(Task *task)
{
m_running = true;
- Assert(m_currentTask != m_tasks.end() && "Task list is empty or all tasks done");
+ Assert(
+ m_currentTask != m_tasks.end() &&
+ "Task list is empty or all tasks done");
m_switched = false;
bool result = (*m_currentTask)->NextStep();
- if (result || m_switched)
+ if (result || m_switched) {
return true;
+ }
return ++m_currentTask != m_tasks.end();
}
bool TaskList::Abort()
{
- m_tasks.erase(m_currentTask,m_tasks.end());
+ m_tasks.erase(m_currentTask, m_tasks.end());
m_tasks.reverse();
- for (Tasks::iterator i = m_tasks.begin(); i != m_tasks.end();)
- {
+ for (Tasks::iterator i = m_tasks.begin(); i != m_tasks.end();) {
//If given task does not have any "abortSteps", remove it from the list
- if(!(*i)->Abort())
- {
+ if (!(*i)->Abort()) {
delete *i;
- i=m_tasks.erase(i);
+ i = m_tasks.erase(i);
continue;
}
++i;
}
- if(m_tasks.empty())
+ if (m_tasks.empty()) {
return false;
+ }
- m_currentTask=m_tasks.begin();
+ m_currentTask = m_tasks.begin();
return true;
}
{
size_t count = 0;
- for (Tasks::const_iterator i = m_tasks.begin(); i != m_tasks.end(); ++i)
+ for (Tasks::const_iterator i = m_tasks.begin(); i != m_tasks.end(); ++i) {
count += (*i)->GetStepCount();
+ }
return count;
}
-
} // namespace DPL
class ThreadSpecific
{
-public:
+ public:
pthread_key_t threadSpecific;
- ThreadSpecific()
- : threadSpecific(0)
+ ThreadSpecific() :
+ threadSpecific(0)
{
- threadSpecific=0;
+ threadSpecific = 0;
pthread_key_create(&threadSpecific, NULL);
}
static ThreadSpecific g_threadSpecific;
} // namespace anonymous
-namespace DPL
-{
+namespace DPL {
bool g_TLSforMainCreated = false;
-Thread::Thread()
- : m_thread(0),
- m_abandon(false),
- m_running(false),
- m_directInvoke(false)
-{
-}
+Thread::Thread() :
+ m_thread(0),
+ m_abandon(false),
+ m_running(false),
+ m_directInvoke(false)
+{}
Thread::~Thread()
{
// Remove any remainig events
// Thread proc is surely not running now
- for (InternalEventList::iterator iterator = m_eventList.begin(); iterator != m_eventList.end(); ++iterator)
+ for (InternalEventList::iterator iterator = m_eventList.begin();
+ iterator != m_eventList.end();
+ ++iterator)
+ {
iterator->eventDeleteProc(iterator->event, iterator->userParam);
+ }
m_eventList.clear();
}
Thread *Thread::GetCurrentThread()
{
- if (pthread_equal(pthread_self(), g_mainThread))
+ if (pthread_equal(pthread_self(), g_mainThread)) {
return NULL;
+ }
void *threadSpecific = pthread_getspecific(g_threadSpecific.threadSpecific);
// Is this a managed thread ?
- if (threadSpecific == NULL)
+ if (threadSpecific == NULL) {
Throw(Exception::UnmanagedThread);
+ }
return static_cast<Thread *>(threadSpecific);
}
Assert(This != NULL);
// Set thread specific
- int result = pthread_setspecific(g_threadSpecific.threadSpecific, This);
+ int result = pthread_setspecific(g_threadSpecific.threadSpecific, This);
- if (result!=0)
- {
+ if (result != 0) {
LogError("Failed to set threadSpecific. Error: " << strerror(result));
}
This->m_running = false;
// Abandon thread
- if (This->m_abandon)
- {
+ if (This->m_abandon) {
LogPedantic("Thread was abandoned");
pthread_detach(This->m_thread);
- }
- else
- {
+ } else {
LogPedantic("Thread is joinable");
}
}
void Thread::ProcessEvents()
{
LogPedantic("Processing events");
-
+
// Steal current event list
InternalEventList stolenEvents;
// Process event list
LogPedantic("Stolen " << stolenEvents.size() << " internal events");
- for (InternalEventList::iterator iterator = stolenEvents.begin(); iterator != stolenEvents.end(); ++iterator)
+ for (InternalEventList::iterator iterator = stolenEvents.begin();
+ iterator != stolenEvents.end();
+ ++iterator)
{
// Dispatch immediate event
iterator->eventDispatchProc(iterator->event, iterator->userParam);
unsigned long currentTimeMiliseconds = GetCurrentTimeMiliseconds();
// Info
- LogPedantic("Processing timed events. Time now: " << currentTimeMiliseconds << " ms");
+ LogPedantic(
+ "Processing timed events. Time now: " << currentTimeMiliseconds <<
+ " ms");
// All timed events are sorted chronologically
// Emit timed out events
while (!m_timedEventVector.empty() &&
- currentTimeMiliseconds >= m_timedEventVector.begin()->registerTimeMiliseconds + m_timedEventVector.begin()->dueTimeMiliseconds)
+ currentTimeMiliseconds >=
+ m_timedEventVector.begin()->registerTimeMiliseconds +
+ m_timedEventVector.begin()->dueTimeMiliseconds)
{
// Info
- LogPedantic("Transforming timed event into immediate event. Absolute due time: " <<
- (m_timedEventVector.begin()->registerTimeMiliseconds + m_timedEventVector.begin()->dueTimeMiliseconds) << " ms");
+ LogPedantic(
+ "Transforming timed event into immediate event. Absolute due time: "
+ <<
+ (m_timedEventVector.begin()->registerTimeMiliseconds +
+ m_timedEventVector.begin()->dueTimeMiliseconds) <<
+ " ms");
// Emit immediate event
PushEvent(m_timedEventVector.begin()->event,
{
timeval tv;
gettimeofday(&tv, NULL);
- return static_cast<unsigned long>(tv.tv_sec) * 1000 + static_cast<unsigned long>(tv.tv_usec) / 1000;
+ return static_cast<unsigned long>(tv.tv_sec) * 1000 +
+ static_cast<unsigned long>(tv.tv_usec) / 1000;
}
int Thread::Exec()
handleList.push_back(std::make_pair(m_quitEvent.GetHandle(), WaitMode::Read));
// index 1: Event occurred event handle
- handleList.push_back(std::make_pair(m_eventInvoker.GetHandle(), WaitMode::Read));
+ handleList.push_back(std::make_pair(m_eventInvoker.GetHandle(),
+ WaitMode::Read));
// index 2: Timed event occurred event handle
- handleList.push_back(std::make_pair(m_timedEventInvoker.GetHandle(), WaitMode::Read));
+ handleList.push_back(std::make_pair(m_timedEventInvoker.GetHandle(),
+ WaitMode::Read));
// index 3: Waitable handle watch support invoker
- handleList.push_back(std::make_pair(WaitableHandleWatchSupport::WaitableInvokerHandle(), WaitMode::Read));
+ handleList.push_back(std::make_pair(WaitableHandleWatchSupport::
+ WaitableInvokerHandle(),
+ WaitMode::Read));
//
// Watch list might have been initialized before threaded started
// Need to fill waitable event watch list in this case
//
{
- WaitableHandleListEx waitableHandleWatchHandles = WaitableHandleWatchSupport::WaitableWatcherHandles();
- std::copy(waitableHandleWatchHandles.begin(), waitableHandleWatchHandles.end(), std::back_inserter(handleList));
+ WaitableHandleListEx waitableHandleWatchHandles =
+ WaitableHandleWatchSupport::WaitableWatcherHandles();
+ std::copy(
+ waitableHandleWatchHandles.begin(),
+ waitableHandleWatchHandles.end(), std::back_inserter(handleList));
}
// Quit flag
bool quit = false;
- while (!quit)
- {
+ while (!quit) {
// Retrieve minimum wait time, according to timed events list
unsigned long minimumWaitTime;
{
Mutex::ScopedLock lock(&m_timedEventMutex);
- if (!m_timedEventVector.empty())
- {
- unsigned long currentTimeMiliseconds = GetCurrentTimeMiliseconds();
- unsigned long destinationTimeMiliseconds = m_timedEventVector.begin()->registerTimeMiliseconds + m_timedEventVector.begin()->dueTimeMiliseconds;
+ if (!m_timedEventVector.empty()) {
+ unsigned long currentTimeMiliseconds =
+ GetCurrentTimeMiliseconds();
+ unsigned long destinationTimeMiliseconds =
+ m_timedEventVector.begin()->registerTimeMiliseconds +
+ m_timedEventVector.begin()->dueTimeMiliseconds;
// Are we already late with timed event ?
- if (currentTimeMiliseconds > destinationTimeMiliseconds)
+ if (currentTimeMiliseconds > destinationTimeMiliseconds) {
minimumWaitTime = 0;
- else
- minimumWaitTime = destinationTimeMiliseconds - currentTimeMiliseconds;
- }
- else
+ } else {
+ minimumWaitTime = destinationTimeMiliseconds -
+ currentTimeMiliseconds;
+ }
+ } else {
minimumWaitTime = 0xFFFFFFFF; // Infinity
+ }
}
// Info
- LogPedantic("Thread loop minimum wait time: " << minimumWaitTime << " ms");
+ LogPedantic(
+ "Thread loop minimum wait time: " << minimumWaitTime << " ms");
// Do thread waiting
- WaitableHandleIndexList waitableHandleIndexList = WaitForMultipleHandles(handleList, minimumWaitTime);
+ WaitableHandleIndexList waitableHandleIndexList =
+ WaitForMultipleHandles(handleList, minimumWaitTime);
- if (waitableHandleIndexList.empty())
- {
+ if (waitableHandleIndexList.empty()) {
// Timeout occurred. Process timed events.
LogPedantic("Timed event list elapsed invoker");
ProcessTimedEvents();
}
// Go through each index
- for (WaitableHandleIndexList::const_iterator waitableHandleIndexIterator = waitableHandleIndexList.begin();
+ for (WaitableHandleIndexList::const_iterator
+ waitableHandleIndexIterator = waitableHandleIndexList.begin();
waitableHandleIndexIterator != waitableHandleIndexList.end();
++waitableHandleIndexIterator)
{
LogPedantic("Event loop triggered with index: " << index);
- switch (index)
- {
- case 0:
- // Quit waitable event handle
- quit = true;
- break;
+ switch (index) {
+ case 0:
+ // Quit waitable event handle
+ quit = true;
+ break;
- case 1:
- // Event occurred event handle
- ProcessEvents();
+ case 1:
+ // Event occurred event handle
+ ProcessEvents();
- // Handle direct invoker
- if (m_directInvoke)
- {
- m_directInvoke = false;
+ // Handle direct invoker
+ if (m_directInvoke) {
+ m_directInvoke = false;
- LogPedantic("Handling direct invoker");
+ LogPedantic("Handling direct invoker");
- // Update list
- while (handleList.size() > MIN_HANDLE_LIST_SIZE)
- handleList.pop_back();
+ // Update list
+ while (handleList.size() > MIN_HANDLE_LIST_SIZE) {
+ handleList.pop_back();
+ }
- // Insert current waitable event handles instead
- {
- WaitableHandleListEx waitableHandleWatchHandles = WaitableHandleWatchSupport::WaitableWatcherHandles();
- std::copy(waitableHandleWatchHandles.begin(), waitableHandleWatchHandles.end(), std::back_inserter(handleList));
- }
+ // Insert current waitable event handles instead
+ {
+ WaitableHandleListEx waitableHandleWatchHandles =
+ WaitableHandleWatchSupport::WaitableWatcherHandles();
+ std::copy(
+ waitableHandleWatchHandles.begin(),
+ waitableHandleWatchHandles.end(),
+ std::back_inserter(handleList));
}
+ }
- // Done
- break;
+ // Done
+ break;
- case 2:
- // Timed event list changed
- LogPedantic("Timed event list changed invoker");
- ProcessTimedEvents();
+ case 2:
+ // Timed event list changed
+ LogPedantic("Timed event list changed invoker");
+ ProcessTimedEvents();
- // Reset timed event invoker
- m_timedEventInvoker.Reset();
+ // Reset timed event invoker
+ m_timedEventInvoker.Reset();
- // Done
- break;
+ // Done
+ break;
- case 3:
- // Waitable handle watch support invoker
- LogPedantic("Waitable handle watch invoker event occurred");
+ case 3:
+ // Waitable handle watch support invoker
+ LogPedantic("Waitable handle watch invoker event occurred");
- // First, remove all previous handles
- while (handleList.size() > MIN_HANDLE_LIST_SIZE)
- handleList.pop_back();
+ // First, remove all previous handles
+ while (handleList.size() > MIN_HANDLE_LIST_SIZE) {
+ handleList.pop_back();
+ }
- // Insert current waitable event handles instead
- {
- WaitableHandleListEx waitableHandleWatchHandles = WaitableHandleWatchSupport::WaitableWatcherHandles();
- std::copy(waitableHandleWatchHandles.begin(), waitableHandleWatchHandles.end(), std::back_inserter(handleList));
- }
+ // Insert current waitable event handles instead
+ {
+ WaitableHandleListEx waitableHandleWatchHandles =
+ WaitableHandleWatchSupport::WaitableWatcherHandles();
+ std::copy(
+ waitableHandleWatchHandles.begin(),
+ waitableHandleWatchHandles.end(),
+ std::back_inserter(handleList));
+ }
- // Handle invoker in waitable watch support
- WaitableHandleWatchSupport::InvokerFinished();
+ // Handle invoker in waitable watch support
+ WaitableHandleWatchSupport::InvokerFinished();
- LogPedantic("Waitable handle watch invoker event handled");
+ LogPedantic("Waitable handle watch invoker event handled");
- // Done
- break;
+ // Done
+ break;
- default:
- // Waitable event watch list
- LogPedantic("Waitable handle watch event occurred");
+ default:
+ // Waitable event watch list
+ LogPedantic("Waitable handle watch event occurred");
- // Handle event in waitable handle watch
- {
- std::pair<WaitableHandle, WaitMode::Type> handle = handleList[index];
- WaitableHandleWatchSupport::HandleWatcher(handle.first, handle.second);
+ // Handle event in waitable handle watch
+ {
+ std::pair<WaitableHandle,
+ WaitMode::Type> handle = handleList[index];
+ WaitableHandleWatchSupport::HandleWatcher(handle.first,
+ handle.second);
+ }
+
+ if (m_directInvoke) {
+ m_directInvoke = false;
+
+ LogPedantic("Handling direct invoker");
+
+ // Update list
+ while (handleList.size() > MIN_HANDLE_LIST_SIZE) {
+ handleList.pop_back();
}
- if (m_directInvoke)
+ // Insert current waitable event handles instead
{
- m_directInvoke = false;
-
- LogPedantic("Handling direct invoker");
-
- // Update list
- while (handleList.size() > MIN_HANDLE_LIST_SIZE)
- handleList.pop_back();
-
- // Insert current waitable event handles instead
- {
- WaitableHandleListEx waitableHandleWatchHandles =
- WaitableHandleWatchSupport::
- WaitableWatcherHandles();
- std::copy(waitableHandleWatchHandles.begin(),
- waitableHandleWatchHandles.end(),
- std::back_inserter(handleList));
- }
+ WaitableHandleListEx waitableHandleWatchHandles =
+ WaitableHandleWatchSupport::
+ WaitableWatcherHandles();
+ std::copy(waitableHandleWatchHandles.begin(),
+ waitableHandleWatchHandles.end(),
+ std::back_inserter(handleList));
}
+ }
- LogPedantic("Waitable handle watch event handled");
+ LogPedantic("Waitable handle watch event handled");
- // Done
- break;
+ // Done
+ break;
}
}
}
{
Mutex::ScopedLock lock(&m_stateMutex);
- if (m_running)
+ if (m_running) {
return;
+ }
// Try to create new thread
- if (pthread_create(&m_thread, NULL, &StaticThreadEntry, this) != 0)
+ if (pthread_create(&m_thread, NULL, &StaticThreadEntry, this) != 0) {
Throw(Exception::RunFailed);
+ }
// At default, we abandon thread
m_abandon = true;
Mutex::ScopedLock lock(&m_stateMutex);
// Is thread running ?
- if (!m_running)
+ if (!m_running) {
return;
+ }
LogPedantic("Quitting thread...");
// Wait for joinable thread
void *result;
- if (pthread_join(joinableThread, &result) != 0)
+ if (pthread_join(joinableThread, &result) != 0) {
Throw(Exception::QuitFailed);
+ }
LogPedantic("Thread quit");
}
-void Thread::PushEvent(void *event, EventDispatchProc eventDispatchProc, EventDeleteProc eventDeleteProc, void *userParam)
+void Thread::PushEvent(void *event,
+ EventDispatchProc eventDispatchProc,
+ EventDeleteProc eventDeleteProc,
+ void *userParam)
{
// Enter event list critical section
Mutex::ScopedLock lock(&m_eventMutex);
// Push new event
- m_eventList.push_back(InternalEvent(event, userParam, eventDispatchProc, eventDeleteProc));
+ m_eventList.push_back(InternalEvent(event, userParam, eventDispatchProc,
+ eventDeleteProc));
// Trigger invoker
m_eventInvoker.Signal();
LogPedantic("Event pushed and invoker signaled");
}
-void Thread::PushTimedEvent(void *event, double dueTimeSeconds, EventDispatchProc eventDispatchProc, EventDeleteProc eventDeleteProc, void *userParam)
+void Thread::PushTimedEvent(void *event,
+ double dueTimeSeconds,
+ EventDispatchProc eventDispatchProc,
+ EventDeleteProc eventDeleteProc,
+ void *userParam)
{
// Check for developer errors
Assert(dueTimeSeconds >= 0.0);
unsigned long currentTimeMiliseconds = GetCurrentTimeMiliseconds();
// Convert to miliseconds
- unsigned long dueTimeMiliseconds = static_cast<unsigned long>(1000.0 * dueTimeSeconds);
+ unsigned long dueTimeMiliseconds =
+ static_cast<unsigned long>(1000.0 * dueTimeSeconds);
// Push new timed event
- m_timedEventVector.push_back(InternalTimedEvent(event, userParam, dueTimeMiliseconds, currentTimeMiliseconds, eventDispatchProc, eventDeleteProc));
+ m_timedEventVector.push_back(InternalTimedEvent(event, userParam,
+ dueTimeMiliseconds,
+ currentTimeMiliseconds,
+ eventDispatchProc,
+ eventDeleteProc));
// Heapify timed events
std::make_heap(m_timedEventVector.begin(), m_timedEventVector.end());
// Trigger invoker
m_timedEventInvoker.Signal();
- LogPedantic("Timed event pushed and invoker signaled: due time: " << dueTimeMiliseconds << " ms, absolute due time: " << currentTimeMiliseconds + dueTimeMiliseconds << " ms");
+ LogPedantic(
+ "Timed event pushed and invoker signaled: due time: " <<
+ dueTimeMiliseconds << " ms, absolute due time: " <<
+ currentTimeMiliseconds + dueTimeMiliseconds << " ms");
}
Thread *Thread::GetInvokerThread()
void Thread::Sleep(uint64_t seconds)
{
- NanoSleep(seconds * NANOSECONDS_PER_SECOND);
+ NanoSleep(seconds * NANOSECONDS_PER_SECOND);
}
void Thread::MiliSleep(uint64_t miliseconds)
void Thread::NanoSleep(uint64_t nanoseconds)
{
- timespec requestedTime =
- {
+ timespec requestedTime = {
static_cast<time_t>(
nanoseconds / NANOSECONDS_PER_SECOND),
timespec remainingTime;
- for (;;)
- {
- if (nanosleep(&requestedTime, &remainingTime) == 0)
+ for (;;) {
+ if (nanosleep(&requestedTime, &remainingTime) == 0) {
break;
+ }
int error = errno;
Assert(error == EINTR);
#include <errno.h>
#include <errno.h>
-namespace DPL
-{
+namespace DPL {
WaitableEvent::WaitableEvent()
{
- if (pipe(m_pipe) == -1)
+ if (pipe(m_pipe) == -1) {
Throw(Exception::CreateFailed);
+ }
- if (fcntl(m_pipe[0], F_SETFL, O_NONBLOCK | fcntl(m_pipe[0], F_GETFL)) == -1)
+ if (fcntl(m_pipe[0], F_SETFL, O_NONBLOCK |
+ fcntl(m_pipe[0], F_GETFL)) == -1)
+ {
Throw(Exception::CreateFailed);
+ }
}
WaitableEvent::~WaitableEvent()
{
- if (TEMP_FAILURE_RETRY(close(m_pipe[0])) == -1)
+ if (TEMP_FAILURE_RETRY(close(m_pipe[0])) == -1) {
Throw(Exception::DestroyFailed);
+ }
- if (TEMP_FAILURE_RETRY(close(m_pipe[1])) == -1)
+ if (TEMP_FAILURE_RETRY(close(m_pipe[1])) == -1) {
Throw(Exception::DestroyFailed);
+ }
}
WaitableHandle WaitableEvent::GetHandle() const
{
char data = 0;
- if (TEMP_FAILURE_RETRY(write(m_pipe[1], &data, 1)) != 1)
+ if (TEMP_FAILURE_RETRY(write(m_pipe[1], &data, 1)) != 1) {
Throw(Exception::SignalFailed);
+ }
}
void WaitableEvent::Reset() const
{
char data;
- if (TEMP_FAILURE_RETRY(read(m_pipe[0], &data, 1)) != 1)
+ if (TEMP_FAILURE_RETRY(read(m_pipe[0], &data, 1)) != 1) {
Throw(Exception::ResetFailed);
+ }
}
} // namespace DPL
#include <errno.h>
#include <dpl/assert.h>
-namespace DPL
-{
+namespace DPL {
namespace // anonymous
{
void CheckWaitableHandle(WaitableHandle handle)
// Try to get descriptor flags
int result = fcntl(handle, F_GETFL);
- if (result == -1 && errno == EBADF)
+ if (result == -1 && errno == EBADF) {
Assert(0 && "CheckWaitableHandle: Invalid WaitableHandle! (EBADF)");
+ }
Assert(result != -1 && "CheckWaitableHandle: Invalid WaitableHandle!");
#endif // DPL_ENABLE_WAITABLE_HANDLE_BADF_CHECK
}
} // namespace anonymous
-WaitableHandleIndexList WaitForSingleHandle(WaitableHandle handle, unsigned long miliseconds)
+WaitableHandleIndexList WaitForSingleHandle(WaitableHandle handle,
+ unsigned long miliseconds)
{
WaitableHandleList waitHandles;
waitHandles.push_back(handle);
return WaitForMultipleHandles(waitHandles, miliseconds);
}
-WaitableHandleIndexList WaitForSingleHandle(WaitableHandle handle, WaitMode::Type mode, unsigned long miliseconds)
+WaitableHandleIndexList WaitForSingleHandle(WaitableHandle handle,
+ WaitMode::Type mode,
+ unsigned long miliseconds)
{
WaitableHandleListEx waitHandles;
waitHandles.push_back(std::make_pair(handle, mode));
return WaitForMultipleHandles(waitHandles, miliseconds);
}
-WaitableHandleIndexList WaitForMultipleHandles(const WaitableHandleList &waitableHandleList, unsigned long miliseconds)
+WaitableHandleIndexList WaitForMultipleHandles(
+ const WaitableHandleList &waitableHandleList,
+ unsigned long miliseconds)
{
WaitableHandleListEx handleList;
return WaitForMultipleHandles(handleList, miliseconds);
}
-WaitableHandleIndexList WaitForMultipleHandles(const WaitableHandleListEx &waitableHandleListEx, unsigned long miliseconds)
+WaitableHandleIndexList WaitForMultipleHandles(
+ const WaitableHandleListEx &waitableHandleListEx,
+ unsigned long miliseconds)
{
fd_set readFds, writeFds, errorFds;
FD_ZERO(&errorFds);
// Add read wait handles
- for (WaitableHandleListEx::const_iterator iterator = waitableHandleListEx.begin();
+ for (WaitableHandleListEx::const_iterator iterator =
+ waitableHandleListEx.begin();
iterator != waitableHandleListEx.end();
++iterator)
{
- if (iterator->first > maxFd)
+ if (iterator->first > maxFd) {
maxFd = iterator->first;
+ }
CheckWaitableHandle(iterator->first);
// Handle errors along with read and write events
FD_SET(iterator->first, &errorFds);
- if (iterator->second == WaitMode::Read)
- {
+ if (iterator->second == WaitMode::Read) {
FD_SET(iterator->first, &readFds);
- }
- else if (iterator->second == WaitMode::Write)
- {
+ } else if (iterator->second == WaitMode::Write) {
FD_SET(iterator->first, &writeFds);
}
}
effectiveTimeout = &timeout;
}
- if (TEMP_FAILURE_RETRY(select(maxFd + 1, &readFds, &writeFds, &errorFds, effectiveTimeout)) == -1)
+ if (TEMP_FAILURE_RETRY(select(maxFd + 1, &readFds, &writeFds, &errorFds,
+ effectiveTimeout)) == -1)
+ {
Throw(WaitFailed);
+ }
// Check results
WaitableHandleIndexList indexes;
size_t index = 0;
- for (WaitableHandleListEx::const_iterator iterator = waitableHandleListEx.begin();
+ for (WaitableHandleListEx::const_iterator iterator =
+ waitableHandleListEx.begin();
iterator != waitableHandleListEx.end();
++iterator)
{
// Always return errors, no matter what type of listening is set
if (FD_ISSET(iterator->first, &errorFds)) {
indexes.push_back(index);
- }
- else if (iterator->second == WaitMode::Read)
- {
- if (FD_ISSET(iterator->first, &readFds))
+ } else if (iterator->second == WaitMode::Read) {
+ if (FD_ISSET(iterator->first, &readFds)) {
indexes.push_back(index);
- }
- else if (iterator->second == WaitMode::Write)
- {
- if (FD_ISSET(iterator->first, &writeFds))
+ }
+ } else if (iterator->second == WaitMode::Write) {
+ if (FD_ISSET(iterator->first, &writeFds)) {
indexes.push_back(index);
+ }
}
++index;
}
* @file waitable_handle_watch_support.cpp
* @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
* @version 1.0
- * @brief This file is the implementation file of waitable handle watch support
+ * @brief This file is the implementation file of waitable handle watch
+ * support
*/
#include <stddef.h>
#include <dpl/waitable_handle_watch_support.h>
#include <algorithm>
#include <dpl/assert.h>
-namespace DPL
-{
+namespace DPL {
WaitableHandleWatchSupport::WaitableHandleWatchSupport()
-{
-}
+{}
WaitableHandleWatchSupport::~WaitableHandleWatchSupport()
{
// Developer assertions
- if (!m_watchersMap.empty())
- {
+ if (!m_watchersMap.empty()) {
LogWarning("### Leaked watchers map dump ###");
- for (WaitableHandleWatchersMap::const_iterator iterator = m_watchersMap.begin();
+ for (WaitableHandleWatchersMap::const_iterator iterator =
+ m_watchersMap.begin();
iterator != m_watchersMap.end();
++iterator)
{
LogWarning("### Waitable handle: " << iterator->first);
- LogWarning("### Read listeners: " << iterator->second.readListenersCount);
- LogWarning("### Write listeners: " << iterator->second.writeListenersCount);
+ LogWarning(
+ "### Read listeners: " <<
+ iterator->second.readListenersCount);
+ LogWarning(
+ "### Write listeners: " <<
+ iterator->second.writeListenersCount);
- for (WaitableHandleListenerList::const_iterator listenersIterator = iterator->second.listeners.begin();
+ for (WaitableHandleListenerList::const_iterator listenersIterator =
+ iterator->second.listeners.begin();
listenersIterator != iterator->second.listeners.end();
++listenersIterator)
{
- LogWarning("### Mode: " << listenersIterator->mode << ". Listener: 0x" << std::hex << listenersIterator->listener);
+ LogWarning(
+ "### Mode: " << listenersIterator->mode <<
+ ". Listener: 0x" << std::hex << listenersIterator->listener);
}
}
}
WaitableHandleListEx handleList;
- for (WaitableHandleWatchersMap::const_iterator iterator = m_watchersMap.begin();
+ for (WaitableHandleWatchersMap::const_iterator iterator =
+ m_watchersMap.begin();
iterator != m_watchersMap.end();
++iterator)
{
// Register waitable event id for wait
// Check if there are any read listeners and write listeners
// and register for both if applicable
- if (iterator->second.readListenersCount > 0)
- handleList.push_back(std::make_pair(iterator->first, WaitMode::Read));
+ if (iterator->second.readListenersCount > 0) {
+ handleList.push_back(std::make_pair(iterator->first,
+ WaitMode::Read));
+ }
- if (iterator->second.writeListenersCount > 0)
- handleList.push_back(std::make_pair(iterator->first, WaitMode::Write));
+ if (iterator->second.writeListenersCount > 0) {
+ handleList.push_back(std::make_pair(iterator->first,
+ WaitMode::Write));
+ }
}
return handleList;
m_watchersInvokerCommit.Signal();
}
-void WaitableHandleWatchSupport::HandleWatcher(WaitableHandle waitableHandle, WaitMode::Type mode)
+void WaitableHandleWatchSupport::HandleWatcher(WaitableHandle waitableHandle,
+ WaitMode::Type mode)
{
//
// Waitable event occurred
// Now call all listeners for that waitable event. It is possible
// that some of listeners early disappeared. This is not a problem.
- // Warning: Listeners and/or watcher may also disappear during dispatching handlers!
+ // Warning: Listeners and/or watcher may also disappear during dispatching
+ // handlers!
//
LogPedantic("Waitable event occurred");
{
RecursiveMutex::ScopedLock lock(&m_watchersMutex);
- // Notice: We must carefully call watchers here as they may disappear (zero listeners) or be created during each of handler call
- // All removed listeners are handled correctly. Adding additional listener to the same waitable handle
+ // Notice: We must carefully call watchers here as they may disappear
+ // (zero listeners) or be created during each of handler call
+ // All removed listeners are handled correctly. Adding
+ // additional listener to the same waitable handle
// during handler dispatch sequence is _not_ supported.
WaitableHandleWatchersMap trackedWatchers = m_watchersMap;
- for (WaitableHandleWatchersMap::const_iterator trackedWatchersIterator = trackedWatchers.begin();
+ for (WaitableHandleWatchersMap::const_iterator trackedWatchersIterator
+ = trackedWatchers.begin();
trackedWatchersIterator != trackedWatchers.end();
++trackedWatchersIterator)
{
// Check if this watcher still exists
// If not, go to next tracked watcher
- if (m_watchersMap.find(trackedWatchersIterator->first) == m_watchersMap.end())
+ if (m_watchersMap.find(trackedWatchersIterator->first) ==
+ m_watchersMap.end())
{
LogPedantic("Watcher disappeared during watcher handler");
continue;
}
// Is this is a waitable handle that we are searching for ?
- if (waitableHandle != trackedWatchersIterator->first)
+ if (waitableHandle != trackedWatchersIterator->first) {
continue;
+ }
// Track watcher listeners list
- WaitableHandleListenerList trackedListeners = trackedWatchersIterator->second.listeners;
+ WaitableHandleListenerList trackedListeners =
+ trackedWatchersIterator->second.listeners;
- LogPedantic("Calling waitable event listeners (" << trackedListeners.size() << ")...");
+ LogPedantic(
+ "Calling waitable event listeners (" <<
+ trackedListeners.size() << ")...");
+
+ // Notice: We must carefully call listeners here as they may
+ // disappear or be created during each of handler call
+ // All removed listeners are handled correctly. Adding
+ // additional listener to the same waitable handle
+ // during handler dispatch sequence is should be also
+ // handled, as an extremly case.
- // Notice: We must carefully call listeners here as they may disappear or be created during each of handler call
- // All removed listeners are handled correctly. Adding additional listener to the same waitable handle
- // during handler dispatch sequence is should be also handled, as an extremly case.
-
// Call all waitable event listeners who listen for that event
- for (WaitableHandleListenerList::const_iterator trackedListenersIterator = trackedListeners.begin();
+ for (WaitableHandleListenerList::const_iterator
+ trackedListenersIterator = trackedListeners.begin();
trackedListenersIterator != trackedListeners.end();
++trackedListenersIterator)
{
// Check if this watcher still exists
- // If not, there cannot be another one. Must exit now (after break, we actually exit)
- if (m_watchersMap.find(trackedWatchersIterator->first) == m_watchersMap.end())
+ // If not, there cannot be another one. Must exit now (after
+ // break, we actually exit)
+ if (m_watchersMap.find(trackedWatchersIterator->first) ==
+ m_watchersMap.end())
{
LogPedantic("Watcher disappeared during watcher handler");
break;
// If not, go to next tracked watcher listener
bool listenerStillExists = false;
- for (WaitableHandleListenerList::const_iterator searchListenerIterator = trackedWatchersIterator->second.listeners.begin();
- searchListenerIterator != trackedWatchersIterator->second.listeners.end();
+ for (WaitableHandleListenerList::const_iterator
+ searchListenerIterator =
+ trackedWatchersIterator->second.listeners.begin();
+ searchListenerIterator !=
+ trackedWatchersIterator->second.listeners.end();
++searchListenerIterator)
{
- if (searchListenerIterator->listener == trackedListenersIterator->listener &&
- searchListenerIterator->mode == trackedListenersIterator->mode)
+ if (searchListenerIterator->listener ==
+ trackedListenersIterator->listener &&
+ searchListenerIterator->mode ==
+ trackedListenersIterator->mode)
{
listenerStillExists = true;
break;
}
}
- if (!listenerStillExists)
- {
- LogPedantic("Watcher listener disappeared during watcher handler");
+ if (!listenerStillExists) {
+ LogPedantic(
+ "Watcher listener disappeared during watcher handler");
break;
}
// Is this is a listener mode that we are searching for ?
- if (mode != trackedListenersIterator->mode)
+ if (mode != trackedListenersIterator->mode) {
continue;
+ }
// Call waitable event watch listener
LogPedantic("Before tracker listener call...");
- trackedListenersIterator->listener->OnWaitableHandleEvent(trackedWatchersIterator->first, trackedListenersIterator->mode);
+ trackedListenersIterator->listener->OnWaitableHandleEvent(
+ trackedWatchersIterator->first,
+ trackedListenersIterator->mode);
LogPedantic("After tracker listener call...");
}
}
}
-void WaitableHandleWatchSupport::AddWaitableHandleWatch(WaitableHandleListener* listener, WaitableHandle waitableHandle, WaitMode::Type mode)
+void WaitableHandleWatchSupport::AddWaitableHandleWatch(
+ WaitableHandleListener* listener,
+ WaitableHandle waitableHandle,
+ WaitMode::Type mode)
{
// Enter waitable event list critical section
RecursiveMutex::ScopedLock lock(&m_watchersMutex);
// Find proper list to register into
- WaitableHandleWatchersMap::iterator mapIterator = m_watchersMap.find(waitableHandle);
-
- if (mapIterator != m_watchersMap.end())
- {
- // Assert if there is no such listener already that is listening in this mode
- for (WaitableHandleListenerList::iterator listenersIterator = mapIterator->second.listeners.begin();
+ WaitableHandleWatchersMap::iterator mapIterator = m_watchersMap.find(
+ waitableHandle);
+
+ if (mapIterator != m_watchersMap.end()) {
+ // Assert if there is no such listener already that is listening in this
+ // mode
+ for (WaitableHandleListenerList::iterator listenersIterator =
+ mapIterator->second.listeners.begin();
listenersIterator != mapIterator->second.listeners.end();
++listenersIterator)
{
// Must not insert same listener-mode pair
- Assert(listenersIterator->listener != listener || listenersIterator->mode != mode);
+ Assert(
+ listenersIterator->listener != listener ||
+ listenersIterator->mode != mode);
}
}
LogPedantic("Adding waitable handle watch: " << waitableHandle);
// Push new waitable event watch
- if (mapIterator != m_watchersMap.end())
- mapIterator->second.listeners.push_back(WaitableHandleWatcher(listener, mode));
- else
- m_watchersMap[waitableHandle].listeners.push_back(WaitableHandleWatcher(listener, mode));
+ if (mapIterator != m_watchersMap.end()) {
+ mapIterator->second.listeners.push_back(WaitableHandleWatcher(listener,
+ mode));
+ } else {
+ m_watchersMap[waitableHandle].listeners.push_back(WaitableHandleWatcher(
+ listener, mode));
+ }
// Update counters
- switch (mode)
- {
- case WaitMode::Read:
- m_watchersMap[waitableHandle].readListenersCount++;
- break;
+ switch (mode) {
+ case WaitMode::Read:
+ m_watchersMap[waitableHandle].readListenersCount++;
+ break;
- case WaitMode::Write:
- m_watchersMap[waitableHandle].writeListenersCount++;
- break;
+ case WaitMode::Write:
+ m_watchersMap[waitableHandle].writeListenersCount++;
+ break;
- default:
- Assert(0);
+ default:
+ Assert(0);
}
// Trigger waitable event invoker to commit changes
LogPedantic("Waitable event watch added and invoker signaled");
}
-void WaitableHandleWatchSupport::RemoveWaitableHandleWatch(WaitableHandleListener *listener, WaitableHandle waitableHandle, WaitMode::Type mode)
+void WaitableHandleWatchSupport::RemoveWaitableHandleWatch(
+ WaitableHandleListener *listener,
+ WaitableHandle waitableHandle,
+ WaitMode::Type mode)
{
// Enter waitable event list critical section
RecursiveMutex::ScopedLock lock(&m_watchersMutex);
// Find proper list with listener
- WaitableHandleWatchersMap::iterator mapIterator = m_watchersMap.find(waitableHandle);
+ WaitableHandleWatchersMap::iterator mapIterator = m_watchersMap.find(
+ waitableHandle);
Assert(mapIterator != m_watchersMap.end());
// Assert if there is such listener and mode
- WaitableHandleListenerList::iterator listIterator = mapIterator->second.listeners.end();
+ WaitableHandleListenerList::iterator listIterator =
+ mapIterator->second.listeners.end();
- for (WaitableHandleListenerList::iterator listenersIterator = mapIterator->second.listeners.begin();
+ for (WaitableHandleListenerList::iterator listenersIterator =
+ mapIterator->second.listeners.begin();
listenersIterator != mapIterator->second.listeners.end();
++listenersIterator)
{
// Check same pair listener-mode
- if (listenersIterator->listener == listener && listenersIterator->mode == mode)
+ if (listenersIterator->listener == listener &&
+ listenersIterator->mode == mode)
{
listIterator = listenersIterator;
break;
Assert(listIterator != mapIterator->second.listeners.end());
LogPedantic("Removing waitable handle watch: " << waitableHandle);
-
+
// Remove waitable event watch
mapIterator->second.listeners.erase(listIterator);
// Update counters
- switch (mode)
- {
- case WaitMode::Read:
- mapIterator->second.readListenersCount--;
- break;
+ switch (mode) {
+ case WaitMode::Read:
+ mapIterator->second.readListenersCount--;
+ break;
- case WaitMode::Write:
- mapIterator->second.writeListenersCount--;
- break;
+ case WaitMode::Write:
+ mapIterator->second.writeListenersCount--;
+ break;
- default:
- Assert(0);
+ default:
+ Assert(0);
}
// If list is empty, remove it too
- if (mapIterator->second.listeners.empty())
+ if (mapIterator->second.listeners.empty()) {
m_watchersMap.erase(mapIterator);
+ }
// Trigger waitable event invoker to commit changes
CommitInvoker();
void WaitableHandleWatchSupport::CommitInvoker()
{
// Check calling context and execute invoker
- if (Thread::GetCurrentThread() == GetInvokerThread())
- {
+ if (Thread::GetCurrentThread() == GetInvokerThread()) {
LogPedantic("Calling direct invoker");
// Direct invoker call
HandleDirectInvoker();
- }
- else
- {
+ } else {
LogPedantic("Calling indirect invoker");
// Indirect invoker call
{
// In threaded context, return thread waitable handle watch implementation
// In main loop, return main waitable handle watch implementation
- if (Thread::GetCurrentThread() != NULL)
+ if (Thread::GetCurrentThread() != NULL) {
return Thread::GetCurrentThread();
- else
+ } else {
return &MainSingleton::Instance();
+ }
}
} // namespace DPL
#include <minizip/framework_minizip.h>
#include <new>
-namespace DPL
-{
+namespace DPL {
namespace // anonymous
{
const size_t EXTRACT_BUFFER_SIZE = 4096;
class ScopedUnzClose
{
-private:
+ private:
unzFile m_file;
-public:
- ScopedUnzClose(unzFile file)
- : m_file(file)
- {
- }
+ public:
+ ScopedUnzClose(unzFile file) :
+ m_file(file)
+ {}
~ScopedUnzClose()
{
- if (!m_file)
+ if (!m_file) {
return;
+ }
- if (unzClose(m_file) != UNZ_OK)
+ if (unzClose(m_file) != UNZ_OK) {
LogPedantic("Failed to close zip input file");
+ }
}
unzFile Release()
*
* About generalization:
* To achieve the same results on abstract input device, there must be
- * provided a mechanism to read data from random address without synchronization.
+ * provided a mechanism to read data from random address without
+ * synchronization.
* In other words: stateless. As described above, stateless property can be
* achieved via memory mapping.
*/
class Device
{
-private:
+ private:
int m_handle;
off64_t m_size; // file mapping size
unsigned char *m_address; // mapping base address
off64_t offset;
Device *device;
- File(Device *d)
- : offset(0),
- device(d)
- {
- }
+ File(Device *d) :
+ offset(0),
+ device(d)
+ {}
};
-public:
+ public:
Device(const std::string &fileName)
{
LogPedantic("Creating file mapping");
// Open device and map it to user space
int file = TEMP_FAILURE_RETRY(open(fileName.c_str(), O_RDONLY));
- if (file == -1)
- {
+ if (file == -1) {
int error = errno;
ThrowMsg(ZipInput::Exception::OpenFailed,
"Failed to open file. errno = " << error);
// Calculate file size
off64_t size = lseek64(file, 0, SEEK_END);
- if (size == static_cast<off64_t>(-1))
- {
+ if (size == static_cast<off64_t>(-1)) {
int error = errno;
ThrowMsg(ZipInput::Exception::OpenFailed,
"Failed to seek file. errno = " << error);
void *address = mmap(0, static_cast<size_t>(size),
PROT_READ, MAP_SHARED, file, 0);
- if (address == MAP_FAILED)
- {
+ if (address == MAP_FAILED) {
int error = errno;
ThrowMsg(ZipInput::Exception::OpenFailed,
"Failed to map file. errno = " << error);
LogPedantic("Created file mapping: " << fileName <<
" of size: " << m_size <<
- " at address: " << std::hex << static_cast<void *>(m_address));
+ " at address: " << std::hex <<
+ static_cast<void *>(m_address));
}
~Device()
{
// Close mapping
- if (munmap(m_address, static_cast<size_t>(m_size)) == -1)
- {
+ if (munmap(m_address, static_cast<size_t>(m_size)) == -1) {
int error = errno;
LogPedantic("Failed to munmap file. errno = " << error);
}
// Close file descriptor
- if (close(m_handle) == -1)
- {
+ if (close(m_handle) == -1) {
int error = errno;
LogPedantic("Failed to close file. errno = " << error);
}
File *deviceFile = static_cast<File *>(pstream);
// Check if offset is out of bounds
- if (deviceFile->offset >= device->m_size)
- {
+ if (deviceFile->offset >= device->m_size) {
LogPedantic("Device: read offset out of bounds");
return -1;
}
off64_t bytesLeft = device->m_size -
- deviceFile->offset;
+ deviceFile->offset;
off64_t bytesToRead;
// Calculate bytes to read
- if (static_cast<off64_t>(size) > bytesLeft)
+ if (static_cast<off64_t>(size) > bytesLeft) {
bytesToRead = bytesLeft;
- else
+ } else {
bytesToRead = static_cast<off64_t>(size);
+ }
// Do copy
memcpy(buf,
Device *device = static_cast<Device *>(opaque);
File *deviceFile = static_cast<File *>(stream);
- switch (origin)
- {
- case ZLIB_FILEFUNC_SEEK_SET:
- deviceFile->offset = static_cast<off64_t>(offset);
+ switch (origin) {
+ case ZLIB_FILEFUNC_SEEK_SET:
+ deviceFile->offset = static_cast<off64_t>(offset);
- break;
+ break;
- case ZLIB_FILEFUNC_SEEK_CUR:
- deviceFile->offset += static_cast<off64_t>(offset);
+ case ZLIB_FILEFUNC_SEEK_CUR:
+ deviceFile->offset += static_cast<off64_t>(offset);
- break;
+ break;
- case ZLIB_FILEFUNC_SEEK_END:
- deviceFile->offset =
- device->m_size -
- static_cast<off64_t>(offset);
+ case ZLIB_FILEFUNC_SEEK_END:
+ deviceFile->offset =
+ device->m_size -
+ static_cast<off64_t>(offset);
- break;
+ break;
- default:
- return -1;
+ default:
+ return -1;
}
return 0;
}
};
-ZipInput::ZipInput(const std::string &fileName)
- : m_device(NULL),
- m_numberOfFiles(0),
- m_globalComment(),
- m_fileInfos()
+ZipInput::ZipInput(const std::string &fileName) :
+ m_device(NULL),
+ m_numberOfFiles(0),
+ m_globalComment(),
+ m_fileInfos()
{
LogPedantic("Zip input file: " << fileName);
LogPedantic("Opening zip file");
unzFile file = unzOpen2_64(NULL, &interface);
- if (file == NULL)
- {
+ if (file == NULL) {
LogPedantic("Failed to open zip file");
- // Some errror occured
+ // Some errror occured
ThrowMsg(Exception::OpenFailed,
"Failed to open zip file: " << fileName);
}
ZipInput::~ZipInput()
{
// Close zip
- if (unzClose(static_cast<unzFile>(m_masterFile)) != UNZ_OK)
+ if (unzClose(static_cast<unzFile>(m_masterFile)) != UNZ_OK) {
LogPedantic("Failed to close zip input file");
+ }
// Close device
delete m_device;
// Read infos
m_fileInfos.reserve(m_numberOfFiles);
- if (unzGoToFirstFile(static_cast<unzFile>(masterFile)) != UNZ_OK)
- {
+ if (unzGoToFirstFile(static_cast<unzFile>(masterFile)) != UNZ_OK) {
LogPedantic("Failed to go to first file");
ThrowMsg(Exception::SeekFileFailed, "Failed to seek first file");
}
- for (size_t i = 0; i < m_numberOfFiles; ++i)
- {
+ for (size_t i = 0; i < m_numberOfFiles; ++i) {
unz_file_pos_s filePos;
if (unzGetFilePos(static_cast<unzFile>(masterFile),
FileHandle(
static_cast<size_t>(filePos.pos_in_zip_directory),
static_cast<size_t>(filePos.num_of_file)
- ),
+ ),
std::string(fileName.Get()),
std::string(fileComment.Get()),
static_cast<off64_t>(fileInfo.compressed_size),
static_cast<off64_t>(fileInfo.uncompressed_size)
- )
- );
+ )
+ );
// If this is not the last file, go to next one
- if (i != m_numberOfFiles - 1)
- {
+ if (i != m_numberOfFiles - 1) {
if (unzGoToNextFile(
- static_cast<unzFile>(masterFile))!= UNZ_OK)
+ static_cast<unzFile>(masterFile)) != UNZ_OK)
{
LogPedantic("Failed to go to next file");
{
FOREACH(iterator, m_fileInfos)
{
- if (iterator->name == fileName)
- {
+ if (iterator->name == fileName) {
return new File(m_device, iterator->handle);
}
}
LogPedantic("Opening zip file");
unzFile file = unzOpen2_64(NULL, &interface);
- if (file == NULL)
- {
+ if (file == NULL) {
LogPedantic("Failed to open zip file");
- // Some errror occured
+ // Some errror occured
ThrowMsg(ZipInput::Exception::OpenFileFailed,
"Failed to open zip file");
}
ScopedUnzClose scopedUnzClose(file);
// Look up file handle
- unz64_file_pos filePos =
- {
+ unz64_file_pos filePos = {
static_cast<ZPOS64_T>(handle.first),
static_cast<ZPOS64_T>(handle.second)
};
- if (unzGoToFilePos64(file, &filePos) != UNZ_OK)
- {
+ if (unzGoToFilePos64(file, &filePos) != UNZ_OK) {
LogPedantic("Failed to seek to zip file");
- // Some errror occured
+ // Some errror occured
ThrowMsg(ZipInput::Exception::OpenFileFailed,
"Failed to open zip file");
}
// Open current file for reading
- if (unzOpenCurrentFile(file) != UNZ_OK)
- {
+ if (unzOpenCurrentFile(file) != UNZ_OK) {
LogPedantic("Failed to open current zip file");
- // Some errror occured
+ // Some errror occured
ThrowMsg(ZipInput::Exception::OpenFileFailed,
"Failed to open current zip file");
}
ZipInput::File::~File()
{
// Close current file for reading
- if (unzCloseCurrentFile(static_cast<unzFile>(m_file)) != UNZ_OK)
+ if (unzCloseCurrentFile(static_cast<unzFile>(m_file)) != UNZ_OK) {
LogPedantic("Failed to close current zip input file");
+ }
// Close zip file
- if (unzClose(static_cast<unzFile>(m_file)) != UNZ_OK)
+ if (unzClose(static_cast<unzFile>(m_file)) != UNZ_OK) {
LogPedantic("Failed to close zip input file");
+ }
}
DPL::BinaryQueueAutoPtr ZipInput::File::Read(size_t size)
{
// Do not even try to unzip if requested zero bytes
- if (size == 0)
+ if (size == 0) {
return DPL::BinaryQueueAutoPtr(new DPL::BinaryQueue());
+ }
// Calc data to read
size_t sizeToRead = size > EXTRACT_BUFFER_SIZE ?
- EXTRACT_BUFFER_SIZE :
- size;
+ EXTRACT_BUFFER_SIZE :
+ size;
// Extract zip file data (one-copy)
ScopedFree<void> rawBuffer(malloc(sizeToRead));
- if (!rawBuffer)
+ if (!rawBuffer) {
throw std::bad_alloc();
+ }
// Do unpack
int bytes = unzReadCurrentFile(static_cast<unzFile>(m_file),
sizeToRead);
// Internal unzipper error
- if (bytes < 0)
- {
+ if (bytes < 0) {
LogPedantic("Extract failed. Error: " << bytes);
ThrowMsg(ZipInput::Exception::ReadFileFailed,
namespace CustomHandlerDB {
namespace Interface {
-
namespace {
const char* CustomHandler_DB_DATABASE = "/opt/dbspace/.wrt_custom_handler.db";
DPL::DB::SqlConnection::Flag::Type CustomHandler_DB_FLAGS =
{
g_dbInterface.DetachFromThread();
}
-
} //namespace Interface
} //namespace CustomHandlerDB
using namespace DPL::DB::ORM::custom_handler;
namespace CustomHandlerDB {
-
namespace {
-
template <typename T>
void fillRow(T& row, const CustomHandler& handler, const DPL::String& pkgName)
{
row.Set_title(handler.title);
row.Set_user_allowed(handler.user_decision);
}
-
} // namespace
CustomHandlerDAO::CustomHandlerDAO(const DPL::String& pkgName) :
CustomHandlerDAOReadOnly(pkgName)
-{
-}
+{}
CustomHandlerDAO::~CustomHandlerDAO()
-{
-}
+{}
void CustomHandlerDAO::registerContentHandler(const CustomHandler& handler)
{
LogDebug("Registering content handler " << handler.target << " " <<
- handler.base_url);
+ handler.base_url);
Try {
if (handler.user_decision & Agreed) {
//need to disable all previous, agreed entries
CUSTOM_HANDLER_DB_SELECT(select, ContentHandlers);
select->Where(And(Equals<ContentHandlers::target>(handler.target),
- Or(Equals<ContentHandlers::user_allowed>(Agreed),
- Equals<ContentHandlers::user_allowed>(AgreedPermanently))
- ));
+ Or(Equals<ContentHandlers::user_allowed>(Agreed),
+ Equals<ContentHandlers::user_allowed>(
+ AgreedPermanently))
+ ));
ContentHandlers::Select::RowList rows = select->GetRowList();
if (rows.size() > 1) {
//more than one activ content handler - not good. Remove all.
//this should never happen
LogError("Database data incoherent.");
CUSTOM_HANDLER_DB_DELETE(deleteContent, ContentHandlers);
- deleteContent->Where(And(Equals<ContentHandlers::target>(handler.target),
- Or(Equals<ContentHandlers::user_allowed>(Agreed),
- Equals<ContentHandlers::user_allowed>(AgreedPermanently))));
+ deleteContent->Where(And(Equals<ContentHandlers::target>(
+ handler.target),
+ Or(Equals<ContentHandlers::
+ user_allowed>(Agreed),
+ Equals<ContentHandlers::
+ user_allowed>(
+ AgreedPermanently))));
deleteContent->Execute();
//all content handlers removed. New one can be inserted
} else if (!rows.empty()) {
//one active handler. Can be updaed
LogDebug("Activ content handler exist. Update");
CUSTOM_HANDLER_DB_UPDATE(update, ContentHandlers);
- update->Where(And(Equals<ContentHandlers::target>(handler.target),
- Or(Equals<ContentHandlers::user_allowed>(Agreed),
- Equals<ContentHandlers::user_allowed>(AgreedPermanently))
- ));
+ update->Where(And(Equals<ContentHandlers::target>(handler.
+ target),
+ Or(Equals<ContentHandlers::user_allowed>(
+ Agreed),
+ Equals<ContentHandlers::user_allowed>(
+ AgreedPermanently))
+ ));
ContentHandlers::Row rowToUpdate = rows.front();
if (handler.user_decision & DecisionSaved) {
LogDebug("Content handler exist. Update its state");
CUSTOM_HANDLER_DB_UPDATE(updateRow, ContentHandlers);
updateRow->Where(And(Equals<ContentHandlers::app_id>(m_pkgName),
- And(Equals<ContentHandlers::target>(handler.target),
- And(Equals<ContentHandlers::url>(handler.url),
- Equals<ContentHandlers::base_url>(handler.base_url)))));
+ And(Equals<ContentHandlers::target>(handler.
+ target),
+ And(Equals<ContentHandlers::url>(handler.
+ url),
+ Equals<ContentHandlers::base_url>(
+ handler.base_url)))));
updateRow->Values(row);
updateRow->Execute();
LogDebug("updated");
void CustomHandlerDAO::registerProtocolHandler(const CustomHandler& handler)
{
LogDebug("Registering protocol handler " << handler.target << " " <<
- handler.base_url);
+ handler.base_url);
Try {
-
if (handler.user_decision & Agreed) {
//need to disable all previous, agreed entries
CUSTOM_HANDLER_DB_SELECT(select, ProtocolHandlers);
select->Where(And(Equals<ProtocolHandlers::target>(handler.target),
- Or(Equals<ProtocolHandlers::user_allowed>(Agreed),
- Equals<ProtocolHandlers::user_allowed>(AgreedPermanently))
- ));
+ Or(Equals<ProtocolHandlers::user_allowed>(Agreed),
+ Equals<ProtocolHandlers::user_allowed>(
+ AgreedPermanently))
+ ));
ProtocolHandlers::Select::RowList rows = select->GetRowList();
if (rows.size() > 1) {
//more than one activ protocol handler - not good. Remove all.
//this should never happen
LogError("Database data incoherent.");
CUSTOM_HANDLER_DB_DELETE(deleteProtocol, ProtocolHandlers);
- deleteProtocol->Where(And(Equals<ProtocolHandlers::target>(handler.target),
- Or(Equals<ProtocolHandlers::user_allowed>(Agreed),
- Equals<ProtocolHandlers::user_allowed>(AgreedPermanently))));
+ deleteProtocol->Where(And(Equals<ProtocolHandlers::target>(
+ handler.target),
+ Or(Equals<ProtocolHandlers::
+ user_allowed>(Agreed),
+ Equals<ProtocolHandlers::
+ user_allowed>(
+ AgreedPermanently))));
deleteProtocol->Execute();
//all protocol handlers removed. New one can be inserted
} else if (!rows.empty()) {
//one active handler. Can be updaed
CUSTOM_HANDLER_DB_UPDATE(update, ProtocolHandlers);
- update->Where(And(Equals<ProtocolHandlers::target>(handler.target),
- Or(Equals<ProtocolHandlers::user_allowed>(Agreed),
- Equals<ProtocolHandlers::user_allowed>(AgreedPermanently))
- ));
+ update->Where(And(Equals<ProtocolHandlers::target>(handler.
+ target),
+ Or(Equals<ProtocolHandlers::user_allowed>(
+ Agreed),
+ Equals<ProtocolHandlers::user_allowed>(
+ AgreedPermanently))
+ ));
ProtocolHandlers::Row rowToUpdate = rows.front();
if (handler.user_decision & DecisionSaved) {
LogDebug("Inserting new protocol handler");
ProtocolHandlers::Row row;
fillRow(row, handler, m_pkgName);
- if (getProtocolHandler(handler.target, handler.url, handler.base_url)) {
+ if (getProtocolHandler(handler.target, handler.url,
+ handler.base_url))
+ {
LogDebug("Protocol handler exist. Update its state");
CUSTOM_HANDLER_DB_UPDATE(updateRow, ProtocolHandlers);
updateRow->Where(And(Equals<ProtocolHandlers::app_id>(m_pkgName),
- And(Equals<ProtocolHandlers::target>(handler.target),
- And(Equals<ProtocolHandlers::url>(handler.url),
- Equals<ProtocolHandlers::base_url>(handler.base_url)))));
+ And(Equals<ProtocolHandlers::target>(handler.
+ target),
+ And(Equals<ProtocolHandlers::url>(handler.
+ url),
+ Equals<ProtocolHandlers::base_url>(
+ handler.base_url)))));
updateRow->Values(row);
updateRow->Execute();
LogDebug("updated");
{
LogDebug("Removing content handler " << target << " " << url);
Try {
- CUSTOM_HANDLER_DB_DELETE(deleteFrom, ContentHandlers);
- deleteFrom->Where(And(Equals<ContentHandlers::app_id>(m_pkgName),
- And(Equals<ContentHandlers::target>(target),
- Equals<ContentHandlers::url>(url))));
- deleteFrom->Execute();
+ CUSTOM_HANDLER_DB_DELETE(deleteFrom, ContentHandlers);
+ deleteFrom->Where(And(Equals<ContentHandlers::app_id>(m_pkgName),
+ And(Equals<ContentHandlers::target>(target),
+ Equals<ContentHandlers::url>(url))));
+ deleteFrom->Execute();
}
Catch(DPL::DB::SqlConnection::Exception::Base) {
- ReThrowMsg(CustomHandlerDAO::Exception::DatabaseError,
- "Failed to remove content handler");
+ ReThrowMsg(CustomHandlerDAO::Exception::DatabaseError,
+ "Failed to remove content handler");
}
}
{
LogDebug("Removing protocol handler " << target << " " << url);
Try {
- CUSTOM_HANDLER_DB_DELETE(deleteFrom, ProtocolHandlers);
- deleteFrom->Where(And(Equals<ProtocolHandlers::app_id>(m_pkgName),
- And(Equals<ProtocolHandlers::target>(target),
- Equals<ProtocolHandlers::url>(url))));
- deleteFrom->Execute();
+ CUSTOM_HANDLER_DB_DELETE(deleteFrom, ProtocolHandlers);
+
deleteFrom->Where(And(Equals<ProtocolHandlers::app_id>(m_pkgName),
+
And(Equals<ProtocolHandlers::target>(target),
+
Equals<ProtocolHandlers::url>(url))));
+ deleteFrom->Execute();
}
Catch(DPL::DB::SqlConnection::Exception::Base) {
- ReThrowMsg(CustomHandlerDAO::Exception::DatabaseError,
- "Failed to remove content handler");
+ ReThrowMsg(CustomHandlerDAO::Exception::DatabaseError,
+ "Failed to remove content handler");
}
-
}
void CustomHandlerDAO::unregisterContentHandler(const DPL::String& target,
{
LogDebug("Removing content handler " << target << " " << url);
Try {
- CUSTOM_HANDLER_DB_DELETE(deleteFrom, ContentHandlers);
- deleteFrom->Where(And(Equals<ContentHandlers::app_id>(m_pkgName),
- And(Equals<ContentHandlers::target>(target),
- And(Equals<ContentHandlers::url>(url),
- Equals<ContentHandlers::base_url>(baseURL)))));
- deleteFrom->Execute();
+ CUSTOM_HANDLER_DB_DELETE(deleteFrom, ContentHandlers);
+ deleteFrom->Where(And(Equals<ContentHandlers::app_id>(m_pkgName),
+ And(Equals<ContentHandlers::target>(target),
+ And(Equals<ContentHandlers::url>(url),
+ Equals<ContentHandlers::base_url>(baseURL)))));
+ deleteFrom->Execute();
}
Catch(DPL::DB::SqlConnection::Exception::Base) {
- ReThrowMsg(CustomHandlerDAO::Exception::DatabaseError,
- "Failed to remove content handler");
+ ReThrowMsg(CustomHandlerDAO::Exception::DatabaseError,
+ "Failed to remove content handler");
}
}
{
LogDebug("Removing protocol handler " << target << " " << url);
Try {
- CUSTOM_HANDLER_DB_DELETE(deleteFrom, ProtocolHandlers);
- deleteFrom->Where(And(Equals<ProtocolHandlers::app_id>(m_pkgName),
- And(Equals<ProtocolHandlers::target>(target),
- And(Equals<ProtocolHandlers::url>(url),
- Equals<ProtocolHandlers::base_url>(baseURL)))));
- deleteFrom->Execute();
+ CUSTOM_HANDLER_DB_DELETE(deleteFrom, ProtocolHandlers);
+ deleteFrom->Where(And(Equals<ProtocolHandlers::app_id>(m_pkgName),
+ And(Equals<ProtocolHandlers::target>(target),
+ And(Equals<ProtocolHandlers::url>(url),
+ Equals<ProtocolHandlers::base_url>(
+ baseURL)))));
+ deleteFrom->Execute();
}
Catch(DPL::DB::SqlConnection::Exception::Base) {
- ReThrowMsg(CustomHandlerDAO::Exception::DatabaseError,
- "Failed to remove content handler");
+ ReThrowMsg(CustomHandlerDAO::Exception::DatabaseError,
+ "Failed to remove content handler");
}
-
}
void CustomHandlerDAO::removeWidgetProtocolHandlers()
CUSTOM_HANDLER_DB_DELETE(deleteProtocol, ProtocolHandlers);
deleteProtocol->Where(Equals<ProtocolHandlers::app_id>(m_pkgName));
deleteProtocol->Execute();
-
} Catch(DPL::DB::SqlConnection::Exception::Base) {
ReThrowMsg(CustomHandlerDAO::Exception::DatabaseError,
"Failed to remove widget protoc");
CUSTOM_HANDLER_DB_DELETE(deleteContent, ContentHandlers);
deleteContent->Where(Equals<ContentHandlers::app_id>(m_pkgName));
deleteContent->Execute();
-
} Catch(DPL::DB::SqlConnection::Exception::Base) {
ReThrowMsg(CustomHandlerDAO::Exception::DatabaseError,
"Failed to remove widget entries");
}
}
-
-
} // namespace CustomHandlerDB
using namespace DPL::DB::ORM::custom_handler;
namespace CustomHandlerDB {
-
namespace {
-
template <typename T>
CustomHandlerPtr getSingleHandler(std::list<T> row)
{
}
return handler;
}
-
} // namespace
-CustomHandlerDAOReadOnly::CustomHandlerDAOReadOnly(const DPL::String& pkgName) :
- m_pkgName(pkgName)
-{
-}
+CustomHandlerDAOReadOnly::CustomHandlerDAOReadOnly(const DPL::String& pkgName)
+ :
+ m_pkgName(pkgName)
+{}
CustomHandlerDAOReadOnly::~CustomHandlerDAOReadOnly()
-{
-}
+{}
CustomHandlerPtr CustomHandlerDAOReadOnly::getProtocolHandler(
- const DPL::String& protocol,
- const DPL::String& url)
+ const DPL::String& protocol,
+ const DPL::String& url)
{
LogDebug("Getting protocol handler");
- Try{
+ Try {
CUSTOM_HANDLER_DB_SELECT(select, ProtocolHandlers);
select->Where(And(Equals<ProtocolHandlers::app_id>(m_pkgName),
- And(Equals<ProtocolHandlers::target>(protocol),
- Equals<ProtocolHandlers::url>(url))));
+
And(Equals<ProtocolHandlers::target>(protocol),
+
Equals<ProtocolHandlers::url>(url))));
std::list<ProtocolHandlers::Row> list = select->GetRowList();
return getSingleHandler(list);
}
CustomHandlerPtr CustomHandlerDAOReadOnly::getContentHandler(
- const DPL::String& content,
- const DPL::String& url)
+ const DPL::String& content,
+ const DPL::String& url)
{
LogDebug("Getting content handler");
- Try{
+ Try {
CUSTOM_HANDLER_DB_SELECT(select, ContentHandlers);
select->Where(And(Equals<ContentHandlers::app_id>(m_pkgName),
- And(Equals<ContentHandlers::target>(content),
- Equals<ContentHandlers::url>(url))));
+ And(Equals<ContentHandlers::target>(content),
+ Equals<ContentHandlers::url>(url))));
std::list<ContentHandlers::Row> list = select->GetRowList();
return getSingleHandler(list);
}
CustomHandlerPtr CustomHandlerDAOReadOnly::getActivProtocolHandler(
- const DPL::String& protocol)
+ const DPL::String& protocol)
{
LogDebug("Getting active protocol handler");
- Try{
+ Try {
CUSTOM_HANDLER_DB_SELECT(select, ProtocolHandlers);
select->Where(And(Equals<ProtocolHandlers::app_id>(m_pkgName),
}
CustomHandlerPtr CustomHandlerDAOReadOnly::getProtocolHandler(
- const DPL::String& protocol,
- const DPL::String& url,
- const DPL::String& baseURL)
+ const DPL::String& protocol,
+ const DPL::String& url,
+ const DPL::String& baseURL)
{
LogDebug("Check if protocol is registered");
- Try{
+ Try {
CUSTOM_HANDLER_DB_SELECT(select, ProtocolHandlers);
select->Where(And(Equals<ProtocolHandlers::app_id>(m_pkgName),
And(Equals<ProtocolHandlers::target>(protocol),
And(Equals<ProtocolHandlers::url>(url),
Equals<ProtocolHandlers::base_url>(baseURL)
+ )
)
- )
- )
- );
+ )
+ );
std::list<ProtocolHandlers::Row> list = select->GetRowList();
return getSingleHandler(list);
}
}
-
CustomHandlerPtr CustomHandlerDAOReadOnly::getActivContentHandler(
- const DPL::String& content)
+ const DPL::String& content)
{
LogDebug("Getting active content handler");
- Try{
+ Try {
CUSTOM_HANDLER_DB_SELECT(select, ContentHandlers);
select->Where(And(Equals<ContentHandlers::app_id>(m_pkgName),
}
CustomHandlerPtr CustomHandlerDAOReadOnly::getContentHandler(
- const DPL::String& content,
- const DPL::String& url,
- const DPL::String& baseURL)
+ const DPL::String& content,
+ const DPL::String& url,
+ const DPL::String& baseURL)
{
LogDebug("Check if content is registered");
- Try{
+ Try {
CUSTOM_HANDLER_DB_SELECT(select, ContentHandlers);
select->Where(And(Equals<ContentHandlers::app_id>(m_pkgName),
- And(Equals<ContentHandlers::target>(content),
- And(Equals<ContentHandlers::url>(url),
- Equals<ContentHandlers::base_url>(baseURL)))));
+ And(Equals<ContentHandlers::target>(content),
+ And(Equals<ContentHandlers::url>(url),
+ Equals<ContentHandlers::base_url>(baseURL)))));
std::list<ContentHandlers::Row> list = select->GetRowList();
return getSingleHandler(list);
}
CustomHandlerPtr CustomHandlerDAOReadOnly::getAllowedProtocolHandler(
- const DPL::String& protocol)
+ const DPL::String& protocol)
{
LogDebug("Getting allowed protocol handler");
- Try{
+ Try {
CUSTOM_HANDLER_DB_SELECT(select, ProtocolHandlers);
select->Where(And(Equals<ProtocolHandlers::app_id>(m_pkgName),
- And(Equals<ProtocolHandlers::target>(protocol),
- Equals<ProtocolHandlers::user_allowed>(true))));
+
And(Equals<ProtocolHandlers::target>(protocol),
+
Equals<ProtocolHandlers::user_allowed>(true))));
std::list<ProtocolHandlers::Row> list = select->GetRowList();
return getSingleHandler(list);
}
CustomHandlerPtr CustomHandlerDAOReadOnly::getAllowedContentHandler(
- const DPL::String& protocol)
+ const DPL::String& protocol)
{
LogDebug("Getting allowed content handler");
- Try{
+ Try {
CUSTOM_HANDLER_DB_SELECT(select, ContentHandlers)
select->Where(And(Equals<ContentHandlers::app_id>(m_pkgName),
- And(Equals<ContentHandlers::target>(protocol),
- Equals<ContentHandlers::user_allowed>(true))));
+ And(Equals<ContentHandlers::target>(protocol),
+ Equals<ContentHandlers::user_allowed>(true))));
std::list<ContentHandlers::Row> list = select->GetRowList();
return getSingleHandler(list);
"Failed to get content handler");
}
}
-
} // namespace CustomHandlerDB
namespace CustomHandlerDB {
namespace Interface {
-
void attachDatabaseRO();
void attachDatabaseRW();
void detachDatabase();
extern DPL::Mutex g_dbQueriesMutex;
extern DPL::DB::ThreadDatabaseSupport g_dbInterface;
-
} // namespace Interface
} // namespace CustomHandlerDB
#define CUSTOM_HANDLER_DB_INTERNAL(tlsCommand, InternalType) \
- static DPL::ThreadLocalVariable<InternalType> *tlsCommand ## Ptr = NULL; \
+ static DPL::ThreadLocalVariable<InternalType> *tlsCommand##Ptr = NULL; \
{ \
DPL::Mutex::ScopedLock lock( \
- &CustomHandlerDB::Interface::g_dbQueriesMutex); \
- if (!tlsCommand ## Ptr) { \
+ &CustomHandlerDB::Interface::g_dbQueriesMutex); \
+ if (!tlsCommand##Ptr) { \
static DPL::ThreadLocalVariable<InternalType> tmp; \
- tlsCommand ## Ptr = &tmp; \
+ tlsCommand##Ptr = &tmp; \
} \
} \
- DPL::ThreadLocalVariable<InternalType> &tlsCommand = *tlsCommand ## Ptr; \
+ DPL::ThreadLocalVariable<InternalType> &tlsCommand = *tlsCommand##Ptr; \
if (tlsCommand.IsNull()) \
{ \
tlsCommand = InternalType(&CustomHandlerDB::Interface::g_dbInterface); \
}
#define CUSTOM_HANDLER_DB_SELECT(name, type) \
- CUSTOM_HANDLER_DB_INTERNAL(name, type::Select)
+ CUSTOM_HANDLER_DB_INTERNAL(name, type::Select)
#define CUSTOM_HANDLER_DB_INSERT(name, type) \
- CUSTOM_HANDLER_DB_INTERNAL(name, type::Insert)
+ CUSTOM_HANDLER_DB_INTERNAL(name, type::Insert)
#define CUSTOM_HANDLER_DB_UPDATE(name, type) \
- CUSTOM_HANDLER_DB_INTERNAL(name, type::Update)
+ CUSTOM_HANDLER_DB_INTERNAL(name, type::Update)
#define CUSTOM_HANDLER_DB_DELETE(name, type) \
- CUSTOM_HANDLER_DB_INTERNAL(name, type::Delete)
+ CUSTOM_HANDLER_DB_INTERNAL(name, type::Delete)
#endif /* _CUSTOM_HANDLER_DATABASE_H_ */
#include <dpl/string.h>
namespace CustomHandlerDB {
-
/**
* @brief Custom Handler struct
*
//but want to ask in next occurence
Declined = 0x02, //user declined to use protocol,
//but want to ask in next occurence
- //in fact it is used when user wants to cover saved agreed
+ //in fact it is used when user wants to cover saved
+ // agreed
//decision by agreeing to another one without save.
DecisionSaved = 0x04, //user dont want to ask again
AgreedPermanently = Agreed | DecisionSaved,
typedef std::shared_ptr<CustomHandler> CustomHandlerPtr;
typedef std::list <CustomHandlerPtr> CustomHandlersList;
-
} // namespace CustomHandlerDB
#endif /* SRC_MODULES_CUSTOM_HANDLERS_DAO_COMMON_DAO_TYPES_H_ */
#include "common_dao_types.h"
namespace CustomHandlerDB {
-
class CustomHandlerDAOReadOnly
{
public:
const DPL::String& baseURL);
/**
- * Returns protocol handler that is agreed or agreed and saved and match tizenID
+ * Returns protocol handler that is agreed or agreed and saved and match
+ * tizenID
*/
CustomHandlerPtr getActivProtocolHandler(const DPL::String& protocol);
-
-
/**
* Returns content handler
*/
const DPL::String& baseURL);
/**
- * Returns content handler that is agreed or agreed and saved and match tizenID
+ * Returns content handler that is agreed or agreed and saved and match
+ * tizenID
*/
CustomHandlerPtr getActivContentHandler(const DPL::String& content);
protected:
DPL::String m_pkgName;
};
-
} // namespace CustomHandlerDB
#endif // _CUSTOM_HANDLER_DAO_READ_ONLY_H_
#include <wrt-commons/custom-handler-dao-ro/custom_handler_dao_read_only.h>
namespace CustomHandlerDB {
-
class CustomHandlerDAO : public CustomHandlerDAOReadOnly
{
public:
void removeWidgetProtocolHandlers();
void removeWidgetContentHandlers();
};
-
} // namespace CustomHandlerDB
#endif // _CUSTOM_HANDLER_DAO_H_
* @file naive_synchronization_object.h
* @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
* @version 1.0
- * @brief This file is the implementation file of SQL naive synchronization object
+ * @brief This file is the implementation file of SQL naive
+ * synchronization object
*/
#ifndef DPL_NAIVE_SYNCHRONIZATION_OBJECT_H
#define DPL_NAIVE_SYNCHRONIZATION_OBJECT_H
#include <dpl/db/sql_connection.h>
-namespace DPL
-{
-namespace DB
-{
-
+namespace DPL {
+namespace DB {
/**
* Naive synchronization object used to synchronize SQL connection
* to the same database across different threads and processes
*/
-class NaiveSynchronizationObject
- : public SqlConnection::SynchronizationObject
+class NaiveSynchronizationObject :
+ public SqlConnection::SynchronizationObject
{
-public:
+ public:
// [SqlConnection::SynchronizationObject]
virtual void Synchronize();
virtual void NotifyAll();
};
-
} // namespace DB
} // namespace DPL
typedef std::shared_ptr<Expression> ExpressionPtr;
+namespace OrderingUtils {
+
+template<typename CompoundType> inline std::string OrderByInternal()
+{
+ std::string order = OrderByInternal<typename CompoundType::Tail>();
+ if(!order.empty()) return CompoundType::Head::GetString() + ", " + order;
+ else return CompoundType::Head::GetString();
+}
+
+template<> inline std::string OrderByInternal<TypeListGuard>()
+{
+ return std::string();
+}
+
+}
+
+template<typename ColumnType>
+class __attribute__ ((visibility("hidden"))) OrderingExpression {
+protected:
+ static std::string GetSchemaAndName()
+ {
+ std::string statement;
+ statement += ColumnType::GetTableName();
+ statement += ".";
+ statement += ColumnType::GetColumnName();
+ statement += " ";
+ return statement;
+ }
+public:
+ virtual ~OrderingExpression() {}
+};
+
template<const char* Operator, typename LeftExpression, typename RightExpression>
class __attribute__ ((visibility("hidden"))) BinaryExpression : public Expression {
protected:
ORM_DEFINE_COMPARE_EXPRESSION(Equals, Equal)
ORM_DEFINE_COMPARE_EXPRESSION(Is, Is)
+#define ORM_DEFINE_ORDERING_EXPRESSION(name, value) \
+ template<typename ColumnType> \
+ class __attribute__ ((visibility("hidden"))) name \
+ : OrderingExpression<ColumnType> { \
+ public: \
+ static std::string GetString() \
+ { \
+ std::string statement = OrderingExpression<ColumnType>::GetSchemaAndName(); \
+ statement += value; \
+ return statement; \
+ } \
+ };
+
+ORM_DEFINE_ORDERING_EXPRESSION(OrderingAscending, "ASC")
+ORM_DEFINE_ORDERING_EXPRESSION(OrderingDescending, "DESC")
+
template<typename ColumnData1, typename ColumnData2>
class __attribute__ ((visibility("hidden"))) CompareBinaryColumn {
private:
m_distinctResults = true;
}
- void OrderBy(const std::string& orderBy)
+ template<typename CompoundType>
+ void OrderBy(const CompoundType&)
+ {
+ m_orderBy = OrderingUtils::OrderByInternal<typename CompoundType::Type>();
+ }
+
+ void OrderBy(const std::string & orderBy) //backward compatibility
{
m_orderBy = orderBy;
}
+ void OrderBy(const char * orderBy) //backward compatibility
+ {
+ m_orderBy = std::string(orderBy);
+ }
+
template<typename ColumnList, typename Expression>
void Join(const Expression& expression) {
std::string usedTableNames = TableDefinition::GetName();
#ifndef DPL_ORM_INTERFACE_H
#define DPL_ORM_INTERFACE_H
-namespace DPL
-{
-namespace DB
-{
-namespace ORM
-{
-
+namespace DPL {
+namespace DB {
+namespace ORM {
class IOrmInterface
{
public:
virtual ~IOrmInterface() {}
- virtual DPL::DB::SqlConnection::DataCommand *AllocDataCommand(const std::string &statement) = 0;
- virtual void FreeDataCommand(DPL::DB::SqlConnection::DataCommand *command) = 0;
+ virtual DPL::DB::SqlConnection::DataCommand *AllocDataCommand(
+ const std::string &statement) = 0;
+ virtual void FreeDataCommand(DPL::DB::SqlConnection::DataCommand *command)
+ = 0;
virtual void TransactionBegin() = 0;
virtual void TransactionCommit() = 0;
virtual void TransactionRollback() = 0;
virtual DPL::DB::SqlConnection::RowID GetLastInsertRowID() = 0;
};
-
}
}
}
* @file orm_macros.h
* @author Bartosz Janiak (b.janiak@samsung.com)
* @version 1.0
- * @brief Macro definitions for generating the SQL input file from database definition.
+ * @brief Macro definitions for generating the SQL input file from
+ * database definition.
*/
//Do not include this file directly! It is used only for SQL code generation.
-#define CREATE_TABLE(name) CREATE TABLE name (
-#define COLUMN(name, type, ...) name type __VA_ARGS__ ,
+#define CREATE_TABLE(name) CREATE TABLE name(
+#define COLUMN(name, type, ...) name type __VA_ARGS__,
#define COLUMN_NOT_NULL(name, type, ...) name type __VA_ARGS__ not null,
#define SQL(...) __VA_ARGS__
-#define TABLE_CONSTRAINTS(...) __VA_ARGS__ ,
+#define TABLE_CONSTRAINTS(...) __VA_ARGS__,
#define CREATE_TABLE_END() CHECK(1) );
#define DATABASE_START(db_name)
#define DATABASE_END()
#include <memory>
#include <stdint.h>
-namespace DPL
-{
-namespace DB
-{
-
+namespace DPL {
+namespace DB {
/**
* SQL connection class
*/
class SqlConnection
{
-public:
+ public:
/**
* SQL Exception classes
*/
class Exception
{
- public:
+ public:
DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, SyntaxError)
DECLARE_EXCEPTION_TYPE(Base, ConnectionBroken)
/*
* SQL processed data command
*/
- class DataCommand
- : private Noncopyable
+ class DataCommand :
+ private Noncopyable
{
- private:
+ private:
SqlConnection *m_masterConnection;
sqlite3_stmt *m_stmt;
friend class SqlConnection;
- public:
+ public:
virtual ~DataCommand();
/**
// Open flags
class Flag
{
- public:
+ public:
enum Type
{
- None = 1<<0,
- UseLucene = 1<<1
+ None = 1 << 0,
+ UseLucene = 1 << 1
};
enum Option
{
RO = SQLITE_OPEN_NOMUTEX | SQLITE_OPEN_READONLY,
/**
- *TODO: please remove CREATE option from RW flag when all places
+ * *TODO: please remove CREATE option from RW flag when all places
* that need that switched do CRW
*/
- RW = SQLITE_OPEN_NOMUTEX | SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE,
+ RW = SQLITE_OPEN_NOMUTEX | SQLITE_OPEN_READWRITE |
+ SQLITE_OPEN_CREATE,
CRW = RW | SQLITE_OPEN_CREATE
};
};
*/
class SynchronizationObject
{
- public:
+ public:
virtual ~SynchronizationObject() {}
/**
virtual void NotifyAll() = 0;
};
-protected:
+ protected:
sqlite3 *m_connection;
// Options
static SynchronizationObject *AllocDefaultSynchronizationObject();
-public:
+ public:
/**
* Open SQL connection
*
*/
RowID GetLastInsertRowID() const;
};
-
} // namespace DB
} // namespace DPL
#include <dpl/assert.h>
#include <stdint.h>
-namespace DPL
-{
-namespace DB
-{
-
+namespace DPL {
+namespace DB {
/**
* Thread database support
*
DPL::DB::SqlConnection::Flag::Type flags) :
m_address(address),
m_flags(flags)
- {
- }
+ {}
virtual ~ThreadDatabaseSupport()
- {
- }
+ {}
void AttachToThread(
- DPL::DB::SqlConnection::Flag::Option options =
- DPL::DB::SqlConnection::Flag::RO)
+ DPL::DB::SqlConnection::Flag::Option options =
+ DPL::DB::SqlConnection::Flag::RO)
{
Linger() = false;
// Initialize SQL connection described in traits
LogInfo("Attaching thread database connection: " << m_address);
- Connection() = new DPL::DB::SqlConnection(m_address.c_str(), m_flags, options);
+ Connection() = new DPL::DB::SqlConnection(
+ m_address.c_str(), m_flags, options);
RefCounter() = 0;
}
DPL::DB::SqlConnection::DataCommand *AllocDataCommand(
- const std::string &statement)
+ const std::string &statement)
{
// Calling thread must support thread database connections
Assert(!Connection().IsNull());
return (*Connection())->CheckTableExist(name);
}
};
-
}
}
* @file naive_synchronization_object.cpp
* @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
* @version 1.0
- * @brief This file is the implementation file of SQL naive synchronization object
+ * @brief This file is the implementation file of SQL naive
+ * synchronization object
*/
#include <stddef.h>
#include <dpl/db/naive_synchronization_object.h>
#include <dpl/thread.h>
-namespace DPL
-{
-namespace DB
-{
+namespace {
+ unsigned int seed = time(NULL);
+}
+namespace DPL {
+namespace DB {
void NaiveSynchronizationObject::Synchronize()
{
// Sleep for about 10ms - 30ms
- Thread::MiliSleep(10 + rand() % 20);
+ Thread::MiliSleep(10 + rand_r(&seed) % 20);
}
void NaiveSynchronizationObject::NotifyAll()
{
// No need to inform about anything
}
-
} // namespace DB
} // namespace DPL
* @file orm.cpp
* @author Bartosz Janiak (b.janiak@samsung.com)
* @version 1.0
- * @brief Static definitions and function template specialziations of DPL-ORM.
+ * @brief Static definitions and function template specialziations of
+ * DPL-ORM.
*/
#include <stddef.h>
#include <dpl/db/orm.h>
namespace DPL {
namespace DB {
namespace ORM {
-
namespace RelationTypes {
const char Equal[] = "=";
const char LessThan[] = "<";
template<>
int GetColumnFromCommand<int>(ColumnIndex columnIndex,
- DataCommand *command)
+ DataCommand *command)
{
return command->GetColumnInteger(columnIndex);
}
template<>
DPL::String GetColumnFromCommand<DPL::String>(ColumnIndex columnIndex,
- DataCommand *command)
+ DataCommand *command)
{
return DPL::FromUTF8String(command->GetColumnString(columnIndex));
}
template<>
OptionalInteger GetColumnFromCommand<OptionalInteger>(ColumnIndex columnIndex,
- DataCommand *command)
+ DataCommand *command)
{
return command->GetColumnOptionalInteger(columnIndex);
}
template<>
OptionalString GetColumnFromCommand<OptionalString>(ColumnIndex columnIndex,
- DataCommand *command)
+ DataCommand *command)
{
return command->GetColumnOptionalString(columnIndex);
}
template<>
double GetColumnFromCommand<double>(ColumnIndex columnIndex,
- DataCommand *command)
+ DataCommand *command)
{
return command->GetColumnDouble(columnIndex);
}
void DataCommandUtils::BindArgument(DataCommand *command,
- ArgumentIndex index,
- int argument)
+ ArgumentIndex index,
+ int argument)
{
command->BindInteger(index, argument);
}
void DataCommandUtils::BindArgument(DataCommand *command,
- ArgumentIndex index,
- const OptionalInteger& argument)
+ ArgumentIndex index,
+ const OptionalInteger& argument)
{
command->BindInteger(index, argument);
}
void DataCommandUtils::BindArgument(DataCommand *command,
- ArgumentIndex index,
- const DPL::String& argument)
+ ArgumentIndex index,
+ const DPL::String& argument)
{
command->BindString(index, argument);
}
void DataCommandUtils::BindArgument(DataCommand *command,
- ArgumentIndex index,
- const OptionalString& argument)
+ ArgumentIndex index,
+ const OptionalString& argument)
{
command->BindString(index, argument);
}
-
}
}
}
#include <cstdio>
#include <cstdarg>
-namespace DPL
-{
-namespace DB
-{
-
+namespace DPL {
+namespace DB {
namespace // anonymous
{
-class ScopedNotifyAll
- : public Noncopyable
+class ScopedNotifyAll :
+ public Noncopyable
{
-private:
+ private:
SqlConnection::SynchronizationObject *m_synchronizationObject;
-public:
+ public:
explicit ScopedNotifyAll(
- SqlConnection::SynchronizationObject *synchronizationObject)
- : m_synchronizationObject(synchronizationObject)
- {
- }
+ SqlConnection::SynchronizationObject *synchronizationObject) :
+ m_synchronizationObject(synchronizationObject)
+ {}
~ScopedNotifyAll()
{
- if (!m_synchronizationObject)
+ if (!m_synchronizationObject) {
return;
+ }
LogPedantic("Notifying after successful synchronize");
m_synchronizationObject->NotifyAll();
} // namespace anonymous
SqlConnection::DataCommand::DataCommand(SqlConnection *connection,
- const char *buffer)
- : m_masterConnection(connection),
- m_stmt(NULL)
+ const char *buffer) :
+ m_masterConnection(connection),
+ m_stmt(NULL)
{
Assert(connection != NULL);
// Notify all after potentially synchronized database connection access
ScopedNotifyAll notifyAll(connection->m_synchronizationObject.get());
- for (;;)
- {
+ for (;;) {
int ret = sqlite3_prepare_v2(connection->m_connection,
buffer, strlen(buffer),
&m_stmt, NULL);
- if (ret == SQLITE_OK)
- {
+ if (ret == SQLITE_OK) {
LogPedantic("Data command prepared successfuly");
break;
- }
- else if (ret == SQLITE_BUSY)
- {
+ } else if (ret == SQLITE_BUSY) {
LogPedantic("Collision occurred while preparing SQL command");
// Synchronize if synchronization object is available
- if (connection->m_synchronizationObject)
- {
+ if (connection->m_synchronizationObject) {
LogPedantic("Performing synchronization");
connection->m_synchronizationObject->Synchronize();
continue;
{
LogPedantic("SQL data command finalizing");
- if (sqlite3_finalize(m_stmt) != SQLITE_OK)
+ if (sqlite3_finalize(m_stmt) != SQLITE_OK) {
LogPedantic("Failed to finalize data command");
+ }
// Decrement stored data command count
--m_masterConnection->m_dataCommandsCount;
void SqlConnection::DataCommand::CheckBindResult(int result)
{
- if (result != SQLITE_OK)
- {
+ if (result != SQLITE_OK) {
const char *error = sqlite3_errmsg(
- m_masterConnection->m_connection);
+ m_masterConnection->m_connection);
LogPedantic("Failed to bind SQL statement parameter");
LogPedantic(" Error: " << error);
SqlConnection::ArgumentIndex position,
const char *value)
{
- if (!value)
- {
+ if (!value) {
BindNull(position);
return;
}
SqlConnection::ArgumentIndex position,
const Optional<int> &value)
{
- if (value.IsNull())
+ if (value.IsNull()) {
BindNull(position);
- else
+ } else {
BindInteger(position, *value);
+ }
}
void SqlConnection::DataCommand::BindInt8(
SqlConnection::ArgumentIndex position,
const Optional<int8_t> &value)
{
- if (value.IsNull())
+ if (value.IsNull()) {
BindNull(position);
- else
+ } else {
BindInt8(position, *value);
+ }
}
void SqlConnection::DataCommand::BindInt16(
SqlConnection::ArgumentIndex position,
const Optional<int16_t> &value)
{
- if (value.IsNull())
+ if (value.IsNull()) {
BindNull(position);
- else
+ } else {
BindInt16(position, *value);
+ }
}
void SqlConnection::DataCommand::BindInt32(
SqlConnection::ArgumentIndex position,
const Optional<int32_t> &value)
{
- if (value.IsNull())
+ if (value.IsNull()) {
BindNull(position);
- else
+ } else {
BindInt32(position, *value);
+ }
}
void SqlConnection::DataCommand::BindInt64(
SqlConnection::ArgumentIndex position,
const Optional<int64_t> &value)
{
- if (value.IsNull())
+ if (value.IsNull()) {
BindNull(position);
- else
+ } else {
BindInt64(position, *value);
+ }
}
void SqlConnection::DataCommand::BindFloat(
SqlConnection::ArgumentIndex position,
const Optional<float> &value)
{
- if (value.IsNull())
+ if (value.IsNull()) {
BindNull(position);
- else
+ } else {
BindFloat(position, *value);
+ }
}
void SqlConnection::DataCommand::BindDouble(
SqlConnection::ArgumentIndex position,
const Optional<double> &value)
{
- if (value.IsNull())
+ if (value.IsNull()) {
BindNull(position);
- else
+ } else {
BindDouble(position, *value);
+ }
}
void SqlConnection::DataCommand::BindString(
SqlConnection::ArgumentIndex position,
const Optional<String> &value)
{
- if (!!value)
+ if (!!value) {
BindString(position, ToUTF8String(*value).c_str());
- else
+ } else {
BindNull(position);
+ }
}
bool SqlConnection::DataCommand::Step()
ScopedNotifyAll notifyAll(
m_masterConnection->m_synchronizationObject.get());
- for (;;)
- {
+ for (;;) {
int ret = sqlite3_step(m_stmt);
- if (ret == SQLITE_ROW)
- {
+ if (ret == SQLITE_ROW) {
LogPedantic("SQL data command step ROW");
return true;
- }
- else if (ret == SQLITE_DONE)
- {
+ } else if (ret == SQLITE_DONE) {
LogPedantic("SQL data command step DONE");
return false;
- }
- else if (ret == SQLITE_BUSY)
- {
+ } else if (ret == SQLITE_BUSY) {
LogPedantic("Collision occurred while executing SQL command");
// Synchronize if synchronization object is available
- if (m_masterConnection->m_synchronizationObject)
- {
+ if (m_masterConnection->m_synchronizationObject) {
LogPedantic("Performing synchronization");
m_masterConnection->
void SqlConnection::DataCommand::CheckColumnIndex(
SqlConnection::ColumnIndex column)
{
- if (column < 0 || column >= sqlite3_column_count(m_stmt))
+ if (column < 0 || column >= sqlite3_column_count(m_stmt)) {
ThrowMsg(Exception::InvalidColumn, "Column index is out of bounds");
+ }
}
bool SqlConnection::DataCommand::IsColumnNull(
CheckColumnIndex(column);
const char *value = reinterpret_cast<const char *>(
- sqlite3_column_text(m_stmt, column));
+ sqlite3_column_text(m_stmt, column));
LogPedantic("Value: " << (value ? value : "NULL"));
- if (value == NULL)
+ if (value == NULL) {
return std::string();
+ }
return std::string(value);
}
LogPedantic("SQL data command get column optional integer: ["
<< column << "]");
CheckColumnIndex(column);
- if (sqlite3_column_type(m_stmt, column) == SQLITE_NULL)
+ if (sqlite3_column_type(m_stmt, column) == SQLITE_NULL) {
return Optional<int>::Null;
+ }
int value = sqlite3_column_int(m_stmt, column);
LogPedantic(" Value: " << value);
return Optional<int>(value);
LogPedantic("SQL data command get column optional int8: ["
<< column << "]");
CheckColumnIndex(column);
- if (sqlite3_column_type(m_stmt, column) == SQLITE_NULL)
+ if (sqlite3_column_type(m_stmt, column) == SQLITE_NULL) {
return Optional<int8_t>::Null;
+ }
int8_t value = static_cast<int8_t>(sqlite3_column_int(m_stmt, column));
LogPedantic(" Value: " << value);
return Optional<int8_t>(value);
LogPedantic("SQL data command get column optional int16: ["
<< column << "]");
CheckColumnIndex(column);
- if (sqlite3_column_type(m_stmt, column) == SQLITE_NULL)
+ if (sqlite3_column_type(m_stmt, column) == SQLITE_NULL) {
return Optional<int16_t>::Null;
+ }
int16_t value = static_cast<int16_t>(sqlite3_column_int(m_stmt, column));
LogPedantic(" Value: " << value);
return Optional<int16_t>(value);
LogPedantic("SQL data command get column optional int32: ["
<< column << "]");
CheckColumnIndex(column);
- if (sqlite3_column_type(m_stmt, column) == SQLITE_NULL)
+ if (sqlite3_column_type(m_stmt, column) == SQLITE_NULL) {
return Optional<int32_t>::Null;
+ }
int32_t value = static_cast<int32_t>(sqlite3_column_int(m_stmt, column));
LogPedantic(" Value: " << value);
return Optional<int32_t>(value);
LogPedantic("SQL data command get column optional int64: ["
<< column << "]");
CheckColumnIndex(column);
- if (sqlite3_column_type(m_stmt, column) == SQLITE_NULL)
+ if (sqlite3_column_type(m_stmt, column) == SQLITE_NULL) {
return Optional<int64_t>::Null;
+ }
int64_t value = static_cast<int64_t>(sqlite3_column_int64(m_stmt, column));
LogPedantic(" Value: " << value);
return Optional<int64_t>(value);
LogPedantic("SQL data command get column optional float: ["
<< column << "]");
CheckColumnIndex(column);
- if (sqlite3_column_type(m_stmt, column) == SQLITE_NULL)
+ if (sqlite3_column_type(m_stmt, column) == SQLITE_NULL) {
return Optional<float>::Null;
+ }
float value = static_cast<float>(sqlite3_column_double(m_stmt, column));
LogPedantic(" Value: " << value);
return Optional<float>(value);
LogPedantic("SQL data command get column optional double: ["
<< column << "]");
CheckColumnIndex(column);
- if (sqlite3_column_type(m_stmt, column) == SQLITE_NULL)
+ if (sqlite3_column_type(m_stmt, column) == SQLITE_NULL) {
return Optional<double>::Null;
+ }
double value = sqlite3_column_double(m_stmt, column);
LogPedantic(" Value: " << value);
return Optional<double>(value);
LogPedantic("SQL data command get column optional string: ["
<< column << "]");
CheckColumnIndex(column);
- if (sqlite3_column_type(m_stmt, column) == SQLITE_NULL)
+ if (sqlite3_column_type(m_stmt, column) == SQLITE_NULL) {
return Optional<String>::Null;
+ }
const char *value = reinterpret_cast<const char *>(
- sqlite3_column_text(m_stmt, column));
+ sqlite3_column_text(m_stmt, column));
LogPedantic("Value: " << value);
String s = FromUTF8String(value);
return Optional<String>(s);
}
void SqlConnection::Connect(const std::string &address,
- Flag::Type type,
- Flag::Option flag)
+ Flag::Type type,
+ Flag::Option flag)
{
if (m_connection != NULL) {
LogPedantic("Already connected.");
int result;
if (type & Flag::UseLucene) {
result = db_util_open_with_options(
- address.c_str(),
- &m_connection,
- flag,
- NULL);
+ address.c_str(),
+ &m_connection,
+ flag,
+ NULL);
m_usingLucene = true;
LogPedantic("Lucene index enabled");
} else {
result = sqlite3_open_v2(
- address.c_str(),
- &m_connection,
- flag,
- NULL);
+ address.c_str(),
+ &m_connection,
+ flag,
+ NULL);
m_usingLucene = false;
LogPedantic("Lucene index disabled");
void SqlConnection::Disconnect()
{
- if (m_connection == NULL)
- {
+ if (m_connection == NULL) {
LogPedantic("Already disconnected.");
return;
}
int result;
- if (m_usingLucene)
- {
+ if (m_usingLucene) {
result = db_util_close(m_connection);
- }
- else
- {
+ } else {
result = sqlite3_close(m_connection);
}
- if (result != SQLITE_OK)
- {
+ if (result != SQLITE_OK) {
const char *error = sqlite3_errmsg(m_connection);
LogPedantic("SQL close failed");
LogPedantic(" Error: " << error);
bool SqlConnection::CheckTableExist(const char *tableName)
{
- if (m_connection == NULL)
- {
+ if (m_connection == NULL) {
LogPedantic("Cannot execute command. Not connected to DB!");
return false;
}
command->BindString(1, tableName);
- if (!command->Step())
- {
+ if (!command->Step()) {
LogPedantic("No matching records in table");
return false;
}
SqlConnection::SqlConnection(const std::string &address,
Flag::Type flag,
Flag::Option option,
- SynchronizationObject *synchronizationObject)
- : m_connection(NULL),
- m_usingLucene(false),
- m_dataCommandsCount(0),
- m_synchronizationObject(synchronizationObject)
+ SynchronizationObject *synchronizationObject) :
+ m_connection(NULL),
+ m_usingLucene(false),
+ m_dataCommandsCount(0),
+ m_synchronizationObject(synchronizationObject)
{
LogPedantic("Opening database connection to: " << address);
// Connect to DB
SqlConnection::Connect(address, flag, option);
- if (!m_synchronizationObject)
- {
+ if (!m_synchronizationObject) {
LogPedantic("No synchronization object defined");
}
}
{
SqlConnection::Disconnect();
}
- Catch (Exception::Base)
+ Catch(Exception::Base)
{
LogPedantic("Failed to disconnect from database");
}
void SqlConnection::ExecCommand(const char *format, ...)
{
- if (m_connection == NULL)
- {
+ if (m_connection == NULL) {
LogPedantic("Cannot execute command. Not connected to DB!");
return;
}
- if (format == NULL)
- {
+ if (format == NULL) {
LogPedantic("Null query!");
ThrowMsg(Exception::SyntaxError, "Null statement");
}
va_list args;
va_start(args, format);
- if (vasprintf(&rawBuffer, format, args) == -1)
+ if (vasprintf(&rawBuffer, format, args) == -1) {
rawBuffer = NULL;
+ }
va_end(args);
ScopedFree<char> buffer(rawBuffer);
- if (!buffer)
- {
+ if (!buffer) {
LogPedantic("Failed to allocate statement string");
return;
}
// Notify all after potentially synchronized database connection access
ScopedNotifyAll notifyAll(m_synchronizationObject.get());
- for (;;)
- {
+ for (;;) {
char *errorBuffer;
int ret = sqlite3_exec(m_connection,
std::string errorMsg;
// Take allocated error buffer
- if (errorBuffer != NULL)
- {
+ if (errorBuffer != NULL) {
errorMsg = errorBuffer;
sqlite3_free(errorBuffer);
}
- if (ret == SQLITE_OK)
+ if (ret == SQLITE_OK) {
return;
+ }
- if (ret == SQLITE_BUSY)
- {
+ if (ret == SQLITE_BUSY) {
LogPedantic("Collision occurred while executing SQL command");
// Synchronize if synchronization object is available
- if (m_synchronizationObject)
- {
+ if (m_synchronizationObject) {
LogPedantic("Performing synchronization");
m_synchronizationObject->Synchronize();
continue;
const char *format,
...)
{
- if (m_connection == NULL)
- {
+ if (m_connection == NULL) {
LogPedantic("Cannot execute data command. Not connected to DB!");
return DataCommandAutoPtr();
}
va_list args;
va_start(args, format);
- if (vasprintf(&rawBuffer, format, args) == -1)
+ if (vasprintf(&rawBuffer, format, args) == -1) {
rawBuffer = NULL;
+ }
va_end(args);
ScopedFree<char> buffer(rawBuffer);
- if (!buffer)
- {
+ if (!buffer) {
LogPedantic("Failed to allocate statement string");
return DataCommandAutoPtr();
}
}
SqlConnection::SynchronizationObject *
- SqlConnection::AllocDefaultSynchronizationObject()
+SqlConnection::AllocDefaultSynchronizationObject()
{
return new NaiveSynchronizationObject();
}
-
} // namespace DB
} // namespace DPL
${PROJECT_SOURCE_DIR}/modules/dbus/include/dpl/dbus/dbus_server_serialization.h
${PROJECT_SOURCE_DIR}/modules/dbus/include/dpl/dbus/dbus_signature.h
${PROJECT_SOURCE_DIR}/modules/dbus/include/dpl/dbus/dispatcher.h
+ ${PROJECT_SOURCE_DIR}/modules/dbus/include/dpl/dbus/glib_util.h
${PROJECT_SOURCE_DIR}/modules/dbus/include/dpl/dbus/exception.h
${PROJECT_SOURCE_DIR}/modules/dbus/include/dpl/dbus/interface.h
${PROJECT_SOURCE_DIR}/modules/dbus/include/dpl/dbus/method_proxy.h
#include <memory>
#include <vector>
#include <string>
-#include <gio/gio.h>
#include <dpl/generic_event.h>
#include <dpl/event/event_support.h>
#include <dpl/dbus/object.h>
#include <dpl/dbus/object_proxy.h>
+#include <dpl/dbus/glib_util.h>
namespace DPL {
namespace DBus {
-
-namespace ConnectionEvents
-{
+namespace ConnectionEvents {
/**
* Emitted when service name is acquired.
*
typedef std::shared_ptr<ObjectProxy> ObjectProxyPtr;
class Connection :
- public DPL::Event::EventSupport<ConnectionEvents::ServiceNameAcquiredEvent>,
- public DPL::Event::EventSupport<ConnectionEvents::ServiceNameLostEvent>,
- public DPL::Event::EventSupport<ConnectionEvents::ConnectionBrokenEvent>,
- public DPL::Event::EventSupport<ConnectionEvents::ConnectionInvalidEvent>
+ public DPL::Event::EventSupport<ConnectionEvents::ServiceNameAcquiredEvent>,
+ public DPL::Event::EventSupport<ConnectionEvents::ServiceNameLostEvent>,
+ public DPL::Event::EventSupport<ConnectionEvents::ConnectionBrokenEvent>,
+ public DPL::Event::EventSupport<ConnectionEvents::ConnectionInvalidEvent>
{
-public:
+ public:
/**
* Acquires connection to session bus.
*
ObjectProxyPtr createObjectProxy(const std::string& serviceName,
const std::string& objectPath);
-private:
+ private:
friend class Server;
typedef std::map<std::string, guint> RegisteredServices;
struct ObjectRegistration
{
- ObjectRegistration(guint _registrationId, const ObjectPtr& _object)
- : registrationId(_registrationId),
- object(_object)
- {
- }
+ ObjectRegistration(guint _registrationId, const ObjectPtr& _object) :
+ registrationId(_registrationId),
+ object(_object)
+ {}
guint registrationId;
ObjectPtr object;
RegisteredObjects m_registeredObjects;
};
-
}
}
namespace DPL {
namespace DBus {
-
/*
* DBus::Client class is intended to act as simple DBus client. To call a method
* on remote service "Service", on remote object "Object", interface
class Client
{
-
public:
class Exception
{
Client(std::string serverPath,
std::string serviceName,
std::string interfaceName) :
- m_serviceName(serviceName),
- m_serverPath(serverPath),
- m_interfaceName(interfaceName)
+ m_serviceName(serviceName),
+ m_serverPath(serverPath),
+ m_interfaceName(interfaceName)
{
DBusError error;
m_connection = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
if (NULL == m_connection) {
LogPedantic("Couldn't get DBUS connection. Error: " <<
- error.message);
+ error.message);
dbus_error_free(&error);
ThrowMsg(Exception::DBusClientException,
- "Couldn't get DBUS connection." );
+ "Couldn't get DBUS connection.");
}
}
- template<typename ...Args>
- void call(const char* methodName, const Args&... args)
+ template<typename ... Args>
+ void call(const char* methodName, const Args& ... args)
{
DBusMessage* message = dbus_message_new_method_call(
m_serviceName.c_str(),
methodName);
DBusMessageIter argsIterator;
dbus_message_iter_init_append(message, &argsIterator);
- call(message, &argsIterator, args...);
+ call(message, &argsIterator, args ...);
dbus_message_unref(message);
}
- template<typename ...Args>
- void call(std::string methodName, const Args&... args)
+ template<typename ... Args>
+ void call(std::string methodName, const Args& ... args)
{
- call(methodName.c_str(), args...);
+ call(methodName.c_str(), args ...);
}
~Client()
private:
DBusMessage* makeCall(
- DBusMessage* message)
+ DBusMessage* message)
{
DBusError error;
dbus_error_init(&error);
&error);
if (NULL == ret) {
LogPedantic("Error sending DBUS message: " <<
- error.message);
+ error.message);
dbus_error_free(&error);
ThrowMsg(Exception::DBusClientException,
- "Error sending DBUS message." );
+ "Error sending DBUS message.");
}
return ret;
}
} else {
LogPedantic("Error getting DBUS response.");
ThrowMsg(Exception::DBusClientException,
- "Error getting DBUS response." );
+ "Error getting DBUS response.");
}
}
template<typename T, typename ... Args>
void call(
- DBusMessage* message,
- DBusMessageIter* argsIterator,
- const T& invalue,
- const Args&... args)
+ DBusMessage* message,
+ DBusMessageIter* argsIterator,
+ const T& invalue,
+ const Args& ... args)
{
- if (!Serialization::serialize(argsIterator, invalue)){
+ if (!Serialization::serialize(argsIterator, invalue)) {
LogPedantic("Error in serialization.");
ThrowMsg(Exception::DBusClientException,
- "Error in serialization." );
+ "Error in serialization.");
}
- call(message, argsIterator, args...);
+ call(message, argsIterator, args ...);
}
template<typename T, typename ... Args>
void call(
- DBusMessage* message,
- DBusMessageIter* argsIterator,
- const T* invalue,
- const Args&... args)
+ DBusMessage* message,
+ DBusMessageIter* argsIterator,
+ const T* invalue,
+ const Args& ... args)
{
- if (!Serialization::serialize(argsIterator, invalue)){
+ if (!Serialization::serialize(argsIterator, invalue)) {
LogPedantic("Error in serialization.");
ThrowMsg(Exception::DBusClientException,
- "Error in serialization." );
+ "Error in serialization.");
}
- call(message, argsIterator, args...);
+ call(message, argsIterator, args ...);
}
template<typename T, typename ... Args>
void call(
- DBusMessage* message,
- DBusMessageIter* argsIterator,
- const T* invalue)
+ DBusMessage* message,
+ DBusMessageIter* argsIterator,
+ const T* invalue)
{
- if (!Serialization::serialize(argsIterator, invalue)){
+ if (!Serialization::serialize(argsIterator, invalue)) {
LogPedantic("Error in serialization.");
ThrowMsg(Exception::DBusClientException,
- "Error in serialization." );
+ "Error in serialization.");
}
call(message, argsIterator);
}
template<typename T, typename ... Args>
void call(
- DBusMessage* message,
- DBusMessageIter* /*argsIterator*/,
- T* out,
- const Args&... args)
+ DBusMessage* message,
+ DBusMessageIter* /*argsIterator*/,
+ T* out,
+ const Args& ... args)
{
DBusMessage* ret = makeCall(message);
if (ret != NULL) {
DBusMessageIter responseIterator;
dbus_message_iter_init(ret, &responseIterator);
- returnFromCall(&responseIterator, out, args...);
+ returnFromCall(&responseIterator, out, args ...);
dbus_message_unref(ret);
}
}
template<typename T, typename ... Args>
void returnFromCall(
- DBusMessageIter* responseIterator,
- T* out,
- const Args&... args)
+ DBusMessageIter* responseIterator,
+ T* out,
+ const Args& ... args)
{
- if (!Deserialization::deserialize(responseIterator, out)){
+ if (!Deserialization::deserialize(responseIterator, out)) {
LogPedantic("Error in deserialization.");
ThrowMsg(Exception::DBusClientException,
- "Error in deserialization." );
+ "Error in deserialization.");
}
- returnFromCall(responseIterator, args...);
+ returnFromCall(responseIterator, args ...);
}
template<typename T>
void returnFromCall(DBusMessageIter* responseIterator, T* out)
{
- if (!Deserialization::deserialize(responseIterator, out)){
+ if (!Deserialization::deserialize(responseIterator, out)) {
LogPedantic("Error in deserialization.");
ThrowMsg(Exception::DBusClientException,
- "Error in deserialization." );
+ "Error in deserialization.");
}
}
std::string m_serviceName, m_serverPath, m_interfaceName;
DBusConnection* m_connection;
};
-
} // namespace DBus
} // namespace DPL
namespace DPL {
namespace DBus {
-
struct Deserialization
{
-
static bool deserializePrimitive(
- DBusMessageIter* responseIterator,
- void* arg,
- int type)
+ DBusMessageIter* responseIterator,
+ void* arg,
+ int type)
{
if (dbus_message_iter_get_arg_type(responseIterator) != type) {
return false;
static bool deserialize(DBusMessageIter* responseIterator, T* arg)
{
if (dbus_message_iter_get_arg_type(responseIterator)
- != SimpleType<T>::value) {
+ != SimpleType<T>::value)
+ {
return false;
}
dbus_message_iter_get_basic(responseIterator, arg);
static bool deserialize(DBusMessageIter* responseIterator, float* arg)
{
double d;
- if (!deserialize(responseIterator, &d)){
+ if (!deserialize(responseIterator, &d)) {
return false;
}
*arg = static_cast<float>(d);
// std::string
static bool deserialize(
- DBusMessageIter* responseIterator,
- std::string* arg)
+ DBusMessageIter* responseIterator,
+ std::string* arg)
{
char* str = NULL;
- if (!deserialize(responseIterator, &str)){
+ if (!deserialize(responseIterator, &str)) {
return false;
}
*arg = std::string(str);
// dbus array deserialization
template<typename T>
static bool deserializeContainer(
- DBusMessageIter* responseIterator,
- T* arg)
+ DBusMessageIter* responseIterator,
+ T* arg)
{
if (dbus_message_iter_get_arg_type(responseIterator)
- != DBUS_TYPE_ARRAY) {
+ != DBUS_TYPE_ARRAY)
+ {
return false;
}
DBusMessageIter subIterator;
dbus_message_iter_recurse(responseIterator, &subIterator);
while (dbus_message_iter_get_arg_type(&subIterator)
- != DBUS_TYPE_INVALID) {
+ != DBUS_TYPE_INVALID)
+ {
arg->push_back(typename T::value_type());
- if (!deserialize(&subIterator, &arg->back())){
+ if (!deserialize(&subIterator, &arg->back())) {
return false;
}
dbus_message_iter_next(&subIterator);
// std::vector
template<typename T>
static bool deserialize(
- DBusMessageIter* responseIterator,
- std::vector<T>* arg)
+ DBusMessageIter* responseIterator,
+ std::vector<T>* arg)
{
return deserializeContainer(responseIterator, arg);
}
// std::list
template<typename T>
static bool deserialize(
- DBusMessageIter* responseIterator,
- std::list<T>* arg)
+ DBusMessageIter* responseIterator,
+ std::list<T>* arg)
{
return deserializeContainer(responseIterator, arg);
}
// std::set
template<typename T>
static bool deserialize(
- DBusMessageIter* responseIterator,
- std::set<T>* arg)
+ DBusMessageIter* responseIterator,
+ std::set<T>* arg)
{
if (dbus_message_iter_get_arg_type(responseIterator)
- != DBUS_TYPE_ARRAY) {
+ != DBUS_TYPE_ARRAY)
+ {
return false;
}
DBusMessageIter subIterator;
dbus_message_iter_recurse(responseIterator, &subIterator);
while (dbus_message_iter_get_arg_type(&subIterator)
- != DBUS_TYPE_INVALID) {
+ != DBUS_TYPE_INVALID)
+ {
typename std::set<T>::value_type element;
- if (!deserialize(&subIterator, &element)){
+ if (!deserialize(&subIterator, &element)) {
return false;
}
arg->insert(element);
// std::pair
template<typename A, typename B>
static bool deserialize(
- DBusMessageIter* argsIterator,
-
const std::pair<A, B>* arg)
+ DBusMessageIter* argsIterator,
+ const std::pair<A, B>* arg)
{
if (dbus_message_iter_get_arg_type(argsIterator)
- != DBUS_TYPE_DICT_ENTRY) {
+ != DBUS_TYPE_DICT_ENTRY)
+ {
return false;
}
DBusMessageIter dictEntryIterator;
dbus_message_iter_recurse(argsIterator, &dictEntryIterator);
- if (!deserialize(dictEntryIterator, &arg->first)){
+ if (!deserialize(dictEntryIterator, &arg->first)) {
return false;
}
dbus_message_iter_next(&dictEntryIterator);
- if (!deserialize(dictEntryIterator, &arg->second)){
+ if (!deserialize(dictEntryIterator, &arg->second)) {
return false;
}
return true;
// std::map
template<typename K, typename V>
static bool deserialize(
- DBusMessageIter* responseIterator,
- const std::map<K, V>* arg)
+ DBusMessageIter* responseIterator,
+ const std::map<K, V>* arg)
{
if (dbus_message_iter_get_arg_type(responseIterator)
- != DBUS_TYPE_ARRAY) {
+ != DBUS_TYPE_ARRAY)
+ {
return false;
}
DBusMessageIter subIterator;
dbus_message_iter_recurse(responseIterator, &subIterator);
while (dbus_message_iter_get_arg_type(&subIterator)
- != DBUS_TYPE_INVALID) {
+ != DBUS_TYPE_INVALID)
+ {
typename std::pair<K, V> element;
- if (!deserialize(&subIterator, &element)){
+ if (!deserialize(&subIterator, &element)) {
return false;
}
arg->insert(element);
}
return true;
}
-
};
template<>
{
unsigned int value;
if (dbus_message_iter_get_arg_type(responseIterator)
- != SimpleType<bool>::value) {
+ != SimpleType<bool>::value)
+ {
return false;
}
dbus_message_iter_get_basic(responseIterator, &value);
*arg = static_cast<bool>(value);
return true;
}
-
} // namespace DBus
} // namespace DPL
namespace DPL {
namespace DBus {
-
class InterfaceDispatcher : public DBus::Dispatcher
{
-public:
- explicit InterfaceDispatcher(const std::string& interfaceName):
+ public:
+ explicit InterfaceDispatcher(const std::string& interfaceName) :
m_interfaceName(interfaceName)
- {
- }
+ {}
virtual ~InterfaceDispatcher()
{}
GVariant* parameters,
GDBusMethodInvocation* invocation)
{
- if (g_strcmp0(interfaceName, m_interfaceName.c_str()) == 0){
+ if (g_strcmp0(interfaceName, m_interfaceName.c_str()) == 0) {
onMethodCall(methodName, parameters, invocation);
} else {
LogPedantic("Called invalid interface: " << interfaceName <<
- " instead of: " << m_interfaceName);
+ " instead of: " << m_interfaceName);
}
}
LogInfo("InterfaceDispatcher onPropertySet: " << propertyName);
return false;
}
-private:
- std::string m_interfaceName, m_xml;
-};
+ private:
+ std::string m_interfaceName, m_xml;
+};
} // namespace DBus
} // namespace DPL
namespace DPL {
namespace DBus {
-
struct Serialization
{
-
// std::string
static bool serialize(
- DBusMessageIter* argsIterator,
- const std::string& str)
+ DBusMessageIter* argsIterator,
+ const std::string& str)
{
return serialize(argsIterator, str.c_str());
}
// dbus array serialization
template<typename T>
static bool serializeContainer(
- DBusMessageIter* argsIterator,
- const T& arg)
+ DBusMessageIter* argsIterator,
+ const T& arg)
{
typename T::const_iterator containerIt;
DBusMessageIter subIterator;
if (!dbus_message_iter_open_container(argsIterator, DBUS_TYPE_ARRAY,
- Signature<typename T::value_type>::value(), &subIterator)) {
+ Signature<typename T::value_type>
+ ::value(), &subIterator))
+ {
return false;
}
- FOREACH(containerIt,arg) {
- if (!serialize(&subIterator, *containerIt)){
+ FOREACH(containerIt, arg) {
+ if (!serialize(&subIterator, *containerIt)) {
return false;
}
}
// std::vector
template<typename T>
static bool serialize(
- DBusMessageIter* argsIterator,
- const std::vector<T> &arg)
+ DBusMessageIter* argsIterator,
+ const std::vector<T> &arg)
{
return serializeContainer(argsIterator, arg);
}
// std::list
template<typename T>
static bool serialize(
- DBusMessageIter* argsIterator,
- const std::list<T> &arg)
+ DBusMessageIter* argsIterator,
+ const std::list<T> &arg)
{
return serializeContainer(argsIterator, arg);
}
// std::set
template<typename T>
static bool serialize(
- DBusMessageIter* argsIterator,
- const std::set<T> &arg)
+ DBusMessageIter* argsIterator,
+ const std::set<T> &arg)
{
return serializeContainer(argsIterator, arg);
}
// std::pair
template<typename A, typename B>
static bool serialize(
- DBusMessageIter* argsIterator,
-
const std::pair<A, B> &arg)
+ DBusMessageIter* argsIterator,
+ const std::pair<A, B> &arg)
{
DBusMessageIter dictEntryIterator;
if (!dbus_message_iter_open_container(argsIterator,
- DBUS_TYPE_DICT_ENTRY, NULL, &dictEntryIterator)) {
+ DBUS_TYPE_DICT_ENTRY, NULL,
+ &dictEntryIterator))
+ {
return false;
}
- if (!serialize(dictEntryIterator, arg.first)){
+ if (!serialize(dictEntryIterator, arg.first)) {
return false;
}
- if (!serialize(dictEntryIterator, arg.second)){
+ if (!serialize(dictEntryIterator, arg.second)) {
return false;
}
return dbus_message_iter_close_container(argsIterator,
// std::map
template<typename K, typename V>
static bool serialize(
- DBusMessageIter* argsIterator,
- const std::map<K, V> &arg)
+ DBusMessageIter* argsIterator,
+ const std::map<K, V> &arg)
{
return serializeContainer(argsIterator, arg);
}
-
};
// char* and all integer types + doubles
SimpleType<bool>::value,
&value);
}
-
} // namespace DBus
} // namespace DPL
namespace DPL {
namespace DBus {
-
struct ServerDeserialization {
-
- template<typename T, typename ...Args>
- static bool deserialize(GVariant* g, T* arg1, Args... args)
+ template<typename T, typename ... Args>
+ static bool deserialize(GVariant* g, T* arg1, Args ... args)
{
Assert(NULL != g);
Assert(NULL != arg1);
g_variant_iter_free(iterator);
return false;
}
- if (!deserializeIterator(iterator, args...)) {
+ if (!deserializeIterator(iterator, args ...)) {
g_variant_iter_free(iterator);
return false;
}
}
// deserialization from GVariant tuple iterator
- template<typename T, typename ...Args>
- static bool deserializeIterator(GVariantIter* g, T* arg1, Args... args)
+ template<typename T, typename ... Args>
+ static bool deserializeIterator(GVariantIter* g, T* arg1, Args ... args)
{
Assert(NULL != g);
Assert(NULL != arg1);
if (!deserializeElem(elem, arg1)) {
return false;
}
- if (!deserializeIterator(g, args...)) {
+ if (!deserializeIterator(g, args ...)) {
return false;
}
return true;
}
static bool deserializeElem(GVariant* parameters,
- std::vector<std::string>* outArray)
+ std::vector<std::string>* outArray)
{
unsigned int i = 0;
gsize length = 0;
return true;
}
};
-
} // namespace DBus
} // namespace DPL
namespace DPL {
namespace DBus {
-
struct ServerSerialization {
-
- template<typename ...Args>
- static GVariant* serialize(Args... args)
+ template<typename ... Args>
+ static GVariant* serialize(Args ... args)
{
GVariantBuilder* builder = g_variant_builder_new(G_VARIANT_TYPE_TUPLE);
if (NULL == builder) {
}
// serialization on GVariantBuilder
- template<typename T, typename ...Args>
+ template<typename T, typename ... Args>
static void serializeBuilder(GVariantBuilder* builder,
const T& arg,
- Args... args)
+ Args ... args)
{
serializeElem(builder, arg);
serializeBuilder(builder, args ...);
}
static void serializeElem(GVariantBuilder* builder,
- const std::string& arg)
+ const std::string& arg)
{
g_variant_builder_add_value(builder, g_variant_new_string(arg.c_str()));
}
};
-
} // namespace DBus
} // namespace DPL
namespace DPL {
namespace DBus {
-
template<typename T>
struct SimpleType;
struct SimpleType<unsigned char>
{
static const int value =
- __UnsignedIntegerType<sizeof(unsigned char)>::value;
+ __UnsignedIntegerType<sizeof(unsigned char)>::value;
};
template<>
struct SimpleType<unsigned short>
{
static const int value =
- __UnsignedIntegerType<sizeof(unsigned short)>::value;
+ __UnsignedIntegerType<sizeof(unsigned short)>::value;
};
template<>
struct SimpleType<unsigned int>
{
static const int value =
- __UnsignedIntegerType<sizeof(unsigned int)>::value;
+ __UnsignedIntegerType<sizeof(unsigned int)>::value;
};
template<>
struct SimpleType<unsigned long>
{
static const int value =
- __UnsignedIntegerType<sizeof(unsigned long)>::value;
+ __UnsignedIntegerType<sizeof(unsigned long)>::value;
};
template<>
// std::vector
template<typename T>
struct Signature<std::vector<T> > : public ArraySignature<T>
-{
-};
+{};
// std::list
template<typename T>
struct Signature<std::list<T> > : public ArraySignature<T>
-{
-};
+{};
// std::set
template<typename T>
struct Signature<std::set<T> > : public ArraySignature<T>
-{
-};
+{};
// std::pair
template<typename K, typename V>
{
static const std::string signature = std::string(
DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING)
- + Signature<K>::value() + Signature<V>::value()
- + DBUS_DICT_ENTRY_END_CHAR_AS_STRING;
+ + Signature<K>::value() + Signature<V>::value()
+ + DBUS_DICT_ENTRY_END_CHAR_AS_STRING;
return signature.c_str();
}
};
// std::map
template<typename K, typename V>
struct Signature<std::map<K, V> > : public ArraySignature<std::pair<K, V> >
-{
-};
-
+{};
} // namespace DBus
} // namespace DPL
namespace DPL {
namespace DBus {
-
class Dispatcher
{
-public:
- virtual ~Dispatcher() =0;
+ public:
+ virtual ~Dispatcher() = 0;
/**
* Called on method invocation.
const gchar* interfaceName,
const gchar* methodName,
GVariant* parameters,
- GDBusMethodInvocation* invocation) =0;
+ GDBusMethodInvocation* invocation) = 0;
/**
* Called on property get.
GVariant* value,
GError** error);
};
-
}
}
namespace DPL {
namespace DBus {
-
/**
* Thrown when none of the following, more specific exception fit.
*/
* Thrown when passing invalid argument(s).
*/
DECLARE_EXCEPTION_TYPE(DBus::Exception, InvalidArgumentException)
-
}
}
--- /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 glib_util.h
+ * @author Iwanek Tomasz (t.iwanek@samsung.com)
+ * @version 1.0
+ * @brief This file is the definitions of loop controlling utilities
+ */
+#ifndef GLIB_UTIL_H
+#define GLIB_UTIL_H
+
+//this header wraps glib headers which generates warnings
+
+#pragma GCC system_header
+#include <gio/gio.h>
+
+#endif // GLIB_UTIL_H
namespace DPL {
namespace DBus {
-
class Interface;
typedef std::shared_ptr<Interface> InterfacePtr;
class Interface : private DPL::Noncopyable
{
-public:
+ public:
/**
* Parses supplied XML string to produce DBus interface descriptions.
*
* @throw DPL::DBus::Exception If error while parsing occurs.
*/
static std::vector<InterfacePtr> fromXMLString(
- const std::string& xmlString);
+ const std::string& xmlString);
-public:
+ public:
~Interface();
/**
*/
void setDispatcher(Dispatcher* dispatcher);
-private:
+ private:
static void onMethodCallFunc(GDBusConnection *connection,
const gchar *sender,
const gchar *objectPath,
Dispatcher* m_dispatcher;
};
-
}
}
namespace DPL {
namespace DBus {
-
class ObjectProxy;
/**
* Represents a remote method.
*/
-template<typename Result, typename ...Args>
+template<typename Result, typename ... Args>
class MethodProxy
{
-public:
+ public:
~MethodProxy()
{
g_object_unref(m_connection);
* @throw DBus::ConnectionClosedException If connection is closed.
* @throw DBus::Exception If some other error occurs.
*/
- Result operator()(const Args&... args)
+ Result operator()(const Args& ... args)
{
- return invoke(args...);
+ return invoke(args ...);
}
-private:
+ private:
friend class ObjectProxy;
MethodProxy(GDBusConnection* connection,
const std::string& serviceName,
const std::string& objectPath,
const std::string& interfaceName,
- const std::string& methodName)
- : m_connection(connection),
- m_serviceName(serviceName),
- m_objectPath(objectPath),
- m_interfaceName(interfaceName),
- m_methodName(methodName)
+ const std::string& methodName) :
+ m_connection(connection),
+ m_serviceName(serviceName),
+ m_objectPath(objectPath),
+ m_interfaceName(interfaceName),
+ m_methodName(methodName)
{
Assert(m_connection && "Connection is not set.");
*/
template<typename R = Result>
typename std::enable_if<!std::is_void<R>::value, R>::type
- invoke(const Args&... args)
+ invoke(const Args& ... args)
{
- GVariant* parameters = serialize(args...);
+ GVariant* parameters = serialize(args ...);
GVariant* invokeResult = invokeSync(parameters);
*/
template<typename R = Result>
typename std::enable_if<std::is_void<R>::value>::type
- invoke(const Args&... args)
+ invoke(const Args& ... args)
{
- GVariant* parameters = serialize(args...);
+ GVariant* parameters = serialize(args ...);
GVariant* invokeResult = invokeSync(parameters);
* @remarks ArgsM... are the same as Args...; it has been made a template
* to make overloading/specialization possible.
*/
- template<typename ...ArgsM>
- GVariant* serialize(ArgsM&&... args)
+ template<typename ... ArgsM>
+ GVariant* serialize(ArgsM && ... args)
{
- return ServerSerialization::serialize(std::forward<ArgsM>(args)...);
+ return ServerSerialization::serialize(std::forward<ArgsM>(args) ...);
}
/**
{
GError* error = NULL;
- LogPedantic("Invoking method: " << m_interfaceName << "." << m_methodName);
+ LogPedantic(
+ "Invoking method: " << m_interfaceName << "." << m_methodName);
GVariant* result = g_dbus_connection_call_sync(m_connection,
m_serviceName.c_str(),
m_objectPath.c_str(),
DBUS_SYNC_CALL_TIMEOUT,
NULL,
&error);
- if (NULL == result)
- {
+ if (NULL == result) {
std::ostringstream oss;
oss << "Error while invoking: "
<< m_interfaceName << "." << m_methodName
g_error_free(error);
- switch (code)
- {
+ switch (code) {
case G_IO_ERROR_INVALID_ARGUMENT:
ThrowMsg(DBus::InvalidArgumentException, message);
case G_IO_ERROR_CLOSED:
/**
* Smart pointer for MethodProxy objects.
*/
-template<typename Result, typename ...Args>
+template<typename Result, typename ... Args>
class MethodProxyPtr
{
-public:
- explicit MethodProxyPtr(MethodProxy<Result, Args...>* method = NULL)
- : m_method(method)
- {
- }
+ public:
+ explicit MethodProxyPtr(MethodProxy<Result, Args ...>* method = NULL) :
+ m_method(method)
+ {}
- Result operator()(const Args&... args) const
+ Result operator()(const Args& ... args) const
{
Assert(NULL != m_method.get() && "Method not set.");
- return (*m_method)(args...);
+ return (*m_method)(args ...);
}
-private:
- std::shared_ptr<MethodProxy<Result, Args...> > m_method;
+ private:
+ std::shared_ptr<MethodProxy<Result, Args ...> > m_method;
};
-
}
}
namespace DPL {
namespace DBus {
-
class Object;
typedef std::shared_ptr<Object> ObjectPtr;
class Object
{
-public:
+ public:
/**
* Creates an object.
*
*/
InterfacePtr getInterface() const;
-private:
+ private:
Object(const std::string& path, const InterfacePtr& interface);
std::string m_path;
InterfacePtr m_interface;
};
-
}
}
namespace DPL {
namespace DBus {
-
class Connection;
/**
*/
class ObjectProxy
{
-public:
+ public:
~ObjectProxy();
/**
* @return Proxy to remote method.
* @throw DBus::ConnectionClosedException If connection is closed.
*/
- template<typename Result, typename ...Args>
- MethodProxyPtr<Result, Args...> createMethodProxy(
- const std::string& interface,
- const std::string& name)
+ template<typename Result, typename ... Args>
+ MethodProxyPtr<Result, Args ...> createMethodProxy(
+ const std::string& interface,
+ const std::string& name)
{
- if (g_dbus_connection_is_closed(m_connection))
- {
+ if (g_dbus_connection_is_closed(m_connection)) {
ThrowMsg(DBus::ConnectionClosedException, "Connection closed.");
}
- return MethodProxyPtr<Result, Args...>(
- new MethodProxy<Result, Args...>(m_connection,
- m_serviceName,
- m_objectPath,
- interface,
- name));
+ return MethodProxyPtr<Result, Args ...>(
+ new MethodProxy<Result, Args ...>(m_connection,
+ m_serviceName,
+ m_objectPath,
+ interface,
+ name));
}
-private:
+ private:
friend class Connection;
ObjectProxy(GDBusConnection* connection,
std::string m_serviceName;
std::string m_objectPath;
};
-
}
}
#include <dpl/event/event_support.h>
#include <dpl/dbus/connection.h>
-namespace DPL
-{
-namespace DBus
-{
-
-namespace ServerEvents
-{
+namespace DPL {
+namespace DBus {
+namespace ServerEvents {
/**
* Emitted when new connection is accepted.
*
*/
class Server : public DPL::Event::EventSupport<ServerEvents::NewConnectionEvent>
{
-public:
+ public:
/**
* Creates server.
*
*/
void stop();
-protected:
+ protected:
explicit Server(GDBusServer* server);
-private:
+ private:
static gboolean onNewConnection(GDBusServer* server,
GDBusConnection* connection,
gpointer data);
GDBusServer* m_server;
};
-
}
}
#include <dpl/dbus/exception.h>
#include <dpl/dbus/object_proxy.h>
-namespace DPL
-{
-namespace DBus
-{
-
+namespace DPL {
+namespace DBus {
ConnectionPtr Connection::sessionBus()
{
return connectTo(G_BUS_TYPE_SESSION);
GDBusConnection* connection = g_bus_get_sync(busType,
NULL,
&error);
- if (NULL == connection)
- {
+ if (NULL == connection) {
std::string message;
- if (NULL != error)
- {
+ if (NULL != error) {
message = error->message;
g_error_free(error);
}
GError* error = NULL;
GDBusConnection* connection = g_dbus_connection_new_for_address_sync(
- address.c_str(),
- G_DBUS_CONNECTION_FLAGS_NONE,
- NULL,
- NULL,
- &error);
- if (NULL == connection)
- {
+ address.c_str(),
+ G_DBUS_CONNECTION_FLAGS_NONE,
+ NULL,
+ NULL,
+ &error);
+ if (NULL == connection) {
std::string message;
- if (NULL != error)
- {
+ if (NULL != error) {
message = error->message;
g_error_free(error);
}
return ConnectionPtr(new Connection(connection));
}
-Connection::Connection(GDBusConnection* connection)
- : m_connection(connection)
+Connection::Connection(GDBusConnection* connection) :
+ m_connection(connection)
{
g_signal_connect(m_connection,
"closed",
{
std::for_each(m_registeredServices.begin(),
m_registeredServices.end(),
- [] (const RegisteredServices::value_type& value)
+ [] (const RegisteredServices::value_type & value)
{
g_bus_unown_name(value.second);
});
std::for_each(m_registeredObjects.begin(),
m_registeredObjects.end(),
- [m_connection] (const RegisteredObjects::value_type& value)
+ [this] (const RegisteredObjects::value_type & value)
{
g_dbus_connection_unregister_object(
- m_connection,
- value.second.registrationId);
+ m_connection,
+ value.second.registrationId);
});
- if (!g_dbus_connection_is_closed(m_connection))
- {
+ if (!g_dbus_connection_is_closed(m_connection)) {
GError* error = NULL;
- if (FALSE == g_dbus_connection_flush_sync(m_connection, NULL, &error))
+ if (FALSE ==
+ g_dbus_connection_flush_sync(m_connection, NULL, &error))
{
LogPedantic("Could not flush the connection"
- << " <" << error->message << ">");
+ << " <" << error->message << ">");
g_error_free(error);
}
}
onServiceNameLost,
this,
NULL);
- if (0 >= regId)
- {
+ if (0 >= regId) {
ThrowMsg(DBus::Exception, "Error while registering service.");
}
void Connection::unregisterService(const std::string& serviceName)
{
auto it = m_registeredServices.find(serviceName);
- if (m_registeredServices.end() == it)
- {
+ if (m_registeredServices.end() == it) {
ThrowMsg(DBus::Exception, "Service not registered.");
}
GError* error = NULL;
guint regId = g_dbus_connection_register_object(
- m_connection,
- object->getPath().c_str(),
- object->getInterface()->getInfo(),
- object->getInterface()->getVTable(),
- // TODO This is ugly, fix this!
- object->getInterface().get(),
- NULL,
- &error);
- if (0 == regId)
- {
+ m_connection,
+ object->getPath().c_str(),
+ object->getInterface()->getInfo(),
+ object->getInterface()->getVTable(),
+ // TODO This is ugly, fix this!
+ object->getInterface().get(),
+ NULL,
+ &error);
+ if (0 == regId) {
std::string message;
- if (NULL != error)
- {
+ if (NULL != error) {
message = error->message;
LogPedantic(error->message << " " << error->code);
g_error_free(error);
}
ThrowMsg(DBus::Exception, "Error while registering an object: "
- << message);
+ << message);
}
m_registeredObjects.insert(RegisteredObjects::value_type(
- object->getPath(),
- ObjectRegistration(regId, object)));
+ object->getPath(),
+ ObjectRegistration(regId, object)));
}
void Connection::unregisterObject(const std::string& objectPath)
{
auto it = m_registeredObjects.find(objectPath);
- if (m_registeredObjects.end() == it)
- {
+ if (m_registeredObjects.end() == it) {
ThrowMsg(DBus::Exception, "Object not registered.");
}
gboolean result = g_dbus_connection_unregister_object(
- m_connection,
- it->second.registrationId);
- if (FALSE == result)
- {
+ m_connection,
+ it->second.registrationId);
+ if (FALSE == result) {
ThrowMsg(DBus::Exception, "Unregistering object failed.");
}
m_registeredObjects.erase(it);
ObjectProxyPtr Connection::createObjectProxy(const std::string& serviceName,
const std::string& objectPath)
{
- if (g_dbus_connection_is_closed(m_connection))
- {
+ if (g_dbus_connection_is_closed(m_connection)) {
ThrowMsg(DBus::ConnectionClosedException, "Connection closed.");
}
return ObjectProxyPtr(
- new ObjectProxy(m_connection, serviceName, objectPath));
+ new ObjectProxy(m_connection, serviceName, objectPath));
}
void Connection::onServiceNameAcquired(GDBusConnection* /*connection*/,
LogPedantic("Emitting service name acquired event: " << serviceName);
ConnectionEvents::ServiceNameAcquiredEvent event(serviceName);
- self->DPL::Event::EventSupport<ConnectionEvents::ServiceNameAcquiredEvent>::
- EmitEvent(event, DPL::Event::EmitMode::Queued);
+ self->DPL::Event::EventSupport<ConnectionEvents::ServiceNameAcquiredEvent>
+ ::
+ EmitEvent(event, DPL::Event::EmitMode::Queued);
}
void Connection::onServiceNameLost(GDBusConnection* /*connection*/,
ConnectionEvents::ServiceNameLostEvent event(serviceName);
self->DPL::Event::EventSupport<ConnectionEvents::ServiceNameLostEvent>::
- EmitEvent(event, DPL::Event::EmitMode::Queued);
+ EmitEvent(event, DPL::Event::EmitMode::Queued);
}
void Connection::onConnectionClosed(GDBusConnection* /*connection*/,
Connection* self = static_cast<Connection*>(data);
- if ((NULL == error) && (FALSE == peerVanished))
- {
+ if ((NULL == error) && (FALSE == peerVanished)) {
// Connection closed by this.
- }
- else if (NULL != error)
- {
+ } else if (NULL != error) {
std::string message = error->message;
g_error_free(error);
- if (TRUE == peerVanished)
- {
+ if (TRUE == peerVanished) {
// Connection closed by remote host.
ConnectionEvents::ConnectionBrokenEvent event(message);
- self->DPL::Event::EventSupport<ConnectionEvents::ConnectionBrokenEvent>::
- EmitEvent(event, DPL::Event::EmitMode::Queued);
- }
- else
- {
+ self->DPL::Event::EventSupport<ConnectionEvents::
+ ConnectionBrokenEvent>::
+ EmitEvent(event, DPL::Event::EmitMode::Queued);
+ } else {
// Invalid or malformed data on connection.
ConnectionEvents::ConnectionInvalidEvent event(message);
- self->DPL::Event::EventSupport<ConnectionEvents::ConnectionInvalidEvent>::
- EmitEvent(event, DPL::Event::EmitMode::Queued);
+ self->DPL::Event::EventSupport<ConnectionEvents::
+ ConnectionInvalidEvent>::
+ EmitEvent(event, DPL::Event::EmitMode::Queued);
}
}
}
-
}
}
#include <stddef.h>
#include <dpl/dbus/dispatcher.h>
-namespace DPL
-{
-namespace DBus
-{
-
+namespace DPL {
+namespace DBus {
Dispatcher::~Dispatcher() { }
GVariant* Dispatcher::onPropertyGet(GDBusConnection* /*connection*/,
{
return false;
}
-
}
}
namespace DPL {
namespace DBus {
-
-const GDBusInterfaceVTable Interface::m_vTable =
-{
+const GDBusInterfaceVTable Interface::m_vTable = {
Interface::onMethodCallFunc,
Interface::onPropertyGetFunc,
Interface::onPropertySetFunc,
- {0, 0, 0, 0, 0, 0, 0, 0}
+ { 0, 0, 0, 0, 0, 0, 0, 0 }
};
std::vector<InterfacePtr> Interface::fromXMLString(const std::string& xmlString)
GDBusNodeInfo* nodeInfo = g_dbus_node_info_new_for_xml(xmlString.c_str(),
&error);
- if (NULL == nodeInfo)
- {
+ if (NULL == nodeInfo) {
std::string message;
- if (NULL != error)
- {
+ if (NULL != error) {
message = error->message;
g_error_free(error);
}
std::vector<InterfacePtr> result;
GDBusInterfaceInfo** interface = nodeInfo->interfaces;
- while (NULL != *interface)
- {
+ while (NULL != *interface) {
result.push_back(InterfacePtr(new Interface(*interface)));
++interface;
}
return result;
}
-Interface::Interface(GDBusInterfaceInfo* info)
- : m_info(info)
+Interface::Interface(GDBusInterfaceInfo* info) :
+ m_info(info)
{
g_dbus_interface_info_ref(m_info);
}
// TODO Verify interface name.
- if (NULL != self->m_dispatcher)
- {
- try
- {
+ if (NULL != self->m_dispatcher) {
+ try {
self->m_dispatcher->onMethodCall(connection,
sender,
objectPath,
methodName,
parameters,
invocation);
- }
- catch (const DPL::Exception& /*ex*/)
- {
+ } catch (const DPL::Exception& /*ex*/) {
// TODO Support for errors.
}
}
// TODO Verify interface name.
- if (NULL != self->m_dispatcher)
- {
- try
- {
+ if (NULL != self->m_dispatcher) {
+ try {
// TODO Check if NULL is returned, if so set error variable.
return self->m_dispatcher->onPropertyGet(connection,
sender,
interfaceName,
propertyName,
error);
- }
- catch (const DPL::Exception& /*ex*/)
- {
+ } catch (const DPL::Exception& /*ex*/) {
// TODO Support for errors.
}
}
// TODO Verify interface name.
- if (NULL != self->m_dispatcher)
- {
- try
- {
+ if (NULL != self->m_dispatcher) {
+ try {
return self->m_dispatcher->onPropertySet(connection,
sender,
objectPath,
propertyName,
value,
error);
- }
- catch (const DPL::Exception& /*ex*/)
- {
+ } catch (const DPL::Exception& /*ex*/) {
// TODO Support for errors.
}
}
return false;
}
-
}
}
namespace DPL {
namespace DBus {
-
ObjectPtr Object::create(const std::string& path, const InterfacePtr& interface)
{
return ObjectPtr(new Object(path, interface));
return m_interface;
}
-Object::Object(const std::string& path, const InterfacePtr& interface)
- : m_path(path),
- m_interface(interface)
-{
-}
-
+Object::Object(const std::string& path, const InterfacePtr& interface) :
+ m_path(path),
+ m_interface(interface)
+{}
}
}
\ No newline at end of file
namespace DPL {
namespace DBus {
-
ObjectProxy::ObjectProxy(GDBusConnection* connection,
const std::string& serviceName,
- const std::string& objectPath)
- : m_connection(connection),
- m_serviceName(serviceName),
- m_objectPath(objectPath)
+ const std::string& objectPath) :
+ m_connection(connection),
+ m_serviceName(serviceName),
+ m_objectPath(objectPath)
{
g_object_ref(m_connection);
}
{
g_object_unref(m_connection);
}
-
}
}
\ No newline at end of file
namespace DPL {
namespace DBus {
-
ServerPtr Server::create(const std::string& address)
{
GError* error = NULL;
int flags = G_DBUS_SERVER_FLAGS_NONE |
- G_DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS;
+ G_DBUS_SERVER_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS;
gchar* serverId = g_dbus_generate_guid();
GDBusServer* server = g_dbus_server_new_sync(
- address.c_str(),
- static_cast<GDBusServerFlags>(flags),
- serverId,
- NULL,
- NULL,
- &error);
+ address.c_str(),
+ static_cast<GDBusServerFlags>(flags),
+ serverId,
+ NULL,
+ NULL,
+ &error);
g_free(serverId);
- if (NULL == server)
- {
+ if (NULL == server) {
std::string message;
- if (NULL != error)
- {
+ if (NULL != error) {
message = error->message;
g_error_free(error);
}
return ServerPtr(new Server(server));
}
-Server::Server(GDBusServer* server)
- : m_server(server)
-{
-}
+Server::Server(GDBusServer* server) :
+ m_server(server)
+{}
Server::~Server()
{
- if (g_dbus_server_is_active(m_server))
- {
+ if (g_dbus_server_is_active(m_server)) {
stop();
}
g_object_unref(m_server);
Server* self = static_cast<Server*>(data);
ServerEvents::NewConnectionEvent event(
- ConnectionPtr(new Connection(connection)));
+ ConnectionPtr(new Connection(connection)));
LogInfo("Emitting new connection event");
// TODO Blocking to allow object registration before any DBus messages are
// processed.
self->DPL::Event::EventSupport<ServerEvents::NewConnectionEvent>::
- EmitEvent(event, DPL::Event::EmitMode::Blocking);
+ EmitEvent(event, DPL::Event::EmitMode::Blocking);
return TRUE;
}
-
}
}
extern char** calculate(char*pappId, int idLen, int keyLen);
-namespace WRTDecryptor{
+namespace WRTDecryptor {
class ResourceDecryptor
{
public:
- class Exception
- {
- public:
- DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
- DECLARE_EXCEPTION_TYPE(Base, GetDecKeyFailed)
- DECLARE_EXCEPTION_TYPE(Base, EncryptionFailed)
- };
-
- ResourceDecryptor();
- ResourceDecryptor(std::string userKey);
- virtual ~ResourceDecryptor();
-
- void SetDecryptionKey(std::string userKey);
- void GetDecryptedChunk(unsigned char* inBuf, unsigned char* decBuf, size_t chunkSize);
+ class Exception
+ {
+ public:
+ DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
+ DECLARE_EXCEPTION_TYPE(Base, GetDecKeyFailed)
+ DECLARE_EXCEPTION_TYPE(Base, EncryptionFailed)
+ };
+
+ ResourceDecryptor();
+ ResourceDecryptor(std::string userKey);
+ virtual ~ResourceDecryptor();
+
+ void SetDecryptionKey(std::string userKey);
+ void GetDecryptedChunk(unsigned char* inBuf,
+ unsigned char* decBuf,
+ size_t chunkSize);
private:
- AES_KEY* GetDecryptionKey();
- AES_KEY m_decKey;
-
+ AES_KEY* GetDecryptionKey();
+ AES_KEY m_decKey;
};
-} //namespace WRTDecryptor
+} //namespace WRTDecryptor
#endif /* RESOURCE_DECRYPTION_H */
extern char** calculate(char*pappId, int idLen, int keyLen);
-namespace WRTEncryptor{
+namespace WRTEncryptor {
class ResourceEncryptor
{
public:
- class Exception
- {
- public:
- DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
- DECLARE_EXCEPTION_TYPE(DPL::Exception, CreateEncKeyFailed)
- DECLARE_EXCEPTION_TYPE(DPL::Exception, CreateDecKeyFailed)
- DECLARE_EXCEPTION_TYPE(DPL::Exception, CreateEncKeyFileFailed)
- DECLARE_EXCEPTION_TYPE(DPL::Exception, CreateDecKeyFileFailed)
- DECLARE_EXCEPTION_TYPE(DPL::Exception, EncryptionFailed)
- };
+ class Exception
+ {
+ public:
+ DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
+ DECLARE_EXCEPTION_TYPE(DPL::Exception, CreateEncKeyFailed)
+ DECLARE_EXCEPTION_TYPE(DPL::Exception, CreateDecKeyFailed)
+ DECLARE_EXCEPTION_TYPE(DPL::Exception, CreateEncKeyFileFailed)
+ DECLARE_EXCEPTION_TYPE(DPL::Exception, CreateDecKeyFileFailed)
+ DECLARE_EXCEPTION_TYPE(DPL::Exception, EncryptionFailed)
+ };
- ResourceEncryptor();
- virtual ~ResourceEncryptor();
+ ResourceEncryptor();
+ virtual ~ResourceEncryptor();
- int GetBlockSize(int inSize);
- void CreateEncryptionKey(std::string userKey);
- void EncryptChunk(unsigned char* inputBuf, unsigned char* encBuf, size_t
- chunkSize);
+ int GetBlockSize(int inSize);
+ void CreateEncryptionKey(std::string userKey);
+ void EncryptChunk(unsigned char* inputBuf, unsigned char* encBuf, size_t
+ chunkSize);
private:
- AES_KEY GetEncryptionkey();
- AES_KEY m_encKey;
+ AES_KEY GetEncryptionkey();
+ AES_KEY m_encKey;
};
} //namespace WRTEncryptor
#include <string>
#include <dpl/log/log.h>
#include <dpl/exception.h>
+#include <dukgen.h>
namespace {
#define BITS_SIZE 128
#define KEY_SIZE 16
}
-namespace WRTDecryptor{
+namespace WRTDecryptor {
ResourceDecryptor::ResourceDecryptor()
{
LogDebug("Started Decryption");
}
-ResourceDecryptor::ResourceDecryptor(std::string userKey)
+ResourceDecryptor::ResourceDecryptor(std::string userKey)
{
LogDebug("Finished Decryption");
SetDecryptionKey(userKey);
}
ResourceDecryptor::~ResourceDecryptor()
-{
-}
+{}
void ResourceDecryptor::SetDecryptionKey(std::string userKey)
{
return;
}
- char **duk = calculate(const_cast<char*>(userKey.c_str()), userKey.size(), KEY_SIZE);
- unsigned char *key = reinterpret_cast<unsigned char*>(*duk);
+ char* pKey = GetDeviceUniqueKey(const_cast<char*>(userKey.c_str()),
+ userKey.size(), KEY_SIZE);
- if ( 0 > AES_set_decrypt_key(key, BITS_SIZE, &m_decKey)) {
+ unsigned char *key = reinterpret_cast<unsigned char*>(pKey);
+
+ if (0 > AES_set_decrypt_key(key, BITS_SIZE, &m_decKey)) {
ThrowMsg(ResourceDecryptor::Exception::GetDecKeyFailed,
- "Failed to create decryption key");
+ "Failed to create decryption key");
}
}
}
void ResourceDecryptor::GetDecryptedChunk(unsigned char*
- inBuf, unsigned char* decBuf, size_t inBufSize)
+ inBuf,
+ unsigned char* decBuf,
+ size_t inBufSize)
{
Assert(decBuf);
if (decBuf == NULL) {
ThrowMsg(ResourceDecryptor::Exception::EncryptionFailed,
- "Failed to Get Decryption Chunk");
+ "Failed to Get Decryption Chunk");
}
- unsigned char ivec[16] = {0, };
+ unsigned char ivec[16] = { 0, };
AES_cbc_encrypt(inBuf, decBuf, inBufSize, &m_decKey, ivec, AES_DECRYPT);
LogDebug("Success decryption");
}
-
} //namespace WRTDecryptor
#include <fcntl.h>
#include <dpl/log/log.h>
+#include <dukgen.h>
namespace {
#define BITS_SIZE 128
#define KEY_SIZE 16
}
-namespace WRTEncryptor{
+namespace WRTEncryptor {
ResourceEncryptor::ResourceEncryptor()
{
LogDebug("Started Encrytion");
int ResourceEncryptor::GetBlockSize(int inSize)
{
if ((inSize % AES_BLOCK_SIZE) != 0) {
- return (( inSize/ AES_BLOCK_SIZE) +1) * AES_BLOCK_SIZE;
+ return (( inSize / AES_BLOCK_SIZE) + 1) * AES_BLOCK_SIZE;
}
return inSize;
}
return;
}
- char **duk = calculate(const_cast<char*>(userKey.c_str()), userKey.size(), KEY_SIZE);
- unsigned char *key = reinterpret_cast<unsigned char*>(*duk);
+ char* pKey = GetDeviceUniqueKey(const_cast<char*>(userKey.c_str()),
+ userKey.size(), KEY_SIZE);
+ unsigned char *key = reinterpret_cast<unsigned char*>(pKey);
- if ( 0 > AES_set_encrypt_key(key, BITS_SIZE, &m_encKey)) {
+ if (0 > AES_set_encrypt_key(key, BITS_SIZE, &m_encKey)) {
ThrowMsg(ResourceEncryptor::Exception::CreateEncKeyFailed,
- "Failed to create encryption key");
+ "Failed to create encryption key");
}
LogDebug("Success to create ecryption and decryption key");
}
}
void ResourceEncryptor::EncryptChunk(unsigned char*
- inputBuf, unsigned char* encBuf, size_t chunkSize)
+ inputBuf,
+ unsigned char* encBuf,
+ size_t chunkSize)
{
Assert(inputBuf);
Assert(encBuf);
- unsigned char ivec[16] = {0, };
+ unsigned char ivec[16] = { 0, };
AES_cbc_encrypt(inputBuf, encBuf, chunkSize, &m_encKey, ivec, AES_ENCRYPT);
}
#include <dpl/noncopyable.h>
-namespace DPL
+namespace DPL {
+namespace Event {
+class AbstractEventCall :
+ private Noncopyable
{
-namespace Event
-{
-
-
-class AbstractEventCall
- : private Noncopyable
-{
-public:
+ public:
/**
* Constructor
*/
*/
virtual void Call() = 0;
};
-
}
} // namespace DPL
* @file abstract_event_dispatcher.h
* @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
* @version 1.0
- * @brief This file is the implementation file of abstract event dispatcher
+ * @brief This file is the implementation file of abstract event
+ * dispatcher
*/
#ifndef DPL_ABSTRACT_EVENT_DISPATCHER_H
#define DPL_ABSTRACT_EVENT_DISPATCHER_H
#include <dpl/event/abstract_event_call.h>
#include <dpl/noncopyable.h>
-namespace DPL
+namespace DPL {
+namespace Event {
+class AbstractEventDispatcher :
+ private Noncopyable
{
-namespace Event
-{
-
-class AbstractEventDispatcher
- : private Noncopyable
-{
-public:
+ public:
/**
* Constructor
*/
* @param[in] dueTime Due time for timed event in seconds
* @return none
*/
- virtual void AddTimedEventCall(AbstractEventCall *abstractEventCall, double dueTime) = 0;
+ virtual void AddTimedEventCall(AbstractEventCall *abstractEventCall,
+ double dueTime) = 0;
};
-
}
} // namespace DPL
#include <dpl/thread.h>
#include <dpl/assert.h>
-namespace DPL
-{
-namespace Event
-{
-
+namespace DPL {
+namespace Event {
template<typename EventType>
-class ControllerEventHandler
- : public EventListener<EventType>,
- private EventSupport<EventType>
+class ControllerEventHandler :
+ public EventListener<EventType>,
+ private EventSupport<EventType>
{
-private:
+ private:
bool m_touched;
-public:
- ControllerEventHandler()
- : m_touched(false)
+ public:
+ ControllerEventHandler() :
+ m_touched(false)
{
EventSupport<EventType>::AddListener(this);
}
void PostEvent(const EventType &event)
{
- Assert(m_touched && "Default context not inherited. Call Touch() to inherit one.");
+ Assert(
+ m_touched &&
+ "Default context not inherited. Call Touch() to inherit one.");
EventSupport<EventType>::EmitEvent(event, EmitMode::Queued);
}
void PostTimedEvent(const EventType &event, double dueTime)
{
- Assert(m_touched && "Default context not inherited. Call Touch() to inherit one.");
+ Assert(
+ m_touched &&
+ "Default context not inherited. Call Touch() to inherit one.");
EventSupport<EventType>::EmitEvent(event, EmitMode::Deffered, dueTime);
}
void PostSyncEvent(const EventType &event)
{
- Assert(m_touched && "Default context not inherited. Call Touch() to inherit one.");
+ Assert(
+ m_touched &&
+ "Default context not inherited. Call Touch() to inherit one.");
// Check calling context
EventSupport<EventType>::EmitEvent(event, EmitMode::Blocking);
void SwitchToThread(Thread *thread)
{
- Assert(m_touched && "Default context not inherited. Call Touch() to inherit one.");
+ Assert(
+ m_touched &&
+ "Default context not inherited. Call Touch() to inherit one.");
EventSupport<EventType>::SwitchListenerToThread(this, thread);
}
void Touch()
{
m_touched = true;
- EventSupport<EventType>::SwitchListenerToThread(this, Thread::GetCurrentThread());
+ EventSupport<EventType>::SwitchListenerToThread(
+ this,
+ Thread::
+ GetCurrentThread());
}
};
template<typename EventTypeList>
-class Controller
- : public Controller<typename EventTypeList::Tail>,
- public ControllerEventHandler<typename EventTypeList::Head>
+class Controller :
+ public Controller<typename EventTypeList::Tail>,
+ public ControllerEventHandler<typename EventTypeList::Head>
{
-public:
+ public:
typedef typename EventTypeList::Head EventType;
-public:
+ public:
Controller()
- {
- }
+ {}
virtual ~Controller()
- {
- }
+ {}
virtual void SwitchToThread(Thread *thread)
{
template<>
class Controller<TypeListDecl<>::Type>
{
-public:
+ public:
Controller()
- {
- }
+ {}
virtual ~Controller()
- {
- }
+ {}
virtual void SwitchToThread(Thread *thread)
{
}
virtual void Touch()
- {
- }
+ {}
};
-
}
} // namespace DPL
// Utilities
-#define CONTROLLER_POST_EVENT(Name, EventArg) Name##Singleton::Instance().DPL::Event::ControllerEventHandler<__typeof__ EventArg>::PostEvent(EventArg)
-#define CONTROLLER_POST_TIMED_EVENT(Name, EventArg, DueTime) Name##Singleton::Instance().DPL::Event::ControllerEventHandler<__typeof__ EventArg>::PostTimedEvent(EventArg, DueTime)
-#define CONTROLLER_POST_SYNC_EVENT(Name, EventArg) Name##Singleton::Instance().DPL::Event::ControllerEventHandler<__typeof__ EventArg>::PostSyncEvent(EventArg)
+#define CONTROLLER_POST_EVENT(Name, \
+ EventArg) Name##Singleton::Instance().DPL::Event \
+ ::ControllerEventHandler< \
+ __typeof__ EventArg>::PostEvent(EventArg)
+#define CONTROLLER_POST_TIMED_EVENT(Name, EventArg, \
+ DueTime) Name##Singleton::Instance().DPL:: \
+ Event::ControllerEventHandler< \
+ __typeof__ EventArg>::PostTimedEvent(EventArg, DueTime)
+#define CONTROLLER_POST_SYNC_EVENT(Name, \
+ EventArg) Name##Singleton::Instance().DPL:: \
+ Event::ControllerEventHandler< \
+ __typeof__ EventArg>::PostSyncEvent(EventArg)
#endif // DPL_CONTROLLER_H
#include <dpl/noncopyable.h>
-namespace DPL
-{
-namespace Event
-{
-
+namespace DPL {
+namespace Event {
template<typename EventType>
-class EventListener
- : private Noncopyable
+class EventListener :
+ private Noncopyable
{
-public:
+ public:
EventListener()
- {
- }
+ {}
virtual ~EventListener()
- {
- }
+ {}
virtual void OnEventReceived(const EventType &event) = 0;
};
-
}
} // namespace DPL
#include <map>
#include <list>
-namespace DPL
-{
-namespace Event
-{
-namespace EmitMode
-{
+namespace DPL {
+namespace Event {
+namespace EmitMode {
enum Type
{
Auto, ///< If calling thread is the same as receiver's use
} // namespace EmitMode
template<typename EventType>
-class EventSupport
- : private Noncopyable
+class EventSupport :
+ private Noncopyable
{
-public:
+ public:
typedef EventSupport<EventType> EventSupportType;
typedef EventListener<EventType> EventListenerType;
class EventSupportData; // Forward declaration
typedef EventSupportData *EventSupportDataPtr;
-private:
+ private:
typedef typename GenericEventCall<EventType, EventSupportDataPtr>::
template Rebind<EventType, EventSupportDataPtr>::
- Other GenericEventCallType;
+ Other GenericEventCallType;
// Event listener list
typedef std::map<EventListenerType *, Thread *> EventListenerList;
// Events list mutex
Mutex m_eventListMutex;
-public:
+ public:
class EventSupportData
{
- private:
+ private:
typedef void (EventSupportType::*ReceiveAbstractEventCallMethod)(
const EventType &event,
EventListenerType *eventListener,
Mutex m_dataMutex;
- public:
+ public:
EventSupportData(EventSupportType *support,
ReceiveAbstractEventCallMethod method,
- WaitableEvent *synchronization)
- : m_eventSupport(support),
- m_method(method),
- m_synchronization(synchronization)
- {
- }
+ WaitableEvent *synchronization) :
+ m_eventSupport(support),
+ m_method(method),
+ m_synchronization(synchronization)
+ {}
~EventSupportData()
{
Mutex::ScopedLock lock(&m_dataMutex);
- if (!m_eventSupport)
- {
+ if (!m_eventSupport) {
LogPedantic("EventSupport for this call does not exist");
return;
}
{
Mutex::ScopedLock lock(&m_dataMutex);
- if (m_eventSupport != NULL)
- {
+ if (m_eventSupport != NULL) {
(*m_eventSupport.*m_method)(event,
listener,
delegate,
m_synchronization);
- }
- else
- {
+ } else {
LogPedantic("EventSupport for this call does not "
"exist anymore. Ignored.");
}
}
};
-private:
+ private:
GenericEventCallType *RegisterEventCall(const EventType &event,
EventListenerType *eventListener,
DelegateType delegate,
}
UNHANDLED_EXCEPTION_HANDLER_END
- --m_guardedCallInProgress;
+ -- m_guardedCallInProgress;
LogPedantic("Guarded event listener finished");
}
}
UNHANDLED_EXCEPTION_HANDLER_END
- --m_guardedCallInProgress;
+ -- m_guardedCallInProgress;
LogPedantic("Guarded delegate call finished");
}
Thread *targetThread;
// Listener might have been removed, ensure that it still exits
- if (eventListener != NULL)
- {
+ if (eventListener != NULL) {
Mutex::ScopedLock lock(&m_listenerDelegateMutex);
typename EventListenerList::iterator iterator =
m_eventListenerList.find(eventListener);
- if (iterator == m_eventListenerList.end())
- {
+ if (iterator == m_eventListenerList.end()) {
LogPedantic("Abstract event call listener disappeared."
"Event ignored.");
// Even though, synchronize caller if needed
- if (synchronization != NULL)
+ if (synchronization != NULL) {
synchronization->Signal();
+ }
return;
}
// Get target thread id
targetThread = iterator->second;
- }
- else
- {
+ } else {
// Delegate might have been removed, ensure that it still exits
Mutex::ScopedLock lock(&m_listenerDelegateMutex);
typename DelegateList::iterator iterator =
m_delegateList.find(delegate);
- if (iterator == m_delegateList.end())
- {
+ if (iterator == m_delegateList.end()) {
LogPedantic("Abstract event call delegate disappeared."
"Event ignored.");
// Even though, synchronize caller if needed
- if (synchronization != NULL)
+ if (synchronization != NULL) {
synchronization->Signal();
+ }
return;
}
}
// Ensure that we are now in proper thread now
- if (targetThread != Thread::GetCurrentThread())
- {
+ if (targetThread != Thread::GetCurrentThread()) {
LogPedantic("Detected event dispatching ping-pong scenario");
// Retry if it was not synchronized
- if (synchronization == NULL)
- {
+ if (synchronization == NULL) {
// Cheat with event delivery
EmitEvent(event, EmitMode::Queued);
LogPedantic("Ping-Pong: Resent as queued event");
- }
- else
- {
+ } else {
// There is a problem
- // Developer did something nasty, and we will not clean up his mess
+ // Developer did something nasty, and we will not clean up his
+ // mess
synchronization->Signal();
LogPedantic("### Ping-Pong: Failed to deliver synchronized"
}
// Guard listener code for exceptions
- if (eventListener != NULL)
+ if (eventListener != NULL) {
GuardedEventCall(event, eventListener);
- else
+ } else {
GuardedEventCall(event, delegate);
+ }
// Release caller if synchronizing
- if (synchronization != NULL)
+ if (synchronization != NULL) {
synchronization->Signal();
+ }
}
-protected:
+ protected:
void EmitEvent(const EventType &event,
EmitMode::Type mode = EmitMode::Queued,
double dueTime = 0.0)
new Mutex::ScopedLock(&m_listenerDelegateMutex));
// Show some info
- switch (mode)
- {
- case EmitMode::Auto:
- LogPedantic("Emitting AUTO event...");
- break;
+ switch (mode) {
+ case EmitMode::Auto:
+ LogPedantic("Emitting AUTO event...");
+ break;
- case EmitMode::Queued:
- LogPedantic("Emitting QUEUED event...");
- break;
+ case EmitMode::Queued:
+ LogPedantic("Emitting QUEUED event...");
+ break;
- case EmitMode::Blocking:
- LogPedantic("Emitting BLOCKING event...");
- break;
+ case EmitMode::Blocking:
+ LogPedantic("Emitting BLOCKING event...");
+ break;
- case EmitMode::Deffered:
- LogPedantic("Emitting DEFFERED event...");
- break;
+ case EmitMode::Deffered:
+ LogPedantic("Emitting DEFFERED event...");
+ break;
- default:
- break;
+ default:
+ break;
}
// In some configurations there is a barrier
// Switch to proper dispatcher and emit event
AbstractEventDispatcher *dispatcher = NULL;
- if (iterator->second == NULL)
- {
+ if (iterator->second == NULL) {
// Send to main thread
LogPedantic("Sending event to main dispatcher");
dispatcher = &GetMainEventDispatcherInstance();
- }
- else
- {
+ } else {
// Setup thread dispatcher, and send to proper thread
LogPedantic("Sending event to thread dispatcher");
m_threadEventDispatcher.SetThread(iterator->second);
WaitableEvent *synchronization;
// TODO: Pool synchronization objects
- switch (mode)
- {
- case EmitMode::Auto:
- // Check thread
- if (iterator->second == Thread::GetCurrentThread())
- {
- // Guard listener code for exceptions
- GuardedEventCall(event, iterator->first);
- }
- else
- {
- // Handle non-synchronized event
- dispatcher->AddEventCall(
- RegisterEventCall(event, iterator->first,
- DelegateType(), NULL));
- }
- break;
-
- case EmitMode::Queued:
+ switch (mode) {
+ case EmitMode::Auto:
+ // Check thread
+ if (iterator->second == Thread::GetCurrentThread()) {
+ // Guard listener code for exceptions
+ GuardedEventCall(event, iterator->first);
+ } else {
// Handle non-synchronized event
dispatcher->AddEventCall(
RegisterEventCall(event, iterator->first,
DelegateType(), NULL));
+ }
+ break;
- break;
-
- case EmitMode::Blocking:
- // Check thread
- if (iterator->second == Thread::GetCurrentThread())
- {
- // Guard listener code for exceptions
- GuardedEventCall(event, iterator->first);
- }
- else
- {
- // New synchronization object is needed
- synchronization = new WaitableEvent();
-
- // Handle synchronized event
- dispatcher->AddEventCall(
- RegisterEventCall(event, iterator->first,
- DelegateType(), synchronization));
-
- // Add to barrier
- synchronizationBarrier.push_back(synchronization);
- }
- break;
-
- case EmitMode::Deffered:
- // Handle deffered events
- Assert(dueTime >= 0.0 && "Due time must be non-negative");
-
- dispatcher->AddTimedEventCall(
+ case EmitMode::Queued:
+ // Handle non-synchronized event
+ dispatcher->AddEventCall(
+ RegisterEventCall(event, iterator->first,
+ DelegateType(), NULL));
+
+ break;
+
+ case EmitMode::Blocking:
+ // Check thread
+ if (iterator->second == Thread::GetCurrentThread()) {
+ // Guard listener code for exceptions
+ GuardedEventCall(event, iterator->first);
+ } else {
+ // New synchronization object is needed
+ synchronization = new WaitableEvent();
+
+ // Handle synchronized event
+ dispatcher->AddEventCall(
RegisterEventCall(event, iterator->first,
- DelegateType(), NULL), dueTime);
+ DelegateType(), synchronization));
+
+ // Add to barrier
+ synchronizationBarrier.push_back(synchronization);
+ }
+ break;
+
+ case EmitMode::Deffered:
+ // Handle deffered events
+ Assert(dueTime >= 0.0 && "Due time must be non-negative");
- break;
+ dispatcher->AddTimedEventCall(
+ RegisterEventCall(event, iterator->first,
+ DelegateType(), NULL), dueTime);
+
+ break;
- default:
- Assert("Invalid emit mode");
+ default:
+ Assert("Invalid emit mode");
}
}
// Switch to proper dispatcher and emit event
AbstractEventDispatcher *dispatcher = NULL;
- if (iterator->second == NULL)
- {
+ if (iterator->second == NULL) {
// Send to main thread
LogPedantic("Sending event to main dispatcher");
dispatcher = &GetMainEventDispatcherInstance();
- }
- else
- {
+ } else {
// Setup thread dispatcher, and send to proper thread
LogPedantic("Sending event to thread dispatcher");
m_threadEventDispatcher.SetThread(iterator->second);
WaitableEvent *synchronization;
// TODO: Pool synchronization objects
- switch (mode)
- {
- case EmitMode::Auto:
- // Check thread
- if (iterator->second == Thread::GetCurrentThread())
- {
- // Guard listener code for exceptions
- GuardedEventCall(event, iterator->first);
- }
- else
- {
- // Handle non-synchronized event
- dispatcher->AddEventCall(
- RegisterEventCall(event,
- NULL,
- iterator->first,
- NULL));
- }
- break;
-
- case EmitMode::Queued:
+ switch (mode) {
+ case EmitMode::Auto:
+ // Check thread
+ if (iterator->second == Thread::GetCurrentThread()) {
+ // Guard listener code for exceptions
+ GuardedEventCall(event, iterator->first);
+ } else {
// Handle non-synchronized event
dispatcher->AddEventCall(
RegisterEventCall(event,
NULL,
iterator->first,
NULL));
+ }
+ break;
+
+ case EmitMode::Queued:
+ // Handle non-synchronized event
+ dispatcher->AddEventCall(
+ RegisterEventCall(event,
+ NULL,
+ iterator->first,
+ NULL));
- break;
-
- case EmitMode::Blocking:
- // Check thread
- if (iterator->second == Thread::GetCurrentThread())
- {
- // Guard listener code for exceptions
- GuardedEventCall(event, iterator->first);
- }
- else
- {
- // New synchronization object is needed
- synchronization = new WaitableEvent();
-
- // Handle synchronized event
- dispatcher->AddEventCall(
- RegisterEventCall(event,
- NULL,
- iterator->first,
- synchronization));
-
- // Add to barrier
- synchronizationBarrier.push_back(synchronization);
- }
- break;
-
- case EmitMode::Deffered:
- // Handle deffered events
- Assert(dueTime >= 0.0 && "Due time must be non-negative");
-
- dispatcher->AddTimedEventCall(
+ break;
+
+ case EmitMode::Blocking:
+ // Check thread
+ if (iterator->second == Thread::GetCurrentThread()) {
+ // Guard listener code for exceptions
+ GuardedEventCall(event, iterator->first);
+ } else {
+ // New synchronization object is needed
+ synchronization = new WaitableEvent();
+
+ // Handle synchronized event
+ dispatcher->AddEventCall(
RegisterEventCall(event,
NULL,
iterator->first,
- NULL), dueTime);
+ synchronization));
+
+ // Add to barrier
+ synchronizationBarrier.push_back(synchronization);
+ }
+ break;
+
+ case EmitMode::Deffered:
+ // Handle deffered events
+ Assert(dueTime >= 0.0 && "Due time must be non-negative");
+
+ dispatcher->AddTimedEventCall(
+ RegisterEventCall(event,
+ NULL,
+ iterator->first,
+ NULL), dueTime);
- break;
+ break;
- default:
- Assert("Invalid emit mode");
+ default:
+ Assert("Invalid emit mode");
}
}
LogPedantic("Added event to dispatchers");
// Leave listeners lock in case of blocking call
- if (!synchronizationBarrier.empty())
- {
+ if (!synchronizationBarrier.empty()) {
LogPedantic("Leaving lock due to existing barrier");
lock.reset();
}
// Synchronize with barrier
// TODO: Implement generic WaitForAllMultipleHandles call
- while (!synchronizationBarrier.empty())
- {
+ while (!synchronizationBarrier.empty()) {
// Get barrier waitable handles
WaitableHandleList barrierHandles;
FOREACH(iterator, synchronizationBarrier)
- barrierHandles.push_back((*iterator)->GetHandle());
+ barrierHandles.push_back((*iterator)->GetHandle());
// Await more events
WaitableHandleIndexList indexList =
FOREACH(iterator, synchronizationBarrier)
{
- if (*iterator == NULL)
+ if (*iterator == NULL) {
continue;
+ }
clearedSynchronizationBarrier.push_back(*iterator);
}
LogPedantic("Event emitted");
}
-public:
- EventSupport()
- : m_guardedCallInProgress(false)
- {
- }
+ public:
+ EventSupport() :
+ m_guardedCallInProgress(false)
+ {}
virtual ~EventSupport()
{
// Switch all listeners and delegates
FOREACH(iterator, m_eventListenerList)
- iterator->second = thread;
+ iterator->second = thread;
FOREACH(iterator, m_delegateList)
- iterator->second = thread;
+ iterator->second = thread;
LogPedantic("All listeners and delegates switched");
}
};
-
}
} // namespace DPL
#include <dpl/log/log.h>
#include <dpl/assert.h>
-namespace DPL
-{
-namespace Event
-{
-
+namespace DPL {
+namespace Event {
template<typename EventType, typename SupportDataType>
-class GenericEventCall
- : public AbstractEventCall
+class GenericEventCall :
+ public AbstractEventCall
{
-public:
+ public:
typedef EventListener<EventType> EventListenerType;
typedef FastDelegate1<const EventType &> DelegateType;
-protected:
+ protected:
SupportDataType m_supportData;
EventListenerType *m_eventListener;
DelegateType m_delegate;
EventType m_event;
-public:
+ public:
template<typename OtherEventType, typename OtherSupportType>
struct Rebind
{
GenericEventCall(SupportDataType supportData,
EventListenerType *eventListener,
DelegateType delegate,
- const EventType &event)
- : m_supportData(supportData),
- m_eventListener(eventListener),
- m_delegate(delegate),
- m_event(event)
- {
- }
+ const EventType &event) :
+ m_supportData(supportData),
+ m_eventListener(eventListener),
+ m_delegate(delegate),
+ m_event(event)
+ {}
virtual ~GenericEventCall()
{
// from the event queue (not just marked "disabled")
}
};
-
}
} // namespace DPL
namespace DPL {
namespace Event {
-
//forward declaration
template <typename ... ArgTypesList>
class ICDelegate;
-namespace ICD{
+namespace ICD {
// This Type defines whether ICDelegate should be destroyed after the call, or
// could be reused later.
-enum class Reuse{ Yes, No };
+enum class Reuse
+{
+ Yes, No
+};
}
namespace ICDPrivate {
public:
explicit ScopedLock(ICDSharedDataBasePtr helperBase) :
m_scopedLock(&helperBase->m_mutex)
- {
- }
+ {}
private:
DPL::RecursiveMutex::ScopedLock m_scopedLock;
};
ICDSharedDataBase() : m_disabled(false)
- {
- }
+ {}
virtual ~ICDSharedDataBase()
- {
- }
+ {}
bool isDisabled() const
{
{
public:
DeleteICDSharedDataBaseEventCall(
- ICDSharedDataBase::ICDSharedDataBasePtr helperBase) :
+ ICDSharedDataBase::ICDSharedDataBasePtr helperBase) :
m_helperBase(helperBase)
- {
- }
+ {}
virtual void Call()
{
m_helperBase.reset();
ICDSharedDataBase::ICDSharedDataBasePtr m_helperBase;
};
-
class ICDelegateSupportInterface
{
protected:
virtual ~ICDelegateSupportInterface()
- {
- }
+ {}
virtual void unregisterICDSharedData(
- ICDPrivate::ICDSharedDataBase::ICDSharedDataBasePtr helper) = 0;
+ ICDPrivate::ICDSharedDataBase::ICDSharedDataBasePtr helper) = 0;
virtual void registerICDSharedData(
- ICDPrivate::ICDSharedDataBase::ICDSharedDataBasePtr helper) = 0;
+ ICDPrivate::ICDSharedDataBase::ICDSharedDataBasePtr helper) = 0;
+
private:
template <typename ... ArgTypesList>
friend class DPL::Event::ICDelegate;
template<typename ThisType, typename ... ArgTypesList>
FastDelegate<void (ArgTypesList ...)>
makeDelegate(ThisType* This,
- void (ThisType::*Func)(ArgTypesList ...))
+ void (ThisType::*Func)(ArgTypesList ...))
{
return FastDelegate<void (ArgTypesList ...)>(This, Func);
}
{
public:
ICDelegate()
- {
- }
+ {}
ICDelegate(ICDPrivate::ICDelegateSupportInterface* base,
DPL::FastDelegate<void (ArgTypesList ...)> outerDelegate,
ICD::Reuse reuse)
struct PrivateEvent
{
PrivateEvent(ICDSharedDataPtr a_helper,
- ArgTypesList ... arguments) :
+ ArgTypesList ... arguments) :
helper(a_helper),
args(std::make_tuple(arguments ...))
- {
- }
+ {}
ICDSharedDataPtr helper;
std::tuple<ArgTypesList ...> args;
} else {
DPL::Apply(m_outerDelegate, event.args);
- if(m_reuse == ICD::Reuse::Yes)
+ if (m_reuse == ICD::Reuse::Yes) {
return;
+ }
disable();
deleteICDSharedDataBase(ptr);
};
// Schedules helper removal.
- static void deleteICDSharedDataBase(ICDPrivate::ICDSharedDataBase::ICDSharedDataBasePtr helper)
+ static void deleteICDSharedDataBase(
+ ICDPrivate::ICDSharedDataBase::ICDSharedDataBasePtr helper)
{
using namespace ICDPrivate;
ICDSharedDataBase::ScopedLock lock(helper);
DeleteICDSharedDataBaseEventCall* event =
- new DeleteICDSharedDataBaseEventCall(helper);
+ new DeleteICDSharedDataBaseEventCall(helper);
if (DPL::Thread::GetCurrentThread() == NULL) {
DPL::Event::GetMainEventDispatcherInstance().AddEventCall(event);
} else {
protected:
template<typename ... ArgTypesList>
ICDelegate<ArgTypesList ...> makeICDelegate(
- void (ThisType::*Func)(ArgTypesList ...),
- ICD::Reuse reuse = ICD::Reuse::No)
+ void (ThisType::*Func)(ArgTypesList ...),
+ ICD::Reuse reuse = ICD::Reuse::No)
{
ThisType* This = static_cast<ThisType*>(this);
ICDelegate<ArgTypesList ...> icdelegate(
}
ICDelegateSupport()
- {
- }
+ {}
~ICDelegateSupport()
{
private:
virtual void unregisterICDSharedData(
- ICDPrivate::ICDSharedDataBase::ICDSharedDataBasePtr helper)
+ ICDPrivate::ICDSharedDataBase::ICDSharedDataBasePtr helper)
{
m_ICDSharedDatas.erase(helper->getIterator());
}
virtual void registerICDSharedData(
- ICDPrivate::ICDSharedDataBase::ICDSharedDataBasePtr helper)
+ ICDPrivate::ICDSharedDataBase::ICDSharedDataBasePtr helper)
{
helper->setIterator(
m_ICDSharedDatas.insert(m_ICDSharedDatas.begin(),
private:
ICDPrivate::ICDSharedDataBase::ICDSharedDataBaseList m_ICDSharedDatas;
};
-
}
} //namespace
* @file main_event_dispatcher.h
* @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
* @version 1.0
- * @brief This file is the implementation file of main event dispatcher for EFL
+ * @brief This file is the implementation file of main event dispatcher
+ * for EFL
*/
#ifndef DPL_MAIN_EVENT_DISPATCHER_H
#define DPL_MAIN_EVENT_DISPATCHER_H
#include <dpl/framework_efl.h>
#include <list>
-namespace DPL
+namespace DPL {
+namespace Event {
+class MainEventDispatcher :
+ public AbstractEventDispatcher
{
-namespace Event
-{
-
-class MainEventDispatcher
- : public AbstractEventDispatcher
-{
-public:
+ public:
class Exception
{
- public:
+ public:
DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, CreateFailed)
DECLARE_EXCEPTION_TYPE(Base, AddEventFailed)
DECLARE_EXCEPTION_TYPE(Base, AddTimedEventFailed)
};
-protected:
+ protected:
struct WrappedEventCall
{
AbstractEventCall *abstractEventCall;
WrappedEventCall(AbstractEventCall *abstractEventCallArg,
bool timedArg,
- double dueTimeArg)
- : abstractEventCall(abstractEventCallArg),
- timed(timedArg),
- dueTime(dueTimeArg)
- {
- }
+ double dueTimeArg) :
+ abstractEventCall(abstractEventCallArg),
+ timed(timedArg),
+ dueTime(dueTimeArg)
+ {}
};
typedef std::list<WrappedEventCall> WrappedEventCallList;
MainEventDispatcher *This;
TimedEventStruct(AbstractEventCall *abstractEventCallArg,
- MainEventDispatcher *ThisArg)
- : abstractEventCall(abstractEventCallArg),
- This(ThisArg)
- {
- }
+ MainEventDispatcher *ThisArg) :
+ abstractEventCall(abstractEventCallArg),
+ This(ThisArg)
+ {}
};
- void InternalAddEvent(AbstractEventCall *abstractEventCall, bool timed, double dueTime);
+ void InternalAddEvent(AbstractEventCall *abstractEventCall,
+ bool timed,
+ double dueTime);
static void StaticDeleteEvent(void *data, void *event);
static Eina_Bool StaticDispatchEvent(void *data, int type, void *event);
static Eina_Bool StaticDispatchTimedEvent(void *event);
- static Eina_Bool StaticDispatchCrossInvoker(void *data, Ecore_Fd_Handler *fd_handler);
+ static Eina_Bool StaticDispatchCrossInvoker(void *data,
+ Ecore_Fd_Handler *fd_handler);
void DeleteEvent(AbstractEventCall *abstractEventCall);
void DispatchEvent(AbstractEventCall *abstractEventCall);
void DispatchTimedEvent(AbstractEventCall *abstractEventCall);
void DispatchCrossInvoker();
-public:
+ public:
explicit MainEventDispatcher();
virtual ~MainEventDispatcher();
virtual void AddEventCall(AbstractEventCall *abstractEventCall);
- virtual void AddTimedEventCall(AbstractEventCall *abstractEventCall, double dueTime);
+ virtual void AddTimedEventCall(AbstractEventCall *abstractEventCall,
+ double dueTime);
virtual void ResetCrossEventCallHandler();
};
MainEventDispatcher& GetMainEventDispatcherInstance();
-
}
} // namespace DPL
#include <dpl/read_write_mutex.h>
#include <dpl/noncopyable.h>
-namespace DPL
+namespace DPL {
+namespace Event {
+class Model :
+ public Noncopyable
{
-namespace Event
-{
-
-class Model
- : public Noncopyable
-{
-protected:
+ protected:
mutable DPL::ReadWriteMutex m_mutex;
template<typename Type, typename StorageMethod>
template<typename Type, typename AccessType, typename StorageMethod>
friend class Property;
-public:
+ public:
virtual ~Model() = 0;
};
-
}
} // namespace DPL
#ifndef DPL_MODEL_BIND_TO_DAO_H_
#define DPL_MODEL_BIND_TO_DAO_H_
-namespace DPL
-{
-namespace Event
-{
-
+namespace DPL {
+namespace Event {
/**
* @param ObjectType type of object used as delegate argument
* @param RetType Type returned from the external function
return (extObject.*externalGetter)();
}
};
-
}
}
#include <dpl/fast_delegate.h>
#include <dpl/once.h>
-namespace DPL
-{
-namespace Event
-{
-
+namespace DPL {
+namespace Event {
/**
* Property is a class that encapsulates model's property fields.
* Its main purpose is to automate things related to model's properties
struct PropertyReadOnly {}; ///< Read only, not setter available
struct PropertyReadWrite {}; ///< Read and write
-
template<typename Type>
struct PropertyEvent
{
- PropertyEvent(const Type &v, Model *s)
- : value(v),
- sender(s)
- {
- }
+ PropertyEvent(const Type &v, Model *s) :
+ value(v),
+ sender(s)
+ {}
Type value;
Model *sender;
template<typename ReadDelegateType, typename WriteDelegateType>
class PropertyStorageMethodDynamicBase
{
-protected:
+ protected:
ReadDelegateType m_readValue;
WriteDelegateType m_writeValue;
PropertyStorageMethodDynamicBase(ReadDelegateType readValue,
- WriteDelegateType writeValue)
- : m_readValue(readValue),
- m_writeValue(writeValue)
- {
- }
+ WriteDelegateType writeValue) :
+ m_readValue(readValue),
+ m_writeValue(writeValue)
+ {}
};
template<typename Type>
class PropertyStorageMethodCachedBase
{
-protected:
+ protected:
mutable Type m_value;
PropertyStorageMethodCachedBase()
- {
- }
+ {}
};
class PropertyStorageMethodBase
{
-protected:
- explicit PropertyStorageMethodBase(Model *model)
- : m_model(model)
- {
- }
+ protected:
+ explicit PropertyStorageMethodBase(Model *model) :
+ m_model(model)
+ {}
Model *m_model;
};
class PropertyStorageMethod<Type,
PropertyStorageCached,
ReadDelegateType,
- WriteDelegateType>
- : protected PropertyStorageMethodBase,
- protected PropertyStorageMethodCachedBase<Type>
+ WriteDelegateType>:
+ protected PropertyStorageMethodBase,
+ protected PropertyStorageMethodCachedBase<Type>
{
-public:
+ public:
PropertyStorageMethod(Model *model,
ReadDelegateType /*readValue*/,
- WriteDelegateType /*writeValue*/)
- : PropertyStorageMethodBase(model)
- {
- }
+ WriteDelegateType /*writeValue*/) :
+ PropertyStorageMethodBase(model)
+ {}
Type Get() const
{
class PropertyStorageMethod<Type,
PropertyStorageDynamic,
ReadDelegateType,
- WriteDelegateType>
- : protected PropertyStorageMethodBase,
- protected PropertyStorageMethodDynamicBase<ReadDelegateType,
- WriteDelegateType>
+ WriteDelegateType>:
+ protected PropertyStorageMethodBase,
+ protected PropertyStorageMethodDynamicBase<ReadDelegateType,
+ WriteDelegateType>
{
-public:
+ public:
PropertyStorageMethod(Model *model,
ReadDelegateType readValue,
- WriteDelegateType writeValue)
- : PropertyStorageMethodBase(model),
- PropertyStorageMethodDynamicBase<ReadDelegateType, WriteDelegateType>(
- readValue,
- writeValue)
- {
- }
+ WriteDelegateType writeValue) :
+ PropertyStorageMethodBase(model),
+ PropertyStorageMethodDynamicBase<ReadDelegateType, WriteDelegateType>(
+ readValue,
+ writeValue)
+ {}
Type Get() const
{
class PropertyStorageMethod<Type,
PropertyStorageDynamicCached,
ReadDelegateType,
- WriteDelegateType>
- : protected PropertyStorageMethodBase,
- protected PropertyStorageMethodDynamicBase<ReadDelegateType,
- WriteDelegateType>,
- protected PropertyStorageMethodCachedBase<Type>
+ WriteDelegateType>:
+ protected PropertyStorageMethodBase,
+ protected PropertyStorageMethodDynamicBase<ReadDelegateType,
+ WriteDelegateType>,
+ protected PropertyStorageMethodCachedBase<Type>
{
-private:
+ private:
typedef PropertyStorageMethod<Type,
PropertyStorageDynamicCached,
ReadDelegateType,
}
void OnceDisable() const
- {
- }
+ {}
-protected:
+ protected:
mutable Once m_once;
-public:
+ public:
PropertyStorageMethod(Model *model,
ReadDelegateType readValue,
- WriteDelegateType writeValue)
- : PropertyStorageMethodBase(model),
- PropertyStorageMethodDynamicBase<ReadDelegateType, WriteDelegateType>(
- readValue, writeValue)
- {
- }
+ WriteDelegateType writeValue) :
+ PropertyStorageMethodBase(model),
+ PropertyStorageMethodDynamicBase<ReadDelegateType, WriteDelegateType>(
+ readValue, writeValue)
+ {}
Type Get() const
{
};
template<typename Type, typename StorageMethod>
-class PropertyBase
-
: protected EventSupport<PropertyEvent<Type> >
+class PropertyBase :
+ protected EventSupport<PropertyEvent<Type> >
{
-public:
+ public:
typedef typename EventSupport<PropertyEvent<Type> >::EventListenerType
- EventListenerType;
+ EventListenerType;
typedef typename EventSupport<PropertyEvent<Type> >::DelegateType
- DelegateType;
+ DelegateType;
- typedef FastDelegate<Type (Model *)>
- ReadDelegateType;
+ typedef FastDelegate<Type(Model *)>
+ ReadDelegateType;
typedef FastDelegate<void (const Type &, Model *)>
- WriteDelegateType;
+ WriteDelegateType;
-protected:
+ protected:
PropertyStorageMethod<Type,
StorageMethod,
ReadDelegateType,
PropertyBase(Model *model,
ReadDelegateType readValue,
- WriteDelegateType writeValue)
- : m_storage(model, readValue, writeValue),
- m_model(model)
- {
- }
+ WriteDelegateType writeValue) :
+ m_storage(model, readValue, writeValue),
+ m_model(model)
+ {}
-public:
+ public:
virtual Type Get() const
{
ReadWriteMutex::ScopedReadLock lock(&m_model->m_mutex);
class Property;
template<typename Type, typename StorageMethod>
-class Property<Type, PropertyReadOnly, StorageMethod>
- : public PropertyBase<Type, StorageMethod>
+class Property<Type, PropertyReadOnly, StorageMethod>:
+ public PropertyBase<Type, StorageMethod>
{
-public:
+ public:
typedef typename PropertyBase<Type, StorageMethod>::EventListenerType
- EventListenerType;
+ EventListenerType;
typedef typename PropertyBase<Type, StorageMethod>::DelegateType
- DelegateType;
+ DelegateType;
typedef typename PropertyBase<Type, StorageMethod>::ReadDelegateType
- ReadDelegateType;
+ ReadDelegateType;
typedef typename PropertyBase<Type, StorageMethod>::WriteDelegateType
- WriteDelegateType;
+ WriteDelegateType;
-public:
+ public:
explicit Property(Model *model,
- ReadDelegateType readValue = NULL)
- : PropertyBase<Type, StorageMethod>(model, readValue, NULL)
- {
- }
+ ReadDelegateType readValue = NULL) :
+ PropertyBase<Type, StorageMethod>(model, readValue, NULL)
+ {}
Property(Model *model,
const Type &value,
- ReadDelegateType readValue = NULL)
- : PropertyBase<Type, StorageMethod>(model, readValue, NULL)
+ ReadDelegateType readValue = NULL) :
+ PropertyBase<Type, StorageMethod>(model, readValue, NULL)
{
this->m_storage.Set(value);
}
};
template<typename Type, typename StorageMethod>
-class Property<Type, PropertyReadWrite, StorageMethod>
- : public PropertyBase<Type, StorageMethod>
+class Property<Type, PropertyReadWrite, StorageMethod>:
+ public PropertyBase<Type, StorageMethod>
{
-public:
+ public:
typedef typename PropertyBase<Type, StorageMethod>::EventListenerType
- EventListenerType;
+ EventListenerType;
typedef typename PropertyBase<Type, StorageMethod>::DelegateType
- DelegateType;
+ DelegateType;
typedef typename PropertyBase<Type, StorageMethod>::ReadDelegateType
- ReadDelegateType;
+ ReadDelegateType;
typedef typename PropertyBase<Type, StorageMethod>::WriteDelegateType
- WriteDelegateType;
+ WriteDelegateType;
-public:
+ public:
explicit Property(Model *model,
- ReadDelegateType readValue = NULL,
- WriteDelegateType writeValue = NULL)
- : PropertyBase<Type, StorageMethod>(model, readValue, writeValue)
- {
- }
+ ReadDelegateType readValue = NULL,
+ WriteDelegateType writeValue = NULL) :
+ PropertyBase<Type, StorageMethod>(model, readValue, writeValue)
+ {}
Property(Model *model,
const Type &value,
ReadDelegateType readValue = NULL,
- WriteDelegateType writeValue = NULL)
- : PropertyBase<Type, StorageMethod>(model, readValue, writeValue)
+ WriteDelegateType writeValue = NULL) :
+ PropertyBase<Type, StorageMethod>(model, readValue, writeValue)
{
this->m_storage.Set(value);
}
{
ReadWriteMutex::ScopedWriteLock lock(&this->m_model->m_mutex);
- if (this->m_storage.Get() == value)
+ if (this->m_storage.Get() == value) {
return;
+ }
this->m_storage.Set(value);
- EmitEvent(PropertyEvent<Type>(value, this->m_model),
- EmitMode::Auto);
+ this->EmitEvent(PropertyEvent<Type>(value, this->m_model),
+ EmitMode::Auto);
}
void SetWithoutLock(const Type &value)
{
- if (this->m_storage.Get() == value)
+ if (this->m_storage.Get() == value) {
return;
+ }
this->m_storage.Set(value);
}
};
-
}
} // namespace DPL
#include <dpl/event/abstract_event_call.h>
#include <dpl/thread.h>
-namespace DPL
+namespace DPL {
+namespace Event {
+class ThreadEventDispatcher :
+ public AbstractEventDispatcher
{
-namespace Event
-{
-
-class ThreadEventDispatcher
- : public AbstractEventDispatcher
-{
-protected:
+ protected:
Thread *m_thread;
static void StaticEventDelete(void *event, void *userParam);
void EventDelete(AbstractEventCall *abstractEventCall);
void EventDispatch(AbstractEventCall *abstractEventCall);
-public:
+ public:
explicit ThreadEventDispatcher();
virtual ~ThreadEventDispatcher();
void SetThread(Thread *thread);
virtual void AddEventCall(AbstractEventCall *abstractEventCall);
- virtual void AddTimedEventCall(AbstractEventCall *abstractEventCall, double dueTime);
+ virtual void AddTimedEventCall(AbstractEventCall *abstractEventCall,
+ double dueTime);
};
-
}
} // namespace DPL
#include <stddef.h>
#include <dpl/event/abstract_event_call.h>
-namespace DPL
-{
-namespace Event
-{
-
+namespace DPL {
+namespace Event {
AbstractEventCall::AbstractEventCall()
-{
-}
+{}
AbstractEventCall::~AbstractEventCall()
-{
-}
-
+{}
}
} // namespace DPL
* @file abstract_event_dispatcher.cpp
* @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
* @version 1.0
- * @brief This file is the implementation file of abstract event dispatcher
+ * @brief This file is the implementation file of abstract event
+ * dispatcher
*/
#include <stddef.h>
#include <dpl/event/abstract_event_dispatcher.h>
-namespace DPL
-{
-namespace Event
-{
-
+namespace DPL {
+namespace Event {
AbstractEventDispatcher::AbstractEventDispatcher()
-{
-}
+{}
AbstractEventDispatcher::~AbstractEventDispatcher()
-{
-}
-
+{}
}
} // namespace DPL
#include <stddef.h>
#include <dpl/event/event_support.h>
-namespace DPL
-{
-namespace Event
-{
-
+namespace DPL {
+namespace Event {
namespace // anonymous
{
int dummyInitializerProc()
}
int g_dummyInitializer = dummyInitializerProc();
-
} // namespace anonymous
-
}
} // namespace DPL
* @file main_event_dispatcher.cpp
* @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
* @version 1.0
- * @brief This file is the implementation file of main event dispatcher for EFL
+ * @brief This file is the implementation file of main event dispatcher
+ * for EFL
*/
#include <stddef.h>
#include <dpl/event/main_event_dispatcher.h>
#include <dpl/assert.h>
#include <dpl/singleton_impl.h>
-namespace DPL
-{
-
+namespace DPL {
IMPLEMENT_SINGLETON(Event::MainEventDispatcher)
-namespace Event
-{
-
+namespace Event {
typedef Singleton<Event::MainEventDispatcher> MainEventDispatcherSingleton;
namespace // anonymous
LogPedantic("ECORE event class registered: " << m_eventId);
// Register event class handler
- if ((m_eventCallHandler = ecore_event_handler_add(m_eventId, &StaticDispatchEvent, this)) == NULL)
+ if ((m_eventCallHandler =
+ ecore_event_handler_add(m_eventId, &StaticDispatchEvent,
+ this)) == NULL)
+ {
ThrowMsg(Exception::CreateFailed, "Failed to register event handler!");
+ }
// Allocate WaitableEvent
m_crossEventCallInvoker = new WaitableEvent();
// Register cross event handler
- m_crossEventCallHandler = ecore_main_fd_handler_add(m_crossEventCallInvoker->GetHandle(), ECORE_FD_READ, &StaticDispatchCrossInvoker, this, NULL, NULL);
+ m_crossEventCallHandler = ecore_main_fd_handler_add(
+ m_crossEventCallInvoker->GetHandle(),
+ ECORE_FD_READ,
+ &StaticDispatchCrossInvoker,
+ this,
+ NULL,
+ NULL);
- if (m_crossEventCallHandler == NULL)
- ThrowMsg(Exception::CreateFailed, "Failed to register cross event handler!");
+ if (m_crossEventCallHandler == NULL) {
+ ThrowMsg(Exception::CreateFailed,
+ "Failed to register cross event handler!");
+ }
LogPedantic("ECORE cross-event handler registered");
}
NULL);
if (m_crossEventCallHandler == NULL) {
- ThrowMsg(Exception::CreateFailed, "Failed to register cross event handler!");
+ ThrowMsg(Exception::CreateFailed,
+ "Failed to register cross event handler!");
}
LogPedantic("ECORE cross-event handler re-registered");
LogPedantic("Static ECORE delete event handler");
MainEventDispatcher *This = static_cast<MainEventDispatcher *>(data);
- AbstractEventCall *abstractEventCall = static_cast<AbstractEventCall *>(event);
+ AbstractEventCall *abstractEventCall =
+ static_cast<AbstractEventCall *>(event);
Assert(This != NULL);
Assert(abstractEventCall != NULL);
// Late EFL event handling
- if (g_lateMainEventDispatcher == NULL)
- {
+ if (g_lateMainEventDispatcher == NULL) {
LogPedantic("WARNING: Late EFL event delete!");
delete abstractEventCall;
- }
- else
- {
+ } else {
This->DeleteEvent(abstractEventCall);
}
}
-Eina_Bool MainEventDispatcher::StaticDispatchEvent(void *data, int type, void *event)
+Eina_Bool MainEventDispatcher::StaticDispatchEvent(void *data,
+ int type,
+ void *event)
{
LogPedantic("Static ECORE dispatch event");
MainEventDispatcher *This = static_cast<MainEventDispatcher *>(data);
- AbstractEventCall *abstractEventCall = static_cast<AbstractEventCall *>(event);
+ AbstractEventCall *abstractEventCall =
+ static_cast<AbstractEventCall *>(event);
(void)type;
Assert(This != NULL);
Assert(abstractEventCall != NULL);
// Late EFL event handling
- if (g_lateMainEventDispatcher == NULL)
- {
+ if (g_lateMainEventDispatcher == NULL) {
LogPedantic("WARNING: Late EFL event dispatch!");
- }
- else
- {
+ } else {
This->DispatchEvent(abstractEventCall);
}
Assert(abstractEventCall != NULL);
// Late EFL event handling
- if (g_lateMainEventDispatcher == NULL)
- {
+ if (g_lateMainEventDispatcher == NULL) {
LogPedantic("WARNING: Late EFL timed event dispatch!");
- }
- else
- {
+ } else {
// Dispatch timed event
This->DispatchEvent(abstractEventCall);
}
// And delete manually event, because ECORE does not
// use delete handler for timers
- StaticDeleteEvent(static_cast<void *>(This), static_cast<void *>(abstractEventCall));
+ StaticDeleteEvent(static_cast<void *>(This),
+ static_cast<void *>(abstractEventCall));
// Do not continue timed event handlers
// This also releases ECORE timer
return ECORE_CALLBACK_CANCEL;
}
-Eina_Bool MainEventDispatcher::StaticDispatchCrossInvoker(void *data, Ecore_Fd_Handler *fd_handler)
+Eina_Bool MainEventDispatcher::StaticDispatchCrossInvoker(
+ void *data,
+ Ecore_Fd_Handler *
+ fd_handler)
{
LogPedantic("Static ECORE dispatch cross invoker");
Assert(This != NULL);
// Late EFL event handling
- if (g_lateMainEventDispatcher == NULL)
- {
+ if (g_lateMainEventDispatcher == NULL) {
LogPedantic("WARNING: Late EFL cross invoker dispatch!");
- }
- else
- {
+ } else {
This->DispatchCrossInvoker();
}
abstractEventCall->Call();
}
-void MainEventDispatcher::DispatchTimedEvent(AbstractEventCall *abstractEventCall)
+void MainEventDispatcher::DispatchTimedEvent(
+ AbstractEventCall *abstractEventCall)
{
LogPedantic("ECORE dispatch timed event");
m_wrappedCrossEventCallList.swap(stolenCrossEvents);
}
- LogPedantic("Cross-thread event list stolen. Number of events: " << stolenCrossEvents.size());
+ LogPedantic(
+ "Cross-thread event list stolen. Number of events: " <<
+ stolenCrossEvents.size());
// Repush all stolen events
WrappedEventCallList::const_iterator eventIterator;
- for (eventIterator = stolenCrossEvents.begin(); eventIterator != stolenCrossEvents.end(); ++eventIterator)
+ for (eventIterator = stolenCrossEvents.begin();
+ eventIterator != stolenCrossEvents.end();
+ ++eventIterator)
{
// Unwrap events
LogPedantic("Dispatching event from invoker");
- InternalAddEvent(eventIterator->abstractEventCall, eventIterator->timed, eventIterator->dueTime);
+ InternalAddEvent(eventIterator->abstractEventCall,
+ eventIterator->timed,
+ eventIterator->dueTime);
}
LogPedantic("Cross-thread events dispatched");
void MainEventDispatcher::AddEventCall(AbstractEventCall *abstractEventCall)
{
- if (pthread_equal(pthread_self(), g_threadMain))
- {
+ if (pthread_equal(pthread_self(), g_threadMain)) {
LogPedantic("Main thread ECORE event push");
InternalAddEvent(abstractEventCall, false, 0.0);
- }
- else
- {
+ } else {
LogPedantic("Cross-thread ECORE event push");
// Push event to cross event list
{
Mutex::ScopedLock lock(&m_crossEventCallMutex);
- m_wrappedCrossEventCallList.push_back(WrappedEventCall(abstractEventCall, false, 0.0));
+ m_wrappedCrossEventCallList.push_back(WrappedEventCall(
+ abstractEventCall, false,
+ 0.0));
m_crossEventCallInvoker->Signal();
}
}
}
-void MainEventDispatcher::AddTimedEventCall(AbstractEventCall *abstractEventCall, double dueTime)
+void MainEventDispatcher::AddTimedEventCall(
+ AbstractEventCall *abstractEventCall,
+ double dueTime)
{
- if (pthread_equal(pthread_self(), g_threadMain))
- {
+ if (pthread_equal(pthread_self(), g_threadMain)) {
LogPedantic("Main thread timed ECORE event push");
InternalAddEvent(abstractEventCall, true, dueTime);
- }
- else
- {
+ } else {
LogPedantic("Cross-thread timed ECORE event push");
// Push event to cross event list
{
Mutex::ScopedLock lock(&m_crossEventCallMutex);
- m_wrappedCrossEventCallList.push_back(WrappedEventCall(abstractEventCall, true, dueTime));
+ m_wrappedCrossEventCallList.push_back(WrappedEventCall(
+ abstractEventCall, true,
+ dueTime));
m_crossEventCallInvoker->Signal();
}
}
}
-void MainEventDispatcher::InternalAddEvent(AbstractEventCall *abstractEventCall, bool timed, double dueTime)
+void MainEventDispatcher::InternalAddEvent(AbstractEventCall *abstractEventCall,
+ bool timed,
+ double dueTime)
{
LogPedantic("Adding base event");
- if (timed == true)
- {
+ if (timed == true) {
// Push timed event onto ecore stack
- TimedEventStruct* eventData = new TimedEventStruct(abstractEventCall, this);
- Ecore_Timer *timedEvent = ecore_timer_add(dueTime, &StaticDispatchTimedEvent, eventData);
+ TimedEventStruct* eventData = new TimedEventStruct(abstractEventCall,
+ this);
+ Ecore_Timer *timedEvent = ecore_timer_add(dueTime,
+ &StaticDispatchTimedEvent,
+ eventData);
- if (timedEvent == NULL)
- {
+ if (timedEvent == NULL) {
delete eventData;
delete abstractEventCall;
- ThrowMsg(Exception::AddTimedEventFailed, "Failed to add ECORE timed event");
+ ThrowMsg(Exception::AddTimedEventFailed,
+ "Failed to add ECORE timed event");
}
LogPedantic("Timed wrapped event added");
- }
- else
- {
+ } else {
// Push immediate event onto ecore stack
- Ecore_Event *event = ecore_event_add(m_eventId, abstractEventCall, &StaticDeleteEvent, this);
+ Ecore_Event *event = ecore_event_add(m_eventId,
+ abstractEventCall,
+ &StaticDeleteEvent,
+ this);
- if (event == NULL)
- {
+ if (event == NULL) {
delete abstractEventCall;
ThrowMsg(Exception::AddEventFailed, "Failed to add ECORE event");
}
{
return MainEventDispatcherSingleton::Instance();
}
-
}
} // namespace DPL
#include <stddef.h>
#include <dpl/event/model.h>
-namespace DPL
-{
-namespace Event
-{
+namespace DPL {
+namespace Event {
Model::~Model()
-{
-}
+{}
}
} // namespace DPL
#include <dpl/log/log.h>
#include <dpl/assert.h>
-namespace DPL
-{
-namespace Event
-{
-
-ThreadEventDispatcher::ThreadEventDispatcher()
- : m_thread(NULL)
-{
-}
+namespace DPL {
+namespace Event {
+ThreadEventDispatcher::ThreadEventDispatcher() :
+ m_thread(NULL)
+{}
ThreadEventDispatcher::~ThreadEventDispatcher()
-{
-}
+{}
void ThreadEventDispatcher::SetThread(Thread *thread)
{
void ThreadEventDispatcher::StaticEventDelete(void *event, void *userParam)
{
- AbstractEventCall *abstractEventCall = static_cast<AbstractEventCall *>(event);
- ThreadEventDispatcher *This = static_cast<ThreadEventDispatcher *>(userParam);
+ AbstractEventCall *abstractEventCall =
+ static_cast<AbstractEventCall *>(event);
+ ThreadEventDispatcher *This =
+ static_cast<ThreadEventDispatcher *>(userParam);
LogPedantic("Received static event delete from thread");
void ThreadEventDispatcher::StaticEventDispatch(void *event, void *userParam)
{
- AbstractEventCall *abstractEventCall = static_cast<AbstractEventCall *>(event);
- ThreadEventDispatcher *This = static_cast<ThreadEventDispatcher *>(userParam);
+ AbstractEventCall *abstractEventCall =
+ static_cast<AbstractEventCall *>(event);
+ ThreadEventDispatcher *This =
+ static_cast<ThreadEventDispatcher *>(userParam);
LogPedantic("Received static event dispatch from thread");
LogPedantic("Adding event to thread event loop");
// Call abstract event call in dedicated thread
- m_thread->PushEvent(abstractEventCall, &StaticEventDispatch, &StaticEventDelete, this);
+ m_thread->PushEvent(abstractEventCall,
+ &StaticEventDispatch,
+ &StaticEventDelete,
+ this);
}
-void ThreadEventDispatcher::AddTimedEventCall(AbstractEventCall *abstractEventCall, double dueTime)
+void ThreadEventDispatcher::AddTimedEventCall(
+ AbstractEventCall *abstractEventCall,
+ double dueTime)
{
// Thread must be set prior to call
Assert(m_thread != NULL);
LogPedantic("Adding timed event to thread event loop");
// Call abstract event call in dedicated thread
- m_thread->PushTimedEvent(abstractEventCall, dueTime, &StaticEventDispatch, &StaticEventDelete, this);
+ m_thread->PushTimedEvent(abstractEventCall,
+ dueTime,
+ &StaticEventDispatch,
+ &StaticEventDelete,
+ this);
}
-
}
} // namespace DPL
typedef std::list<DPL::String> LanguageTags;
-class LanguageTagsProvider {
-
-public:
+class LanguageTagsProvider
+{
+ public:
/*
* Get list of currently set language tags
*/
/*
* Set new language tags (other than based on system locales)
*/
- void setLanguageTags(const LanguageTags& taglist );
+ void setLanguageTags(const LanguageTags& taglist);
/*
* Set language tags from given locales.
static DPL::String BCP47LanguageTagToLocale(const DPL::String&);
/*
- * Function converts locales string (i.e. en_US.UTF-8) into language tag (i.e. en-US)
+ * Function converts locales string (i.e. en_US.UTF-8) into language tag
+ * (i.e. en-US)
*/
static DPL::String LocaleToBCP47LanguageTag(const DPL::String&);
-private:
+ private:
friend class DPL::Singleton<LanguageTagsProvider>;
LanguageTags m_languageTagsList;
WidgetIcon() :
width(DPL::Optional<int>::Null),
height(DPL::Optional<int>::Null)
- {
- }
+ {}
/*
* a valid URI to an image file inside the widget package that represents an
typedef std::list<WidgetIcon> WidgetIconList;
DPL::Optional<DPL::String> getFilePathInWidgetPackageFromUrl(
- WrtDB::DbWidgetHandle widgetHandle,
- const DPL::String &url);
+ WrtDB::DbWidgetHandle widgetHandle,
+ const DPL::String &url);
DPL::Optional<DPL::String> getFilePathInWidgetPackageFromUrl(
- const WrtDB::WidgetPkgName &pkgname,
- const DPL::String &url);
+ const WrtDB::WidgetPkgName &pkgname,
+ const DPL::String &url);
DPL::Optional<DPL::String> getFilePathInWidgetPackageFromUrl(
- WrtDB::WidgetDAOReadOnlyPtr dao,
- const DPL::String &url);
+ WrtDB::WidgetDAOReadOnlyPtr dao,
+ const DPL::String &url);
DPL::Optional<DPL::String> getFilePathInWidgetPackage(
- WrtDB::DbWidgetHandle widgetHandle,
- const DPL::String& file);
+ WrtDB::DbWidgetHandle widgetHandle,
+ const DPL::String& file);
DPL::Optional<DPL::String> getFilePathInWidgetPackage(
- const WrtDB::WidgetPkgName &pkgname,
- const DPL::String& file);
+ const WrtDB::WidgetPkgName &pkgname,
+ const DPL::String& file);
DPL::Optional<DPL::String> getFilePathInWidgetPackage(
- WrtDB::WidgetDAOReadOnlyPtr dao,
- const DPL::String& file);
+ WrtDB::WidgetDAOReadOnlyPtr dao,
+ const DPL::String& file);
DPL::OptionalString getStartFile(WrtDB::DbWidgetHandle handle);
DPL::OptionalString getStartFile(const WrtDB::WidgetPkgName & pkgname);
OptionalWidgetIcon getIcon(WrtDB::WidgetDAOReadOnlyPtr dao);
WidgetIconList getValidIconsList(
- WrtDB::DbWidgetHandle widgetHandle);
+ WrtDB::DbWidgetHandle widgetHandle);
WidgetIconList getValidIconsList(
- const WrtDB::WidgetPkgName &pkgname);
+ const WrtDB::WidgetPkgName &pkgname);
WidgetIconList getValidIconsList(
- WrtDB::WidgetDAOReadOnlyPtr dao);
+ WrtDB::WidgetDAOReadOnlyPtr dao);
OptionalWidgetStartFileInfo getStartFileInfo(
- WrtDB::DbWidgetHandle widgetHandle);
+ WrtDB::DbWidgetHandle widgetHandle);
OptionalWidgetStartFileInfo getStartFileInfo(
- const WrtDB::WidgetPkgName &pkgname);
+ const WrtDB::WidgetPkgName &pkgname);
OptionalWidgetStartFileInfo getStartFileInfo(
- WrtDB::WidgetDAOReadOnlyPtr dao);
+ WrtDB::WidgetDAOReadOnlyPtr dao);
WrtDB::WidgetLocalizedInfo getLocalizedInfo(WrtDB::DbWidgetHandle widgetHandle);
-WrtDB::WidgetLocalizedInfo getLocalizedInfo(const WrtDB::WidgetPkgName & pkgname);
+WrtDB::WidgetLocalizedInfo getLocalizedInfo(
+ const WrtDB::WidgetPkgName & pkgname);
WrtDB::WidgetLocalizedInfo getLocalizedInfo(WrtDB::WidgetDAOReadOnlyPtr dao);
}
* In case of empty list given as parameter only default value
* will exist on m_languageTagsList. */
DPL::String tofind = L"";
- if(std::find(m_languageTagsList.begin(), m_languageTagsList.end(),
- tofind) == m_languageTagsList.end()) {
+ if (std::find(m_languageTagsList.begin(), m_languageTagsList.end(),
+ tofind) == m_languageTagsList.end())
+ {
m_languageTagsList.push_back(L"");
}
}
this->loadSystemTags();
}
-void LanguageTagsProvider::addWidgetDefaultLocales(const DPL::String& defaultLocale){
+void LanguageTagsProvider::addWidgetDefaultLocales(
+ const DPL::String& defaultLocale)
+{
if (defaultLocale.size() > 0 &&
- std::find(m_languageTagsList.begin(), m_languageTagsList.end(), defaultLocale) == m_languageTagsList.end())
+ std::find(m_languageTagsList.begin(), m_languageTagsList.end(),
+ defaultLocale) == m_languageTagsList.end())
{
if (m_languageTagsList.size() < 2) {
m_languageTagsList.push_front(defaultLocale);
} else {
LanguageTags::iterator placeToInsert = m_languageTagsList.end();
--placeToInsert;
- if (*placeToInsert != L"")
- {
+ if (*placeToInsert != L"") {
++placeToInsert;
}
m_languageTagsList.insert(placeToInsert, defaultLocale);
}
}
-DPL::String LanguageTagsProvider::BCP47LanguageTagToLocale(const DPL::String& inLanguageTag)
+DPL::String LanguageTagsProvider::BCP47LanguageTagToLocale(
+ const DPL::String& inLanguageTag)
{
DPL::String languageTag(inLanguageTag);
/* Replace all */
return languageTag;
}
-DPL::String LanguageTagsProvider::LocaleToBCP47LanguageTag(const DPL::String& inLocaleString)
+DPL::String LanguageTagsProvider::LocaleToBCP47LanguageTag(
+ const DPL::String& inLocaleString)
{
/* Cut off codepage information from given string (if any exists)
* i.e. change en_US.UTF-8 into en_US */
}
LanguageTagsProvider::~LanguageTagsProvider()
-{
-}
+{}
void LanguageTagsProvider::loadSystemTags()
{
char* language = vconf_get_str(VCONFKEY_LANGSET);
- if(!language) {
+ if (!language) {
LogError("Failed to get language from vconf");
- }
- else {
+ } else {
LogDebug("Language fetched from vconf: " << language);
}
createTagsFromLocales(language);
void LanguageTagsProvider::createTagsFromLocales(const char* language)
{
m_languageTagsList.clear();
- if(!language) {
+ if (!language) {
LogDebug("Setting default language tags");
/* If NULL language given than set default language tags
* and return. */
}
LogDebug("Setting tags for language: " << language);
- DPL::String langdescr = LocaleToBCP47LanguageTag(DPL::FromUTF8String(language));
+ DPL::String langdescr =
+ LocaleToBCP47LanguageTag(DPL::FromUTF8String(language));
- size_t position;
- if(langdescr.empty()) {
+ if (langdescr.empty()) {
LogError("Empty language description while correct value needed");
- }
- else {
+ } else {
/* Language tags list should not be cleared before this place to
* avoid losing current data when new data are invalid */
+ size_t position;
while (true) {
LogDebug("Processing language description: " << langdescr);
m_languageTagsList.push_back(langdescr);
+++ /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 localization_utils.cpp
- * @author Bartosz Janiak (b.janiak@samsung.com)
- * @version 1.0
- */
-
-#include <dpl/localization/localization_utils.h>
-
-#include <dpl/foreach.h>
-#include <dpl/mutex.h>
-
-namespace LocalizationUtils {
-static LanguageTagsList m_systemLanguageTags;
-static LanguageTagsList m_languageTags;
-static DPL::ReadWriteMutex m_readWriteMutex;
-
-template<typename StringType>
-void FindAndReplace(StringType& source,
- const StringType& find,
- const StringType& replace)
-{
- size_t pos = 0;
- while ((pos = source.find(find, pos)) != StringType::npos) {
- source.replace(pos, find.length(), replace);
- pos += replace.length();
- }
-}
-
-DPL::String BCP47LanguageTagToLocale(const DPL::String& inLanguageTag)
-{
- DPL::String languageTag(inLanguageTag);
- FindAndReplace(languageTag, DPL::String(L"-"), DPL::String(L"_"));
- return languageTag;
-}
-
-DPL::String LocaleToBCP47LanguageTag(const DPL::String& inLocaleString)
-{
- DPL::String localeString = inLocaleString.substr(
- 0,
- inLocaleString.
- find_first_of(L"."));
- FindAndReplace(localeString, DPL::String(L"_"), DPL::String(L"-"));
- return localeString;
-}
-
-void UpdateUserAgentLanguageTags()
-{
- // WARNING!!!!! This function shall be called
- // only when mutex is locked in readWriteMode!
-
- m_languageTags.clear();
-
- FOREACH(i, m_systemLanguageTags) {
- DPL::String tag = LocaleToBCP47LanguageTag(*i);
- while (true) { //W3C Packaging 9. Step 5. 2. D
- if (tag.empty()) { continue; }
-
- LogDebug("Adding user locale '" << tag << "'");
- m_languageTags.push_back(tag);
-
- size_t subtagPos = tag.find_last_of(L"-");
- if (subtagPos == DPL::String::npos) {
- break;
- }
- tag = tag.substr(0, subtagPos);
- }
- }
-
- m_languageTags.push_back(L"en");
- m_languageTags.push_back(L"");
-}
-
-void SetSystemLanguageTags(const LanguageTagsList& tags)
-{
- DPL::ReadWriteMutex::ScopedWriteLock lock(&m_readWriteMutex);
- if (m_systemLanguageTags != tags) {
- m_systemLanguageTags = tags;
- UpdateUserAgentLanguageTags();
- }
-}
-
-LanguageTagsList GetUserAgentLanguageTags()
-{
- DPL::ReadWriteMutex::ScopedReadLock lock(&m_readWriteMutex);
- return m_languageTags;
-}
-}
namespace {
const DPL::String FILE_URI_BEGIN = L"file://";
const DPL::String WIDGET_URI_BEGIN = L"widget://";
+const DPL::String APP_URI_BEGIN = L"app://";
const DPL::String LOCALE_PREFIX = L"locales/";
DPL::Optional<std::string> GetFilePathInWidgetPackageInternal(
- const std::string& basePath,
- std::string filePath)
+ const std::string& basePath,
+ std::string filePath)
{
LogDebug("Looking for file: " << filePath << " in: " << basePath);
- const LanguageTags& ltags = LanguageTagsProviderSingleton::Instance().getLanguageTags();
+ const LanguageTags& ltags =
+ LanguageTagsProviderSingleton::Instance().getLanguageTags();
//Check if string isn't empty
- if (filePath.size() == 0) { return DPL::Optional<std::string>::Null; }
+ if (filePath.size() == 0) {
+ return DPL::Optional<std::string>::Null;
+ }
//Removing preceding '/'
- if (filePath[0] == '/') { filePath.erase(0, 1); }
- // In some cases (start file localization) url has unnecessary "/" at the end
- if(filePath[filePath.size()-1] == '/') { filePath.erase(filePath.size()-1, 1); }
+ if (filePath[0] == '/') {
+ filePath.erase(0, 1);
+ }
+ // In some cases (start file localization) url has unnecessary "/" at the
+ // end
+ if (filePath[filePath.size() - 1] == '/') {
+ filePath.erase(filePath.size() - 1, 1);
+ }
//Check if string isn't empty
- if (filePath.size() == 0) { return DPL::Optional<std::string>::Null; }
+ if (filePath.size() == 0) {
+ return DPL::Optional<std::string>::Null;
+ }
LogDebug("locales size = " << ltags.size());
for (LanguageTags::const_iterator it = ltags.begin();
- it != ltags.end();
- ++it) {
+ it != ltags.end();
+ ++it)
+ {
LogDebug("Trying locale: " << *it);
std::string path = basePath;
if (path[path.size() - 1] == '/') {
}
DPL::Optional<DPL::String> GetFilePathInWidgetPackageInternal(
- const DPL::String& basePath,
- const DPL::String& filePath)
+ const DPL::String& basePath,
+ const DPL::String& filePath)
{
DPL::Optional<std::string> path =
GetFilePathInWidgetPackageInternal(DPL::ToUTF8String(basePath),
}
namespace W3CFileLocalization {
-
DPL::Optional<DPL::String> getFilePathInWidgetPackageFromUrl(
- DbWidgetHandle widgetHandle,
- const DPL::String &url)
+ DbWidgetHandle widgetHandle,
+ const DPL::String &url)
{
return getFilePathInWidgetPackageFromUrl(
- WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(widgetHandle)),
- url);
+ WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(widgetHandle)),
+ url);
}
DPL::Optional<DPL::String> getFilePathInWidgetPackageFromUrl(
- const WrtDB::WidgetPkgName &pkgname,
- const DPL::String &url)
+ const WrtDB::WidgetPkgName &pkgname,
+ const DPL::String &url)
{
return getFilePathInWidgetPackageFromUrl(
- WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(pkgname)),
- url);
+ WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(pkgname)),
+ url);
}
DPL::Optional<DPL::String> getFilePathInWidgetPackageFromUrl(
- WrtDB::WidgetDAOReadOnlyPtr dao,
- const DPL::String &url)
+ WrtDB::WidgetDAOReadOnlyPtr dao,
+ const DPL::String &url)
{
DPL::String req = url;
// should always be >0 as correct locales path is
// always locales/xx/ or locales/xx-XX/
if (position != std::string::npos && position > 0) {
- req.erase(0, position+1);
+ req.erase(0, position + 1);
}
}
+ } else if(req.find(APP_URI_BEGIN) == 0) {
+ req.erase(0, APP_URI_BEGIN.length());
+ DPL::String id = *dao->getTizenAppId();
+ if(req.substr(0, id.size()) != id)
+ {
+ LogError("Tizen id does not match, ignoring");
+ return DPL::Optional<DPL::String>::Null;
+ }
+ req.erase(0, id.length());
} else {
LogDebug("Unknown path format, ignoring");
return DPL::Optional<DPL::String>::Null;
auto widgetPath = dao->getPath();
+ LogDebug("Required path: " << req);
DPL::Optional<DPL::String> found =
GetFilePathInWidgetPackageInternal(widgetPath, req);
}
DPL::Optional<DPL::String> getFilePathInWidgetPackage(
- WrtDB::DbWidgetHandle widgetHandle,
- const DPL::String& file)
+ WrtDB::DbWidgetHandle widgetHandle,
+ const DPL::String& file)
{
return getFilePathInWidgetPackage(
- WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(widgetHandle)),
- file);
+ WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(widgetHandle)),
+ file);
}
DPL::Optional<DPL::String> getFilePathInWidgetPackage(
- const WrtDB::WidgetPkgName &pkgname,
- const DPL::String& file)
+ const WrtDB::WidgetPkgName &pkgname,
+ const DPL::String& file)
{
return getFilePathInWidgetPackage(
- WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(pkgname)),
- file);
+ WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(pkgname)),
+ file);
}
DPL::Optional<DPL::String> getFilePathInWidgetPackage(
- WrtDB::WidgetDAOReadOnlyPtr dao,
- const DPL::String& file)
+ WrtDB::WidgetDAOReadOnlyPtr dao,
+ const DPL::String& file)
{
return GetFilePathInWidgetPackageInternal(dao->getPath(), file);
}
DPL::OptionalString getStartFile(WrtDB::WidgetDAOReadOnlyPtr dao)
{
- WidgetDAOReadOnly::LocalizedStartFileList locList = dao->getLocalizedStartFileList();
+ WidgetDAOReadOnly::LocalizedStartFileList locList =
+ dao->getLocalizedStartFileList();
WidgetDAOReadOnly::WidgetStartFileList list = dao->getStartFileList();
- LanguageTags tagsList = LanguageTagsProviderSingleton::Instance().getLanguageTags();
+ LanguageTags tagsList =
+ LanguageTagsProviderSingleton::Instance().getLanguageTags();
DPL::OptionalString defaultLoc = dao->getDefaultlocale();
if (!!defaultLoc) {
OptionalWidgetIcon getIcon(WrtDB::WidgetDAOReadOnlyPtr dao)
{
- WidgetDAOReadOnly::WidgetLocalizedIconList locList = dao->getLocalizedIconList();
+ WidgetDAOReadOnly::WidgetLocalizedIconList locList =
+ dao->getLocalizedIconList();
WidgetDAOReadOnly::WidgetIconList list = dao->getIconList();
- LanguageTags tagsList = LanguageTagsProviderSingleton::Instance().getLanguageTags();
+ LanguageTags tagsList =
+ LanguageTagsProviderSingleton::Instance().getLanguageTags();
DPL::OptionalString defaultLoc = dao->getDefaultlocale();
if (!!defaultLoc) {
WidgetIconList getValidIconsList(WrtDB::DbWidgetHandle widgetHandle)
{
return getValidIconsList(
- WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(widgetHandle)));
+ WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(widgetHandle)));
}
WidgetIconList getValidIconsList(const WrtDB::WidgetPkgName &pkgname)
{
return getValidIconsList(
- WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(pkgname)));
+ WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(pkgname)));
}
WidgetIconList getValidIconsList(WrtDB::WidgetDAOReadOnlyPtr dao)
OptionalWidgetStartFileInfo getStartFileInfo(WrtDB::DbWidgetHandle widgetHandle)
{
return getStartFileInfo(
- WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(widgetHandle)));
+ WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(widgetHandle)));
}
-OptionalWidgetStartFileInfo getStartFileInfo(const WrtDB::WidgetPkgName &pkgname)
+OptionalWidgetStartFileInfo getStartFileInfo(
+ const WrtDB::WidgetPkgName &pkgname)
{
return getStartFileInfo(
- WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(pkgname)));
-
+ WidgetDAOReadOnlyPtr(new WidgetDAOReadOnly(pkgname)));
}
-
OptionalWidgetStartFileInfo getStartFileInfo(WrtDB::WidgetDAOReadOnlyPtr dao)
{
WidgetStartFileInfo info;
WidgetDAOReadOnly::LocalizedStartFileList locList =
dao->getLocalizedStartFileList();
WidgetDAOReadOnly::WidgetStartFileList list = dao->getStartFileList();
- const LanguageTags tagsList = LanguageTagsProviderSingleton::Instance().getLanguageTags();
+ const LanguageTags tagsList =
+ LanguageTagsProviderSingleton::Instance().getLanguageTags();
FOREACH(tag, tagsList)
{
FOREACH(it, list)
{
if (it->startFileId ==
- sFile->startFileId) {
+ sFile->startFileId)
+ {
info.file = it->src;
info.encoding = sFile->encoding;
info.type = sFile->type;
WidgetLocalizedInfo getLocalizedInfo(WidgetDAOReadOnlyPtr dao)
{
- LanguageTags languages = LanguageTagsProviderSingleton::Instance().getLanguageTags();
+ LanguageTags languages =
+ LanguageTagsProviderSingleton::Instance().getLanguageTags();
DPL::OptionalString dl = dao->getDefaultlocale();
if (!!dl) {
languages.push_back(*dl);
#ifndef DPL_ABSTRACT_LOG_PROVIDER_H
#define DPL_ABSTRACT_LOG_PROVIDER_H
-namespace DPL
-{
-namespace Log
-{
-
+namespace DPL {
+namespace Log {
class AbstractLogProvider
{
-public:
+ public:
virtual ~AbstractLogProvider() {}
- virtual void Debug(const char *message, const char *fileName, int line, const char *function) = 0;
- virtual void Info(const char *message, const char *fileName, int line, const char *function) = 0;
- virtual void Warning(const char *message, const char *fileName, int line, const char *function) = 0;
- virtual void Error(const char *message, const char *fileName, int line, const char *function) = 0;
- virtual void Pedantic(const char *message, const char *fileName, int line, const char *function) = 0;
+ virtual void Debug(const char *message,
+ const char *fileName,
+ int line,
+ const char *function) = 0;
+ virtual void Info(const char *message,
+ const char *fileName,
+ int line,
+ const char *function) = 0;
+ virtual void Warning(const char *message,
+ const char *fileName,
+ int line,
+ const char *function) = 0;
+ virtual void Error(const char *message,
+ const char *fileName,
+ int line,
+ const char *function) = 0;
+ virtual void Pedantic(const char *message,
+ const char *fileName,
+ int line,
+ const char *function) = 0;
-protected:
+ protected:
static const char *LocateSourceFileName(const char *filename);
};
-
}
} // namespace DPL
#include <dpl/scoped_free.h>
#include <string>
-namespace DPL
+namespace DPL {
+namespace Log {
+class DLOGLogProvider :
+ public AbstractLogProvider
{
-namespace Log
-{
-
-class DLOGLogProvider
- : public AbstractLogProvider
-{
-private:
+ private:
DPL::ScopedFree<char> m_tag;
- static std::string FormatMessage(const char *message, const char *filename, int line, const char *function);
-public:
+ static std::string FormatMessage(const char *message,
+ const char *filename,
+ int line,
+ const char *function);
+
+ public:
DLOGLogProvider();
virtual ~DLOGLogProvider();
- virtual void Debug(const char *message, const char *fileName, int line, const char *function);
- virtual void Info(const char *message, const char *fileName, int line, const char *function);
- virtual void Warning(const char *message, const char *fileName, int line, const char *function);
- virtual void Error(const char *message, const char *fileName, int line, const char *function);
- virtual void Pedantic(const char *message, const char *fileName, int line, const char *function);
+ virtual void Debug(const char *message,
+ const char *fileName,
+ int line,
+ const char *function);
+ virtual void Info(const char *message,
+ const char *fileName,
+ int line,
+ const char *function);
+ virtual void Warning(const char *message,
+ const char *fileName,
+ int line,
+ const char *function);
+ virtual void Error(const char *message,
+ const char *fileName,
+ int line,
+ const char *function);
+ virtual void Pedantic(const char *message,
+ const char *fileName,
+ int line,
+ const char *function);
// Set global Tag according to DLOG
void SetTag(const char *tag);
};
-
}
} // namespace DPL
#include <sstream>
#include <list>
-namespace DPL
-{
-namespace Log
-{
+namespace DPL {
+namespace Log {
/**
* DPL log system
*
* To switch logs into old style, export
* DPL_USE_OLD_STYLE_LOGS before application start
*/
-class LogSystem
- : private Noncopyable
+class LogSystem :
+ private Noncopyable
{
-private:
+ private:
typedef std::list<AbstractLogProvider *> AbstractLogProviderPtrList;
AbstractLogProviderPtrList m_providers;
bool m_isLoggingEnabled;
-public:
+ public:
bool IsLoggingEnabled() const;
LogSystem();
virtual ~LogSystem();
/**
* Log debug message
*/
- void Debug(const char *message, const char *filename, int line, const char *function);
+ void Debug(const char *message,
+ const char *filename,
+ int line,
+ const char *function);
/**
* Log info message
*/
- void Info(const char *message, const char *filename, int line, const char *function);
+ void Info(const char *message,
+ const char *filename,
+ int line,
+ const char *function);
/**
* Log warning message
*/
- void Warning(const char *message, const char *filename, int line, const char *function);
+ void Warning(const char *message,
+ const char *filename,
+ int line,
+ const char *function);
/**
* Log error message
*/
- void Error(const char *message, const char *filename, int line, const char *function);
+ void Error(const char *message,
+ const char *filename,
+ int line,
+ const char *function);
/**
* Log pedantic message
*/
- void Pedantic(const char *message, const char *filename, int line, const char *function);
+ void Pedantic(const char *message,
+ const char *filename,
+ int line,
+ const char *function);
/**
* Set default's DLOG provider Tag
/*
* Replacement low overhead null logging class
*/
-class NullStream {
+class NullStream
+{
public:
NullStream() {}
template <typename T>
- NullStream& operator<<(const T&) { return *this; }
+ NullStream& operator<<(const T&)
+ {
+ return *this;
+ }
};
/**
* Log system singleton
*/
typedef Singleton<LogSystem> LogSystemSingleton;
-
}
} // namespace DPL
#ifdef DPL_LOGS_ENABLED
#define DPL_MACRO_FOR_LOGGING(message, function) \
- do \
- { \
- if (DPL::Log::LogSystemSingleton::Instance().IsLoggingEnabled()) \
- { \
- std::ostringstream platformLog; \
- platformLog << message; \
- DPL::Log::LogSystemSingleton::Instance().function( \
- platformLog.str().c_str(), \
- __FILE__, __LINE__, __FUNCTION__); \
- } \
- } while (0)
+ do \
+ { \
+ if (DPL::Log::LogSystemSingleton::Instance().IsLoggingEnabled()) \
+ { \
+ std::ostringstream platformLog; \
+ platformLog << message; \
+ DPL::Log::LogSystemSingleton::Instance().function( \
+ platformLog.str().c_str(), \
+ __FILE__, __LINE__, __FUNCTION__); \
+ } \
+ } while (0)
#else
/* avoid warnings about unused variables */
#define DPL_MACRO_FOR_LOGGING(message, function) \
- do { \
- DPL::Log::NullStream ns; \
- ns << message; \
- } while (0)
+ do { \
+ DPL::Log::NullStream ns; \
+ ns << message; \
+ } while (0)
#endif
-
#define LogDebug(message) DPL_MACRO_FOR_LOGGING(message, Debug)
#define LogInfo(message) DPL_MACRO_FOR_LOGGING(message, Info)
#define LogWarning(message) DPL_MACRO_FOR_LOGGING(message, Warning)
#include <dpl/log/abstract_log_provider.h>
#include <string>
-namespace DPL
+namespace DPL {
+namespace Log {
+class OldStyleLogProvider :
+ public AbstractLogProvider
{
-namespace Log
-{
-class OldStyleLogProvider
- : public AbstractLogProvider
-{
-private:
+ private:
bool m_showDebug;
bool m_showInfo;
bool m_showWarning;
bool m_showError;
bool m_showPedantic;
- static std::string FormatMessage(const char *message, const char *filename, int line, const char *function);
+ static std::string FormatMessage(const char *message,
+ const char *filename,
+ int line,
+ const char *function);
-public:
- OldStyleLogProvider(bool showDebug, bool showInfo, bool showWarning, bool showError, bool showPedantic);
+ public:
+ OldStyleLogProvider(bool showDebug,
+ bool showInfo,
+ bool showWarning,
+ bool showError,
+ bool showPedantic);
virtual ~OldStyleLogProvider() {}
- virtual void Debug(const char *message, const char *fileName, int line, const char *function);
- virtual void Info(const char *message, const char *fileName, int line, const char *function);
- virtual void Warning(const char *message, const char *fileName, int line, const char *function);
- virtual void Error(const char *message, const char *fileName, int line, const char *function);
- virtual void Pedantic(const char *message, const char *fileName, int line, const char *function);
+ virtual void Debug(const char *message,
+ const char *fileName,
+ int line,
+ const char *function);
+ virtual void Info(const char *message,
+ const char *fileName,
+ int line,
+ const char *function);
+ virtual void Warning(const char *message,
+ const char *fileName,
+ int line,
+ const char *function);
+ virtual void Error(const char *message,
+ const char *fileName,
+ int line,
+ const char *function);
+ virtual void Pedantic(const char *message,
+ const char *fileName,
+ int line,
+ const char *function);
};
-
}
} // namespace DPL
#include <dpl/log/abstract_log_provider.h>
#include <cstring>
-namespace DPL
-{
-namespace Log
-{
+namespace DPL {
+namespace Log {
const char *AbstractLogProvider::LocateSourceFileName(const char *filename)
{
const char *ptr = strrchr(filename, '/');
#include <sstream>
#include <dlog.h>
-namespace DPL
-{
-namespace Log
-{
-
-std::string DLOGLogProvider::FormatMessage(const char *message, const char *filename, int line, const char *function)
+namespace DPL {
+namespace Log {
+std::string DLOGLogProvider::FormatMessage(const char *message,
+ const char *filename,
+ int line,
+ const char *function)
{
std::ostringstream val;
val << std::string("[") <<
- LocateSourceFileName(filename) << std::string(":") << line <<
- std::string("] ") << function << std::string("(): ") << message;
+ LocateSourceFileName(filename) << std::string(":") << line <<
+ std::string("] ") << function << std::string("(): ") << message;
return val.str();
}
DLOGLogProvider::DLOGLogProvider()
-{
-}
+{}
DLOGLogProvider::~DLOGLogProvider()
-{
-}
+{}
void DLOGLogProvider::SetTag(const char *tag)
{
m_tag.Reset(strdup(tag));
}
-void DLOGLogProvider::Debug(const char *message, const char *filename, int line, const char *function)
+void DLOGLogProvider::Debug(const char *message,
+ const char *filename,
+ int line,
+ const char *function)
{
- LOG(LOG_DEBUG, m_tag.Get(), "%s" , FormatMessage(message, filename, line, function).c_str());
+ LOG(LOG_DEBUG, m_tag.Get(), "%s",
+ FormatMessage(message, filename, line, function).c_str());
}
-void DLOGLogProvider::Info(const char *message, const char *filename, int line, const char *function)
+void DLOGLogProvider::Info(const char *message,
+ const char *filename,
+ int line,
+ const char *function)
{
- LOG(LOG_INFO, m_tag.Get(), "%s" , FormatMessage(message, filename, line, function).c_str());
+ LOG(LOG_INFO, m_tag.Get(), "%s",
+ FormatMessage(message, filename, line, function).c_str());
}
-void DLOGLogProvider::Warning(const char *message, const char *filename, int line, const char *function)
+void DLOGLogProvider::Warning(const char *message,
+ const char *filename,
+ int line,
+ const char *function)
{
- LOG(LOG_WARN, m_tag.Get(), "%s" , FormatMessage(message, filename, line, function).c_str());
+ LOG(LOG_WARN, m_tag.Get(), "%s",
+ FormatMessage(message, filename, line, function).c_str());
}
-void DLOGLogProvider::Error(const char *message, const char *filename, int line, const char *function)
+void DLOGLogProvider::Error(const char *message,
+ const char *filename,
+ int line,
+ const char *function)
{
- LOG(LOG_ERROR, m_tag.Get(), "%s" , FormatMessage(message, filename, line, function).c_str());
+ LOG(LOG_ERROR, m_tag.Get(), "%s",
+ FormatMessage(message, filename, line, function).c_str());
}
-void DLOGLogProvider::Pedantic(const char *message, const char *filename, int line, const char *function)
+void DLOGLogProvider::Pedantic(const char *message,
+ const char *filename,
+ int line,
+ const char *function)
{
- LOG(LOG_DEBUG, "DPL", "%s", FormatMessage(message, filename, line, function).c_str());
+ LOG(LOG_DEBUG, "DPL", "%s", FormatMessage(message,
+ filename,
+ line,
+ function).c_str());
}
-
}
} // namespace DPL
IMPLEMENT_SINGLETON(DPL::Log::LogSystem)
-namespace DPL
-{
-namespace Log
-{
+namespace DPL {
+namespace Log {
namespace // anonymous
{
const char *OLD_STYLE_LOGS_ENV_NAME = "DPL_USE_OLD_STYLE_LOGS";
-const char *OLD_STYLE_PEDANTIC_LOGS_ENV_NAME = "DPL_USE_OLD_STYLE_PEDANTIC_LOGS";
+const char *OLD_STYLE_PEDANTIC_LOGS_ENV_NAME =
+ "DPL_USE_OLD_STYLE_PEDANTIC_LOGS";
const char *OLD_STYLE_LOGS_MASK_ENV_NAME = "DPL_USE_OLD_STYLE_LOGS_MASK";
const char *DPL_LOG_OFF = "DPL_LOG_OFF";
} // namespace anonymous
-
bool LogSystem::IsLoggingEnabled() const
{
return m_isLoggingEnabled;
}
-LogSystem::LogSystem()
- : m_dlogProvider(NULL),
- m_oldStyleProvider(NULL),
- m_isLoggingEnabled(!getenv(DPL_LOG_OFF))
+LogSystem::LogSystem() :
+ m_dlogProvider(NULL),
+ m_oldStyleProvider(NULL),
+ m_isLoggingEnabled(!getenv(DPL_LOG_OFF))
{
bool oldStyleLogs = false;
bool oldStyleDebugLogs = true;
// Check environment settings about pedantic logs
const char *value = getenv(OLD_STYLE_LOGS_ENV_NAME);
- if (value != NULL && !strcmp(value, "1"))
+ if (value != NULL && !strcmp(value, "1")) {
oldStyleLogs = true;
+ }
value = getenv(OLD_STYLE_PEDANTIC_LOGS_ENV_NAME);
- if (value != NULL && !strcmp(value, "1"))
+ if (value != NULL && !strcmp(value, "1")) {
oldStylePedanticLogs = true;
+ }
value = getenv(OLD_STYLE_LOGS_MASK_ENV_NAME);
- if (value != NULL)
- {
+ if (value != NULL) {
size_t len = strlen(value);
- if (len >= 1)
- {
- if (value[0] == '0')
+ if (len >= 1) {
+ if (value[0] == '0') {
oldStyleDebugLogs = false;
- else if (value[0] == '1')
+ } else if (value[0] == '1') {
oldStyleDebugLogs = true;
+ }
}
- if (len >= 2)
- {
- if (value[1] == '0')
+ if (len >= 2) {
+ if (value[1] == '0') {
oldStyleInfoLogs = false;
- else if (value[1] == '1')
+ } else if (value[1] == '1') {
oldStyleInfoLogs = true;
+ }
}
- if (len >= 3)
- {
- if (value[2] == '0')
+ if (len >= 3) {
+ if (value[2] == '0') {
oldStyleWarningLogs = false;
- else if (value[2] == '1')
+ } else if (value[2] == '1') {
oldStyleWarningLogs = true;
+ }
}
- if (len >= 4)
- {
- if (value[3] == '0')
+ if (len >= 4) {
+ if (value[3] == '0') {
oldStyleErrorLogs = false;
- else if (value[3] == '1')
+ } else if (value[3] == '1') {
oldStyleErrorLogs = true;
+ }
}
}
// Setup default DLOG and old style logging
- if (oldStyleLogs)
- {
+ if (oldStyleLogs) {
// Old style
- m_oldStyleProvider = new OldStyleLogProvider(oldStyleDebugLogs, oldStyleInfoLogs, oldStyleWarningLogs, oldStyleErrorLogs, oldStylePedanticLogs);
+ m_oldStyleProvider = new OldStyleLogProvider(oldStyleDebugLogs,
+ oldStyleInfoLogs,
+ oldStyleWarningLogs,
+ oldStyleErrorLogs,
+ oldStylePedanticLogs);
AddProvider(m_oldStyleProvider);
- }
- else
- {
+ } else {
// DLOG
m_dlogProvider = new DLOGLogProvider();
AddProvider(m_dlogProvider);
LogSystem::~LogSystem()
{
// Delete all providers
- for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); iterator != m_providers.end(); ++iterator)
+ for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin();
+ iterator != m_providers.end();
+ ++iterator)
+ {
delete *iterator;
+ }
m_providers.clear();
void LogSystem::SetTag(const char* tag)
{
- if (m_dlogProvider != NULL)
+ if (m_dlogProvider != NULL) {
m_dlogProvider->SetTag(tag);
+ }
}
void LogSystem::AddProvider(AbstractLogProvider *provider)
m_providers.remove(provider);
}
-void LogSystem::Debug(const char *message, const char *filename, int line, const char *function)
+void LogSystem::Debug(const char *message,
+ const char *filename,
+ int line,
+ const char *function)
{
- for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); iterator != m_providers.end(); ++iterator)
+ for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin();
+ iterator != m_providers.end();
+ ++iterator)
+ {
(*iterator)->Debug(message, filename, line, function);
+ }
}
-void LogSystem::Info(const char *message, const char *filename, int line, const char *function)
+void LogSystem::Info(const char *message,
+ const char *filename,
+ int line,
+ const char *function)
{
- for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); iterator != m_providers.end(); ++iterator)
+ for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin();
+ iterator != m_providers.end();
+ ++iterator)
+ {
(*iterator)->Info(message, filename, line, function);
+ }
}
-void LogSystem::Warning(const char *message, const char *filename, int line, const char *function)
+void LogSystem::Warning(const char *message,
+ const char *filename,
+ int line,
+ const char *function)
{
- for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); iterator != m_providers.end(); ++iterator)
+ for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin();
+ iterator != m_providers.end();
+ ++iterator)
+ {
(*iterator)->Warning(message, filename, line, function);
+ }
}
-void LogSystem::Error(const char *message, const char *filename, int line, const char *function)
+void LogSystem::Error(const char *message,
+ const char *filename,
+ int line,
+ const char *function)
{
- for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); iterator != m_providers.end(); ++iterator)
+ for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin();
+ iterator != m_providers.end();
+ ++iterator)
+ {
(*iterator)->Error(message, filename, line, function);
+ }
}
-void LogSystem::Pedantic(const char *message, const char *filename, int line, const char *function)
+void LogSystem::Pedantic(const char *message,
+ const char *filename,
+ int line,
+ const char *function)
{
- for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin(); iterator != m_providers.end(); ++iterator)
+ for (AbstractLogProviderPtrList::iterator iterator = m_providers.begin();
+ iterator != m_providers.end();
+ ++iterator)
+ {
(*iterator)->Pedantic(message, filename, line, function);
+ }
}
-
}
} // namespace DPL
#include <cstring>
#include <sstream>
#include <sys/time.h>
+#include <unistd.h>
-namespace DPL
-{
-namespace Log
-{
+namespace DPL {
+namespace Log {
namespace // anonymous
{
using namespace DPL::Colors::Text;
const char *PEDANTIC_BEGIN = PURPLE_BEGIN;
const char *PEDANTIC_END = PURPLE_END;
-
std::string GetFormattedTime()
{
timeval tv;
localtime_r(&tv.tv_sec, &localNowTime);
char format[64];
- snprintf(format, sizeof(format), "%02i:%02i:%02i.%03i", localNowTime.tm_hour, localNowTime.tm_min, localNowTime.tm_sec, static_cast<int>(tv.tv_usec / 1000));
+ snprintf(format,
+ sizeof(format),
+ "%02i:%02i:%02i.%03i",
+ localNowTime.tm_hour,
+ localNowTime.tm_min,
+ localNowTime.tm_sec,
+ static_cast<int>(tv.tv_usec / 1000));
return format;
}
-
} // namespace anonymous
-std::string OldStyleLogProvider::FormatMessage(const char *message, const char *filename, int line, const char *function)
+std::string OldStyleLogProvider::FormatMessage(const char *message,
+ const char *filename,
+ int line,
+ const char *function)
{
std::ostringstream val;
val << std::string("[") << GetFormattedTime() << std::string("] [") <<
- static_cast<unsigned long>(pthread_self()) << "/" << static_cast<int>(getpid()) << std::string("] [") <<
- LocateSourceFileName(filename) << std::string(":") << line <<
- std::string("] ") << function << std::string("(): ") << message;
+ static_cast<unsigned long>(pthread_self()) << "/" <<
+ static_cast<int>(getpid()) << std::string("] [") <<
+ LocateSourceFileName(filename) << std::string(":") << line <<
+ std::string("] ") << function << std::string("(): ") << message;
return val.str();
}
-OldStyleLogProvider::OldStyleLogProvider(bool showDebug, bool showInfo, bool showWarning, bool showError, bool showPedantic)
- : m_showDebug(showDebug),
- m_showInfo(showInfo),
- m_showWarning(showWarning),
- m_showError(showError),
- m_showPedantic(showPedantic)
+OldStyleLogProvider::OldStyleLogProvider(bool showDebug,
+ bool showInfo,
+ bool showWarning,
+ bool showError,
+ bool showPedantic) :
+ m_showDebug(showDebug),
+ m_showInfo(showInfo),
+ m_showWarning(showWarning),
+ m_showError(showError),
+ m_showPedantic(showPedantic)
+{}
+
+void OldStyleLogProvider::Debug(const char *message,
+ const char *filename,
+ int line,
+ const char *function)
{
+ if (m_showDebug) {
+ fprintf(stdout, "%s%s%s\n", DEBUG_BEGIN,
+ FormatMessage(message, filename, line,
+ function).c_str(), DEBUG_END);
+ }
}
-void OldStyleLogProvider::Debug(const char *message, const char *filename, int line, const char *function)
+void OldStyleLogProvider::Info(const char *message,
+ const char *filename,
+ int line,
+ const char *function)
{
- if (m_showDebug)
- fprintf(stdout, "%s%s%s\n", DEBUG_BEGIN, FormatMessage(message, filename, line, function).c_str(), DEBUG_END);
+ if (m_showInfo) {
+ fprintf(stdout, "%s%s%s\n", INFO_BEGIN,
+ FormatMessage(message, filename, line,
+ function).c_str(), INFO_END);
+ }
}
-void OldStyleLogProvider::Info(const char *message, const char *filename, int line, const char *function)
+void OldStyleLogProvider::Warning(const char *message,
+ const char *filename,
+ int line,
+ const char *function)
{
- if (m_showInfo)
- fprintf(stdout, "%s%s%s\n", INFO_BEGIN, FormatMessage(message, filename, line, function).c_str(), INFO_END);
+ if (m_showWarning) {
+ fprintf(stdout, "%s%s%s\n", WARNING_BEGIN,
+ FormatMessage(message, filename, line,
+ function).c_str(), WARNING_END);
+ }
}
-void OldStyleLogProvider::Warning(const char *message, const char *filename, int line, const char *function)
+void OldStyleLogProvider::Error(const char *message,
+ const char *filename,
+ int line,
+ const char *function)
{
- if (m_showWarning)
- fprintf(stdout, "%s%s%s\n", WARNING_BEGIN, FormatMessage(message, filename, line, function).c_str(), WARNING_END);
+ if (m_showError) {
+ fprintf(stdout, "%s%s%s\n", ERROR_BEGIN,
+ FormatMessage(message, filename, line,
+ function).c_str(), ERROR_END);
+ }
}
-void OldStyleLogProvider::Error(const char *message, const char *filename, int line, const char *function)
+void OldStyleLogProvider::Pedantic(const char *message,
+ const char *filename,
+ int line,
+ const char *function)
{
- if (m_showError)
- fprintf(stdout, "%s%s%s\n", ERROR_BEGIN, FormatMessage(message, filename, line, function).c_str(), ERROR_END);
+ if (m_showPedantic) {
+ fprintf(stdout, "%s%s%s\n", PEDANTIC_BEGIN,
+ FormatMessage(message, filename, line,
+ function).c_str(), PEDANTIC_END);
+ }
}
-
-void OldStyleLogProvider::Pedantic(const char *message, const char *filename, int line, const char *function)
-{
- if (m_showPedantic)
- fprintf(stdout, "%s%s%s\n", PEDANTIC_BEGIN, FormatMessage(message, filename, line, function).c_str(), PEDANTIC_END);
-}
-
}
} // namespace DPL
#include <memory>
#include <string>
-namespace DPL
-{
-namespace RPC
-{
-namespace AbstractRPCConnectionEvents
-{
+namespace DPL {
+namespace RPC {
+namespace AbstractRPCConnectionEvents {
/**
* Asynchronous call event
*/
DECLARE_GENERIC_EVENT_0(ConnectionBrokenEvent)
} // namespace AbstractRPCConnectionEvents
-class AbstractRPCConnection
- : public DPL::Event::EventSupport<AbstractRPCConnectionEvents::AsyncCallEvent>,
- public DPL::Event::EventSupport<AbstractRPCConnectionEvents::ConnectionClosedEvent>,
- public DPL::Event::EventSupport<AbstractRPCConnectionEvents::ConnectionBrokenEvent>
+class AbstractRPCConnection :
+ public DPL::Event::EventSupport<AbstractRPCConnectionEvents::AsyncCallEvent>,
+ public DPL::Event::EventSupport<AbstractRPCConnectionEvents::
+ ConnectionClosedEvent>,
+ public DPL::Event::EventSupport<AbstractRPCConnectionEvents::
+ ConnectionBrokenEvent>
{
-public:
+ public:
class Exception
{
- public:
+ public:
DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, AsyncCallFailed)
DECLARE_EXCEPTION_TYPE(Base, PingFailed)
};
-public:
+ public:
virtual ~AbstractRPCConnection() {}
/**
* or RPC server accepting connection
*/
typedef void *AbstractRPCConnectionID;
-
}
} // namespace DPL
#include <dpl/event/event_support.h>
#include <dpl/generic_event.h>
-namespace DPL
-{
-namespace RPC
-{
-namespace AbstractRPCConnectorEvents
-{
+namespace DPL {
+namespace RPC {
+namespace AbstractRPCConnectorEvents {
/**
* RPC connection established
*/
-DECLARE_GENERIC_EVENT_2(ConnectionEstablishedEvent, AbstractRPCConnectionID, AbstractRPCConnection *)
+DECLARE_GENERIC_EVENT_2(ConnectionEstablishedEvent,
+ AbstractRPCConnectionID,
+ AbstractRPCConnection *)
} // namespace AbstractRPCClientEvents
-class AbstractRPCConnector
- : public DPL::Event::EventSupport<AbstractRPCConnectorEvents::ConnectionEstablishedEvent>
+class AbstractRPCConnector :
+ public DPL::Event::EventSupport<AbstractRPCConnectorEvents::
+ ConnectionEstablishedEvent>
{
-public:
+ public:
/**
* Destructor
*/
virtual ~AbstractRPCConnector() {}
};
-
}
} // namespace DPL
#include <dpl/socket/waitable_input_output_execution_context_support.h>
#include <memory>
-namespace DPL
+namespace DPL {
+namespace RPC {
+class GenericRPCConnection :
+ public AbstractRPCConnection,
+ private DPL::Socket::WaitableInputOutputExecutionContextSupport
{
-namespace RPC
-{
-
-class GenericRPCConnection
- : public AbstractRPCConnection,
- private DPL::Socket::WaitableInputOutputExecutionContextSupport
-{
-private:
+ private:
// WaitableInputOutputExecutionContextSupport
virtual void OnInputStreamRead();
virtual void OnInputStreamClosed();
std::unique_ptr<AbstractWaitableInputOutput> m_inputOutput;
-public:
+ public:
/**
* Costructor
*
- * Abstract waitable input/outobject is acquired by class and destroyed upon desctructor
+ * Abstract waitable input/outobject is acquired by class and destroyed upon
+ * destructor
*/
explicit GenericRPCConnection(AbstractWaitableInputOutput *inputOutput);
virtual ~GenericRPCConnection();
virtual void AsyncCall(const RPCFunction &function);
virtual void Ping();
};
-
}
} // namespace DPL
#include <dpl/socket/abstract_socket.h>
#include <set>
-namespace DPL
-{
-namespace RPC
-{
-
+namespace DPL {
+namespace RPC {
template<typename SocketType>
-class GenericSocketRPCClient
- : public AbstractRPCConnector,
- private DPL::Event::EventListener<DPL::Socket::AbstractSocketEvents::ConnectedEvent>
+class GenericSocketRPCClient :
+ public AbstractRPCConnector,
+ private DPL::Event::EventListener<DPL::Socket::AbstractSocketEvents::
+ ConnectedEvent>
{
-public:
+ public:
class Exception
{
- public:
+ public:
DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, OpenFailed)
DECLARE_EXCEPTION_TYPE(Base, CloseFailed)
};
-protected:
+ protected:
// Derived class implementations for connection managment
- virtual AbstractRPCConnection *OpenSpecificConnection(SocketType *socket) = 0;
+ virtual AbstractRPCConnection *OpenSpecificConnection(SocketType *socket) =
+ 0;
-private:
+ private:
typedef std::set<SocketType *> InternalConnectionSet;
InternalConnectionSet m_internalConnectionSet;
- virtual void OnEventReceived(const DPL::Socket::AbstractSocketEvents::ConnectedEvent &event)
+ virtual void OnEventReceived(
+ const DPL::Socket::AbstractSocketEvents::ConnectedEvent &event)
{
// Retrieve socket sender
SocketType *socket = static_cast<SocketType *>(event.GetSender());
// Is this connection still tracked ?
// It might have disappeared on close
- typename InternalConnectionSet::iterator iterator = m_internalConnectionSet.find(socket);
+ typename InternalConnectionSet::iterator iterator =
+ m_internalConnectionSet.find(socket);
- if (iterator == m_internalConnectionSet.end())
- {
+ if (iterator == m_internalConnectionSet.end()) {
LogPedantic("RPC client connection socket disappeared");
return;
}
AbstractRPCConnection *connection = OpenSpecificConnection(socket);
// Remove internal connection
- socket->EventSupport<DPL::Socket::AbstractSocketEvents::ConnectedEvent>::RemoveListener(this);
+ socket->EventSupport<DPL::Socket::AbstractSocketEvents::ConnectedEvent>
+ ::RemoveListener(this);
m_internalConnectionSet.erase(iterator);
// Retrieve ID once again
- AbstractRPCConnectionID connectionID = static_cast<AbstractRPCConnectionID>(socket);
+ AbstractRPCConnectionID connectionID =
+ static_cast<AbstractRPCConnectionID>(socket);
// Inform listeners
- DPL::Event::EventSupport<AbstractRPCConnectorEvents::ConnectionEstablishedEvent>::
+ DPL::Event::EventSupport<AbstractRPCConnectorEvents::
+ ConnectionEstablishedEvent>::
EmitEvent(AbstractRPCConnectorEvents::ConnectionEstablishedEvent(
- connectionID, connection, EventSender(this)), DPL::Event::EmitMode::Queued);
+ connectionID, connection, EventSender(
+ this)), DPL::Event::EmitMode::Queued);
}
-public:
+ public:
explicit GenericSocketRPCClient()
- {
- }
+ {}
virtual ~GenericSocketRPCClient()
{
SocketType *socket = new SocketType();
// Add socket listeners
- socket->EventSupport<DPL::Socket::AbstractSocketEvents::ConnectedEvent>::AddListener(this);
+ socket->EventSupport<DPL::Socket::AbstractSocketEvents::ConnectedEvent>
+ ::AddListener(this);
Try
{
// Start connecting to server
socket->Connect(Address(socketAddress));
}
- Catch (DPL::Socket::AbstractSocket::Exception::Base)
+ Catch(DPL::Socket::AbstractSocket::Exception::Base)
{
// Remove back socket listener
- socket->EventSupport<DPL::Socket::AbstractSocketEvents::ConnectedEvent>::RemoveListener(this);
+ socket->EventSupport<DPL::Socket::AbstractSocketEvents::
+ ConnectedEvent>::RemoveListener(this);
// Log debug message
LogPedantic("Cannot connect to: " << socketAddress.ToString());
m_internalConnectionSet.insert(socket);
// Debug info
- LogPedantic("Client started on interface: " << socket->GetLocalAddress().ToString());
+ LogPedantic(
+ "Client started on interface: " <<
+ socket->GetLocalAddress().ToString());
// Return unique identifier
return static_cast<AbstractRPCConnectionID>(socket);
SocketType *socket = static_cast<SocketType *>(connectionID);
// Find corresponding internal connection
- typename InternalConnectionSet::iterator iterator = m_internalConnectionSet.find(socket);
+ typename InternalConnectionSet::iterator iterator =
+ m_internalConnectionSet.find(socket);
- if (iterator == m_internalConnectionSet.end())
+ if (iterator == m_internalConnectionSet.end()) {
return;
+ }
// Close socket
socket->Close();
// Remove internal socket
- socket->EventSupport<DPL::Socket::AbstractSocketEvents::ConnectedEvent>::RemoveListener(this);
+ socket->EventSupport<DPL::Socket::AbstractSocketEvents::ConnectedEvent>
+ ::RemoveListener(this);
delete socket;
m_internalConnectionSet.erase(iterator);
void CloseAll()
{
- while (!m_internalConnectionSet.empty())
- Close(static_cast<AbstractRPCConnectionID>(*m_internalConnectionSet.begin()));
+ while (!m_internalConnectionSet.empty()) {
+ Close(static_cast<AbstractRPCConnectionID>(*m_internalConnectionSet
+ .begin()));
+ }
}
};
-
}
} // namespace DPL
#include <dpl/rpc/generic_rpc_connection.h>
-namespace DPL
-{
-namespace RPC
-{
-
+namespace DPL {
+namespace RPC {
template<class SocketType>
-class GenericSocketRPCConnection
- : public GenericRPCConnection
+class GenericSocketRPCConnection :
+ public GenericRPCConnection
{
-protected:
+ protected:
// Private construction with socket acquisition
- GenericSocketRPCConnection(SocketType *socket)
- : GenericRPCConnection(socket)
- {
- }
+ GenericSocketRPCConnection(SocketType *socket) :
+ GenericRPCConnection(socket)
+ {}
};
-
}
} // namespace DPL
#include <dpl/socket/abstract_socket.h>
#include <set>
-namespace DPL
-{
-namespace RPC
-{
-
+namespace DPL {
+namespace RPC {
template<typename SocketType>
-class GenericSocketRPCServer
- : public AbstractRPCConnector,
- private DPL::Event::EventListener<DPL::Socket::AbstractSocketEvents::AcceptEvent>
+class GenericSocketRPCServer :
+ public AbstractRPCConnector,
+ private DPL::Event::EventListener<DPL::Socket::AbstractSocketEvents::
+ AcceptEvent>
{
-public:
+ public:
class Exception
{
- public:
+ public:
DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, OpenFailed)
DECLARE_EXCEPTION_TYPE(Base, CloseFailed)
};
-protected:
+ protected:
// Derived class implementations for connection managment
- virtual AbstractRPCConnection *OpenSpecificConnection(SocketType *socket) = 0;
+ virtual AbstractRPCConnection *OpenSpecificConnection(SocketType *socket) =
+ 0;
-private:
+ private:
typedef std::set<SocketType *> InternalInterfaceSet;
InternalInterfaceSet m_internalInterfacesSet;
- virtual void OnEventReceived(const DPL::Socket::AbstractSocketEvents::AcceptEvent &event)
+ virtual void OnEventReceived(
+ const DPL::Socket::AbstractSocketEvents::AcceptEvent &event)
{
// Retrieve socket sender
SocketType *server = static_cast<SocketType *>(event.GetSender());
// Is this interface still tracked ?
// It might have disappeared on close
- typename InternalInterfaceSet::iterator iterator = m_internalInterfacesSet.find(server);
+ typename InternalInterfaceSet::iterator iterator =
+ m_internalInterfacesSet.find(server);
- if (iterator == m_internalInterfacesSet.end())
- {
+ if (iterator == m_internalInterfacesSet.end()) {
LogPedantic("RPC server interface socket disappeared");
return;
}
// Accept incoming client
SocketType *client = static_cast<SocketType *>(server->Accept());
- if(client == NULL)
- {
+ if (client == NULL) {
LogPedantic("Spontaneous accept on socket occurred");
return;
}
- LogPedantic("Client connected to server: " << client->GetRemoteAddress().ToString());
+ LogPedantic(
+ "Client connected to server: " <<
+ client->GetRemoteAddress().ToString());
// Open specific connection implementation
AbstractRPCConnection *connection = OpenSpecificConnection(client);
// Retrieve ID once again
- AbstractRPCConnectionID connectionID = static_cast<AbstractRPCConnectionID>(server);
+ AbstractRPCConnectionID connectionID =
+ static_cast<AbstractRPCConnectionID>(server);
// Inform listeners
- DPL::Event::EventSupport<AbstractRPCConnectorEvents::ConnectionEstablishedEvent>::
+ DPL::Event::EventSupport<AbstractRPCConnectorEvents::
+ ConnectionEstablishedEvent>::
EmitEvent(AbstractRPCConnectorEvents::ConnectionEstablishedEvent(
- connectionID, connection, EventSender(this)), DPL::Event::EmitMode::Queued);
+ connectionID, connection, EventSender(
+ this)), DPL::Event::EmitMode::Queued);
}
-public:
+ public:
explicit GenericSocketRPCServer()
- {
- }
+ {}
virtual ~GenericSocketRPCServer()
{
SocketType *socket = new SocketType();
// Add socket listener
- socket->EventSupport<DPL::Socket::AbstractSocketEvents::AcceptEvent>::AddListener(this);
+ socket->EventSupport<DPL::Socket::AbstractSocketEvents::AcceptEvent>::
+ AddListener(this);
Try
{
// Start listening
socket->Listen(8);
}
- Catch (DPL::Socket::AbstractSocket::Exception::Base)
+ Catch(DPL::Socket::AbstractSocket::Exception::Base)
{
// Remove back socket listener
- socket->EventSupport<DPL::Socket::AbstractSocketEvents::AcceptEvent>::RemoveListener(this);
+ socket->EventSupport<DPL::Socket::AbstractSocketEvents::AcceptEvent>
+ ::RemoveListener(this);
// Log debug
LogPedantic("Cannot start server: " << socketAddress.ToString());
m_internalInterfacesSet.insert(socket);
// Debug info
- LogPedantic("Server started on interface: " << socket->GetLocalAddress().ToString());
+ LogPedantic(
+ "Server started on interface: " <<
+ socket->GetLocalAddress().ToString());
// Return unique identifier
return static_cast<AbstractRPCConnectionID>(socket);
SocketType *socket = static_cast<SocketType *>(connectionID);
// Find corresponding internal connection
- typename InternalInterfaceSet::iterator iterator = m_internalInterfacesSet.find(socket);
+ typename InternalInterfaceSet::iterator iterator =
+ m_internalInterfacesSet.find(socket);
- if (iterator == m_internalInterfacesSet.end())
+ if (iterator == m_internalInterfacesSet.end()) {
return;
+ }
// Close socket
socket->Close();
// Remove socket listeners
- socket->EventSupport<DPL::Socket::AbstractSocketEvents::AcceptEvent>::RemoveListener(this);
+ socket->EventSupport<DPL::Socket::AbstractSocketEvents::AcceptEvent>::
+ RemoveListener(this);
delete socket;
m_internalInterfacesSet.erase(iterator);
void CloseAll()
{
- while (!m_internalInterfacesSet.empty())
- Close(static_cast<AbstractRPCConnectionID>(*m_internalInterfacesSet.begin()));
+ while (!m_internalInterfacesSet.empty()) {
+ Close(static_cast<AbstractRPCConnectionID>(*m_internalInterfacesSet
+ .begin()));
+ }
}
};
-
}
} // namespace DPL
#include <dpl/serialization.h>
#include <string>
-namespace DPL
-{
-namespace RPC
-{
-
+namespace DPL {
+namespace RPC {
class RPCFunction : public IStream
{
-protected:
+ protected:
BinaryQueue m_buffer; ///< Serialized RPC function call as a binary queue
-public:
+ public:
class Exception
{
- public:
+ public:
DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, ParseFailed)
};
* Constructor
*/
RPCFunction()
- {
- }
+ {}
/**
* Constructor
* Destructor
*/
virtual ~RPCFunction()
- {
- }
+ {}
/**
* Append argument to call
*
* @param[in] arg Template based argument to append
* @return none
- * @warning Carefully add any pointers to buffer because of template nature of this method
+ * @warning Carefully add any pointers to buffer because of template nature
+ * of this method
*/
template<typename Type>
void AppendArg(const Type &arg)
* (same as they were pushed onto RPC function argument stack)
*
* @param[out] arg Reference to output template based argument
- * @warning Carefully add any pointers to buffer because of template nature of this method
+ * @warning Carefully add any pointers to buffer because of template nature
+ * of this method
* @return none
*/
template<typename Type>
size_t argSize = sizeof(arg);
m_buffer.FlattenConsume(&argSize, sizeof(argSize));
- if (argSize != sizeof(arg))
+ if (argSize != sizeof(arg)) {
ThrowMsg(Exception::ParseFailed, "Stream parse CRC failed");
+ }
m_buffer.FlattenConsume(&arg, sizeof(arg));
}
- Catch (BinaryQueue::Exception::OutOfData)
+ Catch(BinaryQueue::Exception::OutOfData)
{
ReThrowMsg(Exception::ParseFailed, "Unexpected end of stream");
}
}
/**
- * Consume @a std::string argument from call. Arguments are retrieved in non-reversed order
+ * Consume @a std::string argument from call. Arguments are retrieved in
+ * non-reversed order
* (same as they were pushed onto RPC function argument stack)
*
* @param[out] arg Reference to output @a std::string argument
m_buffer.FlattenConsume(str.Get(), size);
arg = std::string(str.Get(), str.Get() + size);
}
- Catch (BinaryQueue::Exception::OutOfData)
+ Catch(BinaryQueue::Exception::OutOfData)
{
ReThrowMsg(Exception::ParseFailed, "Unexpected end of stream");
}
}
/**
- * Consume @a DPL::String argument from call. Arguments are converted to UTF-8 string
+ * Consume @a DPL::String argument from call. Arguments are converted to
+ * UTF-8 string
*
* @param[out] arg Reference to output @a DPL::String argument
* @return none
m_buffer.AppendCopy(bytes, num);
}
};
-
}
} // namespace DPL
#include <dpl/socket/unix_socket.h>
#include <string>
-namespace DPL
+namespace DPL {
+namespace RPC {
+class UnixSocketRPCClient :
+ public GenericSocketRPCClient<DPL::Socket::UnixSocket>
{
-namespace RPC
-{
-
-class UnixSocketRPCClient
- : public GenericSocketRPCClient<DPL::Socket::UnixSocket>
-{
-protected:
- virtual AbstractRPCConnection *OpenSpecificConnection(DPL::Socket::UnixSocket *socket);
+ protected:
+ virtual AbstractRPCConnection *OpenSpecificConnection(
+ DPL::Socket::UnixSocket *socket);
-public:
+ public:
AbstractRPCConnectionID Open(const std::string &fileName);
};
-
}
} // namespace DPL
#include <dpl/rpc/generic_socket_rpc_connection.h>
#include <dpl/socket/unix_socket.h>
-namespace DPL
+namespace DPL {
+namespace RPC {
+class UnixSocketRPCConnection :
+ public GenericSocketRPCConnection<DPL::Socket::UnixSocket>
{
-namespace RPC
-{
-
-class UnixSocketRPCConnection
- : public GenericSocketRPCConnection<DPL::Socket::UnixSocket>
-{
-public:
+ public:
// Socket acquisition
UnixSocketRPCConnection(DPL::Socket::UnixSocket *socket);
};
-
}
} // namespace DPL
#include <dpl/socket/unix_socket.h>
#include <string>
-namespace DPL
+namespace DPL {
+namespace RPC {
+class UnixSocketRPCServer :
+ public GenericSocketRPCServer<DPL::Socket::UnixSocket>
{
-namespace RPC
-{
-
-class UnixSocketRPCServer
- : public GenericSocketRPCServer<DPL::Socket::UnixSocket>
-{
-protected:
- virtual AbstractRPCConnection *OpenSpecificConnection(DPL::Socket::UnixSocket *socket);
+ protected:
+ virtual AbstractRPCConnection *OpenSpecificConnection(
+ DPL::Socket::UnixSocket *socket);
-public:
+ public:
AbstractRPCConnectionID Open(const std::string &fileName);
};
-
}
} // namespace DPL
#include <dpl/aligned.h>
#include <stdexcept>
-namespace DPL
-{
-namespace RPC
-{
+namespace DPL {
+namespace RPC {
namespace // anonymous
{
-namespace Protocol
-{
+namespace Protocol {
// Packet definitions
enum PacketType
{
unsigned short type;
} DPL_ALIGNED(1);
-struct AsyncCall
- : public Header
+struct AsyncCall :
+ public Header
{
unsigned char data[1];
} DPL_ALIGNED(1);
-
} // namespace Protocol
} // namespace anonymous
-GenericRPCConnection::GenericRPCConnection(AbstractWaitableInputOutput *inputOutput)
- : m_inputOutput(inputOutput)
+GenericRPCConnection::GenericRPCConnection(
+ AbstractWaitableInputOutput *inputOutput) :
+ m_inputOutput(inputOutput)
{
LogPedantic("Opening generic RPC...");
WaitableInputOutputExecutionContextSupport::Open(inputOutput);
{
FeedOutput();
}
- Catch (WaitableInputOutputExecutionContextSupport::Exception::NotOpened)
+ Catch(WaitableInputOutputExecutionContextSupport::Exception::NotOpened)
{
// Error occurred while feeding
ReThrow(AbstractRPCConnection::Exception::AsyncCallFailed);
{
FeedOutput();
}
- Catch (WaitableInputOutputExecutionContextSupport::Exception::NotOpened)
+ Catch(WaitableInputOutputExecutionContextSupport::Exception::NotOpened)
{
// Error occurred while feeding
ReThrow(AbstractRPCConnection::Exception::PingFailed);
LogPedantic("Interpreting " << m_inputStream.Size() << " bytes buffer");
// Enough bytes to read at least one header ?
- if (m_inputStream.Size() >= sizeof(Protocol::Header))
- {
+ if (m_inputStream.Size() >= sizeof(Protocol::Header)) {
// Begin consuming as much packets as it is possible
- while (m_inputStream.Size() >= sizeof(Protocol::Header))
- {
+ while (m_inputStream.Size() >= sizeof(Protocol::Header)) {
Protocol::Header header;
m_inputStream.Flatten(&header, sizeof(header));
- if (m_inputStream.Size() >= sizeof(Protocol::Header) + header.size)
+ if (m_inputStream.Size() >= sizeof(Protocol::Header) +
+ header.size)
{
LogPedantic("Will parse packet of type: " << header.type);
// Allocate new packet (header + real packet data)
- void *binaryPacket = malloc(sizeof(Protocol::Header) + header.size);
+ void *binaryPacket = malloc(
+ sizeof(Protocol::Header) + header.size);
- if (binaryPacket == NULL)
+ if (binaryPacket == NULL) {
throw std::bad_alloc();
+ }
// Get it from stream
- m_inputStream.FlattenConsume(binaryPacket, sizeof(Protocol::Header) + header.size);
+ m_inputStream.FlattenConsume(
+ binaryPacket,
+ sizeof(Protocol::Header) +
+ header.size);
// Parse specific packet
- switch (header.type)
+ switch (header.type) {
+ case Protocol::PacketType_AsyncCall:
{
- case Protocol::PacketType_AsyncCall:
- {
- BinaryQueue call;
-
- // No need to delete packet data, we can use it
- call.AppendUnmanaged(binaryPacket, sizeof(Protocol::Header) + header.size, &BinaryQueue::BufferDeleterFree, NULL);
-
- // ...but just remove protocol header
- call.Consume(sizeof(Protocol::Header));
-
- LogPedantic("Async call of size: " << header.size << " parsed");
-
- // Call async call event listeners
- DPL::Event::EventSupport<AbstractRPCConnectionEvents::AsyncCallEvent>::
- EmitEvent(AbstractRPCConnectionEvents::AsyncCallEvent(
- RPCFunction(call), EventSender(this)), DPL::Event::EmitMode::Queued);
- }
- break;
+ BinaryQueue call;
+
+ // No need to delete packet data, we can use it
+ call.AppendUnmanaged(binaryPacket,
+ sizeof(Protocol::Header) + header.size,
+ &BinaryQueue::BufferDeleterFree,
+ NULL);
+
+ // ...but just remove protocol header
+ call.Consume(sizeof(Protocol::Header));
+
+ LogPedantic(
+ "Async call of size: " << header.size <<
+ " parsed");
+
+ // Call async call event listeners
+ DPL::Event::EventSupport<AbstractRPCConnectionEvents::
+ AsyncCallEvent>::
+ EmitEvent(AbstractRPCConnectionEvents::AsyncCallEvent(
+ RPCFunction(call), EventSender(
+ this)), DPL::Event::EmitMode::Queued);
+ }
+ break;
- case Protocol::PacketType_PingPong:
- {
- // Reply with ping/pong
- Ping();
+ case Protocol::PacketType_PingPong:
+ {
+ // Reply with ping/pong
+ Ping();
- // Do not need packet data
- free(binaryPacket);
+ // Do not need packet data
+ free(binaryPacket);
- LogPedantic("Ping pong replied");
- }
- break;
+ LogPedantic("Ping pong replied");
+ }
+ break;
- default:
- LogPedantic("Warning: Unknown packet type");
- free(binaryPacket);
- break;
+ default:
+ LogPedantic("Warning: Unknown packet type");
+ free(binaryPacket);
+ break;
}
- }
- else
- {
+ } else {
LogPedantic("Too few bytes to read packet");
break;
}
}
- }
- else
- {
+ } else {
LogPedantic("Too few bytes to read header");
}
}
void GenericRPCConnection::OnInputStreamClosed()
{
// Emit closed event
- DPL::Event::EventSupport<AbstractRPCConnectionEvents::ConnectionClosedEvent>::
+ DPL::Event::EventSupport<AbstractRPCConnectionEvents::ConnectionClosedEvent>
+ ::
EmitEvent(AbstractRPCConnectionEvents::ConnectionClosedEvent(
- EventSender(this)), DPL::Event::EmitMode::Queued);
+ EventSender(this)), DPL::Event::EmitMode::Queued);
}
void GenericRPCConnection::OnInputStreamBroken()
{
// Emit broken event
- DPL::Event::EventSupport<AbstractRPCConnectionEvents::ConnectionBrokenEvent>::
+ DPL::Event::EventSupport<AbstractRPCConnectionEvents::ConnectionBrokenEvent>
+ ::
EmitEvent(AbstractRPCConnectionEvents::ConnectionBrokenEvent(
- EventSender(this)), DPL::Event::EmitMode::Queued);
+ EventSender(this)), DPL::Event::EmitMode::Queued);
}
-
}
} // namespace DPL
* @file generic_socket_rpc_client.cpp
* @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
* @version 1.0
- * @brief This file is the implementation file of generic socket RPC client
+ * @brief This file is the implementation file of generic socket RPC
+ * client
*/
#include <stddef.h>
#include <dpl/rpc/generic_socket_rpc_client.h>
* @file generic_socket_rpc_connection.cpp
* @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
* @version 1.0
- * @brief This file is the implementation file of generic socket RPC connection
+ * @brief This file is the implementation file of generic socket RPC
+ * connection
*/
#include <stddef.h>
#include <dpl/rpc/generic_socket_rpc_connection.h>
#include <dpl/rpc/unix_socket_rpc_client.h>
#include <dpl/rpc/unix_socket_rpc_connection.h>
-namespace DPL
-{
-namespace RPC
-{
-AbstractRPCConnection *UnixSocketRPCClient::OpenSpecificConnection(DPL::Socket::UnixSocket *socket)
+namespace DPL {
+namespace RPC {
+AbstractRPCConnection *UnixSocketRPCClient::OpenSpecificConnection(
+ DPL::Socket::UnixSocket *socket)
{
// Allocate new UNIX/RPC connection object
UnixSocketRPCConnection *connection = new UnixSocketRPCConnection(socket);
AbstractRPCConnectionID UnixSocketRPCClient::Open(const std::string &fileName)
{
- return GenericSocketRPCClient<DPL::Socket::UnixSocket>::Open(Address(fileName));
+ return GenericSocketRPCClient<DPL::Socket::UnixSocket>::Open(Address(
+ fileName));
}
}
} // namespace DPL
* @file unix_socket_rpc_connection.cpp
* @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
* @version 1.0
- * @brief This file is the implementation file of unix socket RPC connection
+ * @brief This file is the implementation file of unix socket RPC
+ * connection
*/
#include <stddef.h>
#include <dpl/rpc/unix_socket_rpc_connection.h>
-namespace DPL
-{
-namespace RPC
-{
-UnixSocketRPCConnection::UnixSocketRPCConnection(DPL::Socket::UnixSocket *socket)
- : GenericSocketRPCConnection<DPL::Socket::UnixSocket>(socket)
-{
-}
+namespace DPL {
+namespace RPC {
+UnixSocketRPCConnection::UnixSocketRPCConnection(
+ DPL::Socket::UnixSocket *socket) :
+ GenericSocketRPCConnection<DPL::Socket::UnixSocket>(socket)
+{}
}
} // namespace DPL
#include <dpl/rpc/unix_socket_rpc_server.h>
#include <dpl/rpc/unix_socket_rpc_connection.h>
-namespace DPL
-{
-namespace RPC
-{
-AbstractRPCConnection *UnixSocketRPCServer::OpenSpecificConnection(DPL::Socket::UnixSocket *socket)
+namespace DPL {
+namespace RPC {
+AbstractRPCConnection *UnixSocketRPCServer::OpenSpecificConnection(
+ DPL::Socket::UnixSocket *socket)
{
// Allocate new UNIX/RPC connection object
UnixSocketRPCConnection *connection = new UnixSocketRPCConnection(socket);
AbstractRPCConnectionID UnixSocketRPCServer::Open(const std::string &fileName)
{
- return GenericSocketRPCServer<DPL::Socket::UnixSocket>::Open(Address(fileName));
+ return GenericSocketRPCServer<DPL::Socket::UnixSocket>::Open(Address(
+ fileName));
}
-
}
} // namespace DPL
using namespace DPL::DB::ORM::security_origin;
namespace SecurityOriginDB {
-
#define SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN Try
#define SQL_CONNECTION_EXCEPTION_HANDLER_END(message) \
const char* const SECURITY_ORIGIN_DB_NAME = ".security_origin.db";
const char* const SECURITY_ORIGIN_DB_SQL_PATH =
"/usr/share/wrt-engine/security_origin_db.sql";
+const char* const SECURITY_DATABASE_JOURNAL_FILENAME = "-journal";
+
+const int WEB_APPLICATION_UID = 5000;
+const int WEB_APPLICATION_GUID = 5000;
std::string createDatabasePath(const WrtDB::WidgetPkgName &pkgName)
{
- std::stringstream filename;
+ std::stringstream filename;
- filename << WrtDB::WidgetConfig::GetWidgetPersistentStoragePath(pkgName)
- << "/"
- << SECURITY_ORIGIN_DB_NAME;
- return filename.str();
+ filename << WrtDB::WidgetConfig::GetWidgetPersistentStoragePath(pkgName)
+ << "/"
+ << SECURITY_ORIGIN_DB_NAME;
+ return filename.str();
}
std::string createDatabasePath(int widgetHandle)
using namespace WrtDB::WidgetConfig;
using namespace WrtDB::GlobalConfig;
- WrtDB::WidgetPkgName pkgname;
+ WrtDB::TizenAppId appid;
Try
{
- pkgname = WrtDB::WidgetDAOReadOnly::getPkgName(widgetHandle);
+ appid = WrtDB::WidgetDAOReadOnly::getTzAppId(widgetHandle);
}
Catch(DPL::DB::SqlConnection::Exception::Base) {
LogError("Failed to get database Path");
}
- return createDatabasePath(pkgname);
+ return createDatabasePath(appid);
}
void checkDatabase(std::string databasePath)
struct stat buffer;
if (stat(databasePath.c_str(), &buffer) != 0) {
-
//Create fresh database
LogInfo("Creating database " << databasePath);
SECURITY_ORIGIN_DB_OPTION);
con.ExecCommand(ssBuffer.str().c_str());
}
+
+ if(chown(databasePath.c_str(),
+ WEB_APPLICATION_UID,
+ WEB_APPLICATION_GUID) != 0)
+ {
+ ThrowMsg(SecurityOriginDAO::Exception::DatabaseError,
+ "Fail to change uid/guid");
+ }
+ std::string databaseJournal =
+ databasePath + SECURITY_DATABASE_JOURNAL_FILENAME;
+ if(chown(databaseJournal.c_str(),
+ WEB_APPLICATION_UID,
+ WEB_APPLICATION_GUID) != 0)
+ {
+ ThrowMsg(SecurityOriginDAO::Exception::DatabaseError,
+ "Fail to change uid/guid");
+ }
}
SQL_CONNECTION_EXCEPTION_HANDLER_END("Fail to get database Path")
}
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
SecurityOriginDataList list;
- SECURITY_ORIGIN_DB_SELECT(select, SecurityOriginInfo, &m_securityOriginDBInterface);
+ SECURITY_ORIGIN_DB_SELECT(select,
+ SecurityOriginInfo,
+ &m_securityOriginDBInterface);
typedef std::list<SecurityOriginInfo::Row> RowList;
RowList rowList = select->GetRowList();
SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get data list")
}
-Result SecurityOriginDAO::getResult(const SecurityOriginData &securityOriginData)
+Result SecurityOriginDAO::getResult(
+ const SecurityOriginData &securityOriginData)
+{
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ SECURITY_ORIGIN_DB_SELECT(select,
+ SecurityOriginInfo,
+ &m_securityOriginDBInterface);
+ select->Where(
+ And(And(And(Equals<SecurityOriginInfo::feature>(securityOriginData.
+ feature),
+ Equals<SecurityOriginInfo::scheme>(securityOriginData.
+ origin.scheme)),
+ Equals<SecurityOriginInfo::host>(securityOriginData.origin.
+ host)),
+ Equals<SecurityOriginInfo::port>(securityOriginData.origin.port)));
+ SecurityOriginInfo::Select::RowList rows = select->GetRowList();
+
+ if (rows.empty()) {
+ return RESULT_UNKNOWN;
+ }
+ SecurityOriginInfo::Row row = rows.front();
+ return static_cast<Result>(row.Get_result());
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END(
+ "Failed to get result for security origin")
+}
+
+bool SecurityOriginDAO::isReadOnly(const SecurityOriginData &securityOriginData)
{
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
return RESULT_UNKNOWN;
}
SecurityOriginInfo::Row row = rows.front();
- return static_cast<Result>(row.Get_result());
+ return row.Get_readonly() ? true : false;
}
- SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get result for security origin")
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Fail to get readonly property")
}
void SecurityOriginDAO::setSecurityOriginData(const SecurityOriginData &securityOriginData,
- const Result result)
+ const Result result,
+ const bool readOnly)
{
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
row.Set_host(securityOriginData.origin.host);
row.Set_port(securityOriginData.origin.port);
row.Set_result(result);
+ row.Set_readonly(readOnly ? 1 : 0);
if (true == hasResult(securityOriginData)) {
SECURITY_ORIGIN_DB_UPDATE(update,
- SecurityOriginInfo,
- &m_securityOriginDBInterface);
+ SecurityOriginInfo,
+ &m_securityOriginDBInterface);
update->Values(row);
update->Execute();
} else {
SQL_CONNECTION_EXCEPTION_HANDLER_END("Fail to set security origin data")
}
+void SecurityOriginDAO::setPrivilegeSecurityOriginData(const Feature feature,
+ bool isOnlyAllowedLocalOrigin)
+{
+ Origin origin(DPL::FromUTF8String("file"),
+ DPL::FromUTF8String(""),
+ 0);
+ if (!isOnlyAllowedLocalOrigin) {
+ origin.scheme = DPL::FromUTF8String("");
+ }
+ SecurityOriginData data(feature, origin);
+ setSecurityOriginData(data, RESULT_ALLOW_ALWAYS, true);
+}
+
void SecurityOriginDAO::removeSecurityOriginData(
const SecurityOriginData &securityOriginData)
{
ScopedTransaction transaction(&m_securityOriginDBInterface);
if (true == hasResult(securityOriginData)) {
- SECURITY_ORIGIN_DB_DELETE(del, SecurityOriginInfo, &m_securityOriginDBInterface)
+ SECURITY_ORIGIN_DB_DELETE(del,
+ SecurityOriginInfo,
+ &m_securityOriginDBInterface)
del->Where(
- And(And(And(Equals<SecurityOriginInfo::feature>(securityOriginData.feature),
- Equals<SecurityOriginInfo::scheme>(securityOriginData.origin.scheme)),
- Equals<SecurityOriginInfo::host>(securityOriginData.origin.host)),
- Equals<SecurityOriginInfo::port>(securityOriginData.origin.port)));
+ And(And(And(Equals<SecurityOriginInfo::feature>(
+ securityOriginData.feature),
+ Equals<SecurityOriginInfo::scheme>(
+ securityOriginData.origin.scheme)),
+ Equals<SecurityOriginInfo::host>(securityOriginData.
+ origin.host)),
+ Equals<SecurityOriginInfo::port>(securityOriginData.origin.
+ port)));
del->Execute();
transaction.Commit();
}
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
ScopedTransaction transaction(&m_securityOriginDBInterface);
- SECURITY_ORIGIN_DB_DELETE(del, SecurityOriginInfo, &m_securityOriginDBInterface)
+ SECURITY_ORIGIN_DB_DELETE(del,
+ SecurityOriginInfo,
+ &m_securityOriginDBInterface)
del->Where(Equals<SecurityOriginInfo::result>(result));
del->Execute();
transaction.Commit();
bool SecurityOriginDAO::hasResult(const SecurityOriginData &securityOriginData)
{
- Result res=getResult(securityOriginData);
+ Result res = getResult(securityOriginData);
return (res != RESULT_UNKNOWN);
}
#undef SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
#undef SQL_CONNECTION_EXCEPTION_HANDLER_END
-
} // namespace SecurityOriginDB
#include <dpl/log/log.h>
namespace SecurityOriginDB {
-} // namespace SecurityOriginDB
\ No newline at end of file
+const std::map<std::string, Feature> g_W3CPrivilegeTextMap = {
+ {"http://tizen.org/privilege/location", FEATURE_GEOLOCATION},
+ {"http://tizen.org/privilege/notification", FEATURE_WEB_NOTIFICATION},
+ {"http://tizen.org/privilege/mediacapture", FEATURE_USER_MEDIA}
+};
+} // namespace SecurityOriginDB
#include <dpl/wrt-dao-ro/common_dao_types.h>
namespace SecurityOriginDB {
-
class SecurityOriginDAO
{
public:
virtual ~SecurityOriginDAO();
SecurityOriginDataList getSecurityOriginDataList();
Result getResult(const SecurityOriginData &securityOriginData);
+ bool isReadOnly(const SecurityOriginData &securityOriginData);
void setSecurityOriginData(const SecurityOriginData &securityOriginData,
- const Result result);
+ const Result result,
+ const bool readOnly = false);
+ void setPrivilegeSecurityOriginData(const Feature feature,
+ bool isOnlyAllowedLocalOrigin = true);
void removeSecurityOriginData(const SecurityOriginData &securityOriginData);
void removeSecurityOriginData(const Result result);
+
private:
std::string m_securityOriginDBPath;
DPL::DB::ThreadDatabaseSupport m_securityOriginDBInterface;
};
typedef std::shared_ptr<SecurityOriginDAO> SecurityOriginDAOPtr;
-
} // namespace SecurityOriginDB
#endif // _SECURITY_ORIGIN_DAO_H_
#include <list>
#include <memory>
+#include <map>
#include <dpl/string.h>
namespace SecurityOriginDB {
-
enum Feature
{
FEATURE_START = 0,
FEATURE_GEOLOCATION = 0,
FEATURE_WEB_NOTIFICATION,
- FEATURE_WEB_DATABASE,
- FEATURE_FILE_SYSTEM_ACCESS,
- FEATURE_END = FEATURE_FILE_SYSTEM_ACCESS
+ FEATURE_USER_MEDIA,
+ FEATURE_END = FEATURE_USER_MEDIA
};
enum Result
RESULT_DENY_ALWAYS
};
+extern const std::map<std::string, Feature> g_W3CPrivilegeTextMap;
+
struct Origin
{
DPL::String scheme;
scheme(Scheme),
host(Host),
port(Port)
- {
- }
+ {}
- bool operator== (const Origin& other) const
+ bool operator== (const Origin& other) const
{
return (!DPL::StringCompare(scheme, other.scheme) &&
- !DPL::StringCompare(host, other.host) &&
- port == other.port);
+ !DPL::StringCompare(host, other.host) &&
+ port == other.port);
}
bool operator!= (const Origin& other) const
SecurityOriginData(const Feature features, const Origin& ori) :
feature(features),
origin(ori)
- {
- }
+ {}
bool operator== (const SecurityOriginData& other) const
{
typedef std::shared_ptr<SecurityOriginData> SecurityOriginDataPtr;
typedef std::list<SecurityOriginDataPtr> SecurityOriginDataList;
-
} // namespace SecurityOriginDB
#endif // _SECURITY_ORIGIN_DAO_TYPES_H_
extern DPL::Mutex g_securityOriginDBQueriesMutex;
#define SECURITY_ORIGIN_DB_INTERNAL(tlsCommand, InternalType, interface) \
- static DPL::ThreadLocalVariable<InternalType> *tlsCommand ## Ptr = NULL; \
+ static DPL::ThreadLocalVariable<InternalType> *tlsCommand##Ptr = NULL; \
{ \
DPL::Mutex::ScopedLock lock(&g_securityOriginDBQueriesMutex); \
- if (!tlsCommand ## Ptr) { \
+ if (!tlsCommand##Ptr) { \
static DPL::ThreadLocalVariable<InternalType> tmp; \
- tlsCommand ## Ptr = &tmp; \
+ tlsCommand##Ptr = &tmp; \
} \
} \
- DPL::ThreadLocalVariable<InternalType> &tlsCommand = *tlsCommand ## Ptr; \
+ DPL::ThreadLocalVariable<InternalType> &tlsCommand = *tlsCommand##Ptr; \
if (tlsCommand.IsNull()) { tlsCommand = InternalType(interface); }
#define SECURITY_ORIGIN_DB_SELECT(name, type, interface) \
SQL(BEGIN TRANSACTION;)
CREATE_TABLE(SecurityOriginInfo)
- COLUMN_NOT_NULL(feature, INT, )
- COLUMN_NOT_NULL(scheme, TEXT,DEFAULT '')
- COLUMN_NOT_NULL(host, TEXT,DEFAULT '')
- COLUMN_NOT_NULL(port, INT, DEFAULT 0)
- COLUMN_NOT_NULL(result, INT, DEFAULT 0)
+ COLUMN_NOT_NULL(feature, INT, )
+ COLUMN_NOT_NULL(scheme, TEXT,DEFAULT '')
+ COLUMN_NOT_NULL(host, TEXT,DEFAULT '')
+ COLUMN_NOT_NULL(port, INT, DEFAULT 0)
+ COLUMN_NOT_NULL(result, INT, DEFAULT 0)
+ COLUMN_NOT_NULL(readonly, INT, DEFAULT 0)
TABLE_CONSTRAINTS(PRIMARY KEY(feature,scheme,host,port))
CREATE_TABLE_END()
#include <dpl/exception.h>
#include <dpl/address.h>
-namespace DPL
-{
-namespace Socket
-{
-namespace AbstractSocketEvents
-{
+namespace DPL {
+namespace Socket {
+namespace AbstractSocketEvents {
// Successfuly connected to server socket
DECLARE_GENERIC_EVENT_0(ConnectedEvent)
DECLARE_GENERIC_EVENT_0(WriteEvent)
} // namespace AbstractSocketEvents
-class AbstractSocket
- : public AbstractWaitableInputOutput,
-
public DPL::Event::EventSupport<AbstractSocketEvents::ConnectedEvent>,
-
public DPL::Event::EventSupport<AbstractSocketEvents::AcceptEvent>,
-
public DPL::Event::EventSupport<AbstractSocketEvents::ReadEvent>,
-
public DPL::Event::EventSupport<AbstractSocketEvents::WriteEvent>
+class AbstractSocket :
+ public AbstractWaitableInputOutput,
+ public DPL::Event::EventSupport<AbstractSocketEvents::ConnectedEvent>,
+ public DPL::Event::EventSupport<AbstractSocketEvents::AcceptEvent>,
+ public DPL::Event::EventSupport<AbstractSocketEvents::ReadEvent>,
+ public DPL::Event::EventSupport<AbstractSocketEvents::WriteEvent>
{
-public:
+ public:
class Exception
{
- public:
- DECLARE_EXCEPTION_TYPE(DPL::Exception, Base) ///< Base abstract socket exception
-
- DECLARE_EXCEPTION_TYPE(Base, OpenFailed) ///< Fatal error occurred during open socket descriptor. Socket state is inconsistent and it should be not used anymore.
-
- DECLARE_EXCEPTION_TYPE(Base, ConnectFailed) ///< Fatal error occurred during connect. Socket state is inconsistent and it should be not used anymore.
- ///< Warning: This exception does not mean that socket did not succeed to connect, see CannotConnect
- ///< for this specific scenario
-
- DECLARE_EXCEPTION_TYPE(Base, SetNonBlockingFailed) ///< Fatal error occurred during setting socket to non-blocking mode. Socket state is inconsistent and it should be not used anymore.
-
- DECLARE_EXCEPTION_TYPE(Base, BindFailed) ///< Fatal error occurred during bind. Socket state is inconsistent and it should be not used anymore.
-
- DECLARE_EXCEPTION_TYPE(Base, AcceptFailed) ///< Fatal error occurred during accept. Socket state is inconsistent and it should be not used anymore.
-
- DECLARE_EXCEPTION_TYPE(Base, ListenFailed) ///< Fatal error occurred during listen. Socket state is inconsistent and it should be not used anymore.
-
- DECLARE_EXCEPTION_TYPE(Base, CloseFailed) ///< Fatal error occurred during close. Socket state is inconsistent and it should be not used anymore.
-
- DECLARE_EXCEPTION_TYPE(Base, ReadFailed) ///< Fatal error occurred during read. Socket state is inconsistent and it should be not used anymore.
- ///< Warning: This exception does not mean that connection was broken, see ConnectionBroken
- ///< for this specific scenario
-
- DECLARE_EXCEPTION_TYPE(Base, WriteFailed) ///< Fatal error occurred during write. Socket state is inconsistent and it should be not used anymore.
- ///< Warning: This exception does not mean that connection was broken, see ConnectionBroken
- ///< for this specific scenario
-
- DECLARE_EXCEPTION_TYPE(Base, GetPeerNameFailed) ///< Fatal error occurred during getpeername or getsockname. Socket state is inconsistent and it should be not used anymore.
-
- DECLARE_EXCEPTION_TYPE(Base, CannotConnect) ///< Cannot connect to remote socket. This is not fatal error, socket state is still consistent and it can be reconnected.
-
- DECLARE_EXCEPTION_TYPE(Base, ConnectionBroken) ///< Connection was broken. This is not fatal error, socket state is still consistent and it can be reconnected.
+ public:
+ DECLARE_EXCEPTION_TYPE(DPL::Exception, Base) ///< Base abstract
+ // socket exception
+
+ DECLARE_EXCEPTION_TYPE(Base, OpenFailed) ///< Fatal error
+ // occurred during
+ // open socket
+ // descriptor. Socket
+ // state is
+ // inconsistent and
+ // it should be not
+ // used anymore.
+
+ DECLARE_EXCEPTION_TYPE(Base, ConnectFailed) ///< Fatal error
+ // occurred during
+ // connect. Socket
+ // state is
+ // inconsistent and
+ // it should be not
+ // used anymore.
+ ///< Warning: This
+ // exception does not
+ // mean that socket
+ // did not succeed to
+ // connect, see
+ // CannotConnect
+ ///< for this
+ // specific scenario
+
+ DECLARE_EXCEPTION_TYPE(Base, SetNonBlockingFailed) ///< Fatal error
+ // occurred during
+ // setting socket to
+ // non-blocking mode.
+ // Socket state is
+ // inconsistent and
+ // it should be not
+ // used anymore.
+
+ DECLARE_EXCEPTION_TYPE(Base, BindFailed) ///< Fatal error
+ // occurred during
+ // bind. Socket state
+ // is inconsistent
+ // and it should be
+ // not used anymore.
+
+ DECLARE_EXCEPTION_TYPE(Base, AcceptFailed) ///< Fatal error
+ // occurred during
+ // accept. Socket
+ // state is
+ // inconsistent and
+ // it should be not
+ // used anymore.
+
+ DECLARE_EXCEPTION_TYPE(Base, ListenFailed) ///< Fatal error
+ // occurred during
+ // listen. Socket
+ // state is
+ // inconsistent and
+ // it should be not
+ // used anymore.
+
+ DECLARE_EXCEPTION_TYPE(Base, CloseFailed) ///< Fatal error
+ // occurred during
+ // close. Socket
+ // state is
+ // inconsistent and
+ // it should be not
+ // used anymore.
+
+ DECLARE_EXCEPTION_TYPE(Base, ReadFailed) ///< Fatal error
+ // occurred during
+ // read. Socket state
+ // is inconsistent
+ // and it should be
+ // not used anymore.
+ ///< Warning: This
+ // exception does not
+ // mean that
+ // connection was
+ // broken, see
+ // ConnectionBroken
+ ///< for this
+ // specific scenario
+
+ DECLARE_EXCEPTION_TYPE(Base, WriteFailed) ///< Fatal error
+ // occurred during
+ // write. Socket
+ // state is
+ // inconsistent and
+ // it should be not
+ // used anymore.
+ ///< Warning: This
+ // exception does not
+ // mean that
+ // connection was
+ // broken, see
+ // ConnectionBroken
+ ///< for this
+ // specific scenario
+
+ DECLARE_EXCEPTION_TYPE(Base, GetPeerNameFailed) ///< Fatal error
+ // occurred during
+ // getpeername or
+ // getsockname.
+ // Socket state is
+ // inconsistent and
+ // it should be not
+ // used anymore.
+
+ DECLARE_EXCEPTION_TYPE(Base, CannotConnect) ///< Cannot connect
+ // to remote socket.
+ // This is not fatal
+ // error, socket
+ // state is still
+ // consistent and it
+ // can be
+ // reconnected.
+
+ DECLARE_EXCEPTION_TYPE(Base, ConnectionBroken) ///< Connection was
+ // broken. This is
+ // not fatal error,
+ // socket state is
+ // still consistent
+ // and it can be
+ // reconnected.
};
-public:
+ public:
virtual ~AbstractSocket() {}
// Connect to remote host
// Remote socket address
virtual Address GetRemoteAddress() const = 0;
};
-
}
} // namespace DPL
#include <errno.h>
#include <dpl/assert.h>
-namespace DPL
-{
-namespace Socket
-{
+namespace DPL {
+namespace Socket {
//
// Generic abstract socket implementation
// Execution context is inherited
//
template<typename SocketType>
-class GenericSocket
- : public AbstractSocket,
- private WaitableHandleWatchSupport::WaitableHandleListener
+class GenericSocket :
+ public AbstractSocket,
+ private WaitableHandleWatchSupport::WaitableHandleListener
{
-protected:
+ protected:
/**
* Translate generic Address to specific socket kernel structure
*
* @warning Must be implemented in derived class
*/
- virtual std::pair<sockaddr *, socklen_t> TranslateAddressGenericToSpecific(const Address &address) const = 0;
+ virtual std::pair<sockaddr *, socklen_t> TranslateAddressGenericToSpecific(
+ const Address &address) const = 0;
/**
* Translate specific socket kernel structure to generic Address
*
* @warning Must be implemented in derived class
*/
- virtual Address TranslateAddressSpecificToGeneric(sockaddr *, socklen_t) const = 0;
+ virtual Address TranslateAddressSpecificToGeneric(sockaddr *,
+ socklen_t) const = 0;
/**
* Get specific socket kernel structure size
*/
virtual int AllocSpecificDescriptor() const = 0;
-private:
+ private:
// Constants
static const size_t DEFAULT_READ_BUFFER_SIZE = 4096;
// Socket handle
- int m_socket; // FIXME: Consider generalization to WaitableHandle upon leaving nix platform
+ int m_socket; // FIXME: Consider generalization to WaitableHandle upon
+ // leaving nix platform
// Internal state
enum InternalState
void SetNonBlocking()
{
// Set non-blocking mode
- if (fcntl(m_socket, F_SETFL, O_NONBLOCK | fcntl(m_socket, F_GETFL)) == -1)
+ if (fcntl(m_socket, F_SETFL, O_NONBLOCK |
+ fcntl(m_socket, F_GETFL)) == -1)
+ {
Throw(AbstractSocket::Exception::SetNonBlockingFailed);
+ }
}
// WaitableHandleWatchSupport::WaitableHandleListener
- virtual void OnWaitableHandleEvent(WaitableHandle waitableHandle, WaitMode::Type mode)
+ virtual void OnWaitableHandleEvent(WaitableHandle waitableHandle,
+ WaitMode::Type mode)
{
(void)waitableHandle;
Assert(waitableHandle == m_socket);
- switch (m_internalState)
- {
- case InternalState_None:
- break;
-
- case InternalState_Prepare:
- Assert(0 && "Invalid internal generic socket state!");
- break;
+ switch (m_internalState) {
+ case InternalState_None:
+ break;
- case InternalState_Listening:
- Assert(mode == WaitMode::Read);
+ case InternalState_Prepare:
+ Assert(0 && "Invalid internal generic socket state!");
+ break;
- // New client waiting for accept
- DPL::Event::EventSupport<AbstractSocketEvents::AcceptEvent>::
- EmitEvent(AbstractSocketEvents::AcceptEvent(
- EventSender(this)), DPL::Event::EmitMode::Queued);
+ case InternalState_Listening:
+ Assert(mode == WaitMode::Read);
- // Done
- break;
+ // New client waiting for accept
+ DPL::Event::EventSupport<AbstractSocketEvents::AcceptEvent>::
+ EmitEvent(AbstractSocketEvents::AcceptEvent(
+ EventSender(this)), DPL::Event::EmitMode::Queued);
- case InternalState_Connecting:
- Assert(mode == WaitMode::Write);
+ // Done
+ break;
- // Connected to server
- RemoveConnectWatch();
- m_internalState = InternalState_Connected;
+ case InternalState_Connecting:
+ Assert(mode == WaitMode::Write);
- // Add read watch
- AddReadWatch();
-
- // Emit event
- DPL::Event::EventSupport<AbstractSocketEvents::ConnectedEvent>::
- EmitEvent(AbstractSocketEvents::ConnectedEvent(
- EventSender(this)), DPL::Event::EmitMode::Queued);
+ // Connected to server
+ RemoveConnectWatch();
+ m_internalState = InternalState_Connected;
- // Done
- break;
+ // Add read watch
+ AddReadWatch();
- case InternalState_Connected:
- if (mode == WaitMode::Read)
- {
- // Emit ReadEvent
- DPL::Event::EventSupport<AbstractSocketEvents::ReadEvent>::
- EmitEvent(AbstractSocketEvents::ReadEvent(
- EventSender(this)), DPL::Event::EmitMode::Queued);
- }
- else if (mode == WaitMode::Write)
- {
- // Emit WriteEvent
- DPL::Event::EventSupport<AbstractSocketEvents::WriteEvent>::
- EmitEvent(AbstractSocketEvents::WriteEvent(
- EventSender(this)), DPL::Event::EmitMode::Queued);
- }
- else
- {
- Assert(0);
- }
+ // Emit event
+ DPL::Event::EventSupport<AbstractSocketEvents::ConnectedEvent>::
+ EmitEvent(AbstractSocketEvents::ConnectedEvent(
+ EventSender(this)), DPL::Event::EmitMode::Queued);
+
+ // Done
+ break;
+
+ case InternalState_Connected:
+ if (mode == WaitMode::Read) {
+ // Emit ReadEvent
+ DPL::Event::EventSupport<AbstractSocketEvents::ReadEvent>::
+ EmitEvent(AbstractSocketEvents::ReadEvent(
+ EventSender(
+ this)), DPL::Event::EmitMode::Queued);
+ } else if (mode == WaitMode::Write) {
+ // Emit WriteEvent
+ DPL::Event::EventSupport<AbstractSocketEvents::WriteEvent>::
+ EmitEvent(AbstractSocketEvents::WriteEvent(
+ EventSender(
+ this)), DPL::Event::EmitMode::Queued);
+ } else {
+ Assert(0);
+ }
- break;
+ break;
- default:
- Assert(0);
- break;
+ default:
+ Assert(0);
+ break;
}
}
void AddAcceptWatch()
{
- WaitableHandleWatchSupport::InheritedContext()->AddWaitableHandleWatch(this, m_socket, WaitMode::Read);
+ WaitableHandleWatchSupport::InheritedContext()->AddWaitableHandleWatch(
+ this,
+ m_socket,
+ WaitMode::Read);
}
void RemoveAcceptWatch()
{
- WaitableHandleWatchSupport::InheritedContext()->RemoveWaitableHandleWatch(this, m_socket, WaitMode::Read);
+ WaitableHandleWatchSupport::InheritedContext()->
+ RemoveWaitableHandleWatch(this, m_socket, WaitMode::Read);
}
void AddConnectWatch()
{
- WaitableHandleWatchSupport::InheritedContext()->AddWaitableHandleWatch(this, m_socket, WaitMode::Write);
+ WaitableHandleWatchSupport::InheritedContext()->AddWaitableHandleWatch(
+ this,
+ m_socket,
+ WaitMode::Write);
}
void RemoveConnectWatch()
{
- WaitableHandleWatchSupport::InheritedContext()->RemoveWaitableHandleWatch(this, m_socket, WaitMode::Write);
+ WaitableHandleWatchSupport::InheritedContext()->
+ RemoveWaitableHandleWatch(this, m_socket, WaitMode::Write);
}
void AddReadWatch()
{
- WaitableHandleWatchSupport::InheritedContext()->AddWaitableHandleWatch(this, m_socket, WaitMode::Read);
+ WaitableHandleWatchSupport::InheritedContext()->AddWaitableHandleWatch(
+ this,
+ m_socket,
+ WaitMode::Read);
}
void RemoveReadWatch()
{
- WaitableHandleWatchSupport::InheritedContext()->RemoveWaitableHandleWatch(this, m_socket, WaitMode::Read);
+ WaitableHandleWatchSupport::InheritedContext()->
+ RemoveWaitableHandleWatch(this, m_socket, WaitMode::Read);
}
void AddWriteWatch()
{
- WaitableHandleWatchSupport::InheritedContext()->AddWaitableHandleWatch(this, m_socket, WaitMode::Write);
+ WaitableHandleWatchSupport::InheritedContext()->AddWaitableHandleWatch(
+ this,
+ m_socket,
+ WaitMode::Write);
}
void RemoveWriteWatch()
{
- WaitableHandleWatchSupport::InheritedContext()->RemoveWaitableHandleWatch(this, m_socket, WaitMode::Write);
+ WaitableHandleWatchSupport::InheritedContext()->
+ RemoveWaitableHandleWatch(this, m_socket, WaitMode::Write);
}
-public:
- GenericSocket()
- : m_socket(-1),
- m_internalState(InternalState_None)
- {
- }
+ public:
+ GenericSocket() :
+ m_socket(-1),
+ m_internalState(InternalState_None)
+ {}
virtual ~GenericSocket()
{
virtual void Open()
{
- if (m_internalState != InternalState_None)
- ThrowMsg(AbstractSocket::Exception::OpenFailed, "Invalid socket state, should be 'None'");
+ if (m_internalState != InternalState_None) {
+ ThrowMsg(AbstractSocket::Exception::OpenFailed,
+ "Invalid socket state, should be 'None'");
+ }
LogPedantic("Opening socket...");
virtual void Connect(const Address &address)
{
- if (m_internalState != InternalState_Prepare)
- ThrowMsg(AbstractSocket::Exception::ConnectFailed, "Invalid socket state, should be 'Prepare'");
+ if (m_internalState != InternalState_Prepare) {
+ ThrowMsg(AbstractSocket::Exception::ConnectFailed,
+ "Invalid socket state, should be 'Prepare'");
+ }
LogPedantic("Connecting to: " << address.ToString());
// Translate address to specific socket address struct
socketAddress = TranslateAddressGenericToSpecific(address);
}
- Catch (Address::Exception::InvalidAddress)
+ Catch(Address::Exception::InvalidAddress)
{
// This address is invalid. Cannot connect.
- ReThrowMsg(AbstractSocket::Exception::ConnectFailed, address.ToString());
+ ReThrowMsg(AbstractSocket::Exception::ConnectFailed,
+ address.ToString());
}
// Do connect
- int result = TEMP_FAILURE_RETRY(connect(m_socket, socketAddress.first, socketAddress.second));
+ int result =
+ TEMP_FAILURE_RETRY(connect(m_socket, socketAddress.first,
+ socketAddress.second));
- if (result == 0)
- {
+ if (result == 0) {
// Immediate connect
LogPedantic("Immediate connected to: " << address.ToString());
// Emit connected event
DPL::Event::EventSupport<AbstractSocketEvents::ConnectedEvent>::
EmitEvent(AbstractSocketEvents::ConnectedEvent(
- EventSender(this)), DPL::Event::EmitMode::Queued);
- }
- else
- {
- if (errno == EINTR || errno == EINPROGRESS)
- {
- LogPedantic("Asynchronous connect in progress: " << address.ToString());
+ EventSender(this)), DPL::Event::EmitMode::Queued);
+ } else {
+ if (errno == EINTR || errno == EINPROGRESS) {
+ LogPedantic(
+ "Asynchronous connect in progress: " << address.ToString());
// Connecting in progress
AddConnectWatch();
m_internalState = InternalState_Connecting;
- }
- else
- {
+ } else {
// Free translation structure
free(socketAddress.first);
// Error occurred
- ThrowMsg(AbstractSocket::Exception::ConnectFailed, address.ToString());
+ ThrowMsg(AbstractSocket::Exception::ConnectFailed,
+ address.ToString());
}
}
virtual void Close()
{
- if (m_internalState == InternalState_None)
+ if (m_internalState == InternalState_None) {
return;
+ }
Assert(m_socket != -1);
- if (m_internalState == InternalState_Listening)
- {
+ if (m_internalState == InternalState_Listening) {
// Remove watch in listening state
LogPedantic("Removing accept watch");
RemoveAcceptWatch();
m_internalState = InternalState_None;
- }
- else if (m_internalState == InternalState_Connecting)
- {
+ } else if (m_internalState == InternalState_Connecting) {
// Remove watch in connecting state
LogPedantic("Removing connect watch");
RemoveConnectWatch();
m_internalState = InternalState_None;
- }
- else if (m_internalState == InternalState_Connected)
- {
+ } else if (m_internalState == InternalState_Connected) {
// Remove watch in connected state
LogPedantic("Removing read watch");
RemoveReadWatch();
m_internalState = InternalState_None;
- }
- else
- {
+ } else {
// State must be just prepared only
Assert(m_internalState == InternalState_Prepare);
}
- if (TEMP_FAILURE_RETRY(close(m_socket)) == -1)
+ if (TEMP_FAILURE_RETRY(close(m_socket)) == -1) {
Throw(Exception::CloseFailed);
+ }
// Reset socket
m_socket = -1;
virtual void Bind(const Address &address)
{
- if (m_internalState != InternalState_Prepare)
- ThrowMsg(AbstractSocket::Exception::BindFailed, "Invalid socket state, should be 'Prepare'");
+ if (m_internalState != InternalState_Prepare) {
+ ThrowMsg(AbstractSocket::Exception::BindFailed,
+ "Invalid socket state, should be 'Prepare'");
+ }
- LogPedantic("Binding to: " << address.GetAddress() << ":" << address.GetPort());
+ LogPedantic(
+ "Binding to: " << address.GetAddress() << ":" << address.GetPort());
// Translate address to specific socket address struct
- std::pair<sockaddr *, socklen_t> socketAddress = TranslateAddressGenericToSpecific(address);
+ std::pair<sockaddr *,
+ socklen_t> socketAddress = TranslateAddressGenericToSpecific(
+ address);
// Do bind
- if (::bind(m_socket, socketAddress.first, socketAddress.second) == -1)
+ if (::bind(m_socket, socketAddress.first,
+ socketAddress.second) == -1)
+ {
ThrowMsg(AbstractSocket::Exception::BindFailed, address.ToString());
+ }
// Free translation structure
free(socketAddress.first);
// Show info
- LogPedantic("Bound to address: " << address.GetAddress() << ":" << address.GetPort());
+ LogPedantic(
+ "Bound to address: " << address.GetAddress() << ":" <<
+ address.GetPort());
}
virtual void Listen(int backlog)
{
- if (m_internalState != InternalState_Prepare)
- ThrowMsg(AbstractSocket::Exception::ListenFailed, "Invalid socket state, should be 'None'");
+ if (m_internalState != InternalState_Prepare) {
+ ThrowMsg(AbstractSocket::Exception::ListenFailed,
+ "Invalid socket state, should be 'None'");
+ }
LogPedantic("Starting to listen...");
// Do listen
- if (listen(m_socket, backlog) != 0)
+ if (listen(m_socket, backlog) != 0) {
Throw(AbstractSocket::Exception::ListenFailed);
+ }
// Begin read watch
AddAcceptWatch();
virtual AbstractSocket *Accept()
{
- if (m_internalState != InternalState_Listening)
- ThrowMsg(AbstractSocket::Exception::AcceptFailed, "Invalid socket state, should be 'Listening'");
+ if (m_internalState != InternalState_Listening) {
+ ThrowMsg(AbstractSocket::Exception::AcceptFailed,
+ "Invalid socket state, should be 'Listening'");
+ }
LogPedantic("Accepting...");
int client = TEMP_FAILURE_RETRY(accept(m_socket, NULL, &length));
LogPedantic("Socket accept returned " << client);
- if (client == -1)
- {
+ if (client == -1) {
// Check if there is any client waiting
- if (errno == EWOULDBLOCK || errno == EAGAIN)
+ if (errno == EWOULDBLOCK || errno == EAGAIN) {
return NULL;
+ }
int err = errno;
- if (errno == ENOENT)
+ if (errno == ENOENT) {
return NULL;
+ }
LogPedantic("throwing error. errrno " << err);
// Error occurred
Throw(AbstractSocket::Exception::AcceptFailed);
// FIXME: Additional internal state check
socklen_t length = GetSpecificAddressSize();
- ScopedFree<sockaddr> address(static_cast<sockaddr *>(calloc(static_cast<size_t>(length), 1)));
-
- if (getsockname(m_socket, address.Get(), &length) == -1)
- ThrowMsg(AbstractSocket::Exception::GetPeerNameFailed, "Failed to get local address");
+ ScopedFree<sockaddr> address(static_cast<sockaddr *>(calloc(
+ static_cast<
+ size_t>(
+ length),
+ 1)));
+
+ if (getsockname(m_socket, address.Get(), &length) == -1) {
+ ThrowMsg(AbstractSocket::Exception::GetPeerNameFailed,
+ "Failed to get local address");
+ }
return TranslateAddressSpecificToGeneric(address.Get(), length);
}
// FIXME: Additional internal state check
socklen_t length = GetSpecificAddressSize();
- ScopedFree<sockaddr> address(static_cast<sockaddr *>(calloc(static_cast<size_t>(length), 1)));
-
- if (getpeername(m_socket, address.Get(), &length) == -1)
- ThrowMsg(AbstractSocket::Exception::GetPeerNameFailed, "Failed to get remote address");
+ ScopedFree<sockaddr> address(static_cast<sockaddr *>(calloc(
+ static_cast<
+ size_t>(
+ length),
+ 1)));
+
+ if (getpeername(m_socket, address.Get(), &length) == -1) {
+ ThrowMsg(AbstractSocket::Exception::GetPeerNameFailed,
+ "Failed to get remote address");
+ }
return TranslateAddressSpecificToGeneric(address.Get(), length);
}
virtual BinaryQueueAutoPtr Read(size_t size)
{
- if (m_internalState != InternalState_Connected)
- ThrowMsg(AbstractSocket::Exception::AcceptFailed, "Invalid socket state, should be 'Connected'");
+ if (m_internalState != InternalState_Connected) {
+ ThrowMsg(AbstractSocket::Exception::AcceptFailed,
+ "Invalid socket state, should be 'Connected'");
+ }
Try
{
// Adjust bytes to be read
- size_t bytesToRead = size > DEFAULT_READ_BUFFER_SIZE ? DEFAULT_READ_BUFFER_SIZE : size;
+ size_t bytesToRead = size >
+ DEFAULT_READ_BUFFER_SIZE ? DEFAULT_READ_BUFFER_SIZE : size;
// Malloc default read buffer size
- // It is unmanaged, so it can be then attached directly to binary queue
+ // It is unmanaged, so it can be then attached directly to binary
+ // queue
void *buffer = malloc(bytesToRead);
- if (buffer == NULL)
+ if (buffer == NULL) {
throw std::bad_alloc();
+ }
// Receive bytes from socket
- ssize_t result = TEMP_FAILURE_RETRY(recv(m_socket, buffer, bytesToRead, 0));
+ ssize_t result =
+ TEMP_FAILURE_RETRY(recv(m_socket, buffer, bytesToRead, 0));
- if (result > 0)
- {
+ if (result > 0) {
// Succedded to read socket data
BinaryQueueAutoPtr binaryQueue(new BinaryQueue());
// Append unmanaged memory
- binaryQueue->AppendUnmanaged(buffer, result, &BinaryQueue::BufferDeleterFree, NULL);
+ binaryQueue->AppendUnmanaged(buffer,
+ result,
+ &BinaryQueue::BufferDeleterFree,
+ NULL);
// Return buffer
return binaryQueue;
- }
- else if (result == 0)
- {
+ } else if (result == 0) {
// Socket was gracefuly closed
free(buffer);
// Return empty buffer
return BinaryQueueAutoPtr(new BinaryQueue());
- }
- else
- {
+ } else {
// Must first save errno value, because it may be altered
int lastErrno = errno;
free(buffer);
// Interpret error result
- switch (lastErrno)
- {
- case EAGAIN: // = EWOULDBLOCK
- //
- // * The socket's file descriptor is marked O_NONBLOCK and no data is waiting
- // to be received; or MSG_OOB is set and no out-of-band data is available
- // and either the socket's file descriptor is marked O_NONBLOCK or the socket
- // does not support blocking to await out-of-band data.
- //
- // return null data buffer to indicate no data waiting
- //
- return BinaryQueueAutoPtr();
-
- case EBADF:
- //
- // * The socket argument is not a valid file descriptor.
- //
- // This is internal error
- //
- ThrowMsg(CommonException::InternalError, "Invalid socket descriptor");
-
- case ECONNRESET:
- //
- // * A connection was forcibly closed by a peer.
- //
- // In result, we can interpret this error as a broken connection
- //
- Throw(AbstractSocket::Exception::ConnectionBroken);
-
- case EINTR:
- //
- // * The recv() function was interrupted by a signal that was caught, before any
- // data was available.
- //
- // No interrupt here is expected, due to fact that we used TEMP_FAILURE_RETRY
- //
- ThrowMsg(CommonException::InternalError, "Unexpected interrupt occurred");
-
- case EINVAL:
- //
- // * The MSG_OOB flag is set and no out-of-band data is available.
- //
- // We did not specified OOB data. This is an error.
- //
- ThrowMsg(CommonException::InternalError, "Unexpected OOB error occurred");
-
- case ENOTCONN:
- //
- // * A receive is attempted on a connection-mode socket that is not connected.
- //
- // FIXME: Is this proper exception here ?
- //
- ThrowMsg(CommonException::InternalError, "Socket is not connected");
-
- case ENOTSOCK:
- //
- // * The socket argument does not refer to a socket.
- //
- ThrowMsg(CommonException::InternalError, "Handle is not a socket");
-
- case EOPNOTSUPP:
- //
- // * The specified flags are not supported for this socket type or protocol.
- //
- ThrowMsg(CommonException::InternalError, "Socket flags not supported");
-
- case ETIMEDOUT:
- //
- // * The connection timed out during connection establishment, or due to a transmission timeout on active connection.
- //
- // In result, we can interpret this error as a broken connection
- //
- Throw(AbstractSocket::Exception::ConnectionBroken);
-
- case EIO:
- //
- // * An I/O error occurred while reading from or writing to the file system.
- //
- // In result, we can interpret this error as a broken connection
- //
- Throw(AbstractSocket::Exception::ConnectionBroken);
-
- case ENOBUFS:
- //
- // * Insufficient resources were available in the system to perform the operation.
- //
- ThrowMsg(CommonException::InternalError, "Insufficient system resources");
-
- case ENOMEM:
- //
- // * Insufficient memory was available to fulfill the request.
- //
- ThrowMsg(CommonException::InternalError, "Insufficient system memory");
-
- default:
- // Some kernel error occurred, should never happen
- ThrowMsg(CommonException::InternalError, "Unknown kernel read error returned");
- break;
+ switch (lastErrno) {
+ case EAGAIN: // = EWOULDBLOCK
+ //
+ // * The socket's file descriptor is marked O_NONBLOCK and
+ // no data is waiting
+ // to be received; or MSG_OOB is set and no out-of-band
+ // data is available
+ // and either the socket's file descriptor is marked
+ // O_NONBLOCK or the socket
+ // does not support blocking to await out-of-band data.
+ //
+ // return null data buffer to indicate no data waiting
+ //
+ return BinaryQueueAutoPtr();
+
+ case EBADF:
+ //
+ // * The socket argument is not a valid file descriptor.
+ //
+ // This is internal error
+ //
+ ThrowMsg(CommonException::InternalError,
+ "Invalid socket descriptor");
+
+ case ECONNRESET:
+ //
+ // * A connection was forcibly closed by a peer.
+ //
+ // In result, we can interpret this error as a broken
+ // connection
+ //
+ Throw(AbstractSocket::Exception::ConnectionBroken);
+
+ case EINTR:
+ //
+ // * The recv() function was interrupted by a signal that
+ // was caught, before any
+ // data was available.
+ //
+ // No interrupt here is expected, due to fact that we used
+ // TEMP_FAILURE_RETRY
+ //
+ ThrowMsg(CommonException::InternalError,
+ "Unexpected interrupt occurred");
+
+ case EINVAL:
+ //
+ // * The MSG_OOB flag is set and no out-of-band data is
+ // available.
+ //
+ // We did not specified OOB data. This is an error.
+ //
+ ThrowMsg(CommonException::InternalError,
+ "Unexpected OOB error occurred");
+
+ case ENOTCONN:
+ //
+ // * A receive is attempted on a connection-mode socket that
+ // is not connected.
+ //
+ // FIXME: Is this proper exception here ?
+ //
+ ThrowMsg(CommonException::InternalError,
+ "Socket is not connected");
+
+ case ENOTSOCK:
+ //
+ // * The socket argument does not refer to a socket.
+ //
+ ThrowMsg(CommonException::InternalError,
+ "Handle is not a socket");
+
+ case EOPNOTSUPP:
+ //
+ // * The specified flags are not supported for this socket
+ // type or protocol.
+ //
+ ThrowMsg(CommonException::InternalError,
+ "Socket flags not supported");
+
+ case ETIMEDOUT:
+ //
+ // * The connection timed out during connection
+ // establishment, or due to a transmission timeout on active
+ // connection.
+ //
+ // In result, we can interpret this error as a broken
+ // connection
+ //
+ Throw(AbstractSocket::Exception::ConnectionBroken);
+
+ case EIO:
+ //
+ // * An I/O error occurred while reading from or writing to
+ // the file system.
+ //
+ // In result, we can interpret this error as a broken
+ // connection
+ //
+ Throw(AbstractSocket::Exception::ConnectionBroken);
+
+ case ENOBUFS:
+ //
+ // * Insufficient resources were available in the system to
+ // perform the operation.
+ //
+ ThrowMsg(CommonException::InternalError,
+ "Insufficient system resources");
+
+ case ENOMEM:
+ //
+ // * Insufficient memory was available to fulfill the
+ // request.
+ //
+ ThrowMsg(CommonException::InternalError,
+ "Insufficient system memory");
+
+ default:
+ // Some kernel error occurred, should never happen
+ ThrowMsg(CommonException::InternalError,
+ "Unknown kernel read error returned");
+ break;
}
}
}
- Catch (CommonException::InternalError)
+ Catch(CommonException::InternalError)
{
// If any internal error occurred, this is fatal for Write method
// interpret this as WriteError exception and rethrow
virtual size_t Write(const BinaryQueue &buffer, size_t bufferSize)
{
- if (m_internalState != InternalState_Connected)
- ThrowMsg(AbstractSocket::Exception::AcceptFailed, "Invalid socket state, should be 'Connected'");
+ if (m_internalState != InternalState_Connected) {
+ ThrowMsg(AbstractSocket::Exception::AcceptFailed,
+ "Invalid socket state, should be 'Connected'");
+ }
Try
{
// Adjust write size
- if (bufferSize > buffer.Size())
+ if (bufferSize > buffer.Size()) {
bufferSize = buffer.Size();
+ }
// FIXME: User write visitor to write !
// WriteVisitor visitor
// Linux: MSG_NOSIGNAL is supported, but it is not an ideal solution
// FIXME: Should we setup signal PIPE ignoring for whole process ?
- // In BSD, there is: setsockopt(c, SOL_SOCKET, SO_NOSIGPIPE, (void *)&on, sizeof(on))
- ssize_t result = TEMP_FAILURE_RETRY(send(m_socket, flattened.Get(), bufferSize, MSG_NOSIGNAL));
+ // In BSD, there is: setsockopt(c, SOL_SOCKET, SO_NOSIGPIPE, (void
+ // *)&on, sizeof(on))
+ ssize_t result =
+ TEMP_FAILURE_RETRY(send(m_socket, flattened.Get(), bufferSize,
+ MSG_NOSIGNAL));
- if (result > 0)
- {
+ if (result > 0) {
// Successfuly written some bytes
return static_cast<size_t>(result);
- }
- else if (result == 0)
- {
+ } else if (result == 0) {
// This is abnormal result
- ThrowMsg(CommonException::InternalError, "Invalid socket write result, 0 bytes written");
- }
- else if (result == -1)
- {
+ ThrowMsg(CommonException::InternalError,
+ "Invalid socket write result, 0 bytes written");
+ } else if (result == -1) {
// Interpret error result
- switch (errno)
- {
- case EAGAIN: // = EWOULDBLOCK
- //
- // * The socket's file descriptor is marked O_NONBLOCK and the requested operation would block.
- //
- // We should wait for writability
- //
- return 0;
-
- case EBADF:
- //
- // * The socket argument is not a valid file descriptor.
- //
- // This is internal error
- //
- ThrowMsg(CommonException::InternalError, "Invalid socket descriptor");
-
- case ECONNRESET:
- //
- // * A connection was forcibly closed by a peer.
- //
- // In result, we can interpret this error as a broken connection
- //
- Throw(AbstractSocket::Exception::ConnectionBroken);
-
- case EDESTADDRREQ:
- //
- // * The socket is not connection-mode and no peer address is set.
- //
- // FIXME: Is this proper exception here ?
- //
- ThrowMsg(CommonException::InternalError, "Socket is not connected");
-
- case EINTR:
- //
- // * A signal interrupted send() before any data was transmitted.
- //
- // No interrupt here is expected, due to fact that we used TEMP_FAILURE_RETRY
- //
- ThrowMsg(CommonException::InternalError, "Unexpected interrupt occurred");
-
- case EMSGSIZE:
- //
- // * The message is too large to be sent all at once, as the socket requires.
- //
- // FIXME: Is this proper exception here ?
- //
- ThrowMsg(CommonException::InternalError, "Socket message is too big");
-
- case ENOTCONN:
- //
- // * The socket is not connected or otherwise has not had the peer pre-specified.
- //
- // FIXME: Is this proper exception here ?
- //
- ThrowMsg(CommonException::InternalError, "Socket is not connected");
-
- case ENOTSOCK:
- //
- // * The socket argument does not refer to a socket.
- //
- ThrowMsg(CommonException::InternalError, "Handle is not a socket");
-
- case EOPNOTSUPP:
- //
- // * The socket argument is associated with a socket that does not support one or more of the values set in flags.
- //
- ThrowMsg(CommonException::InternalError, "Socket flags not supported");
-
- case EPIPE:
- //
- // * The socket is shut down for writing, or the socket is connection-mode and
- // is no longer connected. In the latter case, and if the socket is of type
- // SOCK_STREAM, the SIGPIPE signal is generated to the calling thread.
- //
- // In result, we can interpret this error as a broken connection
- //
- Throw(AbstractSocket::Exception::ConnectionBroken);
-
- case EACCES:
- //
- // * The calling process does not have the appropriate privileges.
- //
- // Priviledges might have changed.
- // In result, we can interpret this error as a broken connection
- //
- Throw(AbstractSocket::Exception::ConnectionBroken);
-
- case EIO:
- //
- // * An I/O error occurred while reading from or writing to the file system.
- //
- // In result, we can interpret this error as a broken connection
- //
- Throw(AbstractSocket::Exception::ConnectionBroken);
-
- case ENETDOWN:
- //
- // * The local network interface used to reach the destination is down.
- //
- // In result, we can interpret this error as a broken connection
- //
- Throw(AbstractSocket::Exception::ConnectionBroken);
-
- case ENETUNREACH:
- //
- // * No route to the network is present.
- //
- // In result, we can interpret this error as a broken connection
- //
- Throw(AbstractSocket::Exception::ConnectionBroken);
-
- case ENOBUFS:
- //
- // * Insufficient resources were available in the system to perform the operation.
- //
- ThrowMsg(CommonException::InternalError, "Insufficient system resources");
-
- default:
- // Some kernel error occurred, should never happen
- ThrowMsg(CommonException::InternalError, "Unknown kernel write error returned");
- break;
+ switch (errno) {
+ case EAGAIN: // = EWOULDBLOCK
+ //
+ // * The socket's file descriptor is marked O_NONBLOCK and
+ // the requested operation would block.
+ //
+ // We should wait for writability
+ //
+ return 0;
+
+ case EBADF:
+ //
+ // * The socket argument is not a valid file descriptor.
+ //
+ // This is internal error
+ //
+ ThrowMsg(CommonException::InternalError,
+ "Invalid socket descriptor");
+
+ case ECONNRESET:
+ //
+ // * A connection was forcibly closed by a peer.
+ //
+ // In result, we can interpret this error as a broken
+ // connection
+ //
+ Throw(AbstractSocket::Exception::ConnectionBroken);
+
+ case EDESTADDRREQ:
+ //
+ // * The socket is not connection-mode and no peer address
+ // is set.
+ //
+ // FIXME: Is this proper exception here ?
+ //
+ ThrowMsg(CommonException::InternalError,
+ "Socket is not connected");
+
+ case EINTR:
+ //
+ // * A signal interrupted send() before any data was
+ // transmitted.
+ //
+ // No interrupt here is expected, due to fact that we used
+ // TEMP_FAILURE_RETRY
+ //
+ ThrowMsg(CommonException::InternalError,
+ "Unexpected interrupt occurred");
+
+ case EMSGSIZE:
+ //
+ // * The message is too large to be sent all at once, as the
+ // socket requires.
+ //
+ // FIXME: Is this proper exception here ?
+ //
+ ThrowMsg(CommonException::InternalError,
+ "Socket message is too big");
+
+ case ENOTCONN:
+ //
+ // * The socket is not connected or otherwise has not had
+ // the peer pre-specified.
+ //
+ // FIXME: Is this proper exception here ?
+ //
+ ThrowMsg(CommonException::InternalError,
+ "Socket is not connected");
+
+ case ENOTSOCK:
+ //
+ // * The socket argument does not refer to a socket.
+ //
+ ThrowMsg(CommonException::InternalError,
+ "Handle is not a socket");
+
+ case EOPNOTSUPP:
+ //
+ // * The socket argument is associated with a socket that
+ // does not support one or more of the values set in flags.
+ //
+ ThrowMsg(CommonException::InternalError,
+ "Socket flags not supported");
+
+ case EPIPE:
+ //
+ // * The socket is shut down for writing, or the socket is
+ // connection-mode and
+ // is no longer connected. In the latter case, and if the
+ // socket is of type
+ // SOCK_STREAM, the SIGPIPE signal is generated to the
+ // calling thread.
+ //
+ // In result, we can interpret this error as a broken
+ // connection
+ //
+ Throw(AbstractSocket::Exception::ConnectionBroken);
+
+ case EACCES:
+ //
+ // * The calling process does not have the appropriate
+ // privileges.
+ //
+ // Priviledges might have changed.
+ // In result, we can interpret this error as a broken
+ // connection
+ //
+ Throw(AbstractSocket::Exception::ConnectionBroken);
+
+ case EIO:
+ //
+ // * An I/O error occurred while reading from or writing to
+ // the file system.
+ //
+ // In result, we can interpret this error as a broken
+ // connection
+ //
+ Throw(AbstractSocket::Exception::ConnectionBroken);
+
+ case ENETDOWN:
+ //
+ // * The local network interface used to reach the
+ // destination is down.
+ //
+ // In result, we can interpret this error as a broken
+ // connection
+ //
+ Throw(AbstractSocket::Exception::ConnectionBroken);
+
+ case ENETUNREACH:
+ //
+ // * No route to the network is present.
+ //
+ // In result, we can interpret this error as a broken
+ // connection
+ //
+ Throw(AbstractSocket::Exception::ConnectionBroken);
+
+ case ENOBUFS:
+ //
+ // * Insufficient resources were available in the system to
+ // perform the operation.
+ //
+ ThrowMsg(CommonException::InternalError,
+ "Insufficient system resources");
+
+ default:
+ // Some kernel error occurred, should never happen
+ ThrowMsg(CommonException::InternalError,
+ "Unknown kernel write error returned");
+ break;
}
}
}
- Catch (CommonException::InternalError)
+ Catch(CommonException::InternalError)
{
// If any internal error occurred, this is fatal for Write method
// interpret this as WriteError exception and rethrow
return m_socket;
}
};
-
}
} // namespace DPL
#include <dpl/socket/generic_socket.h>
#include <dpl/exception.h>
-namespace DPL
+namespace DPL {
+namespace Socket {
+class UnixSocket :
+ public GenericSocket<UnixSocket>
{
-namespace Socket
-{
-
-class UnixSocket
- : public GenericSocket<UnixSocket>
-{
-public:
+ public:
class Exception
{
- public:
+ public:
DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, CreateFailed)
};
-protected:
- /**
- * Translate generic Address to specific socket kernel structure
- */
- virtual std::pair<sockaddr *, socklen_t> TranslateAddressGenericToSpecific(const Address &address) const;
+ protected:
+ /**
+ * Translate generic Address to specific socket kernel structure
+ */
+ virtual std::pair<sockaddr *, socklen_t> TranslateAddressGenericToSpecific(
+ const Address &address) const;
/**
* Translate specific socket kernel structure to generic Address
*/
- virtual Address TranslateAddressSpecificToGeneric(sockaddr *, socklen_t) const;
+ virtual Address TranslateAddressSpecificToGeneric(sockaddr *,
+ socklen_t) const;
/**
* Get specific socket kernel structure size
*/
virtual int AllocSpecificDescriptor() const;
-public:
+ public:
UnixSocket();
virtual void Bind(const Address &address);
};
-
}
} // namespace DPL
* @file waitable_input_output_execution_context_support.h
* @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
* @version 1.0
- * @brief This file is the header file for waitable input-output execution context support
+ * @brief This file is the header file for waitable input-output execution
+ * context support
*/
#ifndef DPL_WAITABLE_INPUT_OUTPUT_EXECUTION_CONTEXT_SUPPORT_H
#define DPL_WAITABLE_INPUT_OUTPUT_EXECUTION_CONTEXT_SUPPORT_H
#include <dpl/waitable_handle_watch_support.h>
#include <dpl/binary_queue.h>
-namespace DPL
+namespace DPL {
+namespace Socket {
+class WaitableInputOutputExecutionContextSupport :
+ private WaitableHandleWatchSupport::WaitableHandleListener
{
-namespace Socket
-{
-
-class WaitableInputOutputExecutionContextSupport
- : private WaitableHandleWatchSupport::WaitableHandleListener
-{
-public:
+ public:
class Exception
{
- public:
+ public:
DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, AlreadyOpened)
DECLARE_EXCEPTION_TYPE(Base, NotOpened)
DECLARE_EXCEPTION_TYPE(Base, CloseFailed)
};
-private:
+ private:
bool m_opened;
AbstractWaitableInputOutput *m_waitableInputOutput;
void CheckedRemoveReadWriteWatch();
- virtual void OnWaitableHandleEvent(WaitableHandle waitableHandle, WaitMode::Type mode);
+ virtual void OnWaitableHandleEvent(WaitableHandle waitableHandle,
+ WaitMode::Type mode);
-protected:
+ protected:
// Incoming/Outgoing streams
BinaryQueue m_inputStream;
BinaryQueue m_outputStream;
void Open(AbstractWaitableInputOutput *waitableInputOutput);
void Close();
-public:
+ public:
/**
* Constructor
*/
*/
virtual ~WaitableInputOutputExecutionContextSupport();
};
-
}
} // namespace DPL
#include <errno.h>
#include <string.h>
-namespace DPL
-{
-namespace Socket
-{
-
+namespace DPL {
+namespace Socket {
UnixSocket::UnixSocket()
-{
-}
+{}
int UnixSocket::AllocSpecificDescriptor() const
{
// Create new descriptor
int newSocket = socket(AF_UNIX, SOCK_STREAM, 0);
- if (newSocket == -1)
+ if (newSocket == -1) {
Throw(Exception::CreateFailed);
+ }
LogPedantic("UNIX socket created");
return newSocket;
}
-std::pair<sockaddr *, socklen_t> UnixSocket::TranslateAddressGenericToSpecific(const Address &address) const
+std::pair<sockaddr *, socklen_t> UnixSocket::TranslateAddressGenericToSpecific(
+ const Address &address) const
{
// Allocate new socket address structure
- sockaddr_un *sockAddress = static_cast<sockaddr_un *>(malloc(sizeof(sockaddr_un)));
- if (!sockAddress) throw std::bad_alloc();
+ sockaddr_un *sockAddress =
+ static_cast<sockaddr_un *>(malloc(sizeof(sockaddr_un)));
+ if (!sockAddress) {
+ throw std::bad_alloc();
+ }
memset(sockAddress, 0, sizeof(sockaddr_un));
// Copy address properties
sockAddress->sun_family = AF_UNIX;
- strncpy(sockAddress->sun_path, address.GetAddress().c_str(), sizeof(sockAddress->sun_path) - 1);
- sockAddress->sun_path[sizeof(sockAddress->sun_path) - 1] = '\0'; // Prevent buffer overflows
+ strncpy(sockAddress->sun_path, address.GetAddress().c_str(),
+ sizeof(sockAddress->sun_path) - 1);
+
+ //Prevent buffer overflows
+ sockAddress->sun_path[sizeof(sockAddress->sun_path) - 1] = '\0';
// Set proper address length
socklen_t sockAddressLength = SUN_LEN(sockAddress);
// Return new translated address
- return std::make_pair(reinterpret_cast<sockaddr *>(sockAddress), sockAddressLength);
+ return std::make_pair(reinterpret_cast<sockaddr *>(sockAddress),
+ sockAddressLength);
}
-Address UnixSocket::TranslateAddressSpecificToGeneric(sockaddr *address, socklen_t) const
+Address UnixSocket::TranslateAddressSpecificToGeneric(sockaddr *address,
+ socklen_t) const
{
// FIXME: Constrain check ?
sockaddr_un *unixAddress = reinterpret_cast<sockaddr_un *>(address);
GenericSocket<UnixSocket>::Bind(address);
// Always set proper permissions to the socket file
- if(chmod(address.GetAddress().c_str(), 0777)<0){
- LogError("Error setting permissions to the socket file. Errno " << strerror(errno));
+ if (chmod(address.GetAddress().c_str(), 0777) < 0) {
+ LogError(
+ "Error setting permissions to the socket file. Errno " <<
+ strerror(errno));
}
}
}
* @file waitable_input_output_execution_context_support.cpp
* @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
* @version 1.0
- * @brief This file is the implementation file of waitable input-output execution context support
+ * @brief This file is the implementation file of waitable input-output
+ * execution context support
*/
#include <stddef.h>
#include <dpl/socket/waitable_input_output_execution_context_support.h>
#include <dpl/log/log.h>
#include <dpl/assert.h>
-namespace DPL
-{
-namespace Socket
-{
-
+namespace DPL {
+namespace Socket {
namespace // anonymous
{
const size_t DEFAULT_READ_SIZE = 2048;
} // namespace anonymous
-WaitableInputOutputExecutionContextSupport::WaitableInputOutputExecutionContextSupport()
- : m_opened(false),
- m_waitableInputOutput(NULL),
- m_hasReadWatch(false),
- m_hasWriteWatch(false)
-{
-}
+WaitableInputOutputExecutionContextSupport::
+ WaitableInputOutputExecutionContextSupport() :
+ m_opened(false),
+ m_waitableInputOutput(NULL),
+ m_hasReadWatch(false),
+ m_hasWriteWatch(false)
+{}
-WaitableInputOutputExecutionContextSupport::~WaitableInputOutputExecutionContextSupport()
+WaitableInputOutputExecutionContextSupport::~
+WaitableInputOutputExecutionContextSupport()
{
// Ensure support is closed
Close();
}
-void WaitableInputOutputExecutionContextSupport::Open(AbstractWaitableInputOutput *inputOutput)
+void WaitableInputOutputExecutionContextSupport::Open(
+ AbstractWaitableInputOutput *inputOutput)
{
- if (m_opened)
+ if (m_opened) {
Throw(Exception::AlreadyOpened);
+ }
LogPedantic("Opening waitable input-output execution context support...");
void WaitableInputOutputExecutionContextSupport::Close()
{
- if (!m_opened)
+ if (!m_opened) {
return;
+ }
LogPedantic("Closing waitable input-output execution context support...");
void WaitableInputOutputExecutionContextSupport::AddReadWatch()
{
- WaitableHandleWatchSupport::InheritedContext()->AddWaitableHandleWatch(this, m_waitableInputOutput->WaitableReadHandle(), WaitMode::Read);
+ WaitableHandleWatchSupport::InheritedContext()->AddWaitableHandleWatch(
+ this,
+ m_waitableInputOutput
+ ->WaitableReadHandle(),
+ WaitMode
+ ::Read);
}
void WaitableInputOutputExecutionContextSupport::RemoveReadWatch()
{
- WaitableHandleWatchSupport::InheritedContext()->RemoveWaitableHandleWatch(this, m_waitableInputOutput->WaitableReadHandle(), WaitMode::Read);
+ WaitableHandleWatchSupport::InheritedContext()->RemoveWaitableHandleWatch(
+ this,
+ m_waitableInputOutput->WaitableReadHandle(),
+ WaitMode::Read);
}
void WaitableInputOutputExecutionContextSupport::AddWriteWatch()
{
- WaitableHandleWatchSupport::InheritedContext()->AddWaitableHandleWatch(this, m_waitableInputOutput->WaitableWriteHandle(), WaitMode::Write);
+ WaitableHandleWatchSupport::InheritedContext()->AddWaitableHandleWatch(
+ this,
+ m_waitableInputOutput
+ ->WaitableWriteHandle(),
+ WaitMode
+ ::Write);
}
void WaitableInputOutputExecutionContextSupport::RemoveWriteWatch()
{
- WaitableHandleWatchSupport::InheritedContext()->RemoveWaitableHandleWatch(this, m_waitableInputOutput->WaitableWriteHandle(), WaitMode::Write);
+ WaitableHandleWatchSupport::InheritedContext()->RemoveWaitableHandleWatch(
+ this,
+ m_waitableInputOutput->WaitableWriteHandle(),
+ WaitMode::Write);
}
void WaitableInputOutputExecutionContextSupport::CheckedRemoveReadWatch()
{
- if (!m_hasReadWatch)
+ if (!m_hasReadWatch) {
return;
+ }
RemoveReadWatch();
m_hasReadWatch = false;
void WaitableInputOutputExecutionContextSupport::CheckedRemoveWriteWatch()
{
- if (!m_hasWriteWatch)
+ if (!m_hasWriteWatch) {
return;
+ }
RemoveWriteWatch();
m_hasWriteWatch = false;
CheckedRemoveWriteWatch();
}
-void WaitableInputOutputExecutionContextSupport::OnWaitableHandleEvent(WaitableHandle waitableHandle, WaitMode::Type mode)
+void WaitableInputOutputExecutionContextSupport::OnWaitableHandleEvent(
+ WaitableHandle waitableHandle,
+ WaitMode::Type mode)
{
(void)waitableHandle;
- switch (mode)
- {
- case WaitMode::Read:
- LogPedantic("Read event occurred");
+ switch (mode) {
+ case WaitMode::Read:
+ LogPedantic("Read event occurred");
- // Read and parse bytes
- ReadInput();
+ // Read and parse bytes
+ ReadInput();
- // Done
- break;
+ // Done
+ break;
- case WaitMode::Write:
- LogPedantic("Write event occurred");
+ case WaitMode::Write:
+ LogPedantic("Write event occurred");
- // Push bytes and unregister from write event
- FeedOutput();
+ // Push bytes and unregister from write event
+ FeedOutput();
- // Unregister write watch only if no more data is available
- if (m_outputStream.Empty())
- {
- Assert(m_hasWriteWatch == true);
- CheckedRemoveWriteWatch();
- }
+ // Unregister write watch only if no more data is available
+ if (m_outputStream.Empty()) {
+ Assert(m_hasWriteWatch == true);
+ CheckedRemoveWriteWatch();
+ }
- // Done
- break;
+ // Done
+ break;
- default:
- Assert(0);
- break;
+ default:
+ Assert(0);
+ break;
}
}
Try
{
- BinaryQueueAutoPtr inputBuffer = m_waitableInputOutput->Read(DEFAULT_READ_SIZE);
+ BinaryQueueAutoPtr inputBuffer = m_waitableInputOutput->Read(
+ DEFAULT_READ_SIZE);
- if (inputBuffer.get() == NULL)
- {
+ if (inputBuffer.get() == NULL) {
// No data, should not occur
LogPedantic("WARNING: Spontaneous ReadSocket occurred");
return;
}
- if (inputBuffer->Empty())
- {
+ if (inputBuffer->Empty()) {
// Connection was closed
OnInputStreamClosed();
// Append all read data
m_inputStream.AppendMoveFrom(*inputBuffer);
}
- Catch (AbstractSocket::Exception::ConnectionBroken) // FIXME: Inproper exception abstraction !!!
+ Catch(AbstractSocket::Exception::ConnectionBroken)
{
+ //FIXME: Inproper exception abstraction!!!
// Some errors occurred while feeding abstract IO
// Interpret connection broken errors, and pass futher other ones
LogPedantic("Abstract IO connection was broken during read");
void WaitableInputOutputExecutionContextSupport::FeedOutput()
{
- if (!m_opened)
+ if (!m_opened) {
Throw(Exception::NotOpened);
+ }
// Anything to feed ?
- if (m_outputStream.Empty())
+ if (m_outputStream.Empty()) {
return;
+ }
// OK to feed output
LogPedantic("Feeding output");
Try
{
// Try to write some bytes
- size_t bytes = m_waitableInputOutput->Write(m_outputStream, m_outputStream.Size());
+ size_t bytes = m_waitableInputOutput->Write(m_outputStream,
+ m_outputStream.Size());
- if (bytes < m_outputStream.Size())
- {
- // Start exhaustive output feeding if it is blocked and not already started
- if (!m_hasWriteWatch)
- {
+ if (bytes < m_outputStream.Size()) {
+ // Start exhaustive output feeding if it is blocked and not already
+ // started
+ if (!m_hasWriteWatch) {
AddWriteWatch();
m_hasWriteWatch = true;
// Some bytes were written, consume them
m_outputStream.Consume(bytes);
}
- Catch (AbstractSocket::Exception::ConnectionBroken) // FIXME: Inproper exception abstraction !!!
+ Catch(AbstractSocket::Exception::ConnectionBroken) // FIXME: Inproper
+ // exception abstraction
+ // !!!
{
// Some errors occurred while feeding abstract IO
// Interpret connection broken errors, and pass futher other ones
return;
}
}
-
}
} // namespace DPL
#define PLUGIN_API_ACCESS_DENIED 0
#define PLUGIN_API_ACCESS_ERROR -1
-
typedef const void* java_script_context_t;
typedef struct js_object_properties_s
typedef void* js_object_ref_t;
typedef const void* js_value_ref_t;
-typedef js_class_template_t (*js_class_template_getter) (void);
+typedef js_class_template_t (*js_class_template_getter)(void);
typedef void* (*js_class_constructor_cb_t)(js_class_template_t,
- js_object_ref_t, size_t, js_value_ref_t[],
- js_value_ref_t*);
+ js_object_ref_t, size_t,
+ js_value_ref_t[],
+ js_value_ref_t*);
typedef enum class_definition_type_e
{
//object should be copied as reference to each iframe
REFERENCE,
//object should be created for each iframe and NOT inform plugin
- CREATE_INSTANCE,
+ CREATE_INSTANCE
} class_definition_iframe_behaviour_t;
typedef enum class_definition_iframe_notice_e
typedef void* js_object_instance_t;
//global_context - id
-typedef void(*iframe_loaded_cb)(java_script_context_t global_context,
- js_object_instance_t iframe,
- js_object_instance_t object);
+typedef void (*iframe_loaded_cb)(java_script_context_t global_context,
+ js_object_instance_t iframe,
+ js_object_instance_t object);
typedef void* (*js_function_impl)(void*);
js_function_impl function;
} class_definition_options_t;
-
/*
* list of device caps
*/
size_t featuresCount;
} feature_mapping_t;
-
typedef feature_mapping_t* pfeature_mapping_t;
typedef pfeature_mapping_t (*features_getter)(void);
*/
} feature_mapping_interface_t;
-
/*
* This is a structure describing a JS entity template (a class, an interface
* or function), object name and it's parent class name (parent_name). JS
SET(DPL_TEST_ENGINE_SOURCES
${PROJECT_SOURCE_DIR}/modules/test/src/test_results_collector.cpp
${PROJECT_SOURCE_DIR}/modules/test/src/test_runner.cpp
+ ${PROJECT_SOURCE_DIR}/modules/test/src/test_runner_child.cpp
PARENT_SCOPE
)
SET(DPL_TEST_ENGINE_HEADERS
${PROJECT_SOURCE_DIR}/modules/test/include/dpl/test/test_results_collector.h
${PROJECT_SOURCE_DIR}/modules/test/include/dpl/test/test_runner.h
+ ${PROJECT_SOURCE_DIR}/modules/test/include/dpl/test/test_runner_child.h
PARENT_SCOPE
)
#include <string>
#include <memory>
-namespace DPL
-{
-namespace Test
-{
-
+namespace DPL {
+namespace Test {
class TestResultsCollectorBase;
typedef std::shared_ptr<TestResultsCollectorBase>
- TestResultsCollectorBasePtr;
+TestResultsCollectorBasePtr;
-class TestResultsCollectorBase
- : private DPL::Noncopyable
+class TestResultsCollectorBase :
+ private DPL::Noncopyable
{
public:
typedef TestResultsCollectorBase* (*CollectorConstructorFunc)();
virtual ~TestResultsCollectorBase() {}
- virtual bool Configure() { return true; }
+ virtual bool Configure()
+ {
+ return true;
+ }
virtual void Start() { }
virtual void Finish() { }
- virtual void CollectCurrentTestGroupName(const std::string& /*groupName*/) {}
+ virtual void CollectCurrentTestGroupName(const std::string& /*groupName*/)
+ {}
virtual void CollectTestsCasesList(const TestCaseIdList& /*list*/) {}
virtual void CollectResult(const std::string& id,
const std::string& description,
const FailStatus::Type status = FailStatus::NONE,
const std::string& reason = "") = 0;
- virtual std::string CollectorSpecificHelp() const { return ""; }
+ virtual std::string CollectorSpecificHelp() const
+ {
+ return "";
+ }
virtual bool ParseCollectorSpecificArg (const std::string& /*arg*/)
{
return false;
}
static TestResultsCollectorBase* Create(const std::string& name);
- static void RegisterCollectorConstructor(const std::string& name,
- CollectorConstructorFunc constructor);
+ static void RegisterCollectorConstructor(
+ const std::string& name,
+ CollectorConstructorFunc
+ constructor);
static std::vector<std::string> GetCollectorsNames();
private:
typedef std::map<std::string, CollectorConstructorFunc> ConstructorsMap;
static ConstructorsMap m_constructorsMap;
};
-
}
}
#include <set>
#include <map>
-namespace DPL
-{
-namespace Test
-{
+namespace DPL {
+namespace Test {
class TestRunner
{
typedef std::map<std::string, TestResultsCollectorBasePtr>
- TestResultsCollectors;
+ TestResultsCollectors;
TestResultsCollectors m_collectors;
std::string m_startTestId;
bool m_runIgnored;
-public:
+ public:
+ TestRunner() :
+ m_terminate(false)
+ , m_allowChildLogs(false)
+ {}
+
typedef void (*TestCase)();
-private:
+ private:
struct TestCaseStruct
{
std::string name;
return name == other.name;
}
- TestCaseStruct(const std::string &n, TestCase p)
- : name(n),
- proc(p)
- {
- }
+ TestCaseStruct(const std::string &n, TestCase p) :
+ name(n),
+ proc(p)
+ {}
};
typedef std::list<TestCaseStruct> TestCaseStructList;
DPL::Atomic m_totalAssertions;
+ // Terminate without any logs.
+ // Some test requires to call fork function.
+ // Child process must not produce any logs and should die quietly.
+ bool m_terminate;
+ bool m_allowChildLogs;
+
void Banner();
void InvalidArgs(const std::string& message = "Invalid arguments!");
void Usage();
= TestResultsCollectorBase::FailStatus::NONE,
const std::string& reason = std::string());
-public:
+ public:
class TestFailed
{
- private:
+ private:
std::string m_message;
- public:
+ public:
TestFailed()
- {
- }
+ {}
//! \brief Failed test message creator
//!
//! \param[in] aFile source file name
//! \param[in] aLine source file line
//! \param[in] aMessage error message
- TestFailed(const char* aTest, const char* aFile, int aLine, const std::string &aMessage);
+ TestFailed(const char* aTest,
+ const char* aFile,
+ int aLine,
+ const std::string &aMessage);
+
+ TestFailed(const std::string &message);
std::string GetMessage() const
{
class Ignored
{
- private:
+ private:
std::string m_message;
- public:
+ public:
Ignored()
- {
- }
+ {}
- Ignored(const std::string &message)
- : m_message(message)
- {
- }
+ Ignored(const std::string &message) :
+ m_message(message)
+ {}
std::string GetMessage() const
{
typedef std::vector<std::string> ArgsList;
int ExecTestRunner(const ArgsList& args);
bool getRunIgnored() const;
+ // The runner will terminate as soon as possible (after current test).
+ void Terminate();
+ bool GetAllowChildLogs();
};
typedef DPL::Singleton<TestRunner> TestRunnerSingleton;
-
}
} // namespace DPL
#define RUNNER_TEST_GROUP_INIT(GroupName) \
static int Static##GroupName##Init() \
{ \
- DPL::Test::TestRunnerSingleton::Instance().InitGroup(#GroupName);\
+ DPL::Test::TestRunnerSingleton::Instance().InitGroup(#GroupName); \
return 0; \
} \
- const int DPL_UNUSED Static##GroupName##InitVar = \
+ const int DPL_UNUSED Static##GroupName##InitVar = \
Static##GroupName##Init();
#define RUNNER_TEST(Proc) \
DPL::Test::TestRunnerSingleton::Instance().RegisterTest(#Proc, &Proc); \
return 0; \
} \
- const int DPL_UNUSED Static##Proc##InitVar = Static##Proc##Init(); \
+ const int DPL_UNUSED Static##Proc##InitVar = Static##Proc##Init(); \
void Proc()
//! \brief Returns base name for path
#define RUNNER_ASSERT_MSG(test, message) \
-do \
-{ \
- DPL::Test::TestRunnerSingleton::Instance().MarkAssertion(); \
+ do \
+ { \
+ DPL::Test::TestRunnerSingleton::Instance().MarkAssertion(); \
\
- if (!(test)) \
- { \
- std::ostringstream assertMsg; \
- assertMsg << message; \
- throw DPL::Test::TestRunner::TestFailed(#test, __FILE__, __LINE__, assertMsg.str()); \
- } \
-} while (0)
+ if (!(test)) \
+ { \
+ std::ostringstream assertMsg; \
+ assertMsg << message; \
+ throw DPL::Test::TestRunner::TestFailed(#test, \
+ __FILE__, \
+ __LINE__, \
+ assertMsg.str()); \
+ } \
+ } while (0)
#define RUNNER_ASSERT(test) RUNNER_ASSERT_MSG(test, "")
#define RUNNER_FAIL RUNNER_ASSERT(false)
-#define RUNNER_IGNORED_MSG(message) do { std::ostringstream assertMsg; assertMsg << message; throw DPL::Test::TestRunner::Ignored(assertMsg.str()); } while (0)
+#define RUNNER_IGNORED_MSG(message) do { std::ostringstream assertMsg; \
+ assertMsg << message; \
+ throw DPL::Test::TestRunner::Ignored( \
+ assertMsg.str()); \
+} while (0)
#endif // DPL_TEST_RUNNER_H
--- /dev/null
+/*
+ * Copyright (c) 2013 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 test_runner_child.h
+ * @author Bartlomiej Grzelewski (b.grzelewski@samsung.com)
+ * @version 1.0
+ * @brief This file is the header file of test runner
+ */
+#ifndef DPL_TEST_RUNNER_CHILD_H
+#define DPL_TEST_RUNNER_CHILD_H
+
+#include <dpl/test/test_runner.h>
+
+namespace DPL {
+namespace Test {
+void RunChildProc(TestRunner::TestCase procChild);
+} // namespace Test
+} // namespace DPL
+
+#define RUNNER_CHILD_TEST(Proc) \
+ void Proc(); \
+ void Proc##Child(); \
+ static int Static##Proc##Init() \
+ { \
+ DPL::Test::TestRunnerSingleton::Instance().RegisterTest(#Proc, &Proc); \
+ return 0; \
+ } \
+ const int DPL_UNUSED Static##Proc##InitVar = Static##Proc##Init(); \
+ void Proc(){ \
+ DPL::Test::RunChildProc(&Proc##Child); \
+ } \
+ void Proc##Child()
+
+#endif // DPL_TEST_RUNNER_CHILD_H
#include <sstream>
#include <cstdlib>
-#define GREEN_RESULT_OK "[%s%s%s]\n", BOLD_GREEN_BEGIN, " OK ", BOLD_GREEN_END
+#define GREEN_RESULT_OK "[%s%s%s]\n", BOLD_GREEN_BEGIN, " OK ", \
+ BOLD_GREEN_END
-namespace DPL
-{
-namespace Test
-{
-
-namespace
-{
+namespace DPL {
+namespace Test {
+namespace {
const char *DEFAULT_HTML_FILE_NAME = "index.html";
const char *DEFAULT_TAP_FILE_NAME = "results.tap";
const char *DEFAULT_XML_FILE_NAME = "results.xml";
bool ParseCollectorFileArg(const std::string &arg, std::string &filename)
{
const std::string argname = "--file=";
- if (0 == arg.find(argname)) {
+ if (arg.find(argname) == 0 ) {
filename = arg.substr(argname.size());
return true;
}
m_ignored(0),
m_passed(0),
m_count(0)
- {
- }
+ {}
void AddTest(TestResultsCollectorBase::FailStatus::Type type)
{
++m_count;
switch (type) {
- case TestResultsCollectorBase::FailStatus::INTERNAL:
- case TestResultsCollectorBase::FailStatus::FAILED: ++m_failed; break;
- case TestResultsCollectorBase::FailStatus::IGNORED: ++m_ignored; break;
- case TestResultsCollectorBase::FailStatus::NONE: ++m_passed; break;
- default:
- Assert(false && "Bad FailStatus");
+ case TestResultsCollectorBase::FailStatus::INTERNAL:
+ case TestResultsCollectorBase::FailStatus::FAILED: ++m_failed;
+ break;
+ case TestResultsCollectorBase::FailStatus::IGNORED: ++m_ignored;
+ break;
+ case TestResultsCollectorBase::FailStatus::NONE: ++m_passed;
+ break;
+ default:
+ Assert(false && "Bad FailStatus");
}
}
- std::size_t GetTotal() const { return m_count; }
- std::size_t GetPassed() const { return m_passed; }
- std::size_t GetSuccesed() const { return m_passed; }
- std::size_t GetFailed() const { return m_failed; }
- std::size_t GetIgnored() const { return m_ignored; }
+ std::size_t GetTotal() const
+ {
+ return m_count;
+ }
+ std::size_t GetPassed() const
+ {
+ return m_passed;
+ }
+ std::size_t GetSuccesed() const
+ {
+ return m_passed;
+ }
+ std::size_t GetFailed() const
+ {
+ return m_failed;
+ }
+ std::size_t GetIgnored() const
+ {
+ return m_ignored;
+ }
float GetPassedOrIgnoredPercend() const
{
float passIgnoredPercent =
std::size_t m_count;
};
-class ConsoleCollector
- : public TestResultsCollectorBase
+class ConsoleCollector :
+ public TestResultsCollectorBase
{
public:
static TestResultsCollectorBase* Constructor();
std::string tmp = "'" + id + "' ...";
printf("Running test case %-60s", tmp.c_str());
- switch(status) {
- case TestResultsCollectorBase::FailStatus::NONE:
- printf(GREEN_RESULT_OK); break;
- case TestResultsCollectorBase::FailStatus::FAILED:
- PrintfErrorMessage( " FAILED ", reason, true); break;
- case TestResultsCollectorBase::FailStatus::IGNORED:
- PrintfIgnoredMessage("Ignored ", reason, true); break;
- case TestResultsCollectorBase::FailStatus::INTERNAL:
- PrintfErrorMessage( "INTERNAL", reason, true); break;
- default:
- Assert(false && "Bad status");
+ switch (status) {
+ case TestResultsCollectorBase::FailStatus::NONE:
+ printf(GREEN_RESULT_OK);
+ break;
+ case TestResultsCollectorBase::FailStatus::FAILED:
+ PrintfErrorMessage(" FAILED ", reason, true);
+ break;
+ case TestResultsCollectorBase::FailStatus::IGNORED:
+ PrintfIgnoredMessage("Ignored ", reason, true);
+ break;
+ case TestResultsCollectorBase::FailStatus::INTERNAL:
+ PrintfErrorMessage("INTERNAL", reason, true);
+ break;
+ default:
+ Assert(false && "Bad status");
}
m_stats.AddTest(status);
m_groupsStats[m_currentGroup].AddTest(status);
BOLD_YELLOW_END);
} else {
printf("[%s%s%s]\n",
- BOLD_RED_BEGIN,
- type,
- BOLD_RED_END);
+ BOLD_RED_BEGIN,
+ type,
+ BOLD_RED_END);
}
}
BOLD_GOLD_END);
} else {
printf("[%s%s%s]\n",
- CYAN_BEGIN ,
+ CYAN_BEGIN,
type,
CYAN_END);
}
void PrintStats(const std::string& title, const Statistic& stats)
{
using namespace DPL::Colors::Text;
- printf("\n%sResults [%s]: %s\n", BOLD_GREEN_BEGIN, title.c_str(), BOLD_GREEN_END);
- printf("%s%s%3d%s\n", CYAN_BEGIN, "Total tests: ", stats.GetTotal(), CYAN_END);
- printf(" %s%s%3d%s\n", CYAN_BEGIN, "Succeeded: ", stats.GetPassed(), CYAN_END);
- printf(" %s%s%3d%s\n", CYAN_BEGIN, "Failed: ", stats.GetFailed(), CYAN_END);
- printf(" %s%s%3d%s\n", CYAN_BEGIN, "Ignored: ", stats.GetIgnored(), CYAN_END);
+ printf("\n%sResults [%s]: %s\n", BOLD_GREEN_BEGIN,
+ title.c_str(), BOLD_GREEN_END);
+ printf("%s%s%3d%s\n",
+ CYAN_BEGIN,
+ "Total tests: ",
+ stats.GetTotal(),
+ CYAN_END);
+ printf(" %s%s%3d%s\n",
+ CYAN_BEGIN,
+ "Succeeded: ",
+ stats.GetPassed(),
+ CYAN_END);
+ printf(" %s%s%3d%s\n",
+ CYAN_BEGIN,
+ "Failed: ",
+ stats.GetFailed(),
+ CYAN_END);
+ printf(" %s%s%3d%s\n",
+ CYAN_BEGIN,
+ "Ignored: ",
+ stats.GetIgnored(),
+ CYAN_END);
}
Statistic m_stats;
std::string m_currentGroup;
};
-
TestResultsCollectorBase* ConsoleCollector::Constructor()
{
return new ConsoleCollector();
}
-
-class HtmlCollector
- : public TestResultsCollectorBase
+class HtmlCollector :
+ public TestResultsCollectorBase
{
public:
static TestResultsCollectorBase* Constructor();
virtual void CollectCurrentTestGroupName(const std::string& name)
{
- fprintf(m_fp.Get(),"<b>Starting group %s", name.c_str());
+ fprintf(m_fp.Get(), "<b>Starting group %s", name.c_str());
m_currentGroup = name;
}
virtual bool Configure()
{
- m_fp.Reset(fopen (m_filename.c_str(), "w"));
+ m_fp.Reset(fopen(m_filename.c_str(), "w"));
if (!m_fp) {
LogPedantic("Could not open file " << m_filename << " for writing");
return false;
std::string tmp = "'" + id + "' ...";
fprintf(m_fp.Get(), "Running test case %-100s", tmp.c_str());
- switch(status) {
- case TestResultsCollectorBase::FailStatus::NONE:
- fprintf(m_fp.Get(), GREEN_RESULT_OK); break;
- case TestResultsCollectorBase::FailStatus::FAILED:
- PrintfErrorMessage( " FAILED ", reason, true); break;
- case TestResultsCollectorBase::FailStatus::IGNORED:
- PrintfIgnoredMessage("Ignored ", reason, true); break;
- case TestResultsCollectorBase::FailStatus::INTERNAL:
- PrintfErrorMessage( "INTERNAL", reason, true); break;
- default:
- Assert(false && "Bad status");
+ switch (status) {
+ case TestResultsCollectorBase::FailStatus::NONE:
+ fprintf(m_fp.Get(), GREEN_RESULT_OK);
+ break;
+ case TestResultsCollectorBase::FailStatus::FAILED:
+ PrintfErrorMessage(" FAILED ", reason, true);
+ break;
+ case TestResultsCollectorBase::FailStatus::IGNORED:
+ PrintfIgnoredMessage("Ignored ", reason, true);
+ break;
+ case TestResultsCollectorBase::FailStatus::INTERNAL:
+ PrintfErrorMessage("INTERNAL", reason, true);
+ break;
+ default:
+ Assert(false && "Bad status");
}
m_groupsStats[m_currentGroup].AddTest(status);
m_stats.AddTest(status);
} else {
fprintf(m_fp.Get(),
"[%s%s%s]\n",
- CYAN_BEGIN ,
+ CYAN_BEGIN,
type,
CYAN_END);
}
void PrintStats(const std::string& name, const Statistic& stats)
{
using namespace DPL::Colors::Html;
- fprintf(m_fp.Get(), "\n%sResults [%s]:%s\n", BOLD_GREEN_BEGIN, name.c_str(), BOLD_GREEN_END);
- fprintf(m_fp.Get(), "%s%s%3d%s\n", CYAN_BEGIN, "Total tests: ", stats.GetTotal(), CYAN_END);
- fprintf(m_fp.Get(), " %s%s%3d%s\n", CYAN_BEGIN, "Succeeded: ", stats.GetPassed(), CYAN_END);
- fprintf(m_fp.Get(), " %s%s%3d%s\n", CYAN_BEGIN, "Failed: ", stats.GetFailed(), CYAN_END);
- fprintf(m_fp.Get(), " %s%s%3d%s\n", CYAN_BEGIN, "Ignored: ", stats.GetIgnored(), CYAN_END);
+ fprintf(
+ m_fp.Get(), "\n%sResults [%s]:%s\n", BOLD_GREEN_BEGIN,
+ name.c_str(), BOLD_GREEN_END);
+ fprintf(
+ m_fp.Get(), "%s%s%3d%s\n", CYAN_BEGIN,
+ "Total tests: ", stats.GetTotal(), CYAN_END);
+ fprintf(
+ m_fp.Get(), " %s%s%3d%s\n", CYAN_BEGIN,
+ "Succeeded: ", stats.GetPassed(), CYAN_END);
+ fprintf(
+ m_fp.Get(), " %s%s%3d%s\n", CYAN_BEGIN,
+ "Failed: ", stats.GetFailed(), CYAN_END);
+ fprintf(
+ m_fp.Get(), " %s%s%3d%s\n", CYAN_BEGIN,
+ "Ignored: ", stats.GetIgnored(), CYAN_END);
}
std::string m_filename;
return new HtmlCollector();
}
-
-class XmlCollector
- : public TestResultsCollectorBase
+class XmlCollector :
+ public TestResultsCollectorBase
{
public:
static TestResultsCollectorBase* Constructor();
virtual void CollectCurrentTestGroupName(const std::string& name)
{
std::size_t pos = GetCurrentGroupPosition();
- if (std::string::npos != pos)
- {
+ if (std::string::npos != pos) {
GroupFinish(pos);
FlushOutput();
m_stats = Statistic();
}
pos = m_outputBuffer.find("</testsuites>");
- if (std::string::npos == pos)
- {
+ if (std::string::npos == pos) {
ThrowMsg(DPL::Exception, "Could not find test suites closing tag");
}
GroupStart(pos, name);
groupHeader << ">";
groupHeader << "\n\t\t<testcase name=\"unknown\" status=\"FAILED\">";
- groupHeader << "\n\t\t\t<failure type=\"FAILED\" message=\"segmentation fault\"/>";
+ groupHeader <<
+ "\n\t\t\t<failure type=\"FAILED\" message=\"segmentation fault\"/>";
groupHeader << "\n\t\t</testcase>";
groupHeader << "\n\t</testsuite>";
virtual bool Configure()
{
- m_fp.Reset(fopen (m_filename.c_str(), "w"));
+ m_fp.Reset(fopen(m_filename.c_str(), "w"));
if (!m_fp) {
LogPedantic("Could not open file " << m_filename << " for writing");
return false;
virtual void Finish()
{
std::size_t pos = GetCurrentGroupPosition();
- if (std::string::npos != pos)
- {
+ if (std::string::npos != pos) {
GroupFinish(pos);
FlushOutput();
}
m_resultBuffer.append("\t\t<testcase name=\"");
m_resultBuffer.append(EscapeSpecialCharacters(id));
m_resultBuffer.append("\"");
- switch(status) {
- case TestResultsCollectorBase::FailStatus::NONE:
- m_resultBuffer.append(" status=\"OK\"/>\n");
- break;
- case TestResultsCollectorBase::FailStatus::FAILED:
- m_resultBuffer.append(" status=\"FAILED\">\n");
- PrintfErrorMessage("FAILED", EscapeSpecialCharacters(reason), true);
- m_resultBuffer.append("\t\t</testcase>\n");
- break;
- case TestResultsCollectorBase::FailStatus::IGNORED:
- m_resultBuffer.append(" status=\"Ignored\">\n");
- PrintfIgnoredMessage("Ignored", EscapeSpecialCharacters(reason), true);
- m_resultBuffer.append("\t\t</testcase>\n");
- break;
- case TestResultsCollectorBase::FailStatus::INTERNAL:
- m_resultBuffer.append(" status=\"FAILED\">\n");
- PrintfErrorMessage("INTERNAL", EscapeSpecialCharacters(reason), true);
- m_resultBuffer.append("\t\t</testcase>");
- break;
- default:
- Assert(false && "Bad status");
+ switch (status) {
+ case TestResultsCollectorBase::FailStatus::NONE:
+ m_resultBuffer.append(" status=\"OK\"/>\n");
+ break;
+ case TestResultsCollectorBase::FailStatus::FAILED:
+ m_resultBuffer.append(" status=\"FAILED\">\n");
+ PrintfErrorMessage("FAILED", EscapeSpecialCharacters(reason), true);
+ m_resultBuffer.append("\t\t</testcase>\n");
+ break;
+ case TestResultsCollectorBase::FailStatus::IGNORED:
+ m_resultBuffer.append(" status=\"Ignored\">\n");
+ PrintfIgnoredMessage("Ignored", EscapeSpecialCharacters(
+ reason), true);
+ m_resultBuffer.append("\t\t</testcase>\n");
+ break;
+ case TestResultsCollectorBase::FailStatus::INTERNAL:
+ m_resultBuffer.append(" status=\"FAILED\">\n");
+ PrintfErrorMessage("INTERNAL", EscapeSpecialCharacters(
+ reason), true);
+ m_resultBuffer.append("\t\t</testcase>");
+ break;
+ default:
+ Assert(false && "Bad status");
}
std::size_t group_pos = GetCurrentGroupPosition();
- if (std::string::npos == group_pos)
- {
+ if (std::string::npos == group_pos) {
ThrowMsg(DPL::Exception, "No current group set");
}
- std::size_t last_case_pos = m_outputBuffer.find("<testcase name=\"unknown\"", group_pos);
- if (std::string::npos == last_case_pos)
- {
+ std::size_t last_case_pos = m_outputBuffer.find(
+ "<testcase name=\"unknown\"",
+ group_pos);
+ if (std::string::npos == last_case_pos) {
ThrowMsg(DPL::Exception, "Could not find SegFault test case");
}
m_outputBuffer.insert(last_case_pos - 2, m_resultBuffer);
std::string pattern = name + "=\"";
std::size_t start = m_outputBuffer.find(pattern, elementPosition);
- if (std::string::npos == start)
- {
- ThrowMsg(DPL::Exception, "Could not find attribute " << name << " beginning");
+ if (std::string::npos == start) {
+ ThrowMsg(DPL::Exception,
+ "Could not find attribute " << name << " beginning");
}
std::size_t end = m_outputBuffer.find("\"", start + pattern.length());
- if (std::string::npos == end)
- {
- ThrowMsg(DPL::Exception, "Could not find attribute " << name << " end");
+ if (std::string::npos == end) {
+ ThrowMsg(DPL::Exception,
+ "Could not find attribute " << name << " end");
}
m_outputBuffer.replace(start + pattern.length(),
void GroupFinish(const std::size_t groupPosition)
{
std::size_t segFaultStart =
- m_outputBuffer.find("<testcase name=\"unknown\"", groupPosition);
- if (std::string::npos == segFaultStart)
- {
- ThrowMsg(DPL::Exception, "Could not find SegFault test case start position");
+ m_outputBuffer.find("<testcase name=\"unknown\"", groupPosition);
+ if (std::string::npos == segFaultStart) {
+ ThrowMsg(DPL::Exception,
+ "Could not find SegFault test case start position");
}
segFaultStart -= 2; // to erase tabs
std::string closeTag = "</testcase>";
std::size_t segFaultEnd = m_outputBuffer.find(closeTag, segFaultStart);
- if (std::string::npos == segFaultEnd)
- {
- ThrowMsg(DPL::Exception, "Could not find SegFault test case end position");
+ if (std::string::npos == segFaultEnd) {
+ ThrowMsg(DPL::Exception,
+ "Could not find SegFault test case end position");
}
segFaultEnd += closeTag.length() + 1; // to erase new line
void FlushOutput()
{
int fd = fileno(m_fp.Get());
- if (-1 == fd)
- {
+ if (-1 == fd) {
int error = errno;
ThrowMsg(DPL::Exception, DPL::GetErrnoString(error));
}
- if (-1 == TEMP_FAILURE_RETRY(ftruncate(fd, 0L)))
- {
+ if (-1 == TEMP_FAILURE_RETRY(ftruncate(fd, 0L))) {
int error = errno;
ThrowMsg(DPL::Exception, DPL::GetErrnoString(error));
}
- if (-1 == TEMP_FAILURE_RETRY(fseek(m_fp.Get(), 0L, SEEK_SET)))
- {
+ if (-1 == TEMP_FAILURE_RETRY(fseek(m_fp.Get(), 0L, SEEK_SET))) {
int error = errno;
ThrowMsg(DPL::Exception, DPL::GetErrnoString(error));
}
- if (0 > fprintf(m_fp.Get(), m_outputBuffer.c_str()))
+ if (m_outputBuffer.size() !=
+ fwrite(m_outputBuffer.c_str(), 1, m_outputBuffer.size(),
+ m_fp.Get()))
{
int error = errno;
ThrowMsg(DPL::Exception, DPL::GetErrnoString(error));
}
- if (-1 == TEMP_FAILURE_RETRY(fflush(m_fp.Get())))
- {
+ if (-1 == TEMP_FAILURE_RETRY(fflush(m_fp.Get()))) {
int error = errno;
ThrowMsg(DPL::Exception, DPL::GetErrnoString(error));
}
m_resultBuffer.append("\" message=\"");
m_resultBuffer.append(EscapeSpecialCharacters(message));
m_resultBuffer.append("\"/>\n");
-
} else {
-
m_resultBuffer.append("\t\t\t<failure type=\"");
m_resultBuffer.append(EscapeSpecialCharacters(type));
m_resultBuffer.append("\"/>\n");
m_resultBuffer.append(EscapeSpecialCharacters(message));
m_resultBuffer.append("\"/>\n");
} else {
-
m_resultBuffer.append("\t\t\t<skipped type=\"");
m_resultBuffer.append(EscapeSpecialCharacters(type));
m_resultBuffer.append("\"/>\n");
std::string EscapeSpecialCharacters(std::string s)
{
for (unsigned int i = 0; i < s.size();) {
- switch(s[i]){
+ switch (s[i]) {
case '"':
- s.erase(i,1);
+ s.erase(i, 1);
s.insert(i, """);
- i+=6;
+ i += 6;
break;
case '&':
- s.erase(i,1);
+ s.erase(i, 1);
s.insert(i, "&");
- i+=5;
+ i += 5;
break;
case '<':
- s.erase(i,1);
+ s.erase(i, 1);
s.insert(i, "<");
- i+=4;
+ i += 4;
break;
case '>':
- s.erase(i,1);
+ s.erase(i, 1);
s.insert(i, ">");
- i+=4;
+ i += 4;
break;
case '\'':
- s.erase(i,1);
+ s.erase(i, 1);
s.insert(i, "'");
- i+=5;
+ i += 5;
break;
default:
++i;
return new XmlCollector();
}
-
-
-class CSVCollector
- : public TestResultsCollectorBase
+class CSVCollector :
+ public TestResultsCollectorBase
{
public:
static TestResultsCollectorBase* Constructor();
private:
CSVCollector() {}
- virtual void Start() {
+ virtual void Start()
+ {
printf("GROUP;ID;RESULT;REASON\n");
}
const std::string& reason = "")
{
std::string statusMsg = "";
- switch(status) {
- case TestResultsCollectorBase::FailStatus::NONE: statusMsg = "OK"; break;
- case TestResultsCollectorBase::FailStatus::FAILED: statusMsg = "FAILED"; break;
- case TestResultsCollectorBase::FailStatus::IGNORED: statusMsg = "IGNORED"; break;
- case TestResultsCollectorBase::FailStatus::INTERNAL: statusMsg = "FAILED"; break;
- default:
- Assert(false && "Bad status");
+ switch (status) {
+ case TestResultsCollectorBase::FailStatus::NONE: statusMsg = "OK";
+ break;
+ case TestResultsCollectorBase::FailStatus::FAILED: statusMsg = "FAILED";
+ break;
+ case TestResultsCollectorBase::FailStatus::IGNORED: statusMsg =
+ "IGNORED";
+ break;
+ case TestResultsCollectorBase::FailStatus::INTERNAL: statusMsg =
+ "FAILED";
+ break;
+ default:
+ Assert(false && "Bad status");
}
printf("%s;%s;%s;%s\n",
m_currentGroup.c_str(),
std::string m_currentGroup;
};
-
TestResultsCollectorBase* CSVCollector::Constructor()
{
return new CSVCollector();
}
-
}
-class TAPCollector
- : public TestResultsCollectorBase
+class TAPCollector :
+ public TestResultsCollectorBase
{
public:
static TestResultsCollectorBase* Constructor();
const std::string& reason = "")
{
m_testIndex++;
- switch(status) {
- case TestResultsCollectorBase::FailStatus::NONE:
- LogBasicTAP(true, id, description);
- endTAPLine();
- break;
- case TestResultsCollectorBase::FailStatus::FAILED:
- LogBasicTAP(false, id, description);
- endTAPLine();
- break;
- case TestResultsCollectorBase::FailStatus::IGNORED:
- LogBasicTAP(true, id, description);
- m_collectedData << " # skip " << reason;
- endTAPLine();
- break;
- case TestResultsCollectorBase::FailStatus::INTERNAL:
- LogBasicTAP(true, id, description);
- endTAPLine();
- m_collectedData << " ---" << std::endl;
- m_collectedData << " message: " << reason << std::endl;
- m_collectedData << " severity: Internal" << std::endl;
- m_collectedData << " ..." << std::endl;
- break;
- default:
- Assert(false && "Bad status");
+ switch (status) {
+ case TestResultsCollectorBase::FailStatus::NONE:
+ LogBasicTAP(true, id, description);
+ endTAPLine();
+ break;
+ case TestResultsCollectorBase::FailStatus::FAILED:
+ LogBasicTAP(false, id, description);
+ endTAPLine();
+ break;
+ case TestResultsCollectorBase::FailStatus::IGNORED:
+ LogBasicTAP(true, id, description);
+ m_collectedData << " # skip " << reason;
+ endTAPLine();
+ break;
+ case TestResultsCollectorBase::FailStatus::INTERNAL:
+ LogBasicTAP(true, id, description);
+ endTAPLine();
+ m_collectedData << " ---" << std::endl;
+ m_collectedData << " message: " << reason << std::endl;
+ m_collectedData << " severity: Internal" << std::endl;
+ m_collectedData << " ..." << std::endl;
+ break;
+ default:
+ Assert(false && "Bad status");
}
}
void LogBasicTAP(bool isOK, const std::string& id,
- const std::string& description)
+ const std::string& description)
{
if (!isOK) {
m_collectedData << "not ";
}
m_collectedData << "ok " << m_testIndex << " [" <<
- id << "] " << description;
+ id << "] " << description;
}
void endTAPLine()
m_collectedData << std::endl;
}
-
std::string m_filename;
std::stringstream m_collectedData;
std::ofstream m_output;
int m_testIndex;
};
-
TestResultsCollectorBase* TAPCollector::Constructor()
{
return new TAPCollector();
}
-
void TestResultsCollectorBase::RegisterCollectorConstructor(
const std::string& name,
TestResultsCollectorBase::CollectorConstructorFunc func)
const std::string& name)
{
ConstructorsMap::iterator found = m_constructorsMap.find(name);
- if (found != m_constructorsMap.end())
+ if (found != m_constructorsMap.end()) {
return found->second();
- else
+ } else {
return NULL;
+ }
}
std::vector<std::string> TestResultsCollectorBase::GetCollectorsNames()
return list;
}
-TestResultsCollectorBase::ConstructorsMap TestResultsCollectorBase::m_constructorsMap;
+TestResultsCollectorBase::ConstructorsMap TestResultsCollectorBase::
+ m_constructorsMap;
-namespace
-{
+namespace {
static int RegisterCollectorConstructors();
static const int RegisterHelperVariable = RegisterCollectorConstructors();
int RegisterCollectorConstructors()
return 0;
}
-
}
-
}
}
#undef GREEN_RESULT_OK
#include <dpl/singleton_impl.h>
IMPLEMENT_SINGLETON(DPL::Test::TestRunner)
-namespace DPL
-{
-namespace Test
-{
-
+namespace DPL {
+namespace Test {
namespace // anonymous
{
-
std::string BaseName(std::string aPath)
{
ScopedFree<char> path(strdup(aPath.c_str()));
- if (NULL == path.Get())
- {
- throw std::bad_alloc();
+ if (NULL == path.Get()) {
+ throw std::bad_alloc();
}
char* baseName = basename(path.Get());
std::string retValue = baseName;
return retValue;
}
-
} // namespace anonymous
//! \brief Failed test message creator
m_message = assertMsg.str();
}
+TestRunner::TestFailed::TestFailed(const std::string &message)
+{
+ m_message = message;
+}
+
void TestRunner::RegisterTest(const char *testName, TestCase proc)
{
m_testGroups[m_currentGroup].push_back(TestCaseStruct(testName, proc));
m_currentGroup = name;
}
-
TestRunner::Status TestRunner::RunTestCase(const TestCaseStruct& testCase)
{
- try
- {
+ try {
testCase.proc();
- }
- catch (const TestFailed &e)
- {
+ } catch (const TestFailed &e) {
// Simple test failure
CollectResult(testCase.name,
"",
TestResultsCollectorBase::FailStatus::FAILED,
e.GetMessage());
return FAILED;
- }
- catch (const Ignored &e)
- {
+ } catch (const Ignored &e) {
if (m_runIgnored) {
// Simple test have to be implemented
CollectResult(testCase.name,
}
return IGNORED;
- }
- catch (const DPL::Exception &e)
- {
+ } catch (const DPL::Exception &e) {
// DPL exception failure
CollectResult(testCase.name,
"",
"DPL exception:" + e.GetMessage());
return FAILED;
- }
- catch (const std::exception &)
- {
+ } catch (const std::exception &) {
// std exception failure
CollectResult(testCase.name,
"",
"std exception");
return FAILED;
- }
- catch (...)
- {
+ } catch (...) {
// Unknown exception failure
CollectResult(testCase.name,
"",
Banner();
std::for_each(m_collectors.begin(),
m_collectors.end(),
- [](const TestResultsCollectors::value_type& collector)
+ [] (const TestResultsCollectors::value_type & collector)
{
collector.second->Start();
});
TestCaseStructList list = group->second;
if (!list.empty()) {
std::for_each(
- m_collectors.begin(),
- m_collectors.end(),
- [&group](const TestResultsCollectors::value_type& collector)
- {
- collector.second->
- CollectCurrentTestGroupName(group->first);
- });
+ m_collectors.begin(),
+ m_collectors.end(),
+ [&group](const TestResultsCollectors::value_type & collector)
+ {
+ collector.second->
+ CollectCurrentTestGroupName(group->first);
+ });
list.sort();
for (TestCaseStructList::const_iterator iterator = list.begin();
++iterator)
{
TestCaseStruct test = *iterator;
- if (m_startTestId == test.name)
+ if (m_startTestId == test.name) {
m_startTestId = "";
+ }
if (m_startTestId.empty()) {
RunTestCase(test);
}
+ if (m_terminate == true) {
+ // Terminate quietly without any logs
+ return;
+ }
}
}
}
std::for_each(m_collectors.begin(),
m_collectors.end(),
- [](const TestResultsCollectors::value_type& collector)
+ [] (const TestResultsCollectors::value_type & collector)
{
collector.second->Finish();
});
}
void TestRunner::CollectResult(
- const std::string& id,
- const std::string& description,
- const TestResultsCollectorBase::FailStatus::Type status,
- const std::string& reason)
+ const std::string& id,
+ const std::string& description,
+ const TestResultsCollectorBase::FailStatus::Type status,
+ const std::string& reason)
{
std::for_each(m_collectors.begin(),
m_collectors.end(),
- [&](const TestResultsCollectors::value_type& collector)
+ [&](const TestResultsCollectors::value_type & collector)
{
collector.second->CollectResult(id,
description,
fprintf(stderr, "Output type:\n");
fprintf(stderr, " --output=<output type> --output=<output type> ...\n");
fprintf(stderr, "\n possible output types:\n");
- FOREACH (type, TestResultsCollectorBase::GetCollectorsNames()) {
+ FOREACH(type, TestResultsCollectorBase::GetCollectorsNames()) {
fprintf(stderr, " --output=%s\n", type->c_str());
}
fprintf(stderr, "\n example:\n");
- fprintf(stderr, " test-binary --output=text --output=xml --file=output.xml\n\n");
+ fprintf(stderr,
+ " test-binary --output=text --output=xml --file=output.xml\n\n");
fprintf(stderr, "Other parameters:\n");
fprintf(stderr,
" --regexp='regexp'\t Only selected tests"
fprintf(stderr, " --runignored\t Run also ignored tests\n");
fprintf(stderr, " --list\t Show a list of Test IDs\n");
fprintf(stderr, " --listgroups\t Show a list of Test Group names \n");
- fprintf(stderr, " --listingroup=<group name>\t Show a list of Test IDS in one group\n");
+ fprintf(
+ stderr,
+ " --listingroup=<group name>\t Show a list of Test IDS in one group\n");
+ fprintf(stderr, " --allowchildlogs\t Allow to print logs from child process on screen.\n");
+ fprintf(stderr, " When active child process will be able to print logs on stdout and stderr.\n");
+ fprintf(stderr, " Both descriptors will be closed after test.\n");
fprintf(stderr, " --help\t This help\n\n");
std::for_each(m_collectors.begin(),
m_collectors.end(),
- [](const TestResultsCollectors::value_type& collector)
+ [] (const TestResultsCollectors::value_type & collector)
{
fprintf(stderr,
"Output %s has specific args:\n",
fprintf(stderr,
"%s\n",
collector.second->
- CollectorSpecificHelp().c_str());
+ CollectorSpecificHelp().c_str());
});
fprintf(stderr, "For bug reporting, please write to:\n");
fprintf(stderr, "<p.dobrowolsk@samsung.com>\n");
int TestRunner::ExecTestRunner(int argc, char *argv[])
{
std::vector<std::string> args;
- for (int i = 0; i < argc; ++i)
- {
+ for (int i = 0; i < argc; ++i) {
args.push_back(argv[i]);
}
return ExecTestRunner(args);
m_runIgnored = false;
ArgsList args = value;
// Parse command line
- if (args.size() == 1)
- {
+ if (args.size() == 1) {
InvalidArgs();
Usage();
return -1;
const std::string startCmd = "--start=";
const std::string listGroupsCmd = "--listgroups";
const std::string listInGroup = "--listingroup=";
+ const std::string allowChildLogs = "--allowchildlogs";
- if (currentCollector)
- {
- if (currentCollector->ParseCollectorSpecificArg(arg))
- {
+ if (currentCollector) {
+ if (currentCollector->ParseCollectorSpecificArg(arg)) {
continue;
}
}
- if (arg.find(startCmd) == 0)
- {
+ if (arg.find(startCmd) == 0) {
arg.erase(0, startCmd.length());
FOREACH(group, m_testGroups) {
FOREACH(tc, group->second) {
break;
}
}
- if (!m_startTestId.empty()) break;
+ if (!m_startTestId.empty()) {
+ break;
+ }
+ }
+ if (!m_startTestId.empty()) {
+ continue;
}
- if (!m_startTestId.empty()) continue;
InvalidArgs();
fprintf(stderr, "Start test id has not been found\n");
Usage();
return 0;
- }
- else if (arg.find(groupId) == 0)
- {
+ } else if (arg.find(groupId) == 0) {
arg.erase(0, groupId.length());
TestCaseGroupMap::iterator found = m_testGroups.find(arg);
if (found != m_testGroups.end()) {
Usage();
return -1;
}
- }
- else if (arg == runIgnored)
- {
+ } else if (arg == runIgnored) {
m_runIgnored = true;
- }
- else if (arg == listCmd)
- {
+ } else if (arg == listCmd) {
FOREACH(group, m_testGroups) {
FOREACH(test, group->second) {
printf("ID:%s:%s\n", group->first.c_str(), test->name.c_str());
}
}
return 0;
- }
- else if (arg == listGroupsCmd)
- {
+ } else if (arg == listGroupsCmd) {
FOREACH(group, m_testGroups) {
printf("GR:%s\n", group->first.c_str());
}
return 0;
- }
- else if (arg.find(listInGroup) == 0)
- {
+ } else if (arg.find(listInGroup) == 0) {
arg.erase(0, listInGroup.length());
FOREACH(test, m_testGroups[arg]) {
printf("ID:%s\n", test->name.c_str());
}
return 0;
- }
- else if (arg == "--help")
+ } else if (arg.find(allowChildLogs) == 0) {
+ arg.erase(0, allowChildLogs.length());
+ m_allowChildLogs = true;
+ } else if (arg == "--help") {
showHelp = true;
- else if (arg.find(output) == 0)
- {
+ } else if (arg.find(output) == 0) {
arg.erase(0, output.length());
- if (m_collectors.find(arg) != m_collectors.end())
- {
- InvalidArgs("Multiple outputs of the same type are not supported!");
+ if (m_collectors.find(arg) != m_collectors.end()) {
+ InvalidArgs(
+ "Multiple outputs of the same type are not supported!");
Usage();
return -1;
}
return -1;
}
m_collectors[arg] = currentCollector;
- }
- else if (arg.find(regexp) == 0)
- {
+ } else if (arg.find(regexp) == 0) {
arg.erase(0, regexp.length());
- if (arg.length() == 0)
- {
+ if (arg.length() == 0) {
InvalidArgs();
Usage();
return -1;
}
- if (arg[0] == '\'' && arg[arg.length() - 1] == '\'')
- {
+ if (arg[0] == '\'' && arg[arg.length() - 1] == '\'') {
arg.erase(0);
arg.erase(arg.length() - 1);
}
- if (arg.length() == 0)
- {
+ if (arg.length() == 0) {
InvalidArgs();
Usage();
return -1;
TestCaseStructList newList;
FOREACH(iterator, group->second)
{
- if (re.PartialMatch(iterator->name))
- {
+ if (re.PartialMatch(iterator->name)) {
newList.push_back(*iterator);
}
}
group->second = newList;
}
- }
- else
- {
+ } else {
InvalidArgs();
Usage();
return -1;
currentCollector.reset();
// Show help
- if (showHelp)
- {
+ if (showHelp) {
Usage();
return 0;
}
- if (m_collectors.empty())
- {
+ if (m_collectors.empty()) {
TestResultsCollectorBasePtr collector(
- TestResultsCollectorBase::Create("text"));
+ TestResultsCollectorBase::Create("text"));
m_collectors["text"] = collector;
}
- for (auto it = m_collectors.begin(); it != m_collectors.end(); ++it)
- {
- if (!it->second->Configure())
- {
+ for (auto it = m_collectors.begin(); it != m_collectors.end(); ++it) {
+ if (!it->second->Configure()) {
fprintf(stderr, "Could not configure selected output");
return 0;
}
return m_runIgnored;
}
+void TestRunner::Terminate()
+{
+ m_terminate = true;
+}
+
+bool TestRunner::GetAllowChildLogs()
+{
+ return m_allowChildLogs;
+}
+
}
} // namespace DPL
--- /dev/null
+/*
+ * Copyright (c) 2013 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 test_runner_child.cpp
+ * @author Bartlomiej Grzelewski (b.grzelewski@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of test runner
+ */
+#include <stddef.h>
+#include <dpl/test/test_runner.h>
+#include <dpl/test/test_runner_child.h>
+#include <dpl/test/test_results_collector.h>
+#include <dpl/binary_queue.h>
+#include <dpl/exception.h>
+#include <dpl/scoped_free.h>
+#include <dpl/foreach.h>
+#include <dpl/colors.h>
+#include <pcrecpp.h>
+#include <algorithm>
+#include <cstdio>
+#include <memory.h>
+#include <libgen.h>
+#include <cstring>
+#include <cstdlib>
+#include <ctime>
+#include <unistd.h>
+#include <poll.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <dpl/utils/wrt_global_settings.h>
+
+namespace {
+const int PIPE_CLOSED = -1;
+}
+
+namespace DPL {
+namespace Test {
+class PipeWrapper : DPL::Noncopyable
+{
+ public:
+ enum Usage {
+ READONLY,
+ WRITEONLY
+ };
+
+ enum Status {
+ SUCCESS,
+ TIMEOUT,
+ ERROR
+ };
+
+ PipeWrapper()
+ {
+ if (-1 == pipe(m_pipefd)) {
+ m_pipefd[0] = PIPE_CLOSED;
+ m_pipefd[1] = PIPE_CLOSED;
+ }
+ }
+
+ bool isReady()
+ {
+ return m_pipefd[0] != PIPE_CLOSED || m_pipefd[1] != PIPE_CLOSED;
+ }
+
+ void setUsage(Usage usage)
+ {
+ if (usage == READONLY) {
+ closeHelp(1);
+ }
+ if (usage == WRITEONLY) {
+ closeHelp(0);
+ }
+ }
+ ~PipeWrapper()
+ {
+ closeHelp(0);
+ closeHelp(1);
+ }
+
+ Status send(int code, std::string &message)
+ {
+ if (m_pipefd[1] == PIPE_CLOSED) {
+ return ERROR;
+ }
+
+ std::ostringstream output;
+ output << toBinaryString(code);
+ output << toBinaryString(static_cast<int>(message.size()));
+ output << message;
+
+ std::string binary = output.str();
+ int size = binary.size();
+
+ if ((writeHelp(&size,
+ sizeof(int)) == ERROR) ||
+ (writeHelp(binary.c_str(), size) == ERROR))
+ {
+ return ERROR;
+ }
+ return SUCCESS;
+ }
+
+ Status receive(int &code, std::string &data, time_t deadline)
+ {
+ if (m_pipefd[0] == PIPE_CLOSED) {
+ return ERROR;
+ }
+
+ int size;
+ Status ret;
+
+ if ((ret = readHelp(&size, sizeof(int), deadline)) != SUCCESS) {
+ return ret;
+ }
+
+ std::vector<char> buffer;
+ buffer.resize(size);
+
+ if ((ret = readHelp(&buffer[0], size, deadline)) != SUCCESS) {
+ return ret;
+ }
+
+ try {
+ DPL::BinaryQueue queue;
+ queue.AppendCopy(&buffer[0], size);
+
+ queue.FlattenConsume(&code, sizeof(int));
+ queue.FlattenConsume(&size, sizeof(int));
+
+ buffer.resize(size);
+
+ queue.FlattenConsume(&buffer[0], size);
+ data.assign(buffer.begin(), buffer.end());
+ } catch (DPL::BinaryQueue::Exception::Base &e) {
+ return ERROR;
+ }
+ return SUCCESS;
+ }
+
+ void closeAll()
+ {
+ closeHelp(0);
+ closeHelp(1);
+ }
+
+ private:
+ std::string toBinaryString(int data)
+ {
+ char buffer[sizeof(int)];
+ memcpy(buffer, &data, sizeof(int));
+ return std::string(buffer, buffer + sizeof(int));
+ }
+
+ void closeHelp(int desc)
+ {
+ if (m_pipefd[desc] != PIPE_CLOSED) {
+ TEMP_FAILURE_RETRY(close(m_pipefd[desc]));
+ m_pipefd[desc] = PIPE_CLOSED;
+ }
+ }
+
+ Status writeHelp(const void *buffer, int size)
+ {
+ int ready = 0;
+ const char *p = static_cast<const char *>(buffer);
+ while (ready != size) {
+ int ret = write(m_pipefd[1], &p[ready], size - ready);
+
+ if (ret == -1 && (errno == EAGAIN || errno == EINTR)) {
+ continue;
+ }
+
+ if (ret == -1) {
+ closeHelp(1);
+ return ERROR;
+ }
+
+ ready += ret;
+ }
+ return SUCCESS;
+ }
+
+ Status readHelp(void *buf, int size, time_t deadline)
+ {
+ int ready = 0;
+ char *buffer = static_cast<char*>(buf);
+ while (ready != size) {
+ time_t wait = deadline - time(0);
+ wait = wait < 1 ? 1 : wait;
+ pollfd fds = { m_pipefd[0], POLLIN, 0 };
+
+ int pollReturn = poll(&fds, 1, wait * 1000);
+
+ if (pollReturn == 0) {
+ return TIMEOUT; // Timeout
+ }
+
+ if (pollReturn < -1) {
+ return ERROR;
+ }
+
+ int ret = read(m_pipefd[0], &buffer[ready], size - ready);
+
+ if (ret == -1 && (errno == EAGAIN || errno == EINTR)) {
+ continue;
+ }
+
+ if (ret == -1 || ret == 0) {
+ closeHelp(0);
+ return ERROR;
+ }
+
+ ready += ret;
+ }
+ return SUCCESS;
+ }
+
+ int m_pipefd[2];
+};
+
+void RunChildProc(TestRunner::TestCase procChild)
+{
+ PipeWrapper pipe;
+ if (!pipe.isReady()) {
+ throw TestRunner::TestFailed("Pipe creation failed");
+ }
+
+ pid_t pid = fork();
+
+ if (pid == -1) {
+ throw TestRunner::TestFailed("Child creation failed");
+ }
+
+ if (pid != 0) {
+ // parent code
+ pipe.setUsage(PipeWrapper::READONLY);
+
+ int code;
+ std::string message;
+
+ int pipeReturn = pipe.receive(code, message, time(0) + 10);
+
+ if (pipeReturn != PipeWrapper::SUCCESS) { // Timeout or reading error
+ pipe.closeAll();
+ kill(pid, SIGKILL);
+ }
+
+ int status;
+ waitpid(pid, &status, 0);
+
+ if (pipeReturn == PipeWrapper::TIMEOUT) {
+ throw TestRunner::TestFailed("Timeout");
+ }
+
+ if (pipeReturn == PipeWrapper::ERROR) {
+ throw TestRunner::TestFailed("Reading pipe error");
+ }
+
+ if (code == 0) {
+ throw TestRunner::TestFailed(message);
+ }
+ } else {
+ // child code
+
+ // End Runner after current test
+ TestRunnerSingleton::Instance().Terminate();
+
+ int code = 1;
+ std::string msg;
+
+ bool allowLogs = TestRunnerSingleton::Instance().GetAllowChildLogs();
+
+ close(0); // stdin
+ if (!allowLogs) {
+ close(1); // stdout
+ close(2); // stderr
+ }
+
+ pipe.setUsage(PipeWrapper::WRITEONLY);
+
+ try {
+ procChild();
+ } catch (DPL::Test::TestRunner::TestFailed &e) {
+ msg = e.GetMessage();
+ code = 0;
+ } catch (...) { // Pokemon Catch... cache them all...
+ msg = "unhandled exeception";
+ code = 0;
+ }
+
+ if (allowLogs) {
+ close(1); // stdout
+ close(2); // stderr
+ }
+
+ pipe.send(code, msg);
+ }
+}
+} // namespace Test
+} // namespace DPL
${PROJECT_SOURCE_DIR}/modules/utils/src/widget_version.cpp
${PROJECT_SOURCE_DIR}/modules/utils/src/wrt_global_settings.cpp
${PROJECT_SOURCE_DIR}/modules/utils/src/wrt_utility.cpp
+ ${PROJECT_SOURCE_DIR}/modules/utils/src/path.cpp
PARENT_SCOPE
)
-
SET(DPL_UTILS_HEADERS
${PROJECT_SOURCE_DIR}/modules/utils/include/dpl/utils/bash_utils.h
${PROJECT_SOURCE_DIR}/modules/utils/include/dpl/utils/folder_size.h
${PROJECT_SOURCE_DIR}/modules/utils/include/dpl/utils/widget_version.h
${PROJECT_SOURCE_DIR}/modules/utils/include/dpl/utils/wrt_global_settings.h
${PROJECT_SOURCE_DIR}/modules/utils/include/dpl/utils/wrt_utility.h
+ ${PROJECT_SOURCE_DIR}/modules/utils/include/dpl/utils/path.h
PARENT_SCOPE
)
#ifndef BASH_UTILS_H
#define BASH_UTILS_H
-#include<string>
+#include <string>
namespace BashUtils {
-
/**
* Escapes bash special characters in string and return string in double quotes
* @param source string to be escaped
* @return escaped string
*/
std::string escape_arg(const std::string & source);
-
}
#endif // BASH_UTILS_H
* @throw FileUtils::DirectoryRemoveException If an error occured.
*/
void RemoveDir(const std::string& path);
-
} // namespace FileUtils
#endif
#include <dpl/string.h>
namespace Utils {
-
size_t getFolderSize(const std::string& path);
DPL::String fromFileSizeString(size_t fileSize);
-
}
#endif /* SRC_COMMON_FOLDER_SIZE_H_ */
typedef std::map<DPL::String, DPL::String> MimeAttributes;
static bool isValidIcon(const DPL::String& path);
static bool isValidStartFile(const DPL::String& path,
- const DPL::OptionalString& providedMimeType);
+ const DPL::OptionalString& providedMimeType);
static bool isMimeTypeSupportedForStartFile(const DPL::String& mimeType);
static bool isMimeTypeSupportedForIcon(const DPL::String& mimeType);
static MimeAttributes getMimeAttributes(const DPL::String& mimeType);
--- /dev/null
+/*
+ * Copyright (c) 2013 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 path.h
+ * @author Tomasz Iwanek (t.iwanek@samsung.com)
+ * @version 1.0
+ */
+#ifndef PATH_H
+#define PATH_H
+
+#include <dirent.h>
+#include <sys/stat.h>
+
+#include <string>
+#include <sstream>
+#include <iterator>
+#include <memory>
+#include <vector>
+
+#include <dpl/exception.h>
+#include <dpl/string.h>
+
+namespace DPL {
+namespace Utils {
+class Path;
+}
+}
+
+std::ostream & operator<<(std::ostream & str, const DPL::Utils::Path & path);
+
+namespace DPL {
+namespace Utils {
+/**
+ * @brief The Path class path abstraction
+ *
+ * Class for expressing paths not limited not existing ones.
+ * It's possible to check if path exists, remove it or iterate it if it's directory
+ */
+class Path
+{
+public:
+ DECLARE_EXCEPTION_TYPE(DPL::Exception, BaseException)
+ DECLARE_EXCEPTION_TYPE(BaseException, AlreadyExists)
+ DECLARE_EXCEPTION_TYPE(BaseException, NotExists)
+ DECLARE_EXCEPTION_TYPE(BaseException, NotDirectory)
+ DECLARE_EXCEPTION_TYPE(BaseException, OperationFailed)
+ DECLARE_EXCEPTION_TYPE(BaseException, EmptyPath)
+ DECLARE_EXCEPTION_TYPE(BaseException, InternalError)
+
+ class Iterator : public std::iterator<std::input_iterator_tag, Path>
+ {
+ public:
+ Iterator();
+ Iterator(const char *);
+ Iterator& operator++();
+ Iterator operator++(int);
+ bool operator==(const Iterator& rhs) const;
+ bool operator!=(const Iterator& rhs) const;
+ const Path & operator*();
+ const Path * operator->();
+ private:
+ void ReadNext();
+
+ std::shared_ptr<DIR> m_dir;
+ std::shared_ptr<Path> m_path;
+ std::shared_ptr<Path> m_root;
+ };
+
+ explicit Path(const DPL::String & str);
+ explicit Path(const std::string & str);
+ explicit Path(const char * str);
+
+ /**
+ * @brief DirectoryName shell's dirname equivalent
+ * @return directory name of given path
+ */
+ std::string DirectoryName() const;
+ /**
+ * @brief Basename shell's basename equivalent
+ * @return base name of given path
+ */
+ std::string Basename() const;
+ /**
+ * @brief Fullpath fullpath based on current working diretory
+ * @return full path
+ */
+ std::string Fullpath() const;
+
+ bool Exists() const;
+ bool IsDir() const;
+ bool IsFile() const;
+ bool IsSymlink() const;
+
+ bool operator==(const Path & other) const;
+ bool operator!=(const Path & other) const;
+
+ //appending to path
+ Path operator/(const DPL::String& part) const;
+ Path operator/(const std::string& part) const;
+ Path operator/(const char * part) const;
+
+ Path & operator/=(const DPL::String& part);
+ Path & operator/=(const std::string& part);
+ Path & operator/=(const char * part);
+
+ //foreach
+ Iterator begin() const;
+ Iterator end() const;
+
+private:
+ Path();
+
+ void Append(const std::string& part);
+ void Construct(const std::string & src);
+
+ std::vector<std::string> m_parts;
+
+ friend std::ostream & ::operator<<(std::ostream & str, const DPL::Utils::Path & path);
+};
+
+/**
+ * @brief MkDir creates 'current path' as directory
+ * @param path path
+ * @param mode mode
+ */
+void MakeDir(const Path & path, mode_t mode = 0755);
+
+/**
+ * @brief MkFile creates 'current path' as empty file
+ * @param path path
+ */
+void MakeEmptyFile(const Path & path);
+
+/**
+ * @brief Remove removes 'current path'
+ * @param path path to remove
+ */
+void Remove(const Path & path);
+
+/**
+ * @brief Rename renames(moves) current path
+ *
+ * If you uses this method string to path is internally change
+ * and this object will store new path not only anymore
+ * @param from source path
+ * @param to target path
+ */
+void Rename(const Path & from, const Path & to);
+
+/**
+ * @brief Exists Checks if given path exists
+ * @param path path
+ * @return true if path exists
+ */
+bool Exists(const Path & path);
+
+}
+
+}
+
+//TODO: uncomment when user defiend literals are supported
+///Path operator"" p(const char * str);
+
+#endif // PATH_H
class WarpIRI
{
static const unsigned int UNKNOWN_PORT = 0;
+
public:
WarpIRI();
void set(const char *iri,
- bool domain);
+ bool domain);
void set(const DPL::String &iristring,
- bool domain);
+ bool domain);
/* It also checks port and schema */
bool isSubDomain(const WarpIRI &second) const;
* WAC Waikiki Beta Release Core Specification: Widget Runtime
* 10 Dec 2010
*
- * WL-3370 The WRT MUST process widget packages as an update when received under the following conditions:
+ * WL-3370 The WRT MUST process widget packages as an update when received under
+ * the following conditions:
*
* - the Widget Id matches the Widget Id of an installed widget
- * - the Widget version number is greater (as a compared string) than that of the installed widget, or no version
+ * - the Widget version number is greater (as a compared string) than that of
+ * the installed widget, or no version
* information was provided for the installed widget
*
- * To ensure that a string comparison of widget versions can reliably determine which version is an updated widget,
- * WAC will mandate a specific version string format for WAC widgets. All widgets coming through the WAC channel
- * will be required to have version strings in this format. Side-loaded widgets may have any format and, in this
- * case, there is no requirement that the WRT support version detection for update of these widgets.
+ * To ensure that a string comparison of widget versions can reliably determine
+ * which version is an updated widget,
+ * WAC will mandate a specific version string format for WAC widgets. All
+ * widgets coming through the WAC channel
+ * will be required to have version strings in this format. Side-loaded widgets
+ * may have any format and, in this
+ * case, there is no requirement that the WRT support version detection for
+ * update of these widgets.
*
- * The widget version format is the rec-version-tag grammar as described in [Widget Packaging]:
+ * The widget version format is the rec-version-tag grammar as described in
+ * [Widget Packaging]:
*
- * rec-version-tag = 1*DIGIT "." 1*DIGIT [ "." 1*DIGIT] *[ 1*ALPHA / SP / 1*DIGIT ]
+ * rec-version-tag = 1*DIGIT "." 1*DIGIT [ "." 1*DIGIT] *[ 1*ALPHA / SP /
+ * 1*DIGIT ]
*
* Examples of rec-version-tag:
*
* 1.10.1 beta1
* 1.02.12 RC1
*
- * WL-3371 The WRT MUST use the following widget version comparison algorithm to compare WAC widget version strings:
+ * WL-3371 The WRT MUST use the following widget version comparison algorithm to
+ * compare WAC widget version strings:
*
* - prepare the version strings for comparison:
* - all leading zeros are discarded
* - the optional *[ 1*ALPHA / SP / 1*DIGIT ] part, if present, is discarded
* - the resulting numbers are then in the format major.minor[.micro]
- * - Version A = Amajor.Aminor[.Amicro] is equal to Version B = Bmajor.Bminor[.Bmicro] if and only if:
+ * - Version A = Amajor.Aminor[.Amicro] is equal to Version B =
+ * Bmajor.Bminor[.Bmicro] if and only if:
* - Amajor Bmajor
* - Aminor Bminor
- * - both Amicro and Bmicro are present and Amicro == Bmicro; or both Amicro and Bmicro are absent.
- * - Version A = Amajor.Aminor[.Amicro] is greater than Version B = Bmajor.Bminor[.Bmicro] if and only if:
+ * - both Amicro and Bmicro are present and Amicro == Bmicro; or both Amicro
+ * and Bmicro are absent.
+ * - Version A = Amajor.Aminor[.Amicro] is greater than Version B =
+ * Bmajor.Bminor[.Bmicro] if and only if:
* - Amajor > Bmajor; or
* - Amajor Bmajor && Aminor > Bminor; or
- * - Amajor Bmajor && Aminor == Bminor && both Amicro and Bmicro are present and Amicro > Bmicro; or Bmicro is absent.
+ * - Amajor Bmajor && Aminor == Bminor && both Amicro and Bmicro are present
+ * and Amicro > Bmicro; or Bmicro is absent.
*/
class WidgetVersion
{
DPL::Optional<DPL::String> m_optional;
void WacCertify(const DPL::String &major,
- const DPL::String &minor,
- const DPL::Optional<DPL::String> µ,
- const DPL::Optional<DPL::String> &optional);
+ const DPL::String &minor,
+ const DPL::Optional<DPL::String> µ,
+ const DPL::Optional<DPL::String> &optional);
public:
explicit WidgetVersion(const DPL::String &str = DPL::String());
WidgetVersion(const DPL::String &major,
- const DPL::String &minor,
- const DPL::Optional<DPL::String> µ,
- const DPL::Optional<DPL::String> &optional);
+ const DPL::String &minor,
+ const DPL::Optional<DPL::String> µ,
+ const DPL::Optional<DPL::String> &optional);
bool IsWac() const;
const DPL::String &Raw() const;
};
bool operator<(const WidgetVersion &left,
- const WidgetVersion &right);
+ const WidgetVersion &right);
bool operator<=(const WidgetVersion &left,
- const WidgetVersion &right);
+ const WidgetVersion &right);
bool operator>(const WidgetVersion &left,
- const WidgetVersion &right);
+ const WidgetVersion &right);
bool operator>=(const WidgetVersion &left,
- const WidgetVersion &right);
+ const WidgetVersion &right);
bool operator==(const WidgetVersion &left,
- const WidgetVersion &right);
+ const WidgetVersion &right);
bool operator!=(const WidgetVersion &left,
- const WidgetVersion &right);
+ const WidgetVersion &right);
std::ostream & operator<<(std::ostream& stream,
- const WidgetVersion& version);
+ const WidgetVersion& version);
#endif // WIDGET_VERSION_H
#define WRT_COMMON_GLOBAL_SETTINGS_H_
namespace GlobalSettings {
-
// Methods for getting test mode environment flag
bool TestModeEnabled();
bool PopupsTestModeEnabled();
bool CrlTestModeEnabled();
bool MakeScreenTestModeEnabled();
bool IsEmulator();
-
}
#endif /* WRT_COMMON_GLOBAL_SETTINGS_H_ */
* Data stored in joined before the function call will be replaced with joined
* paths.
*/
-void WrtUtilJoinPaths(std::string &joined, const std::string &parent, const std::string &child);
+void WrtUtilJoinPaths(std::string &joined,
+ const std::string &parent,
+ const std::string &child);
/**
* Creates directories specified by path
* several nested directories, you must make sure that the mode flag allows you
* to write and search the direcotries you create.
*/
-bool WrtUtilMakeDir(const std::string &newpath, mode_t mode=0755);
+bool WrtUtilMakeDir(const std::string &newpath, mode_t mode = 0755);
/**
* This function removes the directory or file pointed to by path
* @version 1.0
*/
#include <stddef.h>
-#include<dpl/utils/bash_utils.h>
-#include<dpl/log/log.h>
+#include <dpl/utils/bash_utils.h>
+#include <dpl/log/log.h>
-#include<string>
+#include <string>
namespace BashUtils {
-
std::string escape_arg(const std::string & source)
{
static const std::string special("!$`\\\"");
std::string ret = "\"";
- for(std::string::const_iterator iter = source.begin(); iter != source.end(); ++iter)
+ for (std::string::const_iterator iter = source.begin();
+ iter != source.end();
+ ++iter)
{
- if(special.find(*iter) != std::string::npos)
- {
+ if (special.find(*iter) != std::string::npos) {
ret += std::string("\\") + *iter;
- }
- else
- {
+ } else {
ret += *iter;
}
}
return ret + "\"";
}
-
}
+++ /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 file_utils.cpp
- * @author Bartosz Janiak (b.janiak@samsung.com)
- * @version 1.0
- */
-
-
-#include <sys/stat.h>
-#include <cerrno>
-#include <cstring>
-#include <cstdlib>
-#include <dirent.h>
-#include <unistd.h>
-
-#include <dpl/exception.h>
-#include <dpl/errno_string.h>
-#include <dpl/utils/file_utils.h>
-
-#include <dpl/wrt-dao-ro/path_builder.h>
-
-namespace {
-int try_mkdir(const char* path,
- mode_t mode)
-{
- struct stat st;
- int err = 0;
-
- if (::stat(path, &st) != 0) {
- if (::mkdir(path, mode) != 0) {
- err = -1;
- }
- } else if (!S_ISDIR(st.st_mode)) {
- errno = ENOTDIR;
- err = -1;
- }
-
- return err;
-}
-
-int mkpath(const char* path,
- mode_t mode)
-{
- char* copy = ::strdup(path);
- if (NULL == copy) {
- return -1;
- }
-
- int err = 0;
- char* ptr = copy;
- char* slash = NULL;
-
- while ((0 == err) && (NULL != (slash = ::strchr(ptr, '/')))) {
- if (slash != ptr) {
- *slash = '\0';
- err = try_mkdir(copy, mode);
- *slash = '/';
- }
- ptr = slash + 1;
- }
-
- if (0 == err) {
- err = try_mkdir(path, mode);
- }
-
- ::free(copy);
- return err;
-}
-
-int RmNode(const char* path);
-
-int RmDir(const char* path)
-{
- DIR* dir = ::opendir(path);
- if (NULL == dir) {
- return -1;
- }
-
- struct dirent* entry = NULL;
- do {
- errno = 0;
- if (NULL != (entry = ::readdir(dir))) {
- if (!::strncmp(entry->d_name, ".", 1) ||
- !::strncmp(entry->d_name, "..", 2)) {
- continue;
- }
- std::string fullPath = WrtDB::PathBuilder(path)
- .Append(entry->d_name)
- .GetFullPath();
- if (RmNode(fullPath.c_str()) != 0) {
- int error = errno;
- TEMP_FAILURE_RETRY(::closedir(dir));
- errno = error;
- return -1;
- }
- }
- }
- while (NULL != entry);
-
- int error = errno;
- if (TEMP_FAILURE_RETRY(::closedir(dir)) != 0) {
- return -1;
- }
- errno = error;
-
- return (errno == 0 ? ::rmdir(path) : -1);
-}
-
-int RmNode(const char* path)
-{
- struct stat st;
- if (::lstat(path, &st) != 0) {
- return -1;
- }
- return (S_ISDIR(st.st_mode) ? RmDir(path) : ::unlink(path));
-}
-}
-
-namespace FileUtils {
-bool FileExists(const DPL::String& absolutePath)
-{
- struct stat statStruct;
- if (stat(DPL::ToUTF8String(absolutePath).c_str(), &statStruct) == 0) {
- return S_ISREG(statStruct.st_mode);
- } else {
- return false;
- }
-}
-
-void MakePath(const std::string& path,
- mode_t mode)
-{
- if (mkpath(path.c_str(), mode) == -1) {
- ThrowMsg(CreateDirectoryException, "Cannot make path");
- }
-}
-
-void RemoveDir(const std::string& path)
-{
- if (RmDir(path.c_str()) != 0) {
- ThrowMsg(RemoveDirectoryException, DPL::GetErrnoString());
- }
-}
-}
#include <dpl/utils/folder_size.h>
namespace Utils {
-
size_t getFolderSize(const std::string& path)
{
size_t size = 0;
FTS *fts;
FTSENT *ftsent;
- char * const paths[] = {const_cast<char * const>(path.c_str()), NULL};
+ char * const paths[] = { const_cast<char * const>(path.c_str()), NULL };
- if ((fts = fts_open(paths, FTS_PHYSICAL|FTS_NOCHDIR, NULL)) == NULL) {
+ if ((fts = fts_open(paths, FTS_PHYSICAL | FTS_NOCHDIR, NULL)) == NULL) {
//ERROR
int error = errno;
LogWarning(__PRETTY_FUNCTION__ << ": fts_open failed with error: "
- << strerror(error));
+ << strerror(error));
return 0;
}
while ((ftsent = fts_read(fts)) != NULL) {
switch (ftsent->fts_info) {
- case FTS_DP:
- case FTS_DC:
- //directory in postorder and directory causing a loop
- break;
- case FTS_F:
- case FTS_D:
- case FTS_NSOK:
- case FTS_SL:
- case FTS_SLNONE:
- case FTS_DEFAULT:
- //regular files and other objects that can be counted
- size += ftsent->fts_statp->st_size;
- break;
- case FTS_NS:
- case FTS_DOT:
- case FTS_DNR:
- case FTS_ERR:
- default:
- LogWarning(__PRETTY_FUNCTION__
- << ": traversal failed on file: "
- << ftsent->fts_path
- << " with error: "
- << strerror(ftsent->fts_errno));
- return 0;
+ case FTS_DP:
+ case FTS_DC:
+ //directory in postorder and directory causing a loop
+ break;
+ case FTS_F:
+ case FTS_D:
+ case FTS_NSOK:
+ case FTS_SL:
+ case FTS_SLNONE:
+ case FTS_DEFAULT:
+ //regular files and other objects that can be counted
+ size += ftsent->fts_statp->st_size;
+ break;
+ case FTS_NS:
+ case FTS_DOT:
+ case FTS_DNR:
+ case FTS_ERR:
+ default:
+ LogWarning(__PRETTY_FUNCTION__
+ << ": traversal failed on file: "
+ << ftsent->fts_path
+ << " with error: "
+ << strerror(ftsent->fts_errno));
+ return 0;
}
}
if (fts_close(fts) == -1) {
int error = errno;
LogWarning(__PRETTY_FUNCTION__ << ": fts_close failed with error: "
- << strerror(error));
+ << strerror(error));
return 0;
}
return size;
}
-
-
-
-
namespace {
#define DECLARE_PREFIX_STRUCT(name) \
-struct Prefix##name \
-{ \
- static std::string get() \
- { \
- return std::string(#name); \
- } \
-}; \
+ struct Prefix##name \
+ { \
+ static std::string get() \
+ { \
+ return std::string(#name); \
+ } \
+ }; \
DECLARE_PREFIX_STRUCT(B)
DECLARE_PREFIX_STRUCT(KB)
#undef DECLARE_PREFIX_STRUCT
-
const int stepSize = 1024;
-template<typename... Rest>
+template<typename ... Rest>
struct Pre;
-
-template<typename Postfix, typename... Rest>
-struct Pre<Postfix, Rest...>
+template<typename Postfix, typename ... Rest>
+struct Pre<Postfix, Rest ...>
{
static const double value;
static std::string printSize(double fileSize)
{
- if(fileSize >= Pre<Rest...>::value) {
- double now = fileSize / Pre<Rest...>::value;
+ if (fileSize >= Pre<Rest ...>::value) {
+ double now = fileSize / Pre<Rest ...>::value;
std::ostringstream outputStream;
outputStream.setf(std::ios::fixed, std::ios::floatfield);
outputStream.precision(2);
outputStream << now << Postfix::get();
return outputStream.str();
} else {
- return Pre<Rest...>::printSize(fileSize);
+ return Pre<Rest ...>::printSize(fileSize);
}
-
}
};
template<>
struct Pre<>
{
- static const double value;
- static std::string printSize(double /*fileSize*/)
- {
- return "0B";
- }
-
+ static const double value;
+ static std::string printSize(double /*fileSize*/)
+ {
+ return "0B";
+ }
};
const double Pre<>::value = 1.0;
-template<typename Postfix, typename... Params> const double Pre<Postfix, Params...>::value(Pre<>::value * stepSize);
-
+template<typename Postfix, typename ... Params> const double Pre<Postfix,
+ Params ...>::
+ value(Pre<>::value * stepSize);
typedef Pre<PrefixGB, PrefixMB, PrefixKB, PrefixB> FolderSizeToStringType;
-
-
} //anonymous namespace
-
DPL::String fromFileSizeString(size_t fileSize)
{
-
std::string output =
FolderSizeToStringType::printSize(static_cast<double>(fileSize));
return DPL::FromUTF8String(output);
}
-
} // end of namespace Utils
}
MimeTypeUtils::MimeAttributes MimeTypeUtils::getMimeAttributes(
- const DPL::String& mimeType)
+ const DPL::String& mimeType)
{
MimeAttributes attributes;
std::vector<DPL::String> tokens;
return getMimeTypesSupportedForIcon().count(identifyFileMimeType(path)) > 0;
}
-bool MimeTypeUtils::isValidStartFile(const DPL::String& path,
- const DPL::OptionalString& providedMimeType)
+bool MimeTypeUtils::isValidStartFile(
+ const DPL::String& path,
+ const DPL::OptionalString&
+ providedMimeType)
{
DPL::String mimeType = (!!providedMimeType) ? stripMimeParameters(
*providedMimeType) : identifyFileMimeType(path);
--- /dev/null
+/*
+ * Copyright (c) 2013 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 path.h
+ * @author Tomasz Iwanek (t.iwanek@samsung.com)
+ * @version 1.0
+ */
+
+#include "dpl/utils/path.h"
+
+#include <dpl/utils/wrt_utility.h>
+
+#include <dpl/scoped_free.h>
+#include <dpl/errno_string.h>
+#include <dpl/file_input.h>
+#include <dpl/file_output.h>
+#include <dpl/copy.h>
+
+#include <sys/stat.h>
+
+namespace DPL {
+
+namespace Utils {
+
+Path::Iterator::Iterator() //end iterator by default
+{
+}
+
+Path::Iterator::Iterator(const char * str)
+{
+ m_root = std::shared_ptr<Path>(new Path(str));
+ m_dir = std::shared_ptr<DIR>(opendir(str), [](DIR * d){ if(d)closedir(d); }); //custom delete
+ if(m_dir.get() == NULL)
+ {
+ ThrowMsg(NotDirectory, "Not directory");
+ }
+ ReadNext();
+}
+
+Path::Iterator& Path::Iterator::operator++()
+{
+ ReadNext();
+ return *this;
+}
+
+Path::Iterator Path::Iterator::operator++(int)
+{
+ Path::Iterator copy(*this);
+ ReadNext();
+ return copy;
+}
+
+void Path::Iterator::ReadNext()
+{
+ struct dirent * entry = readdir(m_dir.get());
+ while(entry && (strcmp(entry->d_name, ".") == 0 ||
+ strcmp(entry->d_name, "..") == 0))
+ {
+ entry = readdir(m_dir.get());
+ }
+ if(entry)
+ {
+ m_path = std::shared_ptr<Path>(new Path(*m_root));
+ m_path->Append(entry->d_name);
+ }
+ else //transform into end iterator
+ {
+ m_path.reset();
+ m_dir.reset();
+ }
+}
+
+bool Path::Iterator::operator==(const Path::Iterator& rhs) const
+{
+ if(m_dir.get() == NULL)
+ {
+ if(rhs.m_dir.get() == NULL) return true;
+ else return false;
+ }
+ else
+ {
+ if(rhs.m_dir.get() == NULL) return false;
+ }
+ return *m_path == *rhs.m_path;
+}
+
+bool Path::Iterator::operator!=(const Path::Iterator& rhs) const
+{
+ return !this->operator==(rhs);
+}
+
+const Path & Path::Iterator::operator*()
+{
+ return *m_path;
+}
+
+const Path * Path::Iterator::operator->()
+{
+ return m_path.get();
+}
+
+Path::Path(const DPL::String & str)
+{
+ Construct(ToUTF8String(str));
+}
+
+Path::Path(const std::string & str)
+{
+ Construct(str);
+}
+
+Path::Path(const char * str)
+{
+ Construct(std::string(str));
+}
+
+void Path::Construct(const std::string & src)
+{
+ if(src.empty()) ThrowMsg(EmptyPath, "Path cannot be empty");
+ if(src[0] != '/')
+ {
+ DPL::ScopedFree<char> root(getcwd(NULL,0));
+ Tokenize(std::string(root.Get()), "\\/", std::inserter(m_parts, m_parts.begin()), true);
+ }
+ Tokenize(src, "\\/", std::inserter(m_parts, m_parts.end()), true);
+}
+
+Path::Path() //for private usage
+{
+}
+
+std::string Path::DirectoryName() const
+{
+ if(m_parts.empty()) ThrowMsg(InternalError, "Asking DirectoryName for root directory");
+ std::string ret = Join(m_parts.begin(), --m_parts.end(), "/");
+ return std::string("/") + ret;
+}
+
+std::string Path::Basename() const
+{
+ if(m_parts.empty()) return "";
+ else return m_parts.back();
+}
+
+std::string Path::Fullpath() const
+{
+ std::string ret = Join(m_parts.begin(), m_parts.end(), "/");
+ return std::string ("/") + ret;
+}
+
+//foreach
+Path::Iterator Path::begin() const
+{
+ if(IsDir())
+ {
+ return Iterator(Fullpath().c_str());
+ }
+ else
+ {
+ ThrowMsg(NotDirectory, "Cannot iterate not a directory");
+ }
+}
+
+Path::Iterator Path::end() const
+{
+ return Iterator();
+}
+
+
+bool Path::Exists() const
+{
+ struct stat tmp;
+ return (0 == lstat(Fullpath().c_str(), &tmp));
+}
+
+bool Path::IsDir() const
+{
+ struct stat tmp;
+ if (-1 == lstat(Fullpath().c_str(), &tmp))
+ {
+ ThrowMsg(NotExists, DPL::GetErrnoString());
+ }
+ return S_ISDIR(tmp.st_mode);
+}
+
+bool Path::IsFile() const
+{
+ struct stat tmp;
+ if (-1 == lstat(Fullpath().c_str(), &tmp))
+ {
+ ThrowMsg(NotExists, DPL::GetErrnoString());
+ }
+ return S_ISREG(tmp.st_mode);
+}
+
+bool Path::IsSymlink() const
+{
+ struct stat tmp;
+ if (-1 == lstat(Fullpath().c_str(), &tmp))
+ {
+ ThrowMsg(NotExists, DPL::GetErrnoString());
+ }
+ return S_ISLNK(tmp.st_mode);
+}
+
+bool Path::operator==(const Path & other) const
+{
+ return m_parts == other.m_parts;
+}
+
+bool Path::operator!=(const Path & other) const
+{
+ return m_parts != other.m_parts;
+}
+
+Path Path::operator/(const DPL::String& part) const
+{
+ Path newOne;
+ newOne.Append(ToUTF8String(part));
+ return newOne;
+}
+
+Path Path::operator/(const std::string& part) const
+{
+ Path newOne;
+ newOne.Append(part);
+ return newOne;
+}
+
+Path Path::operator/(const char * part) const
+{
+ Path newOne(*this);
+ newOne.Append(std::string(part));
+ return newOne;
+}
+
+Path & Path::operator/=(const DPL::String& part)
+{
+ Append(ToUTF8String(part));
+}
+
+Path & Path::operator/=(const std::string& part)
+{
+ Append(part);
+}
+
+Path & Path::operator/=(const char * part)
+{
+ Append(std::string(part));
+}
+
+void Path::Append(const std::string& part)
+{
+ std::vector<std::string> tokens;
+ Tokenize(part, "\\/", std::inserter(tokens, tokens.end()), true);
+ std::copy(tokens.begin(), tokens.end(), std::inserter(m_parts, m_parts.end()));
+}
+
+void MakeDir(const Path & path, mode_t mode)
+{
+ if(!WrtUtilMakeDir(path.Fullpath(), mode)) ThrowMsg(Path::OperationFailed, "Cannot make directory");
+}
+
+void MakeEmptyFile(const Path & path)
+{
+ std::string fp = path.Fullpath();
+ FILE* fd = fopen(fp.c_str(), "wx");
+ if(!fd)
+ {
+ struct stat st;
+ if(lstat(fp.c_str(), &st) == 0)
+ {
+ ThrowMsg(Path::AlreadyExists, "File already exists");
+ }
+ else
+ {
+ ThrowMsg(Path::OperationFailed, "Operation failed");
+ }
+ }
+ fclose(fd);
+}
+
+void Remove(const Path & path)
+{
+ if(!WrtUtilRemove(path.Fullpath())) ThrowMsg(Path::OperationFailed, "Cannot remove path");
+}
+
+void Rename(const Path & from, const Path & to)
+{
+ if(from == to)
+ {
+ return;
+ }
+ int code = 0;
+ if( (code = rename(from.Fullpath().c_str(), to.Fullpath().c_str())) )
+ {
+ if(code == EXDEV)
+ {
+ Try
+ {
+ DPL::FileInput in(from.Fullpath());
+ DPL::FileOutput out(to.Fullpath());
+ DPL::Copy(&in, &out);
+ }
+ Catch(DPL::FileInput::Exception::Base)
+ {
+ ThrowMsg(Path::OperationFailed, "Cannot open input file " << from.Fullpath());
+ }
+ Catch(DPL::FileOutput::Exception::Base)
+ {
+ ThrowMsg(Path::OperationFailed, "Cannot open output file " << to.Fullpath());
+ }
+ }
+ else
+ {
+ ThrowMsg(Path::OperationFailed, DPL::GetErrnoString());
+ }
+ }
+}
+
+bool Exists(const Path & path)
+{
+ return path.Exists();
+}
+
+}
+
+}
+
+std::ostream & operator<<(std::ostream & str, const DPL::Utils::Path & path)
+{
+ str << path.Fullpath();
+ return str;
+}
+
+//TODO: uncomment when used defiend literals are supported
+///DPL::Utils::Path operator""p(const char * str, size_t)
+//{
+// return DPL::Utils::Path(str);
+//}
// Unfortunatly all widgets are using file protocol to load its data from
// hard drive. What's why we cannot check any iri with file schema.
-const char *IRI_IGNORED_SCHEME[] = { "file://", "widget://", "tel:", "sms:",
- "mmsto:", "mailto:", "data:", "blob:", 0 };
+const char *IRI_IGNORED_SCHEME[] = { "file://", "widget://", "app://", "tel:",
+ "sms:", "mmsto:", "mailto:", "data:", "blob:",
+ 0 };
const DPL::String SCHEMA_HTTP = DPL::FromUTF8String("http");
const DPL::String SCHEMA_HTTPS = DPL::FromUTF8String("https");
// This will create AutoPtr deleter for iri_struct.
// Deleter must be in the same namespace as definition of AutoPtr.
-namespace DPL{
+namespace DPL {
DECLARE_DELETER(iri_struct, iri_destroy)
} // namespace DPL
m_port(UNKNOWN_PORT),
m_isAccessDefinition(false),
m_isIRIValid(false)
-{
-}
+{}
void WarpIRI::set(const char *p_iri,
- bool domain)
+ bool domain)
{
if (!p_iri) {
m_isAccessDefinition = m_isIRIValid = false;
}
void WarpIRI::set(const DPL::String &iristring,
- bool domain)
+ bool domain)
{
set(DPL::ToUTF8String(iristring).c_str(), domain);
}
bool WarpIRI::isSubDomain(const WarpIRI &second) const
{
- if (!m_isAccessDefinition || !second.m_isIRIValid) { return false; }
- if (m_schema != second.m_schema) { return false; }
- if (m_port != second.m_port) { return false; }
+ if (!m_isAccessDefinition || !second.m_isIRIValid) {
+ return false;
+ }
+ if (m_schema != second.m_schema) {
+ return false;
+ }
+ if (m_port != second.m_port) {
+ return false;
+ }
size_t size = m_host.size() < second.m_host.size() ?
m_host.size() : second.m_host.size();
for (int i = 0; IRI_IGNORED_SCHEME[i]; ++i) {
if (0 ==
strncmp(iri, IRI_IGNORED_SCHEME[i],
- strlen(IRI_IGNORED_SCHEME[i]))) {
+ strlen(IRI_IGNORED_SCHEME[i])))
+ {
return true;
}
}
//
// [ABNF]
-// Augmented BNF for Syntax Specifications: ABNF. RFC5234. D. Crocker and P. Overell. January 2008.
+// Augmented BNF for Syntax Specifications: ABNF. RFC5234. D. Crocker and P.
+// Overell. January 2008.
//
// ALPHA = %x41-5A / %x61-7A
inline bool IsAlpha(int c)
// operator <
bool NumberLessOperator(const DPL::String &left,
- const DPL::String &right)
+ const DPL::String &right)
{
// Assume: No leading zeroes
if (left.size() < right.size()) {
LogDebug("Tokenized mandatory parts: " << parts.size());
if (parts.size() != WAC_CERTIFY_MANDATORY_PART_LOW_COUNT &&
- parts.size() != WAC_CERTIFY_MANDATORY_PART_HIGH_COUNT) {
+ parts.size() != WAC_CERTIFY_MANDATORY_PART_HIGH_COUNT)
+ {
return;
}
}
WidgetVersion::WidgetVersion(const DPL::String &major,
- const DPL::String &minor,
- const DPL::Optional<DPL::String> µ,
- const DPL::Optional<DPL::String> &optional) :
+ const DPL::String &minor,
+ const DPL::Optional<DPL::String> µ,
+ const DPL::Optional<DPL::String> &optional) :
m_isWac(false)
{
// Create Raw version
}
void WidgetVersion::WacCertify(const DPL::String &major,
- const DPL::String &minor,
- const DPL::Optional<DPL::String> µ,
- const DPL::Optional<DPL::String> &optional)
+ const DPL::String &minor,
+ const DPL::Optional<DPL::String> µ,
+ const DPL::Optional<DPL::String> &optional)
{
LogDebug("Certyfing...");
}
if (!!optional &&
- (optional->empty() || !WacCertifyAlphaNumberStringSpace(*optional))) {
+ (optional->empty() || !WacCertifyAlphaNumberStringSpace(*optional)))
+ {
LogDebug("Optional version not certified!");
return;
}
}
bool operator<(const WidgetVersion &left,
- const WidgetVersion &right)
+ const WidgetVersion &right)
{
Assert(
left.IsWac() && right.IsWac() &&
"Only WAC version strings are comparable!");
if (NumberLessOperator(RemoveLeadingZeroes(left.Major()),
- RemoveLeadingZeroes(right.Major()))) { return true; }
+ RemoveLeadingZeroes(right.Major())))
+ {
+ return true;
+ }
if (NumberLessOperator(RemoveLeadingZeroes(right.Major()),
- RemoveLeadingZeroes(left.Major()))) { return false; }
+ RemoveLeadingZeroes(left.Major())))
+ {
+ return false;
+ }
if (NumberLessOperator(RemoveLeadingZeroes(left.Minor()),
- RemoveLeadingZeroes(right.Minor()))) { return true; }
+ RemoveLeadingZeroes(right.Minor())))
+ {
+ return true;
+ }
if (NumberLessOperator(RemoveLeadingZeroes(right.Minor()),
- RemoveLeadingZeroes(left.Minor()))) { return false; }
+ RemoveLeadingZeroes(left.Minor())))
+ {
+ return false;
+ }
if (!!left.Micro() && !!right.Micro() &&
NumberLessOperator(RemoveLeadingZeroes(*left.Micro()),
- RemoveLeadingZeroes(*right.Micro()))) { return true; }
- if (!left.Micro() && !!right.Micro()) { return true; }
+ RemoveLeadingZeroes(*right.Micro())))
+ {
+ return true;
+ }
+ if (!left.Micro() && !!right.Micro()) {
+ return true;
+ }
return false;
}
bool operator<=(const WidgetVersion &left,
- const WidgetVersion &right)
+ const WidgetVersion &right)
{
Assert(
left.IsWac() && right.IsWac() &&
}
bool operator>(const WidgetVersion &left,
- const WidgetVersion &right)
+ const WidgetVersion &right)
{
Assert(
left.IsWac() && right.IsWac() &&
}
bool operator>=(const WidgetVersion &left,
- const WidgetVersion &right)
+ const WidgetVersion &right)
{
Assert(
left.IsWac() && right.IsWac() &&
}
bool operator==(const WidgetVersion &left,
- const WidgetVersion &right)
+ const WidgetVersion &right)
{
Assert(
left.IsWac() && right.IsWac() &&
"Only WAC version strings are comparable!");
+ //Major are equal
+ //and
+ //Minor are equal
+ //and
+ //Both Micro exist and are equal
+ //or both Micro do not exist
return RemoveLeadingZeroes(left.Major()) ==
- RemoveLeadingZeroes(right.Major()) && // Major are equal
+ RemoveLeadingZeroes(right.Major()) &&
RemoveLeadingZeroes(left.Minor()) ==
- RemoveLeadingZeroes(right.Minor()) && // and Minor are equal
- ( // and ...
+ RemoveLeadingZeroes(right.Minor()) &&
+ (
(!!left.Micro() && !!right.Micro() &&
RemoveLeadingZeroes(*left.Micro()) ==
- RemoveLeadingZeroes(*right.Micro())) || // Both Micro exist and are equal
- (!left.Micro() && !right.Micro()) // or both Micro do not exist
+ RemoveLeadingZeroes(*right.Micro())) ||
+ (!left.Micro() && !right.Micro())
);
}
bool operator!=(const WidgetVersion &left,
- const WidgetVersion &right)
+ const WidgetVersion &right)
{
Assert(
left.IsWac() && right.IsWac() &&
}
std::ostream & operator<<(std::ostream& stream,
- const WidgetVersion& version)
+ const WidgetVersion& version)
{
stream << version.Raw();
return stream;
#include <dpl/utils/wrt_global_settings.h>
namespace GlobalSettings {
-
namespace {
const int ROAMING_TEST = 0x00000001;
-const int POPUPS_TEST = 0x00000002;
+const int POPUPS_TEST = 0x00000002;
const int OCSP_TEST = 0x00000004;
const int WARP_TEST = 0x00000008;
const int CRL_TEST = 0x00000010;
bool isEmulator;
int testModes;
- Settings()
- : isEmulator(false), testModes(0)
+ Settings() :
+ isEmulator(false), testModes(0)
{}
};
// ignore environment variables if this flag is not set
#ifdef GLOBAL_SETTINGS_CONTROL
char * envStr = getenv(WRT_TEST_MODE);
- int testMode = 0;
if (NULL != envStr) {
std::string env = envStr;
+ int testMode = 0;
if ("1" == env) {
testMode = ALL_TEST;
} else {
std::istringstream str(envStr);
while (std::getline(str, env, '|')) {
if ("popups" == env) {
- testMode |= POPUPS_TEST;
+ testMode |= POPUPS_TEST;
} else if ("roaming" == env) {
- testMode |= ROAMING_TEST;;
+ testMode |= ROAMING_TEST;
} else if ("ocsp" == env) {
- testMode |= OCSP_TEST;;
+ testMode |= OCSP_TEST;
} else if ("warp" == env) {
- testMode |= WARP_TEST;;
+ testMode |= WARP_TEST;
} else if ("crl" == env) {
- testMode |= CRL_TEST;
+ testMode |= CRL_TEST;
} else if ("screen" == env) {
- testMode |= SCREEN_SHOT_TEST;;
+ testMode |= SCREEN_SHOT_TEST;
}
}
}
return ((gSettings.testModes & ALL_TEST) == ALL_TEST);
}
-bool PopupsTestModeEnabled() {
+bool PopupsTestModeEnabled()
+{
return (gSettings.testModes & POPUPS_TEST);
}
-bool WarpTestModeEnabled() {
+bool WarpTestModeEnabled()
+{
return (gSettings.testModes & WARP_TEST);
}
-bool RoamingTestModeEnabled() {
+bool RoamingTestModeEnabled()
+{
return (gSettings.testModes & ROAMING_TEST);
}
-bool OCSPTestModeEnabled() {
+bool OCSPTestModeEnabled()
+{
return (gSettings.testModes & OCSP_TEST);
}
-bool CrlTestModeEnabled() {
+bool CrlTestModeEnabled()
+{
return (gSettings.testModes & CRL_TEST);
}
-bool MakeScreenTestModeEnabled() {
+bool MakeScreenTestModeEnabled()
+{
return (gSettings.testModes & SCREEN_SHOT_TEST);
}
{
return gSettings.isEmulator;
}
-
} // GlobalSettings
#include <sys/types.h>
#include <errno.h>
#include <ctype.h>
+#include <unistd.h>
#include <dpl/log/log.h>
#include <dpl/utils/wrt_utility.h>
-void WrtUtilJoinPaths(std::string &joined, const std::string &parent, const std::string &child)
+void WrtUtilJoinPaths(std::string &joined,
+ const std::string &parent,
+ const std::string &child)
{
- size_t parent_len = parent.length();;
- joined=parent;
- joined+=child;
+ size_t parent_len = parent.length();
+ joined = parent;
+ joined += child;
//In case someone used windows-style paths
std::replace(joined.begin(), joined.end(), '\\', '/');
if (parent_len != 0 && child.length() != 0) {
- if (joined[parent_len-1] != '/' && joined[parent_len] != '/')
+ if (joined[parent_len - 1] != '/' && joined[parent_len] != '/') {
joined.insert(parent_len, "/");
- else if (joined[parent_len-1] == '/' && joined[parent_len] == '/')
+ } else if (joined[parent_len - 1] == '/' && joined[parent_len] ==
+ '/')
+ {
joined.erase(parent_len, 1);
+ }
}
}
size_t pos = 0;
int error;
- if (newpath.length() == 0) return false;
+ if (newpath.length() == 0) {
+ return false;
+ }
- std::string path=newpath;
+ std::string path = newpath;
- if (*(path.rbegin()) != '/') path += '/';
+ if (*(path.rbegin()) != '/') {
+ path += '/';
+ }
- while ((pos = path.find('/', pos+1)) != std::string::npos) {
+ while ((pos = path.find('/', pos + 1)) != std::string::npos) {
if (mkdir(path.substr(0, pos).c_str(), mode) != 0) {
- error=errno;
- if (error == EEXIST) continue;
+ error = errno;
+ if (error == EEXIST) {
+ continue;
+ }
LogWarning(__PRETTY_FUNCTION__ << ": failed to create directory "
- << path.substr(0,pos)
- << ". Error: "
- << strerror(error));
+ << path.substr(0, pos)
+ << ". Error: "
+ << strerror(error));
return false;
}
}
FTSENT *ftsent;
bool rv = true;
int error = 0;
- char * const paths[] = {const_cast<char * const>(path.c_str()), NULL};
+ char * const paths[] = { const_cast<char * const>(path.c_str()), NULL };
- if ((fts = fts_open(paths, FTS_PHYSICAL|FTS_NOCHDIR, NULL)) == NULL) {
+ if ((fts = fts_open(paths, FTS_PHYSICAL | FTS_NOCHDIR, NULL)) == NULL) {
//ERROR
error = errno;
LogWarning(__PRETTY_FUNCTION__ << ": fts_open failed with error: "
- << strerror(error));
+ << strerror(error));
return false;
}
while ((ftsent = fts_read(fts)) != NULL) {
switch (ftsent->fts_info) {
- case FTS_D:
- //directory in preorder - do nothing
- break;
- case FTS_DP:
- //directory in postorder - remove
- if (rmdir(ftsent->fts_accpath) != 0) {
- error = errno;
- LogWarning(__PRETTY_FUNCTION__
- << ": rmdir failed with error: "
- << strerror(error));
- rv = false;
- }
- break;
- case FTS_DC:
- case FTS_F:
- case FTS_NSOK:
- case FTS_SL:
- case FTS_SLNONE:
- case FTS_DEFAULT:
- //regular files and other objects that can safely be removed
- if (unlink(ftsent->fts_accpath) != 0) {
- error = errno;
- LogWarning(__PRETTY_FUNCTION__
- << ": unlink failed with error: "
- << strerror(error));
- rv = false;
- }
- break;
- case FTS_NS:
+ case FTS_D:
+ //directory in preorder - do nothing
+ break;
+ case FTS_DP:
+ //directory in postorder - remove
+ if (rmdir(ftsent->fts_accpath) != 0) {
+ error = errno;
LogWarning(__PRETTY_FUNCTION__
- << ": couldn't get stat info for file: "
- << ftsent->fts_path
- << ". The error was: "
- << strerror(ftsent->fts_errno));
+ << ": rmdir failed with error: "
+ << strerror(error));
rv = false;
- break;
- case FTS_DOT:
- case FTS_DNR:
- case FTS_ERR:
- default:
+ }
+ break;
+ case FTS_DC:
+ case FTS_F:
+ case FTS_NSOK:
+ case FTS_SL:
+ case FTS_SLNONE:
+ case FTS_DEFAULT:
+ //regular files and other objects that can safely be removed
+ if (unlink(ftsent->fts_accpath) != 0) {
+ error = errno;
LogWarning(__PRETTY_FUNCTION__
- << ": traversal failed with error: "
- << strerror(ftsent->fts_errno));
+ << ": unlink failed with error: "
+ << strerror(error));
rv = false;
- break;
+ }
+ break;
+ case FTS_NS:
+ LogWarning(__PRETTY_FUNCTION__
+ << ": couldn't get stat info for file: "
+ << ftsent->fts_path
+ << ". The error was: "
+ << strerror(ftsent->fts_errno));
+ rv = false;
+ break;
+ case FTS_DOT:
+ case FTS_DNR:
+ case FTS_ERR:
+ default:
+ LogWarning(__PRETTY_FUNCTION__
+ << ": traversal failed with error: "
+ << strerror(ftsent->fts_errno));
+ rv = false;
+ break;
}
}
if (fts_close(fts) == -1) {
error = errno;
LogWarning(__PRETTY_FUNCTION__ << ": fts_close failed with error: "
- << strerror(error));
+ << strerror(error));
rv = false;
}
return rv;
bool WrtUtilFileExists(const std::string &path)
{
struct stat tmp;
- if (stat(path.c_str(),&tmp) == 0) {
+ if (stat(path.c_str(), &tmp) == 0) {
return S_ISREG(tmp.st_mode);
} else {
return false;
bool WrtUtilDirExists(const std::string &path)
{
struct stat tmp;
- if (stat(path.c_str(),&tmp) == 0) {
+ if (stat(path.c_str(), &tmp) == 0) {
return S_ISDIR(tmp.st_mode);
} else {
return false;
#include <dpl/wrt-dao-ro/global_config.h>
namespace WrtDB {
-
const char* WrtDatabase::Address()
{
using namespace WrtDB;
}
DPL::DB::ThreadDatabaseSupport WrtDatabase::m_interface(
- WrtDatabase::Address(),
- WrtDatabase::Flags());
+ WrtDatabase::Address(),
+ WrtDatabase::Flags());
void WrtDatabase::attachToThreadRO()
{
{
return m_interface.CheckTableExist(name);
}
-
}
* @brief This file contains the implementation of common data types for wrtdb
*/
#include <stddef.h>
-namespace WrtDB {
-} // namespace WrtDB
+namespace WrtDB {} // namespace WrtDB
bool IsSpace(const xmlChar* str);
bool CopyChar(xmlChar* out, xmlChar* in);
-
bool IsSpace(const xmlChar* str)
{
int charlen = xmlUTF8Size(str);
}
bool CopyChar(xmlChar* out,
- xmlChar* in)
+ xmlChar* in)
{
int size = xmlUTF8Size(in);
switch (size) {
str = *opt;
}
-void NormalizeString (DPL::Optional<DPL::String>& txt)
+void NormalizeString (DPL::Optional<DPL::String>& txt, bool isTrimSpace)
{
if (!!txt) {
std::string tmp = DPL::ToUTF8String(*txt);
if (c[0] == 0x0) {
break;
}
- if (first) {
+ if (first && !isTrimSpace) {
xmlChar space[6] = { 0x20 };
CopyChar(s, space);
s += xmlUTF8Size(s);
}
}
+void NormalizeAndTrimSpaceString(DPL::OptionalString& txt)
+{
+ NormalizeString(txt, true);
+}
+
bool ConfigParserData::Param::operator==(const Param& other) const
{
return name == other.name && value == other.value;
bool ConfigParserData::Setting::operator==(const Setting& other) const
{
return m_name == other.m_name &&
- m_value == other.m_value;
+ m_value == other.m_value;
}
bool ConfigParserData::Setting::operator!=(const Setting& other) const
{
return m_name != other.m_name ||
- m_value != other.m_value;
+ m_value != other.m_value;
}
bool ConfigParserData::Setting::operator >(const Setting& other) const
bool ConfigParserData::ServiceInfo::operator== (const ServiceInfo& info) const
{
return m_src == info.m_src &&
- m_operation == info.m_operation &&
- m_scheme == info.m_scheme &&
- m_mime == info.m_mime;
+ m_operation == info.m_operation &&
+ m_scheme == info.m_scheme &&
+ m_mime == info.m_mime &&
+ m_disposition == info.m_disposition;
}
bool ConfigParserData::ServiceInfo::operator!= (const ServiceInfo& info) const
{
return m_src != info.m_src &&
- m_operation != info.m_operation &&
- m_scheme != info.m_scheme &&
- m_mime != info.m_mime;
+ m_operation != info.m_operation &&
+ m_scheme != info.m_scheme &&
+ m_mime != info.m_mime &&
+ m_disposition != info.m_disposition;
}
bool ConfigParserData::LiveboxInfo::operator==(const LiveboxInfo& other) const
{
return m_liveboxId == other.m_liveboxId &&
- m_autoLaunch == other.m_autoLaunch &&
- m_updatePeriod == other.m_updatePeriod &&
- m_primary == other.m_primary &&
- m_label == other.m_label &&
- m_icon == other.m_icon;
+ m_autoLaunch == other.m_autoLaunch &&
+ m_updatePeriod == other.m_updatePeriod &&
+ m_primary == other.m_primary &&
+ m_label == other.m_label &&
+ m_icon == other.m_icon;
}
bool ConfigParserData::LiveboxInfo::operator!=(const LiveboxInfo& other) const
{
return m_liveboxId != other.m_liveboxId &&
- m_autoLaunch != other.m_autoLaunch &&
- m_updatePeriod != other.m_updatePeriod &&
- m_primary != other.m_primary &&
- m_label != other.m_label &&
- m_icon != other.m_icon;
+ m_autoLaunch != other.m_autoLaunch &&
+ m_updatePeriod != other.m_updatePeriod &&
+ m_primary != other.m_primary &&
+ m_label != other.m_label &&
+ m_icon != other.m_icon;
}
-
} // namespace WrtDB
namespace WrtDB {
namespace FeatureDAO {
-
FeatureHandle RegisterFeature(const PluginMetafileData::Feature &feature,
const DbPluginHandle pluginHandle)
{
Try
{
LogDebug("Registering Feature " << feature.m_name);
- DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
+ DPL::DB::ORM::wrt::ScopedTransaction transaction(
+ &WrtDatabase::interface());
if (FeatureDAOReadOnly::isFeatureInstalled(feature.m_name)) {
LogError(" >> Feature " << feature.m_name <<
}
FeatureHandle featureHandle =
- FeatureDAOReadOnly(feature.m_name).GetFeatureHandle();
+ FeatureDAOReadOnly(feature.m_name).GetFeatureHandle();
//register device capabilities
// Device Capabilities is unused in current version
LogInfo(" | |--DeviceCap " << *itdev <<
" already installed!");
- WRT_DB_SELECT(select, DeviceCapabilities, &WrtDatabase::interface())
+ WRT_DB_SELECT(select,
+ DeviceCapabilities,
+ &WrtDatabase::interface())
select->Where(Equals<DeviceCapabilities::DeviceCapName>(
DPL::FromUTF8String(*itdev)));
DeviceCapabilities::Row row;
row.Set_DeviceCapName(DPL::FromUTF8String(*itdev));
- WRT_DB_INSERT(insert, DeviceCapabilities, &WrtDatabase::interface())
+ WRT_DB_INSERT(insert,
+ DeviceCapabilities,
+ &WrtDatabase::interface())
insert->Values(row);
- deviceCapID = insert->Execute();
+ deviceCapID = static_cast<int>(insert->Execute());
}
FeatureDeviceCapProxy::Row row;
row.Set_FeatureUUID(featureHandle);
row.Set_DeviceCapID(deviceCapID);
- WRT_DB_INSERT(insert, FeatureDeviceCapProxy, &WrtDatabase::interface())
+ WRT_DB_INSERT(insert,
+ FeatureDeviceCapProxy,
+ &WrtDatabase::interface())
insert->Values(row);
insert->Execute();
}
{
LogDebug("Unregistering Feature " << featureHandle);
DPL::DB::ORM::wrt::ScopedTransaction transaction(
- &WrtDatabase::interface());
+ &WrtDatabase::interface());
if (FeatureDAOReadOnly::isFeatureInstalled(featureHandle)) {
LogError("Feature handle is invalid");
"Fail to unregister Feature");
}
}
-
-
} // namespace FeatureDAO
} // namespace WrtDB
#include <dpl/wrt-dao-ro/plugin_dao_read_only.h>
namespace WrtDB {
-
FeatureDAOReadOnly::FeatureDAOReadOnly(FeatureHandle featureHandle) :
m_featureHandle(featureHandle)
{
#define GET_PLUGIN_DATA(func) \
Try { \
- DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface()); \
- LogDebug(# func << ". FeatureHandle: " << m_featureHandle); \
+ DPL::DB::ORM::wrt::ScopedTransaction transaction( \
+ &WrtDatabase::interface()); \
+ LogDebug(#func << ". FeatureHandle: " << m_featureHandle); \
std::string ret = PluginDAOReadOnly(GetPluginHandle()).func(); \
transaction.Commit(); \
return ret; \
} \
Catch(DPL::DB::SqlConnection::Exception::Base) { \
std::ostringstream failure("Failure during "); \
- failure << # func; \
+ failure << #func; \
ReThrowMsg(FeatureDAOReadOnly::Exception::DatabaseError, \
- failure.str()); \
+ failure.str()); \
}
std::string FeatureDAOReadOnly::GetLibraryPath() const
}
bool FeatureDAOReadOnly::isDeviceCapabilityInstalled(
- const std::string &deviceCapName)
+ const std::string &deviceCapName)
{
LogDebug("Check if DeviceCap is installed. Name: " << deviceCapName);
Try {
{
Try {
LogDebug("Get DeviceCap. FeatureHandle: " << m_featureHandle);
- DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
+ DPL::DB::ORM::wrt::ScopedTransaction transaction(
+ &WrtDatabase::interface());
using namespace DPL::DB::ORM;
using namespace DPL::DB::ORM::wrt;
- WRT_DB_SELECT(selectDevCP, FeatureDeviceCapProxy, &WrtDatabase::interface())
+ WRT_DB_SELECT(selectDevCP,
+ FeatureDeviceCapProxy,
+ &WrtDatabase::interface())
selectDevCP->Where(Equals<FeatureDeviceCapProxy::FeatureUUID>(
m_featureHandle));
selectDevCP->GetValueList<FeatureDeviceCapProxy::DeviceCapID>();
FOREACH(devCId, deviceIDs)
{
- WRT_DB_SELECT(selectDevC, DeviceCapabilities, &WrtDatabase::interface())
+ WRT_DB_SELECT(selectDevC,
+ DeviceCapabilities,
+ &WrtDatabase::interface())
selectDevC->Where(Equals<DeviceCapabilities::DeviceCapID>(*devCId));
DPL::String devNames =
}
FeatureHandleListPtr FeatureDAOReadOnly::GetFeatureHandleListForPlugin(
- DbPluginHandle pluginHandle)
+ DbPluginHandle pluginHandle)
{
LogDebug("Getting FeatureHandle list for pluginHandle: " << pluginHandle);
Try {
}
Catch(DPL::DB::SqlConnection::Exception::Base){
ReThrowMsg(
- FeatureDAOReadOnly::Exception::DatabaseError,
- "Failure during getting FeatureHandle Set for plugin handle");
+ FeatureDAOReadOnly::Exception::DatabaseError,
+ "Failure during getting FeatureHandle Set for plugin handle");
}
}
FeaturesList::Select::RowList rows = select->GetRowList();
FOREACH(rowIt, rows)
{
- nameMap.insert(std::pair<FeatureHandle, std::string>(rowIt->Get_FeatureUUID(), DPL::ToUTF8String(rowIt->Get_FeatureName())));
+ nameMap.insert(std::pair<FeatureHandle,
+ std::string>(rowIt->Get_FeatureUUID(),
+ DPL::ToUTF8String(rowIt->
+ Get_FeatureName())));
}
return nameMap;
DECLARE_COLUMN_TYPE_LIST_END(DevCapNameList)
WRT_DB_SELECT(select, FeatureDeviceCapProxy, &WrtDatabase::interface())
- select->Join<DevCapNameList>(Equal<FeatureDeviceCapProxy::DeviceCapID, DeviceCapabilities::DeviceCapID>());
+ select->Join<DevCapNameList>(Equal<FeatureDeviceCapProxy::DeviceCapID,
+ DeviceCapabilities::DeviceCapID>());
DeviceCapabilitiesMap devCap;
- std::list< CustomRow<DevCapNameList> > rowList = select->GetCustomRowList< DevCapNameList, CustomRow<DevCapNameList> >();
+ std::list< CustomRow<DevCapNameList> > rowList =
+ select->GetCustomRowList< DevCapNameList, CustomRow<DevCapNameList> >();
FOREACH(rowIt, rowList)
{
- FeatureHandle featureHandle = (*rowIt).GetColumnData<FeatureDeviceCapProxy::FeatureUUID>();
- std::string devName = DPL::ToUTF8String((*rowIt).GetColumnData<DeviceCapabilities::DeviceCapName>());
- devCap.insert(std::pair<FeatureHandle, std::string>(featureHandle, devName));
+ FeatureHandle featureHandle =
+ (*rowIt).GetColumnData<FeatureDeviceCapProxy::FeatureUUID>();
+ std::string devName =
+ DPL::ToUTF8String((*rowIt).GetColumnData<DeviceCapabilities::
+ DeviceCapName>());
+ devCap.insert(std::pair<FeatureHandle, std::string>(featureHandle,
+ devName));
}
return devCap;
rowIt->Get_FeatureName());
featureData.pluginHandle = rowIt->Get_PluginPropertiesId();
featureMap.insert(std::pair<FeatureHandle, FeatureData>(
- rowIt->Get_FeatureUUID(), featureData));
+ rowIt->Get_FeatureUUID(), featureData));
}
return featureMap;
"Failure during getting GetFeatures");
}
}
-
} // namespace WrtDB
void GlobalDAO::setComplianceMode(bool mode)
{
LogDebug("Updating compliance mode to:" << mode);
- Try{
- using namespace DPL::DB::ORM; using namespace DPL::DB::ORM::wrt;
+ Try {
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::wrt;
GlobalProperties::Row row;
row.Set_compliance_mode(mode);
update->Values(row);
update->Execute();
}
- Catch (DPL::DB::SqlConnection::Exception::Base){
+ Catch(DPL::DB::SqlConnection::Exception::Base){
ReThrowMsg(GlobalDAO::Exception::DatabaseError,
"Failed to update compliance mode");
}
void GlobalDAO::setComplianceFakeImei(const std::string &imei)
{
LogDebug("Setting compliance fake IMEI: " << imei);
- Try{
- using namespace DPL::DB::ORM; using namespace DPL::DB::ORM::wrt;
+ Try {
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::wrt;
GlobalProperties::Row row;
row.Set_compliance_fake_imei(DPL::FromASCIIString(imei));
update->Values(row);
update->Execute();
}
- Catch (DPL::DB::SqlConnection::Exception::Base){
+ Catch(DPL::DB::SqlConnection::Exception::Base){
ReThrowMsg(GlobalDAO::Exception::DatabaseError,
"Failed to update compliance fake IMEI");
}
void GlobalDAO::setComplianceFakeMeid(const std::string &meid)
{
LogDebug("Setting compliance fake MEID: " << meid);
- Try{
- using namespace DPL::DB::ORM; using namespace DPL::DB::ORM::wrt;
+ Try {
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::wrt;
GlobalProperties::Row row;
row.Set_compliance_fake_meid(DPL::FromASCIIString(meid));
update->Values(row);
update->Execute();
}
- Catch (DPL::DB::SqlConnection::Exception::Base){
+ Catch(DPL::DB::SqlConnection::Exception::Base){
ReThrowMsg(GlobalDAO::Exception::DatabaseError,
"Failed to update compliance fake MEID");
}
using namespace DPL::DB::ORM::wrt;
WRT_DB_DELETE(deleteFrom, WidgetWhiteURIList, &WrtDatabase::interface())
- deleteFrom->Where(Equals<WidgetWhiteURIList::uri>(DPL::FromASCIIString(uri)));
+ deleteFrom->Where(Equals<WidgetWhiteURIList::uri>(DPL::FromASCIIString(
+ uri)));
deleteFrom->Execute();
} Catch(DPL::DB::SqlConnection::Exception::Base) {
ReThrowMsg(GlobalDAO::Exception::DatabaseError,
"Failed to update Cookie Sharing Mode");
}
}
-
} // namespace WrtDB
#include <dpl/wrt-dao-ro/common_dao_types.h>
namespace WrtDB {
-
bool GlobalDAOReadOnly::GetDeveloperMode()
{
LogDebug("Getting Developer mode");
bool GlobalDAOReadOnly::getComplianceMode()
{
LogDebug("Getting compliance mode");
- Try{
- using namespace DPL::DB::ORM; using namespace DPL::DB::ORM::wrt;
+ Try {
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, GlobalProperties, &WrtDatabase::interface())
return select->GetSingleValue<GlobalProperties::compliance_mode>();
}
- Catch (DPL::DB::SqlConnection::Exception::Base){
+ Catch(DPL::DB::SqlConnection::Exception::Base){
ReThrowMsg(GlobalDAOReadOnly::Exception::DatabaseError,
"Failed to get compliance mode");
}
std::string GlobalDAOReadOnly::getComplianceFakeImei()
{
LogDebug("Getting compliance fake IMEI");
- Try{
- using namespace DPL::DB::ORM; using namespace DPL::DB::ORM::wrt;
+ Try {
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, GlobalProperties, &WrtDatabase::interface())
DPL::Optional<DPL::String> result =
select->GetSingleValue<GlobalProperties::compliance_fake_imei>();
}
return DPL::ToUTF8String(*result);
}
- Catch (DPL::DB::SqlConnection::Exception::Base){
+ Catch(DPL::DB::SqlConnection::Exception::Base){
ReThrowMsg(GlobalDAOReadOnly::Exception::DatabaseError,
"Failed to get compliance fake IMEI");
}
std::string GlobalDAOReadOnly::getComplianceFakeMeid()
{
LogDebug("Getting compliance fake MEID");
- Try{
- using namespace DPL::DB::ORM; using namespace DPL::DB::ORM::wrt;
+ Try {
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, GlobalProperties, &WrtDatabase::interface())
DPL::Optional<DPL::String> result =
select->GetSingleValue<GlobalProperties::compliance_fake_meid>();
}
return DPL::ToUTF8String(*result);
}
- Catch (DPL::DB::SqlConnection::Exception::Base){
+ Catch(DPL::DB::SqlConnection::Exception::Base){
ReThrowMsg(GlobalDAOReadOnly::Exception::DatabaseError,
"Failed to get compliance fake MEID");
}
WRT_DB_SELECT(select, iana_records, &WrtDatabase::interface())
select->Where(Equals<iana_records::SUBTAG>(tag));
auto row = select->GetRowList();
- if (row.size() == 0 || row.front().Get_TYPE() != type) {
+ if (row.empty() || row.front().Get_TYPE() != type) {
return false;
} else {
return true;
}
GlobalDAOReadOnly::NetworkAccessMode
- GlobalDAOReadOnly::GetHomeNetworkDataUsage()
+GlobalDAOReadOnly::GetHomeNetworkDataUsage()
{
LogDebug("Getting home network data usage");
Try {
using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, GlobalProperties, &WrtDatabase::interface())
return static_cast<GlobalDAOReadOnly::NetworkAccessMode>(
- select->GetSingleValue<
- GlobalProperties::home_network_data_usage>());
+ select->GetSingleValue<
+ GlobalProperties::home_network_data_usage>());
}
Catch(DPL::DB::SqlConnection::Exception::Base){
ReThrowMsg(GlobalDAOReadOnly::Exception::DatabaseError,
using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, GlobalProperties, &WrtDatabase::interface())
return static_cast<GlobalDAOReadOnly::NetworkAccessMode>(
- select->GetSingleValue<GlobalProperties::roaming_data_usage>());
+ select->GetSingleValue<GlobalProperties::roaming_data_usage>());
}
Catch(DPL::DB::SqlConnection::Exception::Base){
ReThrowMsg(GlobalDAOReadOnly::Exception::DatabaseError,
}
DeviceCapabilitySet GlobalDAOReadOnly::GetDeviceCapability(
- const DPL::String &apifeature)
+ const DPL::String &apifeature)
{
// This could be done with one simply sql query but support for join is
// needed in orm.
- Try{
- using namespace DPL::DB::ORM; using namespace DPL::DB::ORM::wrt;
+ Try {
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::wrt;
int featureUUID;
FeatureDeviceCapProxy::Select::RowList rows;
}
{
- WRT_DB_SELECT(select, FeatureDeviceCapProxy, &WrtDatabase::interface())
+ WRT_DB_SELECT(select,
+ FeatureDeviceCapProxy,
+ &WrtDatabase::interface())
select->Where(Equals<FeatureDeviceCapProxy::FeatureUUID>(
- featureUUID));
+ featureUUID));
rows = select->GetRowList();
}
FOREACH(it, rows){
WRT_DB_SELECT(select, DeviceCapabilities, &WrtDatabase::interface())
select->Where(Equals<DeviceCapabilities::DeviceCapID>(
- it->Get_DeviceCapID()));
+ it->Get_DeviceCapID()));
result.insert(select->
- GetSingleValue<DeviceCapabilities::DeviceCapName>());
+ GetSingleValue<DeviceCapabilities::DeviceCapName>());
}
return result;
- }Catch(DPL::DB::SqlConnection::Exception::Base){
+ } Catch(DPL::DB::SqlConnection::Exception::Base){
ReThrowMsg(GlobalDAOReadOnly::Exception::DatabaseError,
"Failed to update roaming network data usage");
}
WidgetAccessInfoList GlobalDAOReadOnly::GetWhiteURIList()
{
LogDebug("Getting WhiteURIList.");
- Try{
+ Try {
using namespace DPL::DB::ORM;
using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, WidgetWhiteURIList, &WrtDatabase::interface())
"Failed to get Cookie Sharing mode");
}
}
-
} // namespace WrtDB
{
public:
PathBuilderImpl()
- {
- }
+ {}
explicit PathBuilderImpl(const std::string& path) :
m_stream(path, std::ios_base::app)
- {
- }
+ {}
void Append(const std::string& path)
{
};
PathBuilder::PathBuilder() : m_impl(new PathBuilderImpl())
-{
-}
+{}
PathBuilder::PathBuilder(const std::string& path) :
m_impl(new PathBuilderImpl(path))
-{
-}
+{}
PathBuilder::~PathBuilder()
{
{
return m_impl->GetFullPath();
}
-
} // namespace WrtDB
#include <dpl/wrt-dao-ro/WrtDatabase.h>
namespace WrtDB {
-
PluginDAO::PluginDAO(DbPluginHandle pluginHandle) :
PluginDAOReadOnly(pluginHandle)
-{
-}
+{}
PluginDAO::PluginDAO(const std::string &libraryName) :
PluginDAOReadOnly(libraryName)
-{
-}
+{}
DbPluginHandle PluginDAO::registerPlugin(const PluginMetafileData& metafile,
- const std::string& pluginPath)
+ const std::string& pluginPath)
{
LogDebug("Registering plugin. Path: " << pluginPath);
Try {
- DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
+ DPL::DB::ORM::wrt::ScopedTransaction transaction(
+ &WrtDatabase::interface());
DbPluginHandle handle;
if (isPluginInstalled(metafile.m_libraryName)) {
WRT_DB_INSERT(insert, PluginProperties, &WrtDatabase::interface())
insert->Values(row);
- handle = insert->Execute();
+ handle = static_cast<WrtDB::DbWidgetHandle>(insert->Execute());
LogDebug(" >> Plugin Registered. Handle: " << handle);
}
transaction.Commit();
}
void PluginDAO::registerPluginImplementedObject(const std::string& objectName,
- DbPluginHandle pluginHandle)
+ DbPluginHandle pluginHandle)
{
LogDebug("Registering plugin object: " << objectName);
Try {
- DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
+ DPL::DB::ORM::wrt::ScopedTransaction transaction(
+ &WrtDatabase::interface());
LogDebug("Register Object: " << objectName);
}
void PluginDAO::registerPluginRequiredObject(const std::string& objectName,
- DbPluginHandle pluginHandle)
+ DbPluginHandle pluginHandle)
{
LogDebug("Registering plugin object: " << objectName);
Try {
- DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
+ DPL::DB::ORM::wrt::ScopedTransaction transaction(
+ &WrtDatabase::interface());
LogDebug("Register Object: " << objectName);
}
void PluginDAO::registerPluginLibrariesDependencies(
- DbPluginHandle pluginHandle,
- const PluginHandleSetPtr& dependencies)
+ DbPluginHandle pluginHandle,
+ const PluginHandleSetPtr& dependencies)
{
LogDebug("Registering plugin library dependencies: " << pluginHandle);
Try {
- DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
+ DPL::DB::ORM::wrt::ScopedTransaction transaction(
+ &WrtDatabase::interface());
using namespace DPL::DB::ORM;
using namespace DPL::DB::ORM::wrt;
Try {
DPL::DB::ORM::wrt::ScopedTransaction transaction(
- &WrtDatabase::interface());
+ &WrtDatabase::interface());
if (!isPluginInstalled(pluginHandle)) {
LogInfo("PluginHandle is invalid. Handle: " << pluginHandle);
return;
-
} else {
using namespace DPL::DB::ORM;
using namespace DPL::DB::ORM::wrt;
"Failed in UnregisterPlugin");
}
}
-
} // namespace WrtDB
#include <dpl/wrt-dao-ro/WrtDatabase.h>
namespace WrtDB {
-
namespace {
-
typedef DPL::DB::ORM::wrt::PluginProperties::Row PluginRow;
PluginRow getPluginRow(DbPluginHandle pluginHandle)
void PluginDAOReadOnly::checkInstallationCompleted()
{
if (getInstallationStateForHandle(m_pluginHandle)
- != PluginDAOReadOnly::INSTALLATION_COMPLETED) {
+ != PluginDAOReadOnly::INSTALLATION_COMPLETED)
+ {
LogError("Plugin " << m_pluginHandle << " installation not completed");
Throw(PluginDAOReadOnly::Exception::PluginInstallationNotCompleted);
}
return m_pluginHandle;
}
-
//"value" cannot be null, as in registerPlugin it is always set
#define RETURN_STD_STRING(in, what) \
std::string ret = ""; \
}
DbPluginHandle PluginDAOReadOnly::getPluginHandleForImplementedObject(
- const std::string& objectName)
+ const std::string& objectName)
{
LogDebug("GetPluginHandle for object: " << objectName);
}
ImplementedObjectsList PluginDAOReadOnly::getImplementedObjectsForPluginHandle(
- DbPluginHandle handle)
+ DbPluginHandle handle)
{
LogDebug("getImplementedObjects for pluginHandle: " << handle);
}
}
-PluginObjectsDAO::ObjectsPtr PluginDAOReadOnly::getRequiredObjectsForPluginHandle(
- DbPluginHandle handle)
+PluginObjectsDAO::ObjectsPtr PluginDAOReadOnly::
+ getRequiredObjectsForPluginHandle(
+ DbPluginHandle handle)
{
Try
{
}
PluginHandleSetPtr PluginDAOReadOnly::getPluginHandleByStatus(
- PluginInstallationState state)
+ PluginInstallationState state)
{
Try
{
}
}
-PluginDAOReadOnly::PluginInstallationState PluginDAOReadOnly::getInstallationStatus() const
+PluginDAOReadOnly::PluginInstallationState PluginDAOReadOnly::
+ getInstallationStatus() const
{
PluginRow row = getPluginRow(m_pluginHandle);
return ToState(row.Get_InstallationState());
}
-PluginDAOReadOnly::PluginInstallationState PluginDAOReadOnly::getInstallationStateForHandle(
- DbPluginHandle handle)
+PluginDAOReadOnly::PluginInstallationState PluginDAOReadOnly::
+ getInstallationStateForHandle(
+ DbPluginHandle handle)
{
Try
{
"Failed in isPluginInstalled");
}
}
-
} // namespace WrtDB
namespace WrtDB {
namespace PropertyDAO {
-//deprecated
-void RemoveProperty(DbWidgetHandle widgetHandle,
- const PropertyDAOReadOnly::WidgetPropertyKey &key)
-{
- RemoveProperty(WidgetDAOReadOnly::getPkgName(widgetHandle),key);
-}
-
-void RemoveProperty(WidgetPkgName pkgName,
+void RemoveProperty(TizenAppId tzAppid,
const PropertyDAOReadOnly::WidgetPropertyKey &key)
{
//TODO below there are two queries.
// First query asks if given property can be removed,
// Second removes it. Maybe it should be combined two one.
- LogDebug("Removing Property. pkgName: " << pkgName << ", key: " << key);
+ LogDebug("Removing Property. appid: " << tzAppid << ", key: " << key);
Try {
- DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
+ DPL::DB::ORM::wrt::ScopedTransaction transaction(
+ &WrtDatabase::interface());
DPL::OptionalInt readonly = PropertyDAOReadOnly::CheckPropertyReadFlag(
- pkgName,
+ tzAppid,
key);
if (!readonly.IsNull() && *readonly == 1) {
LogError("'" << key <<
using namespace DPL::DB::ORM::wrt;
WRT_DB_DELETE(del, WidgetPreference, &WrtDatabase::interface())
del->Where(And(
- Equals<WidgetPreference::pkgname>(pkgName),
+ Equals<WidgetPreference::tizen_appid>(tzAppid),
Equals<WidgetPreference::key_name>(key)));
del->Execute();
const PropertyDAOReadOnly::WidgetPropertyValue &value,
bool readOnly)
{
- SetProperty(WidgetDAOReadOnly::getPkgName(widgetHandle),key,value,readOnly);
+ SetProperty(WidgetDAOReadOnly::getTzAppId(
+ widgetHandle), key, value, readOnly);
}
-void SetProperty(WidgetPkgName pkgName,
+void SetProperty(TizenAppId tzAppid,
const PropertyDAOReadOnly::WidgetPropertyKey &key,
const PropertyDAOReadOnly::WidgetPropertyValue &value,
bool readOnly)
{
- LogDebug("Setting/updating Property. pkgName: " << pkgName <<
+ LogDebug("Setting/updating Property. appid: " << tzAppid <<
", key: " << key);
Try {
using namespace DPL::DB::ORM;
using namespace DPL::DB::ORM::wrt;
- DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
+ DPL::DB::ORM::wrt::ScopedTransaction transaction(
+ &WrtDatabase::interface());
DPL::OptionalInt readonly = PropertyDAOReadOnly::CheckPropertyReadFlag(
- pkgName,
+ tzAppid,
key);
if (!readonly.IsNull() && *readonly == 1) {
LogError("'" << key <<
if (readonly.IsNull()) {
WidgetPreference::Row row;
- row.Set_pkgname(pkgName);
+ row.Set_tizen_appid(tzAppid);
row.Set_key_name(key);
row.Set_key_value(value);
row.Set_readonly(readOnly ? 1 : 0);
WRT_DB_UPDATE(update, WidgetPreference, &WrtDatabase::interface())
update->Where(And(
- Equals<WidgetPreference::pkgname>(pkgName),
+ Equals<WidgetPreference::tizen_appid>(tzAppid),
Equals<WidgetPreference::key_name>(key)));
update->Values(row);
}
}
-//deprecated
-void RegisterProperties(DbWidgetHandle widgetHandle,
+void RegisterProperties(TizenAppId tzAppid,
const WidgetRegisterInfo ®Info)
{
- RegisterProperties(WidgetDAOReadOnly::getPkgName(widgetHandle),regInfo);
-}
-
-void RegisterProperties(WidgetPkgName pkgName,
- const WidgetRegisterInfo ®Info)
-{
- LogDebug("Registering proferences for widget. pkgName: " << pkgName);
+ LogDebug("Registering proferences for widget. appid: " << tzAppid);
// Try-Catch in WidgetDAO
{
{ // Insert into table Widget Preferences
WidgetPreference::Row row;
- row.Set_pkgname(pkgName);
+ row.Set_tizen_appid(tzAppid);
row.Set_key_name(it->name);
row.Set_key_value(it->value);
int readonly = true == it->readonly ? 1 : 0;
}
}
}
-
} // namespace PropertyDAO
} // namespace WrtDB
namespace WrtDB {
namespace PropertyDAOReadOnly {
-
namespace {
-
typedef DPL::DB::ORM::wrt::WidgetPreference::key_name::ColumnType
- ORMWidgetPropertyKey;
+ORMWidgetPropertyKey;
typedef DPL::DB::ORM::wrt::WidgetPreference::key_value::ColumnType
- ORMWidgetPropertyValue;
-typedef std::list<DPL::DB::ORM::wrt::WidgetPreference::Row> ORMWidgetPreferenceList;
+ORMWidgetPropertyValue;
+typedef std::list<DPL::DB::ORM::wrt::WidgetPreference::Row>
+ORMWidgetPreferenceList;
typedef std::list<WidgetPropertyKey> ORMWidgetPropertyKeyList;
-
void convertPropertyKey(const ORMWidgetPropertyKey& ormKey,
WidgetPropertyKey& key)
{
FOREACH(it, ormWidgetPrefRow) {
WidgetPreferenceRow row;
- row.pkgname = it->Get_pkgname();
+ row.tizen_appid = it->Get_tizen_appid();
row.key_name = it->Get_key_name();
row.key_value = it->Get_key_value();
row.readonly = it->Get_readonly();
keyList.push_back(*it);
}
}
-
-
}
//deprecated
DPL::OptionalInt CheckPropertyReadFlag(DbWidgetHandle widgetHandle,
- const WidgetPropertyKey &key)
+ const WidgetPropertyKey &key)
{
- return CheckPropertyReadFlag(WidgetDAOReadOnly::getPkgName(widgetHandle),
+ return CheckPropertyReadFlag(WidgetDAOReadOnly::getTzAppId(widgetHandle),
key);
}
-DPL::OptionalInt CheckPropertyReadFlag(WidgetPkgName pkgName,
- const WidgetPropertyKey &key)
+DPL::OptionalInt CheckPropertyReadFlag(TizenAppId tzAppid,
+ const WidgetPropertyKey &key)
{
- LogDebug("Checking Property flag. pkgName: " << pkgName <<
+ LogDebug("Checking Property flag. appid: " << tzAppid <<
", key: " << key);
Try {
using namespace DPL::DB::ORM;
using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, WidgetPreference, &WrtDatabase::interface())
- select->Where(And(Equals<WidgetPreference::pkgname>(pkgName),
+ select->Where(And(Equals<WidgetPreference::tizen_appid>(tzAppid),
Equals<WidgetPreference::key_name>(key)));
return select->GetSingleValue<WidgetPreference::readonly>();
}
}
-//deprecated
-WidgetPropertyKeyList GetPropertyKeyList(DbWidgetHandle widgetHandle)
-{
- return GetPropertyKeyList(WidgetDAOReadOnly::getPkgName(widgetHandle));
-}
-
-WidgetPropertyKeyList GetPropertyKeyList(WidgetPkgName pkgName)
+WidgetPropertyKeyList GetPropertyKeyList(TizenAppId tzAppid)
{
- LogDebug("Get PropertyKey list. pkgName: " << pkgName);
+ LogDebug("Get PropertyKey list. appid: " << tzAppid);
Try {
using namespace DPL::DB::ORM;
using namespace DPL::DB::ORM::wrt;
ORMWidgetPropertyKeyList keyList;
WRT_DB_SELECT(select, WidgetPreference, &WrtDatabase::interface())
- select->Where(Equals<WidgetPreference::pkgname>(pkgName));
+ select->Where(Equals<WidgetPreference::tizen_appid>(tzAppid));
keyList = select->GetValueList<WidgetPreference::key_name>();
WidgetPropertyKeyList retKeyList;
//deprecated
WidgetPreferenceList GetPropertyList(DbWidgetHandle widgetHandle)
{
- Try{
- WidgetPkgName pkgName=WidgetDAOReadOnly::getPkgName(widgetHandle);
- return GetPropertyList(pkgName);
- }Catch(WidgetDAOReadOnly::Exception::WidgetNotExist){
+ Try {
+ TizenAppId tzAppid = WidgetDAOReadOnly::getTzAppId(widgetHandle);
+ return GetPropertyList(tzAppid);
+ } Catch(WidgetDAOReadOnly::Exception::WidgetNotExist){
WidgetPreferenceList empty;
return empty;
}
}
-WidgetPreferenceList GetPropertyList(WidgetPkgName pkgName)
+WidgetPreferenceList GetPropertyList(TizenAppId tzAppId)
{
- LogDebug("Get Property list. pkgName: " << pkgName);
+ LogDebug("Get Property list. tizenAppId: " << tzAppId);
Try {
using namespace DPL::DB::ORM;
using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, WidgetPreference, &WrtDatabase::interface())
- select->Where(Equals<WidgetPreference::pkgname>(pkgName));
+ select->Where(Equals<WidgetPreference::tizen_appid>(tzAppId));
ORMWidgetPreferenceList ormPrefList = select->GetRowList();
WidgetPreferenceList prefList;
}
}
-//deprecated
-WidgetPropertyValue GetPropertyValue(DbWidgetHandle widgetHandle,
- const WidgetPropertyKey &key)
-{
- return GetPropertyValue(WidgetDAOReadOnly::getPkgName(widgetHandle),key);
-}
-
-WidgetPropertyValue GetPropertyValue(WidgetPkgName pkgName,
+WidgetPropertyValue GetPropertyValue(TizenAppId tzAppid,
const WidgetPropertyKey &key)
{
- LogDebug("Get Property value. pkgName: " << pkgName <<
+ LogDebug("Get Property value. appid: " << tzAppid <<
", key: " << key);
Try {
using namespace DPL::DB::ORM;
using namespace DPL::DB::ORM::wrt;
WRT_DB_SELECT(select, WidgetPreference, &WrtDatabase::interface())
- select->Where(And(Equals<WidgetPreference::pkgname>(pkgName),
+ select->Where(And(Equals<WidgetPreference::tizen_appid>(tzAppid),
Equals<WidgetPreference::key_name>(key)));
ORMWidgetPropertyValue ormPropValue =
- select->GetSingleValue<WidgetPreference::key_value>();
+ select->GetSingleValue<WidgetPreference::key_value>();
WidgetPropertyValue propValue;
"Failure during getting property");
}
}
-
} // namespace PropertyDAOReadOnly
} // namespace WrtDB
#include <dpl/wrt-dao-ro/WrtDatabase.h>
namespace WrtDB {
-
//TODO in current solution in each getter there exists a check
//"IsWidgetInstalled". Maybe it should be verified, if it could be done
//differently (check in WidgetDAO constructor)
WidgetDAO::WidgetDAO(DPL::OptionalString widgetGUID) :
WidgetDAOReadOnly(WidgetDAOReadOnly::getHandle(widgetGUID))
-{
-}
+{}
-WidgetDAO::WidgetDAO(DPL::String pkgName) :
- WidgetDAOReadOnly(WidgetDAOReadOnly::getHandle(pkgName))
-{
-}
+WidgetDAO::WidgetDAO(DPL::String tzAppId) :
+ WidgetDAOReadOnly(WidgetDAOReadOnly::getHandle(tzAppId))
+{}
WidgetDAO::WidgetDAO(DbWidgetHandle handle) :
WidgetDAOReadOnly(handle)
-{
-}
+{}
WidgetDAO::~WidgetDAO()
-{
-}
-
-void WidgetDAO::removeProperty(
- const PropertyDAOReadOnly::WidgetPropertyKey &key)
-{
- Try {
- PropertyDAO::RemoveProperty(m_widgetHandle, key);
- }
- Catch(PropertyDAOReadOnly::Exception::ReadOnlyProperty){
- ReThrowMsg(WidgetDAO::Exception::DatabaseError,
- "Failure during removing property");
- }
-}
-
-void WidgetDAO::setProperty(
- const PropertyDAOReadOnly::WidgetPropertyKey &key,
- const PropertyDAOReadOnly::WidgetPropertyValue &value,
- bool readOnly)
-{
- Try {
- PropertyDAO::SetProperty(m_widgetHandle, key, value, readOnly);
- }
- Catch(PropertyDAOReadOnly::Exception::ReadOnlyProperty){
- ReThrowMsg(WidgetDAO::Exception::DatabaseError,
- "Failure during setting/updating property");
- }
-}
+{}
-void WidgetDAO::setPkgName(const DPL::OptionalString& pkgName)
-{
-
- // if(!!pkgName)
- setPkgName_TEMPORARY_API(*pkgName);
-}
-
-
-void WidgetDAO::setPkgName_TEMPORARY_API(const WidgetPkgName& pkgName)
+void WidgetDAO::setTizenAppId(const DPL::OptionalString& tzAppId)
{
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
if (!isWidgetInstalled(getHandle())) {
ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
- "Cannot find widget. Handle: " << getHandle());
+ "Cannot find widget. Handle: " << getHandle());
}
wrt::WidgetInfo::Row row;
- row.Set_pkgname(pkgName);
+ row.Set_tizen_appid(*tzAppId);
WRT_DB_UPDATE(update, wrt::WidgetInfo, &WrtDatabase::interface())
update->Where(
ScopedTransaction transaction(&WrtDatabase::interface());
if (!isWidgetInstalled(getHandle())) {
ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
- "Cannot find widget. Handle: " << getHandle());
+ "Cannot find widget. Handle: " << getHandle());
}
WidgetSecuritySettings::Row row;
ScopedTransaction transaction(&WrtDatabase::interface());
if (!isWidgetInstalled(getHandle())) {
ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
- "Cannot find widget. Handle: " << getHandle());
+ "Cannot find widget. Handle: " << getHandle());
}
WidgetSecuritySettings::Row row;
ScopedTransaction transaction(&WrtDatabase::interface());
if (!isWidgetInstalled(getHandle())) {
ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
- "Cannot find widget. Handle: " << getHandle());
+ "Cannot find widget. Handle: " << getHandle());
}
WidgetSecuritySettings::Row row;
ScopedTransaction transaction(&WrtDatabase::interface());
if (!isWidgetInstalled(getHandle())) {
ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
- "Cannot find widget. Handle: " << getHandle());
+ "Cannot find widget. Handle: " << getHandle());
}
WidgetSecuritySettings::Row row;
ScopedTransaction transaction(&WrtDatabase::interface());
if (!isWidgetInstalled(getHandle())) {
ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
- "Cannot find widget. Handle: " << getHandle());
+ "Cannot find widget. Handle: " << getHandle());
}
WidgetSecuritySettings::Row row;
}
void WidgetDAO::registerWidget(
- const WidgetPkgName & widgetPkgname,
- const WidgetRegisterInfo &widgetRegInfo,
- const IWacSecurity &wacSecurity)
+ const TizenAppId & tzAppId,
+ const WidgetRegisterInfo &widgetRegInfo,
+ const IWacSecurity &wacSecurity)
{
LogDebug("Registering widget");
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
- registerWidgetInternal(widgetPkgname, widgetRegInfo, wacSecurity);
- transaction.Commit();
- }
- SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to register widget")
-}
-
-void WidgetDAO::registerWidget(
- WrtDB::DbWidgetHandle handle,
- const WidgetRegisterInfo &widgetRegInfo,
- const IWacSecurity &wacSecurity)
-{
- LogDebug("Registering widget");
- SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
- {
- DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
- registerWidgetInternal(generateTizenId(), widgetRegInfo, wacSecurity, handle);
+ DPL::DB::ORM::wrt::ScopedTransaction transaction(
+ &WrtDatabase::interface());
+ registerWidgetInternal(tzAppId, widgetRegInfo, wacSecurity);
transaction.Commit();
}
SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to register widget")
}
DbWidgetHandle WidgetDAO::registerWidget(
- const WidgetRegisterInfo &pWidgetRegisterInfo,
- const IWacSecurity &wacSecurity)
+ const WidgetRegisterInfo &pWidgetRegisterInfo,
+ const IWacSecurity &wacSecurity)
{
//make it more precise due to very fast tests
struct timeval tv;
gettimeofday(&tv, NULL);
- srand(time(NULL) + tv.tv_usec);
DbWidgetHandle widgetHandle;
+ unsigned int seed = time(NULL);
do {
- widgetHandle = rand();
+ widgetHandle = rand_r(&seed);
} while (isWidgetInstalled(widgetHandle));
- registerWidget(widgetHandle, pWidgetRegisterInfo, wacSecurity);
+ registerWidget(*pWidgetRegisterInfo.configInfo.tizenAppId,
+ pWidgetRegisterInfo,
+ wacSecurity);
return widgetHandle;
}
-WidgetPkgName WidgetDAO::registerWidgetGenerateTizenId(
- const WidgetRegisterInfo &pWidgetRegisterInfo,
- const IWacSecurity &wacSecurity)
+TizenAppId WidgetDAO::registerWidgetGeneratePkgId(
+ const WidgetRegisterInfo &pWidgetRegisterInfo,
+ const IWacSecurity &wacSecurity)
{
- WidgetPkgName widgetPkgName = generateTizenId();
- registerWidget(widgetPkgName, pWidgetRegisterInfo, wacSecurity);
- return widgetPkgName;
+ TizenAppId tzAppId = generatePkgId();
+ registerWidget(tzAppId, pWidgetRegisterInfo, wacSecurity);
+ return tzAppId;
}
void WidgetDAO::registerWidgetInternal(
- const WidgetPkgName & widgetName,
- const WidgetRegisterInfo &widgetRegInfo,
- const IWacSecurity &wacSecurity,
- const DPL::Optional<DbWidgetHandle> handle)
+ const TizenAppId & tzAppId,
+ const WidgetRegisterInfo &widgetRegInfo,
+ const IWacSecurity &wacSecurity,
+ const DPL::Optional<DbWidgetHandle> handle)
{
//Register into WidgetInfo has to be first
//as all other tables depend upon that
- DbWidgetHandle widgetHandle = registerWidgetInfo(widgetName, widgetRegInfo, wacSecurity, handle);
+ DbWidgetHandle widgetHandle = registerWidgetInfo(tzAppId,
+ widgetRegInfo,
+ wacSecurity,
+ handle);
registerWidgetExtendedInfo(widgetHandle, widgetRegInfo);
registerWidgetStartFile(widgetHandle, widgetRegInfo);
- PropertyDAO::RegisterProperties(widgetHandle, widgetRegInfo);
+ PropertyDAO::RegisterProperties(tzAppId, widgetRegInfo);
registerWidgetFeatures(widgetHandle, widgetRegInfo);
}
void WidgetDAO::registerOrUpdateWidget(
- const WidgetPkgName & widgetName,
- const WidgetRegisterInfo &widgetRegInfo,
- const IWacSecurity &wacSecurity)
+ const TizenAppId & widgetName,
+ const WidgetRegisterInfo &widgetRegInfo,
+ const IWacSecurity &wacSecurity)
{
LogDebug("Reregistering widget");
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
+ DPL::DB::ORM::wrt::ScopedTransaction transaction(
+ &WrtDatabase::interface());
unregisterWidgetInternal(widgetName);
registerWidgetInternal(widgetName, widgetRegInfo, wacSecurity);
}
void WidgetDAO::registerWidgetExtendedInfo(DbWidgetHandle widgetHandle,
- const WidgetRegisterInfo ®Info)
+ const WidgetRegisterInfo ®Info)
{
//Try and transaction not needed
using namespace DPL::DB::ORM;
using namespace DPL::DB::ORM::wrt;
-
WidgetExtendedInfo::Row row;
row.Set_app_id(widgetHandle);
// row.Set_share_href (DPL::FromUTF8String(regInfo.shareHref));
}
DbWidgetHandle WidgetDAO::registerWidgetInfo(
- const WidgetPkgName & widgetName,
- const WidgetRegisterInfo ®Info,
- const IWacSecurity &wacSecurity,
- const DPL::Optional<DbWidgetHandle> handle)
+ const TizenAppId & tzAppId,
+ const WidgetRegisterInfo ®Info,
+ const IWacSecurity &wacSecurity,
+ const DPL::Optional<DbWidgetHandle> handle)
{
using namespace DPL::DB::ORM;
using namespace DPL::DB::ORM::wrt;
// Because of that, "Optional" is not used there
WidgetInfo::Row row;
- if(!!handle)
- {
+ if (!!handle) {
row.Set_app_id(*handle);
}
- if (regInfo.webAppType == APP_TYPE_UNKNOWN && regInfo.type !=
- APP_TYPE_UNKNOWN) {
- // TODO : regInfo.type is temporary code for security.
- // This code will be removed.
- row.Set_widget_type(regInfo.type.appType);
- } else {
- row.Set_widget_type(regInfo.webAppType.appType);
- }
+ row.Set_widget_type(regInfo.webAppType.appType);
+
row.Set_widget_id(widgetConfigurationInfo.widget_id);
row.Set_defaultlocale(widgetConfigurationInfo.defaultlocale);
row.Set_widget_version(widgetConfigurationInfo.version);
row.Set_author_name(widgetConfigurationInfo.authorName);
row.Set_author_email(widgetConfigurationInfo.authorEmail);
row.Set_author_href(widgetConfigurationInfo.authorHref);
+ row.Set_csp_policy(widgetConfigurationInfo.cspPolicy);
+ row.Set_csp_policy_report_only(widgetConfigurationInfo.cspPolicyReportOnly);
row.Set_base_folder(DPL::FromUTF8String(regInfo.baseFolder));
row.Set_webkit_plugins_required(widgetConfigurationInfo.flashNeeded);
row.Set_recognized(wacSecurity.isRecognized());
row.Set_wac_signed(wacSecurity.isWacSigned());
row.Set_distributor_signed(wacSecurity.isDistributorSigned());
- row.Set_pkgname(widgetName);
+ row.Set_tizen_appid(tzAppId);
+ row.Set_tizen_pkgid(regInfo.tzPkgid);
{
std::stringstream tmp;
tmp << regInfo.minVersion;
"Failed to register widget info.");
}
- if(!handle)
- {
+ if (!handle) {
//get autoincremented value of widgetHandle
WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
- select->Where(Equals<WidgetInfo::pkgname>(widgetName));
+ select->Where(Equals<WidgetInfo::tizen_appid>(tzAppId));
return select->GetSingleValue<WidgetInfo::app_id>();
- }
- else
- {
+ } else {
return *handle;
}
}
void WidgetDAO::registerWidgetLocalizedInfo(DbWidgetHandle widgetHandle,
- const WidgetRegisterInfo ®Info)
+ const WidgetRegisterInfo ®Info)
{
using namespace DPL::DB::ORM;
using namespace DPL::DB::ORM::wrt;
}
void WidgetDAO::registerWidgetIcons(DbWidgetHandle widgetHandle,
- const WidgetRegisterInfo ®Info)
+ const WidgetRegisterInfo ®Info)
{
using namespace DPL::DB::ORM;
using namespace DPL::DB::ORM::wrt;
-
FOREACH(i, regInfo.localizationData.icons)
{
wrt::WidgetIcon::icon_id::ColumnType icon_id;
WRT_DB_INSERT(insert, wrt::WidgetIcon, &WrtDatabase::interface())
insert->Values(row);
- icon_id = insert->Execute();
+ icon_id = static_cast<int>(insert->Execute());
}
FOREACH(j, i->availableLocales)
row.Set_app_id(widgetHandle);
row.Set_icon_id(icon_id);
row.Set_widget_locale(*j);
- WRT_DB_SELECT(select, WidgetLocalizedIcon, &WrtDatabase::interface())
- select->Where(And(Equals<WidgetLocalizedIcon::app_id>(widgetHandle),
- Equals<WidgetLocalizedIcon::widget_locale>(*j)));
- WidgetLocalizedIcon::Select::RowList rows = select->GetRowList();
-
- bool flag = !rows.empty();
-
- if(flag == true)
- {
- // already default icon value of same locale exists
- WRT_DB_UPDATE(update, WidgetLocalizedIcon, &WrtDatabase::interface())
- update->Where(And(Equals<WidgetLocalizedIcon::app_id>(widgetHandle),
- Equals<WidgetLocalizedIcon::widget_locale>(*j)));
- update->Values(row);
- update->Execute();
- }else{
- // any icon value of same locale doesn't exist
- DO_INSERT(row, WidgetLocalizedIcon)
- }
+ DO_INSERT(row, WidgetLocalizedIcon)
}
}
}
void WidgetDAO::registerWidgetStartFile(DbWidgetHandle widgetHandle,
- const WidgetRegisterInfo ®Info)
+ const WidgetRegisterInfo ®Info)
{
using namespace DPL::DB::ORM;
using namespace DPL::DB::ORM::wrt;
-
FOREACH(i, regInfo.localizationData.startFiles)
{
WidgetStartFile::start_file_id::ColumnType startFileID;
WRT_DB_INSERT(insert, WidgetStartFile, &WrtDatabase::interface())
insert->Values(row);
- startFileID = insert->Execute();
+ startFileID = static_cast<int>(insert->Execute());
}
FOREACH(j, i->propertiesForLocales)
}
void WidgetDAO::registerWidgetFeatures(DbWidgetHandle widgetHandle,
- const WidgetRegisterInfo ®Info)
+ const WidgetRegisterInfo ®Info)
{
using namespace DPL::DB::ORM;
const ConfigParserData& widgetConfigurationInfo = regInfo.configInfo;
-
FOREACH(pWidgetFeature, widgetConfigurationInfo.featuresList)
{
wrt::WidgetFeature::Row widgetFeature;
{
WRT_DB_INSERT(insert, wrt::WidgetFeature, &WrtDatabase::interface())
insert->Values(widgetFeature);
- widgetFeatureID = insert->Execute();
+ widgetFeatureID = static_cast<int>(insert->Execute());
}
// Insert into table FeatureParam
}
}
-void WidgetDAO::updateFeatureRejectStatus(const DbWidgetFeature &widgetFeature){
- // This function could be merged with registerWidgetFeature but it requires desing change:
- // 1. Check "ace step" in installer must be done before "update database step"
+void WidgetDAO::updateFeatureRejectStatus(const DbWidgetFeature &widgetFeature)
+{
+ // This function could be merged with registerWidgetFeature but it requires
+ // desing change:
+ // 1. Check "ace step" in installer must be done before "update database
+ // step"
// And:
// ConfigurationParserData shouldn't be called "ParserData" any more.
using namespace DPL::DB::ORM;
}
void WidgetDAO::registerWidgetWindowModes(DbWidgetHandle widgetHandle,
- const WidgetRegisterInfo ®Info)
+ const WidgetRegisterInfo ®Info)
{
using namespace DPL::DB::ORM;
using namespace DPL::DB::ORM::wrt;
const ConfigParserData& widgetConfigurationInfo = regInfo.configInfo;
-
FOREACH(i, widgetConfigurationInfo.windowModes)
{
wrt::WidgetWindowModes::Row windowMode;
}
void WidgetDAO::registerWidgetWarpInfo(DbWidgetHandle widgetHandle,
- const WidgetRegisterInfo ®Info)
+ const WidgetRegisterInfo ®Info)
{
using namespace DPL::DB::ORM;
using namespace DPL::DB::ORM::wrt;
const ConfigParserData& widgetConfigurationInfo = regInfo.configInfo;
-
FOREACH(AccIt, widgetConfigurationInfo.accessInfoSet)
{
WidgetWARPInfo::Row row;
}
void WidgetDAO::registerWidgetCertificates(DbWidgetHandle widgetHandle,
- const IWacSecurity &wacSecurity)
+ const IWacSecurity &wacSecurity)
{
using namespace DPL::DB::ORM;
using namespace DPL::DB::ORM::wrt;
-
FOREACH(it, wacSecurity.getCertificateList())
{
WidgetCertificateFingerprint::Row row;
}
}
-void WidgetDAO::registerCertificatesChains(DbWidgetHandle widgetHandle,
- CertificateSource certificateSource,
- const CertificateChainList &certificateChainList)
+void WidgetDAO::registerCertificatesChains(
+ DbWidgetHandle widgetHandle,
+ CertificateSource certificateSource,
+ const CertificateChainList &
+ certificateChainList)
{
using namespace DPL::DB::ORM;
using namespace DPL::DB::ORM::wrt;
}
void WidgetDAO::registerWidgetSettings(DbWidgetHandle widgetHandle,
- const WidgetRegisterInfo ®Info)
+ const WidgetRegisterInfo ®Info)
{
using namespace DPL::DB::ORM;
using namespace DPL::DB::ORM::wrt;
}
}
+void WidgetDAO::insertApplicationServiceInfo(DbWidgetHandle handle,
+ DPL::String src,
+ DPL::String operation,
+ DPL::String scheme,
+ DPL::String mime)
+{
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::wrt;
+
+ ApplicationServiceInfo::Row row;
+
+ row.Set_app_id(handle);
+ row.Set_src(src);
+ row.Set_operation(operation);
+ row.Set_scheme(scheme);
+ row.Set_mime(mime);
+
+ DO_INSERT(row, ApplicationServiceInfo);
+}
+
void WidgetDAO::registerAppService(DbWidgetHandle widgetHandle,
const WidgetRegisterInfo ®Info)
{
using namespace DPL::DB::ORM::wrt;
const ConfigParserData& widgetConfigurationInfo = regInfo.configInfo;
+ // appServiceList
FOREACH(ASIt, widgetConfigurationInfo.appServiceList)
{
ApplicationServiceInfo::Row row;
row.Set_operation(ASIt->m_operation);
row.Set_scheme(ASIt->m_scheme);
row.Set_mime(ASIt->m_mime);
+ row.Set_disposition(static_cast<int>(ASIt->m_disposition));
DO_INSERT(row, ApplicationServiceInfo)
}
+
+ // appControlList
+ FOREACH(appControl_it, widgetConfigurationInfo.appControlList)
+ {
+ DPL::String src = appControl_it->m_src;
+ DPL::String operation = appControl_it->m_operation;
+
+ if (!appControl_it->m_uriList.empty())
+ {
+ FOREACH(uri_it, appControl_it->m_uriList)
+ {
+ DPL::String scheme = *uri_it;
+
+ if (!appControl_it->m_mimeList.empty())
+ {
+ FOREACH(mime_it, appControl_it->m_mimeList)
+ {
+ DPL::String mime = *mime_it;
+
+ insertApplicationServiceInfo(widgetHandle, src, operation, scheme, mime);
+ }
+ }
+ else
+ {
+ DPL::String mime = L"";
+
+ insertApplicationServiceInfo(widgetHandle, src, operation, scheme, mime);
+ }
+ }
+ }
+ else
+ {
+ DPL::String scheme = L"";
+
+ if (!appControl_it->m_mimeList.empty())
+ {
+ FOREACH(mime_it, appControl_it->m_mimeList)
+ {
+ DPL::String mime = *mime_it;
+
+ insertApplicationServiceInfo(widgetHandle, src, operation, scheme, mime);
+ }
+ }
+ else
+ {
+ DPL::String mime = L"";
+
+ insertApplicationServiceInfo(widgetHandle, src, operation, scheme, mime);
+ }
+ }
+ }
}
void WidgetDAO::registerEncryptedResouceInfo(DbWidgetHandle widgetHandle,
- const WidgetRegisterInfo ®Info)
+ const WidgetRegisterInfo ®Info)
{
using namespace DPL::DB::ORM;
using namespace DPL::DB::ORM::wrt;
}
}
-void WidgetDAO::registerExternalLocations(DbWidgetHandle widgetHandle,
- const ExternalLocationList & externals)
+void WidgetDAO::registerExternalLocations(
+ DbWidgetHandle widgetHandle,
+ const ExternalLocationList &
+ externals)
{
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
using namespace DPL::DB::ORM;
using namespace DPL::DB::ORM::wrt;
- DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
+ DPL::DB::ORM::wrt::ScopedTransaction transaction(
+ &WrtDatabase::interface());
LogDebug("Inserting external files for widgetHandle: " << widgetHandle);
FOREACH(it, externals)
{
del->Execute();
}
-void WidgetDAO::unregisterWidget(const WidgetPkgName & pkgName)
+void WidgetDAO::unregisterWidget(const TizenAppId & tzAppId)
{
- LogDebug("Unregistering widget from DB. PkgName: " << pkgName);
+ LogDebug("Unregistering widget from DB. tzAppId: " << tzAppId);
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- DPL::DB::ORM::wrt::ScopedTransaction transaction(&WrtDatabase::interface());
- unregisterWidgetInternal(pkgName);
+ DPL::DB::ORM::wrt::ScopedTransaction transaction(
+ &WrtDatabase::interface());
+ unregisterWidgetInternal(tzAppId);
transaction.Commit();
}
SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to unregister widget")
}
void WidgetDAO::unregisterWidgetInternal(
- const WidgetPkgName & pkgName)
+ const TizenAppId & tzAppId)
{
using namespace DPL::DB::ORM;
using namespace DPL::DB::ORM::wrt;
- DbWidgetHandle handle = getHandle(pkgName);
+ DbWidgetHandle handle = getHandle(tzAppId);
// Delete from table Widget Info
WRT_DB_DELETE(del, WidgetInfo, &WrtDatabase::interface())
#undef SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
#undef SQL_CONNECTION_EXCEPTION_HANDLER_END
-
} // namespace WrtDB
#include <orm_generator_wrt.h>
#include <LanguageTagsProvider.h>
-namespace WrtDB {
+namespace {
+ unsigned int seed = time(NULL);
+}
+namespace WrtDB {
//TODO in current solution in each getter there exists a check
//"IsWidgetInstalled". Maybe it should be verified, if it could be done
//differently (check in WidgetDAOReadOnly constructor)
"Cannot find widget. Handle: " << macro_handle); \
}
-
typedef DPL::DB::ORM::wrt::WidgetInfo::Row WidgetInfoRow;
typedef DPL::DB::ORM::wrt::WidgetFeature::widget_feature_id::ColumnType
- WidgetFeatureId;
+WidgetFeatureId;
typedef DPL::DB::ORM::wrt::WidgetSecuritySettings::Row
- WidgetSecuritySettingsRow;
+WidgetSecuritySettingsRow;
namespace {
-
using namespace DPL::DB::ORM;
using namespace DPL::DB::ORM::wrt;
}
return rows.front();
}
- SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed in getWidgetSecuritySettingsRow")
+ SQL_CONNECTION_EXCEPTION_HANDLER_END(
+ "Failed in getWidgetSecuritySettingsRow")
}
const int MAX_TIZENID_LENGTH = 10;
-WidgetPkgName getPkgNameByHandle(const DbWidgetHandle handle)
+TizenAppId getTizenAppIdByHandle(const DbWidgetHandle handle)
{
- LogDebug("Getting WidgetPkgName by DbWidgetHandle: " << handle);
+ LogDebug("Getting TizenAppId by DbWidgetHandle: " << handle);
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
if (rowList.empty()) {
ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
- "Failed to get widget by handle");
+ "Failed to get widget by handle");
}
- WidgetPkgName pkgname = rowList.front().Get_pkgname();
+ TizenAppId tzAppid = rowList.front().Get_tizen_appid();
- return pkgname;
+ return tzAppid;
+ }
+ SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed in getHandle")
+}
+TizenAppId getTizenAppIdByPkgId(const TizenPkgId tzPkgid)
+{
+ LogDebug("Getting TizenAppId by pkgid : " << tzPkgid);
+ SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
+ {
+ WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
+ select->Where(Equals<WidgetInfo::tizen_pkgid>(tzPkgid));
+ WidgetInfo::Select::RowList rowList = select->GetRowList();
+
+ if (rowList.empty()) {
+ ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
+ "Failed to get widget by handle");
+ }
+ TizenAppId tzAppid = rowList.front().Get_tizen_appid();
+
+ return tzAppid;
}
SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed in getHandle")
}
} // namespace
-
IWacSecurity::~IWacSecurity()
-{
-}
+{}
WidgetDAOReadOnly::WidgetDAOReadOnly(DbWidgetHandle widgetHandle) :
m_widgetHandle(widgetHandle)
-{
-}
+{}
WidgetDAOReadOnly::WidgetDAOReadOnly(DPL::OptionalString widgetGUID) :
m_widgetHandle(WidgetDAOReadOnly::getHandle(widgetGUID))
-{
-}
-
-WidgetDAOReadOnly::WidgetDAOReadOnly(DPL::String pkgName) :
- m_widgetHandle(WidgetDAOReadOnly::getHandle(pkgName))
-{
+{}
-}
+WidgetDAOReadOnly::WidgetDAOReadOnly(DPL::String tzAppid) :
+ m_widgetHandle(WidgetDAOReadOnly::getHandle(tzAppid))
+{}
WidgetDAOReadOnly::~WidgetDAOReadOnly()
-{
-}
+{}
DbWidgetHandle WidgetDAOReadOnly::getHandle() const
{
if (rowList.empty()) {
ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
- "Failed to get widget by guid");
+ "Failed to get widget by guid");
}
return rowList.front().Get_app_id();
}
SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed in getHandle")
}
-DbWidgetHandle WidgetDAOReadOnly::getHandle(const DPL::String pkgName)
+DbWidgetHandle WidgetDAOReadOnly::getHandle(const DPL::String tzAppId)
{
- LogDebug("Getting WidgetHandle by Package Name [" << pkgName << "]");
+ LogDebug("Getting WidgetHandle by tizen app id [" << tzAppId << "]");
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
- select->Where(Equals<WidgetInfo::pkgname>(pkgName));
+ select->Where(Equals<WidgetInfo::tizen_appid>(tzAppId));
WidgetInfo::Select::RowList rowList = select->GetRowList();
if (rowList.empty()) {
ThrowMsg(WidgetDAOReadOnly::Exception::WidgetNotExist,
- "Failed to get widget by package name");
+ "Failed to get widget by package name");
}
return rowList.front().Get_app_id();
}
WidgetPkgName WidgetDAOReadOnly::getPkgName() const
{
- return getPkgNameByHandle(m_widgetHandle);
+ return getTzAppId();
}
WidgetPkgName WidgetDAOReadOnly::getPkgName(const WidgetGUID GUID)
{
- return getPkgNameByHandle(getHandle(GUID));
+ return getTzAppId(GUID);
}
WidgetPkgName WidgetDAOReadOnly::getPkgName(const DbWidgetHandle handle)
{
- return getPkgNameByHandle(handle);
+ return getTzAppId(handle);
+}
+
+TizenAppId WidgetDAOReadOnly::getTzAppId() const
+{
+ return getTizenAppIdByHandle(m_widgetHandle);
+}
+
+TizenAppId WidgetDAOReadOnly::getTzAppId(const WidgetGUID GUID)
+{
+ return getTizenAppIdByHandle(getHandle(GUID));
+}
+
+TizenAppId WidgetDAOReadOnly::getTzAppId(const DbWidgetHandle handle)
+{
+ return getTizenAppIdByHandle(handle);
+}
+
+TizenAppId WidgetDAOReadOnly::getTzAppId(const TizenPkgId tzPkgid)
+{
+ return getTizenAppIdByPkgId(tzPkgid);
}
PropertyDAOReadOnly::WidgetPropertyKeyList
WidgetDAOReadOnly::getPropertyKeyList() const
{
- return PropertyDAOReadOnly::GetPropertyKeyList(getPkgName());
+ return PropertyDAOReadOnly::GetPropertyKeyList(getTzAppId());
}
PropertyDAOReadOnly::WidgetPreferenceList
WidgetDAOReadOnly::getPropertyList() const
{
- return PropertyDAOReadOnly::GetPropertyList(getPkgName());
+ return PropertyDAOReadOnly::GetPropertyList(getTzAppId());
}
PropertyDAOReadOnly::WidgetPropertyValue WidgetDAOReadOnly::getPropertyValue(
- const PropertyDAOReadOnly::WidgetPropertyKey &key) const
+ const PropertyDAOReadOnly::WidgetPropertyKey &key) const
{
- return PropertyDAOReadOnly::GetPropertyValue(getPkgName(), key);
+ return PropertyDAOReadOnly::GetPropertyValue(getTzAppId(), key);
}
DPL::OptionalInt WidgetDAOReadOnly::checkPropertyReadFlag(
- const PropertyDAOReadOnly::WidgetPropertyKey &key) const
+ const PropertyDAOReadOnly::WidgetPropertyKey &key) const
{
- return PropertyDAOReadOnly::CheckPropertyReadFlag(getPkgName(), key);
+ return PropertyDAOReadOnly::CheckPropertyReadFlag(getTzAppId(), key);
}
DPL::String WidgetDAOReadOnly::getPath() const
}
WidgetLocalizedInfo
- WidgetDAOReadOnly::getLocalizedInfo(const DPL::String& languageTag)
- const
+WidgetDAOReadOnly::getLocalizedInfo(const DPL::String& languageTag)
+const
{
LogDebug("Getting Localized Info. Handle: " << m_widgetHandle);
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
RowList list = select->GetRowList();
FOREACH(i, list)
- resultMap.insert(std::make_pair(i->Get_name(), i->Get_value()));
+ resultMap.insert(std::make_pair(i->Get_name(), i->Get_value()));
return resultMap;
}
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
- return select->GetValueList<WidgetInfo::pkgname>();
+ return select->GetValueList<WidgetInfo::tizen_appid>();
}
SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get Pkgname list")
}
-WidgetPkgNameList_TEMPORARY_API WidgetDAOReadOnly::getPkgnameList_TEMPORARY_API()
+TizenAppIdList WidgetDAOReadOnly::getTizenAppidList()
{
LogDebug("Getting Pkgname List ");
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
- return select->GetValueList<WidgetInfo::pkgname>();
+ return select->GetValueList<WidgetInfo::tizen_appid>();
}
SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get Pkgname list")
}
SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to check if widget exist")
}
-bool WidgetDAOReadOnly::isWidgetInstalled(const WidgetPkgName & pkgName)
+bool WidgetDAOReadOnly::isWidgetInstalled(const TizenAppId &tzAppId)
{
- LogDebug("Checking if widget exist. package name " << pkgName);
+ LogDebug("Checking if widget exist. tizen app id" << tzAppId);
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
WRT_DB_SELECT(select, WidgetInfo, &WrtDatabase::interface())
- select->Where(Equals<WidgetInfo::pkgname>(pkgName));
+ select->Where(Equals<WidgetInfo::tizen_appid>(tzAppId));
WidgetInfo::Select::RowList rows = select->GetRowList();
}
CertificateChainList WidgetDAOReadOnly::getWidgetCertificate(
- CertificateSource source) const
+ CertificateSource source) const
{
WRT_DB_SELECT(select, WidgetCertificate, &WrtDatabase::interface())
select->Where(
CertificateChainList result;
FOREACH(iter, chainList)
- result.push_back(DPL::ToUTF8String(iter->Get_encoded_chain()));
+ result.push_back(DPL::ToUTF8String(iter->Get_encoded_chain()));
return result;
}
return row.Get_widget_id();
}
-DPL::OptionalString WidgetDAOReadOnly::getPkgname() const
+DPL::OptionalString WidgetDAOReadOnly::getTizenAppId() const
{
- return DPL::OptionalString(getPkgName());
+ return DPL::OptionalString(getTzAppId());
}
DPL::OptionalString WidgetDAOReadOnly::getDefaultlocale() const
}
}
+DPL::OptionalString WidgetDAOReadOnly::getCspPolicy() const
+{
+ WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
+ return row.Get_csp_policy();
+}
+
+DPL::OptionalString WidgetDAOReadOnly::getCspPolicyReportOnly() const
+{
+ WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
+ return row.Get_csp_policy_report_only();
+}
+
bool WidgetDAOReadOnly::getWebkitPluginsRequired() const
{
WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
DPL::OptionalInt ret = row.Get_webkit_plugins_required();
- if (ret.IsNull() || *ret == 0) { return false; } else { return true; }
+ if (ret.IsNull() || *ret == 0) {
+ return false;
+ } else { return true;
+ }
}
time_t WidgetDAOReadOnly::getInstallTime() const
SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get splash image path")
}
-WidgetDAOReadOnly::WidgetLocalizedIconList WidgetDAOReadOnly::getLocalizedIconList() const
+WidgetDAOReadOnly::WidgetLocalizedIconList WidgetDAOReadOnly::
+ getLocalizedIconList() const
{
//TODO check widget existance??
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
select->Where(Equals<WidgetLocalizedIcon::app_id>(m_widgetHandle));
std::list<WidgetLocalizedIcon::Row> list =
- select->GetRowList();
+ select->GetRowList();
WidgetLocalizedIconList ret;
- FOREACH(it,list)
+ FOREACH(it, list)
{
- WidgetLocalizedIconRow icon = {it->Get_app_id(),
- it->Get_icon_id(),
- it->Get_widget_locale()};
+ WidgetLocalizedIconRow icon = { it->Get_app_id(),
+ it->Get_icon_id(),
+ it->Get_widget_locale() };
ret.push_back(icon);
}
return ret;
{
WRT_DB_SELECT(select, wrt::WidgetIcon, &WrtDatabase::interface())
select->Where(Equals<wrt::WidgetIcon::app_id>(m_widgetHandle));
+ select->OrderBy(DPL::TypeListDecl<OrderingAscending<wrt::WidgetIcon::
+ icon_id> >());
std::list<WidgetIcon::Row> list =
- select->GetRowList();
+ select->GetRowList();
WidgetIconList ret;
- FOREACH(it,list)
+ FOREACH(it, list)
{
- WidgetIconRow icon = {it->Get_icon_id(),
- it->Get_app_id(),
- it->Get_icon_src(),
- it->Get_icon_width(),
- it->Get_icon_height()};
+ WidgetIconRow icon = { it->Get_icon_id(),
+ it->Get_app_id(),
+ it->Get_icon_src(),
+ it->Get_icon_width(),
+ it->Get_icon_height() };
ret.push_back(icon);
}
return ret;
SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get icon data")
}
-WidgetDAOReadOnly::LocalizedStartFileList WidgetDAOReadOnly::getLocalizedStartFileList() const
+WidgetDAOReadOnly::LocalizedStartFileList WidgetDAOReadOnly::
+ getLocalizedStartFileList() const
{
//TODO check widget existance
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
select->OrderBy("start_file_id ASC");
std::list<WidgetLocalizedStartFile::Row> list =
- select->GetRowList();
+ select->GetRowList();
LocalizedStartFileList ret;
- FOREACH(it,list)
+ FOREACH(it, list)
{
- WidgetLocalizedStartFileRow file = {it->Get_start_file_id(),
- it->Get_app_id(),
- it->Get_widget_locale(),
- it->Get_type(),
- it->Get_encoding()};
+ WidgetLocalizedStartFileRow file = { it->Get_start_file_id(),
+ it->Get_app_id(),
+ it->Get_widget_locale(),
+ it->Get_type(),
+ it->Get_encoding() };
ret.push_back(file);
}
return ret;
SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get start file list data")
}
-WidgetDAOReadOnly::WidgetStartFileList WidgetDAOReadOnly::getStartFileList() const
+WidgetDAOReadOnly::WidgetStartFileList WidgetDAOReadOnly::getStartFileList()
+const
{
//TODO check widget existance
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
select->OrderBy("start_file_id ASC");
std::list<WidgetStartFile::Row> list =
- select->GetRowList();
+ select->GetRowList();
WidgetStartFileList ret;
- FOREACH(it,list)
+ FOREACH(it, list)
{
- WidgetStartFileRow file = {it->Get_start_file_id(),
- it->Get_app_id(),
- it->Get_src()};
+ WidgetStartFileRow file = { it->Get_start_file_id(),
+ it->Get_app_id(),
+ it->Get_src() };
ret.push_back(file);
}
return ret;
//TODO check widget existance
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- WRT_DB_SELECT(select, WidgetCertificateFingerprint, &WrtDatabase::interface())
+ WRT_DB_SELECT(select,
+ WidgetCertificateFingerprint,
+ &WrtDatabase::interface())
select->Where(Equals<WidgetCertificateFingerprint::app_id>(
m_widgetHandle));
select->OrderBy("chainid");
}
FingerPrintList WidgetDAOReadOnly::getKeyFingerprints(
- WidgetCertificateData::Owner owner,
- WidgetCertificateData::Type type) const
+ WidgetCertificateData::Owner owner,
+ WidgetCertificateData::Type type) const
{
//TODO check widget existance
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- WRT_DB_SELECT(select, WidgetCertificateFingerprint, &WrtDatabase::interface())
+ WRT_DB_SELECT(select,
+ WidgetCertificateFingerprint,
+ &WrtDatabase::interface())
select->Where(And(And(
- Equals<WidgetCertificateFingerprint::app_id>(m_widgetHandle),
- Equals<WidgetCertificateFingerprint::owner>(owner)),
- Equals<WidgetCertificateFingerprint::type>(type)));
+ Equals<WidgetCertificateFingerprint::app_id>(
+ m_widgetHandle),
+ Equals<WidgetCertificateFingerprint::owner>(owner)),
+ Equals<WidgetCertificateFingerprint::type>(type)));
WidgetCertificateFingerprint::Select::RowList rows =
select->GetRowList();
}
WidgetCertificateCNList WidgetDAOReadOnly::getKeyCommonNameList(
- WidgetCertificateData::Owner owner,
- WidgetCertificateData::Type type) const
+ WidgetCertificateData::Owner owner,
+ WidgetCertificateData::Type type) const
{
//TODO check widget existance
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
{
- WRT_DB_SELECT(select, WidgetCertificateFingerprint, &WrtDatabase::interface())
+ WRT_DB_SELECT(select,
+ WidgetCertificateFingerprint,
+ &WrtDatabase::interface())
select->Where(And(And(
- Equals<WidgetCertificateFingerprint::app_id>(m_widgetHandle),
- Equals<WidgetCertificateFingerprint::owner>(owner)),
- Equals<WidgetCertificateFingerprint::type>(type)));
+ Equals<WidgetCertificateFingerprint::app_id>(
+ m_widgetHandle),
+ Equals<WidgetCertificateFingerprint::owner>(owner)),
+ Equals<WidgetCertificateFingerprint::type>(type)));
WidgetCertificateFingerprint::Select::RowList rows =
select->GetRowList();
}
ResourceAttributeList WidgetDAOReadOnly::getResourceAttribute(
- const std::string &resourceId) const
+ const std::string &resourceId) const
{
WRT_DB_SELECT(select, WidgetFeature, &WrtDatabase::interface())
select->Where(And(Equals<WidgetFeature::app_id>(m_widgetHandle),
WidgetParamMap map = getFeatureParams(widgetFeatureId);
FOREACH(i, map)
- result.push_back(DPL::ToUTF8String(i->first));
+ result.push_back(DPL::ToUTF8String(i->first));
}
return result;
}
void WidgetDAOReadOnly::getWidgetAccessInfo(
- WidgetAccessInfoList& outAccessInfoList) const
+ WidgetAccessInfoList& outAccessInfoList) const
{
//TODO check widget existance
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
using namespace WrtDB::WidgetConfig;
std::ostringstream path;
- WidgetPkgName pkgname = getPkgName();
+ TizenAppId tzAppId = getTzAppId();
- path << GetWidgetPersistentStoragePath(pkgname);
+ path << GetWidgetPersistentStoragePath(tzAppId);
path << "/";
path << GlobalConfig::GetCookieDatabaseFile();
std::string WidgetDAOReadOnly::getPrivateLocalStoragePath() const
{
std::ostringstream path;
- WidgetPkgName pkgname = getPkgName();
- path << WidgetConfig::GetWidgetWebLocalStoragePath(pkgname);
+ TizenAppId tzAppId = getTzAppId();
+ path << WidgetConfig::GetWidgetWebLocalStoragePath(tzAppId);
path << "/";
return path.str();
}
void WidgetDAOReadOnly::getWidgetSettings(
- WidgetSettings& outWidgetSettings) const
+ WidgetSettings& outWidgetSettings) const
{
//TODO check widget existance
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
}
void WidgetDAOReadOnly::getAppServiceList(
- WidgetApplicationServiceList& outAppServiceList) const
+ WidgetApplicationServiceList& outAppServiceList) const
{
LogDebug("Getting getAppServiceList. Handle: " << m_widgetHandle);
SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
ret.operation = it->Get_operation();
ret.scheme = it->Get_scheme();
ret.mime = it->Get_mime();
+ ret.disposition = static_cast<WidgetApplicationService::Disposition>(it->Get_disposition());
outAppServiceList.push_back(ret);
}
return PackagingType(static_cast<PkgType>(*result));
}
-void WidgetDAOReadOnly::getEncryptedFileList(EncryptedFileList& filesList) const
+void WidgetDAOReadOnly::getEncryptedFileList(EncryptedFileList& filesList)
+const
{
//TODO check widget existance
WRT_DB_SELECT(select, EncryptedResourceList, &WrtDatabase::interface())
SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get background page")
}
-WidgetPkgName WidgetDAOReadOnly::generateTizenId() {
+TizenPkgId WidgetDAOReadOnly::generatePkgId()
+{
std::string allowed("0123456789"
- "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
- "abcdefghijklmnopqrstuvwxyz");
- WidgetPkgName tizenId;
- tizenId.resize(MAX_TIZENID_LENGTH);
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+ "abcdefghijklmnopqrstuvwxyz");
+ TizenPkgId pkgId;
+ pkgId.resize(MAX_TIZENID_LENGTH);
do {
- for (int i = 0; i < MAX_TIZENID_LENGTH; ++i) {
- tizenId[i] = allowed[rand() % allowed.length()];
- }
- } while (isWidgetInstalled(tizenId));
- return tizenId;
+ for (int i = 0; i < MAX_TIZENID_LENGTH; ++i) {
+ pkgId[i] = allowed[rand_r(&seed) % allowed.length()];
+ }
+ } while (isWidgetInstalled(pkgId));
+ return pkgId;
}
SettingsType WidgetDAOReadOnly::getSecurityPopupUsage(void) const
}
SQL_CONNECTION_EXCEPTION_HANDLER_END("Failed to get widdget installed path")
}
+
+TizenPkgId WidgetDAOReadOnly::getTizenPkgId() const
+{
+ WidgetInfoRow row = getWidgetInfoRow(m_widgetHandle);
+ return row.Get_tizen_pkgid();
+}
+
#undef SQL_CONNECTION_EXCEPTION_HANDLER_BEGIN
#undef SQL_CONNECTION_EXCEPTION_HANDLER_END
#undef CHECK_WIDGET_EXISTENCE
-
} // namespace WrtDB
* limitations under the License.
*/
#ifndef WRT_SRC_CONFIGURATION_WRTDATABASE_H_
-#define WRT_SRC_CONFIGURATION_WRTDATABASE_H_
+#define WRT_SRC_CONFIGURATION_WRTDATABASE_H_
#include <dpl/db/thread_database_support.h>
namespace WrtDB {
-
class WrtDatabase
{
public:
private:
static DPL::DB::ThreadDatabaseSupport m_interface;
};
-
}
#endif /* WRTDATABASE_H */
#include <memory>
#include <dpl/optional_typedefs.h>
-
namespace WrtDB {
class PluginMetafileData
{
public:
PluginMetafileData()
- {
- }
+ {}
std::string m_libraryName;
FeatureContainer m_featureContainer;
* FindWidgetModel routine.
*/
typedef int DbWidgetHandle;
+typedef DPL::String TizenPkgId;
+typedef DPL::String TizenAppId;
typedef DPL::String WidgetPkgName;
/**
DPL::OptionalInt height;
DbWidgetSize(DPL::OptionalInt w = DPL::OptionalInt::Null,
- DPL::OptionalInt h = DPL::OptionalInt::Null) :
+ DPL::OptionalInt h = DPL::OptionalInt::Null) :
width(w),
height(h)
- {
- }
+ {}
};
inline bool operator ==(const DbWidgetSize &objA, const DbWidgetSize &objB)
DbWidgetFeature() :
required(false),
pluginId(INVALID_PLUGIN_HANDLE)
- {
- }
+ {}
};
inline bool operator < (const DbWidgetFeature &objA,
- const DbWidgetFeature &objB)
+ const DbWidgetFeature &objB)
{
return objA.name.compare(objB.name) < 0;
}
inline bool operator==(const DbWidgetFeature &featureA,
- const DbWidgetFeature &featureB)
+ const DbWidgetFeature &featureB)
{
return featureA.name == featureB.name &&
featureA.required == featureB.required &&
*/
typedef std::list<DbWidgetHandle> DbWidgetHandleList;
-typedef std::list<WidgetPkgName> WidgetPkgNameList; //TODO: this cannot be null -> appropriate changes in db schema needed
-typedef std::list<WidgetPkgName> WidgetPkgNameList_TEMPORARY_API; //TODO: this cannot be null -> appropriate changes in db schema needed
+typedef std::list<WidgetPkgName> WidgetPkgNameList; //TODO: this cannot be null
+ // -> appropriate changes in
+ // db schema needed
+typedef std::list<TizenAppId> TizenAppIdList; //TODO: this cannot be null ->
+ // appropriate changes in db
+ // schema needed
class WidgetDAOReadOnly; //forward declaration
typedef std::shared_ptr<WidgetDAOReadOnly> WidgetDAOReadOnlyPtr;
class WidgetType
{
public:
- WidgetType()
- :appType(APP_TYPE_UNKNOWN)
- {
- }
- WidgetType(const AppType type)
- :appType(type)
- {
- }
+ WidgetType() :
+ appType(APP_TYPE_UNKNOWN)
+ {}
+ WidgetType(const AppType type) :
+ appType(type)
+ {}
bool operator== (const AppType& other) const
{
return appType == other;
{
switch (appType) {
#define X(x) case x: return #x;
- X(APP_TYPE_UNKNOWN)
- X(APP_TYPE_WAC20)
- X(APP_TYPE_TIZENWEBAPP)
+ X(APP_TYPE_UNKNOWN)
+ X(APP_TYPE_WAC20)
+ X(APP_TYPE_TIZENWEBAPP)
#undef X
default:
return "UNKNOWN";
class PackagingType
{
public:
- PackagingType()
- :pkgType(PKG_TYPE_UNKNOWN)
- {
- }
- PackagingType(const PkgType type)
- :pkgType(type)
- {
- }
+ PackagingType() :
+ pkgType(PKG_TYPE_UNKNOWN)
+ {}
+ PackagingType(const PkgType type) :
+ pkgType(type)
+ {}
bool operator== (const PkgType& other) const
{
return pkgType == other;
{
switch (pkgType) {
#define X(x) case x: return #x;
- X(PKG_TYPE_UNKNOWN)
- X(PKG_TYPE_NOMAL_WEB_APP)
- X(PKG_TYPE_DIRECTORY_WEB_APP)
- X(PKG_TYPE_HOSTED_WEB_APP)
- X(PKG_TYPE_HYBRID_WEB_APP)
+ X(PKG_TYPE_UNKNOWN)
+ X(PKG_TYPE_NOMAL_WEB_APP)
+ X(PKG_TYPE_DIRECTORY_WEB_APP)
+ X(PKG_TYPE_HOSTED_WEB_APP)
+ X(PKG_TYPE_HYBRID_WEB_APP)
#undef X
default:
return "UNKNOWN";
bool operator ==(const WidgetSetting& info) const
{
return (info.settingName == settingName &&
- info.settingValue == settingValue);
+ info.settingValue == settingValue);
}
bool operator !=(const WidgetSetting& info) const
{
return (info.settingName != settingName ||
- info.settingValue != settingValue);
+ info.settingValue != settingValue);
}
};
*/
struct WidgetApplicationService
{
- public:
+ enum class Disposition {
+ WINDOW = 0,
+ INLINE
+ };
+
DPL::String src; /* start uri */
DPL::String operation; /* service name */
DPL::String scheme; /* scheme type*/
DPL::String mime; /* mime type */
+ Disposition disposition;
bool operator== (const WidgetApplicationService& other) const
{
return src == other.src &&
- operation == other.operation &&
- scheme == other.scheme &&
- mime == other.mime;
+ operation == other.operation &&
+ scheme == other.scheme &&
+ mime == other.mime &&
+ disposition == other.disposition;
}
};
#include <ctype.h>
namespace WrtDB {
-
-void NormalizeString(DPL::OptionalString& txt);
+void NormalizeString(DPL::OptionalString& txt, bool isTrimSpace = false);
void NormalizeString(DPL::String& str);
DPL::String GetSingleAttributeValue(const DPL::String value);
+void NormalizeAndTrimSpaceString(DPL::OptionalString& txt);
class WidgetConfigurationManager;
struct Param
{
Param(const DPL::String& _name) : name(_name)
- {
- }
+ {}
DPL::String name;
DPL::String value;
bool operator==(const Param&) const;
Feature(const DPL::String& _name,
bool _required = true) : name(_name),
required(_required)
- {
- }
+ {}
DPL::String name;
bool required;
ParamsList paramsList;
struct Privilege
{
Privilege(const DPL::String& _name) : name(_name)
- {
- }
+ {}
DPL::String name;
bool operator==(const Privilege&) const;
struct Icon
{
Icon(const DPL::String& _src) : src(_src)
- {
- }
+ {}
DPL::String src;
DPL::OptionalInt width;
DPL::OptionalInt height;
struct Preference
{
Preference(const DPL::String& _name,
- bool _readonly = false) :
+ bool _readonly = false) :
name(_name),
value(),
readonly(_readonly)
- {
- }
+ {}
DPL::String name;
DPL::OptionalString value;
bool readonly;
struct AccessInfo
{
AccessInfo(const DPL::String& strIRI,
- bool bSubdomainAccess) : m_strIRI(strIRI),
+ bool bSubdomainAccess) : m_strIRI(strIRI),
m_bSubDomainAccess(bSubdomainAccess)
- {
- }
+ {}
bool operator==(const AccessInfo&) const;
bool operator!=(const AccessInfo&) const;
{
Setting(const DPL::String& name,
const DPL::String& value) :
- m_name(name),
- m_value(value)
- {
- }
+ m_name(name),
+ m_value(value)
+ {}
DPL::String m_name;
DPL::String m_value;
*/
struct ServiceInfo
{
+ enum class Disposition {
+ WINDOW = 0,
+ INLINE
+ };
ServiceInfo(
const DPL::String& src,
const DPL::String& operation,
const DPL::String& scheme,
- const DPL::String& mime) :
+ const DPL::String& mime,
+ const Disposition dispos) :
m_src(src),
m_operation(operation),
m_scheme(scheme),
- m_mime(mime)
- {
- }
+ m_mime(mime),
+ m_disposition(dispos)
+ {}
DPL::String m_src;
DPL::String m_operation;
DPL::String m_scheme;
DPL::String m_mime;
+ Disposition m_disposition;
bool operator==(const ServiceInfo&) const;
bool operator!=(const ServiceInfo&) const;
AppControlInfo(
const DPL::String& operation) :
m_operation(operation)
- {
- }
+ {}
DPL::String m_src;
DPL::String m_operation;
std::set <DPL::String> m_uriList;
typedef std::list<ServiceInfo> ServiceInfoList; // It will be removed.
typedef std::list<AppControlInfo> AppControlInfoList;
- typedef std::list<std::pair<DPL::String, DPL::String>> BoxSizeList;
+ typedef std::list<std::pair<DPL::String, DPL::String> > BoxSizeList;
struct LiveboxInfo
{
struct BoxContent
{
DPL::String m_boxSrc;
- BoxSizeList m_boxSize ;
+ DPL::String m_boxMouseEvent;
+ BoxSizeList m_boxSize;
DPL::String m_pdSrc;
DPL::String m_pdWidth;
DPL::String m_pdHeight;
- }; typedef BoxContent BoxContentInfo;
+ };
+ typedef BoxContent BoxContentInfo;
DPL::String m_label;
DPL::String m_icon;
DPL::String m_liveboxId;
DPL::String m_primary;
+ DPL::String m_type;
DPL::String m_autoLaunch;
DPL::String m_updatePeriod;
BoxContentInfo m_boxInfo;
bool operator <(const LiveboxInfo&) const;
bool operator<=(const LiveboxInfo&) const;
};
- typedef std::list<DPL::Optional<LiveboxInfo>> LiveboxList;
+ typedef std::list<DPL::Optional<LiveboxInfo> > LiveboxList;
LiveboxList m_livebox;
typedef std::list<DPL::OptionalString> DependsPkgList;
IconsList iconsList;
// tizen id / required platform min version for TIZEN webapp
- DPL::OptionalString tizenId;
DPL::OptionalString tizenMinVersionRequired;
+ DPL::OptionalString tizenPkgId;
+ DPL::OptionalString tizenAppId;
+
+ //csp polic for widget
+ DPL::OptionalString cspPolicy;
+ DPL::OptionalString cspPolicyReportOnly;
//Application service model list
ServiceInfoList appServiceList; //It will be removed.
backSupported(false),
accessNetwork(false),
startFileEncountered(false)
- {
- }
+ {}
};
-
} // namespace WrtDB
#endif //CONFIG_PARSER_DATA_H_
#include <dpl/wrt-dao-ro/WrtDatabase.h>
namespace WrtDB {
-
class FeatureDAOReadOnly
{
public:
FeatureDAOReadOnly(const std::string &featureName);
static FeatureHandleListPtr GetFeatureHandleListForPlugin(
- DbPluginHandle pluginHandle);
+ DbPluginHandle pluginHandle);
static bool isFeatureInstalled(const std::string &featureName);
static bool isFeatureInstalled(FeatureHandle handle);
protected:
FeatureHandle m_featureHandle;
};
-
} // namespace WrtDB
#endif /* WRT_SRC_CONFIGURATION_FEATURE_DAO_READ_ONLY_H_ */
#include <dpl/wrt-dao-ro/common_dao_types.h>
namespace WrtDB {
-
typedef int FeatureHandle;
typedef std::list<FeatureHandle> FeatureHandleList;
typedef std::shared_ptr<FeatureHandleList> FeatureHandleListPtr;
typedef std::list<FeatureSetHandle> FeatureSetHandleList;
typedef struct {
- std::string featureName;
- DbPluginHandle pluginHandle;
+ std::string featureName;
+ DbPluginHandle pluginHandle;
} FeatureData;
class FeatureModel : public DPL::Event::Model
Name(this),
DeviceCapabilities(this),
PHandle(this, -1)
- {
- }
+ {}
- void SetData(const std::string& name, const std::set<std::string>& deviceCapabilities, const DbPluginHandle& pluginHandle)
+ void SetData(const std::string& name,
+ const std::set<std::string>& deviceCapabilities,
+ const DbPluginHandle& pluginHandle)
{
Name.SetWithoutLock(name);
DeviceCapabilities.SetWithoutLock(deviceCapabilities);
};
typedef std::shared_ptr<FeatureModel> FeatureModelPtr;
-
} // namespace WrtDB
#endif // FEATURE_MODEL_H
*/
inline const char* GetUserPreloadedWidgetPath()
{
- return "/usr/apps";
+ // temp
+ // return "/usr/apps";
+
+ return "/opt/usr/apps";
}
/**
inline const char* GetTizenVersion()
{
- return "1.0";
+ return "2.1";
}
inline const char* GetShareDirectoryPath()
{
return "/memory_saving_mode";
}
-
} // namespace GlobalConfig
} // namespace WrtDB
#include <dpl/wrt-dao-ro/common_dao_types.h>
namespace WrtDB {
-
typedef std::list<DPL::String> WidgetPackageList;
typedef std::set<DPL::String> DeviceCapabilitySet;
* This method returns set of device capabilities used by apifeature.
*/
static DeviceCapabilitySet GetDeviceCapability(
- const DPL::String &apifeature);
+ const DPL::String &apifeature);
protected:
GlobalDAOReadOnly()
- {
- }
+ {}
};
-
} // namespace WrtDB
#endif // WRT_SRC_CONFIGURATION_GLOBAL_DAO_READ_ONLY_H_
#include <dpl/noncopyable.h>
namespace WrtDB {
-
class PathBuilderImpl;
class PathBuilder : private DPL::Noncopyable
private:
PathBuilderImpl* m_impl;
};
-
} // namespace WrtDB
#endif
* @brief This file contains the declaration of plugin dao read only
*/
-
#ifndef WRT_SRC_CONFIGURATION_PLUGIN_DAO_READ_ONLY_H_
#define WRT_SRC_CONFIGURATION_PLUGIN_DAO_READ_ONLY_H_
#include <dpl/wrt-dao-ro/common_dao_types.h>
namespace WrtDB {
-
typedef std::list<DbPluginHandle> PluginHandleList;
typedef std::set<DbPluginHandle> PluginHandleSet;
typedef std::list<std::string> ImplementedObjectsList;
static bool isPluginInstalled(DbPluginHandle pluginHandle);
static PluginHandleSetPtr getPluginHandleByStatus(
- PluginInstallationState state);
+ PluginInstallationState state);
static DbPluginHandle getPluginHandleForImplementedObject(
- const std::string& objectName);
+ const std::string& objectName);
static ImplementedObjectsList getImplementedObjectsForPluginHandle(
- DbPluginHandle handle);
+ DbPluginHandle handle);
static PluginObjectsDAO::ObjectsPtr getRequiredObjectsForPluginHandle(
- DbPluginHandle handle);
+ DbPluginHandle handle);
static PluginInstallationState getInstallationStateForHandle(
- DbPluginHandle handle);
+ DbPluginHandle handle);
DbPluginHandle getPluginHandle() const;
PluginInstallationState getInstallationStatus() const;
void checkInstallationCompleted();
};
-
} // namespace WrtDB
#endif /* WRT_SRC_CONFIGURATION_PLUGIN_DAO_READ_ONLY_H_ */
namespace WrtDB {
namespace PropertyDAOReadOnly {
-
typedef DPL::String WidgetPropertyKey;
typedef DPL::OptionalString WidgetPropertyValue;
typedef std::list<WidgetPropertyKey> WidgetPropertyKeyList;
struct WidgetPreferenceRow {
- WidgetPkgName pkgname;
- WidgetPropertyKey key_name;
+ TizenAppId tizen_appid;
+ WidgetPropertyKey key_name;
WidgetPropertyValue key_value;
- DPL::OptionalInt readonly;
+ DPL::OptionalInt readonly;
};
typedef std::list<WidgetPreferenceRow> WidgetPreferenceList;
/* This method checks read only flag for given property
*/
DPL::OptionalInt CheckPropertyReadFlag(DbWidgetHandle widgetHandle,
- const WidgetPropertyKey &key)
- __attribute__((deprecated));
+ const WidgetPropertyKey &key)
+__attribute__((deprecated));
/* This method checks read only flag for given property
*/
-DPL::OptionalInt CheckPropertyReadFlag(WidgetPkgName pkgName,
- const WidgetPropertyKey &key);
-
-//deprecated
-/* This method gets widget property key list
- */
-WidgetPropertyKeyList GetPropertyKeyList(DbWidgetHandle widgetHandle)
- __attribute__((deprecated));
+DPL::OptionalInt CheckPropertyReadFlag(TizenAppId tzAppid,
+ const WidgetPropertyKey &key);
/* This method gets widget property key list
*/
-WidgetPropertyKeyList GetPropertyKeyList(WidgetPkgName pkgName);
+WidgetPropertyKeyList GetPropertyKeyList(TizenAppId tzAppid);
//deprecated
/* This method gets widget property list
*/
WidgetPreferenceList GetPropertyList(DbWidgetHandle widgetHandle)
- __attribute__((deprecated));
+__attribute__((deprecated));
/* This method gets widget property list
*/
-WidgetPreferenceList GetPropertyList(WidgetPkgName pkgName);
+WidgetPreferenceList GetPropertyList(TizenAppId tzAppid);
-//deprecated
/* This method get widget property value
*/
-WidgetPropertyValue GetPropertyValue(DbWidgetHandle widgetHandle,
+WidgetPropertyValue GetPropertyValue(TizenAppId tzAppid,
const WidgetPropertyKey &key);
-
-/* This method get widget property value
- */
-WidgetPropertyValue GetPropertyValue(WidgetPkgName pkgName,
- const WidgetPropertyKey &key);
-
} // PropertyDAOReadOnly
} // namespace WrtDB
namespace WrtDB {
namespace VconfConfig {
-inline std::string GetVconfKeyRootPath(DPL::String pkgName)
+inline std::string GetVconfKeyRootPath(DPL::String tzPkgId)
{
return PathBuilder()
.Append(GlobalConfig::GetVconfKeyPrefixPath())
- .Append(DPL::ToUTF8String(pkgName))
+ .Append(DPL::ToUTF8String(tzPkgId))
.GetFullPath();
}
-inline std::string GetVconfKeyPopupUsage(DPL::String pkgName)
+inline std::string GetVconfKeyPopupUsage(DPL::String tzPkgId)
{
return PathBuilder()
.Append(GlobalConfig::GetVconfKeyPrefixPath())
- .Append(DPL::ToUTF8String(pkgName))
+ .Append(DPL::ToUTF8String(tzPkgId))
.Concat(GlobalConfig::GetVconfKeyPopupUsagePath())
.GetFullPath();
}
-inline std::string GetVconfKeyGeolocationUsage(DPL::String pkgName)
+inline std::string GetVconfKeyGeolocationUsage(DPL::String tzPkgId)
{
return PathBuilder()
.Append(GlobalConfig::GetVconfKeyPrefixPath())
- .Append(DPL::ToUTF8String(pkgName))
+ .Append(DPL::ToUTF8String(tzPkgId))
.Concat(GlobalConfig::GetVconfKeyGeolocationUsagePath())
.GetFullPath();
}
-inline std::string GetVconfKeyWebNotificationUsage(DPL::String pkgName)
+inline std::string GetVconfKeyWebNotificationUsage(DPL::String tzPkgId)
{
return PathBuilder()
.Append(GlobalConfig::GetVconfKeyPrefixPath())
- .Append(DPL::ToUTF8String(pkgName))
+ .Append(DPL::ToUTF8String(tzPkgId))
.Concat(GlobalConfig::GetVconfKeyWebNotificationUsagePath())
.GetFullPath();
}
-inline std::string GetVconfKeyWebDatabaseUsage(DPL::String pkgName)
+inline std::string GetVconfKeyMemorySavingMode(DPL::String tzPkgId)
{
return PathBuilder()
.Append(GlobalConfig::GetVconfKeyPrefixPath())
- .Append(DPL::ToUTF8String(pkgName))
- .Concat(GlobalConfig::GetVconfKeyWebDatabaseUsagePath())
- .GetFullPath();
-}
-
-inline std::string GetVconfKeyFilesystemUsage(DPL::String pkgName)
-{
- return PathBuilder()
- .Append(GlobalConfig::GetVconfKeyPrefixPath())
- .Append(DPL::ToUTF8String(pkgName))
- .Concat(GlobalConfig::GetVconfKeyFilesystemUsagePath())
- .GetFullPath();
-}
-
-inline std::string GetVconfKeyMemorySavingMode(DPL::String pkgName)
-{
- return PathBuilder()
- .Append(GlobalConfig::GetVconfKeyPrefixPath())
- .Append(DPL::ToUTF8String(pkgName))
+ .Append(DPL::ToUTF8String(tzPkgId))
.Concat(GlobalConfig::GetVconfKeyMemorySavingModePath())
.GetFullPath();
}
-
} // namespace VconfConfig
} // namespace WrtDB
extern DPL::Mutex g_wrtDbQueriesMutex;
#define WRT_DB_INTERNAL(tlsCommand, InternalType, interface) \
- static DPL::ThreadLocalVariable<InternalType> *tlsCommand ## Ptr = NULL; \
+ static DPL::ThreadLocalVariable<InternalType> *tlsCommand##Ptr = NULL; \
{ \
DPL::Mutex::ScopedLock lock(&g_wrtDbQueriesMutex); \
- if (!tlsCommand ## Ptr) { \
+ if (!tlsCommand##Ptr) { \
static DPL::ThreadLocalVariable<InternalType> tmp; \
- tlsCommand ## Ptr = &tmp; \
+ tlsCommand##Ptr = &tmp; \
} \
} \
- DPL::ThreadLocalVariable<InternalType> &tlsCommand = *tlsCommand ## Ptr; \
+ DPL::ThreadLocalVariable<InternalType> &tlsCommand = *tlsCommand##Ptr; \
if (tlsCommand.IsNull()) { tlsCommand = InternalType(interface); }
-#define WRT_DB_SELECT(name, type, interface) WRT_DB_INTERNAL(name, type::Select, interface)
+#define WRT_DB_SELECT(name, type, interface) WRT_DB_INTERNAL(name, \
+ type::Select, \
+ interface)
-#define WRT_DB_INSERT(name, type, interface) WRT_DB_INTERNAL(name, type::Insert, interface)
+#define WRT_DB_INSERT(name, type, interface) WRT_DB_INTERNAL(name, \
+ type::Insert, \
+ interface)
-#define WRT_DB_UPDATE(name, type, interface) WRT_DB_INTERNAL(name, type::Update, interface)
+#define WRT_DB_UPDATE(name, type, interface) WRT_DB_INTERNAL(name, \
+ type::Update, \
+ interface)
-#define WRT_DB_DELETE(name, type, interface) WRT_DB_INTERNAL(name, type::Delete, interface)
+#define WRT_DB_DELETE(name, type, interface) WRT_DB_INTERNAL(name, \
+ type::Delete, \
+ interface)
#endif // WRT_ENGINE_SRC_CONFIGURATION_WEBRUNTIME_DATABASE_H
namespace WrtDB {
namespace WidgetConfig {
-
-inline std::string GetWidgetBasePath(DPL::String pkgName)
+inline std::string GetWidgetBasePath(DPL::String tzPkgId)
{
return PathBuilder()
.Append(GlobalConfig::GetWidgetUserDataPath())
- .Append(DPL::ToUTF8String(pkgName))
+ .Append(DPL::ToUTF8String(tzPkgId))
.GetFullPath();
}
-inline std::string GetWidgetWebLocalStoragePath(DPL::String pkgName)
+inline std::string GetWidgetWebLocalStoragePath(DPL::String tzPkgId)
{
- return PathBuilder(GetWidgetBasePath(pkgName))
+ return PathBuilder(GetWidgetBasePath(tzPkgId))
.Append(GlobalConfig::GetWidgetLocalStoragePath())
.GetFullPath();
}
-inline std::string GetWidgetPersistentStoragePath(DPL::String pkgName)
+inline std::string GetWidgetPersistentStoragePath(DPL::String tzPkgId)
{
- return PathBuilder(GetWidgetBasePath(pkgName))
+ return PathBuilder(GetWidgetBasePath(tzPkgId))
.Append(GlobalConfig::GetWidgetPrivateStoragePath())
.GetFullPath();
}
-inline std::string GetWidgetTemporaryStoragePath(DPL::String pkgName)
+inline std::string GetWidgetTemporaryStoragePath(DPL::String tzPkgId)
{
return PathBuilder()
.Append(GlobalConfig::GetTmpDirPath())
- .Append(DPL::ToUTF8String(pkgName))
+ .Append(DPL::ToUTF8String(tzPkgId))
.GetFullPath();
}
-inline std::string GetWidgetDesktopFilePath(DPL::String pkgName)
+inline std::string GetWidgetDesktopFilePath(DPL::String tzPkgId)
{
return PathBuilder()
.Append(GlobalConfig::GetUserWidgetDesktopPath())
- .Append(DPL::ToUTF8String(pkgName))
+ .Append(DPL::ToUTF8String(tzPkgId))
.Concat(".desktop")
.GetFullPath();
}
#include <dpl/wrt-dao-ro/common_dao_types.h>
namespace WrtDB {
-
/**
* Widget's signature enum.
* This enumerates signature type of widget.
// Common name field in certificate
DPL::String strCommonName;
- bool operator== (const WidgetCertificateData& certData) const {
+ bool operator== (const WidgetCertificateData& certData) const
+ {
return certData.chainId == chainId &&
- certData.owner == owner &&
- certData.strCommonName == strCommonName &&
- certData.strMD5Fingerprint == strMD5Fingerprint &&
- certData.strSHA1Fingerprint == strSHA1Fingerprint;
+ certData.owner == owner &&
+ certData.strCommonName == strCommonName &&
+ certData.strMD5Fingerprint == strMD5Fingerprint &&
+ certData.strSHA1Fingerprint == strSHA1Fingerprint;
}
};
struct LocalizedIcon : public ConfigParserData::Icon
{
LocalizedIcon(const ConfigParserData::Icon& icon,
- const LocaleSet& _availableLocales) :
+ const LocaleSet& _availableLocales) :
ConfigParserData::Icon(icon),
availableLocales(_availableLocales)
- {
- }
+ {}
LocaleSet availableLocales;
};
isTestWidget(0),
configInfo(),
packagingType(PKG_TYPE_UNKNOWN)
- {
- }
+ {}
WidgetType webAppType;
- WidgetType type; // TODO : This type will be removed.
DPL::OptionalString guid;
DPL::OptionalString version;
DPL::OptionalString minVersion;
ConfigParserData configInfo;
LocalizationData localizationData;
- DPL::OptionalString pkgname;
- WidgetPkgName pkgName;
+ TizenPkgId tzPkgid;
+ TizenAppId tzAppid;
time_t installedTime;
PackagingType packagingType;
virtual bool isWacSigned() const = 0;
virtual void getCertificateChainList(CertificateChainList& list,
- CertificateSource source) const = 0;
+ CertificateSource source) const = 0;
};
/**
*/
WidgetDAOReadOnly(DbWidgetHandle widgetHandle);
WidgetDAOReadOnly(DPL::OptionalString widgetGUID);
- WidgetDAOReadOnly(DPL::String pkgName);
+ WidgetDAOReadOnly(DPL::String tzAppid);
/**
* Destructor
*
* @return widget handle(m_widgetHandle).
* @exception WRT_CONF_ERR_EMDB_FAILURE - Fail to query DB table.
- * @exception WRT_CONF_ERR_EMDB_NO_RECORD - Can not find matching records in DB table.
+ * @exception WRT_CONF_ERR_EMDB_NO_RECORD - Can not find matching records in
+ * DB table.
*/
DbWidgetHandle getHandle() const;
static DbWidgetHandle getHandle(const WidgetGUID GUID);
static DbWidgetHandle getHandle(const DPL::String pkgName);
/**
- * Returns pkgname for the specified widget
+ * Returns tizenAppId for the specified widget
+ *
+ * @return tzAppid;
+ * @exception WRT_CONF_ERR_EMDB_FAILURE - Fail to query DB table.
+ * @exception WRT_CONF_ERR_EMDB_NO_RECORD - Can not find matching records in
+ * DB table.
+ */
+
+ TizenAppId getTzAppId() const;
+ static TizenAppId getTzAppId(const WidgetGUID GUID);
+ static TizenAppId getTzAppId(const DbWidgetHandle handle);
+ static TizenAppId getTzAppId(const TizenPkgId tzPkgid);
+
+ /**
+ * Returns WidgetPkgName for the specified widget
*
- * @return pkgname
+ * @return pkgName;
* @exception WRT_CONF_ERR_EMDB_FAILURE - Fail to query DB table.
- * @exception WRT_CONF_ERR_EMDB_NO_RECORD - Can not find matching records in DB table.
+ * @exception WRT_CONF_ERR_EMDB_NO_RECORD - Can not find matching records in
+ * DB table.
*/
+
WidgetPkgName getPkgName() const;
static WidgetPkgName getPkgName(const WidgetGUID GUID);
static WidgetPkgName getPkgName(const DbWidgetHandle handle);
* @exception WRT_CONF_ERR_EMDB_NO_RECORD - Can not find matching records in
* DB table.
*/
- DPL::String getPath() const;
+ virtual DPL::String getPath() const;
DPL::String getFullPath() const;
* @return WidgetType
* @exception WRT_CONF_ERR_EMDB_FAILURE - Fail to query DB table.
* @exception WRT_CONF_ERR_EMDB_NO_RECORD - Can not find matching
- records in DB table.
+ * records in DB table.
*/
WidgetType getWidgetType() const;
*/
WidgetGUID getGUID() const;
-
/**
- * This method returns the Package name of the widget.
- *
- * @return pkgname
- * @exception WRT_CONF_ERR_EMDB_FAILURE - Fail to query DB table.
- * @exception WRT_CONF_ERR_EMDB_NO_RECORD - Can not find matching records in DB table.
- */
- DPL::OptionalString getPkgname() const;
+ * This method returns the App id of the widget.
+ *
+ * @return appid
+ * @exception WRT_CONF_ERR_EMDB_FAILURE - Fail to query DB table.
+ * @exception WRT_CONF_ERR_EMDB_NO_RECORD - Can not find matching records in
+ * DB table.
+ */
+ DPL::OptionalString getTizenAppId() const;
/**
* This method returns the defaultlocale for the widget.
DPL::OptionalString getVersion() const;
/**
+ * This method is used as a getter for csp policy of widget. It should be
+ * provided in configuration file.
+ * @return global csp policy for widget
+ */
+ DPL::OptionalString getCspPolicy() const;
+
+ /**
+ * This method is used as a getter for report only csp policy of widget.
+ * It may be provided in configuration file.
+ * @return global csp report only policy for widget
+ */
+ DPL::OptionalString getCspPolicyReportOnly() const;
+
+ /**
* This method returns list filed with Common Name entries from certificate.
*
* @return Common Name of Distribuotor End Entity certificate.
* DB table.
*/
WidgetCertificateCNList getKeyCommonNameList(
- WidgetCertificateData::Owner owner,
- WidgetCertificateData::Type type) const;
+ WidgetCertificateData::Owner owner,
+ WidgetCertificateData::Type type) const;
/**
* given a certificate owner (author / distributor) and type of certificate
* function returns list of matching fingerprints
*/
FingerPrintList getKeyFingerprints(
- WidgetCertificateData::Owner owner,
- WidgetCertificateData::Type type) const;
+ WidgetCertificateData::Owner owner,
+ WidgetCertificateData::Type type) const;
/*
* This method gets certificate data list for a widget from database.
* This method returns list of pkgname of installed packages
* @return list of pkgname of installed packages
*/
+ static TizenAppIdList getTizenAppidList();
static WidgetPkgNameList getPkgnameList();
- static WidgetPkgNameList_TEMPORARY_API getPkgnameList_TEMPORARY_API();
/**
* This method returns a list of all the installed widgets.
*/
static DbWidgetDAOReadOnlyList getWidgetList();
- /**
+ /**
* This method removes a widget's information from EmDB.
*
* @see RegisterWidget()
/* This method gets the parameter list for resource.
*/
ResourceAttributeList getResourceAttribute(
- const std::string &resourceId) const;
+ const std::string &resourceId) const;
/* This method checks read only flag for given property
*/
DPL::OptionalInt checkPropertyReadFlag(
- const PropertyDAOReadOnly::WidgetPropertyKey &key) const;
+ const PropertyDAOReadOnly::WidgetPropertyKey &key) const;
/* This method gets widget property key list
*/
/* This method get widget property value
*/
PropertyDAOReadOnly::WidgetPropertyValue getPropertyValue(
- const PropertyDAOReadOnly::WidgetPropertyKey &key) const;
+ const PropertyDAOReadOnly::WidgetPropertyKey &key) const;
LanguageTagList getLanguageTags() const;
LanguageTagList getIconLanguageTags() const;
-
-
WidgetLocalizedInfo getLocalizedInfo(const DPL::String& languageTag) const;
std::string getCookieDatabasePath() const;
// Local storage
bool getBackSupported() const;
static bool isWidgetInstalled(DbWidgetHandle handle);
- static bool isWidgetInstalled(const WidgetPkgName & pkgName);
+ static bool isWidgetInstalled(const TizenAppId & tzAppId);
/* This method get path of the splash image.
*
* wrt-installer and wrt.
*/
CertificateChainList getWidgetCertificate(
- CertificateSource source = SIGNATURE_DISTRIBUTOR) const;
+ CertificateSource source = SIGNATURE_DISTRIBUTOR) const;
void getWidgetSettings(WidgetSettings& outWidgetSettings) const;
* @exception WRT_CONF_ERR_EMDB_FAILURE - Fail to query DB table.
*/
void getAppServiceList(
- WidgetApplicationServiceList& outAppServiceList) const;
+ WidgetApplicationServiceList& outAppServiceList) const;
/**
* This method returns the type of the package.
* @return PackagingType
* @exception WRT_CONF_ERR_EMDB_FAILURE - Fail to query DB table.
* @exception WRT_CONF_ERR_EMDB_NO_RECORD - Can not find matching
- records in DB table.
+ * records in DB table.
*/
PackagingType getPackagingType() const;
DPL::OptionalString getBackgroundPage() const;
/**
- * @brief generateTizenId generates new tizen id
+ * @brief generateTizenId generates new package id
*
- * If widget do not supplies it's own tizen id, this method can be used,
+ * If widget do not supplies it's own tizen package id, this method can be
+ * used,
* although it should be removed in future.
*
- * @return new tizen id
+ * @return new tizen package id
*/
- static WidgetPkgName generateTizenId();
+ static TizenPkgId generatePkgId();
+ static TizenPkgId generateTizenId()
+ {
+ return generatePkgId();
+ }
/**
* @brief This method return each value for security setting
* @return path of widget installed
*/
DPL::OptionalString getWidgetInstalledPath() const;
-};
+ /**
+ * This method returns tizen package id
+ *
+ * @return tizen package id
+ */
+ TizenPkgId getTizenPkgId() const;
+};
} // namespace WrtDB
#endif // _WRT_SRC_CONFIGURATION_WIDGET_DAO_READ_ONLY_H_
namespace WrtDB {
namespace FeatureDAO {
- FeatureHandle RegisterFeature(const PluginMetafileData::Feature &feature,
- const DbPluginHandle pluginHandle);
- void UnregisterFeature(FeatureHandle featureHandle);
+FeatureHandle RegisterFeature(const PluginMetafileData::Feature &feature,
+ const DbPluginHandle pluginHandle);
+void UnregisterFeature(FeatureHandle featureHandle);
} // namespace FeatureDB
} // namespace WrtDB
#include <dpl/wrt-dao-ro/global_dao_read_only.h>
namespace WrtDB {
-
class GlobalDAO : public GlobalDAOReadOnly
{
public:
private:
GlobalDAO()
- {
- }
+ {}
};
-
} // namespace WrtDB
#endif /* WRT_SRC_CONFIGURATION_GLOBAL_DAO_H_ */
#include <dpl/wrt-dao-ro/plugin_dao_read_only.h>
namespace WrtDB {
-
class PluginDAO : public PluginDAOReadOnly
{
public:
PluginDAO(const std::string &libraryName);
static DbPluginHandle registerPlugin(
- const PluginMetafileData& metafile,
- const std::string& pluginPath);
+ const PluginMetafileData& metafile,
+ const std::string& pluginPath);
static void registerPluginImplementedObject(
- const std::string& objectName,
- DbPluginHandle pluginHandle);
+ const std::string& objectName,
+ DbPluginHandle pluginHandle);
static void registerPluginRequiredObject(
- const std::string& objectName,
- DbPluginHandle pluginHandle);
+ const std::string& objectName,
+ DbPluginHandle pluginHandle);
static void registerPluginLibrariesDependencies(
- DbPluginHandle plugin,
- const PluginHandleSetPtr& dependencies);
+ DbPluginHandle plugin,
+ const PluginHandleSetPtr& dependencies);
static void setPluginInstallationStatus(
- DbPluginHandle,
- PluginInstallationState);
+ DbPluginHandle,
+ PluginInstallationState);
static void unregisterPlugin(DbPluginHandle pluginHandle);
};
-
} // namespace WrtDB
#endif /* WRT_SRC_CONFIGURATION_PLUGIN_DAO_H_ */
#include <dpl/wrt-dao-ro/property_dao_read_only.h>
namespace WrtDB {
-
struct WidgetRegisterInfo; //forward declaration
namespace PropertyDAO {
-
-//deprecated
-void RemoveProperty(DbWidgetHandle widgetHandle,
- const PropertyDAOReadOnly::WidgetPropertyKey &key)
- __attribute__((deprecated));
-
-void RemoveProperty(WidgetPkgName pkgName,
+void RemoveProperty(TizenAppId tzAppid,
const PropertyDAOReadOnly::WidgetPropertyKey &key);
//deprecated
const PropertyDAOReadOnly::WidgetPropertyKey &key,
const PropertyDAOReadOnly::WidgetPropertyValue &value,
bool readOnly = false)
- __attribute__((deprecated));
+__attribute__((deprecated));
/* This method sets widget property
*/
-void SetProperty(WidgetPkgName pkgName,
+void SetProperty(TizenAppId tzAppid,
const PropertyDAOReadOnly::WidgetPropertyKey &key,
const PropertyDAOReadOnly::WidgetPropertyValue &value,
bool readOnly = false);
-//deprecated
-/* This method registers properties for widget.
- * Properties unregistering is done via "delete cascade" mechanism in SQL
- */
-void RegisterProperties(DbWidgetHandle widgetHandle,
- const WidgetRegisterInfo ®Info)
- __attribute__((deprecated));
-
/* This method registers properties for widget.
* Properties unregistering is done via "delete cascade" mechanism in SQL
*/
-void RegisterProperties(WidgetPkgName pkgName,
+void RegisterProperties(TizenAppId tzAppid,
const WidgetRegisterInfo ®Info);
-
} // namespace PropertyDAO
} // namespace WrtDB
#include <dpl/wrt-dao-rw/property_dao.h>
namespace WrtDB {
-
class WidgetDAO : public WidgetDAOReadOnly
{
public:
WidgetDAO(DbWidgetHandle handle);
WidgetDAO(DPL::OptionalString widgetGUID);
- WidgetDAO(DPL::String pkgName);
+ WidgetDAO(DPL::String tzAppId);
/**
* Destructor
virtual ~WidgetDAO();
/**
- * This method registers the widget information in the DB when it is installed.
+ * This method registers the widget information in the DB when it is
+ * installed.
*
* @see WidgetRegisterInfo
* @see UnRegisterWidget()
- * @param[in] widgetPkgname Widget Pkgname that will be registered.
- * @param[in] pWidgetRegisterInfo Specified the widget's information needed to be registered.
+ * @param[in] TizenAppId Widget app id that will be registered.
+ * @param[in] pWidgetRegisterInfo Specified the widget's information
+ * needed to be registered.
* @param[in] wacSecurity Widget's security certificates.
*/
static void registerWidget(
- const WidgetPkgName & widgetPkgname,
- const WidgetRegisterInfo &widgetRegInfo,
- const IWacSecurity &wacSecurity);
+ const TizenAppId& tzAppId,
+ const WidgetRegisterInfo &widgetRegInfo,
+ const IWacSecurity &wacSecurity);
static DbWidgetHandle registerWidget(
- const WidgetRegisterInfo &pWidgetRegisterInfo,
- const IWacSecurity &wacSecurity) __attribute__((deprecated));
+ const WidgetRegisterInfo &pWidgetRegisterInfo,
+ const IWacSecurity &wacSecurity) __attribute__((deprecated));
/**
- * @brief registerWidgetGenerateTizenId Registers widget with auto-generated tizen id
+ * @brief registerWidgetGenerateTizenId Registers widget with auto-generated
+ * tizen id
*
* This function is disadviced and should be used only in tests.
* Function is not thread-safe.
*
* @param pWidgetRegisterInfo registeration information
* @param wacSecurity Widget's security certificates.
- * @return pkgname generated
+ * @return tzAppId generated
*/
- static WidgetPkgName registerWidgetGenerateTizenId(
- const WidgetRegisterInfo &pWidgetRegisterInfo,
- const IWacSecurity &wacSecurity);
+ static TizenAppId registerWidgetGeneratePkgId(
+ const WidgetRegisterInfo &pWidgetRegisterInfo,
+ const IWacSecurity &wacSecurity);
/**
- * This method re-registers the widget information to the DB when it is installed.
+ * This method re-registers the widget information to the DB when it is
+ * installed.
*
- * It performs unregistration and new registration of widget in db in one transaction.
+ * It performs unregistration and new registration of widget in db in one
+ * transaction.
*
* @see WidgetRegisterInfo
- * @param[in] widgetName Widget pkgname that will be registered.
- * @param[in] pWidgetRegisterInfo Specified the widget's information needed to be registered.
+ * @param[in] tzAppId Widget tizen app id that will be registered.
+ * @param[in] pWidgetRegisterInfo Specified the widget's information
+ * needed to be registered.
* @param[in] wacSecurity Widget's security certificates.
*/
static void registerOrUpdateWidget(
- const WidgetPkgName & widgetName,
- const WidgetRegisterInfo &widgetRegInfo,
- const IWacSecurity &wacSecurity);
-
- static void registerWidget(
- WrtDB::DbWidgetHandle handle,
- const WidgetRegisterInfo &widgetRegInfo,
- const IWacSecurity &wacSecurity) __attribute__((deprecated));
+ const TizenAppId & tzAppId,
+ const WidgetRegisterInfo &widgetRegInfo,
+ const IWacSecurity &wacSecurity);
/**
* This method removes a widget's information from EmDB.
*
* @see RegisterWidget()
- * @param[in] pkgName widgets name to be unregistered
+ * @param[in] tzAppId widgets name to be unregistered
*/
- static void unregisterWidget(const WidgetPkgName & pkgName);
+ static void unregisterWidget(const TizenAppId & tzAppId);
- static void unregisterWidget(WrtDB::DbWidgetHandle handle) __attribute__((deprecated));
+ static void unregisterWidget(WrtDB::DbWidgetHandle handle) __attribute__((
+ deprecated));
/* This method removes widget property
*/
void removeProperty(const PropertyDAOReadOnly::WidgetPropertyKey &key);
/**
- * @brief registerExternalLocations Removes rows from WidgetExternalLocations
+ * @brief registerExternalLocations Removes rows from
+ * WidgetExternalLocations
*/
void unregisterAllExternalLocations();
/* This method sets widget property
*/
void setProperty(const PropertyDAOReadOnly::WidgetPropertyKey &key,
- const PropertyDAOReadOnly::WidgetPropertyValue &value,
- bool readOnly = false);
+ const PropertyDAOReadOnly::WidgetPropertyValue &value,
+ bool readOnly = false);
- /* set PkgName
+ /* set tzAppId
*/
- void setPkgName(const DPL::OptionalString& pkgName);
- void setPkgName_TEMPORARY_API(const WidgetPkgName& pkgName);
+ void setTizenAppId(const DPL::OptionalString& tzAppId);
/* This function will update of api-feature status.
* If status is true (feature rejected) plugin connected with this
*/
void updateFeatureRejectStatus(const DbWidgetFeature &widgetFeature);
- /*
- * This method change security settings value
- */
+ /*
+ * This method change security settings value
+ */
void setSecurityPopupUsage(const SettingsType value);
void setGeolocationUsage(const SettingsType value);
void setWebNotificationUsage(const SettingsType value);
private:
//Methods used during widget registering
static DbWidgetHandle registerWidgetInfo(
- const WidgetPkgName & widgetName,
- const WidgetRegisterInfo ®Info,
- const IWacSecurity &wacSecurity,
- const DPL::Optional<DbWidgetHandle> handle = DPL::Optional<DbWidgetHandle>());
+ const TizenAppId & widgetName,
+ const WidgetRegisterInfo ®Info,
+ const IWacSecurity &wacSecurity,
+ const DPL::Optional<DbWidgetHandle> handle =
+ DPL::Optional<DbWidgetHandle>());
static void registerWidgetExtendedInfo(
- DbWidgetHandle widgetHandle,
- const WidgetRegisterInfo ®Info);
+ DbWidgetHandle widgetHandle,
+ const WidgetRegisterInfo ®Info);
static void registerWidgetLocalizedInfo(
- DbWidgetHandle widgetHandle,
- const WidgetRegisterInfo ®Info);
+ DbWidgetHandle widgetHandle,
+ const WidgetRegisterInfo ®Info);
static void registerWidgetIcons(
- DbWidgetHandle widgetHandle,
- const WidgetRegisterInfo ®Info);
+ DbWidgetHandle widgetHandle,
+ const WidgetRegisterInfo ®Info);
static void registerWidgetStartFile(
- DbWidgetHandle widgetHandle,
- const WidgetRegisterInfo ®Info);
+ DbWidgetHandle widgetHandle,
+ const WidgetRegisterInfo ®Info);
static void registerWidgetPreferences(
- DbWidgetHandle widgetHandle,
- const WidgetRegisterInfo ®Info);
+ DbWidgetHandle widgetHandle,
+ const WidgetRegisterInfo ®Info);
static void registerWidgetFeatures(
- DbWidgetHandle widgetHandle,
- const WidgetRegisterInfo ®Info);
+ DbWidgetHandle widgetHandle,
+ const WidgetRegisterInfo ®Info);
static void registerWidgetPrivilege(
- DbWidgetHandle widgetHandle,
- const WidgetRegisterInfo ®Info);
+ DbWidgetHandle widgetHandle,
+ const WidgetRegisterInfo ®Info);
static void registerWidgetWindowModes(
- DbWidgetHandle widgetHandle,
- const WidgetRegisterInfo ®Info);
+ DbWidgetHandle widgetHandle,
+ const WidgetRegisterInfo ®Info);
static void registerWidgetWarpInfo(
- DbWidgetHandle widgetHandle,
- const WidgetRegisterInfo ®Info);
+ DbWidgetHandle widgetHandle,
+ const WidgetRegisterInfo ®Info);
static void registerWidgetCertificates(
- DbWidgetHandle widgetHandle,
- const IWacSecurity &wacSecurity);
+ DbWidgetHandle widgetHandle,
+ const IWacSecurity &wacSecurity);
static void registerCertificatesChains(
- DbWidgetHandle widgetHandle,
- CertificateSource certificateSource,
- const CertificateChainList &list);
+ DbWidgetHandle widgetHandle,
+ CertificateSource certificateSource,
+ const CertificateChainList &list);
static void registerWidgetSettings(
- DbWidgetHandle widgetHandle,
- const WidgetRegisterInfo ®Info);
+ DbWidgetHandle widgetHandle,
+ const WidgetRegisterInfo ®Info);
static void registerAppService(
- DbWidgetHandle widgetHandle,
- const WidgetRegisterInfo ®Info);
+ DbWidgetHandle widgetHandle,
+ const WidgetRegisterInfo ®Info);
static void registerEncryptedResouceInfo(
- DbWidgetHandle widgetHandle,
- const WidgetRegisterInfo ®Info);
+ DbWidgetHandle widgetHandle,
+ const WidgetRegisterInfo ®Info);
/**
- * @brief registerExternalLocations Inserts new rows to WidgetExternalLocations
+ * @brief registerExternalLocations Inserts new rows to
+ * WidgetExternalLocations
* @param externals list of files
*/
- static void registerExternalLocations(DbWidgetHandle widgetHandle,
- const ExternalLocationList & externals);
+ static void registerExternalLocations(
+ DbWidgetHandle widgetHandle,
+ const ExternalLocationList &
+ externals);
static void registerWidgetSecuritySettings(DbWidgetHandle widgetHandle);
-
static void registerWidgetInternal(
- const WidgetPkgName & widgetName,
- const WidgetRegisterInfo &widgetRegInfo,
- const IWacSecurity &wacSecurity,
- const DPL::Optional<DbWidgetHandle> handle = DPL::Optional<DbWidgetHandle>());
+ const TizenAppId & tzAppId,
+ const WidgetRegisterInfo &widgetRegInfo,
+ const IWacSecurity &wacSecurity,
+ const DPL::Optional<DbWidgetHandle> handle =
+ DPL::Optional<DbWidgetHandle>());
static void unregisterWidgetInternal(
- const WidgetPkgName & pkgName);
-};
+ const TizenAppId & tzAppId);
+ static void insertApplicationServiceInfo(DbWidgetHandle handle,
+ DPL::String src,
+ DPL::String operation,
+ DPL::String scheme,
+ DPL::String mime);
+};
} // namespace WrtDB
#endif // WIDGET_DAO_H
CREATE_TABLE(WidgetInfo)
COLUMN_NOT_NULL(app_id, INTEGER, PRIMARY KEY AUTOINCREMENT)
- COLUMN(widget_type, INT, DEFAULT 1)
- COLUMN(widget_id, VARCHAR(256), DEFAULT '')
- COLUMN(widget_version, VARCHAR(256), DEFAULT '')
+ COLUMN(widget_type, INT, DEFAULT 1)
+ COLUMN(widget_id, TEXT, DEFAULT '')
+ COLUMN(widget_version, TEXT, DEFAULT '')
COLUMN(widget_width, INT, DEFAULT 0)
COLUMN(widget_height, INT, DEFAULT 0)
- COLUMN(author_name, VARCHAR(256), DEFAULT '')
- COLUMN(author_email, VARCHAR(256), DEFAULT '')
- COLUMN(author_href, VARCHAR(256), DEFAULT '')
- COLUMN(base_folder, VARCHAR(256), DEFAULT '')
+ COLUMN(author_name, TEXT, DEFAULT '')
+ COLUMN(author_email, TEXT, DEFAULT '')
+ COLUMN(author_href, TEXT, DEFAULT '')
+ COLUMN(base_folder, TEXT, DEFAULT '')
COLUMN(webkit_plugins_required, TINYINT, DEFAULT 0)
COLUMN(security_domain, INT, DEFAULT 0)
+ COLUMN(csp_policy, TEXT, DEFAULT '')
+ COLUMN(csp_policy_report_only, TEXT, DEFAULT '')
COLUMN(recognized, INT, DEFAULT 0)
COLUMN(wac_signed, INT, DEFAULT 0)
COLUMN(distributor_signed, INT, DEFAULT 0)
- COLUMN(min_version, VARCHAR(16), DEFAULT '1.0')
+ COLUMN(min_version, TEXT, DEFAULT '1.0')
COLUMN_NOT_NULL(back_supported, TINYINT, DEFAULT 0)
COLUMN(access_network, TINYINT, DEFAULT 0)
- COLUMN(defaultlocale, VARCHAR(256), DEFAULT 0)
- COLUMN_NOT_NULL(pkgname, VARCHAR(256), DEFAULT 0 UNIQUE)
+ COLUMN(defaultlocale, TEXT, DEFAULT 0)
+ COLUMN_NOT_NULL(tizen_pkgid, TEXT, DEFAULT '')
+ COLUMN_NOT_NULL(tizen_appid, TEXT, DEFAULT 0 UNIQUE)
COLUMN(pkg_type, INT, DEFAULT 0)
CREATE_TABLE_END()
SQL(
- CREATE INDEX IF NOT EXISTS WidgetInfo_PkgnameIndex ON WidgetInfo(pkgname);
+ CREATE INDEX IF NOT EXISTS WidgetInfo_AppidIndex ON WidgetInfo(tizen_appid);
)
CREATE_TABLE(WidgetCertificate)
COLUMN(last_update_time, BIGINT, DEFAULT 0)
COLUMN(install_time, BIGINT, DEFAULT 0)
COLUMN(option_state, INT, DEFAULT 0)
- COLUMN(share_href, VARCHAR(256), DEFAULT '')
+ COLUMN(share_href, TEXT, DEFAULT '')
COLUMN(signature_type, INT, DEFAULT 0)
COLUMN(updated, INT, DEFAULT 0)
COLUMN(update_policy, INT, DEFAULT 0)
COLUMN_NOT_NULL(test_widget, INT, CHECK(test_widget between 0 and 1) DEFAULT 0)
- COLUMN(splash_img_src, VARCHAR(256), DEFAULT '')
- COLUMN(background_page, VARCHAR(256), DEFAULT '')
- COLUMN(installed_path, VARCHAR(512), DEFAULT '')
+ COLUMN(splash_img_src, TEXT, DEFAULT '')
+ COLUMN(background_page, TEXT, DEFAULT '')
+ COLUMN(installed_path, TEXT, DEFAULT '')
TABLE_CONSTRAINTS(
FOREIGN KEY(app_id) REFERENCES WidgetInfo (app_id) ON DELETE CASCADE
)
CREATE_TABLE_END()
CREATE_TABLE(WidgetPreference)
- COLUMN_NOT_NULL(pkgname, VARCHAR(256), DEFAULT 0)
- COLUMN_NOT_NULL(key_name, VARCHAR(256),)
- COLUMN(key_value, VARCHAR(8000), DEFAULT '')
- COLUMN(readonly, INT, DEFAULT 0)
+ COLUMN_NOT_NULL(tizen_appid, TEXT, DEFAULT 0)
+ COLUMN_NOT_NULL(key_name, TEXT,)
+ COLUMN(key_value, TEXT, DEFAULT '')
+ COLUMN(readonly, INT, DEFAULT 0)
TABLE_CONSTRAINTS(
- PRIMARY KEY(pkgname, key_name),
- FOREIGN KEY(pkgname) REFERENCES WidgetInfo (pkgname) ON DELETE CASCADE
+ PRIMARY KEY(tizen_appid, key_name),
+ FOREIGN KEY(tizen_appid) REFERENCES WidgetInfo (tizen_appid) ON DELETE CASCADE
)
CREATE_TABLE_END()
CREATE_TABLE(WidgetFeature)
COLUMN_NOT_NULL(widget_feature_id, INTEGER, primary key autoincrement)
COLUMN_NOT_NULL(app_id, INT,)
- COLUMN_NOT_NULL(name, VARCHAR(256),)
+ COLUMN_NOT_NULL(name, TEXT,)
COLUMN_NOT_NULL(required, INT,)
COLUMN_NOT_NULL(rejected, INT,)
TABLE_CONSTRAINTS(
CREATE_TABLE(WidgetPrivilege)
COLUMN_NOT_NULL(widget_privilege_id, INTEGER, primary key autoincrement)
COLUMN_NOT_NULL(app_id, INT,)
- COLUMN_NOT_NULL(name, VARCHAR(256),)
+ COLUMN_NOT_NULL(name, TEXT,)
TABLE_CONSTRAINTS(
FOREIGN KEY (app_id) REFERENCES WidgetInfo (app_id) ON DELETE CASCADE
)
CREATE_TABLE(WidgetIcon)
COLUMN_NOT_NULL(icon_id, INTEGER, primary key autoincrement)
COLUMN_NOT_NULL(app_id, INT,)
- COLUMN_NOT_NULL(icon_src, VARCHAR(256),)
+ COLUMN_NOT_NULL(icon_src, TEXT,)
COLUMN(icon_width, INT, DEFAULT 0)
COLUMN(icon_height, INT, DEFAULT 0)
TABLE_CONSTRAINTS(
CREATE_TABLE(WidgetStartFile)
COLUMN_NOT_NULL(start_file_id, INTEGER, primary key autoincrement)
COLUMN_NOT_NULL(app_id, INT,)
- COLUMN_NOT_NULL(src, VARCHAR(256),)
+ COLUMN_NOT_NULL(src, TEXT,)
TABLE_CONSTRAINTS(
FOREIGN KEY(app_id) REFERENCES WidgetInfo (app_id) ON DELETE CASCADE
)
CREATE_TABLE(WidgetAccessHost)
COLUMN_NOT_NULL(app_id, INT,)
- COLUMN_NOT_NULL(host, VARCHAR(256),)
+ COLUMN_NOT_NULL(host, TEXT,)
TABLE_CONSTRAINTS(
PRIMARY KEY(app_id, host)
COLUMN_NOT_NULL(owner, INT,)
COLUMN_NOT_NULL(chainid, INT,)
COLUMN_NOT_NULL(type, INT,)
- COLUMN(md5_fingerprint, VARCHAR(64),)
- COLUMN(sha1_fingerprint, VARCHAR(64),)
+ COLUMN(md5_fingerprint, TEXT,)
+ COLUMN(sha1_fingerprint, TEXT,)
COLUMN(common_name, VARCHAR(64),)
TABLE_CONSTRAINTS(
CREATE_TABLE(WidgetWARPInfo)
COLUMN_NOT_NULL(app_id, INT,)
- COLUMN_NOT_NULL(iri, VARCHAR(65536),)
+ COLUMN_NOT_NULL(iri, TEXT,)
COLUMN(subdomain_access, INT, CHECK(subdomain_access between 0 and 1))
TABLE_CONSTRAINTS(
CREATE_TABLE_END()
CREATE_TABLE(SettingsList)
- COLUMN_NOT_NULL(appId, INT,)
- COLUMN_NOT_NULL(settingName, TEXT, )
- COLUMN_NOT_NULL(settingValue, TEXT, )
+ COLUMN_NOT_NULL(appId, INT,)
+ COLUMN_NOT_NULL(settingName, TEXT,)
+ COLUMN_NOT_NULL(settingValue, TEXT,)
TABLE_CONSTRAINTS(
FOREIGN KEY (appId) REFERENCES WidgetInfo (app_id) ON DELETE CASCADE
)
CREATE_TABLE_END()
CREATE_TABLE(ApplicationServiceInfo)
- COLUMN_NOT_NULL(app_id, INT,)
- COLUMN_NOT_NULL(src, TEXT,)
- COLUMN_NOT_NULL(operation, TEXT,)
- COLUMN_NOT_NULL(scheme, TEXT,)
- COLUMN_NOT_NULL(mime, TEXT,)
+ COLUMN_NOT_NULL(app_id, INT,)
+ COLUMN_NOT_NULL(src, TEXT,)
+ COLUMN_NOT_NULL(operation, TEXT,)
+ COLUMN_NOT_NULL(scheme, TEXT,)
+ COLUMN_NOT_NULL(mime, TEXT,)
+ COLUMN_NOT_NULL(disposition, TINYINT, DEFAULT 0)
TABLE_CONSTRAINTS(
PRIMARY KEY(app_id, operation, scheme, mime)
/*TODO: It will be removed when user agent is fixed. User agent MUST be configurable in development...*/
CREATE_TABLE(UserAgents)
- COLUMN_NOT_NULL(key_name, VARCHAR(256),)
- COLUMN(key_value, VARCHAR(8000), DEFAULT '')
+ COLUMN_NOT_NULL(key_name, TEXT,)
+ COLUMN(key_value, TEXT, DEFAULT '')
TABLE_CONSTRAINTS(PRIMARY KEY(key_name))
CREATE_TABLE_END()
INSERT INTO UserAgents VALUES("Galaxy S II", "Mozilla/5.0 (Linux; U; Android 2.3.5; en-gb; GT-I9100 Build/GINGERBREAD) AppleWebKit/533.1 (KHTML, like Gecko) Version/4.0 Mobile Safari/533.1");
INSERT INTO UserAgents VALUES("Galaxy S III", "Mozilla/5.0 (Linux; U; Android 4.0.4; en-gb; GT-I9300 Build/IMM76D) AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30");
INSERT INTO UserAgents VALUES("SLP Galaxy", "Mozilla/5.0 (Linux; U; Android 2.3.4; en-us; GT-I9500 Build/GINGERBREAD) AppleWebKit/533.1 (KHTML, like Gecko) Version/4.0 Mobile Safari/533.1");
- INSERT INTO UserAgents VALUES("Tizen", "Mozilla/5.0 (Linux; U; Tizen 1.0; en-us) AppleWebKit/534.46 (KHTML, like Gecko) Mobile Tizen Browser/1.0");
+ INSERT INTO UserAgents VALUES("Tizen", "Mozilla/5.0 (Linux; U; Tizen 2.1; en-us; SAMSUNG GT-I8800) AppleWebKit/537.1 (KHTML, like Gecko) Version/2.1.0 Mobile");
INSERT INTO UserAgents VALUES("Galaxy Nexus", "Mozilla/5.0 (Linux; U; Android 4.0.3; en-us; Galaxy Nexus Build/IML74K) AppleWebKit/535.7 (KHTML, like Gecko) Mobile Safari/535.7");
INSERT INTO UserAgents VALUES("Samsung", "Mozilla/5.0 (SAMSUNG; SAMSUNG-GT-I9200/1.0; U; Linux/SLP/2.0; ko-kr) AppleWebKit/534.4 (KHTML, like Gecko) Dolfin/2.0 Mobile");
INSERT INTO UserAgents VALUES("Samsung Dolfin", "SAMSUNG-GT-S8500/S8500XXJD2 SHP/VPP/R5 Dolfin/2.0 Nextreaming SMM-MMS/1.2.0 profile/MIDP-2.1 configuration/CLDC-1.1");
* @file wrt_db_sql_generator.h
* @author Bartosz Janiak (b.janiak@samsung.com)
* @version 1.0
- * @brief Macro definitions for generating the SQL input file from database definition.
+ * @brief Macro definitions for generating the SQL input file from
+ * database definition.
*/
//Do not include this file directly! It is used only for SQL code generation.
-#git:framework/web/wrt-commons wrt-commons 0.2.92
+#git:framework/web/wrt-commons wrt-commons 0.2.105
Name: wrt-commons
Summary: Wrt common library
-Version: 0.2.93
+Version: 0.2.105
Release: 1
Group: Development/Libraries
License: Apache License, Version 2.0
BuildRequires: pkgconfig(openssl)
BuildRequires: pkgconfig(libiri)
BuildRequires: pkgconfig(libidn)
+BuildRequires: libcryptsvc-devel
+BuildRequires: dukgenerator-devel
+Requires: libcryptsvc
%description
Wrt common library
%build
-%ifarch %{ix86}
-cp build/encryption/libs/libcal.i586.a build/encryption/libs/libcal.a
-%else
-cp build/encryption/libs/libcal.arm.a build/encryption/libs/libcal.a
-%endif
-
export LDFLAGS+="-Wl,--rpath=%{_libdir} -Wl,--hash-style=both -Wl,--as-needed"
cmake . -DVERSION=%{version} \
%attr(755,root,root) %{_bindir}/wrt_commons_create_clean_db.sh
%attr(755,root,root) %{_bindir}/wrt_commons_reset_db.sh
%if %{with_tests}
- %attr(755,root,root) %{_bindir}/dpl-tests-*
- %attr(755,root,root) %{_bindir}/dpl-dbus-test-service
- %attr(755,root,root) %{_bindir}/wrt-tests-*
+ %attr(755,root,root) %{_bindir}/wrt-commons-tests-*
%attr(755,root,root) %{_bindir}/wrt_dao_tests_prepare_db.sh
+ %attr(755,root,root) %{_bindir}/wrt_db_localization_prepare.sh
%{_datadir}/dbus-1/services/org.tizen.DBusTestService.service
/opt/share/wrt/wrt-commons/tests/*
+ /opt/share/widget/tests/localization/*
%endif
%files devel
${TARGET_DPL_TEST_ENGINE_EFL}
)
+ADD_SUBDIRECTORY(core)
ADD_SUBDIRECTORY(dao)
-ADD_SUBDIRECTORY(dpl)
+ADD_SUBDIRECTORY(db)
+ADD_SUBDIRECTORY(dbus)
+ADD_SUBDIRECTORY(event)
+ADD_SUBDIRECTORY(files_localization)
+ADD_SUBDIRECTORY(localizationTagsProvider)
+ADD_SUBDIRECTORY(utils)
+ADD_SUBDIRECTORY(test)
# Rollback CXX flags
-#SET(CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS_BACKUP})
\ No newline at end of file
+#SET(CMAKE_CXX_FLAGS ${CMAKE_CXX_FLAGS_BACKUP})
--- /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 glib_interface.h
+ * @author Iwanek Tomasz (t.iwanek@samsung.com)
+ * @version 1.0
+ * @brief This file is the definitions of loop controlling utilities
+ */
+
+#ifndef GLIB_INTERFACE_H
+#define GLIB_INTERFACE_H
+
+//this header wraps glib headers which generates warnings
+
+#pragma GCC system_header
+#include <glib.h>
+#include <glib-object.h>
+
+#endif // GLIB_INTERFACE_H
* @brief This file is the definitions of loop controlling utilities
*/
-
#ifndef LOOP_CONTROL_H_
#define LOOP_CONTROL_H_
-namespace LoopControl
-{
-
+namespace LoopControl {
void init_loop(int argc, char *argv[]);
void wait_for_wrt_init();
void finish_wait_for_wrt_init();
void wrt_end_loop();
void *abstract_window();
-
}
#endif /* LOOP_CONTROL_H_ */
* @brief This is implementation of EFL version of loop control
*/
+#include <glib_interface.h>
#include <loop_control.h>
#include <dpl/log/log.h>
#include <dpl/framework_efl.h>
-#include <glib.h>
-#include <glib-object.h>
-
-
-namespace LoopControl
-{
+namespace LoopControl {
void init_loop(int argc, char *argv[])
{
(void)argc;
{
return elm_win_add(NULL, "hello", ELM_WIN_BASIC);
}
-
-}//end of LoopControl namespace
+} //end of LoopControl namespace
# generating proper output files
#
-SET(TARGET_NAME "dpl-tests-core")
+SET(TARGET_NAME "wrt-commons-tests-core")
# Set DPL tests sources
SET(DPL_TESTS_CORE_SOURCES
- ${TESTS_DPL_DIR}/core/main.cpp
- ${TESTS_DPL_DIR}/core/test_address.cpp
- ${TESTS_DPL_DIR}/core/test_binary_queue.cpp
- ${TESTS_DPL_DIR}/core/test_foreach.cpp
- ${TESTS_DPL_DIR}/core/test_fast_delegate.cpp
- ${TESTS_DPL_DIR}/core/test_log_unhandled_exception.cpp
- ${TESTS_DPL_DIR}/core/test_once.cpp
- ${TESTS_DPL_DIR}/core/test_serialization.cpp
- ${TESTS_DPL_DIR}/core/test_scoped_array.cpp
- ${TESTS_DPL_DIR}/core/test_scoped_close.cpp
- ${TESTS_DPL_DIR}/core/test_scoped_fclose.cpp
- ${TESTS_DPL_DIR}/core/test_scoped_free.cpp
- ${TESTS_DPL_DIR}/core/test_scoped_ptr.cpp
- ${TESTS_DPL_DIR}/core/test_semaphore.cpp
- ${TESTS_DPL_DIR}/core/test_shared_ptr.cpp
- ${TESTS_DPL_DIR}/core/test_string.cpp
- ${TESTS_DPL_DIR}/core/test_thread.cpp
- ${TESTS_DPL_DIR}/core/test_type_list.cpp
- ${TESTS_DPL_DIR}/core/test_zip_input.cpp
+ ${TESTS_DIR}/core/main.cpp
+ ${TESTS_DIR}/core/test_address.cpp
+ ${TESTS_DIR}/core/test_binary_queue.cpp
+ ${TESTS_DIR}/core/test_foreach.cpp
+ ${TESTS_DIR}/core/test_fast_delegate.cpp
+ ${TESTS_DIR}/core/test_log_unhandled_exception.cpp
+ ${TESTS_DIR}/core/test_once.cpp
+ ${TESTS_DIR}/core/test_serialization.cpp
+ ${TESTS_DIR}/core/test_scoped_array.cpp
+ ${TESTS_DIR}/core/test_scoped_close.cpp
+ ${TESTS_DIR}/core/test_scoped_dir.cpp
+ ${TESTS_DIR}/core/test_scoped_fclose.cpp
+ ${TESTS_DIR}/core/test_scoped_free.cpp
+ ${TESTS_DIR}/core/test_scoped_ptr.cpp
+ ${TESTS_DIR}/core/test_semaphore.cpp
+ ${TESTS_DIR}/core/test_shared_ptr.cpp
+ ${TESTS_DIR}/core/test_static_block.cpp
+ ${TESTS_DIR}/core/test_string.cpp
+ ${TESTS_DIR}/core/test_thread.cpp
+ ${TESTS_DIR}/core/test_type_list.cpp
+ ${TESTS_DIR}/core/test_zip_input.cpp
)
WRT_TEST_ADD_INTERNAL_DEPENDENCIES(${TARGET_NAME} ${TARGET_DPL_EFL})
WRT_TEST_INSTALL(${TARGET_NAME})
INSTALL(FILES
- ${TESTS_DPL_DIR}/core/data/sample.zip
+ ${TESTS_DIR}/core/data/sample.zip
DESTINATION /opt/share/wrt/wrt-commons/tests/core
)
RUNNER_TEST_GROUP_INIT(DPL)
+/*
+Name: Address_InitialEmpty
+Description: tests empty constructor of DPL::Address
+Expected: string version of empy address equals ":0"
+*/
RUNNER_TEST(Address_InitialEmpty)
{
DPL::Address address;
RUNNER_ASSERT(address.ToString() == ":0");
}
+/*
+Name: Address_InitialAddress
+Description: tests constructor of DPL::Address with name only
+Expected: string version of address equals given name and appended ":0"
+*/
RUNNER_TEST(Address_InitialAddress)
{
DPL::Address address("www.sample.com");
RUNNER_ASSERT(address.ToString() == "www.sample.com:0");
}
+/*
+Name: Address_InitialAddress
+Description: tests constructor of DPL::Address with name and port
+Expected: string version of address should look lik "adress name:port"
+*/
RUNNER_TEST(Address_InitialAddressPort)
{
DPL::Address address("www.somewhere.com", 8080);
RUNNER_ASSERT(address.ToString() == "www.somewhere.com:8080");
}
+/*
+Name: Address_InitialAddress
+Description: tests getter of address
+Expected: address name and port should matches those passed in constructor
+*/
RUNNER_TEST(Address_Getters)
{
DPL::Address address("www.somewhere.com", 8080);
char *buffer = new char[queue.Size()];
queue.Flatten(buffer, queue.Size());
std::string result = std::string(buffer, buffer + queue.Size());
- delete [] buffer;
+ delete[] buffer;
return result;
}
+/*
+Name: BinaryQueue_InitialEmpty
+Description: tests emptiness of new constructed queue
+Expected: new queue should be empty
+*/
RUNNER_TEST(BinaryQueue_InitialEmpty)
{
DPL::BinaryQueue queue;
RUNNER_ASSERT(queue.Empty() == true);
}
+/*
+Name: BinaryQueue_InitialSize
+Description: tests emptiness of new constructed queue
+Expected: new queue size should be equal 0
+*/
RUNNER_TEST(BinaryQueue_InitialSize)
{
DPL::BinaryQueue queue;
RUNNER_ASSERT(queue.Size() == 0);
}
+/*
+Name: BinaryQueue_InitialCopy
+Description: tests emptiness of new copy-constructed empty queue
+Expected: queue constructed on base on empty queue should be empty
+*/
RUNNER_TEST(BinaryQueue_InitialCopy)
{
DPL::BinaryQueue queue;
RUNNER_ASSERT(copy.Size() == 0);
}
+/*
+Name: BinaryQueue_InitialConsumeZero
+Description: tests consume method accepts 0 bytes
+Expected: it should be avaliable to discard 0 bytes from empty queue
+*/
RUNNER_TEST(BinaryQueue_InitialConsumeZero)
{
DPL::BinaryQueue queue;
queue.Consume(0);
}
+/*
+Name: BinaryQueue_InitialFlattenConsumeZero
+Description: tests returning data from queue and discarding
+Expected: it should be able to call flattenconsume with empty buffer if 0 bytes are read
+*/
RUNNER_TEST(BinaryQueue_InitialFlattenConsumeZero)
{
DPL::BinaryQueue queue;
queue.FlattenConsume(NULL, 0);
}
+/*
+Name: BinaryQueue_InitialFlattenZero
+Description: tests returning data from queue
+Expected: it should be able to call flatten with empty buffer if 0 bytes are read
+*/
RUNNER_TEST(BinaryQueue_InitialFlattenZero)
{
DPL::BinaryQueue queue;
queue.Flatten(NULL, 0);
}
+/*
+Name: BinaryQueue_InitialConsumeOne
+Description: tests discarding more bytes than it is avaliable
+Expected: exception throw
+*/
RUNNER_TEST(BinaryQueue_InitialConsumeOne)
{
DPL::BinaryQueue queue;
{
queue.Consume(1);
}
- Catch (DPL::BinaryQueue::Exception::OutOfData)
+ Catch(DPL::BinaryQueue::Exception::OutOfData)
{
return;
}
RUNNER_FAIL;
}
+/*
+Name: BinaryQueue_InitialFlattenConsumeOne
+Description: tests reading and discarding more bytes than it is avaliable
+Expected: exception throw
+*/
RUNNER_TEST(BinaryQueue_InitialFlattenConsumeOne)
{
DPL::BinaryQueue queue;
char data;
queue.FlattenConsume(&data, 1);
}
- Catch (DPL::BinaryQueue::Exception::OutOfData)
+ Catch(DPL::BinaryQueue::Exception::OutOfData)
{
return;
}
RUNNER_FAIL;
}
+/*
+Name: BinaryQueue_InitialFlattenOne
+Description: tests reading more bytes than it is avaliable
+Expected: exception throw
+*/
RUNNER_TEST(BinaryQueue_InitialFlattenOne)
{
DPL::BinaryQueue queue;
char data;
queue.Flatten(&data, 1);
}
- Catch (DPL::BinaryQueue::Exception::OutOfData)
+ Catch(DPL::BinaryQueue::Exception::OutOfData)
{
return;
}
RUNNER_FAIL;
}
+/*
+Name: BinaryQueue_ZeroCopyFrom
+Description: tests coping content of empty queue to another (AppendCopyFrom)
+Expected: source queue should be empty
+*/
RUNNER_TEST(BinaryQueue_ZeroCopyFrom)
{
DPL::BinaryQueue queue;
RUNNER_ASSERT(queue.Empty());
}
+/*
+Name: BinaryQueue_ZeroMoveFrom
+Description: tests moving content of empty queue to another
+Expected: source queue should be empty
+*/
RUNNER_TEST(BinaryQueue_ZeroMoveFrom)
{
DPL::BinaryQueue queue;
RUNNER_ASSERT(queue.Empty());
}
+/*
+Name: BinaryQueue_ZeroCopyTo
+Description: tests moving content of empty queue to another (AppendCopyTo)
+Expected: source queue should be empty
+*/
RUNNER_TEST(BinaryQueue_ZeroCopyTo)
{
DPL::BinaryQueue queue;
RUNNER_ASSERT(queue.Empty());
}
+/*
+Name: BinaryQueue_InsertSingleCharacters
+Description: tests inserting single bytes to queue
+Expected: stringified content and size shoudl match expected
+*/
RUNNER_TEST(BinaryQueue_InsertSingleCharacters)
{
DPL::BinaryQueue queue;
RUNNER_ASSERT(BinaryQueueToString(queue) == "abcd");
}
+/*
+Name: BinaryQueue_Consume
+Description: tests comsuming portions of 1 or 2 bytes
+Expected: stringified content and size should match expected
+ Bytes should be pope from begin.
+*/
RUNNER_TEST(BinaryQueue_Consume)
{
DPL::BinaryQueue queue;
RUNNER_ASSERT(BinaryQueueToString(queue) == "");
}
+/*
+Name: BinaryQueue_Flatten
+Description: tests comsuming portions of 1 and more bytes
+Expected: stringified content and size should match expected
+*/
RUNNER_TEST(BinaryQueue_Flatten)
{
DPL::BinaryQueue queue;
RUNNER_ASSERT(BinaryQueueToString(queue) == "abcdefg");
}
+/*
+Name: BinaryQueue_FlattenConsume
+Description: tests comsuming portions of 1 and more bytes
+Expected: stringified content and size should match expected
+ reading and discarding bytes should affect queue's size and content
+*/
RUNNER_TEST(BinaryQueue_FlattenConsume)
{
DPL::BinaryQueue queue;
RUNNER_ASSERT(BinaryQueueToString(queue) == "def");
}
+/*
+Name: BinaryQueue_AppendCopyFrom
+Description: tests creating copy of not empty queue (use of: AppendCopyFrom)
+Expected: stringified content and size should match expected
+ from original queue and it's copy
+*/
RUNNER_TEST(BinaryQueue_AppendCopyFrom)
{
DPL::BinaryQueue queue;
RUNNER_ASSERT(BinaryQueueToString(copy) == "abcdef");
}
+/*
+Name: BinaryQueue_AppendCopyTo
+Description: tests creating copy of not empty queue (use of: AppendCopyTo)
+Expected: stringified content and size should match expected
+ from original queue and it's copy
+*/
RUNNER_TEST(BinaryQueue_AppendCopyTo)
{
DPL::BinaryQueue queue;
RUNNER_ASSERT(BinaryQueueToString(copy) == "abcdef");
}
+/*
+Name: BinaryQueue_AppendMoveFrom
+Description: tests moving content of not empty queue (use of: AppendMoveFrom)
+Expected: stringified content and size should match expected
+ for new queue. Old queue should be empty after operation
+*/
RUNNER_TEST(BinaryQueue_AppendMoveFrom)
{
DPL::BinaryQueue queue;
RUNNER_ASSERT(BinaryQueueToString(copy) == "abcdef");
}
+/*
+Name: BinaryQueue_AppendMoveFrom
+Description: tests moving content of not empty queue (use of: AppendMoveTo)
+Expected: stringified content and size should match expected
+ for new queue. Old queue should be empty after operation
+*/
RUNNER_TEST(BinaryQueue_AppendMoveTo)
{
DPL::BinaryQueue queue;
RUNNER_ASSERT(BinaryQueueToString(copy) == "abcdef");
}
-class Visitor
- : public DPL::BinaryQueue::BucketVisitor
+class Visitor :
+ public DPL::BinaryQueue::BucketVisitor
{
-private:
+ private:
int m_index;
-public:
- Visitor()
- : m_index(0)
- {
- }
+ public:
+ Visitor() :
+ m_index(0)
+ {}
virtual void OnVisitBucket(const void *buffer, size_t bufferSize)
{
const char *str = static_cast<const char *>(buffer);
-
- if (m_index == 0)
- {
+
+ if (m_index == 0) {
RUNNER_ASSERT(bufferSize == 4);
RUNNER_ASSERT(str[0] == 'a');
RUNNER_ASSERT(str[1] == 'b');
RUNNER_ASSERT(str[2] == 'c');
RUNNER_ASSERT(str[3] == 'd');
- }
- else if (m_index == 1)
- {
+ } else if (m_index == 1) {
RUNNER_ASSERT(bufferSize == 2);
RUNNER_ASSERT(str[0] == 'e');
RUNNER_ASSERT(str[1] == 'f');
- }
- else
- {
+ } else {
RUNNER_FAIL;
}
-
+
++m_index;
}
};
+/*
+Name: BinaryQueue_Visitor
+Description: tests byte by byte content of queue by use of visitor
+Expected: stringified content and size should match expected
+ Each byte should be at right position
+*/
RUNNER_TEST(BinaryQueue_Visitor)
{
DPL::BinaryQueue queue;
RUNNER_ASSERT(queue.Size() == 0);
}
+/*
+Name: BinaryQueue_AbstracOutputWrite
+Description: tests appending one queue to another
+Expected: written bytes shoudl affect content and size of queue
+*/
RUNNER_TEST(BinaryQueue_AbstracOutputWrite)
{
DPL::BinaryQueue queue;
class CBaseClass
{
-protected:
+ protected:
const char *m_name;
-public:
- CBaseClass(const char *name)
- : m_name(name)
- {
- }
+ public:
+ CBaseClass(const char *name) :
+ m_name(name)
+ {}
virtual ~CBaseClass()
- {
- }
+ {}
void SimpleMemberFunction(int num, const char *str)
{
LogDebug("In SimpleMemberFunction in " << m_name << ". Num="
- << num << ", str = " << str);
+ << num << ", str = " << str);
}
int SimpleMemberFunctionReturnsInt(int num, const char *str)
{
- LogDebug("In SimpleMemberFunctionReturnsInt in " << m_name << ". Num="
- << num << ", str = " << str);
+ LogDebug(
+ "In SimpleMemberFunctionReturnsInt in " << m_name << ". Num="
+ << num <<
+ ", str = " << str);
return -1;
}
void ConstMemberFunction(int num, const char *str) const
{
LogDebug("In ConstMemberFunction in " << m_name << ". Num="
- << num << ", str = " << str);
+ << num << ", str = " << str);
}
virtual void SimpleVirtualFunction(int num, const char *str)
{
LogDebug("In SimpleVirtualFunction in " << m_name << ". Num="
- << num << ", str = " << str);
+ << num << ", str = " << str);
}
static void StaticMemberFunction(int num, const char *str)
{
double rubbish; // to ensure this class has non-zero size.
-public:
+ public:
+ COtherClass() :
+ rubbish(0)
+ {}
+
virtual ~COtherClass()
- {
- }
+ {}
virtual void UnusedVirtualFunction(void)
- {
- }
+ {}
virtual void TrickyVirtualFunction(int num, const char *str) = 0;
};
class VeryBigClass
{
+ public:
+ VeryBigClass() {
+ memset(letsMakeThingsComplicated, 0,
+ 400 * sizeof(letsMakeThingsComplicated[0]));
+ }
+
+ private:
int letsMakeThingsComplicated[400];
};
// This declaration ensures that we get a convoluted class heirarchy.
-class CDerivedClass
- : public VeryBigClass,
- virtual public COtherClass,
- virtual public CBaseClass
+class CDerivedClass :
+ public VeryBigClass,
+ virtual public COtherClass,
+ virtual public CBaseClass
{
double m_somemember[8];
-public:
- CDerivedClass()
- : CBaseClass("Base of Derived")
+ public:
+ CDerivedClass() :
+ CBaseClass("Base of Derived")
{
m_somemember[0] = 1.2345;
}
virtual void AnotherUnusedVirtualFunction(int num, const char *str)
{
- LogDebug("In AnotherUnusedVirtualFunction in " << m_name << ". Num="
- << num << ", str = " << str);
+ LogDebug(
+ "In AnotherUnusedVirtualFunction in " << m_name << ". Num="
+ << num << ", str = " <<
+ str);
}
virtual void TrickyVirtualFunction(int num, const char *str)
{
LogDebug("In TrickyVirtualFunction in " << m_name << ". Num="
- << num << ", str = " << str);
+ << num << ", str = " << str);
}
};
+/*
+Name: FastDelegate_Test
+Description: tests several scenarios of using fast delegates
+Expected: function calls succeeded
+*/
RUNNER_TEST(FastDelegate_Test)
{
// Delegates with up to 8 parameters are supported.
// If you want to have a non-void return value, put it at the end.
typedef DPL::FastDelegate2<int, const char *, int> IntMyDelegate;
-
MyDelegate funclist[12]; // delegates are initialized to empty
CBaseClass a("Base A");
CBaseClass b("Base B");
// and const member functions (these only need a const class pointer).
funclist[3].bind((const CBaseClass *) &a,
- &CBaseClass::ConstMemberFunction);
+ &CBaseClass::ConstMemberFunction);
funclist[4].bind(&a, &CBaseClass::ConstMemberFunction);
const char *msg = "Looking for equal delegate";
- for (int i = 0; i < 12; i++)
- {
+ for (int i = 0; i < 12; i++) {
LogDebug(i << ":");
// The == and != operators are provided
// Note that they work even for inline functions.
- if (funclist[i] == dg)
- {
+ if (funclist[i] == dg) {
msg = "Found equal delegate";
}
// operator ! can be used to test for an empty delegate
// You can also use the .empty() member function.
- if (!funclist[i])
- {
+ if (!funclist[i]) {
LogDebug("Delegate is empty");
- }
- else
- {
+ } else {
// Invocation generates optimal assembly code.
funclist[i](i, msg);
}
{
++numberOfCallsToTemporaryList;
std::list<size_t> list;
- for (size_t i = 0 ; i < testContainerSize ; i++)
- {
+ for (size_t i = 0; i < testContainerSize; i++) {
list.push_back(i);
}
return list;
{
++numberOfCallsToTemporaryVector;
std::vector<size_t> vector;
- for (size_t i = 0 ; i < testContainerSize ; i++)
- {
+ for (size_t i = 0; i < testContainerSize; i++) {
vector.push_back(i);
}
return vector;
{
++numberOfCallsToTemporarySet;
std::set<size_t> set;
- for (size_t i = 0 ; i < testContainerSize ; i++)
- {
+ for (size_t i = 0; i < testContainerSize; i++) {
set.insert(i);
}
return set;
}
+/*
+Name: Foreach_std_containers
+Description: tests iterating contianers set, list, vector using foreach
+Expected: value supplied by foreach matches sequence of integers
+*/
RUNNER_TEST(Foreach_std_containers)
{
std::vector<size_t> vector;
std::list<size_t> list;
std::set<size_t> set;
- for (size_t i = 0 ; i < testContainerSize ; i++)
- {
+ for (size_t i = 0; i < testContainerSize; i++) {
vector.push_back(i);
list.push_back(i);
set.insert(i);
RUNNER_TEST_GROUP_INIT(DPL)
class MyException
-{
-};
+{};
class MyDPLException
{
-public:
+ public:
DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
DECLARE_EXCEPTION_TYPE(Base, MyException)
};
-class MySTDException
- : public std::exception
+class MySTDException :
+ public std::exception
{
-public:
- virtual const char* what()const throw() { return "my std exception occurred";}
+ public:
+ virtual const char* what() const throw()
+ {
+ return "my std exception occurred";
+ }
};
+/*
+Name: Log_Unknown_Exception
+Description: tests exceptions catching macros
+Expected: unknown exception should be catched
+
+TODO: workaround abort call
+*/
RUNNER_TEST(Log_Unknown_Exception)
{
UNHANDLED_EXCEPTION_HANDLER_BEGIN
{
-// throw MyException();
+ // throw MyException();
}
UNHANDLED_EXCEPTION_HANDLER_END
RUNNER_ASSERT(true);
}
+/*
+Name: Log_DPL_Exception
+Description: tests exceptions catching macros
+Expected: DPL exception should be catched
+
+TODO: workaround abort call
+*/
RUNNER_TEST(Log_DPL_Exception)
{
UNHANDLED_EXCEPTION_HANDLER_BEGIN
{
-// Throw(MyDPLException::MyException);
+ // Throw(MyDPLException::MyException);
}
UNHANDLED_EXCEPTION_HANDLER_END
RUNNER_ASSERT(true);
}
+/*
+Name: Log_STD_Exception
+Description: tests exceptions catching macros
+Expected: STD exception should be catched
+
+TODO: workaround abort call
+*/
RUNNER_TEST(Log_STD_Exception)
{
UNHANDLED_EXCEPTION_HANDLER_BEGIN
{
-// throw MySTDException();
+ // throw MySTDException();
}
UNHANDLED_EXCEPTION_HANDLER_END
RUNNER_ASSERT(true);
RUNNER_ASSERT_MSG(g_counter == 1, "Counter value is: " << g_counter);
}
-class MyThread
- : public DPL::Thread
+class MyThread :
+ public DPL::Thread
{
-protected:
+ protected:
virtual int ThreadEntry()
{
DPL::WaitForSingleHandle(m_event->GetHandle());
++*m_atom;
}
-public:
- MyThread(DPL::WaitableEvent *event, DPL::Once *once, DPL::Atomic *atom)
- : m_event(event), m_once(once), m_atom(atom)
- {
- }
+ public:
+ MyThread(DPL::WaitableEvent *event, DPL::Once *once, DPL::Atomic *atom) :
+ m_event(event), m_once(once), m_atom(atom)
+ {}
-private:
+ private:
DPL::WaitableEvent *m_event;
DPL::Once *m_once;
DPL::Atomic *m_atom;
};
+/*
+Name: Once_MultiThreadCall
+Description: tests once call wrapper for use by multiple threads
+Expected: function should be called just once from one of running threads
+*/
RUNNER_TEST(Once_MultiThreadCall)
{
const size_t NUM_THREADS = 20;
DPL::Once once;
DPL::Atomic atom;
- for (size_t i = 0; i< NUM_THREADS; ++i)
- {
+ for (size_t i = 0; i < NUM_THREADS; ++i) {
(threads[i] = ThreadPtr(new MyThread(&event, &once, &atom)))->Run();
}
event.Signal();
- for (size_t i = 0; i< NUM_THREADS; ++i)
+ for (size_t i = 0; i < NUM_THREADS; ++i) {
threads[i]->Quit();
+ }
RUNNER_ASSERT_MSG(atom == 1, "Atom value is: " << atom);
}
RUNNER_TEST_GROUP_INIT(DPL)
+/*
+Name: ScopedArray_Zero
+Description: tests emptiness of empty scoped array
+Expected: array should be empty
+*/
RUNNER_TEST(ScopedArray_Zero)
{
DPL::ScopedArray<char> array;
RUNNER_ASSERT(!!!array);
}
+/*
+Name: ScopedArray_NonZero
+Description: tests emptiness of not empty scoped array
+Expected: array should be not empty
+*/
RUNNER_TEST(ScopedArray_NonZero)
{
DPL::ScopedArray<char> array(new char[7]);
RUNNER_ASSERT(!!array);
}
+/*
+Name: ScopedArray_Reset
+Description: tests reseting content of array
+Expected: array should be empty after reset
+*/
RUNNER_TEST(ScopedArray_Reset)
{
DPL::ScopedArray<char> array(new char[7]);
RUNNER_ASSERT(array);
}
+/*
+Name: ScopedArray_ArrayOperator
+Description: tests accessing elements of array
+Expected: returned values should be equal to those which were set
+*/
RUNNER_TEST(ScopedArray_ArrayOperator)
{
DPL::ScopedArray<char> array(new char[7]);
--- /dev/null
+/*
+ * Copyright (c) 2013 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 test_scoped_dir.cpp
+ * @author Iwanek Tomasz (t.iwanek@smasung.com)
+ * @version 1.0
+ * @brief Scoped directory test
+ */
+#include <dpl/test/test_runner.h>
+#include <dpl/scoped_dir.h>
+
+#include <cstdio>
+#include <sstream>
+#include <cstdlib>
+
+#include <unistd.h>
+
+RUNNER_TEST_GROUP_INIT(DPL)
+
+/*
+Name: ScopedDir_Basic
+Description: tests if scoped directory is working
+Expected: directory created and removed
+*/
+RUNNER_TEST(ScopedDir_Basic)
+{
+ const char * path = "/tmp/wrttest123456";
+ if(access(path, F_OK) == 0)
+ {
+ RUNNER_ASSERT_MSG(!remove(path), "Cannot remove test directory");
+ }
+
+ {
+ DPL::ScopedDir dir(path, S_IRUSR | S_IWUSR);
+ std::ostringstream command;
+ command << "touch " << path << "/" << "file.txt";
+ (void)system(command.str().c_str());
+ RUNNER_ASSERT_MSG(access(path, R_OK) == 0, "Directory should be accessible");
+ RUNNER_ASSERT_MSG(access(path, W_OK) == 0, "Directory should be writable");
+ }
+ RUNNER_ASSERT_MSG(access(path, F_OK) != 0, "Directory should not exists");
+}
RUNNER_TEST_GROUP_INIT(DPL)
-namespace
-{
+namespace {
FILE* MakeTmp()
{
FILE* result = NULL;
- do
- {
+ do {
result = tmpfile();
} while (NULL != result && EINTR == errno);
return result;
}
-}//anonymous namespace
+} //anonymous namespace
+/*
+Name: ScopedFClose_Zero
+Description: tests if operator ! works correct for closed file
+Expected: file should be closed
+*/
RUNNER_TEST(ScopedFClose_Zero)
{
DPL::ScopedFClose file;
RUNNER_ASSERT(!!!file);
}
+/*
+Name: ScopedArray_NonZero
+Description: tests if operator ! works correct for open file
+Expected: file should be open
+*/
RUNNER_TEST(ScopedFClose_NonZero)
{
DPL::ScopedFClose file(MakeTmp());
RUNNER_ASSERT(!!file);
}
+/*
+Name: ScopedFClose_Reset
+Description: tests reseting of scoped file
+Expected: file should be closed after reset
+*/
RUNNER_TEST(ScopedFClose_Reset)
{
DPL::ScopedFClose file(MakeTmp());
RUNNER_TEST_GROUP_INIT(DPL)
+/*
+Name: ScopedFree_Zero
+Description: Checks emptiness of not set scoped free
+Expected: resource should be freed
+*/
RUNNER_TEST(ScopedFree_Zero)
{
DPL::ScopedFree<void> free;
RUNNER_ASSERT(!!!free);
}
+/*
+Name: ScopedFree_NonZero
+Description: Checks emptiness of set scoped free
+Expected: resource should not be reported as freed
+*/
RUNNER_TEST(ScopedFree_NonZero)
{
DPL::ScopedFree<void> free(malloc(7));
RUNNER_ASSERT(!!free);
}
+/*
+Name: ScopedFree_Reset
+Description: Checks reseting scoped free
+Expected: resource should be freed after reset
+*/
RUNNER_TEST(ScopedFree_Reset)
{
DPL::ScopedFree<void> free(malloc(7));
RUNNER_TEST_GROUP_INIT(DPL)
+/*
+Name: ScopedPtr_Zero
+Description: Checks if operator! works
+Expected: resource should be not set
+*/
RUNNER_TEST(ScopedPtr_Zero)
{
DPL::ScopedPtr<char> ptr;
RUNNER_ASSERT(!!!ptr);
}
+/*
+Name: ScopedPtr_NonZero
+Description: Checks if operator! works
+Expected: resource should be set
+*/
RUNNER_TEST(ScopedPtr_NonZero)
{
DPL::ScopedPtr<char> ptr(new char(7));
RUNNER_ASSERT(!!ptr);
}
+/*
+Name: ScopedPtr_Reset
+Description: Checks reseting scoped ptr
+Expected: resource should be not set after reset
+*/
RUNNER_TEST(ScopedPtr_Reset)
{
DPL::ScopedPtr<char> ptr(new char(7));
RUNNER_ASSERT(ptr);
}
+/*
+Name: ScopedPtr_Operators
+Description: Checks access operator
+Expected: address of resource should be same as this, received from Get() method
+*/
RUNNER_TEST(ScopedPtr_Operators)
{
DPL::ScopedPtr<char> ptr(new char(7));
RUNNER_TEST_GROUP_INIT(DPL)
-class SemaphoreThread
- : public DPL::Thread
+class SemaphoreThread :
+ public DPL::Thread
{
int m_delta;
int m_times;
int *m_value;
std::string m_semaphoreName;
-public:
+ public:
SemaphoreThread(int delta,
int times,
int *value,
- const std::string &semaphoreName)
- : m_delta(delta),
- m_times(times),
- m_value(value),
- m_semaphoreName(semaphoreName)
- {
- }
+ const std::string &semaphoreName) :
+ m_delta(delta),
+ m_times(times),
+ m_value(value),
+ m_semaphoreName(semaphoreName)
+ {}
-protected:
+ protected:
virtual int ThreadEntry()
{
DPL::Semaphore semaphore(m_semaphoreName);
- for (int i = 0; i < m_times; ++i)
- {
+ for (int i = 0; i < m_times; ++i) {
// Take scoped semaphore lock
DPL::Semaphore::ScopedLock lock(&semaphore);
*m_value += m_delta;
}
};
+/*
+Name: Semaphore_NamedIncrementDecrement
+Description: Checks if semaphore are working
+Expected: value should not change after all
+*/
RUNNER_TEST(Semaphore_NamedIncrementDecrement)
{
std::string semaphoreName =
RUNNER_TEST_GROUP_INIT(DPL)
// test stream class
-class BinaryStream : public DPL::IStream {
+class BinaryStream : public DPL::IStream
+{
public:
virtual void Read(size_t num, void * bytes)
{
{
readPosition = 0;
}
- virtual ~BinaryStream(){};
+ virtual ~BinaryStream(){}
private:
std::vector<unsigned char> data;
};
//test ISerializable class
-class TestClass : public DPL::ISerializable {
+class TestClass : public DPL::ISerializable
+{
public:
TestClass(int val, std::string str1, std::string str2)
{
c.push_back(str1);
c.push_back(str2);
c.push_back(str1 + str2);
- };
- TestClass(DPL::IStream& stream)
+ }
+ TestClass(DPL::IStream& stream) :
+ a(0) //TODO: consider the need (g.rynkowski)
{
- DPL::Deserialization::Deserialize(stream,a);
- DPL::Deserialization::Deserialize(stream,b);
- DPL::Deserialization::Deserialize(stream,c);
- };
+ DPL::Deserialization::Deserialize(stream, a);
+ DPL::Deserialization::Deserialize(stream, b);
+ DPL::Deserialization::Deserialize(stream, c);
+ }
virtual void Serialize(DPL::IStream& stream) const
{
- DPL::Serialization::Serialize(stream,a);
- DPL::Serialization::Serialize(stream,b);
- DPL::Serialization::Serialize(stream,c);
+ DPL::Serialization::Serialize(stream, a);
+ DPL::Serialization::Serialize(stream, b);
+ DPL::Serialization::Serialize(stream, c);
}
virtual ~TestClass(){}
virtual bool operator==(const TestClass& other)
c[1] == other.c[1] &&
c[2] == other.c[2]);
}
+
private:
int a;
std::string b;
std::vector<std::string> c;
};
+/*
+Name: Serialize_primitives
+Description: Tests serialization of primitives types
+Expected: serialized value after deserialization
+ should be equal to deserialied value
+*/
RUNNER_TEST(Serialize_primitives)
{
int a = 1;
bool b = true;
unsigned c = 23;
BinaryStream stream;
- DPL::Serialization::Serialize(stream,a);
- DPL::Serialization::Serialize(stream,b);
- DPL::Serialization::Serialize(stream,c);
+ DPL::Serialization::Serialize(stream, a);
+ DPL::Serialization::Serialize(stream, b);
+ DPL::Serialization::Serialize(stream, c);
int test_int;
- DPL::Deserialization::Deserialize(stream,test_int);
+ DPL::Deserialization::Deserialize(stream, test_int);
RUNNER_ASSERT(test_int == a);
bool test_bool;
- DPL::Deserialization::Deserialize(stream,test_bool);
+ DPL::Deserialization::Deserialize(stream, test_bool);
RUNNER_ASSERT(test_bool == b);
unsigned test_unsigned;
- DPL::Deserialization::Deserialize(stream,test_unsigned);
+ DPL::Deserialization::Deserialize(stream, test_unsigned);
RUNNER_ASSERT(test_unsigned == c);
}
+/*
+Name: Serialize_primitive_pointers
+Description: Tests serialization of primitives pointer types
+Expected: serialized value after deserialization
+ should be equal to deserialied value
+*/
RUNNER_TEST(Serialize_primitive_pointers)
{
int a = 1;
bool b = true;
unsigned c = 23;
BinaryStream stream;
- DPL::Serialization::Serialize(stream,&a);
- DPL::Serialization::Serialize(stream,&b);
- DPL::Serialization::Serialize(stream,&c);
+ DPL::Serialization::Serialize(stream, &a);
+ DPL::Serialization::Serialize(stream, &b);
+ DPL::Serialization::Serialize(stream, &c);
int* test_int;
- DPL::Deserialization::Deserialize(stream,test_int);
+ DPL::Deserialization::Deserialize(stream, test_int);
RUNNER_ASSERT(test_int != NULL && *test_int == a);
bool* test_bool;
- DPL::Deserialization::Deserialize(stream,test_bool);
+ DPL::Deserialization::Deserialize(stream, test_bool);
RUNNER_ASSERT(test_bool != NULL && *test_bool == b);
unsigned* test_unsigned;
- DPL::Deserialization::Deserialize(stream,test_unsigned);
+ DPL::Deserialization::Deserialize(stream, test_unsigned);
RUNNER_ASSERT(test_unsigned != NULL && *test_unsigned == c);
delete test_int;
delete test_bool;
delete test_unsigned;
}
+/*
+Name: Serialize_strings
+Description: Tests serialization of strings
+Expected: serialized value after deserialization
+ should be equal to deserialied value
+*/
RUNNER_TEST(Serialize_strings)
{
std::string str1 = "ALA MA KOTA";
std::string str2 = "MULTILINE\nTEST";
BinaryStream stream;
- DPL::Serialization::Serialize(stream,str1);
- DPL::Serialization::Serialize(stream,str2);
+ DPL::Serialization::Serialize(stream, str1);
+ DPL::Serialization::Serialize(stream, str2);
std::string test_str1;
- DPL::Deserialization::Deserialize(stream,test_str1);
+ DPL::Deserialization::Deserialize(stream, test_str1);
RUNNER_ASSERT(test_str1 == str1);
std::string test_str2;
- DPL::Deserialization::Deserialize(stream,test_str2);
+ DPL::Deserialization::Deserialize(stream, test_str2);
RUNNER_ASSERT(test_str2 == str2);
}
+/*
+Name: Serialize_string_pointers
+Description: Tests serialization of string pointers
+Expected: serialized value after deserialization
+ should be equal to deserialied value
+*/
RUNNER_TEST(Serialize_string_pointers)
{
std::string str1 = "ALA MA KOTA";
std::string str2 = "MULTILINE\nTEST";
BinaryStream stream;
- DPL::Serialization::Serialize(stream,&str1);
- DPL::Serialization::Serialize(stream,&str2);
+ DPL::Serialization::Serialize(stream, &str1);
+ DPL::Serialization::Serialize(stream, &str2);
std::string* test_str1;
- DPL::Deserialization::Deserialize(stream,test_str1);
+ DPL::Deserialization::Deserialize(stream, test_str1);
RUNNER_ASSERT(test_str1 != NULL && *test_str1 == str1);
std::string* test_str2;
- DPL::Deserialization::Deserialize(stream,test_str2);
+ DPL::Deserialization::Deserialize(stream, test_str2);
RUNNER_ASSERT(test_str2 != NULL && *test_str2 == str2);
delete test_str1;
delete test_str2;
}
+/*
+Name: Serialize_containers
+Description: Tests serialization of containers
+Expected: serialized value after deserialization
+ should be equal to deserialied value
+*/
RUNNER_TEST(Serialize_containers)
{
std::vector<int> vec;
std::list<bool> list;
list.push_back(true);
list.push_back(false);
- std::pair<int,unsigned> pair;
+ std::pair<int, unsigned> pair;
pair.first = -23;
pair.second = 1234;
- std::map<int,std::string> map;
- map.insert(std::pair<int,std::string>(45, "ALA MA CZARNEGO KOTA"));
- map.insert(std::pair<int,std::string>(-78, "...A MOZE\nMA\nWIELE LINIJEK"));
+ std::map<int, std::string> map;
+ map.insert(std::pair<int, std::string>(45, "ALA MA CZARNEGO KOTA"));
+ map.insert(std::pair<int, std::string>(-78, "...A MOZE\nMA\nWIELE LINIJEK"));
BinaryStream stream;
- DPL::Serialization::Serialize(stream,vec);
- DPL::Serialization::Serialize(stream,list);
- DPL::Serialization::Serialize(stream,pair);
- DPL::Serialization::Serialize(stream,map);
+ DPL::Serialization::Serialize(stream, vec);
+ DPL::Serialization::Serialize(stream, list);
+ DPL::Serialization::Serialize(stream, pair);
+ DPL::Serialization::Serialize(stream, map);
std::vector<int> test_vec;
- DPL::Deserialization::Deserialize(stream,test_vec);
+ DPL::Deserialization::Deserialize(stream, test_vec);
RUNNER_ASSERT(test_vec.size() == vec.size() &&
test_vec[0] == vec[0] && test_vec[1] == vec[1]);
std::list<bool> test_list;
- DPL::Deserialization::Deserialize(stream,test_list);
+ DPL::Deserialization::Deserialize(stream, test_list);
RUNNER_ASSERT(test_list.size() == list.size() &&
test_list.front() == list.front() &&
test_list.back() == test_list.back());
- std::pair<int,unsigned> test_pair;
- DPL::Deserialization::Deserialize(stream,test_pair);
+ std::pair<int, unsigned> test_pair;
+ DPL::Deserialization::Deserialize(stream, test_pair);
RUNNER_ASSERT(test_pair.first == pair.first &&
test_pair.second == pair.second);
- std::map<int,std::string> test_map;
- DPL::Deserialization::Deserialize(stream,test_map);
+ std::map<int, std::string> test_map;
+ DPL::Deserialization::Deserialize(stream, test_map);
RUNNER_ASSERT(test_map.size() == map.size() &&
test_map.at(45) == map.at(45) &&
test_map.at(-78) == map.at(-78));
}
+/*
+Name: Serialize_objects
+Description: Tests serialization of DPL::ISerializable derived objects
+Expected: serialized value after deserialization
+ should be equal to deserialied value
+*/
RUNNER_TEST(Serialize_objects)
{
- TestClass a(123,"ASDGHUADB\n\n5679b^^()*","TEST_STRING"),
- b(679,"HUSPIDNSAHDPA","\nASDSADASD\naDSADASD8");
+ TestClass a(123, "ASDGHUADB\n\n5679b^^()*", "TEST_STRING"),
+ b(679, "HUSPIDNSAHDPA", "\nASDSADASD\naDSADASD8");
BinaryStream stream;
- DPL::Serialization::Serialize(stream,a);
- DPL::Serialization::Serialize(stream,b);
- TestClass test_a(0,"",""), test_b(0,"","");
+ DPL::Serialization::Serialize(stream, a);
+ DPL::Serialization::Serialize(stream, b);
+ TestClass test_a(0, "", ""), test_b(0, "", "");
DPL::Deserialization::Deserialize(stream, test_a);
RUNNER_ASSERT(test_a == a);
DPL::Deserialization::Deserialize(stream, test_b);
RUNNER_ASSERT(test_b == b);
}
+/*
+Name: Serialize_all
+Description: Tests serialization of compound objects
+Expected: serialized value after deserialization
+ should be equal to deserialied value
+*/
RUNNER_TEST(Serialize_all)
{
std::map<std::string, std::vector<TestClass*> > map;
std::vector<TestClass*> vec;
- vec.push_back(new TestClass(123,"ASDGHUADB\n\n5679b^^()*","TEST_STRING"));
- vec.push_back(new TestClass(679,"HUSPIDNSAHDPA","\nASDSADASD\naDSADASD8"));
- map.insert(std::pair<std::string,std::vector<TestClass*> >("KEY1",vec));
- map.insert(std::pair<std::string,std::vector<TestClass*> >("KEY2",vec));
+ vec.push_back(new TestClass(123, "ASDGHUADB\n\n5679b^^()*", "TEST_STRING"));
+ vec.push_back(new TestClass(679, "HUSPIDNSAHDPA", "\nASDSADASD\naDSADASD8"));
+ map.insert(std::pair<std::string, std::vector<TestClass*> >("KEY1", vec));
+ map.insert(std::pair<std::string, std::vector<TestClass*> >("KEY2", vec));
BinaryStream stream;
DPL::Serialization::Serialize(stream, map);
std::map<std::string, std::vector<TestClass*> > test_map;
- DPL::Deserialization::Deserialize(stream,test_map);
+ DPL::Deserialization::Deserialize(stream, test_map);
RUNNER_ASSERT(map.size() == test_map.size());
- std::vector<TestClass*> test_vec1,test_vec2;
+ std::vector<TestClass*> test_vec1, test_vec2;
test_vec1 = map.at("KEY1");
test_vec2 = test_map.at("KEY1");
RUNNER_ASSERT(test_vec1.size() == test_vec2.size());
unsigned i;
- for (i = 0; i < test_vec1.size(); ++i)
- {
+ for (i = 0; i < test_vec1.size(); ++i) {
RUNNER_ASSERT((*test_vec1[i]) == (*test_vec2[i]));
}
test_vec1 = map.at("KEY2");
test_vec2 = test_map.at("KEY2");
RUNNER_ASSERT(test_vec1.size() == test_vec2.size());
- for (i = 0; i < test_vec1.size(); ++i)
- {
+ for (i = 0; i < test_vec1.size(); ++i) {
RUNNER_ASSERT((*test_vec1[i]) == (*test_vec2[i]));
}
}
RUNNER_TEST_GROUP_INIT(DPL)
+/*
+Name: SharedPtr_Zero
+Description: Tests behaviour of null shared pointer
+Expected: pointer should imitate null pointer
+*/
RUNNER_TEST(SharedPtr_Zero)
{
DPL::SharedPtr<char> ptr;
RUNNER_ASSERT(ptr == DPL::SharedPtr<char>());
}
+/*
+Name: SharedPtr_NonZero
+Description: Tests behaviour of not null shared pointer
+Expected: pointer should imitate null pointer
+*/
RUNNER_TEST(SharedPtr_NonZero)
{
DPL::SharedPtr<char> ptr(new char(7));
RUNNER_ASSERT(ptr != DPL::SharedPtr<char>());
}
+/*
+Name: SharedPtr_Copy
+Description: Tests equality of shared pointer pointing same resource
+Expected: pointers should imitate primitive pointer bahaviour
+*/
RUNNER_TEST(SharedPtr_Copy)
{
DPL::SharedPtr<char> ptr1(new char(7));
RUNNER_ASSERT(ptr1 == ptr2);
}
+/*
+Name: SharedPtr_Reset
+Description: Tests reseting shared pointer
+Expected: pointers should imitate primitive pointer bahaviour after reset
+*/
RUNNER_TEST(SharedPtr_Reset)
{
DPL::SharedPtr<char> ptr(new char(7));
RUNNER_ASSERT(ptr);
}
+/*
+Name: SharedPtr_RefCounting
+Description: Tests use count od shared pointer
+Expected: counters should be equal for equal pointers
+ Count number should match expected
+*/
RUNNER_TEST(SharedPtr_RefCounting)
{
DPL::SharedPtr<char> ptr1(new char(7));
RUNNER_ASSERT(ptr1.GetUseCount() == 2);
}
+/*
+Name: SharedPtr_Operators
+Description: Tests use of operator*
+Expected: pointers should imitate primitive pointer bahaviour
+*/
RUNNER_TEST(SharedPtr_Operators)
{
DPL::SharedPtr<char> ptr(new char(7));
--- /dev/null
+/*
+ * Copyright (c) 2013 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 test_static_block.cpp
+ * @author Tomasz Iwanek (t.iwanek@samsung.com)
+ * @version 0.1
+ * @brief
+ */
+
+#include <dpl/test/test_runner.h>
+#include <dpl/static_block.h>
+
+RUNNER_TEST_GROUP_INIT(DPL)
+
+namespace {
+bool ok_namespace = false;
+bool ok_class = false;
+
+STATIC_BLOCK
+{
+ ok_namespace = true;
+}
+
+struct A
+{
+ static void init()
+ {
+ ok_class = true;
+ }
+};
+STATIC_BLOCK_CLASS( A, init )
+}
+
+/*
+Name: StaticBlockInitCheck
+Description: checks if static blocks were run
+Expected: variables should be set
+*/
+RUNNER_TEST(StaticBlockInitCheck)
+{
+ RUNNER_ASSERT(ok_namespace);
+ RUNNER_ASSERT(ok_class);
+}
#include <cmath>
#include <cstring>
#include <vector>
+#include <string>
#include <dpl/test/test_runner.h>
#include <dpl/string.h>
#include <dpl/sstream.h>
unsigned char GetBaseCode(int index)
{
/* aaaack but it's fast and const should make it shared text page. */
- static const unsigned char pr2six[256] =
- {
+ static const unsigned char pr2six[256] = {
/* ASCII table */
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 62, 64, 64, 64, 63,
52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 64, 64, 64, 64, 64, 64,
- 64, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+ 64, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 64, 64, 64, 64, 64,
64, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 64, 64, 64, 64, 64,
return pr2six[index];
}
-
/* Function adapted from APR library (http://apr.apache.org/) */
int wbxml_base64_decode(const char *buffer, char **result);
int wbxml_base64_decode(const char *buffer, char **result)
const char *bufin = NULL;
char *bufout = NULL;
- if ((buffer == NULL) || (result == NULL))
+ if ((buffer == NULL) || (result == NULL)) {
return 0;
+ }
/* Initialize output buffer */
*result = NULL;
nbytesdecoded = ((nprbytes + 3) / 4) * 3;
/* Malloc result buffer */
- if ((*result = (char*) malloc(nbytesdecoded + 1)) == NULL)
+ if ((*result = (char*) malloc(nbytesdecoded + 1)) == NULL) {
return 0;
- memset(*result, nbytesdecoded + 1, 0);
+ }
+ memset(*result, 0, nbytesdecoded + 1);
bufout = *result;
bufin = buffer;
- while (nprbytes > 4)
- {
- *(bufout++) = (char)(GetBaseCode(*bufin) << 2 | GetBaseCode(bufin[1]) >> 4);
- *(bufout++) = (char)(GetBaseCode(bufin[1]) << 4 | GetBaseCode(bufin[2]) >> 2);
+ while (nprbytes > 4) {
+ *(bufout++) =
+ (char)(GetBaseCode(*bufin) << 2 | GetBaseCode(bufin[1]) >> 4);
+ *(bufout++) =
+ (char)(GetBaseCode(bufin[1]) << 4 | GetBaseCode(bufin[2]) >> 2);
*(bufout++) = (char)(GetBaseCode(bufin[2]) << 6 | GetBaseCode(bufin[3]));
bufin += 4;
nprbytes -= 4;
}
/* Note: (nprbytes == 1) would be an error, so just ingore that case */
- if (nprbytes > 1)
- {
- *(bufout++) = (char)(GetBaseCode(*bufin) << 2 | GetBaseCode(bufin[1]) >> 4);
+ if (nprbytes > 1) {
+ *(bufout++) =
+ (char)(GetBaseCode(*bufin) << 2 | GetBaseCode(bufin[1]) >> 4);
}
- if (nprbytes > 2)
- {
- *(bufout++) = (char)(GetBaseCode(bufin[1]) << 4 | GetBaseCode(bufin[2]) >> 2);
+ if (nprbytes > 2) {
+ *(bufout++) =
+ (char)(GetBaseCode(bufin[1]) << 4 | GetBaseCode(bufin[2]) >> 2);
}
- if (nprbytes > 3)
- {
+ if (nprbytes > 3) {
*(bufout++) = (char)(GetBaseCode(bufin[2]) << 6 | GetBaseCode(bufin[3]));
}
//#define TEST_CONVERSION(in_string, out_string, buffer_type, function
const char utf32Encoded[] =
-"RDAAAI0wAABvMAAAazAAAHswAAB4MAAAaDAAAAAwAABhMAAAijAAAGwwAACLMAAAkjAAAAAwAACP\
+ "RDAAAI0wAABvMAAAazAAAHswAAB4MAAAaDAAAAAwAABhMAAAijAAAGwwAACLMAAAkjAAAAAwAACP\
MAAASzAAAIgwAABfMAAAjDAAAF0wAAAAMAAAZDAAAG0wAABqMAAAiTAAAIAwAAAAMAAARjAAAJAw\
AABuMAAASjAAAE8wAACEMAAAfjAAAAAwAABRMAAAdTAAAFMwAABIMAAAZjAAAAAwAABCMAAAVTAA\
AE0wAACGMAAAgTAAAH8wAABXMAAAADAAAJEwAAByMAAAgjAAAFswAABZMAAACgAAANsFAADaBQAA\
AAAACgAAAAAAAAA=";
const char utf8Encoded[] =
-"44GE44KN44Gv44Gr44G744G444Go44CA44Gh44KK44Gs44KL44KS44CA44KP44GL44KI44Gf44KM\
+ "44GE44KN44Gv44Gr44G744G444Go44CA44Gh44KK44Gs44KL44KS44CA44KP44GL44KI44Gf44KM\
44Gd44CA44Gk44Gt44Gq44KJ44KA44CA44GG44KQ44Gu44GK44GP44KE44G+44CA44GR44G144GT\
44GI44Gm44CA44GC44GV44GN44KG44KB44G/44GX44CA44KR44Gy44KC44Gb44GZCteb15og15TX\
qteo16HXpyDXoNek16Ug16LXnCDXkteV15bXnCDXp9eY158sINep15PXl9ejINeQ16og16bXkdeZ\
vc+Mz4IKVmljdG9yIGphZ3QgenfDtmxmIEJveGvDpG1wZmVyIHF1ZXIgw7xiZXIgZGVuIGdyb8Of\
ZW4gU3lsdGVyIERlaWNoCuimlumHjueEoemZkOW7o++8jOeql+WkluacieiXjeWkqQoKAA==";
-
-
-
const char asciiEncodedIso1[] =
-"ISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZ\
+ "ISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZ\
WltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fgA=";
-const char asciiEncodedUtf32[] =
-"IQAAACIAAAAjAAAAJAAAACUAAAAmAAAAJwAAACgAAAApAAAAKgAAACsAAAAsAAAALQAAAC4AAAAv\
+const char asciiEncodedUtf32[] =
+ "IQAAACIAAAAjAAAAJAAAACUAAAAmAAAAJwAAACgAAAApAAAAKgAAACsAAAAsAAAALQAAAC4AAAAv\
AAAAMAAAADEAAAAyAAAAMwAAADQAAAA1AAAANgAAADcAAAA4AAAAOQAAADoAAAA7AAAAPAAAAD0A\
AAA+AAAAPwAAAEAAAABBAAAAQgAAAEMAAABEAAAARQAAAEYAAABHAAAASAAAAEkAAABKAAAASwAA\
AEwAAABNAAAATgAAAE8AAABQAAAAUQAAAFIAAABTAAAAVAAAAFUAAABWAAAAVwAAAFgAAABZAAAA\
AAAAaQAAAGoAAABrAAAAbAAAAG0AAABuAAAAbwAAAHAAAABxAAAAcgAAAHMAAAB0AAAAdQAAAHYA\
AAB3AAAAeAAAAHkAAAB6AAAAewAAAHwAAAB9AAAAfgAAAAAAAAA=";
-
+/*
+Name: String_ConverterFromASCII
+Description: tests construction of string from ascii data
+Expected: data stored in buffer should match expected
+*/
RUNNER_TEST(String_ConverterFromASCII)
{
char* inStr = NULL;
free(inStr);
}
+/*
+Name: String_ConverterFromUTF8
+Description: tests construction of string from UTF-8 data
+Expected: data stored in buffer should match expected
+*/
RUNNER_TEST(String_ConverterFromUTF8)
{
char* inStr = NULL;
free(inStr);
}
+/*
+Name: String_ConverterFromUTF32
+Description: tests construction of string from UTF-32 data
+Expected: data stored in buffer should match expected
+*/
RUNNER_TEST(String_ConverterFromUTF32)
{
wchar_t* inStr = NULL;
- int inSize = wbxml_base64_decode(utf32Encoded, reinterpret_cast<char**>(&inStr));
+ int inSize =
+ wbxml_base64_decode(utf32Encoded, reinterpret_cast<char**>(&inStr));
RUNNER_ASSERT(inSize > 0);
RUNNER_ASSERT(NULL != inStr);
char* outStr = NULL;
RUNNER_ASSERT(strlen(outStr) == result.size());
RUNNER_ASSERT(0 == memcmp(outStr, result.c_str(), result.size()));
-
RUNNER_ASSERT(inSize / sizeof(wchar_t) - 1 == utfString.size());
- RUNNER_ASSERT(0 == memcmp(inStr, &(utfString[0]), utfString.size() * sizeof(wchar_t)));
-
+ RUNNER_ASSERT(0 ==
+ memcmp(inStr, &(utfString[0]), utfString.size() *
+ sizeof(wchar_t)));
}
free(inStr);
DPL::Tokenize(str, delimiter, std::back_inserter(tokens));
std::vector<DPL::String> expectedTokens;
- for ( int i = 0 ; i < 5 ; i++ )
+ for (int i = 0; i < 5; i++) {
expectedTokens.push_back(L"");
+ }
expectedTokens.push_back(L"abc");
- for ( int i = 0 ; i < 3 ; i++ )
+ for (int i = 0; i < 3; i++) {
expectedTokens.push_back(L"");
+ }
RUNNER_ASSERT(expectedTokens == tokens);
tokens.clear();
RUNNER_ASSERT(expectedTokens == tokens);
}
+/*
+Name: String_Tokenize
+Description: tests of string splitting
+Expected: returned substring should match expected values
+*/
RUNNER_TEST(String_Tokenize)
{
String_TokenizeReal(L"#.");
{
typedef std::basic_string<typename TemplateArgumentCharTraits::char_type,
TemplateArgumentCharTraits>
- String;
+ String;
std::basic_istringstream<typename TemplateArgumentCharTraits::char_type,
TemplateArgumentCharTraits>
- istream(argumentInString);
+ istream(argumentInString);
int intValue = 0;
double doubleValue = 0.0;
float floatValue = 0.0;
{
typedef std::basic_string<typename TemplateArgumentCharTraits::char_type,
TemplateArgumentCharTraits>
- String;
+ String;
std::basic_ostringstream<typename TemplateArgumentCharTraits::char_type,
TemplateArgumentCharTraits>
- ostream;
+ ostream;
int intValue = 1;
double doubleValue = 1.1;
RUNNER_ASSERT(ostream.str() == argumentResultString);
}
+/*
+Name: String_Streams
+Description: tests of input/output stream
+Expected: returned substrign should match expected values
+*/
RUNNER_TEST(String_Streams)
{
TestInStreams<std::char_traits<char> >("1 1.1 1.1 test", "test");
TestInStreams<std::char_traits<wchar_t> >(L"1 1.1 1.1 test", L"test");
TestInStreams<DPL::CharTraits>(L"1 1.1 1.1 test", L"test");
- TestOutStreams<std::char_traits<char> >("test", "11.11.1test");
- TestOutStreams<std::char_traits<wchar_t> >(L"test", L"11.11.1test");
- TestOutStreams<DPL::CharTraits>(L"test", L"11.11.1test");
+ TestOutStreams<std::char_traits<char> >("test", "11.11.1test");
+ TestOutStreams<std::char_traits<wchar_t> >(L"test", L"11.11.1test");
+ TestOutStreams<DPL::CharTraits>(L"test", L"11.11.1test");
}
+/*
+Name: String_CompareCaseSensitive
+Description: tests case sensitive comparision
+Expected: strings should be equal
+*/
RUNNER_TEST(String_CompareCaseSensitive)
{
RUNNER_ASSERT(
DPL::FromUTF32String(L"Ala Makota ma żołądkówkę")) == 0);
}
+/*
+Name: String_CompareCaseInsensitive
+Description: tests case insensitive comparision
+Expected: strings should be equal
+*/
RUNNER_TEST(String_CompareCaseInsensitive)
{
RUNNER_ASSERT(
true) == 0);
}
+/*
+Name: String_Join
+Description: tests joining strings algorithm
+Expected: join should take place correctly
+*/
+RUNNER_TEST(String_Join)
+{
+ std::vector<std::string> strings;
+ RUNNER_ASSERT(DPL::Join(strings.begin(), strings.end(), "/") == "");
+ strings.push_back("one");
+ RUNNER_ASSERT(DPL::Join(strings.begin(), strings.end(), "/") == "one");
+ strings.push_back("two");
+ RUNNER_ASSERT(DPL::Join(strings.begin(), strings.end(), "/") == "one/two");
+ strings.push_back("three");
+ RUNNER_ASSERT(DPL::Join(strings.begin(), strings.end(), "/") == "one/two/three");
+ strings.push_back("four");
+ RUNNER_ASSERT(DPL::Join(strings.begin(), strings.end(), "/") == "one/two/three/four");
+ RUNNER_ASSERT(DPL::Join(++strings.begin(), --strings.end(), "/") == "two/three");
+
+ RUNNER_ASSERT(DPL::Join(strings.begin(), strings.end(), "+") == "one+two+three+four");
+ RUNNER_ASSERT(DPL::Join(strings.begin(), strings.end(), "delim") == "onedelimtwodelimthreedelimfour");
+}
+
class Foo
{
-public:
+ public:
int id;
- Foo(int i=0): id(i)
+ Foo(int i = 0) : id(i)
{
LogInfo("Foo: ctor: " << id);
}
typedef DPL::ThreadLocalVariable<Foo> TlsFoo;
TlsFoo g_foo;
-class FooThread
- : public DPL::Thread
+class FooThread :
+ public DPL::Thread
{
-protected:
+ protected:
virtual int ThreadEntry()
{
LogInfo("In thread");
}
};
+/*
+Name: Thread_ThreadLocalVariable_FooDeletion
+Description: tests local thread variable pattern
+Expected: local thread variables should not be affected by other threads
+*/
RUNNER_TEST(Thread_ThreadLocalVariable_FooDeletion)
{
static TlsFoo staticFooForMain;
RUNNER_TEST_GROUP_INIT(DPL)
+/*
+Name: TypeList_TypeCount
+Description: tests size of typelist idiom
+Expected: size should match
+*/
RUNNER_TEST(TypeList_TypeCount)
{
typedef DPL::TypeListDecl<int, char, int[64]>::Type TestTypeList1;
RUNNER_TEST_GROUP_INIT(DPL)
+/*
+Name: ZipInput_OpenFailed
+Description: tests opening non existing file
+Expected: exception throw
+*/
RUNNER_TEST(ZipInput_OpenFailed)
{
bool opened = true;
RUNNER_ASSERT(opened == false);
}
+/*
+Name: ZipInput_OpenFile
+Description: tests opening existing file
+Expected: zip stats should mkatch expected
+*/
RUNNER_TEST(ZipInput_OpenFile)
{
DPL::ZipInput zip(PATH_ARCHIVE);
}
}
+/*
+Name: ZipInput_UnzipSingleFile
+Description: tests opening existing file and unzipping single file
+Expected: right content
+*/
RUNNER_TEST(ZipInput_UnzipSingleFile)
{
DPL::ZipInput zip(PATH_ARCHIVE);
FILE(GLOB DAO_TESTS_SOURCES "${PROJECT_SOURCE_DIR}/tests/dao/*DAO.cpp")
# target wrt-tests-dao
-SET(TARGET_DAO_TEST "wrt-tests-dao")
+SET(TARGET_DAO_TEST "wrt-commons-tests-dao")
WRT_TEST_INCLUDE_DIRECTORIES(${TARGET_DAO_TEST} ${PROJECT_SOURCE_DIR}/modules/support/)
WRT_TEST_ADD_INTERNAL_DEPENDENCIES(${TARGET_DAO_TEST} ${TARGET_WRT_DAO_RW_LIB} ${TARGET_CUSTOM_HANDLER_DAO_RW_LIB})
WRT_TEST_BUILD(${TARGET_DAO_TEST} ${DAO_TESTS_SOURCES} tests_dao.cpp)
WRT_TEST_INSTALL(${TARGET_DAO_TEST})
-
# common installed files
INSTALL(PROGRAMS
${PROJECT_SOURCE_DIR}/tests/dao/wrt_dao_tests_prepare_db.sh
* limitations under the License.
*/
/**
- * @file TestCases_CustomHandlerDAO.cpp
+ * @file TestCases_CustomHandlerDAO.cpp
* @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
* @version 1.0
* @brief This file contains tests for custom handler dao class.
RUNNER_TEST_GROUP_INIT(DAO)
-namespace
-{
+namespace {
const DPL::String P_TARGET(L"p_target");
const DPL::String P_BASE_URL(L"p_base_url");
const DPL::String P_URL(L"p_url");
const DPL::String C_URL(L"c_url");
const DPL::String C_TITLE(L"c_title");
-void checkHandlersExistence(CustomHandlerDAOReadOnly& dao, bool protocol, bool content)
+void checkHandlersExistence(CustomHandlerDAOReadOnly& dao,
+ bool protocol,
+ bool content)
{
CustomHandlerDB::CustomHandlerPtr handler;
handler = dao.getProtocolHandler(P_TARGET, P_URL);
handler = dao.getContentHandler(C_TARGET, C_URL);
RUNNER_ASSERT_MSG((!!handler) == content, "Content handler check");
}
-
} // namespace
RUNNER_TEST(custom_handler_empty_db_read)
CustomHandlerDAOReadOnly dao(DPL::String(L"test"));
}
-
RUNNER_TEST(custom_handlers)
{
CustomHandlerDAOReadOnly dao_ro(L"test");
p_handler.user_decision = Agreed;
// initial check
- checkHandlersExistence(dao_ro,false,false);
+ checkHandlersExistence(dao_ro, false, false);
// Protocol handler registration
dao_rw.registerProtocolHandler(p_handler);
- checkHandlersExistence(dao_ro,true,false);
+ checkHandlersExistence(dao_ro, true, false);
handler = dao_ro.getProtocolHandler(P_TARGET, P_URL);
RUNNER_ASSERT(handler);
RUNNER_ASSERT(handler->title == P_TITLE);
RUNNER_ASSERT(handler->user_decision == Agreed);
-
// Content handler registration
CustomHandlerDB::CustomHandler c_handler;
c_handler.target = C_TARGET;
c_handler.user_decision = DeclinedPermanently;
dao_rw.registerContentHandler(c_handler);
- checkHandlersExistence(dao_ro,true,true);
+ checkHandlersExistence(dao_ro, true, true);
handler = dao_ro.getContentHandler(C_TARGET, C_URL);
RUNNER_ASSERT(handler);
// Handler unregistration
dao_rw.unregisterProtocolHandler(P_TARGET, P_URL);
- checkHandlersExistence(dao_ro,false,true);
+ checkHandlersExistence(dao_ro, false, true);
// Nonexistent unregistration
dao_rw.unregisterContentHandler(L"blah", L"blah");
- checkHandlersExistence(dao_ro,false,true);
+ checkHandlersExistence(dao_ro, false, true);
// Cleanup
dao_rw.unregisterContentHandler(C_TARGET, C_URL);
- checkHandlersExistence(dao_ro,false,false);
+ checkHandlersExistence(dao_ro, false, false);
}
* limitations under the License.
*/
/**
- * @file TestCases_FeatureDAO.cpp
+ * @file TestCases_FeatureDAO.cpp
* @author Pawel Sikorski (p.sikorski@samsung.com)
* @version 1.0
* @brief This file contains tests for feature dao class.
using namespace WrtDB;
#define RUNNER_ASSERT_WHAT_EQUALS(in, test) \
- {std::string tmp(in); \
- RUNNER_ASSERT_MSG(tmp == test, "Equals: [" + tmp + "]");}
+ { std::string tmp(in); \
+ RUNNER_ASSERT_MSG(tmp == test, "Equals: [" + tmp + "]"); }
RUNNER_TEST_GROUP_INIT(DAO)
/*
-Name: feature_dao_test_register_features
-Description: Checks if plugin registeration performs features registration
-Expected: registrartion should succeed
-*/
+ * Name: feature_dao_test_register_features
+ * Description: Checks if plugin registeration performs features registration
+ * Expected: registrartion should succeed
+ */
RUNNER_TEST(feature_dao_test_register_features)
{
PluginHandle plHandle;
std::string libraryName("nfp1");
PluginMetafileData pluginData;
- pluginData.m_libraryName = libraryName;
+ pluginData.m_libraryName = libraryName;
plHandle = PluginDAO::registerPlugin(pluginData, libraryPath);
RUNNER_ASSERT(PluginDAO::isPluginInstalled(libraryName) == true);
PluginMetafileData::Feature f;
f.m_name = std::string("new_f1");
- FeatureHandle handle = FeatureDAO::RegisterFeature(f,plHandle);
+ FeatureHandle handle = FeatureDAO::RegisterFeature(f, plHandle);
RUNNER_ASSERT_MSG(handle != -1, "Already registered");
RUNNER_ASSERT_MSG(old.size() < FeatureDAOReadOnly::GetHandleList().size(),
"New feature should be saved");
FeatureDAOReadOnly dao(handle);
- RUNNER_ASSERT_WHAT_EQUALS(dao.GetName(),"new_f1");
+ RUNNER_ASSERT_WHAT_EQUALS(dao.GetName(), "new_f1");
plHandle = dao.GetPluginHandle();
}
PluginMetafileData::Feature f;
f.m_name = std::string("new_f2");
- FeatureHandle handle = FeatureDAO::RegisterFeature(f,plHandle);
+ FeatureHandle handle = FeatureDAO::RegisterFeature(f, plHandle);
RUNNER_ASSERT_MSG(handle != -1, "Already registered");
RUNNER_ASSERT_MSG(old.size() < FeatureDAOReadOnly::GetHandleList().size(),
"New feature should be saved");
}
/*
-Name: feature_dao_test_get_feature_properties
-Description: Checks properties of inserted features
-Expected: properties of features should match values inserted to database directly
-*/
+ * Name: feature_dao_test_get_feature_properties
+ * Description: Checks properties of inserted features
+ * Expected: properties of features should match values inserted to database
+ * directly
+ */
RUNNER_TEST(feature_dao_test_get_feature_properties)
{
{
}
/*
-Name: feature_dao_test_feature_constructor_name
-Description: -
-Expected: -
-
-TODO: test
-*/
+ * Name: feature_dao_test_feature_constructor_name
+ * Description: -
+ * Expected: -
+ *
+ * TODO: test
+ */
RUNNER_TEST(feature_dao_test_feature_constructor_name)
{
std::list<const char *> preinstalled;
}
/*
-Name: feature_dao_test_feature_handle_list
-Description: Checks if list of installed features is returend correctly
-Expected: list size should be at last equal number of preinserted features
-*/
+ * Name: feature_dao_test_feature_handle_list
+ * Description: Checks if list of installed features is returend correctly
+ * Expected: list size should be at last equal number of preinserted features
+ */
RUNNER_TEST(feature_dao_test_feature_handle_list)
{
FeatureHandleList handles = FeatureDAOReadOnly::GetHandleList();
}
/*
-Name: feature_dao_test_is_feature_installed
-Description: Checks if installed features are showed correctly.
-Expected: correct installed features should be present
-*/
+ * Name: feature_dao_test_is_feature_installed
+ * Description: Checks if installed features are showed correctly.
+ * Expected: correct installed features should be present
+ */
RUNNER_TEST(feature_dao_test_is_feature_installed)
{
//installed
preinstalled.push_back("feature4");
FOREACH(it, preinstalled)
- RUNNER_ASSERT(FeatureDAOReadOnly::isFeatureInstalled(*it));
+ RUNNER_ASSERT(FeatureDAOReadOnly::isFeatureInstalled(*it));
}
//not installed
{
- RUNNER_ASSERT(FeatureDAOReadOnly::isFeatureInstalled("not_installed1")==false);
- RUNNER_ASSERT(FeatureDAOReadOnly::isFeatureInstalled("plugin1") == false);
+ RUNNER_ASSERT(FeatureDAOReadOnly::isFeatureInstalled(
+ "not_installed1") == false);
+ RUNNER_ASSERT(FeatureDAOReadOnly::isFeatureInstalled(
+ "plugin1") == false);
RUNNER_ASSERT(FeatureDAOReadOnly::isFeatureInstalled("") == false);
RUNNER_ASSERT(FeatureDAOReadOnly::isFeatureInstalled("ff") == false);
}
}
/*
-Name: feature_dao_test_get_device_capab
-Description: -
-Expected: -
-
-TODO: fix test
-*/
+ * Name: feature_dao_test_get_device_capab
+ * Description: -
+ * Expected: -
+ *
+ * TODO: fix test
+ */
RUNNER_TEST(feature_dao_test_get_device_capab)
{
#if 0
//TODO do more tests
- {//check deviceCaps
+ { //check deviceCaps
Feature f;
f.setName("new_dev_f4");
f.setLibraryName("new_dev_f4 lib_name");
devList.insert("new_dev_f4 devcap2");
FOREACH(it, devList)
- f.addDeviceCapability(*it);
+ f.addDeviceCapability(*it);
- FeatureHandle handle = FeatureDAO::RegisterFeature(f,"new_dev_f4 path");
+ FeatureHandle handle = FeatureDAO::RegisterFeature(f, "new_dev_f4 path");
FeatureDAOReadOnly dao(handle);
FeatureDAOReadOnly::DeviceCapabilitiesList gotList =
- dao.GetDeviceCapabilities();
+ dao.GetDeviceCapabilities();
RUNNER_ASSERT_MSG(gotList.size() == devList.size(),
"deviceCaps wrong");
}
}
/*
-Name: feature_dao_test_is_device_capab_installed
-Description: Checks if FeatureDAOReadOnly::isDeviceCapabilityInstalled works correctly.
-Expected: correct capabilities should be present
-*/
+ * Name: feature_dao_test_is_device_capab_installed
+ * Description: Checks if FeatureDAOReadOnly::isDeviceCapabilityInstalled works
+ * correctly.
+ * Expected: correct capabilities should be present
+ */
RUNNER_TEST(feature_dao_test_is_device_capab_installed)
{
//installed
preinstalled.push_back("devicecap4");
FOREACH(it, preinstalled)
- RUNNER_ASSERT(FeatureDAOReadOnly::isDeviceCapabilityInstalled(*it));
+ RUNNER_ASSERT(FeatureDAOReadOnly::isDeviceCapabilityInstalled(*it));
//not installed
std::list<const char *> notinstalled;
notinstalled.push_back("ff");
FOREACH(it, notinstalled)
- RUNNER_ASSERT(!FeatureDAOReadOnly::isDeviceCapabilityInstalled(*it));
+ RUNNER_ASSERT(!FeatureDAOReadOnly::isDeviceCapabilityInstalled(*it));
}
#undef RUNNER_ASSERT_WHAT_EQUALS
* limitations under the License.
*/
/**
- * @file TestCases_GlobalDAO.cpp
+ * @file TestCases_GlobalDAO.cpp
* @author Pawel Sikorski (p.sikorski@samsung.com)
* @version 1.0
* @brief This file contains tests for global dao class.
using namespace WrtDB;
-
-namespace
-{
+namespace {
const DPL::String widgetPackage5(L"widgetpackage5");
} // namespace
RUNNER_TEST_GROUP_INIT(DAO)
/*
-Name: global_dao_developer_mode
-Description: tests if developer mode is correctly set and get
-Expected: received developer shoudl match the one was set
-*/
+ * Name: global_dao_developer_mode
+ * Description: tests if developer mode is correctly set and get
+ * Expected: received developer shoudl match the one was set
+ */
RUNNER_TEST(global_dao_developer_mode)
{
bool prev_mode = GlobalDAO::GetDeveloperMode();
}
/*
-Name: home_network_data_usage
-Description: tests if HomeNetworkDataUsage is correctly set and get
-Expected: received developer shoudl match the one was set
-*/
+ * Name: home_network_data_usage
+ * Description: tests if HomeNetworkDataUsage is correctly set and get
+ * Expected: received developer shoudl match the one was set
+ */
RUNNER_TEST(home_network_data_usage)
{
GlobalDAO::NetworkAccessMode original =
- GlobalDAO::GetHomeNetworkDataUsage();
+ GlobalDAO::GetHomeNetworkDataUsage();
GlobalDAO::SetHomeNetworkDataUsage(GlobalDAO::CONNECT_AUTOMATICALLY);
RUNNER_ASSERT_MSG(GlobalDAO::CONNECT_AUTOMATICALLY ==
- GlobalDAO::GetHomeNetworkDataUsage(), "Value not updated");
+ GlobalDAO::GetHomeNetworkDataUsage(), "Value not updated");
GlobalDAO::SetHomeNetworkDataUsage(GlobalDAO::ALWAYS_ASK);
RUNNER_ASSERT_MSG(GlobalDAO::ALWAYS_ASK ==
- GlobalDAO::GetHomeNetworkDataUsage(), "Value not updated");
+ GlobalDAO::GetHomeNetworkDataUsage(), "Value not updated");
GlobalDAO::SetHomeNetworkDataUsage(GlobalDAO::NEVER_CONNECT);
RUNNER_ASSERT_MSG(GlobalDAO::NEVER_CONNECT ==
- GlobalDAO::GetHomeNetworkDataUsage(), "Value not updated");
+ GlobalDAO::GetHomeNetworkDataUsage(), "Value not updated");
GlobalDAO::SetHomeNetworkDataUsage(original);
RUNNER_ASSERT_MSG(original == GlobalDAO::GetHomeNetworkDataUsage(),
- "Value not updated");
+ "Value not updated");
}
/*
-Name: roaming_data_usage
-Description: tests if RoamingDataUsage is correctly set and get
-Expected: received developer shoudl match the one was set
-*/
+ * Name: roaming_data_usage
+ * Description: tests if RoamingDataUsage is correctly set and get
+ * Expected: received developer shoudl match the one was set
+ */
RUNNER_TEST(roaming_data_usage)
{
GlobalDAO::NetworkAccessMode original =
- GlobalDAO::GetRoamingDataUsage();
+ GlobalDAO::GetRoamingDataUsage();
GlobalDAO::SetRoamingDataUsage(GlobalDAO::CONNECT_AUTOMATICALLY);
RUNNER_ASSERT_MSG(GlobalDAO::CONNECT_AUTOMATICALLY ==
- GlobalDAO::GetRoamingDataUsage(), "Value not updated");
+ GlobalDAO::GetRoamingDataUsage(), "Value not updated");
GlobalDAO::SetRoamingDataUsage(GlobalDAO::ALWAYS_ASK);
RUNNER_ASSERT_MSG(GlobalDAO::ALWAYS_ASK ==
- GlobalDAO::GetRoamingDataUsage(), "Value not updated");
+ GlobalDAO::GetRoamingDataUsage(), "Value not updated");
GlobalDAO::SetRoamingDataUsage(GlobalDAO::NEVER_CONNECT);
RUNNER_ASSERT_MSG(GlobalDAO::NEVER_CONNECT ==
- GlobalDAO::GetRoamingDataUsage(), "Value not updated");
+ GlobalDAO::GetRoamingDataUsage(), "Value not updated");
GlobalDAO::SetRoamingDataUsage(original);
RUNNER_ASSERT_MSG(original == GlobalDAO::GetRoamingDataUsage(),
- "Value not updated");
+ "Value not updated");
}
* limitations under the License.
*/
/**
- * @file TestCases_PluginDAO.cpp
+ * @file TestCases_PluginDAO.cpp
* @author Pawel Sikorski (p.sikorski@samsung.com)
* @version 1.0
* @brief This file contains tests for feature dao class.
using namespace WrtDB;
#define RUNNER_ASSERT_WHAT_EQUALS(in, test) \
- {std::string tmp(in); \
- RUNNER_ASSERT_MSG(tmp == test, "Equals: [" + tmp + "]");}
+ { std::string tmp(in); \
+ RUNNER_ASSERT_MSG(tmp == test, "Equals: [" + tmp + "]"); }
RUNNER_TEST_GROUP_INIT(DAO)
/*
-Name: plugin_dao_test_register_plugins
-Description: registers new plugin and check if it was correctly registered
-Expected: plugin should be correctly registered
-*/
+ * Name: plugin_dao_test_register_plugins
+ * Description: registers new plugin and check if it was correctly registered
+ * Expected: plugin should be correctly registered
+ */
RUNNER_TEST(plugin_dao_test_register_plugins)
{
{
std::string libraryName("np1");
PluginMetafileData pluginData;
- pluginData.m_libraryName = libraryName;
+ pluginData.m_libraryName = libraryName;
PluginHandle handle = PluginDAO::registerPlugin(pluginData, libraryPath);
- PluginDAO::setPluginInstallationStatus(handle,PluginDAO::INSTALLATION_COMPLETED);
+ PluginDAO::setPluginInstallationStatus(
+ handle,
+ PluginDAO::
+ INSTALLATION_COMPLETED);
RUNNER_ASSERT(PluginDAO::isPluginInstalled(libraryName) == true);
PluginDAO dao(handle);
std::string libraryName("np2");
PluginMetafileData pluginData;
- pluginData.m_libraryName = libraryName;
+ pluginData.m_libraryName = libraryName;
PluginHandle handle = PluginDAO::registerPlugin(pluginData, "");
- PluginDAO::setPluginInstallationStatus(handle,PluginDAO::INSTALLATION_COMPLETED);
+ PluginDAO::setPluginInstallationStatus(
+ handle,
+ PluginDAO::
+ INSTALLATION_COMPLETED);
RUNNER_ASSERT(PluginDAO::isPluginInstalled(libraryName) == true);
PluginDAO dao(handle);
}
/*
-Name: plugin_dao_test_register_plugin_implemented_object
-Description: registers new PluginImplementedObject
- and check if it was correctly registered
-Expected: plugin dao shoudld be upodated with PluginImplementedObject
-*/
+ * Name: plugin_dao_test_register_plugin_implemented_object
+ * Description: registers new PluginImplementedObject
+ * and check if it was correctly registered
+ * Expected: plugin dao shoudld be upodated with PluginImplementedObject
+ */
RUNNER_TEST(plugin_dao_test_register_plugin_implemented_object)
{
{
std::string libraryName("np3");
PluginMetafileData pluginData;
- pluginData.m_libraryName = libraryName;
+ pluginData.m_libraryName = libraryName;
PluginHandle handle =
PluginDAO::registerPlugin(pluginData, libraryPath);
}
/*
-Name: plugin_dao_test_register_plugin_implemented_object
-Description: registers dependecies for plugins and checks if they were saved
-Expected: registered dependecies should be returned from database
-*/
+ * Name: plugin_dao_test_register_plugin_implemented_object
+ * Description: registers dependecies for plugins and checks if they were saved
+ * Expected: registered dependecies should be returned from database
+ */
RUNNER_TEST(plugin_dao_test_register_library_dependencies)
{
{
std::string libraryName("np4");
PluginMetafileData pluginData;
- pluginData.m_libraryName = libraryName;
+ pluginData.m_libraryName = libraryName;
PluginHandle handle =
PluginDAO::registerPlugin(pluginData, libraryPath);
- PluginDAO::setPluginInstallationStatus(handle,PluginDAO::INSTALLATION_COMPLETED);
+ PluginDAO::setPluginInstallationStatus(
+ handle,
+ PluginDAO::
+ INSTALLATION_COMPLETED);
RUNNER_ASSERT(PluginDAO::isPluginInstalled(libraryName) == true);
- PluginHandle depHandles[] = {117, 119};
+ PluginHandle depHandles[] = { 117, 119 };
PluginHandleSetPtr dependencies(new PluginHandleSet);
+ dependencies->insert(depHandles[0]);
dependencies->insert(depHandles[1]);
- dependencies->insert(depHandles[2]);
PluginDAO::registerPluginLibrariesDependencies(handle, dependencies);
retDependencies = dao.getLibraryDependencies();
RUNNER_ASSERT(
- retDependencies->size()==sizeof(depHandles)/sizeof(depHandles[0]));
+ retDependencies->size() == sizeof(depHandles) /
+ sizeof(depHandles[0]));
RUNNER_ASSERT(
- retDependencies->find(depHandles[1]) != retDependencies->end());
+ retDependencies->find(depHandles[0]) != retDependencies->end());
RUNNER_ASSERT(
- retDependencies->find(depHandles[2]) != retDependencies->end());
+ retDependencies->find(depHandles[1]) != retDependencies->end());
}
}
/*
-Name: plugin_dao_test_register_required_object
-Description: registers required plugin objects for plugins and checks if they were saved
-Expected: registered required plugin objects should be returned from database
-*/
+ * Name: plugin_dao_test_register_required_object
+ * Description: registers required plugin objects for plugins and checks if they
+ * were saved
+ * Expected: registered required plugin objects should be returned from database
+ */
RUNNER_TEST(plugin_dao_test_register_required_object)
{
{
std::string libraryName("np5");
PluginMetafileData pluginData;
- pluginData.m_libraryName = libraryName;
+ pluginData.m_libraryName = libraryName;
PluginHandle handle =
PluginDAO::registerPlugin(pluginData, libraryPath);
- PluginDAO::setPluginInstallationStatus(handle,PluginDAO::INSTALLATION_COMPLETED);
+ PluginDAO::setPluginInstallationStatus(
+ handle,
+ PluginDAO::
+ INSTALLATION_COMPLETED);
RUNNER_ASSERT(PluginDAO::isPluginInstalled(libraryName) == true);
- const size_t numObjects =2;
- std::string objectReq [numObjects];
+ const size_t numObjects = 2;
+ std::string objectReq[numObjects];
objectReq[0] = std::string("object1.req");
objectReq[1] = std::string("object2.req");
PluginDAO::registerPluginRequiredObject(objectReq[0], handle);
PluginDAO::getRequiredObjectsForPluginHandle(handle);
RUNNER_ASSERT(objects->size() == numObjects
- && objects->find(objectReq[0]) != objects->end()
- && objects->find(objectReq[1]) != objects->end());
+ && objects->find(objectReq[0]) != objects->end()
+ && objects->find(objectReq[1]) != objects->end());
}
}
/*
-Name: plugin_dao_test_is_library_installed
-Description: tests if plugin isntallation/registrartion works
-Expected: only registered plugins should be reported as installed
-*/
+ * Name: plugin_dao_test_is_library_installed
+ * Description: tests if plugin isntallation/registrartion works
+ * Expected: only registered plugins should be reported as installed
+ */
RUNNER_TEST(plugin_dao_test_is_library_installed)
{
{
preinstalled.push_back("p5");
FOREACH(it, preinstalled)
- RUNNER_ASSERT_MSG(PluginDAO::isPluginInstalled(*it),
- std::string("Not found: ") + *it);
+ RUNNER_ASSERT_MSG(PluginDAO::isPluginInstalled(*it),
+ std::string("Not found: ") + *it);
}
{
//does not exist
RUNNER_ASSERT_MSG(
- PluginDAO::isPluginInstalled("not_installed1") == false,
- "Found not_installed1");
+ PluginDAO::isPluginInstalled("not_installed1") == false,
+ "Found not_installed1");
RUNNER_ASSERT_MSG(PluginDAO::isPluginInstalled("p 4") == false,
"Found p 4");
RUNNER_ASSERT_MSG(PluginDAO::isPluginInstalled("") == false,
}
/*
-Name: plugin_dao_test_get_plugin_handle_list
-Description: test of returning plugin handle list
-Expected: returned list should be no less than number of registered plugins
-*/
+ * Name: plugin_dao_test_get_plugin_handle_list
+ * Description: test of returning plugin handle list
+ * Expected: returned list should be no less than number of registered plugins
+ */
RUNNER_TEST(plugin_dao_test_get_plugin_handle_list)
{
PluginHandleList handles = PluginDAO::getPluginHandleList();
}
/*
-Name: plugin_dao_test_constructor_name
-Description: tests construction of plugin dao based on plugin name
-Expected: Instance of dao should be constructed only
- if there is given plugin in database
-*/
+ * Name: plugin_dao_test_constructor_name
+ * Description: tests construction of plugin dao based on plugin name
+ * Expected: Instance of dao should be constructed only
+ * if there is given plugin in database
+ */
RUNNER_TEST(plugin_dao_test_constructor_name)
{
{
PluginDAO dao(*it);
RUNNER_ASSERT_MSG(false, "should not be found");
}
- Catch (PluginDAO::Exception::PluginNotExist) {
+ Catch(PluginDAO::Exception::PluginNotExist) {
continue;
}
}
}
-
}
/*
-Name: plugin_dao_test_get_plugin_properties
-Description: tests reading plugin properties from database
-Expected: Data, inserted into database, should be accessible via dao
-*/
+ * Name: plugin_dao_test_get_plugin_properties
+ * Description: tests reading plugin properties from database
+ * Expected: Data, inserted into database, should be accessible via dao
+ */
RUNNER_TEST(plugin_dao_test_get_plugin_properties)
{
{
}
/*
-Name: plugin_dao_test_get_implemented_objects_for_plugin_handle_1
-Description: tests receiving from dao Implemented Objects
-Expected: returned object is size 0
-*/
+ * Name: plugin_dao_test_get_implemented_objects_for_plugin_handle_1
+ * Description: tests receiving from dao Implemented Objects
+ * Expected: returned object is size 0
+ */
RUNNER_TEST(plugin_dao_test_get_implemented_objects_for_plugin_handle_1)
{
{
RUNNER_ASSERT(dbHandle == handle);
auto objects = dao.getImplementedObjectsForPluginHandle(dbHandle);
- RUNNER_ASSERT(objects.size() == 0);
+ RUNNER_ASSERT(objects.empty());
}
}
/*
-Name: plugin_dao_test_get_implemented_objects_for_plugin_handle_2
-Description: tests receiving from dao Implemented Objects
-Expected: returned object is size as it was inserted
-*/
+ * Name: plugin_dao_test_get_implemented_objects_for_plugin_handle_2
+ * Description: tests receiving from dao Implemented Objects
+ * Expected: returned object is size as it was inserted
+ */
RUNNER_TEST(plugin_dao_test_get_implemented_objects_for_plugin_handle_2)
{
{
- std::set< std::string > preinstalled =
- {
+ std::set< std::string > preinstalled = {
""
};
auto dbHandle = dao.getPluginHandle();
auto objects = dao.getImplementedObjectsForPluginHandle(dbHandle);
- //LogError("\n" << objects.size() << " " << preinstalled.size() << "\n");
+ //LogError("\n" << objects.size() << " " << preinstalled.size() <<
+ // "\n");
RUNNER_ASSERT(objects.size() == preinstalled.size());
}
/*
-Name: plugin_dao_test_get_implemented_objects_for_plugin_handle_3
-Description: tests receiving from dao Implemented Objects
-Expected: returned objects list has preinserted object
-*/
+ * Name: plugin_dao_test_get_implemented_objects_for_plugin_handle_3
+ * Description: tests receiving from dao Implemented Objects
+ * Expected: returned objects list has preinserted object
+ */
RUNNER_TEST(plugin_dao_test_get_implemented_objects_for_plugin_handle_3)
{
{
- std::set< std::string > preinstalled =
- {
+ std::set< std::string > preinstalled = {
"Plugin_3_Object_A"
};
}
/*
-Name: plugin_dao_test_get_implemented_objects_for_plugin_handle_4
-Description: tests receiving from dao Implemented Objects
-Expected: returned objects list has all preinserted objects
-*/
+ * Name: plugin_dao_test_get_implemented_objects_for_plugin_handle_4
+ * Description: tests receiving from dao Implemented Objects
+ * Expected: returned objects list has all preinserted objects
+ */
RUNNER_TEST(plugin_dao_test_get_implemented_objects_for_plugin_handle_4)
{
{
- std::set< std::string > preinstalled =
- {
+ std::set< std::string > preinstalled = {
"Plugin_4_Object_A",
"Plugin_4_Object_B",
"Plugin_4_Object_C",
}
/*
-Name: plugin_dao_test_get_implemented_objects_for_plugin_handle_5
-Description: tests receiving from dao Implemented Objects
-Expected: returned objects list do not have object that was not inserted
-*/
+ * Name: plugin_dao_test_get_implemented_objects_for_plugin_handle_5
+ * Description: tests receiving from dao Implemented Objects
+ * Expected: returned objects list do not have object that was not inserted
+ */
RUNNER_TEST(plugin_dao_test_get_implemented_objects_for_plugin_handle_5)
{
{
- std::set< std::string > preinstalled =
- {
+ std::set< std::string > preinstalled = {
"Plugin_5_Object_B",
};
}
}
-
#undef RUNNER_ASSERT_WHAT_EQUALS
using namespace WrtDB;
using namespace WrtDB::PropertyDAOReadOnly;
-// Widgets used 2000, 2001, 2002, 2003(saved by wrt_dao_tests_prepare_db.sh)
+// Widgets used "tizenid201", "tizenid202", "tizenid203", 2003(saved by
+// wrt_dao_tests_prepare_db.sh)
#define RUNNER_ASSERT_WHAT_EQUALS(in, test) \
- {std::string tmp(in); \
- RUNNER_ASSERT_MSG(tmp == test, "Equals: [" + tmp + "]");}
+ { std::string tmp(in); \
+ RUNNER_ASSERT_MSG(tmp == test, "Equals: [" + tmp + "]"); }
#define RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(in, test) \
- { \
- if(in.IsNull()) RUNNER_ASSERT_MSG(false, "NULL"); \
- else RUNNER_ASSERT_WHAT_EQUALS(DPL::ToUTF8String(*in),test);\
- }
+ { \
+ if (in.IsNull()) { RUNNER_ASSERT_MSG(false, "NULL"); } \
+ else { RUNNER_ASSERT_WHAT_EQUALS(DPL::ToUTF8String(*in), test); } \
+ }
RUNNER_TEST_GROUP_INIT(DAO)
/*
-Name: property_dao_get_lists
-Description: tests returning list of properties for given id
-Expected: data received should match those, which were inserted in prepare script
-*/
+ * Name: property_dao_get_lists
+ * Description: tests returning list of properties for given id
+ * Expected: data received should match those, which were inserted in prepare
+ * script
+ */
RUNNER_TEST(property_dao_get_lists)
{
- {//property list
- std::map<WidgetHandle, size_t> prefsMap;
- prefsMap.insert(std::pair<WidgetHandle, size_t>(2000, 2));
- prefsMap.insert(std::pair<WidgetHandle, size_t>(2001, 1));
- prefsMap.insert(std::pair<WidgetHandle, size_t>(2002, 2));
- prefsMap.insert(std::pair<WidgetHandle, size_t>(1, 0)); //no widget
+ { //property list
+ std::map<WrtDB::TizenAppId, size_t> prefsMap;
+ prefsMap.insert(std::pair<WrtDB::TizenAppId, size_t>(L"tizenid201", 2));
+ prefsMap.insert(std::pair<WrtDB::TizenAppId, size_t>(L"tizenid202", 1));
+ prefsMap.insert(std::pair<WrtDB::TizenAppId, size_t>(L"tizenid203", 2));
+ //no widget
+ prefsMap.insert(std::pair<WrtDB::TizenAppId, size_t>(L"non_exists", 0));
FOREACH(it, prefsMap) {
PropertyDAOReadOnly::WidgetPreferenceList prefs =
- PropertyDAOReadOnly::GetPropertyList(it->first);
+ PropertyDAOReadOnly::GetPropertyList(it->first);
RUNNER_ASSERT(prefs.size() == it->second);
}
}
- {//property key list
+ { //property key list
WidgetPropertyKeyList orig_2000;
orig_2000.push_back(DPL::FromUTF8String("key1_for_2000"));
orig_2000.push_back(DPL::FromUTF8String("key2_for_2000"));
orig_2002.push_back(DPL::FromUTF8String("key1_for_2002"));
orig_2002.push_back(DPL::FromUTF8String("key2_for_2002"));
- std::map<WidgetHandle, WidgetPropertyKeyList *> prefsKeyMap;
- prefsKeyMap.insert(std::pair<WidgetHandle, WidgetPropertyKeyList *>(
- 2000, &orig_2000));
- prefsKeyMap.insert(std::pair<WidgetHandle, WidgetPropertyKeyList *>(
- 2001, &orig_2001));
- prefsKeyMap.insert(std::pair<WidgetHandle, WidgetPropertyKeyList *>(
- 2002, &orig_2002));
+ std::map<WrtDB::TizenAppId, WidgetPropertyKeyList *> prefsKeyMap;
+ prefsKeyMap.insert(std::pair<WrtDB::TizenAppId, WidgetPropertyKeyList *>(
+ L"tizenid201", &orig_2000));
+ prefsKeyMap.insert(std::pair<WrtDB::TizenAppId, WidgetPropertyKeyList *>(
+ L"tizenid202", &orig_2001));
+ prefsKeyMap.insert(std::pair<WrtDB::TizenAppId, WidgetPropertyKeyList *>(
+ L"tizenid203", &orig_2002));
FOREACH(it_out, prefsKeyMap) {
WidgetPropertyKeyList got = PropertyDAOReadOnly::GetPropertyKeyList(
}
/*
-Name: property_dao_set_update_remove
-Description: tests set new property for widget, updating property and removing it
-Expected: given operation should works
-*/
+ * Name: property_dao_set_update_remove
+ * Description: tests set new property for widget, updating property and
+ * removing it
+ * Expected: given operation should works
+ */
RUNNER_TEST(property_dao_set_update_remove)
{
- WidgetPropertyKeyList keys = PropertyDAOReadOnly::GetPropertyKeyList(2000);
+ WidgetPropertyKeyList keys = PropertyDAOReadOnly::GetPropertyKeyList(
+ L"tizenid201");
//ADD
- PropertyDAO::SetProperty(2000,
+ PropertyDAO::SetProperty(L"tizenid201",
DPL::FromUTF8String("new_key"),
DPL::FromUTF8String("new_value1"));
RUNNER_ASSERT_MSG(
- keys.size() + 1 == PropertyDAOReadOnly::GetPropertyKeyList(2000).size(),
+ keys.size() + 1 ==
+ PropertyDAOReadOnly::GetPropertyKeyList(L"tizenid201").size(),
"new property not added");
RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(
- PropertyDAOReadOnly::GetPropertyValue(2000,
+ PropertyDAOReadOnly::GetPropertyValue(L"tizenid201",
DPL::FromUTF8String("new_key")),
"new_value1");
//UPDATE
- PropertyDAO::SetProperty(2000,
+ PropertyDAO::SetProperty(L"tizenid201",
DPL::FromUTF8String("new_key"),
DPL::FromUTF8String("new_value2"));
RUNNER_ASSERT_MSG(
- keys.size() + 1 == PropertyDAOReadOnly::GetPropertyKeyList(2000).size(),
+ keys.size() + 1 ==
+ PropertyDAOReadOnly::GetPropertyKeyList(L"tizenid201").size(),
"new property not added");
RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(
- PropertyDAOReadOnly::GetPropertyValue(2000,
+ PropertyDAOReadOnly::GetPropertyValue(L"tizenid201",
DPL::FromUTF8String("new_key")),
"new_value2");
//REMOVE
- PropertyDAO::RemoveProperty(2000, DPL::FromUTF8String("new_key"));
+ PropertyDAO::RemoveProperty(L"tizenid201", DPL::FromUTF8String("new_key"));
RUNNER_ASSERT_MSG(
- keys.size() == PropertyDAOReadOnly::GetPropertyKeyList(2000).size(),
+ keys.size() == PropertyDAOReadOnly::GetPropertyKeyList(
+ L"tizenid201").size(),
"property not removed");
-
}
/*
-Name: property_dao_get_value
-Description: tests if properties can be received from database
-Expected: value, which were inserted before test, should be present
-*/
+ * Name: property_dao_get_value
+ * Description: tests if properties can be received from database
+ * Expected: value, which were inserted before test, should be present
+ */
RUNNER_TEST(property_dao_get_value)
{
RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(
- PropertyDAOReadOnly::GetPropertyValue(
- 2000, DPL::FromUTF8String("key1_for_2000")),
- "value_for_key1_2000");
+ PropertyDAOReadOnly::GetPropertyValue(
+ L"tizenid201", DPL::FromUTF8String("key1_for_2000")),
+ "value_for_key1_2000");
RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(
- PropertyDAOReadOnly::GetPropertyValue(
- 2000, DPL::FromUTF8String("key2_for_2000")),
- "value_for_key2_2000");
+ PropertyDAOReadOnly::GetPropertyValue(
+ L"tizenid201", DPL::FromUTF8String("key2_for_2000")),
+ "value_for_key2_2000");
}
#undef RUNNER_ASSERT_WHAT_EQUALS
* limitations under the License.
*/
/**
- * @file TestCases_WidgetDAO.cpp
+ * @file TestCases_WidgetDAO.cpp
* @author Pawel Sikorski (p.sikorski@samsung.com)
* @version 1.0
* @brief This file contains tests for widget dao class.
using namespace WrtDB;
namespace {
-
class WacSecurityMock : public WrtDB::IWacSecurity
{
-public:
+ public:
WacSecurityMock() :
mRecognized(false),
mDistributorSigned(false),
mWacSigned(false)
- {
- }
+ {}
virtual const WidgetCertificateDataList& getCertificateList() const
{
return mList;
}
- virtual bool isRecognized() const { return mRecognized; }
- virtual bool isDistributorSigned() const { return mDistributorSigned; }
- virtual bool isWacSigned() const { return mWacSigned; }
+ virtual bool isRecognized() const
+ {
+ return mRecognized;
+ }
+ virtual bool isDistributorSigned() const
+ {
+ return mDistributorSigned;
+ }
+ virtual bool isWacSigned() const
+ {
+ return mWacSigned;
+ }
virtual void getCertificateChainList(CertificateChainList& /*lst*/) const {}
virtual void getCertificateChainList(CertificateChainList& /*lst*/,
- CertificateSource source) const {}
+ CertificateSource /*source*/) const {}
WrtDB::WidgetCertificateDataList& getCertificateListRef()
{
return mList;
}
- void setRecognized(bool recognized) { mRecognized = recognized; }
+ void setRecognized(bool recognized)
+ {
+ mRecognized = recognized;
+ }
void setDistributorSigned(bool distributorSigned)
{
mDistributorSigned = distributorSigned;
}
- void setWacSigned(bool wacSigned) { mWacSigned = wacSigned; }
+ void setWacSigned(bool wacSigned)
+ {
+ mWacSigned = wacSigned;
+ }
-private:
+ private:
WrtDB::WidgetCertificateDataList mList;
// author signature verified
bool mRecognized;
bool mDistributorSigned;
// distributor is wac
bool mWacSigned;
-
};
-WidgetPkgName _registerWidget(const WidgetRegisterInfo& regInfo,
- const IWacSecurity& sec,
- int line)
+TizenAppId _registerWidget(const WidgetRegisterInfo& regInfo,
+ const IWacSecurity& sec,
+ int line)
{
- WidgetPkgName pkgname;
+ TizenAppId tizenAppId;
Try {
- auto previous = WidgetDAO::getPkgnameList();
+ auto previous = WidgetDAO::getTizenAppidList();
// register widget
- pkgname = WidgetDAO::registerWidgetGenerateTizenId(regInfo, sec);
+ tizenAppId = WidgetDAO::registerWidgetGeneratePkgId(regInfo, sec);
- RUNNER_ASSERT_MSG(!pkgname.empty(),
+ RUNNER_ASSERT_MSG(!tizenAppId.empty(),
"(called from line " << line << ")");
- auto current = WidgetDAO::getPkgnameList();
- RUNNER_ASSERT_MSG(previous.size()+1 == current.size(),
+ auto current = WidgetDAO::getTizenAppidList();
+ RUNNER_ASSERT_MSG(previous.size() + 1 == current.size(),
"(called from line " << line << ")");
- RUNNER_ASSERT_MSG(WidgetDAO::isWidgetInstalled(pkgname),
- "(called from line " << line << " pkgname: " << pkgname << ")");
+ RUNNER_ASSERT_MSG(WidgetDAO::isWidgetInstalled(
+ tizenAppId),
+ "(called from line " << line << " tizenAppId: " <<
+ tizenAppId << ")");
}
- Catch (WidgetDAO::Exception::AlreadyRegistered) {
+ Catch(WidgetDAO::Exception::AlreadyRegistered) {
RUNNER_ASSERT_MSG(
- false,
- "Unexpected exception (called from line " << line << ")");
+ false,
+ "Unexpected exception (called from line " << line << ")");
}
- return pkgname;
+ return tizenAppId;
}
-#define REGISTER_WIDGET(regInfo, sec) _registerWidget((regInfo),(sec), __LINE__)
-
+#define REGISTER_WIDGET(regInfo, sec) _registerWidget((regInfo), \
+ (sec), \
+ __LINE__)
} // namespace
// Widgets used <2300,2500), 2000, 2001, 2002, 2003
#define RUNNER_ASSERT_WHAT_EQUALS(in, test) \
- {std::string tmp(in); \
- RUNNER_ASSERT_MSG(tmp == test, "Equals: [" + tmp + "]");}
+ { std::string tmp(in); \
+ RUNNER_ASSERT_MSG(tmp == test, "Equals: [" + tmp + "]"); }
#define RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(in, test) \
- { \
- if(in.IsNull()) RUNNER_ASSERT_MSG(false, "NULL"); \
- else RUNNER_ASSERT_WHAT_EQUALS(DPL::ToUTF8String(*in),test);\
- }
+ { \
+ if (in.IsNull()) { RUNNER_ASSERT_MSG(false, "NULL"); } \
+ else { RUNNER_ASSERT_WHAT_EQUALS(DPL::ToUTF8String(*in), test); } \
+ }
#define RUNNER_ASSERT_WHAT_EQUALS_OPTIONALINT(in, test) \
- { \
- if(in.IsNull()) RUNNER_ASSERT_MSG(false, "NULL"); \
- else RUNNER_ASSERT_MSG(*in == test, "Equals: [" + *in + "]"); \
- }
+ { \
+ if (in.IsNull()) { RUNNER_ASSERT_MSG(false, "NULL"); } \
+ else { RUNNER_ASSERT_MSG(*in == test, "Equals: [" + *in + "]"); } \
+ }
RUNNER_TEST_GROUP_INIT(DAO)
//2300
/*
-Name: widget_dao_test_register_widget_empty_strings
-Description: Tests registeration of new widget with empty values
-Expected: widget should be registered in database
-*/
+ * Name: widget_dao_test_register_widget_empty_strings
+ * Description: Tests registeration of new widget with empty values
+ * Expected: widget should be registered in database
+ */
RUNNER_TEST(widget_dao_test_register_widget_empty_strings)
{
WidgetRegisterInfo regInfo;
locData.licenseFile = DPL::FromUTF8String("");
locData.licenseHref = DPL::FromUTF8String("");
regInfo.configInfo.localizedDataSet.insert(
- std::make_pair(DPL::FromUTF8String("en"),locData));
+ std::make_pair(DPL::FromUTF8String("en"), locData));
//userAgentLoc
icon.height = 10;
LocaleSet locs;
locs.insert(DPL::FromUTF8String("en"));
- WidgetRegisterInfo::LocalizedIcon locIcon(icon,locs);
+ WidgetRegisterInfo::LocalizedIcon locIcon(icon, locs);
regInfo.localizationData.icons.push_back(locIcon);
//start file
WidgetRegisterInfo::LocalizedStartFile file;
file.path = DPL::FromUTF8String("");
file.propertiesForLocales.insert(
- std::make_pair(DPL::FromUTF8String("en"), prop));
+ std::make_pair(DPL::FromUTF8String("en"), prop));
regInfo.localizationData.startFiles.push_back(file);
//widget pref
- ConfigParserData::Preference pref(DPL::FromUTF8String(""),false);
+ ConfigParserData::Preference pref(DPL::FromUTF8String(""), false);
pref.value = DPL::FromUTF8String("");
regInfo.configInfo.preferencesList.insert(pref);
//widget feature
- ConfigParserData::Feature feat(DPL::FromUTF8String(""),false);
+ ConfigParserData::Feature feat(DPL::FromUTF8String(""), false);
ConfigParserData::Param par(DPL::FromUTF8String(("")));
par.value = DPL::FromUTF8String("");
feat.paramsList.insert(par);
regInfo.configInfo.windowModes.insert(DPL::FromUTF8String(""));
//WARP info
- ConfigParserData::AccessInfo access(DPL::FromUTF8String(""),true);
+ ConfigParserData::AccessInfo access(DPL::FromUTF8String(""), true);
regInfo.configInfo.accessInfoSet.insert(access);
//certificates
WacSecurityMock security;
security.getCertificateListRef().push_back(cert);
- REGISTER_WIDGET(regInfo,security);
+ REGISTER_WIDGET(regInfo, security);
}
/*
-Name: widget_dao_test_register_widget_empty_strings
-Description: Tests possiblity of registering twice same content (different tizenId)
-Expected: it should be possible
-*/
+ * Name: widget_dao_test_register_widget_empty_strings
+ * Description: Tests possiblity of registering twice same content (different
+ * tizenId)
+ * Expected: it should be possible
+ */
RUNNER_TEST(widget_dao_test_twice_install_same_widget)
{
WacSecurityMock sec;
WidgetRegisterInfo regInfo;
REGISTER_WIDGET(regInfo, sec);
}
-
}
/*
-Name: widget_dao_test_register_widget_minimum_info
-Description: Tests simplest registeration of new widget
-Expected: widget should be registered in database
-*/
+ * Name: widget_dao_test_register_widget_minimum_info
+ * Description: Tests simplest registeration of new widget
+ * Expected: widget should be registered in database
+ */
RUNNER_TEST(widget_dao_test_register_widget_minimum_info)
{
WacSecurityMock sec;
const std::size_t NUMBER_OF_WIDGETS = 5;
- WidgetPkgName lastPkgname;
+ TizenAppId lastTizenAppId;
- for (std::size_t number = 0; number < NUMBER_OF_WIDGETS; ++number)
- {
+ for (std::size_t number = 0; number < NUMBER_OF_WIDGETS; ++number) {
WidgetRegisterInfo regInfo;
- WidgetPkgName pkgname = REGISTER_WIDGET(regInfo, sec);
+ TizenAppId tizenAppId = REGISTER_WIDGET(regInfo, sec);
- lastPkgname = pkgname;
+ lastTizenAppId = tizenAppId;
- WidgetDAO dao(pkgname);
+ WidgetDAO dao(tizenAppId);
//TODO check nulls
}
}
/*
-Name: widget_dao_test_register_widget_info
-Description: Tests registeration of many widgets
-Expected: all widgets should be registered in database
-*/
+ * Name: widget_dao_test_register_widget_info
+ * Description: Tests registeration of many widgets
+ * Expected: all widgets should be registered in database
+ */
RUNNER_TEST(widget_dao_test_register_widget_info)
{
WacSecurityMock sec;
const std::size_t NUMBER_OF_WIDGETS = 5;
- for (std::size_t number = 0; number < NUMBER_OF_WIDGETS; ++number)
- {
+ for (std::size_t number = 0; number < NUMBER_OF_WIDGETS; ++number) {
std::ostringstream str;
str << "register_info_test_" << number;
regInfo.minVersion = DPL::FromUTF8String("1.0");
regInfo.configInfo.backSupported = true;
- WidgetPkgName pkgname = REGISTER_WIDGET(regInfo, sec);
+ TizenAppId tizenAppId = REGISTER_WIDGET(regInfo, sec);
- WidgetDAO dao(pkgname);
+ WidgetDAO dao(tizenAppId);
RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(dao.getGUID(), str.str());
RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(dao.getVersion(), str.str());
RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(dao.getAuthorName(), str.str());
RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(dao.getAuthorHref(), str.str());
RUNNER_ASSERT_WHAT_EQUALS(dao.getBaseFolder(), str.str() + "/");
RUNNER_ASSERT(dao.getWebkitPluginsRequired() == false);
-// RUNNER_ASSERT(
-// dao.GetWidgetSecurityDomain() == WacSecurity::Trusted);
+ // RUNNER_ASSERT(
+ // dao.GetWidgetSecurityDomain() == WacSecurity::Trusted);
RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(dao.getMinimumWacVersion(), "1.0");
}
-
}
/*
-Name: widget_dao_test_register_widget_extended_info
-Description: Tests registeration of widget_extended_info
-Expected: registeration of extended inforamtion is checked
- via existence of backgroudn page value
-*/
+ * Name: widget_dao_test_register_widget_extended_info
+ * Description: Tests registeration of widget_extended_info
+ * Expected: registeration of extended inforamtion is checked
+ * via existence of backgroudn page value
+ */
RUNNER_TEST(widget_dao_test_register_widget_extended_info)
{
WacSecurityMock sec;
const std::size_t NUMBER_OF_WIDGETS = 5;
- for (std::size_t number = 0; number < NUMBER_OF_WIDGETS; ++number)
- {
+ for (std::size_t number = 0; number < NUMBER_OF_WIDGETS; ++number) {
std::ostringstream str;
str << "register_ext_info_test_" << number;
WidgetRegisterInfo regInfo;
-// regInfo.shareHref = str.str();
+ // regInfo.shareHref = str.str();
regInfo.configInfo.backgroundPage = L"background.html";
- WidgetPkgName pkgname = REGISTER_WIDGET(regInfo, sec);
+ TizenAppId tizenAppId = REGISTER_WIDGET(regInfo, sec);
- WidgetDAO dao(pkgname);
-// RUNNER_ASSERT_WHAT_EQUALS(dao.GetShareHref(), str.str());
+ WidgetDAO dao(tizenAppId);
+ // RUNNER_ASSERT_WHAT_EQUALS(dao.GetShareHref(), str.str());
RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(dao.getBackgroundPage(),
- "background.html");
+ "background.html");
}
}
/*
-Name: widget_dao_test_register_widget_localized_info
-Description: Tests registeration of localized widgets information
-Expected: values received by dao should match those which were registered
-*/
+ * Name: widget_dao_test_register_widget_localized_info
+ * Description: Tests registeration of localized widgets information
+ * Expected: values received by dao should match those which were registered
+ */
RUNNER_TEST(widget_dao_test_register_widget_localized_info)
{
WacSecurityMock sec;
const std::size_t NUMBER_OF_WIDGETS = 5;
- for (std::size_t number = 0; number < NUMBER_OF_WIDGETS; ++number)
- {
+ for (std::size_t number = 0; number < NUMBER_OF_WIDGETS; ++number) {
WidgetRegisterInfo regInfo;
std::ostringstream str_en;
std::ostringstream str_pl;
str_en << "register_loc_info_test_en_" << number;
- str_pl<< "register_loc_info_test_pl_" << number;
- {//EN
+ str_pl << "register_loc_info_test_pl_" << number;
+ { //EN
ConfigParserData::LocalizedData locDataEn;
locDataEn.name = DPL::FromUTF8String(str_en.str());
locDataEn.shortName = DPL::FromUTF8String(str_en.str());
locDataEn.licenseFile = DPL::FromUTF8String(str_en.str());
locDataEn.licenseHref = DPL::FromUTF8String(str_en.str());
regInfo.configInfo.localizedDataSet.insert(
- std::make_pair(DPL::FromUTF8String("en"),locDataEn));
+ std::make_pair(DPL::FromUTF8String("en"), locDataEn));
}
- {//PL
+ { //PL
ConfigParserData::LocalizedData locDataPl;
locDataPl.name = DPL::FromUTF8String(str_pl.str());
locDataPl.shortName = DPL::FromUTF8String(str_pl.str());
locDataPl.licenseFile = DPL::FromUTF8String(str_pl.str());
locDataPl.licenseHref = DPL::FromUTF8String(str_pl.str());
regInfo.configInfo.localizedDataSet.insert(
- std::make_pair(DPL::FromUTF8String("pl"),locDataPl));
+ std::make_pair(DPL::FromUTF8String("pl"), locDataPl));
}
- WidgetPkgName pkgname = REGISTER_WIDGET(regInfo, sec);
+ TizenAppId tizenAppId = REGISTER_WIDGET(regInfo, sec);
- WidgetDAO dao(pkgname);
+ WidgetDAO dao(tizenAppId);
RUNNER_ASSERT_MSG(dao.getLanguageTags().size() == 2,
"language tags list invalid");
- {//EN
+ { //EN
WidgetLocalizedInfo locInfo =
- dao.getLocalizedInfo(DPL::FromUTF8String("en"));
+ dao.getLocalizedInfo(DPL::FromUTF8String("en"));
RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(locInfo.name,
str_en.str());
str_en.str());
}
- {//PL
+ { //PL
WidgetLocalizedInfo locInfo =
- dao.getLocalizedInfo(DPL::FromUTF8String("pl"));
+ dao.getLocalizedInfo(DPL::FromUTF8String("pl"));
RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(locInfo.name,
str_pl.str());
}
/*
-Name: widget_dao_test_register_widget_icons
-Description: Tests registeration of localized icons information
-Expected: values received by dao should match those which were registered
- for icon
-*/
+ * Name: widget_dao_test_register_widget_icons
+ * Description: Tests registeration of localized icons information
+ * Expected: values received by dao should match those which were registered
+ * for icon
+ */
RUNNER_TEST(widget_dao_test_register_widget_icons)
{
WacSecurityMock sec;
icon.height = 10;
LocaleSet locs;
locs.insert(DPL::FromUTF8String("en"));
- WidgetRegisterInfo::LocalizedIcon locIcon(icon,locs);
+ WidgetRegisterInfo::LocalizedIcon locIcon(icon, locs);
regInfo.localizationData.icons.push_back(locIcon);
- WidgetPkgName pkgname = REGISTER_WIDGET(regInfo, sec);
+ TizenAppId tizenAppId = REGISTER_WIDGET(regInfo, sec);
- WidgetDAO dao(pkgname);
+ WidgetDAO dao(tizenAppId);
WidgetDAOReadOnly::WidgetIconList list = dao.getIconList();
RUNNER_ASSERT(list.size() == regInfo.localizationData.icons.size());
WidgetDAOReadOnly::WidgetIconList::const_iterator it1 = list.begin();
WidgetRegisterInfo::LocalizedIconList::const_iterator it2 =
- regInfo.localizationData.icons.begin();
- for(;it1!=list.end() && it2!=regInfo.localizationData.icons.end();
- ++it1,++it2)
+ regInfo.localizationData.icons.begin();
+ for (; it1 != list.end() && it2 != regInfo.localizationData.icons.end();
+ ++it1, ++it2)
{
RUNNER_ASSERT(it2->height == it1->iconHeight);
RUNNER_ASSERT(it2->width == it1->iconWidth);
}
/*
-Name: widget_dao_test_register_widget_start_files
-Description: Tests registeration of localized start files
-Expected: no expectations as it should be removed
-*/
+ * Name: widget_dao_test_register_widget_start_files
+ * Description: Tests registeration of localized start files
+ * Expected: no expectations as it should be removed
+ */
RUNNER_TEST(widget_dao_test_register_widget_start_files)
{
WacSecurityMock sec;
prop1.encoding = DPL::FromUTF8String("enc1");
prop1.type = DPL::FromUTF8String("type1");
- map1.insert(std::make_pair(DPL::FromUTF8String("en"),prop1));
- map1.insert(std::make_pair(DPL::FromUTF8String("pl"),prop1));
+ map1.insert(std::make_pair(DPL::FromUTF8String("en"), prop1));
+ map1.insert(std::make_pair(DPL::FromUTF8String("pl"), prop1));
WidgetRegisterInfo::LocalizedStartFile file1;
WidgetRegisterInfo::LocalizedStartFile file2;
}
/*
-Name: widget_dao_test_register_widget_features
-Description: Tests registeration of features of widget
-Expected: number of features should match (for given widget reginfo)
-*/
+ * Name: widget_dao_test_register_widget_features
+ * Description: Tests registeration of features of widget
+ * Expected: number of features should match (for given widget reginfo)
+ */
RUNNER_TEST(widget_dao_test_register_widget_features)
{
WacSecurityMock sec;
ConfigParserData::FeaturesList features;
- features.insert(ConfigParserData::Feature(DPL::FromUTF8String("f1"),true));
+ features.insert(ConfigParserData::Feature(DPL::FromUTF8String("f1"), true));
features.insert(ConfigParserData::Feature(DPL::FromUTF8String("f2")));
features.insert(ConfigParserData::Feature(DPL::FromUTF8String("f3"),
false));
WidgetRegisterInfo regInfo;
FOREACH(it, features)
- regInfo.configInfo.featuresList.insert(*it);
+ regInfo.configInfo.featuresList.insert(*it);
- WidgetPkgName pkgname = REGISTER_WIDGET(regInfo, sec);
+ TizenAppId tizenAppId = REGISTER_WIDGET(regInfo, sec);
- WidgetDAO dao(pkgname);
+ WidgetDAO dao(tizenAppId);
WidgetFeatureSet out = dao.getFeaturesList();
RUNNER_ASSERT_MSG(out.size() == features.size(),
"wrong number of features");
-// FOREACH(it, out)
-// RUNNER_ASSERT(features.find(*it) != features.end());
+ // FOREACH(it, out)
+ // RUNNER_ASSERT(features.find(*it) != features.end());
}
/*
-Name: widget_dao_test_register_widget_security_settings
-Description: Tests registeration of dafault values of security settings
-Expected: widget should be registered in database.
- Returned values should match dafault.
-*/
+ * Name: widget_dao_test_register_widget_security_settings
+ * Description: Tests registeration of dafault values of security settings
+ * Expected: widget should be registered in database.
+ * Returned values should match dafault.
+ */
RUNNER_TEST(widget_dao_test_register_widget_security_settings)
{
WacSecurityMock sec;
WidgetRegisterInfo regInfo;
- WidgetPkgName pkgname = REGISTER_WIDGET(regInfo, sec);
-
- WidgetDAO dao(pkgname);
- RUNNER_ASSERT_MSG(dao.getSecurityPopupUsage() == WrtDB::SETTINGS_TYPE_ON, "SecurityPopupUsage is not deafult on");
- RUNNER_ASSERT_MSG(dao.getGeolocationUsage() == WrtDB::SETTINGS_TYPE_ON, "GeolocationUsage is not deafult on");
- RUNNER_ASSERT_MSG(dao.getWebNotificationUsage() == WrtDB::SETTINGS_TYPE_ON, "WebNotificationUsage is not deafult on");
- RUNNER_ASSERT_MSG(dao.getWebDatabaseUsage() == WrtDB::SETTINGS_TYPE_ON, "WebDatabaseUsage is not deafult on");
- RUNNER_ASSERT_MSG(dao.getFileSystemUsage() == WrtDB::SETTINGS_TYPE_ON, "FileSystemUsage is not deafult on");
+ TizenAppId tizenAppId = REGISTER_WIDGET(regInfo, sec);
+
+ WidgetDAO dao(tizenAppId);
+ RUNNER_ASSERT_MSG(
+ dao.getSecurityPopupUsage() == WrtDB::SETTINGS_TYPE_ON,
+ "SecurityPopupUsage is not deafult on");
+ RUNNER_ASSERT_MSG(
+ dao.getGeolocationUsage() == WrtDB::SETTINGS_TYPE_ON,
+ "GeolocationUsage is not deafult on");
+ RUNNER_ASSERT_MSG(
+ dao.getWebNotificationUsage() == WrtDB::SETTINGS_TYPE_ON,
+ "WebNotificationUsage is not deafult on");
+ RUNNER_ASSERT_MSG(
+ dao.getWebDatabaseUsage() == WrtDB::SETTINGS_TYPE_ON,
+ "WebDatabaseUsage is not deafult on");
+ RUNNER_ASSERT_MSG(
+ dao.getFileSystemUsage() == WrtDB::SETTINGS_TYPE_ON,
+ "FileSystemUsage is not deafult on");
dao.setSecurityPopupUsage(WrtDB::SETTINGS_TYPE_OFF);
- RUNNER_ASSERT_MSG(dao.getSecurityPopupUsage() == WrtDB::SETTINGS_TYPE_OFF, "SecurityPopupUsage - wrong value");
- RUNNER_ASSERT_MSG(dao.getGeolocationUsage() == WrtDB::SETTINGS_TYPE_ON, "GeolocationUsage - wrong value");
- RUNNER_ASSERT_MSG(dao.getWebNotificationUsage() == WrtDB::SETTINGS_TYPE_ON, "WebNotificationUsage - wrong value");
- RUNNER_ASSERT_MSG(dao.getWebDatabaseUsage() == WrtDB::SETTINGS_TYPE_ON, "WebDatabaseUsage - wrong value");
- RUNNER_ASSERT_MSG(dao.getFileSystemUsage() == WrtDB::SETTINGS_TYPE_ON, "FileSystemUsage - wrong value");
+ RUNNER_ASSERT_MSG(
+ dao.getSecurityPopupUsage() == WrtDB::SETTINGS_TYPE_OFF,
+ "SecurityPopupUsage - wrong value");
+ RUNNER_ASSERT_MSG(
+ dao.getGeolocationUsage() == WrtDB::SETTINGS_TYPE_ON,
+ "GeolocationUsage - wrong value");
+ RUNNER_ASSERT_MSG(
+ dao.getWebNotificationUsage() == WrtDB::SETTINGS_TYPE_ON,
+ "WebNotificationUsage - wrong value");
+ RUNNER_ASSERT_MSG(
+ dao.getWebDatabaseUsage() == WrtDB::SETTINGS_TYPE_ON,
+ "WebDatabaseUsage - wrong value");
+ RUNNER_ASSERT_MSG(
+ dao.getFileSystemUsage() == WrtDB::SETTINGS_TYPE_ON,
+ "FileSystemUsage - wrong value");
dao.setGeolocationUsage(WrtDB::SETTINGS_TYPE_ALWAYS_ASK);
- RUNNER_ASSERT_MSG(dao.getSecurityPopupUsage() == WrtDB::SETTINGS_TYPE_OFF, "SecurityPopupUsage - wrong value");
- RUNNER_ASSERT_MSG(dao.getGeolocationUsage() == WrtDB::SETTINGS_TYPE_ALWAYS_ASK, "GeolocationUsage - wrong value");
- RUNNER_ASSERT_MSG(dao.getWebNotificationUsage() == WrtDB::SETTINGS_TYPE_ON, "WebNotificationUsage - wrong value");
- RUNNER_ASSERT_MSG(dao.getWebDatabaseUsage() == WrtDB::SETTINGS_TYPE_ON, "WebDatabaseUsage - wrong value");
- RUNNER_ASSERT_MSG(dao.getFileSystemUsage() == WrtDB::SETTINGS_TYPE_ON, "FileSystemUsage - wrong value");
+ RUNNER_ASSERT_MSG(
+ dao.getSecurityPopupUsage() == WrtDB::SETTINGS_TYPE_OFF,
+ "SecurityPopupUsage - wrong value");
+ RUNNER_ASSERT_MSG(
+ dao.getGeolocationUsage() == WrtDB::SETTINGS_TYPE_ALWAYS_ASK,
+ "GeolocationUsage - wrong value");
+ RUNNER_ASSERT_MSG(
+ dao.getWebNotificationUsage() == WrtDB::SETTINGS_TYPE_ON,
+ "WebNotificationUsage - wrong value");
+ RUNNER_ASSERT_MSG(
+ dao.getWebDatabaseUsage() == WrtDB::SETTINGS_TYPE_ON,
+ "WebDatabaseUsage - wrong value");
+ RUNNER_ASSERT_MSG(
+ dao.getFileSystemUsage() == WrtDB::SETTINGS_TYPE_ON,
+ "FileSystemUsage - wrong value");
dao.setWebNotificationUsage(WrtDB::SETTINGS_TYPE_OFF);
- RUNNER_ASSERT_MSG(dao.getSecurityPopupUsage() == WrtDB::SETTINGS_TYPE_OFF, "SecurityPopupUsage - wrong value");
- RUNNER_ASSERT_MSG(dao.getGeolocationUsage() == WrtDB::SETTINGS_TYPE_ALWAYS_ASK, "GeolocationUsage - wrong value");
- RUNNER_ASSERT_MSG(dao.getWebNotificationUsage() == WrtDB::SETTINGS_TYPE_OFF, "WebNotificationUsage - wrong value");
- RUNNER_ASSERT_MSG(dao.getWebDatabaseUsage() == WrtDB::SETTINGS_TYPE_ON, "WebDatabaseUsage - wrong value");
- RUNNER_ASSERT_MSG(dao.getFileSystemUsage() == WrtDB::SETTINGS_TYPE_ON, "FileSystemUsage - wrong value");
+ RUNNER_ASSERT_MSG(
+ dao.getSecurityPopupUsage() == WrtDB::SETTINGS_TYPE_OFF,
+ "SecurityPopupUsage - wrong value");
+ RUNNER_ASSERT_MSG(
+ dao.getGeolocationUsage() == WrtDB::SETTINGS_TYPE_ALWAYS_ASK,
+ "GeolocationUsage - wrong value");
+ RUNNER_ASSERT_MSG(
+ dao.getWebNotificationUsage() == WrtDB::SETTINGS_TYPE_OFF,
+ "WebNotificationUsage - wrong value");
+ RUNNER_ASSERT_MSG(
+ dao.getWebDatabaseUsage() == WrtDB::SETTINGS_TYPE_ON,
+ "WebDatabaseUsage - wrong value");
+ RUNNER_ASSERT_MSG(
+ dao.getFileSystemUsage() == WrtDB::SETTINGS_TYPE_ON,
+ "FileSystemUsage - wrong value");
dao.setWebDatabaseUsage(WrtDB::SETTINGS_TYPE_ALWAYS_ASK);
- RUNNER_ASSERT_MSG(dao.getSecurityPopupUsage() == WrtDB::SETTINGS_TYPE_OFF, "SecurityPopupUsage - wrong value");
- RUNNER_ASSERT_MSG(dao.getGeolocationUsage() == WrtDB::SETTINGS_TYPE_ALWAYS_ASK, "GeolocationUsage - wrong value");
- RUNNER_ASSERT_MSG(dao.getWebNotificationUsage() == WrtDB::SETTINGS_TYPE_OFF, "WebNotificationUsage - wrong value");
- RUNNER_ASSERT_MSG(dao.getWebDatabaseUsage() == WrtDB::SETTINGS_TYPE_ALWAYS_ASK, "WebDatabaseUsage - wrong value");
- RUNNER_ASSERT_MSG(dao.getFileSystemUsage() == WrtDB::SETTINGS_TYPE_ON, "FileSystemUsage - wrong value");
+ RUNNER_ASSERT_MSG(
+ dao.getSecurityPopupUsage() == WrtDB::SETTINGS_TYPE_OFF,
+ "SecurityPopupUsage - wrong value");
+ RUNNER_ASSERT_MSG(
+ dao.getGeolocationUsage() == WrtDB::SETTINGS_TYPE_ALWAYS_ASK,
+ "GeolocationUsage - wrong value");
+ RUNNER_ASSERT_MSG(
+ dao.getWebNotificationUsage() == WrtDB::SETTINGS_TYPE_OFF,
+ "WebNotificationUsage - wrong value");
+ RUNNER_ASSERT_MSG(
+ dao.getWebDatabaseUsage() == WrtDB::SETTINGS_TYPE_ALWAYS_ASK,
+ "WebDatabaseUsage - wrong value");
+ RUNNER_ASSERT_MSG(
+ dao.getFileSystemUsage() == WrtDB::SETTINGS_TYPE_ON,
+ "FileSystemUsage - wrong value");
dao.setFileSystemUsage(WrtDB::SETTINGS_TYPE_OFF);
- RUNNER_ASSERT_MSG(dao.getSecurityPopupUsage() == WrtDB::SETTINGS_TYPE_OFF, "SecurityPopupUsage - wrong value");
- RUNNER_ASSERT_MSG(dao.getGeolocationUsage() == WrtDB::SETTINGS_TYPE_ALWAYS_ASK, "GeolocationUsage - wrong value");
- RUNNER_ASSERT_MSG(dao.getWebNotificationUsage() == WrtDB::SETTINGS_TYPE_OFF, "WebNotificationUsage - wrong value");
- RUNNER_ASSERT_MSG(dao.getWebDatabaseUsage() == WrtDB::SETTINGS_TYPE_ALWAYS_ASK, "WebDatabaseUsage - wrong value");
- RUNNER_ASSERT_MSG(dao.getFileSystemUsage() == WrtDB::SETTINGS_TYPE_OFF, "FileSystemUsage - wrong value");
+ RUNNER_ASSERT_MSG(
+ dao.getSecurityPopupUsage() == WrtDB::SETTINGS_TYPE_OFF,
+ "SecurityPopupUsage - wrong value");
+ RUNNER_ASSERT_MSG(
+ dao.getGeolocationUsage() == WrtDB::SETTINGS_TYPE_ALWAYS_ASK,
+ "GeolocationUsage - wrong value");
+ RUNNER_ASSERT_MSG(
+ dao.getWebNotificationUsage() == WrtDB::SETTINGS_TYPE_OFF,
+ "WebNotificationUsage - wrong value");
+ RUNNER_ASSERT_MSG(
+ dao.getWebDatabaseUsage() == WrtDB::SETTINGS_TYPE_ALWAYS_ASK,
+ "WebDatabaseUsage - wrong value");
+ RUNNER_ASSERT_MSG(
+ dao.getFileSystemUsage() == WrtDB::SETTINGS_TYPE_OFF,
+ "FileSystemUsage - wrong value");
dao.setFileSystemUsage(WrtDB::SETTINGS_TYPE_ON);
- RUNNER_ASSERT_MSG(dao.getSecurityPopupUsage() == WrtDB::SETTINGS_TYPE_OFF, "SecurityPopupUsage - wrong value");
- RUNNER_ASSERT_MSG(dao.getGeolocationUsage() == WrtDB::SETTINGS_TYPE_ALWAYS_ASK, "GeolocationUsage - wrong value");
- RUNNER_ASSERT_MSG(dao.getWebNotificationUsage() == WrtDB::SETTINGS_TYPE_OFF, "WebNotificationUsage - wrong value");
- RUNNER_ASSERT_MSG(dao.getWebDatabaseUsage() == WrtDB::SETTINGS_TYPE_ALWAYS_ASK, "WebDatabaseUsage - wrong value");
- RUNNER_ASSERT_MSG(dao.getFileSystemUsage() == WrtDB::SETTINGS_TYPE_ON, "FileSystemUsage - wrong value");
+ RUNNER_ASSERT_MSG(
+ dao.getSecurityPopupUsage() == WrtDB::SETTINGS_TYPE_OFF,
+ "SecurityPopupUsage - wrong value");
+ RUNNER_ASSERT_MSG(
+ dao.getGeolocationUsage() == WrtDB::SETTINGS_TYPE_ALWAYS_ASK,
+ "GeolocationUsage - wrong value");
+ RUNNER_ASSERT_MSG(
+ dao.getWebNotificationUsage() == WrtDB::SETTINGS_TYPE_OFF,
+ "WebNotificationUsage - wrong value");
+ RUNNER_ASSERT_MSG(
+ dao.getWebDatabaseUsage() == WrtDB::SETTINGS_TYPE_ALWAYS_ASK,
+ "WebDatabaseUsage - wrong value");
+ RUNNER_ASSERT_MSG(
+ dao.getFileSystemUsage() == WrtDB::SETTINGS_TYPE_ON,
+ "FileSystemUsage - wrong value");
}
/*
-Name: widget_dao_test_register_widget_win_modes
-Description: Tests registeration of window modes
-Expected: all modes should be returned from dao
-*/
+ * Name: widget_dao_test_register_widget_win_modes
+ * Description: Tests registeration of window modes
+ * Expected: all modes should be returned from dao
+ */
RUNNER_TEST(widget_dao_test_register_widget_win_modes)
{
WacSecurityMock sec;
WidgetRegisterInfo regInfo;
FOREACH(it, modes)
- regInfo.configInfo.windowModes.insert(*it);
+ regInfo.configInfo.windowModes.insert(*it);
- WidgetPkgName pkgname = REGISTER_WIDGET(regInfo, sec);
+ TizenAppId tizenAppId = REGISTER_WIDGET(regInfo, sec);
- WidgetDAO dao(pkgname);
+ WidgetDAO dao(tizenAppId);
std::list<DPL::String> wins = dao.getWindowModes();
RUNNER_ASSERT_MSG(modes.size() == wins.size(),
"wrong number of window modes");
FOREACH(it, wins)
- RUNNER_ASSERT(modes.find(*it) != modes.end());
+ RUNNER_ASSERT(modes.find(*it) != modes.end());
}
/*
-Name: widget_dao_test_register_widget_warp_info
-Description: Tests registeration of access info iris
-Expected: all access info iris should be returned from dao
-*/
+ * Name: widget_dao_test_register_widget_warp_info
+ * Description: Tests registeration of access info iris
+ * Expected: all access info iris should be returned from dao
+ */
RUNNER_TEST(widget_dao_test_register_widget_warp_info)
{
WacSecurityMock sec;
WidgetRegisterInfo regInfo;
FOREACH(it, orig)
- regInfo.configInfo.accessInfoSet.insert(*it);
+ regInfo.configInfo.accessInfoSet.insert(*it);
- WidgetPkgName pkgname = REGISTER_WIDGET(regInfo, sec);
+ TizenAppId tizenAppId = REGISTER_WIDGET(regInfo, sec);
- WidgetDAO dao(pkgname);
+ WidgetDAO dao(tizenAppId);
WidgetAccessInfoList out;
dao.getWidgetAccessInfo(out);
RUNNER_ASSERT_MSG(out.size() == orig.size(),
"wrong number of access info elem");
FOREACH(it, out){
- ConfigParserData::AccessInfo tmp(it->strIRI,it->bSubDomains);
+ ConfigParserData::AccessInfo tmp(it->strIRI, it->bSubDomains);
RUNNER_ASSERT(orig.find(tmp) != orig.end());
}
}
/*
-Name: widget_dao_test_register_widget_certificates
-Description: Tests registeration of widget certificates
-Expected: all certificates should be returned from dao
- and should contain inserted data
-*/
+ * Name: widget_dao_test_register_widget_certificates
+ * Description: Tests registeration of widget certificates
+ * Expected: all certificates should be returned from dao
+ * and should contain inserted data
+ */
RUNNER_TEST(widget_dao_test_register_widget_certificates)
{
WacSecurityMock sec;
certListRef.push_back(cert);
// register widget
- WidgetPkgName pkgname = REGISTER_WIDGET(regInfo, sec);
+ TizenAppId tizenAppId = REGISTER_WIDGET(regInfo, sec);
- WidgetDAO dao(pkgname);
+ WidgetDAO dao(tizenAppId);
// certificates
WidgetCertificateDataList recList = dao.getCertificateDataList();
auto recListIt = recList.begin();
auto certListIt = certListRef.begin();
- for(;recListIt != recList.end() && certListIt != certListRef.end();
- ++recListIt,++certListIt)
+ for (; recListIt != recList.end() && certListIt != certListRef.end();
+ ++recListIt, ++certListIt)
{
RUNNER_ASSERT(recListIt->chainId == certListIt->chainId);
RUNNER_ASSERT(recListIt->owner == certListIt->owner);
RUNNER_ASSERT(recListIt->strCommonName == certListIt->strCommonName);
RUNNER_ASSERT(recListIt->strMD5Fingerprint ==
- certListIt->strMD5Fingerprint);
+ certListIt->strMD5Fingerprint);
RUNNER_ASSERT(recListIt->strSHA1Fingerprint ==
- certListIt->strSHA1Fingerprint);
+ certListIt->strSHA1Fingerprint);
RUNNER_ASSERT(recListIt->type == certListIt->type);
}
// fingerprints
RUNNER_ASSERT(dao.getKeyFingerprints(WidgetCertificateData::DISTRIBUTOR,
- WidgetCertificateData::ENDENTITY).empty());
+ WidgetCertificateData::ENDENTITY).
+ empty());
RUNNER_ASSERT(dao.getKeyFingerprints(WidgetCertificateData::AUTHOR,
- WidgetCertificateData::ENDENTITY).empty());
+ WidgetCertificateData::ENDENTITY).
+ empty());
RUNNER_ASSERT(dao.getKeyFingerprints(WidgetCertificateData::DISTRIBUTOR,
- WidgetCertificateData::ROOT).empty());
+ WidgetCertificateData::ROOT).empty());
FingerPrintList fingerprints = dao.getKeyFingerprints(
WidgetCertificateData::AUTHOR,
WidgetCertificateData::ROOT);
- RUNNER_ASSERT(fingerprints.size() == certListRef.size()*2);
+ RUNNER_ASSERT(fingerprints.size() == certListRef.size() * 2);
FOREACH(it, certListRef)
{
auto md5 = std::find(fingerprints.begin(),
// common names
RUNNER_ASSERT(dao.getKeyCommonNameList(WidgetCertificateData::DISTRIBUTOR,
- WidgetCertificateData::ENDENTITY).empty());
+ WidgetCertificateData::ENDENTITY).
+ empty());
RUNNER_ASSERT(dao.getKeyCommonNameList(WidgetCertificateData::AUTHOR,
- WidgetCertificateData::ENDENTITY).empty());
+ WidgetCertificateData::ENDENTITY).
+ empty());
RUNNER_ASSERT(dao.getKeyCommonNameList(WidgetCertificateData::DISTRIBUTOR,
- WidgetCertificateData::ROOT).empty());
+ WidgetCertificateData::ROOT).empty());
FingerPrintList commonNames = dao.getKeyCommonNameList(
WidgetCertificateData::AUTHOR,
}
/*
-Name: widget_dao_test_is_widget_installed
-Description: Tests checking if widgets are installed
-Expected: installed widgets should be stated as installed
-*/
+ * Name: widget_dao_test_is_widget_installed
+ * Description: Tests checking if widgets are installed
+ * Expected: installed widgets should be stated as installed
+ */
RUNNER_TEST(widget_dao_test_is_widget_installed)
{
RUNNER_ASSERT(WidgetDAO::isWidgetInstalled(L"tizenid201"));
WacSecurityMock sec;
WidgetRegisterInfo regInfo;
- WidgetPkgName pkgname = REGISTER_WIDGET(regInfo, sec);
+ TizenAppId tizenAppId = REGISTER_WIDGET(regInfo, sec);
- RUNNER_ASSERT(WidgetDAO::isWidgetInstalled(pkgname));
+ RUNNER_ASSERT(WidgetDAO::isWidgetInstalled(tizenAppId));
}
/*
-Name: widget_dao_test_unregister_widget
-Description: Tests unregistering widgets
-Expected: widget register informations should be successfully removed
-*/
+ * Name: widget_dao_test_unregister_widget
+ * Description: Tests unregistering widgets
+ * Expected: widget register informations should be successfully removed
+ */
RUNNER_TEST(widget_dao_test_unregister_widget)
{
WacSecurityMock sec;
WidgetRegisterInfo regInfo;
- WidgetPkgName pkgname = REGISTER_WIDGET(regInfo, sec);
+ TizenAppId tizenAppId = REGISTER_WIDGET(regInfo, sec);
- WidgetDAO::unregisterWidget(pkgname);
+ WidgetDAO::unregisterWidget(tizenAppId);
RUNNER_ASSERT_MSG(handles.size() == WidgetDAO::getHandleList().size(),
"Widget unregister failed");
}
/*
-Name: widget_dao_test_register_or_update_widget
-Description: Tests reregistering widgets
-Expected: widget should be successfully replaced
-*/
+ * Name: widget_dao_test_register_or_update_widget
+ * Description: Tests reregistering widgets
+ * Expected: widget should be successfully replaced
+ */
RUNNER_TEST(widget_dao_test_register_or_update_widget)
{
WacSecurityMock sec;
regInfo2.configInfo.version = L"1.1";
regInfo2.configInfo.authorName = L"BBB";
- WrtDB::WidgetPkgName pkgname(L"abcdefghij");
+ WrtDB::TizenAppId tizenAppId(L"abcdefghij");
//first installation
- WidgetDAO::registerWidget(pkgname, regInfo, sec);
- RUNNER_ASSERT_MSG(WidgetDAO::isWidgetInstalled(pkgname), "Widget is not registered");
+ WidgetDAO::registerWidget(tizenAppId, regInfo, sec);
+ RUNNER_ASSERT_MSG(WidgetDAO::isWidgetInstalled(
+ tizenAppId), "Widget is not registered");
//success full update
- WidgetDAO::registerOrUpdateWidget(pkgname, regInfo2, sec);
- RUNNER_ASSERT_MSG(WidgetDAO::isWidgetInstalled(pkgname), "Widget is not reregistered");
- WidgetDAO dao(pkgname);
- RUNNER_ASSERT_MSG(*dao.getVersion() == L"1.1", "Data widget was not updated");
- RUNNER_ASSERT_MSG(*dao.getAuthorName() == L"BBB", "Data widget was not updated");
-
- WidgetDAO::unregisterWidget(pkgname);
+ WidgetDAO::registerOrUpdateWidget(tizenAppId, regInfo2, sec);
+ RUNNER_ASSERT_MSG(WidgetDAO::isWidgetInstalled(
+ tizenAppId), "Widget is not reregistered");
+ WidgetDAO dao(tizenAppId);
+ RUNNER_ASSERT_MSG(
+ *dao.getVersion() == L"1.1", "Data widget was not updated");
+ RUNNER_ASSERT_MSG(
+ *dao.getAuthorName() == L"BBB", "Data widget was not updated");
+
+ WidgetDAO::unregisterWidget(tizenAppId);
}
/*
-Name: widget_dao_test_get_widget_pkgname_list
-Description: Tests getPkgnameList API for backendlib
-Expected: For all position in database should be returned one item in list
-*/
-RUNNER_TEST(widget_dao_test_get_widget_pkgname_list)
+ * Name: widget_dao_test_get_widget_tizenAppId_list
+ * Description: Tests getTizenAppidList API for backendlib
+ * Expected: For all position in database should be returned one item in list
+ */
+RUNNER_TEST(widget_dao_test_get_widget_tizenAppId_list)
{
- WidgetPkgNameList pkgnames = WidgetDAO::getPkgnameList();
- RUNNER_ASSERT(pkgnames.size() >= 3);
+ TizenAppIdList tizenAppIds = WidgetDAO::getTizenAppidList();
+ RUNNER_ASSERT(tizenAppIds.size() >= 3);
}
/*
-Name: widget_dao_test_get_widget_list
-Description: Tests getPkgnameList API for backendlib
-Expected: For all position in database should be returned one item in list
- Those item should contain valid pkgname
-*/
+ * Name: widget_dao_test_get_widget_list
+ * Description: Tests getTizenAppidList API for backendlib
+ * Expected: For all position in database should be returned one item in list
+ * Those item should contain valid tizenAppId
+ */
RUNNER_TEST(widget_dao_test_get_widget_list)
{
WidgetDAOReadOnlyList list = WidgetDAOReadOnly::getWidgetList();
}
/*
-Name: widget_dao_test_get_widget_attributes
-Description: Tests returning basic widget attributes by dao
-Expected: Attributes should match values inserted into database
-*/
+ * Name: widget_dao_test_get_widget_attributes
+ * Description: Tests returning basic widget attributes by dao
+ * Expected: Attributes should match values inserted into database
+ */
RUNNER_TEST(widget_dao_test_get_widget_attributes)
{
{
- WidgetPkgName pkgname = L"tizenid201";
- WidgetDAO dao(pkgname);
+ TizenAppId tizenAppId = L"tizenid201";
+ WidgetDAO dao(tizenAppId);
RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(dao.getGUID(), "w_id_2000");
RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(dao.getVersion(), "1.0.0");
}
/*
-Name: widget_dao_test_localization
-Description: Tests inserting and returning localization info
-Expected: Values inserted into database should match values received from database
-*/
+ * Name: widget_dao_test_localization
+ * Description: Tests inserting and returning localization info
+ * Expected: Values inserted into database should match values received from
+ * database
+ */
RUNNER_TEST(widget_dao_test_localization)
{
WacSecurityMock sec;
LocaleSet locs;
locs.insert(DPL::FromUTF8String("en"));
locs.insert(DPL::FromUTF8String("pl"));
- WidgetRegisterInfo::LocalizedIcon locIcon(icon,locs);
+ WidgetRegisterInfo::LocalizedIcon locIcon(icon, locs);
regInfo.localizationData.icons.push_back(locIcon);
//start file
WidgetRegisterInfo::LocalizedStartFile file;
file.path = DPL::FromUTF8String("path");
file.propertiesForLocales.insert(
- std::make_pair(DPL::FromUTF8String("en"), prop_en));
+ std::make_pair(DPL::FromUTF8String("en"), prop_en));
file.propertiesForLocales.insert(
- std::make_pair(DPL::FromUTF8String("pl"), prop_pl));
+ std::make_pair(DPL::FromUTF8String("pl"), prop_pl));
regInfo.localizationData.startFiles.push_back(file);
// register widget
- WidgetPkgName pkgname = REGISTER_WIDGET(regInfo, sec);
+ TizenAppId tizenAppId = REGISTER_WIDGET(regInfo, sec);
- WidgetDAO dao(pkgname);
+ WidgetDAO dao(tizenAppId);
// check localized icons
WidgetDAO::WidgetLocalizedIconList locList = dao.getLocalizedIconList();
// compare every icon with the origin
auto locsIt = locs.begin();
auto iconIt = locList.begin();
- for(;locsIt!=locs.end() && iconIt!=locList.end();++locsIt,++iconIt) {
+ for (; locsIt != locs.end() && iconIt != locList.end(); ++locsIt,
+ ++iconIt)
+ {
RUNNER_ASSERT(iconIt->appId == dao.getHandle());
RUNNER_ASSERT(iconIt->iconId == iconId);
RUNNER_ASSERT(iconIt->widgetLocale == *locsIt);
int startFileId = dao.getStartFileList().front().startFileId;
- FOREACH(it,fList)
+ FOREACH(it, fList)
{
RUNNER_ASSERT(it->appId == dao.getHandle());
auto propIt = file.propertiesForLocales.find(it->widgetLocale);
}
/*
-Name: widget_dao_test_wac_security
-Description: Tests inserting and returning wac security information
-Expected: Values inserted into database should match values received from database
-*/
+ * Name: widget_dao_test_wac_security
+ * Description: Tests inserting and returning wac security information
+ * Expected: Values inserted into database should match values received from
+ * database
+ */
RUNNER_TEST(widget_dao_test_wac_security)
{
WacSecurityMock sec;
WidgetRegisterInfo regInfo;
{
// register widget
- WidgetPkgName pkgname = REGISTER_WIDGET(regInfo, sec);
- WidgetDAO dao(pkgname);
+ TizenAppId tizenAppId = REGISTER_WIDGET(regInfo, sec);
+ WidgetDAO dao(tizenAppId);
RUNNER_ASSERT(!dao.isDistributorSigned());
RUNNER_ASSERT(!dao.isRecognized());
sec.setWacSigned(true);
{
// register widget
- WidgetPkgName pkgname = REGISTER_WIDGET(regInfo, sec);
- WidgetDAO dao(pkgname);
+ TizenAppId tizenAppId = REGISTER_WIDGET(regInfo, sec);
+ WidgetDAO dao(tizenAppId);
RUNNER_ASSERT(dao.isDistributorSigned());
RUNNER_ASSERT(dao.isRecognized());
}
}
+/*
+ * Name: widget_dao_test_register_scp
+ * Description: Tests inserting and returning scp policy information
+ * Expected: Value inserted into database should match values received from
+ * database
+ */
+RUNNER_TEST(widget_dao_test_register_scp)
+{
+ WacSecurityMock sec;
+ WidgetRegisterInfo regInfo;
+ DPL::OptionalString policy = DPL::FromUTF8String("Some awesome csp policy");
+ regInfo.configInfo.cspPolicy = policy;
+ {
+ // register widget
+ TizenAppId tizenAppId = REGISTER_WIDGET(regInfo, sec);
+ WidgetDAO dao(tizenAppId);
+
+ RUNNER_ASSERT_WHAT_EQUALS_OPTIONAL(
+ dao.getCspPolicy(), DPL::ToUTF8String(*policy));
+ }
+}
+
+/*
+ * Name: widget_dao_test_register_csp_empty
+ * Description: Tests inserting and returning empty csp policy
+ * Expected: Value inserted into database should match values received from
+ * database
+ */
+RUNNER_TEST(widget_dao_test_register_csp_empty)
+{
+ WacSecurityMock sec;
+ WidgetRegisterInfo regInfo;
+ {
+ // register widget
+ TizenAppId tizenAppId = REGISTER_WIDGET(regInfo, sec);
+ WidgetDAO dao(tizenAppId);
+
+ RUNNER_ASSERT_MSG(dao.getCspPolicy().IsNull(), "Policy is not null");
+ }
+}
#undef RUNNER_ASSERT_WHAT_EQUALS
* limitations under the License.
*/
/**
- * @file tests_plugin_dao.cpp
+ * @file tests_plugin_dao.cpp
* @author Pawel Sikorski (p.sikorski@samsung.com)
* @version 1.0
* @brief This file contains tests for plugin dao class.
int ret = system("/usr/bin/wrt_dao_tests_prepare_db.sh start");
if (ret != 0) {
LogError("Preparation script has return error: " << ret
- << ". Quitting");
+ << ". Quitting");
return -1;
}
CustomHandlerDB::Interface::attachDatabaseRW();
LogInfo("Starting tests");
- int status = DPL::Test::TestRunnerSingleton::Instance().ExecTestRunner(argc, argv);
+ int status = DPL::Test::TestRunnerSingleton::Instance().ExecTestRunner(argc,
+ argv);
CustomHandlerDB::Interface::detachDatabase();
WrtDB::WrtDatabase::detachFromThread();
#Widgets
INS_ALL_WIDGETEXT="insert into WidgetExtendedInfo(app_id, share_href, signature_type)"
- INS_ALL_WIDGET="insert into WidgetInfo(app_id, widget_id, widget_version, widget_width, widget_height, author_name, author_email, author_href, base_folder, webkit_plugins_required, recognized, wac_signed, distributor_signed, min_version, pkgname)"
+ INS_ALL_WIDGET="insert into WidgetInfo(app_id, widget_id, widget_version, widget_width, widget_height, author_name, author_email, author_href, base_folder, webkit_plugins_required, recognized, wac_signed, distributor_signed, min_version, tizen_appid)"
INS_ALL_WIDGET_LOC="insert into LocalizedWidgetInfo(app_id, widget_locale, widget_name, widget_shortname, widget_description, widget_license, widget_license_file, widget_license_href)"
INS_ALL_WIDGET_ICONS="insert into WidgetIcon(app_id, icon_src, icon_width, icon_height)"
INS_ALL_WIDGET_LOC_ICONS="insert into WidgetLocalizedIcon(app_id, icon_id, widget_locale)"
INS_ALL_WIDGET_STARTFILE="insert into WidgetStartFile(app_id, src)"
INS_ALL_WIDGET_LOC_STARTFILE="insert into WidgetLocalizedStartFile(app_id, start_file_id, widget_locale, type, encoding)"
INS_ALL_WIDGET_DEFPREF="insert into WidgetDefaultPreference(app_id, key_name, key_value, readonly)"
- INS_ALL_WIDGET_PREF="insert into WidgetPreference(pkgname, key_name, key_value, readonly)"
+ INS_ALL_WIDGET_PREF="insert into WidgetPreference(tizen_appid, key_name, key_value, readonly)"
INS_ALL_WIDGET_FEATURE="insert into WidgetFeature(app_id, name, required)"
INS_ALL_WIDGET_FEATURE_PARAM="insert into FeatureParam(widget_feature_id, name, value)"
INS_ALL_WIDGET_WINMODES="insert into WidgetWindowModes(app_id, window_mode)"
sqlite3 $WRT_DB "${INS_ALL_WIDGET} VALUES(2000, 'w_id_2000', '1.0.0', 100, 200, 'a_name_2000', 'a_email_2000', 'a_href_2000', 'basef_2000', 1, 1, 1, 1, '1.0', 'tizenid201')";
sqlite3 $WRT_DB "${INS_ALL_WIDGET} VALUES(2001, 'w_id_2001', '2.0.0', 100, 200, 'a_name_2001', 'a_email_2001', 'a_href_2001', 'basef_2001', 1, 1, 1, 1, '0.5', 'tizenid202')";
- sqlite3 $WRT_DB "insert into WidgetInfo(app_id, back_supported, pkgname) VALUES(2002, 0, 'tizenid203')";
- sqlite3 $WRT_DB "insert into WidgetInfo(app_id, back_supported, pkgname) VALUES(2003, 0, 'tizenid204')"; # for properties tests
+ sqlite3 $WRT_DB "insert into WidgetInfo(app_id, back_supported, tizen_appid) VALUES(2002, 0, 'tizenid203')";
+ sqlite3 $WRT_DB "insert into WidgetInfo(app_id, back_supported, tizen_appid) VALUES(2003, 0, 'tizenid204')"; # for properties tests
sqlite3 $WRT_DB "${INS_ALL_WIDGETEXT} VALUES(2000, 'share_href_2000', 0)";
sqlite3 $WRT_DB "${INS_ALL_WIDGETEXT} VALUES(2001, 'share_href_2001', 0)";
sqlite3 $WRT_DB "${INS_ALL_WIDGET_PREF} VALUES('tizenid203', 'key2_for_2002', 'value2_for_key_2002', 1)";
#create if not exists and fix autoincrement value
- sqlite3 $WRT_DB "INSERT INTO WidgetInfo(pkgname) VALUES('temp')";
- sqlite3 $WRT_DB "DELETE FROM WidgetInfo WHERE pkgname = 'temp'";
+ sqlite3 $WRT_DB "INSERT INTO WidgetInfo(tizen_appid) VALUES('temp')";
+ sqlite3 $WRT_DB "DELETE FROM WidgetInfo WHERE tizen_appid = 'temp'";
sqlite3 $WRT_DB "UPDATE sqlite_sequence SET seq = 2004 WHERE name = 'WidgetInfo'";
exit $?
# generating proper output files
#
-SET(TARGET_NAME "dpl-tests-db")
+SET(TARGET_NAME "wrt-commons-tests-db")
# Set DPL tests sources
SET(DPL_TESTS_DB_SOURCES
- ${TESTS_DPL_DIR}/db/main.cpp
- ${TESTS_DPL_DIR}/db/test_orm.cpp
- ${TESTS_DPL_DIR}/db/test_sql_connection.cpp
+ ${TESTS_DIR}/db/main.cpp
+ ${TESTS_DIR}/db/test_orm.cpp
+ ${TESTS_DIR}/db/test_sql_connection.cpp
)
ADD_SUBDIRECTORY(orm)
WRT_TEST_INSTALL(${TARGET_NAME})
INSTALL(FILES
- ${TESTS_DPL_DIR}/db/orm/dpl_orm_test.db
+ ${TESTS_DIR}/db/orm/dpl_orm_test.db
DESTINATION /opt/share/wrt/wrt-commons/tests/db
)
)
CREATE_TABLE(TestTableJoin1)
- COLUMN_NOT_NULL(TestID, INT)
- COLUMN_NOT_NULL(TestText, TEXT)
- COLUMN(TestNumber, INT)
+ COLUMN_NOT_NULL(TestID, INT,)
+ COLUMN_NOT_NULL(TestText, TEXT,)
+ COLUMN(TestNumber, INT,)
TABLE_CONSTRAINTS(
PRIMARY KEY(TestID)
)
CREATE_TABLE_END()
CREATE_TABLE(TestTableJoin2)
- COLUMN_NOT_NULL(TestID, INT)
- COLUMN_NOT_NULL(TestText1, TEXT)
- COLUMN_NOT_NULL(TestText2, TEXT)
+ COLUMN_NOT_NULL(TestID, INT,)
+ COLUMN_NOT_NULL(TestText1, TEXT,)
+ COLUMN_NOT_NULL(TestText2, TEXT,)
TABLE_CONSTRAINTS(
PRIMARY KEY(TestID)
)
CREATE_TABLE_END()
CREATE_TABLE(TestTableJoin3)
- COLUMN_NOT_NULL(TestID, INT)
- COLUMN(Value3, INT)
- COLUMN(TestText33, TEXT)
+ COLUMN_NOT_NULL(TestID, INT,)
+ COLUMN(Value3, INT,)
+ COLUMN(TestText33, TEXT,)
TABLE_CONSTRAINTS(
PRIMARY KEY(TestID)
)
INSERT INTO TestTableJoin3 VALUES(6, 222, "test 4");
INSERT INTO TestTableJoin3 (TestID, TestText33) VALUES(7, "test 5");
INSERT INTO TestTableJoin3 (TestID, TestText33) VALUES(10, "test 6");
-)
\ No newline at end of file
+)
* @file dpl_orm_test_db_sql_generator.h
* @author Lukasz Marek (l.marek@samsung.com)
* @version 1.0
- * @brief Macro definitions for generating the SQL input file from database definition.
+ * @brief Macro definitions for generating the SQL input file from
+ * database definition.
*/
//Do not include this file directly! It is used only for SQL code generation.
class SmartAttach
{
-public:
+ public:
SmartAttach(bool autoattach = true) :
m_interface(PATH_DB,
{
return &m_interface;
}
-private:
+
+ private:
DPL::DB::ThreadDatabaseSupport m_interface;
bool m_autoattach;
};
template<typename ContainerType1, typename ContainerType2>
-bool ContainerContentsEqual(const ContainerType1& container1, const ContainerType2& container2)
+bool ContainerContentsEqual(const ContainerType1& container1,
+ const ContainerType2& container2)
{
using namespace DPL::DB::ORM::dpl_orm_test::TestTableInsert;
typedef std::set<typename ContainerType1::value_type> Set1;
Set2 set2(container2.begin(), container2.end());
for (typename Set1::iterator it = set1.begin();
- it != set1.end();
- it++)
+ it != set1.end();
+ it++)
{
LogDebug("Set1 element: " << *it);
}
- for (typename Set2::iterator it = set2.begin(); it != set2.end(); it++)
- {
+ for (typename Set2::iterator it = set2.begin(); it != set2.end(); it++) {
LogDebug("Set2 element: " << *it);
}
RUNNER_TEST_GROUP_INIT(DPL)
+/*
+Name: ORM_SelectSingleValue
+Description: tests quering single value of single row from database
+Expected: Values should match those which were prepared
+*/
RUNNER_TEST(ORM_SelectSingleValue)
{
SmartAttach interface;
TestTable::Select select(interface.get());
select.Where(Equals<TestTable::ColumnInt>(8));
int result;
- RUNNER_ASSERT_MSG((result = *select.GetSingleValue<TestTable::ColumnOptInt>()) == 6, "Got " << result);
+ RUNNER_ASSERT_MSG((result =
+ *select.GetSingleValue<TestTable::ColumnOptInt>())
+ == 6, "Got " <<
+ result);
}
{
TestTable::Select select(interface.get());
select.Where(Equals<TestTable::ColumnInt>(8));
DPL::String result;
- RUNNER_ASSERT_MSG((result = *select.GetSingleValue<TestTable::ColumnOptText>()) == L"seven", "Got " << result);
+ RUNNER_ASSERT_MSG((result =
+ *select.GetSingleValue<TestTable::ColumnOptText>(
+ )) == L"seven",
+ "Got " << result);
}
{
TestTable::Select select(interface.get());
select.Where(Equals<TestTable::ColumnInt>(8));
int result;
- RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt>()) == 8, "Got " << result);
+ RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt>(
+ )) == 8, "Got " << result);
}
{
TestTable::Select select(interface.get());
select.Where(Equals<TestTable::ColumnInt>(8));
int result;
- RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt2>()) == 9, "Got " << result);
+ RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt2>(
+ )) == 9, "Got " << result);
}
{
TestTable::Select select(interface.get());
select.Where(Equals<TestTable::ColumnInt>(8));
DPL::String result;
- RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnText>()) == L"ten", "Got " << result);
+ RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnText>(
+ )) == L"ten", "Got " << result);
}
//Where on each column
TestTable::Select select(interface.get());
select.Where(Equals<TestTable::ColumnOptInt>(6));
int result;
- RUNNER_ASSERT_MSG((result = *select.GetSingleValue<TestTable::ColumnOptInt>()) == 6, "Got " << result);
+ RUNNER_ASSERT_MSG((result =
+ *select.GetSingleValue<TestTable::ColumnOptInt>())
+ == 6, "Got " <<
+ result);
}
{
TestTable::Select select(interface.get());
select.Where(Equals<TestTable::ColumnOptText>(DPL::String(L"seven")));
DPL::String result;
- RUNNER_ASSERT_MSG((result = *select.GetSingleValue<TestTable::ColumnOptText>()) == L"seven", "Got " << result);
+ RUNNER_ASSERT_MSG((result =
+ *select.GetSingleValue<TestTable::ColumnOptText>(
+ )) == L"seven",
+ "Got " << result);
}
{
TestTable::Select select(interface.get());
select.Where(Equals<TestTable::ColumnInt>(8));
int result;
- RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt>()) == 8, "Got " << result);
+ RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt>(
+ )) == 8, "Got " << result);
}
{
TestTable::Select select(interface.get());
select.Where(Equals<TestTable::ColumnInt2>(9));
int result;
- RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt2>()) == 9, "Got " << result);
+ RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt2>(
+ )) == 9, "Got " << result);
}
{
TestTable::Select select(interface.get());
select.Where(Equals<TestTable::ColumnText>(L"ten"));
DPL::String result;
- RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnText>()) == L"ten", "Got " << result);
+ RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnText>(
+ )) == L"ten", "Got " << result);
}
}
+/*
+Name: ORM_SelectSingleRow
+Description: tests quering single row from database
+Expected: Values should match those which were prepared
+*/
RUNNER_TEST(ORM_SelectSingleRow)
{
SmartAttach interface;
}
}
+/*
+Name: ORM_SelectRowList
+Description: tests quering multiple row from database
+Expected: Values should match those which were prepared
+*/
RUNNER_TEST(ORM_SelectRowList)
{
SmartAttach interface;
expected.Set_ColumnInt(3);
expected.Set_ColumnInt2(4);
expected.Set_ColumnText(L"five");
- RUNNER_ASSERT_MSG(*(result.begin()) == expected, "Got " << *(result.begin()) );
+ RUNNER_ASSERT_MSG(*(result.begin()) == expected, "Got " <<
+ *(result.begin()) );
}
{
expected.Set_ColumnInt(8);
expected.Set_ColumnInt2(9);
expected.Set_ColumnText(L"ten");
- RUNNER_ASSERT_MSG(*(result.begin()) == expected, "Got " << *(result.begin()) );
+ RUNNER_ASSERT_MSG(*(result.begin()) == expected, "Got " <<
+ *(result.begin()) );
}
{
expected2.Set_ColumnInt2(13);
expected2.Set_ColumnText(L"fourteen");
- RUNNER_ASSERT(ContainerContentsEqual(makeList(expected1, expected2), result));
+ RUNNER_ASSERT(ContainerContentsEqual(makeList(expected1,
+ expected2), result));
}
}
+/*
+Name: ORM_SelectValueList
+Description: tests quering single column from multiple row from database
+Expected: Values should match those which were prepared
+*/
RUNNER_TEST(ORM_SelectValueList)
{
SmartAttach interface;
{
TestTable::Select select(interface.get());
select.Where(Is<TestTable::ColumnOptInt>(DPL::Optional<int>::Null));
- RUNNER_ASSERT(ContainerContentsEqual(select.GetValueList<TestTable::ColumnInt>(),
- makeList(99, 99)));
+ RUNNER_ASSERT(ContainerContentsEqual(select.GetValueList<TestTable::
+ ColumnInt>(),
+ makeList(99, 99)));
}
{
TestTable::Select select(interface.get());
select.Where(Is<TestTable::ColumnOptInt>(DPL::Optional<int>::Null));
- RUNNER_ASSERT(ContainerContentsEqual(select.GetValueList<TestTable::ColumnInt2>(),
- makeList(11, 13)));
+ RUNNER_ASSERT(ContainerContentsEqual(select.GetValueList<TestTable::
+ ColumnInt2>(),
+ makeList(11, 13)));
}
{
TestTable::Select select(interface.get());
select.Where(Is<TestTable::ColumnOptInt>(DPL::Optional<int>::Null));
- RUNNER_ASSERT(ContainerContentsEqual(select.GetValueList<TestTable::ColumnText>(),
- makeList(DPL::String(L"twelve"), DPL::String(L"fourteen"))));
+ RUNNER_ASSERT(ContainerContentsEqual(select.GetValueList<TestTable::
+ ColumnText>(),
+ makeList(DPL::String(L"twelve"),
+ DPL::String(L"fourteen"))));
}
{
TestTable::Select select(interface.get());
select.Where(Is<TestTable::ColumnOptInt>(DPL::Optional<int>::Null));
- RUNNER_ASSERT(ContainerContentsEqual(select.GetValueList<TestTable::ColumnOptText>(),
- makeList(DPL::Optional<DPL::String>::Null,DPL::Optional<DPL::String>::Null)));
+ RUNNER_ASSERT(ContainerContentsEqual(select.GetValueList<TestTable::
+ ColumnOptText>(),
+ makeList(DPL::Optional<DPL::String>
+ ::Null,
+ DPL::Optional<DPL::String>
+ ::Null)));
}
//Where on each column
{
TestTable::Select select(interface.get());
select.Where(Is<TestTable::ColumnOptInt>(DPL::Optional<int>::Null));
- RUNNER_ASSERT(ContainerContentsEqual(select.GetValueList<TestTable::ColumnInt2>(),
- makeList(11, 13)));
+ RUNNER_ASSERT(ContainerContentsEqual(select.GetValueList<TestTable::
+ ColumnInt2>(),
+ makeList(11, 13)));
}
{
TestTable::Select select(interface.get());
- select.Where(Is<TestTable::ColumnOptText>(DPL::Optional<DPL::String>::Null));
- RUNNER_ASSERT(ContainerContentsEqual(select.GetValueList<TestTable::ColumnInt2>(),
- makeList(11, 13)));
+ select.Where(Is<TestTable::ColumnOptText>(DPL::Optional<DPL::String>::
+ Null));
+ RUNNER_ASSERT(ContainerContentsEqual(select.GetValueList<TestTable::
+ ColumnInt2>(),
+ makeList(11, 13)));
}
{
TestTable::Select select(interface.get());
select.Where(Is<TestTable::ColumnInt>(99));
- RUNNER_ASSERT(ContainerContentsEqual(select.GetValueList<TestTable::ColumnInt2>(),
- makeList(11, 13)));
+ RUNNER_ASSERT(ContainerContentsEqual(select.GetValueList<TestTable::
+ ColumnInt2>(),
+ makeList(11, 13)));
}
}
+/*
+Name: ORM_MultipleCalls
+Description: tests sequnece of different queries
+Expected: Values should match those which were prepared
+*/
RUNNER_TEST(ORM_MultipleCalls)
{
- for (int j = 0 ; j < TEST_REPETITION ; j++ )
- {
- for (int i = 0 ; i < TEST_REPETITION ; i++ )
+ for (int j = 0; j < TEST_REPETITION; j++) {
+ for (int i = 0; i < TEST_REPETITION; i++) {
ORM_SelectSingleValue();
+ }
- for (int i = 0 ; i < TEST_REPETITION ; i++ )
+ for (int i = 0; i < TEST_REPETITION; i++) {
ORM_SelectSingleRow();
+ }
- for (int i = 0 ; i < TEST_REPETITION ; i++ )
+ for (int i = 0; i < TEST_REPETITION; i++) {
ORM_SelectRowList();
+ }
- for (int i = 0 ; i < TEST_REPETITION ; i++ )
+ for (int i = 0; i < TEST_REPETITION; i++) {
ORM_SelectValueList();
+ }
}
}
+/*
+Name: ORM_Insert
+Description: tests insering rows into database
+Expected: Values should be inserted
+*/
RUNNER_TEST(ORM_Insert)
{
SmartAttach interface;
TestTableInsert::Select select1(interface.get());
std::list<int> resultList = select1.GetValueList<TestTableInsert::ColumnInt>();
- RUNNER_ASSERT_MSG(resultList.size() == 0, "Returned list has wrong size: " << resultList.size());
+ RUNNER_ASSERT_MSG(resultList.empty(),
+ "Returned list has wrong size: " << resultList.size());
+
std::list<TestTableInsert::Row> list;
TestTableInsert::Insert insert(interface.get());
list.push_back(row);
{
TestTableInsert::Select select2(interface.get());
- RUNNER_ASSERT_MSG(ContainerContentsEqual(select2.GetRowList(), list), "Returned list doesn't match.");
+ RUNNER_ASSERT_MSG(ContainerContentsEqual(
+ select2.GetRowList(),
+ list), "Returned list doesn't match.");
}
TestTableInsert::Insert insert2(interface.get());
list.push_back(row2);
{
TestTableInsert::Select select(interface.get());
- RUNNER_ASSERT_MSG(ContainerContentsEqual(select.GetRowList(), list), "Returned list doesn't match.");
+ RUNNER_ASSERT_MSG(ContainerContentsEqual(
+ select.GetRowList(),
+ list), "Returned list doesn't match.");
}
TestTableInsert::Insert insert3(interface.get());
list.push_back(row3);
{
TestTableInsert::Select select3(interface.get());
- RUNNER_ASSERT_MSG(ContainerContentsEqual(select3.GetRowList(), list), "Returned list doesn't match.");
+ RUNNER_ASSERT_MSG(ContainerContentsEqual(
+ select3.GetRowList(),
+ list), "Returned list doesn't match.");
}
TestTableInsert::Insert insert4(interface.get());
list.push_back(row4);
{
TestTableInsert::Select select4(interface.get());
- RUNNER_ASSERT_MSG(ContainerContentsEqual(select4.GetRowList(), list), "Returned list doesn't match.");
+ RUNNER_ASSERT_MSG(ContainerContentsEqual(
+ select4.GetRowList(),
+ list), "Returned list doesn't match.");
}
// restore original table state
}
}
+/*
+Name: ORM_MultipleBindInsert
+Description: repeats ORM_Insert test several times
+Expected: Values should be inserted
+*/
RUNNER_TEST(ORM_MultipleBindInsert)
{
- for ( int i = 0 ; i < TEST_REPETITION ; i++ )
- {
+ for (int i = 0; i < TEST_REPETITION; i++) {
ORM_Insert();
}
}
+/*
+Name: ORM_Delete
+Description: tests deleting rows from database
+Expected: deleted rows should not exist
+*/
RUNNER_TEST(ORM_Delete)
{
SmartAttach interface;
using namespace DPL::DB::ORM;
using namespace DPL::DB::ORM::dpl_orm_test;
TestTableDelete::Select selectStart(interface.get());
- selectStart.OrderBy("ColumnInt2 ASC");
+ selectStart.OrderBy(DPL::TypeListDecl<OrderingAscending<TestTableDelete::
+ ColumnInt2> >());
std::list<TestTableDelete::Row> list = selectStart.GetRowList();
std::list<TestTableDelete::Row> originalList = list;
std::vector<TestTableDelete::Row> vector(list.begin(), list.end());
- RUNNER_ASSERT_MSG(list.size() == 4, "Returned list has wrong size: " << list.size());
+ RUNNER_ASSERT_MSG(
+ list.size() == 4, "Returned list has wrong size: " << list.size());
typedef DPL::String S;
//no-act deletes
{
TestTableDelete::Delete del(interface.get());
- del.Where(And(Equals<TestTableDelete::ColumnOptInt>(1), Equals<TestTableDelete::ColumnOptText>(S(L"seven"))));
+ del.Where(And(Equals<TestTableDelete::ColumnOptInt>(1),
+ Equals<TestTableDelete::ColumnOptText>(S(L"seven"))));
del.Execute();
TestTableDelete::Select select(interface.get());
- RUNNER_ASSERT_MSG(ContainerContentsEqual(select.GetRowList(), list), "Returned list doesn't match.");
+ RUNNER_ASSERT_MSG(ContainerContentsEqual(
+ select.GetRowList(),
+ list), "Returned list doesn't match.");
}
{
TestTableDelete::Delete del(interface.get());
- del.Where(And(Equals<TestTableDelete::ColumnOptInt>(6), Equals<TestTableDelete::ColumnOptText>(S(L"two"))));
+ del.Where(And(Equals<TestTableDelete::ColumnOptInt>(6),
+ Equals<TestTableDelete::ColumnOptText>(S(L"two"))));
del.Execute();
TestTableDelete::Select select(interface.get());
- RUNNER_ASSERT_MSG(ContainerContentsEqual(select.GetRowList(), list), "Returned list doesn't match.");
+ RUNNER_ASSERT_MSG(ContainerContentsEqual(
+ select.GetRowList(),
+ list), "Returned list doesn't match.");
}
{
del.Execute();
TestTableDelete::Select select(interface.get());
- RUNNER_ASSERT_MSG(ContainerContentsEqual(select.GetRowList(), list), "Returned list doesn't match.");
+ RUNNER_ASSERT_MSG(ContainerContentsEqual(
+ select.GetRowList(),
+ list), "Returned list doesn't match.");
}
//act deletes
list.remove(vector[1]);
TestTableDelete::Delete del(interface.get());
- del.Where(And(Equals<TestTableDelete::ColumnOptInt>(6), Equals<TestTableDelete::ColumnText>(L"ten")));
+ del.Where(And(Equals<TestTableDelete::ColumnOptInt>(6),
+ Equals<TestTableDelete::ColumnText>(L"ten")));
del.Execute();
TestTableDelete::Select select(interface.get());
- RUNNER_ASSERT_MSG(ContainerContentsEqual(select.GetRowList(), list), "Returned list doesn't match.");
+ RUNNER_ASSERT_MSG(ContainerContentsEqual(
+ select.GetRowList(),
+ list), "Returned list doesn't match.");
}
{
list.remove(vector[3]);
TestTableDelete::Delete del(interface.get());
- del.Where(Is<TestTableDelete::ColumnOptText>(DPL::Optional<DPL::String>::Null));
+ del.Where(Is<TestTableDelete::ColumnOptText>(DPL::Optional<DPL::String>
+ ::Null));
del.Execute();
TestTableDelete::Select select(interface.get());
- RUNNER_ASSERT_MSG(ContainerContentsEqual(select.GetRowList(), list), "Returned list doesn't match.");
+ RUNNER_ASSERT_MSG(ContainerContentsEqual(
+ select.GetRowList(),
+ list), "Returned list doesn't match.");
}
{
del.Execute();
TestTableDelete::Select select(interface.get());
- RUNNER_ASSERT_MSG(select.GetRowList().size() == 0, "Returned list is not empty");
+ RUNNER_ASSERT_MSG(
+ select.GetRowList().size() == 0, "Returned list is not empty");
}
// Restore original table state
- // This also tests if multiple different binds for Insert are working properly
- for (std::list<TestTableDelete::Row>::iterator i = originalList.begin(); i != originalList.end(); i++)
+ // This also tests if multiple different binds for Insert are working
+ // properly
+ for (std::list<TestTableDelete::Row>::iterator i = originalList.begin();
+ i != originalList.end();
+ ++i)
{
TestTableDelete::Insert insert(interface.get());
insert.Values(*i);
{
TestTableDelete::Select select(interface.get());
- RUNNER_ASSERT_MSG(ContainerContentsEqual(select.GetRowList(), originalList), "Returned list doesn't match.");
+ RUNNER_ASSERT_MSG(ContainerContentsEqual(
+ select.GetRowList(),
+ originalList),
+ "Returned list doesn't match.");
}
-
}
+/*
+Name: ORM_MultipleBindDelete
+Description: repeats ORM_Delete test several times
+Expected: Values should be deleted
+*/
RUNNER_TEST(ORM_MultipleBindDelete)
{
- for ( int i = 0 ; i < TEST_REPETITION ; i++ )
- {
+ for (int i = 0; i < TEST_REPETITION; i++) {
ORM_Delete();
}
}
+/*
+Name: ORM_MultipleBindWhere
+Description: tests if multiple bind of same query obejct works
+Expected: Each bind and execution of query should be correct
+*/
RUNNER_TEST(ORM_MultipleBindWhere)
{
SmartAttach interface;
TestTable::Select select(interface.get());
int result;
select.Where(Equals<TestTable::ColumnInt>(8));
- RUNNER_ASSERT_MSG((result = *select.GetSingleValue<TestTable::ColumnOptInt>()) == 6, "Got " << result);
+ RUNNER_ASSERT_MSG((result =
+ *select.GetSingleValue<TestTable::ColumnOptInt>())
+ == 6, "Got " <<
+ result);
select.Where(Equals<TestTable::ColumnInt>(3));
- RUNNER_ASSERT_MSG((result = *select.GetSingleValue<TestTable::ColumnOptInt>()) == 1, "Got " << result);
+ RUNNER_ASSERT_MSG((result =
+ *select.GetSingleValue<TestTable::ColumnOptInt>())
+ == 1, "Got " <<
+ result);
select.Where(Equals<TestTable::ColumnInt>(8));
- RUNNER_ASSERT_MSG((result = *select.GetSingleValue<TestTable::ColumnOptInt>()) == 6, "Got " << result);
+ RUNNER_ASSERT_MSG((result =
+ *select.GetSingleValue<TestTable::ColumnOptInt>())
+ == 6, "Got " <<
+ result);
select.Where(Equals<TestTable::ColumnInt>(3));
- RUNNER_ASSERT_MSG((result = *select.GetSingleValue<TestTable::ColumnOptInt>()) == 1, "Got " << result);
+ RUNNER_ASSERT_MSG((result =
+ *select.GetSingleValue<TestTable::ColumnOptInt>())
+ == 1, "Got " <<
+ result);
}
{
int result;
select.Where(And(Equals<TestTable::ColumnInt>(99),
Equals<TestTable::ColumnText>(L"fourteen")));
- RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt2>()) == 13, "Got " << result);
+ RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt2>(
+ )) == 13, "Got " << result);
select.Where(And(Equals<TestTable::ColumnInt>(99),
Equals<TestTable::ColumnText>(L"twelve")));
- RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt2>()) == 11, "Got " << result);
+ RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt2>(
+ )) == 11, "Got " << result);
select.Where(And(Equals<TestTable::ColumnInt>(99),
Equals<TestTable::ColumnText>(L"fourteen")));
- RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt2>()) == 13, "Got " << result);
+ RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt2>(
+ )) == 13, "Got " << result);
select.Where(And(Equals<TestTable::ColumnInt>(99),
Equals<TestTable::ColumnText>(L"twelve")));
- RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt2>()) == 11, "Got " << result);
+ RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt2>(
+ )) == 11, "Got " << result);
}
{
int result;
select.Where(And(Equals<TestTable::ColumnText>(L"fourteen"),
Equals<TestTable::ColumnInt>(99)));
- RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt2>()) == 13, "Got " << result);
+ RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt2>(
+ )) == 13, "Got " << result);
select.Where(And(Equals<TestTable::ColumnText>(L"twelve"),
Equals<TestTable::ColumnInt>(99)));
- RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt2>()) == 11, "Got " << result);
+ RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt2>(
+ )) == 11, "Got " << result);
select.Where(And(Equals<TestTable::ColumnText>(L"fourteen"),
Equals<TestTable::ColumnInt>(99)));
- RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt2>()) == 13, "Got " << result);
+ RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt2>(
+ )) == 13, "Got " << result);
select.Where(And(Equals<TestTable::ColumnText>(L"twelve"),
Equals<TestTable::ColumnInt>(99)));
- RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt2>()) == 11, "Got " << result);
-
+ RUNNER_ASSERT_MSG((result = select.GetSingleValue<TestTable::ColumnInt2>(
+ )) == 11, "Got " << result);
}
-
}
+/*
+Name: ORM_Update
+Description: tests rows update in database
+Expected: Successful update
+*/
RUNNER_TEST(ORM_Update)
{
SmartAttach interface;
// CHECK
TestTableInsert::Select select(interface.get());
- RUNNER_ASSERT_MSG(ContainerContentsEqual(select.GetRowList(), list), "Returned list doesn't match.");
+ RUNNER_ASSERT_MSG(ContainerContentsEqual(
+ select.GetRowList(),
+ list), "Returned list doesn't match.");
}
{
// UPDATE - no rows
// CHECK
TestTableInsert::Select select(interface.get());
- RUNNER_ASSERT_MSG(ContainerContentsEqual(select.GetRowList(), list), "Returned list doesn't match.");
+ RUNNER_ASSERT_MSG(ContainerContentsEqual(
+ select.GetRowList(),
+ list), "Returned list doesn't match.");
}
{
// UPDATE - one row
// CHECK
TestTableInsert::Select select(interface.get());
- RUNNER_ASSERT_MSG(ContainerContentsEqual(select.GetRowList(), list), "Returned list doesn't match.");
+ RUNNER_ASSERT_MSG(ContainerContentsEqual(
+ select.GetRowList(),
+ list), "Returned list doesn't match.");
}
{
// CHECK
TestTableInsert::Select select(interface.get());
- RUNNER_ASSERT_MSG(ContainerContentsEqual(select.GetRowList(), list), "Returned list doesn't match.");
+ RUNNER_ASSERT_MSG(ContainerContentsEqual(
+ select.GetRowList(),
+ list), "Returned list doesn't match.");
}
// restore original table state
}
}
+/*
+Name: ORM_MultipleBindUpdate
+Description: repeats ORM_Update severl times
+Expected: Successful update
+*/
RUNNER_TEST(ORM_MultipleBindUpdate)
{
- for ( int i = 0 ; i < TEST_REPETITION ; i++ )
- {
+ for (int i = 0; i < TEST_REPETITION; i++) {
ORM_Update();
}
}
+/*
+Name: ORM_transactions
+Description: checks creation of transation object
+Expected: Successful creation of transaction object
+*/
RUNNER_TEST(ORM_transactions)
{
SmartAttach interface;
DPL::DB::ORM::dpl_orm_test::ScopedTransaction transaction(interface.get());
}
+/*
+Name: ORM_MultiAttach
+Description: checks correct behaviou in case of multiple tries to attach to database
+Expected: Methods attaching/dettaching should be prepared for multiple calling
+*/
RUNNER_TEST(ORM_MultiAttach)
{
SmartAttach interface(false);
- RUNNER_ASSERT_MSG(!interface.get()->IsAttached(), "Is attached, but shouldn't be.");
+ RUNNER_ASSERT_MSG(
+ !interface.get()->IsAttached(), "Is attached, but shouldn't be.");
interface.get()->AttachToThread();
- RUNNER_ASSERT_MSG(interface.get()->IsAttached(), "Isn't attached, but should be.");
+ RUNNER_ASSERT_MSG(
+ interface.get()->IsAttached(), "Isn't attached, but should be.");
interface.get()->AttachToThread();
- RUNNER_ASSERT_MSG(interface.get()->IsAttached(), "Isn't attached, but should be.");
+ RUNNER_ASSERT_MSG(
+ interface.get()->IsAttached(), "Isn't attached, but should be.");
interface.get()->DetachFromThread();
- RUNNER_ASSERT_MSG(interface.get()->IsAttached(), "Isn't attached, but should be.");
+ RUNNER_ASSERT_MSG(
+ interface.get()->IsAttached(), "Isn't attached, but should be.");
interface.get()->DetachFromThread();
- RUNNER_ASSERT_MSG(!interface.get()->IsAttached(), "Is attached, but shouldn't be.");
+ RUNNER_ASSERT_MSG(
+ !interface.get()->IsAttached(), "Is attached, but shouldn't be.");
}
+/*
+Name: ORM_Join
+Description: tests ORM's join operation
+Expected: values should insist correct join operation
+*/
RUNNER_TEST(ORM_Join)
{
SmartAttach interface;
using namespace DPL::DB::ORM;
using namespace DPL::DB::ORM::dpl_orm_test;
- typedef DPL::TypeListDecl<TestTableJoin1::TestText, TestTableJoin2::TestText2,
- DPL::TypeListGuard>::Type JoinColumns;
+ typedef DPL::TypeListDecl<TestTableJoin1::TestText,
+ TestTableJoin2::TestText2,
+ DPL::TypeListGuard>::Type JoinColumns;
/* Test for correct join:
* 5 ids from first table matches 5 ids from second table thus join result
* contains 5 rows */
TestTableJoin1::Select select(interface.get());
- select.Join<JoinColumns>(Equal<TestTableJoin1::TestID, TestTableJoin2::TestID>());
- std::list<CustomRow<JoinColumns>> rowlist =
- select.GetCustomRowList<JoinColumns, CustomRow<JoinColumns>>();
+ select.Join<JoinColumns>(Equal<TestTableJoin1::TestID,
+ TestTableJoin2::TestID>());
+ std::list<CustomRow<JoinColumns> > rowlist =
+ select.GetCustomRowList<JoinColumns, CustomRow<JoinColumns> >();
- RUNNER_ASSERT_MSG(rowlist.size() == 5, "Invalid number of rows fetched: " << rowlist.size());
+ RUNNER_ASSERT_MSG(
+ rowlist.size() == 5, "Invalid number of rows fetched: " << rowlist.size());
std::string text;
std::ostringstream oss;
{
cnt++;
- text = DPL::ToUTF8String((*rowit).GetColumnData<TestTableJoin1::TestText>());
+ text =
+ DPL::ToUTF8String((*rowit).GetColumnData<TestTableJoin1::TestText>());
oss << "text val " << cnt;
- RUNNER_ASSERT_MSG(text.compare(oss.str()) == 0, "Invalid value from first column: "
- << text << " expected: " << oss.str());
+ RUNNER_ASSERT_MSG(text.compare(
+ oss.str()) == 0,
+ "Invalid value from first column: "
+ << text << " expected: " << oss.str());
oss.str(std::string());
- text = DPL::ToUTF8String((*rowit).GetColumnData<TestTableJoin2::TestText2>());
+ text =
+ DPL::ToUTF8String((*rowit).GetColumnData<TestTableJoin2::TestText2>());
oss << "text2 " << cnt;
- RUNNER_ASSERT_MSG(text.compare(oss.str()) == 0, "Invalid value from second column: "
- << text << " expected: " << oss.str());
+ RUNNER_ASSERT_MSG(text.compare(
+ oss.str()) == 0,
+ "Invalid value from second column: "
+ << text << " expected: " << oss.str());
oss.str(std::string());
}
/* Test for empty join:
* None of number values from first table matches ids from second table
* - join result should be empty */
TestTableJoin1::Select select2(interface.get());
- select2.Join<JoinColumns>(Equal<TestTableJoin1::TestNumber, TestTableJoin2::TestID>());
- rowlist = select2.GetCustomRowList<JoinColumns, CustomRow<JoinColumns>>();
+ select2.Join<JoinColumns>(Equal<TestTableJoin1::TestNumber,
+ TestTableJoin2::TestID>());
+ rowlist = select2.GetCustomRowList<JoinColumns, CustomRow<JoinColumns> >();
RUNNER_ASSERT_MSG(rowlist.empty(), "Result should be empty but it is not!");
* - join made with int column and text column as keys
* - expected 5 matching rows (one row of 6 should not be matched)*/
TestTableJoin1::Select select3(interface.get());
- select3.Join<JoinColumns>(Equal<TestTableJoin1::TestID, TestTableJoin2::TestText1>());
- rowlist = select3.GetCustomRowList<JoinColumns, CustomRow<JoinColumns>>();
- RUNNER_ASSERT_MSG(rowlist.size() == 5, "Expected 5 rows while received: " << rowlist.size());
+ select3.Join<JoinColumns>(Equal<TestTableJoin1::TestID,
+ TestTableJoin2::TestText1>());
+ rowlist = select3.GetCustomRowList<JoinColumns, CustomRow<JoinColumns> >();
+ RUNNER_ASSERT_MSG(
+ rowlist.size() == 5, "Expected 5 rows while received: " << rowlist.size());
cnt = 0;
FOREACH(rowit, rowlist)
{
cnt++;
// look at last two insertions into TestTableJoin2
// for this skip understanding
- if(cnt == 5) {
+ if (cnt == 5) {
cnt = 6;
}
- text = DPL::ToUTF8String((*rowit).GetColumnData<TestTableJoin1::TestText>());
+ text =
+ DPL::ToUTF8String((*rowit).GetColumnData<TestTableJoin1::TestText>());
oss << "text val " << cnt;
- RUNNER_ASSERT_MSG(text.compare(oss.str()) == 0, "Invalid value from first column: "
- << text << " expected: " << oss.str() << " iteration: " <<cnt);
+ RUNNER_ASSERT_MSG(text.compare(
+ oss.str()) == 0,
+ "Invalid value from first column: "
+ << text << " expected: " << oss.str() <<
+ " iteration: " << cnt);
oss.str(std::string());
- text = DPL::ToUTF8String((*rowit).GetColumnData<TestTableJoin2::TestText2>());
+ text =
+ DPL::ToUTF8String((*rowit).GetColumnData<TestTableJoin2::TestText2>());
oss << "text2 " << cnt;
- RUNNER_ASSERT_MSG(text.compare(oss.str()) == 0, "Invalid value from second column: "
- << text << " expected: " << oss.str() << " iteration: " <<cnt);
+ RUNNER_ASSERT_MSG(text.compare(
+ oss.str()) == 0,
+ "Invalid value from second column: "
+ << text << " expected: " << oss.str() <<
+ " iteration: " << cnt);
oss.str(std::string());
}
/* Test for join with non-unique nullable columns given as keys*/
- typedef DPL::TypeListDecl<TestTableJoin1::TestText, TestTableJoin3::TestText33,
- DPL::TypeListGuard>::Type JoinTables2;
+ typedef DPL::TypeListDecl<TestTableJoin1::TestText,
+ TestTableJoin3::TestText33,
+ DPL::TypeListGuard>::Type JoinTables2;
TestTableJoin1::Select select4(interface.get());
- select4.Join<JoinTables2>(Equal<TestTableJoin1::TestNumber, TestTableJoin3::Value3>());
- std::list<CustomRow<JoinTables2>> rowlist2 = select4.GetCustomRowList<JoinTables2, CustomRow<JoinTables2>>();
- RUNNER_ASSERT_MSG(rowlist2.size() == 4, "Expected 4 rows while received: " << rowlist.size());
+ select4.Join<JoinTables2>(Equal<TestTableJoin1::TestNumber,
+ TestTableJoin3::Value3>());
+ std::list<CustomRow<JoinTables2> > rowlist2 =
+ select4.GetCustomRowList<JoinTables2, CustomRow<JoinTables2> >();
+ RUNNER_ASSERT_MSG(
+ rowlist2.size() == 4, "Expected 4 rows while received: " <<
+ rowlist.size());
cnt = 0;
DPL::Optional<DPL::String> optext;
FOREACH(rowit, rowlist2)
{
cnt++;
- text = DPL::ToUTF8String((*rowit).GetColumnData<TestTableJoin1::TestText>());
+ text =
+ DPL::ToUTF8String((*rowit).GetColumnData<TestTableJoin1::TestText>());
// values expected in subsequent (1,2,3,4) iterations: 1 1 2 2
- oss << "text val " << (1+(int)(cnt/3));
- RUNNER_ASSERT_MSG(text.compare(oss.str()) == 0, "Invalid value from first column: "
- << text << " expected: " << oss.str() << " iteration: " <<cnt);
+ oss << "text val " << (1 + (int)(cnt / 3));
+ RUNNER_ASSERT_MSG(text.compare(
+ oss.str()) == 0,
+ "Invalid value from first column: "
+ << text << " expected: " << oss.str() <<
+ " iteration: " << cnt);
oss.str(std::string());
optext = (*rowit).GetColumnData<TestTableJoin3::TestText33>();
text = DPL::ToUTF8String(*optext);
oss << "test " << cnt;
- RUNNER_ASSERT_MSG(text.compare(oss.str()) == 0, "Invalid value from second column: "
- << text << " expected: " << oss.str() << " iteration: " <<cnt);
+ RUNNER_ASSERT_MSG(text.compare(
+ oss.str()) == 0,
+ "Invalid value from second column: "
+ << text << " expected: " << oss.str() <<
+ " iteration: " << cnt);
oss.str(std::string());
}
/* Test for join made on three tables:
* - 3 text columns selected for join
* - Equal made for TestID of (table1 and table2) and (table1 and table3) */
- typedef DPL::TypeListDecl<TestTableJoin1::TestText, TestTableJoin2::TestText2,
- TestTableJoin3::TestText33, DPL::TypeListGuard>::Type Join3Tables;
+ typedef DPL::TypeListDecl<TestTableJoin1::TestText,
+ TestTableJoin2::TestText2,
+ TestTableJoin3::TestText33,
+ DPL::TypeListGuard>::Type Join3Tables;
TestTableJoin1::Select select5(interface.get());
- select5.Join<Join3Tables>(Equal<TestTableJoin1::TestID, TestTableJoin2::TestID>());
- select5.Join<Join3Tables>(Equal<TestTableJoin1::TestID, TestTableJoin3::TestID>());
- std::list<CustomRow<Join3Tables>> rowlist3tab = select5.GetCustomRowList<Join3Tables, CustomRow<Join3Tables>>();
- RUNNER_ASSERT_MSG(rowlist3tab.size() == 3, "Expected 3 rows while received: " << rowlist3tab.size());
+ select5.Join<Join3Tables>(Equal<TestTableJoin1::TestID,
+ TestTableJoin2::TestID>());
+ select5.Join<Join3Tables>(Equal<TestTableJoin1::TestID,
+ TestTableJoin3::TestID>());
+ std::list<CustomRow<Join3Tables> > rowlist3tab =
+ select5.GetCustomRowList<Join3Tables, CustomRow<Join3Tables> >();
+ RUNNER_ASSERT_MSG(
+ rowlist3tab.size() == 3, "Expected 3 rows while received: " <<
+ rowlist3tab.size());
cnt = 0;
FOREACH(rowit, rowlist3tab)
{
cnt++;
- text = DPL::ToUTF8String((*rowit).GetColumnData<TestTableJoin1::TestText>());
+ text =
+ DPL::ToUTF8String((*rowit).GetColumnData<TestTableJoin1::TestText>());
oss << "text val " << cnt;
- RUNNER_ASSERT_MSG(text.compare(oss.str()) == 0, "Invalid value from first column: "
- << text << " expected: " << oss.str() << " iteration: " <<cnt);
+ RUNNER_ASSERT_MSG(text.compare(
+ oss.str()) == 0,
+ "Invalid value from first column: "
+ << text << " expected: " << oss.str() <<
+ " iteration: " << cnt);
oss.str(std::string());
- text = DPL::ToUTF8String((*rowit).GetColumnData<TestTableJoin2::TestText2>());
+ text =
+ DPL::ToUTF8String((*rowit).GetColumnData<TestTableJoin2::TestText2>());
oss << "text2 " << cnt;
- RUNNER_ASSERT_MSG(text.compare(oss.str()) == 0, "Invalid value from first column: "
- << text << " expected: " << oss.str() << " iteration: " <<cnt);
+ RUNNER_ASSERT_MSG(text.compare(
+ oss.str()) == 0,
+ "Invalid value from first column: "
+ << text << " expected: " << oss.str() <<
+ " iteration: " << cnt);
oss.str(std::string());
optext = (*rowit).GetColumnData<TestTableJoin3::TestText33>();
text = DPL::ToUTF8String(*optext);
oss << "test " << cnt;
- RUNNER_ASSERT_MSG(text.compare(oss.str()) == 0, "Invalid value from second column: "
- << text << " expected: " << oss.str() << " iteration: " <<cnt);
+ RUNNER_ASSERT_MSG(text.compare(
+ oss.str()) == 0,
+ "Invalid value from second column: "
+ << text << " expected: " << oss.str() <<
+ " iteration: " << cnt);
oss.str(std::string());
}
}
+
+RUNNER_TEST(ORM_SelectOrderByMultipleColumns)
+{
+ SmartAttach interface;
+ using namespace DPL::DB::ORM;
+ using namespace DPL::DB::ORM::dpl_orm_test;
+ {
+ TestTableJoin3::Select select(interface.get());
+
+ // testing: " ORDER BY Value3 ASC, TestID DESC, TestID ASC"
+ select.OrderBy(DPL::TypeListDecl<OrderingAscending<TestTableJoin3::
+ Value3>,
+ OrderingDescending<TestTableJoin3::
+ TestText33>,
+ OrderingAscending<TestTableJoin3::
+ TestID> >());
+
+ std::list<TestTableJoin3::Row> result = select.GetRowList();
+ std::list<TestTableJoin3::Row>::const_iterator iter = result.begin();
+ { //1 row
+ RUNNER_ASSERT_MSG(*iter->Get_TestText33() ==
+ DPL::FromASCIIString(
+ "test 6"), "Wrong row 1 order");
+ RUNNER_ASSERT_MSG(iter->Get_TestID() == 10, "Wrong row 1 order");
+ ++iter;
+ }
+ { //2 row
+ RUNNER_ASSERT_MSG(*iter->Get_TestText33() ==
+ DPL::FromASCIIString(
+ "test 5"), "Wrong row 2 order");
+ RUNNER_ASSERT_MSG(iter->Get_TestID() == 7, "Wrong row 2 order");
+ ++iter;
+ }
+ { //3 row
+ RUNNER_ASSERT_MSG(iter->Get_Value3() == 111, "Wrong row 3 order");
+ RUNNER_ASSERT_MSG(*iter->Get_TestText33() ==
+ DPL::FromASCIIString(
+ "test 2"), "Wrong row 3 order");
+ RUNNER_ASSERT_MSG(iter->Get_TestID() == 2, "Wrong row 3 order");
+ ++iter;
+ }
+ { //4 row
+ RUNNER_ASSERT_MSG(iter->Get_Value3() == 111, "Wrong row 4 order");
+ RUNNER_ASSERT_MSG(*iter->Get_TestText33() ==
+ DPL::FromASCIIString(
+ "test 1"), "Wrong row 4 order");
+ RUNNER_ASSERT_MSG(iter->Get_TestID() == 1, "Wrong row 4 order");
+ ++iter;
+ }
+ { //5 row
+ RUNNER_ASSERT_MSG(iter->Get_Value3() == 222, "Wrong row 5 order");
+ RUNNER_ASSERT_MSG(*iter->Get_TestText33() ==
+ DPL::FromASCIIString(
+ "test 4"), "Wrong row 5 order");
+ RUNNER_ASSERT_MSG(iter->Get_TestID() == 6, "Wrong row 5 order");
+ ++iter;
+ }
+ { //6 row
+ RUNNER_ASSERT_MSG(iter->Get_Value3() == 222, "Wrong row 6 order");
+ RUNNER_ASSERT_MSG(*iter->Get_TestText33() ==
+ DPL::FromASCIIString(
+ "test 3"), "Wrong row 6 order");
+ RUNNER_ASSERT_MSG(iter->Get_TestID() == 3, "Wrong row 6 order");
+ ++iter;
+ }
+ }
+}
class AbstractSynchronizationObjectGenerator
{
-public:
+ public:
virtual ~AbstractSynchronizationObjectGenerator() {}
virtual DPL::DB::SqlConnection::SynchronizationObject *Create() = 0;
};
-class NaiveSynchronizationObjectGenerator
- : public AbstractSynchronizationObjectGenerator
+class NaiveSynchronizationObjectGenerator :
+ public AbstractSynchronizationObjectGenerator
{
-public:
+ public:
virtual DPL::DB::SqlConnection::SynchronizationObject *Create()
{
return new DPL::DB::NaiveSynchronizationObject();
void MassiveReadWriteTest(AbstractSynchronizationObjectGenerator *generator);
-class StressGenerator
- : public DPL::Thread
+class StressGenerator :
+ public DPL::Thread
{
-private:
+ private:
size_t m_prefix;
std::string m_dbFileName;
AbstractSynchronizationObjectGenerator *m_generator;
-protected:
+ protected:
virtual int ThreadEntry()
{
DPL::DB::SqlConnection connection(
connection.PrepareDataCommand(
"SELECT COUNT(*) FROM test WHERE value=?");
- for (size_t i = 0; i < 10; ++i)
- {
+ for (size_t i = 0; i < 10; ++i) {
std::ostringstream valueStream;
valueStream << "value_";
return 0;
}
-public:
+ public:
StressGenerator(size_t prefix,
const std::string &dbFileName,
- AbstractSynchronizationObjectGenerator *generator)
- : m_prefix(prefix),
- m_dbFileName(dbFileName),
- m_generator(generator)
- {
- }
+ AbstractSynchronizationObjectGenerator *generator) :
+ m_prefix(prefix),
+ m_dbFileName(dbFileName),
+ m_generator(generator)
+ {}
};
typedef std::shared_ptr<DPL::Thread> ThreadPtr;
const size_t STRESS_GENERATOR_COUNT = 5;
ThreadPtr stressGenerators[STRESS_GENERATOR_COUNT];
- for (size_t i = 0; i < STRESS_GENERATOR_COUNT; ++i)
- {
+ for (size_t i = 0; i < STRESS_GENERATOR_COUNT; ++i) {
stressGenerators[i].reset(
new StressGenerator(i, PATH_DB, generator));
stressGenerators[i]->Run();
}
- for (size_t i = 0; i < STRESS_GENERATOR_COUNT; ++i)
+ for (size_t i = 0; i < STRESS_GENERATOR_COUNT; ++i) {
stressGenerators[i]->Quit();
+ }
connection.ExecCommand("DROP TABLE test;");
}
+/*
+Name: SqlConnection_MassiveReadWrite_NaiveSynchronization
+Description: tests massive multiple quiries from many threads
+Expected: no ORM/db failures
+*/
RUNNER_TEST(SqlConnection_MassiveReadWrite_NaiveSynchronization)
{
srand(time(NULL));
MassiveReadWriteTest(&m_generator);
}
-
-
-
-
-
+/*
+Name: SqlConnection_Not_Connected_Lucene
+Description: tests connection to not existing database with Lucene option
+Expected: exception throw
+*/
RUNNER_TEST(SqlConnection_Not_Connected_Lucene)
{
Try {
- DPL::DB::SqlConnection connection("/notexisitingdirectiory/foo",
- DPL::DB::SqlConnection::Flag::UseLucene,
- DPL::DB::SqlConnection::Flag::RW);
+ DPL::DB::SqlConnection connection(
+ "/notexisitingdirectiory/foo",
+ DPL::DB::SqlConnection::Flag::
+ UseLucene,
+ DPL::DB::SqlConnection::Flag::RW);
RUNNER_ASSERT_MSG(false,
"connection should throw on accessing "
"nonexistent file as a database");
}
- Catch (DPL::DB::SqlConnection::Exception::ConnectionBroken)
+ Catch(DPL::DB::SqlConnection::Exception::ConnectionBroken)
{
RUNNER_ASSERT(true);
- }
- catch (DPL::Exception)
- {
+ } catch (DPL::Exception) {
RUNNER_ASSERT_MSG(false, "Wrong exception found");
}
}
+/*
+Name: SqlConnection_Not_Connected
+Description: tests connection to not existing database without Lucene option
+Expected: exception throw
+*/
RUNNER_TEST(SqlConnection_Not_Connected)
{
Try {
"connection should throw on accessing "
"nonexistent file as a database");
}
- Catch (DPL::DB::SqlConnection::Exception::ConnectionBroken)
+ Catch(DPL::DB::SqlConnection::Exception::ConnectionBroken)
{
RUNNER_ASSERT(true);
- }
- catch (DPL::Exception)
- {
+ } catch (DPL::Exception) {
RUNNER_ASSERT_MSG(false, "Wrong exception found");
}
}
+/*
+Name: SqlConnection_Null_Query
+Description: tests resistance to passing NULL as query in ExecCommand
+Expected: exception throw
+*/
RUNNER_TEST(SqlConnection_Null_Query)
{
DPL::DB::SqlConnection connection(PATH_DB,
RUNNER_ASSERT_MSG(false,
"Null pointer should not be accepted");
}
- Catch (DPL::DB::SqlConnection::Exception::SyntaxError)
+ Catch(DPL::DB::SqlConnection::Exception::SyntaxError)
{
RUNNER_ASSERT(true);
- }
- catch (DPL::Exception)
- {
+ } catch (DPL::Exception) {
RUNNER_ASSERT_MSG(false, "Wrong exception found");
}
-
}
+/*
+Name: SqlConnection_Bad_Query
+Description: tests resistance to passing trash as query in ExecCommand
+Expected: exception throw
+*/
RUNNER_TEST(SqlConnection_Bad_Query)
{
DPL::DB::SqlConnection connection(PATH_DB,
connection.ExecCommand("Some stupid string");
RUNNER_ASSERT_MSG(false, "This string should not be accepted");
}
- Catch (DPL::DB::SqlConnection::Exception::SyntaxError)
+ Catch(DPL::DB::SqlConnection::Exception::SyntaxError)
{
RUNNER_ASSERT(true);
- }
- catch (DPL::Exception)
- {
+ } catch (DPL::Exception) {
RUNNER_ASSERT_MSG(false, "Wrong exception found");
}
}
INCLUDE(FindPkgConfig)
-PKG_CHECK_MODULES(DEPENDENCIES gthread-2.0 REQUIRED)
+PKG_CHECK_MODULES(DEPENDENCIES gthread-2.0 REQUIRED)
-SET(TARGET_DBUS_TESTS "dpl-tests-dbus")
-SET(TARGET_DBUS_TEST_SERVICE "dpl-dbus-test-service")
+SET(TARGET_DBUS_TESTS "wrt-commons-tests-dbus")
+SET(TARGET_DBUS_TEST_SERVICE "wrt-commons-tests-dbus-test-service")
SET(DBUS_TESTS_SRCS
- ${TESTS_DPL_DIR}/dbus/main.cpp
- ${TESTS_DPL_DIR}/dbus/test_cases.cpp
- ${TESTS_DPL_DIR}/dbus/dbus_test.cpp
+ ${TESTS_DIR}/dbus/main.cpp
+ ${TESTS_DIR}/dbus/test_cases.cpp
+ ${TESTS_DIR}/dbus/dbus_test.cpp
${TESTS_COMMON_DIR}/src/loop_control.cpp
)
SET(DBUS_TEST_SERVICE_SRCS
- ${TESTS_DPL_DIR}/dbus/test_service.cpp
+ ${TESTS_DIR}/dbus/test_service.cpp
${TESTS_COMMON_DIR}/src/loop_control.cpp
)
WRT_TEST_INSTALL(${TARGET_DBUS_TEST_SERVICE})
INSTALL(FILES
- ${TESTS_DPL_DIR}/dbus/data/org.tizen.DBusTestService.service
+ ${TESTS_DIR}/dbus/data/org.tizen.DBusTestService.service
DESTINATION /usr/share/dbus-1/services
)
--- /dev/null
+[D-BUS Service]
+Name=org.tizen.DBusTestService
+Exec=/usr/bin/wrt-commons-tests-dbus-test-service
#include "loop_control.h"
#include "dbus_test.h"
-DBusTest::DBusTest(const std::string& name)
- : m_name(name),
- m_status(Status::NONE)
-{
-}
+DBusTest::DBusTest(const std::string& name) :
+ m_name(name),
+ m_status(Status::NONE)
+{}
void DBusTest::run(unsigned int timeout)
{
LoopControl::wrt_start_loop();
- switch (m_status)
- {
+ switch (m_status) {
case Status::FAILED:
throw DPL::Test::TestRunner::TestFailed(m_name.c_str(),
__FILE__,
__LINE__,
m_message);
+ case Status::SUCCESS:
+ case Status::NONE:
default:
break;
}
DECLARE_GENERIC_EVENT_0(TimeoutEvent)
class DBusTest :
- private DPL::Event::Controller<DPL::TypeListDecl<QuitEvent, TimeoutEvent>::Type>
+ private DPL::Event::Controller<DPL::TypeListDecl<QuitEvent,
+ TimeoutEvent>::Type>
{
-public:
+ public:
enum class Status
{
NONE,
void success();
void fail(const std::string& message = std::string());
-private:
+ private:
void OnEventReceived(const TimeoutEvent& event);
void OnEventReceived(const QuitEvent& event);
class DBusTestManager : private DPL::Noncopyable
{
-public:
+ public:
static DBusTestManager& getInstance();
DBusTest& getCurrentTest() const;
void clear();
-private:
+ private:
DBusTestManager();
DBusTest* m_test;
LoopControl::init_loop(argc, argv);
LogInfo("Running tests");
- int status = DPL::Test::TestRunnerSingleton::Instance().ExecTestRunner(argc, argv);
+ int status = DPL::Test::TestRunnerSingleton::Instance().ExecTestRunner(argc,
+ argv);
return status;
}
const std::string methodNameEcho = "echo";
const std::string methodNameQuit = "quit";
const std::string nodeInfo =
- "<?xml version='1.0'?>"
- "<node>"
- " <interface name='" + interfaceName + "'>"
- " <method name='" + methodNameEcho + "'>"
- " <arg type='s' name='challenge' direction='in'/>"
- " <arg type='s' name='response' direction='out'/>"
- " </method>"
- " <method name='" + methodNameQuit + "'>"
- " </method>"
- " </interface>"
- "</node>";
+ "<?xml version='1.0'?>"
+ "<node>"
+ " <interface name='" + interfaceName + "'>"
+ " <method name='" +
+ methodNameEcho + "'>"
+ " <arg type='s' name='challenge' direction='in'/>"
+ " <arg type='s' name='response' direction='out'/>"
+ " </method>"
+ " <method name='"
+ + methodNameQuit + "'>"
+ " </method>"
+ " </interface>"
+ "</node>";
const std::string challenge = "Hello world!";
RUNNER_TEST_GROUP_INIT(DPL)
+/*
+Name: AcquireSessionBus
+Description: tests acquiring session bus
+Expected: no exceptions
+*/
RUNNER_TEST(AcquireSessionBus)
{
- try
- {
+ try {
DPL::DBus::Connection::sessionBus();
- }
- catch (const DPL::DBus::Exception& ex)
- {
+ } catch (const DPL::DBus::Exception& ex) {
RUNNER_ASSERT_MSG(false, ex.DumpToString());
}
}
+/*
+Name: AcquireSystemBus
+Description: tests acquiring system bus
+Expected: no exceptions
+*/
RUNNER_TEST(AcquireSystemBus)
{
- try
- {
+ try {
DPL::DBus::Connection::systemBus();
- }
- catch (const DPL::DBus::Exception& ex)
- {
+ } catch (const DPL::DBus::Exception& ex) {
RUNNER_ASSERT_MSG(false, ex.DumpToString());
}
}
+/*
+Name: ParseNodeInfo
+Description: creates dbus interface from xml string
+Expected: interface should be created correctly
+*/
RUNNER_TEST(ParseNodeInfo)
{
- try
- {
+ try {
auto ifaces = DPL::DBus::Interface::fromXMLString(nodeInfo);
RUNNER_ASSERT(!ifaces.empty());
auto iface = ifaces.at(0);
RUNNER_ASSERT(NULL != iface->getVTable());
RUNNER_ASSERT(NULL != iface->getInfo());
- }
- catch (const DPL::DBus::Exception& ex)
- {
+ } catch (const DPL::DBus::Exception& ex) {
RUNNER_ASSERT_MSG(false, ex.DumpToString());
}
}
+/*
+Name: InvokeRemoteMethod
+Description: performs procedure call via dbus
+Expected: call should return not empty id
+*/
RUNNER_TEST(InvokeRemoteMethod)
{
- try
- {
+ try {
auto connection = DPL::DBus::Connection::systemBus();
auto freedesktop = connection->createObjectProxy(dbusServiceName,
- dbusObjectPath);
+ dbusObjectPath);
auto getId = freedesktop->createMethodProxy<std::string>
(dbusInterfaceName, dbusMethodGetId);
RUNNER_ASSERT(!getId().empty());
- }
- catch (const DPL::DBus::Exception& ex)
- {
+ } catch (const DPL::DBus::Exception& ex) {
RUNNER_ASSERT_MSG(false, ex.DumpToString());
}
}
class RegisterServiceListener :
- public DPL::Event::EventListener<DPL::DBus::ConnectionEvents::ServiceNameAcquiredEvent>
+ public DPL::Event::EventListener<DPL::DBus::ConnectionEvents::
+ ServiceNameAcquiredEvent>
{
-public:
+ public:
void OnEventReceived(
- const DPL::DBus::ConnectionEvents::ServiceNameAcquiredEvent& event)
+ const DPL::DBus::ConnectionEvents::ServiceNameAcquiredEvent& event)
{
DBusTest& test = DBusTestManager::getInstance().getCurrentTest();
auto name = event.GetArg0();
- if (serviceName == name)
- {
+ if (serviceName == name) {
test.success();
- }
- else
- {
+ } else {
test.fail("Acquired service name: " + name);
}
test.quit();
}
};
+/*
+Name: RegisterService
+Description: tests event listener for AcquiredEvent in context of dbus
+Expected: event should be received
+*/
DBUS_TEST(RegisterService)
{
- try
- {
+ try {
RegisterServiceListener listener;
auto connection = DPL::DBus::Connection::sessionBus();
connection->DPL::Event::EventSupport<DPL::DBus::ConnectionEvents::
- ServiceNameAcquiredEvent>::AddListener(&listener);
+ ServiceNameAcquiredEvent>::
+ AddListener(&listener);
connection->registerService(serviceName);
DBusTestManager::getInstance().getCurrentTest().run(DEFAULT_TIMEOUT);
- }
- catch (const DPL::DBus::Exception& ex)
- {
+ } catch (const DPL::DBus::Exception& ex) {
RUNNER_ASSERT_MSG(false, ex.DumpToString());
}
}
*/
DBUS_TEST(InvokeTestService)
{
- try
- {
+ try {
auto connection = DPL::DBus::Connection::sessionBus();
auto testService = connection->createObjectProxy(serviceName,
objectPath);
(interfaceName, methodNameEcho);
auto response = echo(challenge);
- testService->createMethodProxy<void>(interfaceName, methodNameQuit)();
+ testService->createMethodProxy<void>(interfaceName, methodNameQuit) ();
RUNNER_ASSERT_MSG(response == challenge,
"[challenge = " << challenge <<
", response = " << response << "]");
- }
- catch (const DPL::DBus::Exception& ex)
- {
+ } catch (const DPL::DBus::Exception& ex) {
RUNNER_ASSERT_MSG(false, ex.DumpToString());
}
}
const std::string methodNameEcho = "echo";
const std::string methodNameQuit = "quit";
const std::string nodeInfo =
- "<?xml version='1.0'?>"
- "<node>"
- " <interface name='" + interfaceName + "'>"
- " <method name='" + methodNameEcho + "'>"
- " <arg type='s' name='challenge' direction='in'/>"
- " <arg type='s' name='response' direction='out'/>"
- " </method>"
- " <method name='" + methodNameQuit + "'>"
- " </method>"
- " </interface>"
- "</node>";
+ "<?xml version='1.0'?>"
+ "<node>"
+ " <interface name='" + interfaceName + "'>"
+ " <method name='" +
+ methodNameEcho + "'>"
+ " <arg type='s' name='challenge' direction='in'/>"
+ " <arg type='s' name='response' direction='out'/>"
+ " </method>"
+ " <method name='"
+ + methodNameQuit + "'>"
+ " </method>"
+ " </interface>"
+ "</node>";
}
class TestServiceDispatcher : public DPL::DBus::Dispatcher
{
-private:
+ private:
void onMethodCall(GDBusConnection* /*connection*/,
const gchar* /*sender*/,
const gchar* /*objectPath*/,
GVariant* parameters,
GDBusMethodInvocation* invocation)
{
- if (methodNameEcho == methodName)
- {
+ if (methodNameEcho == methodName) {
LogDebug("Echo");
g_dbus_method_invocation_return_value(invocation,
parameters);
- }
- else if (methodNameQuit == methodName)
- {
+ } else if (methodNameQuit == methodName) {
LogDebug("Quit");
g_dbus_method_invocation_return_value(invocation, NULL);
LoopControl::wrt_end_loop();
+++ /dev/null
-Unit tests for dpl library functionality.
-There are 6 binaries: dpl-dbus-test-service, dpl-tests-core, dpl-tests-db,
-dpl-tests-dbus, dpl-tests-event, dpl-tests-utils.
-All binaries are using our test framework - it allows to use different types of
-output. Text output shows results on console - green passed.
-To run:
-1. Install wrt-extra on target
-2. Run for f in /usr/bin/dpl-tests-*; do $f --output=text; done
-
-Automatic: YES
-Included in Daily Build: YES (http://build01.sprc.samsung.pl/browse/LINUXNGWAP-INT)
-Included in Gerrit Builds: YES (http://build01.sprc.samsung.pl/browse/LINUXNGWAP-GERRIT)
-Number of test cases: 151
\ No newline at end of file
+++ /dev/null
-[D-BUS Service]
-Name=org.tizen.DBusTestService
-Exec=/usr/bin/dpl-dbus-test-service
+++ /dev/null
-INSTALL(FILES
- ${DPL_TESTS_DIR}/localization/files/one
- DESTINATION
- /opt/share/widget/tests/localization/widget1/locales/pl-en
- )
-
-INSTALL(FILES
- ${DPL_TESTS_DIR}/localization/files/one
- ${DPL_TESTS_DIR}/localization/files/two
- DESTINATION
- /opt/share/widget/tests/localization/widget2/locales/pl-en
- )
-
-INSTALL(FILES
- ${DPL_TESTS_DIR}/localization/files/two
- DESTINATION
- /opt/share/widget/tests/localization/widget2/locales/en-en
- )
-
+++ /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 common_dao_types.h
- * @author Michal Ciepielski (m.ciepielski@samsung.com)
- * @version 1.0
- * @brief This file contains the declaration of common data types for wrtdb
- */
-
-#ifndef WRT_SRC_CONFIGURATION_COMMON_DAO_TYPES_H_
-#define WRT_SRC_CONFIGURATION_COMMON_DAO_TYPES_H_
-
-#include <set>
-#include <string>
-#include <map>
-#include <vector>
-#include <list>
-#include <dpl/optional_typedefs.h>
-#include <memory>
-
-namespace WrtDB {
-namespace Powder {
-
-typedef std::set<DPL::String> StringSet;
-//! Widget description
-struct Description
-{
- //!Content level
- typedef enum
- {
- Level0 = 0,
- Level1,
- Level2,
- Level3,
- Level4,
- Level5,
- LevelUnknown
- } LevelEnum;
- struct LevelEntry
- {
- LevelEnum level; //!< content level
-
- typedef StringSet Context;
-
- //! POWDER context
- //! xa This material appears in an artistic context
- //! xb This material appears in an educational context
- //! xc This material appears in a medical context
- //! xd This material appears in a sports context
- //! xe This material appears in a violent context
- Context context;
- explicit LevelEntry(LevelEnum level = LevelUnknown);
- //! Function checks if context is valid
- //! \param[in] level POWDER content level
- //! \param[in] context POWDER context
- bool isContextValid(LevelEnum level,
- const DPL::OptionalString& context) const;
- };
-
- struct CategoryEntry
- {
- //! Levels entries for POWDER description
- typedef std::vector <LevelEntry> LevelsContainer;
- LevelsContainer levels;
- //! Function checks if context is valid
- //! \param[out] reason set if context invalid
- //! \param[in] level POWDER content level
- //! \param[in] context POWDER context
- bool isCategoryValid(LevelEntry& reason,
- LevelEnum level,
- const DPL::OptionalString& context) const;
- };
-
- //! POWDER Category -> Category entry map for Widget
- //!
- //! nu Nudity
- //! se Sex
- //! vi Violence
- //! la Potentially offensive language
- //! dr Drug use
- //! ga Gambling
- //! ha Hate or harmful activities
- //! ug Use of user-generated content
- typedef std::map<DPL::String, CategoryEntry> CategoryEntries;
-
- CategoryEntries categories;
-
- //! Age rating for widget
- //! If Null not set
- DPL::OptionalInt ageRating;
-};
-} // namespace Powder
-
-namespace ChildProtection {
-
-//! Blacklist with forbidden URLs
-//! It should be stored in WidgetDAO
-typedef std::vector<DPL::String> BlackList;
-
-//! Widget Child protection record
-//! Record should be stored in WingetDAO
-struct Record
-{
- //! Child protection enabled
- bool enabled;
- explicit Record(bool enabled) :
- enabled(enabled)
- {
- }
-};
-
-//! Powder processing
-struct PowderRules
-{
- //! Rule set by parent about forbidden category
- //! Powder category
- //! nu Nudity
- //! se Sex
- //! vi Violence
- //! la Potentially offensive language
- //! dr Drug use
- //! ga Gambling
- //! ha Hate or harmful activities
- //! ug Use of user-generated content
- //! Powder context
- //! xa This material appears in an artistic conteaxt
- //! xb This material appears in an educational context
- //! xc This material appears in a medical context
- //! xd This material appears in a sports context
- //! xe This material appears in a violent context
- struct CategoryRule
- {
- DPL::String category;
- Powder::Description::LevelEnum level;
- DPL::OptionalString context;
- explicit CategoryRule(const DPL::String& category = DPL::String(),
- Powder::Description::LevelEnum level =
- Powder::Description::LevelUnknown,
- const DPL::OptionalString& context = DPL::OptionalString());
- };
-
- struct PowderResult
- {
- //! Reasoning outcome: part of POWDER description used to invalidate
- Powder::Description::LevelEntry invalidDescription;
- //! Reasoning outcome: rule set by parent not full filed by description
- CategoryRule invalidRule;
-
- //! Reasoning outcome: type of invalidity
- enum InvalidReason
- {
- InvalidRule, //!< One of rules was not fulfilled
- InvalidAge, //!< Age is invalid
- AgeRatingNotSet, //!< Age rating for widget is not set
- Valid //!< Description valid
- };
- InvalidReason reason;
- explicit PowderResult(InvalidReason reason = Valid,
- const Powder::Description::LevelEntry& invalidDescription =
- Powder::Description::LevelEntry(),
- const CategoryRule& invalidRule = CategoryRule());
- };
-
- typedef std::pair<bool, PowderResult> ResultPair;
-
- //! Function checks if rule is fulfilled by description
- //! \param[in] rule checked rule
- //! \param[in] description
- //! \retval true rule is valid
- //! \retval false rule is invalid
- ResultPair isRuleValidForDescription(const CategoryRule& rule,
- const Powder::Description& description) const;
- //! Function checks if age limit is fulfilled by description
- //! \param[in] description
- //! \retval true age is valid
- //! \retval false age is invalid
- ResultPair isAgeValidForDescription(
- const Powder::Description& description) const;
-
- //! It is the maximum age rating valid for child
- //! Uniform age is stored in WidgetDAO
- DPL::OptionalInt ageLimit;
-
- //! Set to true if age rating is required
- //! If ageLimit is not set value is ignored
- bool isAgeRatingRequired;
-
- //! Set of rules configured by parent
- //! Rules are stored in WidgetDAO and are uniform for all widgets
- typedef std::vector<CategoryRule> RulesContainer;
- RulesContainer rules;
-
- //! Function check if Widget description is valid for ChildProtection
- //! configuration
- //! \param description widget description
- //! \retval true widget is valid
- //! \retval false widget is invalid
- ResultPair isDescriptionValid(const Powder::Description& description)
- const;
-
- PowderRules() :
- isAgeRatingRequired(false)
- {
- }
-};
-} // namespace ChildProtection
-
-class PluginMetafileData
-{
- public:
- struct Feature
- {
- std::string m_name;
- std::set<std::string> m_deviceCapabilities;
-
- bool operator< (const Feature& obj) const
- {
- return m_name < obj.m_name;
- }
- };
- typedef std::set<Feature> FeatureContainer;
-
- public:
-
- PluginMetafileData()
- {
- }
-
- std::string m_libraryName;
- std::string m_featuresInstallURI;
- std::string m_featuresKeyCN;
- std::string m_featuresRootCN;
- std::string m_featuresRootFingerprint;
-
- FeatureContainer m_featureContainer;
-};
-
-class PluginObjectsDAO
-{
- public:
- typedef std::set<std::string> Objects;
- typedef std::shared_ptr<Objects> ObjectsPtr;
-
- public:
- explicit PluginObjectsDAO() {}
-
- protected:
- ObjectsPtr m_implemented;
- ObjectsPtr m_dependent;
-};
-
-/**
- * @brief Widget id describes web-runtime global widget identifier.
- *
- * Notice that only up to one widget can exist at the same time.
- * DbWidgetHandle can be translated into corresponding WidgetModel by invoking
- * FindWidgetModel routine.
- */
-typedef int DbWidgetHandle;
-
-/**
- * @brief Structure to hold the information of widget's size
- */
-struct DbWidgetSize
-{
- DPL::OptionalInt width;
- DPL::OptionalInt height;
-
- DbWidgetSize(DPL::OptionalInt w = DPL::OptionalInt::Null,
- DPL::OptionalInt h = DPL::OptionalInt::Null) :
- width(w),
- height(h)
- {
- }
-};
-
-inline bool operator ==(const DbWidgetSize &objA, const DbWidgetSize &objB)
-{
- if (!objA.height || !objA.width || !objB.width || !objB.height) {
- return false;
- } else {
- return *objA.height == *objB.height && *objA.width == *objB.width;
- }
-}
-
-/**
- * Widget [G]lobal [U]nique [ID]entifier
- * Orginated from appstore ID
- */
-typedef DPL::OptionalString WidgetGUID;
-
-struct WidgetAccessInfo
-{
- DPL::String strIRI; /* origin iri */
- bool bSubDomains; /* do we want access to subdomains ? */
-
- bool operator ==(const WidgetAccessInfo& info) const
- {
- return info.strIRI == strIRI &&
- info.bSubDomains == bSubDomains;
- }
-};
-
-typedef std::list<WidgetAccessInfo> WidgetAccessInfoList;
-
-typedef std::list<DPL::String> WindowModeList;
-
-/**
- * @brief Widget configuration parameter key
- */
-typedef DPL::String WidgetParamKey;
-
-/**
- * @brief Widget configuration parameter value
- */
-typedef DPL::String WidgetParamValue;
-
-/**
- * @brief A map of widget configuration parameters.
- *
- * Widget configuration parameters are read from database and are stored
- * along with feature that they describe.
- */
-typedef std::multimap<WidgetParamKey, WidgetParamValue> WidgetParamMap;
-
-/**
- * @brief Widget feature host information about possible javascript extensions
- * that widget may use
- *
- * Widget features are declared in configuration file in widget installation
- * package. Each declared special feature is contained in some wrt-plugin that
- * declares to implement it. After widget launch wrt searches for proper plugin
- * libraries and load needed features.
- *
- * Widget features can be required or optional. It is possible to start widget
- * without missing feature. When required feature cannot be loaded widget will
- * not start.
- */
-
-enum {
- INVALID_PLUGIN_HANDLE = -1
-};
-typedef int DbPluginHandle;
-
-struct DbWidgetFeature
-{
- DPL::String name; /// Feature name
- bool required; /// Whether feature is required
- DbPluginHandle pluginId; /// Plugin id that implement this feature
- WidgetParamMap params; /// Widget's params
-
- DbWidgetFeature() :
- required(false),
- pluginId(INVALID_PLUGIN_HANDLE)
- {
- }
-};
-
-inline bool operator < (const DbWidgetFeature &objA,
- const DbWidgetFeature &objB)
-{
- return objA.name.compare(objB.name) < 0;
-}
-
-inline bool operator==(const DbWidgetFeature &featureA,
- const DbWidgetFeature &featureB)
-{
- return featureA.name == featureB.name &&
- featureA.required == featureB.required &&
- featureA.pluginId == featureB.pluginId;
-}
-
-/**
- * @brief Default container for features list
- */
-typedef std::multiset<DbWidgetFeature> DbWidgetFeatureSet;
-
-/**
- * @brief Default container with DbWidgetHandle's
- */
-typedef std::list<DbWidgetHandle> DbWidgetHandleList;
-
-/**
- * @brief Widget specific type
- *
- * Widget type describes belowed in WAC, TIZEN WebApp
- */
-enum AppType
-{
- APP_TYPE_UNKNOWN = 0, // unknown
- APP_TYPE_WAC20, // WAC 2.0
- APP_TYPE_TIZENWEBAPP, // slp webapp
-};
-
-class WidgetType
-{
- public:
- WidgetType()
- :appType(APP_TYPE_UNKNOWN)
- {
- }
- WidgetType(const AppType type)
- :appType(type)
- {
- }
- bool operator== (const AppType& other) const
- {
- return appType == other;
- }
- std::string getApptypeToString()
- {
- switch (appType) {
-#define X(x) case x: return #x;
- X(APP_TYPE_UNKNOWN)
- X(APP_TYPE_WAC20)
- X(APP_TYPE_TIZENWEBAPP)
-#undef X
- default:
- return "UNKNOWN";
- }
- }
-
- AppType appType;
-};
-
-} // namespace WrtDB
-
-struct WidgetSetting
-{
- DPL::String settingName;
- DPL::String settingValue;
-
- bool operator ==(const WidgetSetting& info) const
- {
- return (info.settingName == settingName &&
- info.settingValue == settingValue);
- }
- bool operator !=(const WidgetSetting& info) const
- {
- return (info.settingName != settingName ||
- info.settingValue != settingValue);
- }
-};
-
-typedef std::list<WidgetSetting> WidgetSettings;
-
-/**
- * @brief Widget Application Service
- *
- * Application sercvice describes details of behaviour
- * when widget receives aul bundle data.
- */
-struct WidgetApplicationService
-{
- public:
- DPL::String src; /* start uri */
- DPL::String operation; /* service name */
- DPL::String scheme; /* scheme type*/
- DPL::String mime; /* mime type */
-
- bool operator== (const WidgetApplicationService& other) const
- {
- return src == other.src &&
- operation == other.operation &&
- scheme == other.scheme &&
- mime == other.mime;
- }
-};
-
-typedef std::list<WidgetApplicationService> WidgetApplicationServiceList;
-#endif /* WRT_SRC_CONFIGURATION_COMMON_DAO_TYPES_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.
- */
-/**
- * This file contains the declaration of widget dao class.
- *
- * @file widget_dao_read_only.h
- * @author Yang Jie (jie2.yang@samsung.com)
- * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
- * @author Pawel Sikorski (p.sikorski@samsung.com)
- * @version 1.0
- * @brief This file contains the declaration of widget dao
- */
-
-#ifndef _WRT_SRC_CONFIGURATION_WIDGET_DAO_READ_ONLY_H_
-#define _WRT_SRC_CONFIGURATION_WIDGET_DAO_READ_ONLY_H_
-
-#include <time.h>
-
-#include <list>
-#include <map>
-#include <set>
-#include <string>
-
-#include <dpl/string.h>
-#include <dpl/exception.h>
-#include <dpl/optional_typedefs.h>
-
-#include <dpl/wrt-dao-ro/common_dao_types.h>
-//#include "../wrt-dao-ro/common_dao_types.h"
-
-typedef DPL::OptionalString WidgetGUID;
-
-namespace ConfigParserData {
-
-struct Icon
-{
- Icon(const DPL::String& src) : src(src)
- {
- }
- DPL::String src;
- DPL::OptionalInt width;
- DPL::OptionalInt height;
- bool operator==(const Icon&) const;
- bool operator!=(const Icon&) const;
- bool operator >(const Icon&) const;
- bool operator>=(const Icon&) const;
- bool operator <(const Icon&) const;
- bool operator<=(const Icon&) const;
-};
-} // namespace ConfigParserData
-namespace WrtDB {
-
-typedef std::list<DPL::String> StringList;
-
-struct WidgetLocalizedInfo
-{
- DPL::OptionalString name;
- DPL::OptionalString shortName;
- DPL::OptionalString description;
- DPL::OptionalString license;
- DPL::OptionalString licenseHref;
-};
-
-typedef std::list<DPL::String> LanguageTagList;
-
-class WidgetDAO
-{
- public:
- /**
- * WidgetDAO Exception classes
- */
- class Exception
- {
- public:
- DECLARE_EXCEPTION_TYPE(DPL::Exception, Base)
- DECLARE_EXCEPTION_TYPE(Base, DatabaseError)
- DECLARE_EXCEPTION_TYPE(Base, ReadOnlyProperty)
- DECLARE_EXCEPTION_TYPE(Base, GUIDisNull)
- DECLARE_EXCEPTION_TYPE(Base, UnexpectedEmptyResult)
- DECLARE_EXCEPTION_TYPE(Base, WidgetNotExist)
- DECLARE_EXCEPTION_TYPE(Base, AlreadyRegistered)
- };
-
- protected:
- DbWidgetHandle m_widgetHandle;
-
- public:
- struct WidgetLocalizedIconRow
- {
- int appId;
- int iconId;
- DPL::String widgetLocale;
- };
- typedef std::list<WidgetLocalizedIconRow> WidgetLocalizedIconList;
-
- struct WidgetIconRow
- {
- int iconId;
- int appId;
- DPL::String iconSrc;
- DPL::OptionalInt iconWidth;
- DPL::OptionalInt iconHeight;
- };
- typedef std::list<WidgetIconRow> WidgetIconList;
-
- struct WidgetStartFileRow
- {
- int startFileId;
- int appId;
- DPL::String src;
- };
- typedef std::list<WidgetStartFileRow> WidgetStartFileList;
-
- struct WidgetLocalizedStartFileRow
- {
- int startFileId;
- int appId;
- DPL::String widgetLocale;
- DPL::String type;
- DPL::String encoding;
- };
- typedef std::list<WidgetLocalizedStartFileRow> LocalizedStartFileList;
-
-
- /**
- * This is a constructor.
- *
- * @param[in] widgetHandle application id of widget.
- */
- WidgetDAO(DbWidgetHandle widgetHandle)
- : m_widgetHandle(widgetHandle)
- {}
-
- /**
- * Destructor
- */
- virtual ~WidgetDAO(){}
-
- /**
- * This method returns widget handle(m_widgetHandle).
- *
- * @return widget handle(m_widgetHandle).
- * @exception WRT_CONF_ERR_EMDB_FAILURE - Fail to query DB table.
- * @exception WRT_CONF_ERR_EMDB_NO_RECORD - Can not find matching records in DB table.
- */
- DbWidgetHandle getHandle() const { return m_widgetHandle; }
- DbWidgetHandle getHandle(const WidgetGUID GUID) const;
- static DbWidgetHandle getHandle(const DPL::String pkgName);
-
- /**
- * This method returns the root directory of widget resource.
- *
- * @return path name of root directory.
- * @exception WRT_CONF_ERR_EMDB_FAILURE - Fail to query DB table.
- * @exception WRT_CONF_ERR_EMDB_NO_RECORD - Can not find matching records in
- * DB table.
- */
- DPL::String getPath() const;
- void setPath(const DPL::String &path) const;
-
- /**
- * This method returns the defaultlocale for the widget.
- *
- * @return defaultlocale
- * @exception WRT_CONF_ERR_EMDB_FAILURE - Fail to query DB table.
- * @exception WRT_CONF_ERR_EMDB_NO_RECORD - Can not find matching records in
- * DB table.
- */
- DPL::OptionalString getDefaultlocale() const;
-
- /**
- * This method returns list of localized icons files;
- *
- * @exception WRT_CONF_ERR_EMDB_FAILURE - Fail to query DB table.
- * @exception WRT_CONF_ERR_EMDB_NO_RECORD - Can not find matching records in
- * DB table.
- */
- WidgetLocalizedIconList getLocalizedIconList() const;
-
- /**
- * This method returns list of icons files;
- *
- * @exception WRT_CONF_ERR_EMDB_FAILURE - Fail to query DB table.
- * @exception WRT_CONF_ERR_EMDB_NO_RECORD - Can not find matching records in
- * DB table.
- */
- WidgetIconList getIconList() const;
-
- /**
- * This method returns list of localized start files;
- *
- * @exception WRT_CONF_ERR_EMDB_FAILURE - Fail to query DB table.
- * @exception WRT_CONF_ERR_EMDB_NO_RECORD - Can not find matching records in
- * DB table.
- */
- LocalizedStartFileList getLocalizedStartFileList() const;
- void setLocalizedStartFileList(const LocalizedStartFileList &list) const;
- /**
- * This method returns list of start files;
- *
- * @exception WRT_CONF_ERR_EMDB_FAILURE - Fail to query DB table.
- * @exception WRT_CONF_ERR_EMDB_NO_RECORD - Can not find matching records in
- * DB table.
- */
- WidgetStartFileList getStartFileList() const;
- void setStartFileList(const WidgetStartFileList &list) const;
-
- WidgetLocalizedInfo getLocalizedInfo(const DPL::String& languageTag) const;
- protected:
- static std::map<DbWidgetHandle,WidgetStartFileList> s_startFileMap;
- static std::map<DbWidgetHandle,LocalizedStartFileList> s_localizedStartFileMap;
- static std::map<DbWidgetHandle,DPL::String> s_pathMap;
-};
-
-} // namespace WrtDB
-
-#endif // _WRT_SRC_CONFIGURATION_WIDGET_DAO_READ_ONLY_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.
- */
-/**
- * This file contains the declaration of widget dao class.
- *
- * @file widget_dao_read_only.cpp
- * @author Yang Jie (jie2.yang@samsung.com)
- * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
- * @author Pawel Sikorski (p.sikorski@samsung.com)
- * @version 1.0
- * @brief This file contains the declaration of widget dao
- */
-
-//#include "../mockup_include/dpl/wrt-dao-rw/widget_dao.h"
-#include <dpl/wrt-dao-rw/widget_dao.h>
-
-#include <sstream>
-#include <dpl/foreach.h>
-#include <dpl/log/log.h>
-#include <dpl/sstream.h>
-
-namespace WrtDB {
-
-std::map<DbWidgetHandle,WidgetDAO::WidgetStartFileList> WidgetDAO::s_startFileMap;
-std::map<DbWidgetHandle,WidgetDAO::LocalizedStartFileList> WidgetDAO::s_localizedStartFileMap;
-std::map<DbWidgetHandle,DPL::String> WidgetDAO::s_pathMap;
-
-DbWidgetHandle WidgetDAO::getHandle(const WidgetGUID /* GUID */) const
-{
- LogError("Not impleneted!");
- return 0;
-}
-
-DbWidgetHandle WidgetDAO::getHandle(const DPL::String /* pkgName */)
-{
- LogError("Not implemented!");
- return 0;
-}
-
-DPL::String WidgetDAO::getPath() const
-{
- return s_pathMap[m_widgetHandle];
-}
-
-void WidgetDAO::setPath(const DPL::String &path) const
-{
- s_pathMap[m_widgetHandle] = path;
-}
-
-WidgetLocalizedInfo
- WidgetDAO::getLocalizedInfo(const DPL::String& /* languageTag */)
- const
-{
- LogError("Not implemented!");
- return WidgetLocalizedInfo();
-}
-
-DPL::OptionalString WidgetDAO::getDefaultlocale() const
-{
- LogError("Not implemented!");
- return DPL::OptionalString();
-}
-
-WidgetDAO::WidgetLocalizedIconList WidgetDAO::getLocalizedIconList() const
-{
- LogError("Not implemented!");
- return WidgetLocalizedIconList();
-}
-
-WidgetDAO::WidgetIconList WidgetDAO::getIconList() const
-{
- LogError("Not implemented!");
- return WidgetIconList();
-}
-
-WidgetDAO::LocalizedStartFileList WidgetDAO::getLocalizedStartFileList() const
-{
- return s_localizedStartFileMap[m_widgetHandle];
-}
-
-void WidgetDAO::setLocalizedStartFileList(const LocalizedStartFileList &list) const {
- s_localizedStartFileMap[m_widgetHandle] = list;
-}
-
-WidgetDAO::WidgetStartFileList WidgetDAO::getStartFileList() const
-{
- return s_startFileMap[m_widgetHandle];
-}
-
-void WidgetDAO::setStartFileList(const WidgetStartFileList &list) const
-{
- s_startFileMap[m_widgetHandle] = list;
-}
-
-} // namespace WrtDB
+++ /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.
- */
-/**
- * This file contains the declaration of widget dao class.
- *
- * @file test_suite01.cpp
- * @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
- * @version 1.0
- * @brief
- */
-
-#include <dpl/log/log.h>
-#include <dpl/test/test_runner.h>
-
-//#include "mockup_include/dpl/wrt-dao-rw/widget_dao.h"
-#include <dpl/wrt-dao-rw/widget_dao.h>
-#include <dpl/localization/w3c_file_localization.h>
-
-namespace {
-
-WrtDB::LanguageTagList generateLanguageTags(){
- WrtDB::LanguageTagList tags;
- tags.push_back(L"pl-pl");
- tags.push_back(L"en-en");
- tags.push_back(L"pl-en");
- return tags;
-}
-
-static const WrtDB::LanguageTagList languageTags = generateLanguageTags();
-static const DPL::String widget1Path = L"/opt/share/widget/tests/localization/widget1/";
-static const DPL::String widget2Path = L"/opt/share/widget/tests/localization/widget2/";
-
-} // anonymous namespace
-
-RUNNER_TEST(test01_getFilePathInWidgetPackageFromUrl){
- const int widgetHandle = 1;
- WrtDB::WidgetDAO dao(widgetHandle);
- //dao.setPath(widget1Path);
-
- auto result = W3CFileLocalization::getFilePathInWidgetPackageFromUrl(
- widgetHandle,
- languageTags,
- L"widget://one");
-
- RUNNER_ASSERT(*result == L"/opt/share/widget/tests/localization/widget1/locales/pl-en/one");
-}
-
-RUNNER_TEST(test02_getFilePathInWidgetPackageFromUrl){
- const int widgetHandle = 2;
- WrtDB::WidgetDAO dao(widgetHandle);
- //dao.setPath(widget2Path);
-
- auto result = W3CFileLocalization::getFilePathInWidgetPackageFromUrl(
- widgetHandle,
- languageTags,
- L"widget://one");
-
- RUNNER_ASSERT(*result == L"/opt/share/widget/tests/localization/widget2/locales/pl-en/one");
-}
-
-RUNNER_TEST(test03_getFilePathInWidgetPackageFromUrl){
- const int widgetHandle = 2;
- WrtDB::WidgetDAO dao(widgetHandle);
- //dao.setPath(widget2Path);
-
- auto result = W3CFileLocalization::getFilePathInWidgetPackageFromUrl(
- widgetHandle,
- languageTags,
- L"widget://two");
-
- RUNNER_ASSERT(*result == L"/opt/share/widget/tests/localization/widget2/locales/en-en/two");
-}
-
-RUNNER_TEST(test04_getFilePathInWidgetPackage){
- const int widgetHandle = 1;
- WrtDB::WidgetDAO dao(widgetHandle);
- //dao.setPath(widget1Path);
-
- auto result = W3CFileLocalization::getFilePathInWidgetPackage(
- widgetHandle,
- languageTags,
- L"one");
-
- RUNNER_ASSERT(*result == L"locales/pl-en/one");
-}
-
-RUNNER_TEST(test05_getFilePathInWidgetPackage){
- const int widgetHandle = 2;
- WrtDB::WidgetDAO dao(widgetHandle);
- //dao.setPath(widget2Path);
-
- auto result = W3CFileLocalization::getFilePathInWidgetPackage(
- widgetHandle,
- languageTags,
- L"two");
-
- RUNNER_ASSERT(*result == L"locales/en-en/two");
-}
-
+++ /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 test_crypto_hash.cpp
- * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
- * @version 1.0
- * @brief This file is the implementation file of test crypto hash
- */
-#include <dpl/test_runner.h>
-#include <dpl/crypto_hash.h>
-RUNNER_TEST_GROUP_INIT(DPL)
-
-#define TEST_CRYPTO_HASH(Class, Input, Output) \
- Class crypto; \
- crypto.Append(Input); \
- crypto.Finish(); \
- RUNNER_ASSERT(crypto.ToString() == Output);
-
-RUNNER_TEST(CryptoHash_MD2)
-{
- TEST_CRYPTO_HASH(DPL::Crypto::Hash::MD2, "sample_input_string", "c9f26439c9882cccc98467dbdf07b1fc");
-}
-
-RUNNER_TEST(CryptoHash_MD4)
-{
- TEST_CRYPTO_HASH(DPL::Crypto::Hash::MD4, "sample_input_string", "8cd0720f7ec98c8e5f008afb54054677");
-}
-
-RUNNER_TEST(CryptoHash_MD5)
-{
- TEST_CRYPTO_HASH(DPL::Crypto::Hash::MD5, "sample_input_string", "eb7ae4f28fecbd1fd777d9b7495fc8ec");
-}
-
-RUNNER_TEST(CryptoHash_SHA)
-{
- TEST_CRYPTO_HASH(DPL::Crypto::Hash::SHA, "sample_input_string", "0a5725f3586616a4049730f3ba14c8aeda79ab21");
-}
-
-RUNNER_TEST(CryptoHash_SHA1)
-{
- TEST_CRYPTO_HASH(DPL::Crypto::Hash::SHA1, "sample_input_string", "be0ed9040af0c2b772b2dd0776f6966b5f4d1206");
-}
-
-RUNNER_TEST(CryptoHash_DSS)
-{
- TEST_CRYPTO_HASH(DPL::Crypto::Hash::DSS, "sample_input_string", "be0ed9040af0c2b772b2dd0776f6966b5f4d1206");
-}
-
-RUNNER_TEST(CryptoHash_DSS1)
-{
- TEST_CRYPTO_HASH(DPL::Crypto::Hash::DSS1, "sample_input_string", "be0ed9040af0c2b772b2dd0776f6966b5f4d1206");
-}
-
-RUNNER_TEST(CryptoHash_ECDSA)
-{
- TEST_CRYPTO_HASH(DPL::Crypto::Hash::ECDSA, "sample_input_string", "be0ed9040af0c2b772b2dd0776f6966b5f4d1206");
-}
-
-RUNNER_TEST(CryptoHash_SHA224)
-{
- TEST_CRYPTO_HASH(DPL::Crypto::Hash::SHA224, "sample_input_string", "d4dde2370eb869f6e790133b94d58e45417392b9d899af883a274011");
-}
-
-RUNNER_TEST(CryptoHash_SHA256)
-{
- TEST_CRYPTO_HASH(DPL::Crypto::Hash::SHA256, "sample_input_string", "a470ec7c783ac51f9eb1772132e6bde1a053bbc81650719dd0ac62ecd93caf12");
-}
-
-RUNNER_TEST(CryptoHash_SHA384)
-{
- TEST_CRYPTO_HASH(DPL::Crypto::Hash::SHA384, "sample_input_string", "63d8bfa95c95c6906d1816965431c065278a655c60f786c9b246c1f73ba7ac557007f5064ba54ebd3a1988e6f37baa97");
-}
-
-RUNNER_TEST(CryptoHash_SHA512)
-{
- TEST_CRYPTO_HASH(DPL::Crypto::Hash::SHA512, "sample_input_string", "799317a140741937d9e5d8dbf9d3045d2c220de5ac33b3d5897acf873291ed14379eb15ef406d2284313d40edb0e01affac8efeb01cb47c2042e3e62a4a83d7d");
-}
# generating proper output files
#
-SET(TARGET_NAME "dpl-tests-event")
+SET(TARGET_NAME "wrt-commons-tests-event")
# Set DPL tests sources
SET(DPL_TESTS_EVENT_SOURCES
- ${TESTS_DPL_DIR}/event/main.cpp
- ${TESTS_DPL_DIR}/event/test_controller.cpp
- ${TESTS_DPL_DIR}/event/test_event_support.cpp
- ${TESTS_DPL_DIR}/event/test_ic_delegate.cpp
- ${TESTS_DPL_DIR}/event/test_property.cpp
+ ${TESTS_DIR}/event/main.cpp
+ ${TESTS_DIR}/event/test_controller.cpp
+ ${TESTS_DIR}/event/test_event_support.cpp
+ ${TESTS_DIR}/event/test_ic_delegate.cpp
+ ${TESTS_DIR}/event/test_property.cpp
)
WRT_TEST_ADD_INTERNAL_DEPENDENCIES(${TARGET_NAME} ${TARGET_DPL_EVENT_EFL})
RUNNER_TEST_GROUP_INIT(DPL)
-class IntController
- : public DPL::Event::Controller<DPL::TypeListDecl<int>::Type>
+namespace {
+ unsigned int seed = time(NULL);
+}
+
+class IntController :
+ public DPL::Event::Controller<DPL::TypeListDecl<int>::Type>
{
-private:
+ private:
int m_value;
-protected:
+ protected:
virtual void OnEventReceived(const int &event)
{
m_value = event;
}
-public:
- IntController()
- : m_value(-1)
- {
- }
+ public:
+ IntController() :
+ m_value(-1)
+ {}
int Value() const
{
DECLARE_GENERIC_EVENT_1(DoneSignalEvent, DPL::WaitableEvent *)
-class ThreadController
- : public DPL::Event::Controller<DPL::TypeListDecl<DoneSignalEvent>::Type>
+class ThreadController :
+ public DPL::Event::Controller<DPL::TypeListDecl<DoneSignalEvent>::Type>
{
-private:
+ private:
DPL::Thread *m_value;
-protected:
+ protected:
virtual void OnEventReceived(const DoneSignalEvent &event)
{
m_value = DPL::Thread::GetCurrentThread();
event.GetArg0()->Signal();
}
-public:
- ThreadController()
- : m_value(NULL)
- {
- }
+ public:
+ ThreadController() :
+ m_value(NULL)
+ {}
DPL::Thread *Value() const
{
double c;
};
-class StrangeController
- : public DPL::Event::Controller<DPL::TypeListDecl<char, short, int, long,
- unsigned char, unsigned short, unsigned int, unsigned long,
- float, double, StrangeStruct>::Type>
+class StrangeController :
+ public DPL::Event::Controller<DPL::TypeListDecl<char, short, int, long,
+ unsigned char,
+ unsigned short,
+ unsigned int, unsigned long,
+ float, double,
+ StrangeStruct>::Type>
{
-protected:
- virtual void OnEventReceived(const char &event) { (void)event; }
- virtual void OnEventReceived(const short &event) { (void)event; }
- virtual void OnEventReceived(const int &event) { (void)event; }
- virtual void OnEventReceived(const long &event) { (void)event; }
- virtual void OnEventReceived(const unsigned char &event) { (void)event; }
- virtual void OnEventReceived(const unsigned short &event) { (void)event; }
- virtual void OnEventReceived(const unsigned int &event) { (void)event; }
- virtual void OnEventReceived(const unsigned long &event) { (void)event; }
- virtual void OnEventReceived(const float &event) { (void)event; }
- virtual void OnEventReceived(const double &event) { (void)event; }
- virtual void OnEventReceived(const StrangeStruct &event) { (void)event; }
+ protected:
+ virtual void OnEventReceived(const char &event)
+ {
+ (void)event;
+ }
+ virtual void OnEventReceived(const short &event)
+ {
+ (void)event;
+ }
+ virtual void OnEventReceived(const int &event)
+ {
+ (void)event;
+ }
+ virtual void OnEventReceived(const long &event)
+ {
+ (void)event;
+ }
+ virtual void OnEventReceived(const unsigned char &event)
+ {
+ (void)event;
+ }
+ virtual void OnEventReceived(const unsigned short &event)
+ {
+ (void)event;
+ }
+ virtual void OnEventReceived(const unsigned int &event)
+ {
+ (void)event;
+ }
+ virtual void OnEventReceived(const unsigned long &event)
+ {
+ (void)event;
+ }
+ virtual void OnEventReceived(const float &event)
+ {
+ (void)event;
+ }
+ virtual void OnEventReceived(const double &event)
+ {
+ (void)event;
+ }
+ virtual void OnEventReceived(const StrangeStruct &event)
+ {
+ (void)event;
+ }
};
+/*
+Name: Controller_InitSimple
+Description: tests initialization of simple int controller
+Expected: no exceptions
+*/
RUNNER_TEST(Controller_InitSimple)
{
IntController controller;
RUNNER_ASSERT(controller.Value() == -1);
}
+/*
+Name: Controller_InitStrange
+Description: tests initialization of struct controller
+Expected: no exceptions
+*/
RUNNER_TEST(Controller_InitStrange)
{
StrangeController controller;
controller.Touch();
}
+/*
+Name: Controller_PostEventToThread
+Description: tests post events to other thread
+Expected: thread id gathered in event handling method should match id of created thread
+*/
RUNNER_TEST(Controller_PostEventToThread)
{
ThreadController controller;
RUNNER_ASSERT(controller.Value() == &thread);
}
+/*
+Name: Controller_PostTimedEventToThread
+Description: tests post events to other thread with time delay
+Expected: thread id gathered in event handling method should match id of created thread
+*/
RUNNER_TEST(Controller_PostTimedEventToThread)
{
ThreadController controller;
RUNNER_ASSERT(controller.Value() == &thread);
}
-DECLARE_GENERIC_EVENT_2(TouchInThread, DPL::WaitableEvent *, DPL::Thread **)
-DECLARE_GENERIC_EVENT_2(TouchedControllerSignal, DPL::WaitableEvent *, DPL::Thread **)
+DECLARE_GENERIC_EVENT_2(TouchInThread, DPL::WaitableEvent *, DPL::Thread * *)
+DECLARE_GENERIC_EVENT_2(TouchedControllerSignal,
+ DPL::WaitableEvent *,
+ DPL::Thread * *)
-class TouchInThreadController
- : public DPL::Event::Controller<DPL::TypeListDecl<TouchInThread>::Type>,
- private DPL::Event::Controller<DPL::TypeListDecl<TouchedControllerSignal>::Type>
+class TouchInThreadController :
+ public DPL::Event::Controller<DPL::TypeListDecl<TouchInThread>::Type>,
+ private DPL::Event::Controller<DPL::TypeListDecl<TouchedControllerSignal>::
+ Type>
{
-public:
- typedef DPL::Event::Controller<DPL::TypeListDecl<TouchInThread>::Type> PublicController;
- typedef DPL::Event::Controller<DPL::TypeListDecl<TouchedControllerSignal>::Type> PrivateController;
+ public:
+ typedef DPL::Event::Controller<DPL::TypeListDecl<TouchInThread>::Type>
+ PublicController;
+ typedef DPL::Event::Controller<DPL::TypeListDecl<TouchedControllerSignal>::
+ Type> PrivateController;
virtual void OnEventReceived(const TouchInThread &event)
{
PrivateController::Touch();
// Post signal
- PrivateController::PostEvent(TouchedControllerSignal(event.GetArg0(), event.GetArg1()));
+ PrivateController::PostEvent(TouchedControllerSignal(event.GetArg0(),
+ event.GetArg1()));
}
virtual void OnEventReceived(const TouchedControllerSignal &event)
}
};
+/*
+Name: Controller_TouchInThread
+Description: tests ability to touch (initizilize / set destination thread) in creatd thread
+ other than thread were controlelr object was created
+Expected: thread id gathered in event handling method should match id of created thread
+*/
RUNNER_TEST(Controller_TouchInThread)
{
TouchInThreadController controller;
DPL::WaitableEvent waitHandle;
DPL::Thread *touchedThread = NULL;
- controller.PublicController::PostEvent(TouchInThread(&waitHandle, &touchedThread));
+ controller.PublicController::PostEvent(TouchInThread(&waitHandle,
+ &touchedThread));
DPL::WaitForSingleHandle(waitHandle.GetHandle());
RUNNER_ASSERT(touchedThread == &thread);
}
+/*
+Name: Controller_SynchronizedEvent
+Description: tests ability to post synchronized events to ther thread
+Expected: correct value should be saved when event was handled
+*/
RUNNER_TEST(Controller_SynchronizedEvent)
{
IntController controller;
typedef std::list<ThreadPtr> ThreadList;
DECLARE_GENERIC_EVENT_0(QuitEvent)
-class QuitController
- : public DPL::Event::Controller<DPL::TypeListDecl<QuitEvent>::Type>,
- public DPL::ApplicationExt
+class QuitController :
+ public DPL::Event::Controller<DPL::TypeListDecl<QuitEvent>::Type>,
+ public DPL::ApplicationExt
{
-public:
- explicit QuitController( ) : DPL::ApplicationExt(1, NULL, "test-app") { Touch(); }
-protected:
- virtual void OnEventReceived(const QuitEvent &) { Quit(); }
+ public:
+ explicit QuitController() : DPL::ApplicationExt(1, NULL, "test-app")
+ {
+ Touch();
+ }
+
+ protected:
+ virtual void OnEventReceived(const QuitEvent &)
+ {
+ Quit();
+ }
};
struct TestContext
DECLARE_GENERIC_EVENT_0(StartSendEvent)
DECLARE_GENERIC_EVENT_0(RandomEvent)
-class TestController
- : public DPL::Event::Controller<DPL::TypeListDecl<RandomEvent, StartSendEvent>::Type>
+class TestController :
+ public DPL::Event::Controller<DPL::TypeListDecl<RandomEvent,
+ StartSendEvent>::Type>
{
-public:
- explicit TestController() { Touch(); }
-protected:
+ public:
+ explicit TestController()
+ {
+ Touch();
+ }
+
+ protected:
virtual void OnEventReceived(const RandomEvent &)
{
++testContextPtr->g_ReceivedCounter;
- if(testContextPtr->g_ReceivedCounter == MaxEvents)
- {
- testContextPtr->quitter.DPL::Event::ControllerEventHandler<QuitEvent>::PostEvent(QuitEvent());
+ if (testContextPtr->g_ReceivedCounter == MaxEvents) {
+ testContextPtr->quitter.DPL::Event::ControllerEventHandler<
+ QuitEvent>::PostEvent(QuitEvent());
return;
}
}
virtual void OnEventReceived(const StartSendEvent &)
{
- for (int i=0 ; i<MaxEventsPerController ;++i)
- {
- if(testContextPtr->g_SentCounter > MaxEvents)
- {
+ for (int i = 0; i < MaxEventsPerController; ++i) {
+ if (testContextPtr->g_SentCounter > MaxEvents) {
return;
}
++testContextPtr->g_SentCounter;
- int id = rand() % static_cast<int>(testContextPtr->controllers.size());
- testContextPtr->controllers.at(id)->DPL::Event::ControllerEventHandler<RandomEvent>::PostEvent(RandomEvent());
+ int id = rand_r(&seed) % static_cast<int>(testContextPtr->controllers.size());
+ testContextPtr->controllers.at(id)->DPL::Event::
+ ControllerEventHandler<RandomEvent>::PostEvent(RandomEvent());
}
}
};
+/*
+Name: Controllers_MultipleEvents
+Description: tests controller coooperation.
+ This runs many controllers in many threads. Each controller sends
+ to other randomly chosen controller events.
+Expected: Test is supposed to be ended when all limits of sent event will be reach
+ -> all scheduled event will be sent and received.
+*/
RUNNER_TEST(Controllers_MultipleEvents)
{
- srand ( time(NULL) );
+ srand(time(NULL) );
testContextPtr.reset(new TestContext());
testContextPtr->controllers.reserve(ControllersNumber);
- for (int i = 0; i < ControllersNumber ; ++i)
- {
- if(testContextPtr->controllers.size() % ControllersPerThread ==0)
- {
+ for (int i = 0; i < ControllersNumber; ++i) {
+ if (testContextPtr->controllers.size() % ControllersPerThread == 0) {
ThreadPtr thread = ThreadPtr(new DPL::Thread());
testContextPtr->threads.push_back(thread);
thread->Run();
ControllerPtr controller = ControllerPtr(new TestController());
testContextPtr->controllers.push_back(controller);
- if(testContextPtr->controllers.size() % 2 == 0)
- {
- //This controller is being switched to thread (otherwise it is touched to main thread)
+ if (testContextPtr->controllers.size() % 2 == 0) {
+ //This controller is being switched to thread (otherwise it is
+ // touched to main thread)
ThreadPtr thread = testContextPtr->threads.back();
controller->SwitchToThread(thread.get());
}
- controller->DPL::Event::ControllerEventHandler<StartSendEvent>::PostEvent(StartSendEvent());
+ controller->DPL::Event::ControllerEventHandler<StartSendEvent>::
+ PostEvent(StartSendEvent());
}
testContextPtr->quitter.Exec();
- RUNNER_ASSERT(testContextPtr->g_SentCounter == testContextPtr->g_ReceivedCounter);
+ RUNNER_ASSERT(
+ testContextPtr->g_SentCounter == testContextPtr->g_ReceivedCounter);
testContextPtr.reset();
}
DECLARE_GENERIC_EVENT_0(TestEvent)
-class TestListener: public DPL::Event::EventListener<TestEvent>
+class TestListener : public DPL::Event::EventListener<TestEvent>
{
-public:
+ public:
explicit TestListener() : m_dummyVar(0) { }
- void OnEventReceived(const TestEvent &) { m_dummyVar = 1; }
- int GetDummyVar() const { return m_dummyVar; }
- void ZeroDummyVar() { m_dummyVar = 0; }
+ void OnEventReceived(const TestEvent &)
+ {
+ m_dummyVar = 1;
+ }
+ int GetDummyVar() const
+ {
+ return m_dummyVar;
+ }
+ void ZeroDummyVar()
+ {
+ m_dummyVar = 0;
+ }
-private:
+ private:
int m_dummyVar;
};
-class TestEventSupport
- : public DPL::Event::EventSupport<TestEvent>
+class TestEventSupport :
+ public DPL::Event::EventSupport<TestEvent>
{
-public:
- void TestEmitEvent() { EmitEvent(TestEvent()); }
+ public:
+ void TestEmitEvent()
+ {
+ EmitEvent(TestEvent());
+ }
};
DECLARE_GENERIC_EVENT_0(QuitEvent)
-class QuitController
- : public DPL::Event::Controller<DPL::TypeListDecl<QuitEvent>::Type>,
- public DPL::ApplicationExt
+class QuitController :
+ public DPL::Event::Controller<DPL::TypeListDecl<QuitEvent>::Type>,
+ public DPL::ApplicationExt
{
-public:
- QuitController() : DPL::ApplicationExt(1, NULL, "test-app") { Touch(); }
+ public:
+ QuitController() : DPL::ApplicationExt(1, NULL, "test-app")
+ {
+ Touch();
+ }
-protected:
- virtual void OnEventReceived(const QuitEvent &) { Quit(); }
+ protected:
+ virtual void OnEventReceived(const QuitEvent &)
+ {
+ Quit();
+ }
};
+/*
+Name: EventSupport_DestroyBeforeProcessing
+Description: tests if remoign listener is full successfull
+Expected: dummy var should be affected by explicit call of ZeroDummyVar(),
+ but no by emitting event after removing listener
+*/
RUNNER_TEST(EventSupport_DestroyBeforeProcessing)
{
QuitController quitter;
g_delegateTest = k;
}
-class DelegateTestSupport
- : public DPL::Event::EventSupport<int>
+class DelegateTestSupport :
+ public DPL::Event::EventSupport<int>
{
-public:
+ public:
void Test()
{
EmitEvent(7);
}
};
+/*
+Name: EventSupport_BindDelegate
+Description: tests if event support derived class successfully propagates
+ event to registered listener
+Expected: value of event should be passed to listener
+*/
RUNNER_TEST(EventSupport_BindDelegate)
{
g_delegateTest = 0;
DECLARE_GENERIC_EVENT_1(GetIntEvent, GetIntDlgType)
DECLARE_GENERIC_EVENT_1(GetIntAndStringEvent, GetIntAndStringDlgType)
-class ICTestController
-: public DPL::Event::Controller<DPL::TypeListDecl<GetNothingEvent,
- GetIntEvent,
- GetIntAndStringEvent>::Type>
+class ICTestController :
+ public DPL::Event::Controller<DPL::TypeListDecl<GetNothingEvent,
+ GetIntEvent,
+ GetIntAndStringEvent>::Type>
{
public:
ICTestController() { }
protected:
virtual void OnEventReceived(const GetNothingEvent& event)
{
- event.GetArg0()(); //calling intercontext delegate
+ event.GetArg0() (); //calling intercontext delegate
}
virtual void OnEventReceived(const GetIntEvent& event)
{
- event.GetArg0()(IntVal); //calling intercontext delegate
+ event.GetArg0() (IntVal); //calling intercontext delegate
}
virtual void OnEventReceived(const GetIntAndStringEvent& event)
{
- event.GetArg0()(IntVal, StringVal); //calling intercontext delegate
+ event.GetArg0() (IntVal, StringVal); //calling intercontext delegate
}
};
m_int(-1),
m_int2(-1),
m_string("")
- {
- }
+ {}
void TestEventsPassed()
{
Thread::Quit();
}
-
void Wait()
{
LogDebug("Waiting for thread");
GetNothingEvent getNothingEvent(
makeICDelegate(
&TestContextFreeClass::OnNothing));
- m_controller->DPL::Event::ControllerEventHandler<GetNothingEvent>::PostEvent(
+ m_controller->DPL::Event::ControllerEventHandler<GetNothingEvent>::
+ PostEvent(
getNothingEvent);
GetIntEvent getIntEvent(
makeICDelegate(
&TestContextFreeClass::OnIntReceive));
- m_controller->DPL::Event::ControllerEventHandler<GetIntEvent>::PostEvent(
+ m_controller->DPL::Event::ControllerEventHandler<GetIntEvent>::
+ PostEvent(
getIntEvent);
GetIntAndStringEvent getIntAndStringEvent(
makeICDelegate(
&TestContextFreeClass::OnIntAndStringReceive));
- m_controller->DPL::Event::ControllerEventHandler<GetIntAndStringEvent>::PostEvent(
+ m_controller->DPL::Event::ControllerEventHandler<GetIntAndStringEvent>
+ ::PostEvent(
getIntAndStringEvent);
return Thread::ThreadEntry();
ICTestController* m_controller;
};
+/*
+Name: ICDelegate_0
+Description: checks if delegetes are correctly called
+Expected: delegates should be called from right context
+*/
RUNNER_TEST(ICDelegate_0)
{
DPL::Thread thread;
result.TestEventsPassed();
}
+/*
+Name: ICDelegate_1
+Description: checks if delegetes are correctly called
+Expected: delegates should be called from right context
+*/
RUNNER_TEST(ICDelegate_1)
{
DPL::Thread thread;
class TestContextFree;
class TestRunnerInThread;
-namespace
-{
+namespace {
const int ControllersPerThread = 40;
const int ContextFreePerThread = 180;
const int TestsPerController = 110;
std::list<ICTestControllerPtr> ctrls;
std::list<TestRunnerInThreadPtr> frees_threads;
std::list<ThreadPtr> ctrls_threads;
-
}
class TestContextFree : public DPL::Event::ICDelegateSupport<TestContextFree>
int eventsCount) :
m_controller(controller),
m_eventsCount(eventsCount)
- {
- }
+ {}
void Wait()
{
DPL::WaitForSingleHandle(m_waitable.GetHandle());
}
-
void OnNothing()
{
LogDebug("Got");
makeICDelegate(
&TestContextFree::OnIntAndStringReceive));
LogDebug("posting next event ...");
- m_controller->DPL::Event::ControllerEventHandler<GetIntAndStringEvent>::PostEvent(
+ m_controller->DPL::Event::ControllerEventHandler<
+ GetIntAndStringEvent>::PostEvent(
getIntAndStringEvent);
LogDebug("posting next event done");
} else {
makeICDelegate(
&TestContextFree::OnNothing));
LogDebug("posting next event ...");
- m_controller->DPL::Event::ControllerEventHandler<GetNothingEvent>::PostEvent(
+ m_controller->DPL::Event::ControllerEventHandler<GetNothingEvent>::
+ PostEvent(
getNothingEvent);
LogDebug("posting next event done");
} else {
makeICDelegate(
&TestContextFree::OnIntReceive));
LogDebug("posting next event ...");
- m_controller->DPL::Event::ControllerEventHandler<GetIntEvent>::PostEvent(
+ m_controller->DPL::Event::ControllerEventHandler<GetIntEvent>::
+ PostEvent(
getIntEvent);
LogDebug("posting next event done");
} else {
GetNothingEvent getNothingEvent(
makeICDelegate(
&TestContextFree::OnNothing));
- m_controller->DPL::Event::ControllerEventHandler<GetNothingEvent>::PostEvent(
+ m_controller->DPL::Event::ControllerEventHandler<GetNothingEvent>::
+ PostEvent(
getNothingEvent);
}
GetIntEvent getIntEvent(
makeICDelegate(
&TestContextFree::OnIntReceive));
- m_controller->DPL::Event::ControllerEventHandler<GetIntEvent>::PostEvent(
+ m_controller->DPL::Event::ControllerEventHandler<GetIntEvent>::
+ PostEvent(
getIntEvent);
}
GetIntAndStringEvent getIntAndStringEvent(
makeICDelegate(
&TestContextFree::OnIntAndStringReceive));
- m_controller->DPL::Event::ControllerEventHandler<GetIntAndStringEvent>::PostEvent(
+ m_controller->DPL::Event::ControllerEventHandler<GetIntAndStringEvent>
+ ::PostEvent(
getIntAndStringEvent);
}
LogDebug("Thread starts");
{
DPL::Mutex::ScopedLock lock(&mutex);
- for (int i = 0; i < m_tests; ++i)
- {
+ for (int i = 0; i < m_tests; ++i) {
if (i % TestsPerController == 0) {
if (ctrls.size() % ControllersPerThread == 0) {
ThreadPtr thread(new DPL::Thread());
int m_tests;
};
+/*
+Name: ICDelegate_2
+Description: checks if delegetes are correctly called
+Expected: delegates should be called from right context
+*/
RUNNER_TEST(ICDelegate_2)
{
LogDebug("Creating test threads");
- for (int i = 0; i < TestThreads; ++i)
- {
+ for (int i = 0; i < TestThreads; ++i) {
TestRunnerInThreadPtr ptr(
new TestRunnerInThread(NumberOfEvents, TestsPerThread));
frees_threads.push_back(ptr);
typedef DPL::Event::ICDelegate<> GetNothingDlpType;
DECLARE_GENERIC_EVENT_1(ReuseCountEvent, GetNothingDlpType)
-class ICReuseTestController
-: public DPL::Event::Controller<DPL::TypeListDecl<ReuseCountEvent>::Type>
+class ICReuseTestController :
+ public DPL::Event::Controller<DPL::TypeListDecl<ReuseCountEvent>::Type>
{
public:
- ICReuseTestController() { m_reuseCount = 0; }
+ ICReuseTestController()
+ {
+ m_reuseCount = 0;
+ }
protected:
virtual void OnEventReceived(const ReuseCountEvent& event)
{
- event.GetArg0()(); //calling intercontext delegate
- if(++m_reuseCount < ReuseCount){
+ event.GetArg0() (); //calling intercontext delegate
+ if (++m_reuseCount < ReuseCount) {
LogInfo("[Send] Reuse: " << m_reuseCount);
- DPL::Event::ControllerEventHandler<ReuseCountEvent>::PostEvent(event);
+ DPL::Event::ControllerEventHandler<ReuseCountEvent>::PostEvent(
+ event);
}
}
m_reuseCount(0)
{ }
- void Run() { Thread::Run(); }
- void Quit() { Thread::Quit(); }
- void Wait() { DPL::WaitForSingleHandle(m_waitable.GetHandle()); }
+ void Run()
+ {
+ Thread::Run();
+ }
+ void Quit()
+ {
+ Thread::Quit();
+ }
+ void Wait()
+ {
+ DPL::WaitForSingleHandle(m_waitable.GetHandle());
+ }
protected:
void OnReuseReceive()
{
LogDebug("[Received] : " << ++m_reuseCount);
- if(m_reuseCount == ReuseCount)
+ if (m_reuseCount == ReuseCount) {
m_waitable.Signal();
+ }
}
virtual int ThreadEntry()
makeICDelegate(
&ReuseTestContextFreeClass::OnReuseReceive,
DPL::Event::ICD::Reuse::Yes));
- m_controller->DPL::Event::ControllerEventHandler<ReuseCountEvent>::PostEvent(
+ m_controller->DPL::Event::ControllerEventHandler<ReuseCountEvent>::
+ PostEvent(
reuseEvent);
return Thread::ThreadEntry();
int m_reuseCount;
};
+/*
+Name: ICDelegate_3
+Description: checks if delegetes are correctly called
+Expected: delegates should be called from right context
+*/
RUNNER_TEST(ICDelegate_3)
{
DPL::Thread thread;
return PROPERTY_VALUE_STRING;
}
-void WriteSomething(const std::string &/*value*/, DPL::Event::Model */*model*/);
-void WriteSomething(const std::string &/*value*/, DPL::Event::Model */*model*/)
-{
-}
+void WriteSomething(const std::string & /*value*/, DPL::Event::Model */*model*/);
+void WriteSomething(const std::string & /*value*/, DPL::Event::Model */*model*/)
+{}
-class MyModel
- : public DPL::Event::Model
+class MyModel :
+ public DPL::Event::Model
{
-public:
+ public:
~MyModel() {}
DPL::Event::Property<std::string>
- Caption;
+ Caption;
DPL::Event::Property<std::string>
- Testproperty0;
+ Testproperty0;
DPL::Event::Property<std::string, DPL::Event::PropertyReadOnly>
- Testproperty1;
+ Testproperty1;
DPL::Event::Property<std::string, DPL::Event::PropertyReadWrite>
- Testproperty2;
+ Testproperty2;
DPL::Event::Property<std::string, DPL::Event::PropertyReadWrite,
- DPL::Event::PropertyStorageCached> Testproperty3;
+ DPL::Event::PropertyStorageCached> Testproperty3;
DPL::Event::Property<std::string, DPL::Event::PropertyReadWrite,
- DPL::Event::PropertyStorageDynamic> Testproperty4;
+ DPL::Event::PropertyStorageDynamic> Testproperty4;
DPL::Event::Property<int, DPL::Event::PropertyReadOnly,
- DPL::Event::PropertyStorageDynamicCached> Testproperty5;
-
- MyModel()
- : Caption(this, "Foo caption"),
- Testproperty0(this, "", &ReadSomething),
- Testproperty1(this),
- Testproperty2(this),
- Testproperty3(this),
- Testproperty4(this, "test", &ReadSomething, &WriteSomething),
- Testproperty5(this, &ReadSomething2)
- {
- }
+ DPL::Event::PropertyStorageDynamicCached>
+ Testproperty5;
+
+ MyModel() :
+ Caption(this, "Foo caption"),
+ Testproperty0(this, "", &ReadSomething),
+ Testproperty1(this),
+ Testproperty2(this),
+ Testproperty3(this),
+ Testproperty4(this, "test", &ReadSomething, &WriteSomething),
+ Testproperty5(this, &ReadSomething2)
+ {}
};
std::string g_caption;
g_caption = event.value;
}
+/*
+Name: Model_Test
+Description: tests accessing and changing models properties
+Expected: listener should get changed value
+*/
RUNNER_TEST(Model_Test)
{
MyModel model;
# generating proper output files
#
-SET(TARGET_LOC "dpl-tests-loc")
+SET(TARGET_LOC "wrt-commons-tests-loc")
SET(LOC_TESTS_SOURCES
- ${DPL_TESTS_DIR}/localization/test_localization.cpp
- ${DPL_TESTS_DIR}/localization/test_suite01.cpp
- #${DPL_TESTS_DIR}/localization/mockup_src/widget_dao.cpp
- #${PROJECT_SOURCE_DIR}/modules/localization/src/localization_utils.cpp
- #${PROJECT_SOURCE_DIR}/modules/localization/src/w3c_file_localization.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/test_localization.cpp
+ ${CMAKE_CURRENT_SOURCE_DIR}/test_suite01.cpp
)
-#WRT_INCLUDE_DIRECTORIES(
- #${SYS_EFL_INCLUDE_DIRS}
- #${DPL_TEST_INCLUDE_DIR}
- #${DPL_TESTS_DIR}/localization/mockup_include
- #${PROJECT_SOURCE_DIR}/modules/localization/include
-#)
-
-#LINK_DIRECTORIES(${SYS_EFL_LIBRARY_DIRS})
-
+WRT_TEST_ADD_INTERNAL_DEPENDENCIES(${TARGET_LOC} ${TARGET_WRT_DAO_RW_LIB} ${TARGET_CUSTOM_HANDLER_DAO_RW_LIB})
WRT_TEST_BUILD(${TARGET_LOC} ${LOC_TESTS_SOURCES})
WRT_TEST_INSTALL(${TARGET_LOC})
ADD_SUBDIRECTORY(files)
+
+INSTALL(PROGRAMS "${CMAKE_CURRENT_SOURCE_DIR}/wrt_db_localization_prepare.sh"
+ DESTINATION bin)
--- /dev/null
+INSTALL(FILES
+ ${CMAKE_CURRENT_SOURCE_DIR}/one
+ DESTINATION
+ /opt/share/widget/tests/localization/widget1/res/wgt/locales/pl-en
+ )
+
+INSTALL(FILES
+ ${CMAKE_CURRENT_SOURCE_DIR}/one
+ ${CMAKE_CURRENT_SOURCE_DIR}/two
+ DESTINATION
+ /opt/share/widget/tests/localization/widget2/res/wgt/locales/pl-en
+ )
+
+INSTALL(FILES
+ ${CMAKE_CURRENT_SOURCE_DIR}/two
+ DESTINATION
+ /opt/share/widget/tests/localization/widget2/res/wgt/locales/en-en
+ )
+
--- /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 main.cpp
+ * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of main
+ */
+#include <dpl/test/test_runner.h>
+#include <dpl/log/log.h>
+#include <dpl/wrt-dao-ro/WrtDatabase.h>
+
+int main(int argc, char *argv[])
+{
+
+ int ret = system("/usr/bin/wrt_db_localization_prepare.sh start");
+ if (ret != 0) {
+ LogError("Preparation script has return error: " << ret
+ << ". Quitting");
+ return -1;
+ }
+
+ WrtDB::WrtDatabase::attachToThreadRW();
+ int status = DPL::Test::TestRunnerSingleton::Instance().ExecTestRunner(argc, argv);
+ WrtDB::WrtDatabase::detachFromThread();
+
+ ret = system("/usr/bin/wrt_db_localization_prepare.sh stop");
+ if (ret != 0) {
+ LogError("Preparation script has return error: " << ret
+ << ". Quitting");
+ return -1;
+ }
+ return status;
+}
+
--- /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.
+ */
+/**
+ * This file contains the declaration of widget dao class.
+ *
+ * @file test_suite01.cpp
+ * @author Krzysztof Jackiewicz (k.jackiewicz@samsung.com)
+ * @version 1.0
+ * @brief
+ */
+
+#include <dpl/log/log.h>
+#include <dpl/test/test_runner.h>
+#include <dpl/static_block.h>
+#include <dpl/wrt-dao-ro/widget_dao_read_only.h>
+#include <dpl/localization/w3c_file_localization.h>
+#include <LanguageTagsProvider.h>
+
+namespace {
+
+STATIC_BLOCK
+{
+ WrtDB::LanguageTagList tags;
+ tags.push_back(L"pl-pl");
+ tags.push_back(L"en-en");
+ tags.push_back(L"pl-en");
+ LanguageTagsProviderSingleton::Instance().setLanguageTags(tags);
+}
+
+static const DPL::String widget1Path =
+ L"/opt/share/widget/tests/localization/widget1/";
+static const DPL::String widget2Path =
+ L"/opt/share/widget/tests/localization/widget2/";
+} // anonymous namespace
+
+RUNNER_TEST(test01_getFilePathInWidgetPackageFromUrl){
+ WrtDB::WidgetPkgName name = L"tizenid201";
+ WrtDB::WidgetDAOReadOnly dao(name);
+
+ DPL::Optional<DPL::String> result = W3CFileLocalization::getFilePathInWidgetPackageFromUrl(
+ name,
+ DPL::String(L"widget://one"));
+
+ RUNNER_ASSERT_MSG(!!result, "No result");
+ RUNNER_ASSERT(
+ *result ==
+ L"/opt/share/widget/tests/localization/widget1/res/wgt/locales/pl-en/one");
+}
+
+RUNNER_TEST(test02_getFilePathInWidgetPackageFromUrl){
+ WrtDB::WidgetPkgName name = L"tizenid202";
+ WrtDB::WidgetDAOReadOnly dao(name);
+
+ DPL::Optional<DPL::String> result = W3CFileLocalization::getFilePathInWidgetPackageFromUrl(
+ name,
+ DPL::String(L"widget://one"));
+
+ RUNNER_ASSERT_MSG(!!result, "No result");
+ RUNNER_ASSERT(
+ *result ==
+ L"/opt/share/widget/tests/localization/widget2/res/wgt/locales/pl-en/one");
+}
+
+RUNNER_TEST(test03_getFilePathInWidgetPackageFromUrl){
+ WrtDB::WidgetPkgName name = L"tizenid202";
+ WrtDB::WidgetDAOReadOnly dao(name);
+
+ DPL::Optional<DPL::String> result = W3CFileLocalization::getFilePathInWidgetPackageFromUrl(
+ name,
+ DPL::String(L"widget://two"));
+
+ RUNNER_ASSERT_MSG(!!result, "No result");
+ RUNNER_ASSERT(
+ *result ==
+ L"/opt/share/widget/tests/localization/widget2/res/wgt/locales/en-en/two");
+}
+
+RUNNER_TEST(test04_getFilePathInWidgetPackage){
+ WrtDB::WidgetPkgName name = L"tizenid201";
+ WrtDB::WidgetDAOReadOnly dao(name);
+
+ DPL::Optional<DPL::String> result = W3CFileLocalization::getFilePathInWidgetPackage(
+ name,
+ DPL::String(L"one"));
+
+ RUNNER_ASSERT_MSG(!!result, "No result");
+ RUNNER_ASSERT(*result == L"locales/pl-en/one");
+}
+
+RUNNER_TEST(test05_getFilePathInWidgetPackage){
+ WrtDB::WidgetPkgName name = L"tizenid202";
+ WrtDB::WidgetDAOReadOnly dao(name);
+
+ DPL::Optional<DPL::String> result = W3CFileLocalization::getFilePathInWidgetPackage(
+ name,
+ DPL::String(L"two"));
+
+ RUNNER_ASSERT_MSG(!!result, "No result");
+ RUNNER_ASSERT(*result == L"locales/en-en/two");
+}
+
--- /dev/null
+#!/bin/bash
+
+# Copyright (c) 2013 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.
+#
+
+set -e
+
+trap 'echo "Script failed"; exit 1' ERR
+
+WRT_DB=/opt/dbspace/.wrt.db
+WRT_DB_BCK=/tmp/wrt.db_backup
+WIDGET_INSTALL_PATH=/opt/usr/apps
+
+case $1 in
+ start)
+ echo "start"
+ cp $WRT_DB $WRT_DB_BCK
+ wrt_commons_create_clean_db.sh
+
+ #Widgets
+ INS_ALL_WIDGETEXT="insert into WidgetExtendedInfo(app_id, installed_path)"
+ INS_ALL_WIDGET="insert into WidgetInfo(app_id, tizen_appid)"
+
+ sqlite3 $WRT_DB "${INS_ALL_WIDGET} VALUES(1, 'tizenid201')";
+ sqlite3 $WRT_DB "${INS_ALL_WIDGET} VALUES(2, 'tizenid202')";
+ sqlite3 $WRT_DB "${INS_ALL_WIDGETEXT} VALUES(1, '/opt/share/widget/tests/localization/widget1')";
+ sqlite3 $WRT_DB "${INS_ALL_WIDGETEXT} VALUES(2, '/opt/share/widget/tests/localization/widget2')";
+ exit 0
+ ;;
+ stop)
+ echo "stop";
+ cp $WRT_DB_BCK $WRT_DB
+ exit 0
+ ;;
+ *)
+ echo "nothing to do"
+ exit 1
+ ;;
+esac
--- /dev/null
+# Copyright (c) 2012 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 CMakeLists.txt
+# @author Marcin Kaminski (marcin.ka@samsung.com)
+# @author Karol Pawlowski (k.pawlowski@samsung.com)
+# @version 1.0
+# @brief
+#
+
+SET(LOCALIZATION_TESTS_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+
+PKG_CHECK_MODULES(TEST_PKGS
+ vconf
+ REQUIRED
+ )
+
+WRT_INCLUDE_DIRECTORIES(
+ ${TEST_PKGS_INCLUDE_DIRS}
+ ${PROJECT_SOURCE_DIR}/modules/localization/include
+ )
+
+WRT_LINK_DIRECTORIES(${TEST_PKGS_LIBRARY_DIRS})
+WRT_TARGET_LINK_LIBRARIES(${TEST_PKGS_LIBRARIES})
+
+FILE(GLOB LOCALIZATION_TESTS_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/*testcases.cpp")
+
+SET(TARGET_LOCALIZATION_TEST "wrt-commons-tests-localization")
+WRT_TEST_BUILD(${TARGET_LOCALIZATION_TEST} ${LOCALIZATION_TESTS_SOURCES} tests_miscunit.cpp)
+WRT_TEST_INSTALL(${TARGET_LOCALIZATION_TEST})
+
--- /dev/null
+/*
+ * Copyright (c) 2012 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 Localization_testcases.cpp
+ * @author Marcin Kaminski (marcin.ka@samsung.com)
+ * @version 1.0
+ * @brief This file contains tests for localization related code.
+ */
+
+#include <dpl/log/log.h>
+#include <dpl/test/test_runner.h>
+#include <vconf.h>
+
+#include <LanguageTagsProvider.h>
+
+RUNNER_TEST_GROUP_INIT(LanguageTagsProvider)
+
+RUNNER_TEST(tagsFromSystemLocales)
+{
+ LogInfo("Generating tags from system locales");
+
+ char* currlocals = vconf_get_str(VCONFKEY_LANGSET);
+ LogDebug("Locales fetched from system settings: " << currlocals);
+ RUNNER_ASSERT_MSG(!!currlocals, "NULL locales received from system");
+ int result = vconf_set_str(VCONFKEY_LANGSET, "en_US.UTF-8");
+ LogDebug("Returned vconf set execution status: " << result);
+ RUNNER_ASSERT_MSG(result == 0, "Invalid value returned by vconf_set_str on setting locales");
+
+ /* Ensure that system locales where fetched */
+ LanguageTagsProviderSingleton::Instance().resetLanguageTags();
+ LogDebug("Language tags set based on current system locales");
+
+ LanguageTags ltlist = LanguageTagsProviderSingleton::Instance().getLanguageTags();
+ RUNNER_ASSERT_MSG(!ltlist.empty(), "Empty tag list returned");
+
+ /* Correct list generated from given locales should contain: "en-US", "en" and "" */
+ LanguageTags correct;
+ correct.push_back(L"en-US");
+ correct.push_back(L"en");
+ correct.push_back(L"");
+
+ RUNNER_ASSERT_MSG( correct==ltlist, "Received and expected language tags lists differ");
+
+ /* Restore system locales */
+ result = vconf_set_str(VCONFKEY_LANGSET, currlocals);
+ RUNNER_ASSERT_MSG(result == 0, "Invalid value returned by vconf_set_str on restoring locales");
+ LogDebug("System locales restored");
+}
+
+RUNNER_TEST(tagsFromGivenLocales)
+{
+ LogInfo("Generating tags from given locales");
+
+ const char *locales1 = "it_IT.UTF-8", *locales2="en_GB";
+
+ LogDebug("Using locales with codepage: " << locales1);
+ LanguageTagsProviderSingleton::Instance().setLanguageTagsFromLocales(locales1);
+ LanguageTags ltlist = LanguageTagsProviderSingleton::Instance().getLanguageTags();
+ /* Correct list generated from given locales should contain: "it-IT", "it" and
+ * two default values: "en" and "" */
+ LanguageTags correct;
+ correct.push_back(L"it-IT");
+ correct.push_back(L"it");
+ correct.push_back(L"");
+ RUNNER_ASSERT_MSG(correct==ltlist, "Received and expected language tags lists differ");
+
+ LogDebug("Using locales without codepage: " << locales2);
+ LanguageTagsProviderSingleton::Instance().setLanguageTagsFromLocales(locales2);
+ ltlist = LanguageTagsProviderSingleton::Instance().getLanguageTags();
+ correct.clear();
+ correct.push_back(L"en-GB");
+ correct.push_back(L"en");
+ correct.push_back(L"");
+ RUNNER_ASSERT_MSG(correct==ltlist, "Received and expected language tags lists differ");
+}
+
+RUNNER_TEST(tagsFromNullLocales)
+{
+ LogInfo("Generating tags when NULL locales given");
+
+ LanguageTagsProviderSingleton::Instance().setLanguageTagsFromLocales(NULL);
+ LanguageTags ltlist = LanguageTagsProviderSingleton::Instance().getLanguageTags();
+ /* List with two values "en" and "" should be returned */
+ LanguageTags correct;
+ correct.push_back(L"");
+ RUNNER_ASSERT_MSG(correct==ltlist, "Received and expected language tags lists differ");
+}
+
+
+RUNNER_TEST(tagsFromGivenTagList)
+{
+ LogInfo("Copying given tags list");
+
+ LogDebug("Correct full list (with default values)");
+ LanguageTags correct;
+ correct.push_back(L"de-DE");
+ correct.push_back(L"de");
+ correct.push_back(L"");
+ LanguageTagsProviderSingleton::Instance().setLanguageTags(correct);
+ LanguageTags result = LanguageTagsProviderSingleton::Instance().getLanguageTags();
+ RUNNER_ASSERT_MSG(correct==result, "Received and expected language tags lists differ");
+
+ LogDebug("Tags list without default values)");
+ LanguageTags nondef;
+ nondef.push_back(L"de-DE");
+ nondef.push_back(L"de");
+ LanguageTagsProviderSingleton::Instance().setLanguageTags(correct);
+ result = LanguageTagsProviderSingleton::Instance().getLanguageTags();
+
+ /* Received list should contains elements from input list with default
+ * values added (as "correct" list has) */
+ RUNNER_ASSERT_MSG(!result.empty(), "Empty tags list should never be returned");
+ RUNNER_ASSERT_MSG(nondef!=result, "Received list is same as given incomplete one");
+ RUNNER_ASSERT_MSG(correct==result, "Received and expected language tags lists differ");
+}
+
+RUNNER_TEST(tagsFromEmptyList)
+{
+ LogInfo("Generating tags when empty tag list given");
+
+ LanguageTags input;
+ LanguageTagsProviderSingleton::Instance().setLanguageTags(input);
+ LanguageTags result = LanguageTagsProviderSingleton::Instance().getLanguageTags();
+ RUNNER_ASSERT_MSG(!result.empty(), "Empty tags list should never be returned");
+}
+
+RUNNER_TEST(defaultWidgetLocale)
+{
+ LogInfo("Adding default widget locales to language tags list");
+
+ LanguageTags input;
+ input.push_back(L"de-DE");
+ input.push_back(L"de");
+ input.push_back(L"");
+ LanguageTagsProviderSingleton::Instance().setLanguageTags(input);
+ LanguageTagsProviderSingleton::Instance().addWidgetDefaultLocales(L"it");
+ LanguageTags result = LanguageTagsProviderSingleton::Instance().getLanguageTags();
+ RUNNER_ASSERT_MSG(result.size() == 4, "4 different language tags expected");
+ LanguageTags reference;
+ reference.push_back(L"de-DE");
+ reference.push_back(L"de");
+ reference.push_back(L"it");
+ reference.push_back(L"");
+ RUNNER_ASSERT_MSG(result == reference, "Received and expected language tags lists differ");
+ LanguageTagsProviderSingleton::Instance().addWidgetDefaultLocales(L"it");
+ LanguageTagsProviderSingleton::Instance().addWidgetDefaultLocales(L"de-DE");
+ result = LanguageTagsProviderSingleton::Instance().getLanguageTags();
+ RUNNER_ASSERT_MSG(result == reference, "Adding already included tag should not change tags list");
+}
--- /dev/null
+Miscellaneous test suite
+Unit tests (manifest files, wrt-api). Internal tests for new features in wrt.
+
+Binary file: wrt-tests-misc. Uses our test framework. Allows to use different
+types of output. Text output shows results on console - green passed.
+To run:
+1. Install wrt-extra on target
+2. Run wrt-tests-localization --output=text
+
+Automatic: YES
+Included in Daily Build: NO
+Included in Gerrit Builds: NO
+Number of test cases: 75
\ No newline at end of file
--- /dev/null
+/*
+ * Copyright (c) 2012 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 tests_miscunit.cpp
+ * @author Marcin Kaminski (marcin.ka@samsung.com)
+ * @version 1.0
+ * @brief This is main file for miscellaneous unit tests (tests of different
+ * classes, namespaces and functions).
+ */
+
+#include <dpl/test/test_runner.h>
+#include <dpl/log/log.h>
+
+int main (int argc, char *argv[])
+{
+ LogInfo("Starting miscellaneous unit tests");
+ int status = DPL::Test::TestRunnerSingleton::Instance().ExecTestRunner(argc, argv);
+
+ return status;
+}
--- /dev/null
+# Copyright (c) 2013 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 CMakeLists.txt
+# @author Bartlomiej Grzelewski (b.grzelewski@samsung.com)
+# @version 1.0
+# @brief
+#
+
+SET(TARGET_NAME "wrt-commons-tests-test-runner-child")
+
+# Set DPL tests sources
+SET(DPL_TESTS_UTIL_SOURCES
+ ${TESTS_DIR}/test/main.cpp
+ ${TESTS_DIR}/test/runner_child.cpp
+)
+
+#WRT_TEST_ADD_INTERNAL_DEPENDENCIES(${TARGET_NAME} ${TARGET_DPL_UTILS_EFL})
+WRT_TEST_BUILD(${TARGET_NAME} ${DPL_TESTS_UTIL_SOURCES})
+WRT_TEST_INSTALL(${TARGET_NAME})
--- /dev/null
+/*
+ * Copyright (c) 2013 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 widget_version.cpp
+ * @author Bartlomiej Grzelewski (b.grzelewski@samsung.com)
+ * @version 1.0
+ * @brief Implementation file for test cases for engine internal tests
+ */
+#include <dpl/test/test_runner_child.h>
+#include <unistd.h>
+#include <vector>
+#include <sys/types.h>
+#include <signal.h>
+
+RUNNER_TEST_GROUP_INIT(DPL_TESTS_TEST_CHILD)
+
+RUNNER_TEST(t00_pass)
+{
+ RUNNER_ASSERT_MSG(1, "This test should pass");
+}
+
+RUNNER_CHILD_TEST(t01_pass)
+{
+ RUNNER_ASSERT_MSG(1, "This test should pass");
+}
+
+RUNNER_CHILD_TEST(t02_fail)
+{
+ RUNNER_ASSERT_MSG(0, "This test should fail");
+}
+
+RUNNER_CHILD_TEST(t03_fail_timeout)
+{
+ sleep(20);
+ RUNNER_ASSERT_MSG(1, "This test should fail");
+}
+
+RUNNER_CHILD_TEST(t04_fail)
+{
+ RUNNER_ASSERT_MSG(1, "This test should fail");
+ RUNNER_ASSERT_MSG(1, "This test should fail");
+ RUNNER_ASSERT_MSG(1, "This test should fail");
+ RUNNER_ASSERT_MSG(1, "This test should fail");
+ RUNNER_ASSERT_MSG(0, "This test should fail");
+}
+
+RUNNER_CHILD_TEST(t05_fail_child_died)
+{
+ kill(getpid(), SIGKILL);
+ RUNNER_ASSERT_MSG(1, "This test should fail");
+}
+
+RUNNER_CHILD_TEST(t06_pass_8_second_test)
+{
+ sleep(8);
+ RUNNER_ASSERT_MSG(1, "This test should pass");
+}
+
+RUNNER_CHILD_TEST(t07_fail_unknown_exception)
+{
+ throw("hello");
+}
+
+RUNNER_CHILD_TEST(t08_fail_unknown_exception)
+{
+ throw(1);
+}
+
+RUNNER_CHILD_TEST(t09_fail_you_should_see_text_normal_assert)
+{
+ RUNNER_ASSERT_MSG(0, "Normal assert");
+}
+
+RUNNER_CHILD_TEST(t10_pass)
+{
+ RUNNER_ASSERT_MSG(1, "Normal assert");
+}
+
RUNNER_TEST_GROUP_INIT(DPL)
// test stream class
-class BinaryStream : public DPL::IStream {
+class BinaryStream : public DPL::IStream
+{
public:
virtual void Read(size_t num, void * bytes)
{
{
readPosition = 0;
}
- virtual ~BinaryStream(){};
+ virtual ~BinaryStream(){}
private:
std::vector<unsigned char> data;
static struct VoidDelegate
{
- void operator()(int a)
- {
- called = a;
- }
+ void operator()(int a)
+ {
+ called = a;
+ }
} voidDelegate;
static struct ReturnDelegate
{
- int operator()(int a)
- {
- return a;
- }
+ int operator()(int a)
+ {
+ return a;
+ }
} returnDelegate;
RUNNER_TEST(Caller_function_void)
{
int a = 23;
BinaryStream stream;
- DPL::Serialization::Serialize(stream,a);
+ DPL::Serialization::Serialize(stream, a);
called = 0;
- DPL::Caller::Call(stream,void_func);
+ DPL::Caller::Call(stream, void_func);
RUNNER_ASSERT(called == a);
}
int a = 23;
bool b = true;
BinaryStream stream;
- DPL::Serialization::Serialize(stream,a);
- DPL::Serialization::Serialize(stream,b);
- int result = DPL::Caller::Call(stream,return_func);
+ DPL::Serialization::Serialize(stream, a);
+ DPL::Serialization::Serialize(stream, b);
+ int result = DPL::Caller::Call(stream, return_func);
RUNNER_ASSERT(result == a);
}
int a = 23;
BinaryStream stream;
called = 0;
- DPL::Serialization::Serialize(stream,a);
- DPL::Caller::CallDelegate(stream,voidDelegate);
+ DPL::Serialization::Serialize(stream, a);
+ DPL::Caller::CallDelegate(stream, voidDelegate);
RUNNER_ASSERT(called == a);
}
int a = 23;
BinaryStream stream;
called = 0;
- DPL::Serialization::Serialize(stream,a);
+ DPL::Serialization::Serialize(stream, a);
int result = 0;
- DPL::Caller::CallDelegate(stream,returnDelegate,result);
+ DPL::Caller::CallDelegate(stream, returnDelegate, result);
RUNNER_ASSERT(result == a);
}
--- /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 test_crypto_hash.cpp
+ * @author Przemyslaw Dobrowolski (p.dobrowolsk@samsung.com)
+ * @version 1.0
+ * @brief This file is the implementation file of test crypto hash
+ */
+#include <dpl/test_runner.h>
+#include <dpl/crypto_hash.h>
+RUNNER_TEST_GROUP_INIT(DPL)
+
+#define TEST_CRYPTO_HASH(Class, Input, Output) \
+ Class crypto; \
+ crypto.Append(Input); \
+ crypto.Finish(); \
+ RUNNER_ASSERT(crypto.ToString() == Output);
+
+RUNNER_TEST(CryptoHash_MD2)
+{
+ TEST_CRYPTO_HASH(DPL::Crypto::Hash::MD2,
+ "sample_input_string",
+ "c9f26439c9882cccc98467dbdf07b1fc");
+}
+
+RUNNER_TEST(CryptoHash_MD4)
+{
+ TEST_CRYPTO_HASH(DPL::Crypto::Hash::MD4,
+ "sample_input_string",
+ "8cd0720f7ec98c8e5f008afb54054677");
+}
+
+RUNNER_TEST(CryptoHash_MD5)
+{
+ TEST_CRYPTO_HASH(DPL::Crypto::Hash::MD5,
+ "sample_input_string",
+ "eb7ae4f28fecbd1fd777d9b7495fc8ec");
+}
+
+RUNNER_TEST(CryptoHash_SHA)
+{
+ TEST_CRYPTO_HASH(DPL::Crypto::Hash::SHA,
+ "sample_input_string",
+ "0a5725f3586616a4049730f3ba14c8aeda79ab21");
+}
+
+RUNNER_TEST(CryptoHash_SHA1)
+{
+ TEST_CRYPTO_HASH(DPL::Crypto::Hash::SHA1,
+ "sample_input_string",
+ "be0ed9040af0c2b772b2dd0776f6966b5f4d1206");
+}
+
+RUNNER_TEST(CryptoHash_DSS)
+{
+ TEST_CRYPTO_HASH(DPL::Crypto::Hash::DSS,
+ "sample_input_string",
+ "be0ed9040af0c2b772b2dd0776f6966b5f4d1206");
+}
+
+RUNNER_TEST(CryptoHash_DSS1)
+{
+ TEST_CRYPTO_HASH(DPL::Crypto::Hash::DSS1,
+ "sample_input_string",
+ "be0ed9040af0c2b772b2dd0776f6966b5f4d1206");
+}
+
+RUNNER_TEST(CryptoHash_ECDSA)
+{
+ TEST_CRYPTO_HASH(DPL::Crypto::Hash::ECDSA,
+ "sample_input_string",
+ "be0ed9040af0c2b772b2dd0776f6966b5f4d1206");
+}
+
+RUNNER_TEST(CryptoHash_SHA224)
+{
+ TEST_CRYPTO_HASH(DPL::Crypto::Hash::SHA224,
+ "sample_input_string",
+ "d4dde2370eb869f6e790133b94d58e45417392b9d899af883a274011");
+}
+
+RUNNER_TEST(CryptoHash_SHA256)
+{
+ TEST_CRYPTO_HASH(
+ DPL::Crypto::Hash::SHA256,
+ "sample_input_string",
+ "a470ec7c783ac51f9eb1772132e6bde1a053bbc81650719dd0ac62ecd93caf12");
+}
+
+RUNNER_TEST(CryptoHash_SHA384)
+{
+ TEST_CRYPTO_HASH(
+ DPL::Crypto::Hash::SHA384,
+ "sample_input_string",
+ "63d8bfa95c95c6906d1816965431c065278a655c60f786c9b246c1f73ba7ac557007f5064ba54ebd3a1988e6f37baa97");
+}
+
+RUNNER_TEST(CryptoHash_SHA512)
+{
+ TEST_CRYPTO_HASH(
+ DPL::Crypto::Hash::SHA512,
+ "sample_input_string",
+ "799317a140741937d9e5d8dbf9d3045d2c220de5ac33b3d5897acf873291ed14379eb15ef406d2284313d40edb0e01affac8efeb01cb47c2042e3e62a4a83d7d");
+}
DECLARE_GENERIC_EVENT_0(QuitEvent)
-class QuitController
- : public DPL::Controller<DPL::TypeListDecl<QuitEvent>::Type>,
- public DPL::ApplicationExt
+class QuitController :
+ public DPL::Controller<DPL::TypeListDecl<QuitEvent>::Type>,
+ public DPL::ApplicationExt
{
-public:
- QuitController() : DPL::ApplicationExt(1, NULL, "test-app") { Touch(); }
+ public:
+ QuitController() : DPL::ApplicationExt(1, NULL, "test-app")
+ {
+ Touch();
+ }
-protected:
- virtual void OnEventReceived(const QuitEvent &) { Quit(); }
+ protected:
+ virtual void OnEventReceived(const QuitEvent &)
+ {
+ Quit();
+ }
};
RUNNER_TEST_GROUP_INIT(DPL)
-class CopyThread
- : public DPL::Thread
+class CopyThread :
+ public DPL::Thread
{
-private:
+ private:
bool m_success;
DPL::AbstractWaitableInput *m_input;
DPL::AbstractWaitableOutput *m_output;
std::size_t m_dataSize;
-public:
+ public:
CopyThread(DPL::AbstractWaitableInput *input,
DPL::AbstractWaitableOutput *output,
- std::size_t dataSize)
- : m_success(true),
- m_input(input),
- m_output(output),
- m_dataSize(dataSize)
+ std::size_t dataSize) :
+ m_success(true),
+ m_input(input),
+ m_output(output),
+ m_dataSize(dataSize)
{
LogInfo("Thread created");
}
-protected:
+ protected:
virtual int ThreadEntry()
{
LogInfo("Entering copy thread");
{
DPL::Copy(m_input, m_output, m_dataSize);
}
- Catch (DPL::CopyFailed)
+ Catch(DPL::CopyFailed)
{
m_success = false;
char *buffer = new char[queue.Size()];
queue.Flatten(buffer, queue.Size());
std::string result = std::string(buffer, buffer + queue.Size());
- delete [] buffer;
+ delete[] buffer;
return result;
}
DPL::AbstractWaitableOutputAdapter dataAdapterD(&dataD);
const std::string testData =
- "Lorem ipsum dolor sit amet, consectetur adipiscing elit."
- "Cras elementum venenatis velit, sit amet vehicula odio gravida a."
- "Curabitur id nibh id ante adipiscing sollicitudin."
- "Maecenas in tellus vel augue vehicula pharetra hendrerit cursus est."
- ""
- "Ut malesuada quam porttitor dui euismod lacinia."
- "Phasellus quis lectus sed lectus dictum tincidunt et vitae leo."
- "Fusce id est massa, condimentum bibendum urna."
- "Donec venenatis quam eget sapien vulputate egestas."
- "Maecenas scelerisque lorem a neque molestie a varius erat condimentum."
- "Maecenas varius hendrerit ligula, sed iaculis justo pretium id."
- "Nunc sit amet nisl vitae justo tristique suscipit id eget tortor."
- ""
- "Pellentesque sollicitudin nulla at metus dapibus tincidunt."
- "Integer consequat justo eget dui imperdiet iaculis."
- "Sed vestibulum ipsum vitae libero accumsan non molestie metus adipiscing."
- ""
- "Vivamus quis dui enim, in blandit urna."
- "In imperdiet lacus at orci elementum a scelerisque dui blandit."
- "Donec vulputate enim metus, eget convallis ante."
- "Etiam mollis enim eget eros pulvinar nec sagittis justo fermentum."
- ""
- "Vestibulum sed nunc eu leo lobortis ultrices."
- "Nullam placerat nulla et est blandit nec interdum nunc pulvinar."
- "Vivamus a lectus eget dui fermentum hendrerit.";
+ "Lorem ipsum dolor sit amet, consectetur adipiscing elit."
+ "Cras elementum venenatis velit, sit amet vehicula odio gravida a."
+ "Curabitur id nibh id ante adipiscing sollicitudin."
+ "Maecenas in tellus vel augue vehicula pharetra hendrerit cursus est."
+ ""
+ "Ut malesuada quam porttitor dui euismod lacinia."
+ "Phasellus quis lectus sed lectus dictum tincidunt et vitae leo."
+ "Fusce id est massa, condimentum bibendum urna."
+ "Donec venenatis quam eget sapien vulputate egestas."
+ "Maecenas scelerisque lorem a neque molestie a varius erat condimentum."
+ "Maecenas varius hendrerit ligula, sed iaculis justo pretium id."
+ "Nunc sit amet nisl vitae justo tristique suscipit id eget tortor."
+ ""
+ "Pellentesque sollicitudin nulla at metus dapibus tincidunt."
+ "Integer consequat justo eget dui imperdiet iaculis."
+ "Sed vestibulum ipsum vitae libero accumsan non molestie metus adipiscing."
+ ""
+ "Vivamus quis dui enim, in blandit urna."
+ "In imperdiet lacus at orci elementum a scelerisque dui blandit."
+ "Donec vulputate enim metus, eget convallis ante."
+ "Etiam mollis enim eget eros pulvinar nec sagittis justo fermentum."
+ ""
+ "Vestibulum sed nunc eu leo lobortis ultrices."
+ "Nullam placerat nulla et est blandit nec interdum nunc pulvinar."
+ "Vivamus a lectus eget dui fermentum hendrerit.";
QuitController quitter;
quitter.PostTimedEvent(QuitEvent(), 1.0);
* 30 seconds unexpected timeout for waitable events
* We don't want to block tests
*/
-const size_t EXPECTED_WAITABLE_TIMEOUT = 5*1000;
-const size_t UNEXPECTED_WAITABLE_TIMEOUT = 30*1000;
+const size_t EXPECTED_WAITABLE_TIMEOUT = 5 * 1000;
+const size_t UNEXPECTED_WAITABLE_TIMEOUT = 30 * 1000;
bool g_enumTestCorrect = false;
bool g_enumTestIncorrect = false;
DPL::WaitableHandleIndexList list = DPL::WaitForSingleHandle(
event.GetHandle(),
expectedTimeout ?
- EXPECTED_WAITABLE_TIMEOUT : UNEXPECTED_WAITABLE_TIMEOUT);
+ EXPECTED_WAITABLE_TIMEOUT : UNEXPECTED_WAITABLE_TIMEOUT);
if (list.size() == 0) {
LogDebug("...timeout.");
- }
- else {
+ } else {
LogDebug("...signaled.");
event.Reset();
}
template <typename SharedType>
ListeningController<SharedType>::ListeningController(
- DPL::WaitableEvent* waitable) :
+ DPL::WaitableEvent* waitable) :
m_waitable(waitable)
{
Touch();
m_so = SharedObjectFactory<SharedType>::Create(SHM_KEY, SEM_NAME);
OnEvent(event);
m_waitable->Signal();
- }
- else if (event == DESTROY_EVENT) {
+ } else if (event == DESTROY_EVENT) {
LogDebug("Destroying shared object");
OnEvent(event);
LogDebug("4");
m_waitable->Signal();
LogDebug("5");
- }
- else {
+ } else {
OnEvent(event);
}
}
protected:
explicit TestSharedObject4(const std::string& semaphore) :
SharedObject<SharedTypeList>(semaphore)
- {
- }
+ {}
private:
void Init()
}
friend class SharedObjectFactory<TestSharedObject4>;
};
-
-
-
} // anonymus namespace
//////////////////////////////////////////////
str.Embedded<3, TestTypeList::Element<3>::Type>::value[1] = 20;
RUNNER_ASSERT(
- (str.Embedded<0, TestTypeList::Element<0>::Type>::value) == 4);
+ (str.Embedded<0, TestTypeList::Element<0>::Type>::value) == 4);
RUNNER_ASSERT(
- (str.Embedded<1, TestTypeList::Element<1>::Type>::value) == 5);
+ (str.Embedded<1, TestTypeList::Element<1>::Type>::value) == 5);
RUNNER_ASSERT(
- (str.Embedded<2, TestTypeList::Element<2>::Type>::value) == 'd');
+ (str.Embedded<2, TestTypeList::Element<2>::Type>::value) == 'd');
RUNNER_ASSERT(
- (str.Embedded<3, TestTypeList::Element<3>::Type>::value[0]) == 1);
+ (str.Embedded<3, TestTypeList::Element<3>::Type>::value[0]) == 1);
RUNNER_ASSERT(
- (str.Embedded<3, TestTypeList::Element<3>::Type>::value[1]) == 20);
+ (str.Embedded<3, TestTypeList::Element<3>::Type>::value[1]) == 20);
}
//////////////////////////////////////////////
Try {
shm.Reset(SharedMemory::Create<SharedStruct>(SHM_KEY, false));
}
- Catch (SharedMemory::Exception::NotFound) {
+ Catch(SharedMemory::Exception::NotFound) {
shm.Reset(SharedMemory::Create<SharedStruct>(SHM_KEY, true, true));
}
Try {
shm2.Reset(SharedMemory::Create<SharedStruct>(SHM_KEY, false));
}
- Catch (SharedMemory::Exception::NotFound) {
+ Catch(SharedMemory::Exception::NotFound) {
shm2.Reset(SharedMemory::Create<SharedStruct>(SHM_KEY, true, true));
}
typedef SharedObject<SharedTypeList> MySharedObj;
MySharedObj::Ptr so =
- SharedObjectFactory<MySharedObj>::Create(SHM_KEY, SEM_NAME);
+ SharedObjectFactory<MySharedObj>::Create(SHM_KEY, SEM_NAME);
RUNNER_ASSERT((so->GetProperty<0, size_t>()) == 0);
- so->SetProperty<0,size_t>(4);
+ so->SetProperty<0, size_t>(4);
RUNNER_ASSERT((so->GetProperty<0, size_t>()) == 4);
}
RemoveIpcs(); // we need non existing shm
std::shared_ptr<InitTestSharedObject> sho =
- SharedObjectFactory<InitTestSharedObject>::Create(
- SHM_KEY, SEM_NAME);
- RUNNER_ASSERT((sho->GetProperty<0,int>()) == 1);
- RUNNER_ASSERT((sho->GetProperty<1,int>()) == 2);
- RUNNER_ASSERT((sho->GetProperty<2,char>()) == 'c');
+ SharedObjectFactory<InitTestSharedObject>::Create(
+ SHM_KEY, SEM_NAME);
+ RUNNER_ASSERT((sho->GetProperty<0, int>()) == 1);
+ RUNNER_ASSERT((sho->GetProperty<1, int>()) == 2);
+ RUNNER_ASSERT((sho->GetProperty<2, char>()) == 'c');
}
//////////////////////////////////////////////
explicit VersionTestSO1(const std::string& semaphore) :
TestSharedObject(semaphore) {}
- virtual SizeType GetVersion() const { return 1; } // from SharedObject
+ virtual SizeType GetVersion() const
+ {
+ return 1;
+ } // from SharedObject
private:
friend class SharedObjectFactory<VersionTestSO1>;
explicit VersionTestSO2(const std::string& semaphore) :
TestSharedObject(semaphore) {}
- virtual SizeType GetVersion() const { return 2; } // from SharedObject
+ virtual SizeType GetVersion() const
+ {
+ return 2;
+ } // from SharedObject
private:
friend class SharedObjectFactory<VersionTestSO2>;
RemoveIpcs(); // we need non existing shm
std::shared_ptr<VersionTestSO1> sho =
- SharedObjectFactory<VersionTestSO1>::Create(SHM_KEY, SEM_NAME);
+ SharedObjectFactory<VersionTestSO1>::Create(SHM_KEY, SEM_NAME);
Try {
std::shared_ptr<VersionTestSO2> sho2 =
- SharedObjectFactory<VersionTestSO2>::Create(SHM_KEY, SEM_NAME);
+ SharedObjectFactory<VersionTestSO2>::Create(SHM_KEY, SEM_NAME);
RUNNER_ASSERT_MSG(false, "Invalid shm version has been accepted");
}
TestSharedObject(semaphore) {}
// from SharedObject
- virtual MagicType GetMagicNumber() const { return 661; }
+ virtual MagicType GetMagicNumber() const
+ {
+ return 661;
+ }
private:
friend class SharedObjectFactory<MagicTestSO1>;
TestSharedObject(semaphore) {}
// from SharedObject
- virtual MagicType GetMagicNumber() const { return 662; }
+ virtual MagicType GetMagicNumber() const
+ {
+ return 662;
+ }
private:
friend class SharedObjectFactory<MagicTestSO2>;
RemoveIpcs(); // we need non existing shm
std::shared_ptr<MagicTestSO1> sho =
- SharedObjectFactory<MagicTestSO1>::Create(SHM_KEY, SEM_NAME);
+ SharedObjectFactory<MagicTestSO1>::Create(SHM_KEY, SEM_NAME);
Try {
std::shared_ptr<MagicTestSO2> sho2 =
- SharedObjectFactory<MagicTestSO2>::Create(SHM_KEY, SEM_NAME);
+ SharedObjectFactory<MagicTestSO2>::Create(SHM_KEY, SEM_NAME);
RUNNER_ASSERT_MSG(false, "Invalid shm magic number has been accepted");
}
class EnumTestSO1 : public TestSharedObject
{
public:
- void SetWaitable(DPL::WaitableEvent* waitable) { m_waitable = waitable; }
+ void SetWaitable(DPL::WaitableEvent* waitable)
+ {
+ m_waitable = waitable;
+ }
protected:
explicit EnumTestSO1(const std::string& semaphore) :
- TestSharedObject(semaphore) {}
+ TestSharedObject(semaphore),
+ m_waitable(NULL)
+ {}
+
virtual void PropertyChanged(size_t propertyEnum);
void EnumTestSO1::PropertyChanged(size_t propertyEnum)
{
- if (propertyEnum == 1)
- {
+ if (propertyEnum == 1) {
LogDebug("Property enum " << propertyEnum << " correctly set");
g_enumTestCorrect = true;
}
- if (propertyEnum == 4)
- {
+ if (propertyEnum == 4) {
// This is bad. We only have 4 types
LogError("Property enum " << propertyEnum << " should be skipped");
g_enumTestIncorrect = true;
// create writing shared object
std::shared_ptr<EnumTestSO2> sho2 =
- SharedObjectFactory<EnumTestSO2>::Create(SHM_KEY, SEM_NAME);
+ SharedObjectFactory<EnumTestSO2>::Create(SHM_KEY, SEM_NAME);
DPL::WaitableHandleIndexList list;
// write property and wait for confirmation
{
ScopedFlaggedLock lock(*this);
- int value = PropertyRef<0,int>();
+ int value = PropertyRef<0, int>();
DPL::Thread::MicroSleep(100);
- SetPropertyInternal<0>(value+1);
+ SetPropertyInternal<0>(value + 1);
}
class ShmController : public ListeningController<MultiThreadSO>
if (event == INIT_EVENT) {
m_so = SharedObjectFactory<MultiThreadSO>::Create(SHM_KEY, SEM_NAME);
PostEvent(2);
- }
- else if (event == DESTROY_EVENT) {
+ } else if (event == DESTROY_EVENT) {
LogDebug("Destroying shared object");
// deregister, destroy ad notify main thread
m_so.Reset();
m_waitable->Signal();
- }
- else if (event == 2){
+ } else if (event == 2) {
m_so->TestAndSetProperty();
m_counter++;
if (m_counter >= TEST_AND_SET_REPEATS) {
ShmController* controller[MAX_THREADS];
DPL::WaitableEvent finalEvent[MAX_THREADS];
- for (size_t i=0;i<MAX_THREADS;++i) {
+ for (size_t i = 0; i < MAX_THREADS; ++i) {
controller[i] = new ShmController(&finalEvent[i]);
}
- for (size_t i=0;i<MAX_THREADS;++i) {
+ for (size_t i = 0; i < MAX_THREADS; ++i) {
Wait(finalEvent[i]);
}
- for (size_t i=0;i<MAX_THREADS;++i) {
+ for (size_t i = 0; i < MAX_THREADS; ++i) {
delete controller[i];
controller[i] = NULL;
}
- int value = sho->GetProperty<0,int>();
- LogDebug("Final value is " << value << ", expected " <<
- MAX_THREADS * TEST_AND_SET_REPEATS);
- RUNNER_ASSERT(value == MAX_THREADS * TEST_AND_SET_REPEATS);
+ int value = sho->GetProperty<0, int>();
+ LogDebug("Final value is " << value << ", expected " <<
+ MAX_THREADS * TEST_AND_SET_REPEATS);
+ RUNNER_ASSERT(value == MAX_THREADS * TEST_AND_SET_REPEATS);
}
//////////////////////////////////////////////
-class MyModel10: public DPL::Model
+class MyModel10 : public DPL::Model
{
public:
- explicit MyModel10(const TestSharedObject4Ptr& shared_object)
- : DPL::Model(), boolValue(this, shared_object) {}
+ explicit MyModel10(const TestSharedObject4Ptr& shared_object) :
+ DPL::Model(), boolValue(this, shared_object) {}
SharedProperty<bool, TestSharedObject4::BOOLEAN, TestSharedObject4>
- boolValue;
+ boolValue;
};
/*
* Listening controller
*/
-class ShmController3: public ListeningController<TestSharedObject4>
+class ShmController3 : public ListeningController<TestSharedObject4>
{
public:
explicit ShmController3(DPL::WaitableEvent* event) :
if (event == INIT_EVENT) {
m_model.Reset(new MyModel10(m_so));
m_model->boolValue.AddListener(
- DPL::FastDelegate<void (const DPL::PropertyEvent<bool>&)>(
- this,
- &ShmController3::OnValueChanged));
+ DPL::FastDelegate<void (const DPL::PropertyEvent<bool>&)>(
+ this,
+ &ShmController3::OnValueChanged));
} else if (event == DESTROY_EVENT) {
m_model->boolValue.RemoveListener(
- DPL::FastDelegate<void (const DPL::PropertyEvent<bool>&)>(
- this,
- &ShmController3::OnValueChanged));
+ DPL::FastDelegate<void (const DPL::PropertyEvent<bool>&)>(
+ this,
+ &ShmController3::OnValueChanged));
m_model.Reset();
}
}
//////////////////////////////////////////////
-class MyModel2: public DPL::Model
+class MyModel2 : public DPL::Model
{
public:
explicit MyModel2(const TestSharedObjectPtr& shared_object) :
m_model1.Reset(new MyModel2(m_so));
m_model2.Reset(new MyModel2(m_so2));
m_model1->counter.AddListener(
- DPL::FastDelegate<void (const DPL::PropertyEvent<int>&)>(
- this,
- &SPController::OnValueChanged1));
+ DPL::FastDelegate<void (const DPL::PropertyEvent<int>&)>(
+ this,
+ &SPController::OnValueChanged1));
m_model2->counter.AddListener(
- DPL::FastDelegate<void (const DPL::PropertyEvent<int>&)>(
- this,
- &SPController::OnValueChanged2));
+ DPL::FastDelegate<void (const DPL::PropertyEvent<int>&)>(
+ this,
+ &SPController::OnValueChanged2));
m_model1->counter.Set(1);
- }
- else if (event == DESTROY_EVENT) {
+ } else if (event == DESTROY_EVENT) {
m_model1->counter.RemoveListener(
- DPL::FastDelegate<void (const DPL::PropertyEvent<int>&)>(
- this,
- &SPController::OnValueChanged1));
+ DPL::FastDelegate<void (const DPL::PropertyEvent<int>&)>(
+ this,
+ &SPController::OnValueChanged1));
m_model2->counter.RemoveListener(
- DPL::FastDelegate<void (const DPL::PropertyEvent<int>&)>(
- this,
- &SPController::OnValueChanged2));
+ DPL::FastDelegate<void (const DPL::PropertyEvent<int>&)>(
+ this,
+ &SPController::OnValueChanged2));
m_model1.Reset();
m_model2.Reset();
LogDebug("[1] Value changed to " << event.value);
m_repeats++;
- m_model1->counter.Set(event.value+1);
+ m_model1->counter.Set(event.value + 1);
}
void SPController::OnValueChanged2(const DPL::PropertyEvent<int>& event)
LogDebug("[2] Value changed to " << event.value);
m_repeats++;
- m_model2->counter.Set(event.value+1);
+ m_model2->counter.Set(event.value + 1);
}
RUNNER_TEST(SharedMemory_060_SingleProcess)
// wait for destruction
Wait(waitable);
- int value = sho->GetProperty<0,int>();
+ int value = sho->GetProperty<0, int>();
LogDebug("final value: " << value);
//////////////////////////////////////////////
-class ListenerTestController: public ListeningController<TestSharedObject>,
- public ISharedObjectListener<0,int>,
- public ISharedObjectListener<1,int>,
- public ISharedObjectListener<2,char>,
- public ISharedObjectListener<3,int[64]>
+class ListenerTestController : public ListeningController<TestSharedObject>,
+ public ISharedObjectListener<0, int>,
+ public ISharedObjectListener<1, int>,
+ public ISharedObjectListener<2, char>,
+ public ISharedObjectListener<3, int[64]>
{
public:
explicit ListenerTestController(DPL::WaitableEvent* event) :
const char& value,
const void* info = NULL);
virtual void ValueChanged(size_t propertyEnum,
- const int(& value)[64],
+ const int(&value)[64],
const void* info = NULL);
};
{
if (event == INIT_EVENT) {
// add self as a listener to shared object
- m_so->AddListener<0,int>(this);
- m_so->AddListener<1,int>(this);
- m_so->AddListener<2,char>(this);
- m_so->AddListener<3,int[64]>(this);
- }
- else if (event == DESTROY_EVENT) {
+ m_so->AddListener<0, int>(this);
+ m_so->AddListener<1, int>(this);
+ m_so->AddListener<2, char>(this);
+ m_so->AddListener<3, int[64]>(this);
+ } else if (event == DESTROY_EVENT) {
// remove self from listener list
- m_so->RemoveListener<0,int>(this);
- m_so->RemoveListener<1,int>(this);
- m_so->RemoveListener<2,char>(this);
- m_so->RemoveListener<3,int[64]>(this);
+ m_so->RemoveListener<0, int>(this);
+ m_so->RemoveListener<1, int>(this);
+ m_so->RemoveListener<2, char>(this);
+ m_so->RemoveListener<3, int[64]>(this);
}
}
const void* /*info*/)
{
LogDebug("ValueChanged(int) " << propertyEnum << " " << value);
- if ((propertyEnum == 0 && value == 1) || (propertyEnum == 1 && value == 2))
+ if ((propertyEnum == 0 &&
+ value == 1) || (propertyEnum == 1 && value == 2))
{
g_values[propertyEnum]++;
if (g_values[propertyEnum] == 3) {
const void* /*info*/)
{
LogDebug("ValueChanged(char) " << propertyEnum << " " << value);
- if (propertyEnum == 2 && value == 'c')
- {
+ if (propertyEnum == 2 && value == 'c') {
g_values[propertyEnum]++;
if (g_values[propertyEnum] == 3) {
m_waitable->Signal();
}
void ListenerTestController::ValueChanged(size_t propertyEnum,
- const int(& value)[64],
+ const int(&value)[64],
const void* /*info*/)
{
LogDebug("ValueChanged(int[64]) " << propertyEnum << " " << value[5]);
- if (propertyEnum == 3 && value[5] == 5)
- {
+ if (propertyEnum == 3 && value[5] == 5) {
g_values[propertyEnum]++;
if (g_values[propertyEnum] == 3) {
m_waitable->Signal();
RemoveIpcs();
// setup global flags
- for (size_t i=0;i<TestTypeList::Size;++i) {
+ for (size_t i = 0; i < TestTypeList::Size; ++i) {
g_values[i] = 0;
}
Wait(waitable);
// set properties and wait for result
- sho->SetProperty<0,int>(1);
+ sho->SetProperty<0, int>(1);
Wait(waitable);
RUNNER_ASSERT(g_values[0] == 3);
- sho->SetProperty<1,int>(2);
+ sho->SetProperty<1, int>(2);
Wait(waitable);
RUNNER_ASSERT(g_values[1] == 3);
- sho->SetProperty<2,char>('c');
+ sho->SetProperty<2, char>('c');
Wait(waitable);
RUNNER_ASSERT(g_values[2] == 3);
int array[64];
- memset(array,64*sizeof(array[0]),0);
+ memset(array, 0, 64 * sizeof(array[0]));
array[5] = 5;
- sho->SetProperty<3,int[64]>(array);
+ sho->SetProperty<3, int[64]>(array);
Wait(waitable);
RUNNER_ASSERT(g_values[3] == 3);
public:
DAO() : m_boolValue(false) {}
- void SetBoolValue(const bool& value) { m_boolValue = value; }
+ void SetBoolValue(const bool& value)
+ {
+ m_boolValue = value;
+ }
- bool GetBoolValue() const { return m_boolValue; }
+ bool GetBoolValue() const
+ {
+ return m_boolValue;
+ }
private:
bool m_boolValue;
/*
* Model with property having set delegate defined
*/
-class MyModel3: public DPL::Model
+class MyModel3 : public DPL::Model
{
public:
typedef SharedPropertyEx<bool,
boolValue(this,
shared_object,
PropertyType::SetDelegate(dao, &DAO::SetBoolValue))
- {
- }
+ {}
PropertyType boolValue;
};
// set property but call dao delegate within semaphore
sho->SetProperty<TestSharedObject4::BOOLEAN>(
- true,
- MyModel3::PropertyType::SetDelegate(&dao, &DAO::SetBoolValue));
+ true,
+ MyModel3::PropertyType::SetDelegate(&dao, &DAO::SetBoolValue));
// check dao value
RUNNER_ASSERT(dao.GetBoolValue() == true);
*/
class LazySharedObject : public SharedObject<TestTypeList>
{
+ private:
+ LazySharedObject() :
+ m_read(false)
+ {}
+
public:
explicit LazySharedObject(const std::string& semaphore) :
SharedObject<TestTypeList>(semaphore)
- ,m_read(false)
- {
- }
+ , m_read(false)
+ {}
void Init();
- bool IsRead() const { return m_read; }
+ bool IsRead() const
+ {
+ return m_read;
+ }
private:
friend class SharedObjectFactory<LazySharedObject>;
RUNNER_ASSERT(sho3->IsRead() == true);
RUNNER_ASSERT(value == 43);
-
}
//////////////////////////////////////////////
g_delegateCalls = 0;
- RUNNER_ASSERT(0 == (sho->GetProperty<0,int>()));
+ RUNNER_ASSERT(0 == (sho->GetProperty<0, int>()));
DPL::FastDelegate<bool (const int&, int&)> condition(&SetCondition);
DPL::FastDelegate<void (const int&)> delegate(&SetDelegate);
succeeded = sho->ConditionalSetProperty<0>(-2, condition);
RUNNER_ASSERT(succeeded);
- RUNNER_ASSERT(-2 == (sho->GetProperty<0,int>()));
+ RUNNER_ASSERT(-2 == (sho->GetProperty<0, int>()));
succeeded = sho->ConditionalSetProperty<0>(4, condition, delegate);
RUNNER_ASSERT(succeeded);
- RUNNER_ASSERT(10 == (sho->GetProperty<0,int>()));
+ RUNNER_ASSERT(10 == (sho->GetProperty<0, int>()));
RUNNER_ASSERT(1 == g_delegateCalls);
succeeded = sho->ConditionalSetProperty<0>(5, condition);
RUNNER_ASSERT(!succeeded);
- RUNNER_ASSERT(10 == (sho->GetProperty<0,int>()));
+ RUNNER_ASSERT(10 == (sho->GetProperty<0, int>()));
succeeded = sho->ConditionalSetProperty<0>(666, condition, delegate);
RUNNER_ASSERT(!succeeded);
- RUNNER_ASSERT(10 == (sho->GetProperty<0,int>()));
+ RUNNER_ASSERT(10 == (sho->GetProperty<0, int>()));
RUNNER_ASSERT(1 == g_delegateCalls);
}
public:
explicit MTSharedObject(const std::string& semaphore) :
SharedObject<TestTypeList>(semaphore)
- {
- }
+ {}
void Clear();
* Listening controller
*/
class ShmController4 : public ListeningController<MTSharedObject>,
- public ISharedObjectListener<0,int>,
- public ISharedObjectListener<1,int>,
- public ISharedObjectListener<2,char>,
- public ISharedObjectListener<3,int[64]>
+ public ISharedObjectListener<0, int>,
+ public ISharedObjectListener<1, int>,
+ public ISharedObjectListener<2, char>,
+ public ISharedObjectListener<3, int[64]>
{
public:
enum {
};
explicit ShmController4(DPL::WaitableEvent* event) :
- ListeningController<MTSharedObject>(event)
+ ListeningController<MTSharedObject>(event),
+ m_counter(0)
{}
virtual void OnEventReceived(const int& event);
const char& value,
const void* info = NULL);
virtual void ValueChanged(size_t propertyEnum,
- const int(& value)[64],
+ const int(&value)[64],
const void* info = NULL);
bool NotRegistered();
void Sleep();
size_t m_counter;
+ static unsigned int seed = time(NULL);
};
void ShmController4::ValueChanged(size_t propertyEnum,
}
void ShmController4::ValueChanged(size_t propertyEnum,
- const int(& value)[64],
+ const int(&value)[64],
const void* /*info*/)
{
LogDebug("ValueChanged(int[64]) " << propertyEnum << " " << value[5]);
void ShmController4::Sleep()
{
DPL::Thread::GetCurrentThread()->MiliSleep(
- rand() % MAX_SINGLETON_LISTENER_DELAY);
+ rand_r(&seed) % MAX_SINGLETON_LISTENER_DELAY);
}
void ShmController4::OnEventReceived(const int& event)
case ADD_LISTENERS:
// add listener and notify
- m_so->AddListener<0,int>(this);
+ m_so->AddListener<0, int>(this);
Sleep();
- m_so->AddListener<1,int>(this);
+ m_so->AddListener<1, int>(this);
Sleep();
- m_so->AddListener<2,char>(this);
+ m_so->AddListener<2, char>(this);
Sleep();
- m_so->AddListener<3,int[64]>(this);
+ m_so->AddListener<3, int[64]>(this);
Sleep();
m_waitable->Signal();
break;
case REMOVE_LISTENERS:
// remove listener and notify
- m_so->RemoveListener<0,int>(this);
+ m_so->RemoveListener<0, int>(this);
Sleep();
- m_so->RemoveListener<1,int>(this);
+ m_so->RemoveListener<1, int>(this);
Sleep();
- m_so->RemoveListener<2,char>(this);
+ m_so->RemoveListener<2, char>(this);
Sleep();
- m_so->RemoveListener<3,int[64]>(this);
+ m_so->RemoveListener<3, int[64]>(this);
Sleep();
m_waitable->Signal();
break;
}
}
-void MultipleWait(DPL::WaitableEvent (& event)[MAX_THREADS]);
-void MultipleWait(DPL::WaitableEvent (& event)[MAX_THREADS])
+void MultipleWait(DPL::WaitableEvent(&event)[MAX_THREADS]);
+void MultipleWait(DPL::WaitableEvent(&event)[MAX_THREADS])
{
- for (size_t i=0;i<MAX_THREADS;++i) {
+ for (size_t i = 0; i < MAX_THREADS; ++i) {
Wait(event[i]);
}
}
Try { \
singleton->RemoveListener<(property)>(controller[i]); \
LogError("Controller " << i << " is still listening for property " \
- << #property); \
+ << #property); \
RUNNER_ASSERT_MSG(false, "No listeners expected"); \
} \
- Catch (MTSharedObject::Exception::ListenerNotFound) { \
+ Catch(MTSharedObject::Exception::ListenerNotFound) { \
RUNNER_ASSERT(true); \
} \
{
RemoveIpcs(); // we need non existing shm
- srand(time(NULL));
-
// writer shared object
TestSharedObjectPtr sho = SharedObjectFactory<TestSharedObject>::Create(
SHM_KEY, SEM_NAME);
ShmController4* controller[MAX_THREADS];
DPL::WaitableEvent waitable[MAX_THREADS];
- const int array[64] = {0,1,2};
+ const int array[64] = { 0, 1, 2 };
// Create and wait for notification. Make sure that the thread/controller 0
// is created first
LogInfo("Creating controllers");
- for (size_t i=0;i<MAX_THREADS;++i) {
+ for (size_t i = 0; i < MAX_THREADS; ++i) {
controller[i] = new ShmController4(&waitable[i]);
Wait(waitable[i]);
}
// singleton will be created by thread/controller 0 by now
MTSharedObjectPtr singleton = SharedObjectSingleton::Instance();
- for (size_t repeats = 0;repeats < SINGLETON_TEST_REPEATS;++repeats) {
+ for (size_t repeats = 0; repeats < SINGLETON_TEST_REPEATS; ++repeats) {
LogInfo("%%%%%%%%%%%%%%%%%%%%%");
- LogInfo("Iteration " << repeats+1 << " of " << SINGLETON_TEST_REPEATS);
+ LogInfo("Iteration " << repeats + 1 << " of " << SINGLETON_TEST_REPEATS);
singleton->Clear();
// add listeners
LogInfo("Adding listeners");
- for (size_t i=0;i<MAX_THREADS;++i) {
+ for (size_t i = 0; i < MAX_THREADS; ++i) {
controller[i]->PostEvent(ShmController4::ADD_LISTENERS);
}
// wait for listeners
MultipleWait(waitable);
- RUNNER_ASSERT((singleton->GetProperty<0,int>()) == 0);
- RUNNER_ASSERT((singleton->GetProperty<1,int>()) == 0);
- RUNNER_ASSERT((singleton->GetProperty<2,char>()) == 0);
+ RUNNER_ASSERT((singleton->GetProperty<0, int>()) == 0);
+ RUNNER_ASSERT((singleton->GetProperty<1, int>()) == 0);
+ RUNNER_ASSERT((singleton->GetProperty<2, char>()) == 0);
int checkArray[64] = {};
singleton->GetProperty<3>(checkArray);
// remove listeners
LogInfo("Removing listeners");
- for (size_t i=0;i<MAX_THREADS;++i) {
+ for (size_t i = 0; i < MAX_THREADS; ++i) {
controller[i]->PostEvent(ShmController4::REMOVE_LISTENERS);
}
// wait for listeners
// check if listeners array is empty
LogInfo("Checking listeners");
- for (size_t i=0;i<MAX_THREADS;++i) {
+ for (size_t i = 0; i < MAX_THREADS; ++i) {
LISTENER_ASSERT(0);
LISTENER_ASSERT(1);
LISTENER_ASSERT(2);
LISTENER_ASSERT(3);
}
- RUNNER_ASSERT((singleton->GetProperty<0,int>()) == 1);
- RUNNER_ASSERT((singleton->GetProperty<1,int>()) == 11);
- RUNNER_ASSERT((singleton->GetProperty<2,char>()) == 'a');
+ RUNNER_ASSERT((singleton->GetProperty<0, int>()) == 1);
+ RUNNER_ASSERT((singleton->GetProperty<1, int>()) == 11);
+ RUNNER_ASSERT((singleton->GetProperty<2, char>()) == 'a');
singleton->GetProperty<3>(checkArray);
RUNNER_ASSERT(checkArray[0] == 0);
RUNNER_ASSERT(checkArray[1] == 1);
// Destroy controllers and wait for confirmation. Make sure that
// thread/controller 0 is destroyed in the end
LogInfo("Destroying controllers");
- for (int i=MAX_THREADS-1;i>=0;--i) {
+ for (int i = MAX_THREADS - 1; i >= 0; --i) {
controller[i]->PostEvent(DESTROY_EVENT);
Wait(waitable[i]);
- if (i==0) {
+ if (i == 0) {
/*
* Destroy singleton before thread that created it finishes.
* This is to properly close all waitable handles opened by
* @brief This file is the implementation file of sql connection tests
*/
-
/*
-
-This test has been saved from original test_sql_connection.cpp in wrt-commons project.
-
-*/
+ *
+ * This test has been saved from original test_sql_connection.cpp in wrt-commons
+ * project.
+ *
+ */
#include <dpl/naive_synchronization_object.h>
RUNNER_TEST(SqlConnection_MassiveReadWrite_SemaphoreSynchronization)
{
- srand(time(NULL));
-
std::ostringstream dbSemaporeFileNameStream;
+ unsigned int seed = time(NULL);
+
dbSemaporeFileNameStream << "dpl_tests_dbso_sem_";
- dbSemaporeFileNameStream << rand() << ".sem";
+ dbSemaporeFileNameStream << rand_r(&seed) << ".sem";
std::string dbSemaphoreFileName = dbSemaporeFileNameStream.str();
RUNNER_TEST_GROUP_INIT(DPL)
-class MySingleTask
- : public DPL::TaskDecl<MySingleTask>
+class MySingleTask :
+ public DPL::TaskDecl<MySingleTask>
{
-protected:
+ protected:
void StepOne()
- {
- }
+ {}
-public:
- MySingleTask()
- : DPL::TaskDecl<MySingleTask>(this)
+ public:
+ MySingleTask() :
+ DPL::TaskDecl<MySingleTask>(this)
{
AddStep(&MySingleTask::StepOne);
}
};
-class MyMultiTask
- : public DPL::MultiTaskDecl<MyMultiTask>
+class MyMultiTask :
+ public DPL::MultiTaskDecl<MyMultiTask>
{
-protected:
+ protected:
typedef DPL::MultiTaskDecl<MyMultiTask> BaseType;
void StepOne()
LogInfo("Step three");
}
-public:
- MyMultiTask()
- : BaseType(this, 2)
+ public:
+ MyMultiTask() :
+ BaseType(this, 2)
{
BaseType::StepList depListStepThree;
depListStepThree.push_back(&MyMultiTask::StepOne);
RUNNER_TEST(Task_SingleTask)
{
MySingleTask task;
- while (task.NextStep());
+ while (task.NextStep()) {}
}
RUNNER_TEST(Task_MultiTask)
{
MyMultiTask task;
- while (task.NextStep());
+ while (task.NextStep()) {}
}
# @brief
#
-SET(TARGET_NAME "dpl-tests-utils")
+SET(TARGET_NAME "wrt-commons-tests-utils")
# Set DPL tests sources
SET(DPL_TESTS_UTIL_SOURCES
- ${TESTS_DPL_DIR}/utils/main.cpp
- ${TESTS_DPL_DIR}/utils/widget_version.cpp
- ${TESTS_DPL_DIR}/utils/bash_utils.cpp
- ${TESTS_DPL_DIR}/utils/wrt_utility.cpp
+ ${TESTS_DIR}/utils/main.cpp
+ ${TESTS_DIR}/utils/widget_version.cpp
+ ${TESTS_DIR}/utils/bash_utils.cpp
+ ${TESTS_DIR}/utils/wrt_utility.cpp
+ ${TESTS_DIR}/utils/path_tests.cpp
)
#WRT_TEST_ADD_INTERNAL_DEPENDENCIES(${TARGET_NAME} ${TARGET_DPL_UTILS_EFL})
RUNNER_TEST_GROUP_INIT(DPL_BASH_UTILS)
+/*
+Name: Bash_Utils_escape_arg
+Description:tests ecaping bash special characters for command arguments
+Expected: matching string
+*/
RUNNER_TEST(Bash_Utils_escape_arg)
{
- RUNNER_ASSERT_MSG(escape_arg(std::string("valid")) == "\"valid\"", "Valid argument failed");
+ RUNNER_ASSERT_MSG(escape_arg(std::string(
+ "valid")) == "\"valid\"",
+ "Valid argument failed");
LogDebug("\"val\\!d\"" << " " << escape_arg(std::string("val!d")));
- RUNNER_ASSERT_MSG(escape_arg(std::string("val!d")) == "\"val\\!d\"", "Single escaped character in argument failed");
+ RUNNER_ASSERT_MSG(escape_arg(std::string(
+ "val!d")) == "\"val\\!d\"",
+ "Single escaped character in argument failed");
LogDebug("\"v\\$l\\$\\$\"" << " " << escape_arg(std::string("v$l$$")));
- RUNNER_ASSERT_MSG(escape_arg(std::string("v$l$$")) == "\"v\\$l\\$\\$\"", "Multiple occurences of single special character in argument failed");
- LogDebug("\"v\\`\\$\\\"\\!d\\`\"" << " " << escape_arg(std::string("v`$\"!d`")));
- RUNNER_ASSERT_MSG(escape_arg(std::string("v`$\"!d`")) == "\"v\\`\\$\\\"\\!d\\`\"", "Multiple occurences of multiple special character in argument failed");
+ RUNNER_ASSERT_MSG(escape_arg(std::string(
+ "v$l$$")) == "\"v\\$l\\$\\$\"",
+ "Multiple occurences of single special character in argument failed");
+ LogDebug("\"v\\`\\$\\\"\\!d\\`\"" << " " <<
+ escape_arg(std::string("v`$\"!d`")));
+ RUNNER_ASSERT_MSG(escape_arg(std::string(
+ "v`$\"!d`")) == "\"v\\`\\$\\\"\\!d\\`\"",
+ "Multiple occurences of multiple special character in argument failed");
}
--- /dev/null
+/*
+ * Copyright (c) 2013 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 path.h
+ * @author Tomasz Iwanek (t.iwanek@samsung.com)
+ * @version 1.0
+ */
+
+#include <set>
+#include <memory>
+
+#include <dpl/test/test_runner.h>
+#include <dpl/scoped_dir.h>
+#include <dpl/scoped_free.h>
+#include <dpl/utils/path.h>
+#include <dpl/foreach.h>
+#include <dpl/log/log.h>
+
+#include <sys/stat.h>
+#include <unistd.h>
+
+using namespace DPL::Utils;
+
+namespace {
+//do not used path here we test it
+std::string rootTest = "/tmp/wrttest/";
+}
+
+RUNNER_TEST_GROUP_INIT(DPL_Path)
+
+/*
+Name: path_touch
+Description: constructs paths in many ways
+Expected: success full constrution
+*/
+RUNNER_TEST(path_mkfile)
+{
+ DPL::ScopedDir sd(rootTest);
+
+ struct stat st;
+ Path path = Path(rootTest) / "touch.txt";
+ RUNNER_ASSERT_MSG(lstat(path.Fullpath().c_str(), &st) != 0, "File should not be created");
+ RUNNER_ASSERT(!path.Exists());
+ MakeEmptyFile(path);
+ RUNNER_ASSERT_MSG(lstat(path.Fullpath().c_str(), &st) == 0, "File should be created");
+ RUNNER_ASSERT(path.Exists());
+ RUNNER_ASSERT(path.IsFile());
+ RUNNER_ASSERT(!path.IsDir());
+ RUNNER_ASSERT(!path.IsSymlink());
+}
+
+/*
+Name: path_touch
+Description: tries to craete file when it exists
+Expected: failure
+*/
+RUNNER_TEST(path_mkfile_exists)
+{
+ DPL::ScopedDir sd(rootTest);
+
+ Path path = Path(rootTest) / "touch.txt";
+ MakeEmptyFile(path);
+ RUNNER_ASSERT(path.Exists());
+ bool cannotCreate2ndTime = false;
+ Try
+ {
+ MakeEmptyFile(path);
+ }
+ Catch(Path::AlreadyExists)
+ {
+ cannotCreate2ndTime = true;
+ }
+ RUNNER_ASSERT_MSG(cannotCreate2ndTime, "File created should not be able to be created second time");
+}
+
+/*
+Name: path_mkfile_invalid_path
+Description: tries to create file in not exisitng directory
+Expected: failure at creation
+*/
+RUNNER_TEST(path_mkfile_invalid_path)
+{
+ DPL::ScopedDir sd(rootTest);
+
+ Path path = Path(rootTest) / "not_existing" / "touch.txt";
+ bool cannotCreate = false;
+ Try
+ {
+ MakeEmptyFile(path);
+ }
+ Catch(Path::OperationFailed)
+ {
+ cannotCreate = true;
+ }
+ RUNNER_ASSERT_MSG(cannotCreate, "File created should not be able to be created");
+}
+
+/*
+Name: path_mkdir
+Description: creates valid directory
+Expected: success direcotry creation
+*/
+RUNNER_TEST(path_mkdir)
+{
+ DPL::ScopedDir sd(rootTest);
+
+ struct stat st;
+ Path path = Path(rootTest) / "touchDir";
+ RUNNER_ASSERT_MSG(lstat(path.Fullpath().c_str(), &st) != 0, "Directory should not be created");
+ RUNNER_ASSERT(!path.Exists());
+ MakeDir(path);
+ RUNNER_ASSERT_MSG(lstat(path.Fullpath().c_str(), &st) == 0, "Directory should be created");
+ RUNNER_ASSERT(path.Exists());
+ RUNNER_ASSERT(!path.IsFile());
+ RUNNER_ASSERT(path.IsDir());
+ RUNNER_ASSERT(!path.IsSymlink());
+}
+
+/*
+Name: path_symlink
+Description: chekc if symlink is correctly recognized
+Expected: method isSymlink returns true
+*/
+RUNNER_TEST(path_symlink)
+{
+ DPL::ScopedDir sd(rootTest);
+
+ struct stat st;
+ Path path = Path(rootTest) / "symlink";
+ RUNNER_ASSERT_MSG(lstat(path.Fullpath().c_str(), &st) != 0, "Symlink should not be created");
+ RUNNER_ASSERT(!path.Exists());
+ (void)symlink("/nonexistisfile/file/file/file ", path.Fullpath().c_str());
+ RUNNER_ASSERT_MSG(lstat(path.Fullpath().c_str(), &st) == 0, "Symlink should be created");
+ RUNNER_ASSERT(path.Exists());
+ RUNNER_ASSERT(!path.IsFile());
+ RUNNER_ASSERT(!path.IsDir());
+ RUNNER_ASSERT(path.IsSymlink());
+}
+
+/*
+Name: path_construction_empty
+Description: tries to construct empty path
+Expected: failure
+*/
+RUNNER_TEST(path_construction_empty)
+{
+ bool passed = false;
+ Try
+ {
+ Path path1(std::string(""));
+ }
+ Catch(Path::EmptyPath)
+ {
+ passed = true;
+ }
+ RUNNER_ASSERT_MSG(passed, "Construction with empty path do not fails");
+}
+
+/*
+Name: path_construction_root
+Description: tries to construct root path
+Expected: success
+*/
+RUNNER_TEST(path_construction_root)
+{
+ Path path1(std::string("/"));
+ RUNNER_ASSERT(path1.Fullpath() == "/");
+ RUNNER_ASSERT(path1.Basename() == "");
+ bool passed = false;
+ Try
+ {
+ RUNNER_ASSERT(path1.DirectoryName() == "/");
+ }
+ Catch(Path::InternalError)
+ {
+ passed = true;
+ }
+ RUNNER_ASSERT_MSG(passed, "Directory name for root should be an error");
+}
+
+/*
+Name: path_construction_1
+Description: constructs paths in many ways
+Expected: success full constrution
+*/
+RUNNER_TEST(path_construction_1)
+{
+ DPL::ScopedFree<char> sf(getcwd(NULL, 0));
+
+ Path path1(std::string("/test/bin/file"));
+ RUNNER_ASSERT(path1.Fullpath() == "/test/bin/file");
+ RUNNER_ASSERT(path1.Basename() == "file");
+ RUNNER_ASSERT(path1.DirectoryName() == "/test/bin");
+}
+
+/*
+Name: path_construction_2
+Description: constructs paths in many ways
+Expected: success full constrution
+*/
+RUNNER_TEST(path_construction_2)
+{
+ DPL::ScopedFree<char> sf(getcwd(NULL, 0));
+ std::string cwd(sf.Get());
+
+ Path path2(std::string("test/bin/file.eas"));
+ RUNNER_ASSERT(path2.Fullpath() == cwd + "/test/bin/file.eas");
+ RUNNER_ASSERT(path2.Basename() == "file.eas");
+ RUNNER_ASSERT(path2.DirectoryName() == cwd + "/test/bin");
+}
+
+/*
+Name: path_construction_3
+Description: constructs paths in many ways
+Expected: success full constrution
+*/
+RUNNER_TEST(path_construction_3)
+{
+ DPL::ScopedFree<char> sf(getcwd(NULL, 0));
+ std::string cwd(sf.Get());
+
+ Path path3("test/23/abc");
+ RUNNER_ASSERT(path3.Fullpath() == cwd + "/test/23/abc");
+ RUNNER_ASSERT(path3.Basename() == "abc");
+ RUNNER_ASSERT(path3.DirectoryName() == cwd + "/test/23");
+}
+
+/*
+Name: path_construction_4
+Description: constructs paths in many ways
+Expected: success full constrution
+*/
+RUNNER_TEST(path_construction_4)
+{
+ DPL::ScopedFree<char> sf(getcwd(NULL, 0));
+
+ Path path4("/test/bin/abc");
+ RUNNER_ASSERT(path4.Fullpath() == "/test/bin/abc");
+ RUNNER_ASSERT(path4.Basename() == "abc");
+ RUNNER_ASSERT(path4.DirectoryName() == "/test/bin");
+}
+
+/*
+Name: path_construction_5
+Description: constructs paths in many ways
+Expected: success full constrution
+*/
+RUNNER_TEST(path_construction_5)
+{
+ DPL::ScopedFree<char> sf(getcwd(NULL, 0));
+ std::string cwd(sf.Get());
+
+ Path path5(DPL::String(L"test/bin/file.st.exe"));
+ RUNNER_ASSERT(path5.Fullpath() == cwd + "/test/bin/file.st.exe");
+ RUNNER_ASSERT(path5.Basename() == "file.st.exe");
+ RUNNER_ASSERT(path5.DirectoryName() == cwd + "/test/bin");
+}
+
+/*
+Name: path_construction_6
+Description: constructs paths in many ways
+Expected: success full constrution
+*/
+RUNNER_TEST(path_construction_6)
+{
+ DPL::ScopedFree<char> sf(getcwd(NULL, 0));
+
+ Path path6(DPL::String(L"/test/bin/file"));
+ RUNNER_ASSERT(path6.Fullpath() == "/test/bin/file");
+ RUNNER_ASSERT(path6.Basename() == "file");
+ RUNNER_ASSERT(path6.DirectoryName() == "/test/bin");
+}
+
+/*
+Name: path_construction_7
+Description: constructs paths in many ways
+Expected: success full constrution
+*/
+RUNNER_TEST(path_construction_7)
+{
+ DPL::ScopedFree<char> sf(getcwd(NULL, 0));
+ std::string cwd(sf.Get());
+
+ Path path7 = Path("test") / "a///23/lol";
+ RUNNER_ASSERT(path7.Fullpath() == cwd + "/test/a/23/lol");
+ RUNNER_ASSERT(path7.Basename() == "lol");
+ RUNNER_ASSERT(path7.DirectoryName() == cwd + "/test/a/23");
+}
+
+/*
+Name: path_construction_8
+Description: constructs paths in many ways
+Expected: success full constrution
+*/
+RUNNER_TEST(path_construction_8)
+{
+ DPL::ScopedFree<char> sf(getcwd(NULL, 0));
+
+ Path path8 = Path("/test/bin/") / "123" / "dir1.dll";
+ RUNNER_ASSERT(path8.Fullpath() == "/test/bin/123/dir1.dll");
+ RUNNER_ASSERT(path8.Basename() == "dir1.dll");
+ RUNNER_ASSERT(path8.DirectoryName() == "/test/bin/123");
+}
+
+/*
+Name: path_construction_9
+Description: constructs paths in many ways
+Expected: success full constrution
+*/
+RUNNER_TEST(path_construction_9)
+{
+ DPL::ScopedFree<char> sf(getcwd(NULL, 0));
+
+ Path path9 = Path("/test/bin/file.txt//");
+ RUNNER_ASSERT(path9.Fullpath() == "/test/bin/file.txt");
+ RUNNER_ASSERT(path9.Basename() == "file.txt");
+ RUNNER_ASSERT(path9.DirectoryName() == "/test/bin");
+}
+
+/*
+Name: path_construction_10
+Description: constructs paths by appending
+Expected: success full constrution
+*/
+RUNNER_TEST(path_construction_10)
+{
+ Path path10 = Path("/test/");
+ path10 /= "one";
+ path10 /= std::string("two");
+ path10 /= DPL::String(L"three");
+ RUNNER_ASSERT(path10.Fullpath() == "/test/one/two/three");
+ RUNNER_ASSERT(path10.Basename() == "three");
+ RUNNER_ASSERT(path10.DirectoryName() == "/test/one/two");
+}
+
+/*
+Name: path_remove
+Description: tests removing paths
+Expected: successfull path remove
+*/
+RUNNER_TEST(path_remove_valid)
+{
+ DPL::ScopedDir sd(rootTest);
+
+ struct stat st;
+ Path path = Path(rootTest) / "touchDir";
+ RUNNER_ASSERT(!path.Exists());
+
+ MakeDir(path);
+ RUNNER_ASSERT_MSG(lstat(path.Fullpath().c_str(), &st) == 0, "Directory should be created");
+ RUNNER_ASSERT(path.Exists());
+
+ Remove(path);
+ RUNNER_ASSERT_MSG(lstat(path.Fullpath().c_str(), &st) != 0, "Directory should not be created");
+ RUNNER_ASSERT(!path.Exists());
+
+ MakeEmptyFile(path);
+ RUNNER_ASSERT_MSG(lstat(path.Fullpath().c_str(), &st) == 0, "File should be created");
+ RUNNER_ASSERT(path.Exists());
+
+ Remove(path);
+ RUNNER_ASSERT_MSG(lstat(path.Fullpath().c_str(), &st) != 0, "File should not be created");
+ RUNNER_ASSERT(!path.Exists());
+}
+
+/*
+Name: path_remove_invalid
+Description: tests removing invalid paths
+Expected: failure at path remove
+*/
+RUNNER_TEST(path_remove_invalid)
+{
+ DPL::ScopedDir sd(rootTest);
+
+ Path path = Path(rootTest) / "touchDir";
+
+ bool removedNotExisting = true;
+ Try
+ {
+ Remove(path);
+ }
+ Catch(Path::OperationFailed)
+ {
+ removedNotExisting = false;
+ }
+ RUNNER_ASSERT_MSG(!removedNotExisting, "Removing not existing file");
+}
+
+/*
+Name: path_rename
+Description: tests path renaming
+Expected: path is successfully renamed
+*/
+RUNNER_TEST(path_rename)
+{
+ DPL::ScopedDir sd(rootTest);
+
+ struct stat st;
+ Path path = Path(rootTest) / "touchDir";
+ Path dirpath = Path(rootTest) / "directory";
+ Path path2 = dirpath / "touchDir2";
+
+ MakeDir(dirpath);
+
+ MakeEmptyFile(path);
+ RUNNER_ASSERT_MSG(lstat(path.Fullpath().c_str(), &st) == 0, "File should be created");
+ RUNNER_ASSERT(path.Exists());
+ RUNNER_ASSERT(!path2.Exists());
+
+ Rename(path, path2);
+ RUNNER_ASSERT(!path.Exists());
+ RUNNER_ASSERT(path2.Exists());
+
+ Rename(path2, path);
+ RUNNER_ASSERT(path.Exists());
+ RUNNER_ASSERT(!path2.Exists());
+
+ //TODO: test for different devices
+}
+
+/*
+Name: path_rename_same
+Description: tests if renam does not brokens file if target location is equal to source location
+Expected: path is avaliable
+*/
+RUNNER_TEST(path_rename_same)
+{
+ DPL::ScopedDir sd(rootTest);
+
+ struct stat st;
+ Path path = Path(rootTest) / "touchDir";
+
+ MakeDir(path);
+ Rename(path, path);
+ RUNNER_ASSERT(path.Exists());
+}
+
+/*
+Name: path_iterate_not_directory
+Description: iterates not a directory
+Expected: success full constrution
+*/
+RUNNER_TEST(path_iterate_not_directory)
+{
+ DPL::ScopedDir sd(rootTest);
+
+ Path fileTest = Path(rootTest) / "file.txt";
+ MakeEmptyFile(fileTest);
+
+ bool passed = false;
+ Try
+ {
+ FOREACH(file, fileTest)
+ {
+
+ }
+ }
+ Catch(Path::NotDirectory)
+ {
+ passed = true;
+ }
+ RUNNER_ASSERT(passed);
+}
+
+/*
+Name: path_construction
+Description: constructs paths in many ways
+Expected: success full constrution
+*/
+RUNNER_TEST(path_iterate_empty_directory)
+{
+ DPL::ScopedDir sd(rootTest);
+
+ Path dirTest = Path(rootTest) / "directory";
+ MakeDir(dirTest);
+
+ bool passed = true;
+ Try
+ {
+ FOREACH(file, dirTest)
+ {
+ passed = false;
+ LogError("Directory should be empty");
+ }
+ }
+ Catch(Path::NotDirectory)
+ {
+ passed = false;
+ LogError("Directory should exists");
+ }
+ RUNNER_ASSERT(passed);
+}
+
+/*
+Name: path_construction
+Description: constructs paths in many ways
+Expected: success full constrution
+*/
+RUNNER_TEST(path_iterate_notempty_directory)
+{
+ DPL::ScopedDir sd(rootTest);
+
+ Path dirTest = Path(rootTest) / "directory";
+
+ Path path1 = Path(rootTest) / "directory" / "file1";
+ Path path2 = Path(rootTest) / "directory" / "file2";
+ Path path3 = Path(rootTest) / "directory" / "file3";
+
+ std::set<std::string> resultSet;
+ std::set<std::string> testSet;
+ testSet.insert(path1.Fullpath());
+ testSet.insert(path2.Fullpath());
+ testSet.insert(path3.Fullpath());
+
+ MakeDir(dirTest);
+ MakeEmptyFile(path1);
+ MakeEmptyFile(path2);
+ MakeEmptyFile(path3);
+
+ FOREACH(file, dirTest)
+ {
+ resultSet.insert(file->Fullpath());
+ }
+
+ RUNNER_ASSERT_MSG(testSet == resultSet, "Testing");
+}
+
+/*
+Name: path_construction
+Description: constructs paths in many ways
+Expected: success full constrution
+*/
+RUNNER_TEST(path_iterator_copy_constructor)
+{
+ DPL::ScopedDir sd(rootTest);
+
+ Path dirTest = Path(rootTest) / "directory";
+
+ Path path1 = Path(rootTest) / "directory" / "file1";
+ Path path2 = Path(rootTest) / "directory" / "file2";
+ Path path3 = Path(rootTest) / "directory" / "file3";
+
+ MakeDir(dirTest);
+ MakeEmptyFile(path1);
+ MakeEmptyFile(path2);
+ MakeEmptyFile(path3);
+
+ std::shared_ptr<Path::Iterator> iter1(new Path::Iterator((Path(rootTest) / "directory").Fullpath().c_str()));
+
+ //as it's input iterator it's guaranteed for one element to be iterate only once
+ (*iter1)++;
+ std::shared_ptr<Path::Iterator> iter2(new Path::Iterator( (*iter1)));
+ iter1.reset();
+ (*iter2)++;
+ ++(*iter2);
+ RUNNER_ASSERT_MSG(*iter2 == dirTest.end(), "Iterator is in broken state");
+ iter2.reset();
+}
RUNNER_TEST_GROUP_INIT(DPL_WIDGET_VERSION)
+/*
+Name: WidgetVersion_M2_O0
+Description: tests correct parsing of version widget in format: [major].[minor]
+Expected: major and minor parts matches expected values
+*/
RUNNER_TEST(WidgetVersion_M2_O0)
{
DPL::String raw(L"1.2");
RUNNER_ASSERT(version.Raw() == raw);
}
+/*
+Name: WidgetVersion_M2_O0_nonwac_1
+Description: tests if version is recognized as wac version number
+Expected: version should not be recognized as wac compatible
+*/
RUNNER_TEST(WidgetVersion_M2_O0_nonwac_1)
{
DPL::String raw(L"a1.2");
RUNNER_ASSERT(version.Raw() == raw);
}
+/*
+Name: WidgetVersion_M2_O0_nonwac_2
+Description: tests if version is recognized as wac version number
+Expected: version should not be recognized as wac compatible
+*/
RUNNER_TEST(WidgetVersion_M2_O0_nonwac_2)
{
DPL::String raw(L"1.2a");
RUNNER_ASSERT(version.Raw() == raw);
}
+/*
+Name: WidgetVersion_M2_O0_nonwac_3
+Description: tests if version is recognized as wac version number
+Expected: version should not be recognized as wac compatible
+*/
RUNNER_TEST(WidgetVersion_M2_O0_nonwac_3)
{
DPL::String raw(L"aaa1.2bbb");
RUNNER_ASSERT(version.Raw() == raw);
}
+/*
+Name: WidgetVersion_M2_O0_nonwac_4
+Description: tests if version is recognized as wac version number
+Expected: version should not be recognized as wac compatible
+*/
RUNNER_TEST(WidgetVersion_M2_O0_nonwac_4)
{
DPL::String raw(L"1a.a2");
RUNNER_ASSERT(version.Raw() == raw);
}
+/*
+Name: WidgetVersion_M2_O0_long
+Description: tests correct parsing of version widget in format: [major].[minor]
+ for huge number
+Expected: major and minor parts matches expected values
+*/
RUNNER_TEST(WidgetVersion_M2_O0_long)
{
- DPL::String raw(L"123456789012345678901234567890.98765432109876543210987654321");
+ DPL::String raw(
+ L"123456789012345678901234567890.98765432109876543210987654321");
WidgetVersion version(raw);
RUNNER_ASSERT(version.IsWac() == true);
- RUNNER_ASSERT(version.Major() == DPL::String(L"123456789012345678901234567890"));
- RUNNER_ASSERT(version.Minor() == DPL::String(L"98765432109876543210987654321"));
+ RUNNER_ASSERT(version.Major() ==
+ DPL::String(L"123456789012345678901234567890"));
+ RUNNER_ASSERT(version.Minor() ==
+ DPL::String(L"98765432109876543210987654321"));
RUNNER_ASSERT(version.Micro() == DPL::Optional<DPL::String>());
RUNNER_ASSERT(version.Optional() == DPL::Optional<DPL::String>());
RUNNER_ASSERT(version.Raw() == raw);
}
+/*
+Name: WidgetVersion_M3_O0
+Description: tests correct wac version number
+Expected: major and minor and micro parts matches expected values.
+ Version should be recognized as wac compatible
+*/
RUNNER_TEST(WidgetVersion_M3_O0)
{
DPL::String raw(L"1.2.3");
RUNNER_ASSERT(version.Raw() == raw);
}
+/*
+Name: WidgetVersion_M3_O0_nonwac_1
+Description: tests if version is recognized as wac version number
+Expected: version should not be recognized as wac compatible
+*/
RUNNER_TEST(WidgetVersion_M3_O0_nonwac_1)
{
DPL::String raw(L"a1a.2.3");
RUNNER_ASSERT(version.Raw() == raw);
}
+/*
+Name: WidgetVersion_M3_O0_nonwac_2
+Description: tests if version is recognized as wac version number
+Expected: version should not be recognized as wac compatible
+*/
RUNNER_TEST(WidgetVersion_M3_O0_nonwac_2)
{
DPL::String raw(L"1.b2.3");
RUNNER_ASSERT(version.Raw() == raw);
}
+/*
+Name: WidgetVersion_M3_O0_nonwac_3
+Description: tests if version is recognized as wac version number
+Expected: version should not be recognized as wac compatible
+*/
RUNNER_TEST(WidgetVersion_M3_O0_nonwac_3)
{
DPL::String raw(L"1.2.3c");
RUNNER_ASSERT(version.Raw() == raw);
}
+/*
+Name: WidgetVersion_M3_O0_nonwac_4
+Description: tests if version is recognized as wac version number
+Expected: version should not be recognized as wac compatible
+*/
RUNNER_TEST(WidgetVersion_M3_O0_nonwac_4)
{
DPL::String raw(L"1.2.3a");
RUNNER_ASSERT(version.Raw() == raw);
}
+/*
+Name: WidgetVersion_M3_O1_1
+Description: tests correct wac version number with optional part
+Expected: major and minor and micro and optional parts matches expected values.
+ Version should be recognized as wac compatible
+*/
RUNNER_TEST(WidgetVersion_M3_O1_1)
{
DPL::String raw(L"1.2.3 test111");
RUNNER_ASSERT(version.Raw() == raw);
}
+/*
+Name: WidgetVersion_M3_O1_1
+Description: tests correct wac version number with numeric optional part
+Expected: major and minor and micro and optional parts matches expected values.
+ Version should be recognized as wac compatible
+*/
RUNNER_TEST(WidgetVersion_M3_O1_2)
{
DPL::String raw(L"1.2.3 111");
RUNNER_ASSERT(version.Raw() == raw);
}
+/*
+Name: WidgetVersion_M3_O1_3
+Description: tests if version is recognized as wac version number
+ when trailer spaces exists
+Expected: version should not be recognized as wac compatible
+*/
RUNNER_TEST(WidgetVersion_M3_O1_3)
{
DPL::String raw(L"1.2.3 ");
RUNNER_ASSERT(version.Raw() == raw);
}
+/*
+Name: WidgetVersion_M2_O1_1
+Description: tests if version is recognized as wac version number
+ when optional part
+Expected: version should be recognized as wac compatible
+*/
RUNNER_TEST(WidgetVersion_M2_O1_1)
{
DPL::String raw(L"1.2 t");
RUNNER_ASSERT(version.Raw() == raw);
}
+/*
+Name: WidgetVersion_Strange_0
+Description: tests if version is recognized as wac version number
+Expected: version should be recognized as wac compatible
+*/
RUNNER_TEST(WidgetVersion_Strange_0)
{
DPL::String raw(L"1");
RUNNER_ASSERT(version.Raw() == raw);
}
+/*
+Name: WidgetVersion_Strange_1
+Description: tests if version is recognized as wac version number
+Expected: version should not be recognized as wac compatible
+*/
RUNNER_TEST(WidgetVersion_Strange_1)
{
DPL::String raw(L".1");
RUNNER_ASSERT(version.Raw() == raw);
}
+/*
+Name: WidgetVersion_Strange_2
+Description: tests if version is recognized as wac version number
+Expected: version should not be recognized as wac compatible
+*/
RUNNER_TEST(WidgetVersion_Strange_2)
{
DPL::String raw(L"..1");
RUNNER_ASSERT(version.Raw() == raw);
}
+/*
+Name: WidgetVersion_Strange_3
+Description: tests if version is recognized as wac version number
+Expected: version should not be recognized as wac compatible
+*/
RUNNER_TEST(WidgetVersion_Strange_3)
{
DPL::String raw(L"...1");
RUNNER_ASSERT(version.Raw() == raw);
}
+/*
+Name: WidgetVersion_Strange_4
+Description: tests if version is recognized as wac version number
+Expected: version should not be recognized as wac compatible
+*/
RUNNER_TEST(WidgetVersion_Strange_4)
{
DPL::String raw(L"qwerty");
RUNNER_ASSERT(version.Raw() == raw);
}
+/*
+Name: WidgetVersion_Strange_5
+Description: tests if version is recognized as wac version number
+Expected: version should not be recognized as wac compatible
+*/
RUNNER_TEST(WidgetVersion_Strange_5)
{
DPL::String raw(L"!@#$%^&*()_+ ^&%^*&%$^*&%*()& JHKJLHKJLH 685685687");
RUNNER_ASSERT(version.Raw() == raw);
}
+/*
+Name: WidgetVersion_Compare_0
+Description: tests version comparision in format [major].[minor]
+Expected: compare should work as expected
+*/
RUNNER_TEST(WidgetVersion_Compare_0)
{
RUNNER_ASSERT(WidgetVersion(L"1.1") < WidgetVersion(L"1.2"));
}
+/*
+Name: WidgetVersion_Compare_1
+Description: tests version comparision in format [major].[minor]
+Expected: compare should work as expected
+*/
RUNNER_TEST(WidgetVersion_Compare_1)
{
RUNNER_ASSERT(WidgetVersion(L"01.001") < WidgetVersion(L"0001.002"));
}
+/*
+Name: WidgetVersion_Compare_2
+Description: tests version equality in format [major].[minor]
+Expected: versions should be equal
+*/
RUNNER_TEST(WidgetVersion_Compare_2)
{
RUNNER_ASSERT(WidgetVersion(L"0.1") == WidgetVersion(L"00.1"));
}
+/*
+Name: WidgetVersion_Compare_3
+Description: tests version comparision in format [major].[minor] [optional]
+Expected: compare should work as expected
+*/
RUNNER_TEST(WidgetVersion_Compare_3)
{
- RUNNER_ASSERT(WidgetVersion(L"1.00000000000000") >= WidgetVersion(L"1.0 test"));
+ RUNNER_ASSERT(WidgetVersion(L"1.00000000000000") >=
+ WidgetVersion(L"1.0 test"));
}
+/*
+Name: WidgetVersion_Compare_4
+Description: tests version comparision for huge numbers
+Expected: compare should work as expected
+*/
RUNNER_TEST(WidgetVersion_Compare_4)
{
- RUNNER_ASSERT(WidgetVersion(L"19647963733338932479072098437089778943732432.00000000000000004324324324324321") > WidgetVersion(L"4324324324324324324321.000432"));
+ RUNNER_ASSERT(WidgetVersion(
+ L"19647963733338932479072098437089778943732432.00000000000000004324324324324321")
+ > WidgetVersion(L"4324324324324324324321.000432"));
}
+/*
+Name: WidgetVersion_Compare_5
+Description: tests equality in format [major].[minor]
+Expected: versions should be equal
+*/
RUNNER_TEST(WidgetVersion_Compare_5)
{
RUNNER_ASSERT(WidgetVersion(L"12345.1") == WidgetVersion(L"12345.1"));
}
+/*
+Name: WidgetVersion_Compare_6
+Description: tests version equality in format [major].[minor]
+Expected: versions should not be equal
+*/
RUNNER_TEST(WidgetVersion_Compare_6)
{
RUNNER_ASSERT(WidgetVersion(L"1.1") != WidgetVersion(L"1.11"));
}
+/*
+Name: WidgetVersion_Compare_7
+Description: tests version equality in format [major].[minor] [optional]
+Expected: versions should be equal, optional part should not be taken into account
+*/
RUNNER_TEST(WidgetVersion_Compare_7)
{
- RUNNER_ASSERT(WidgetVersion(L"000123000.0 notatest") == WidgetVersion(L"00123000.0 testtesttest"));
+ RUNNER_ASSERT(WidgetVersion(L"000123000.0 notatest") ==
+ WidgetVersion(L"00123000.0 testtesttest"));
}
RUNNER_TEST_GROUP_INIT(DPL_WRT_UTILITY)
+/*
+Name: wrt_utility_WrtUtilJoinPaths
+Description: join paths test
+Expected: correctly used separator
+*/
RUNNER_TEST(wrt_utility_WrtUtilJoinPaths)
{
std::string result;
WrtUtilMakeDir("/tmp/test/1/2/3/4/5/6/7/8/9", 0755);
if (stat("/tmp/test/1/2/3/4/5/6/7/8/9", &st) == 0) {
RUNNER_ASSERT_MSG(st.st_mode & S_IRWXU,
- "read, write, execute/search by owner");
+ "read, write, execute/search by owner");
RUNNER_ASSERT_MSG(st.st_mode & S_IXGRP,
- "execute/search permission, group");
+ "execute/search permission, group");
RUNNER_ASSERT_MSG(st.st_mode & S_IRGRP, "read permission, group");
RUNNER_ASSERT_MSG(!(st.st_mode & S_IWGRP),
- "NO write permission, group ");
+ "NO write permission, group ");
RUNNER_ASSERT_MSG(st.st_mode & S_IXOTH,
- "execute/search permission, others");
+ "execute/search permission, others");
RUNNER_ASSERT_MSG(st.st_mode & S_IROTH, "read permission, others");
RUNNER_ASSERT_MSG(!(st.st_mode & S_IWOTH),
- "NO write permission, others ");
+ "NO write permission, others ");
} else {
RUNNER_ASSERT_MSG(false, "Cannot stat folder");
}
RUNNER_TEST(wrt_utility_WrtUtilMakeDir_PermissionError)
{
if (0 == getuid()) {
+ int bufsize;
+ if ((bufsize = sysconf(_SC_GETPW_R_SIZE_MAX)) == -1)
+ RUNNER_ASSERT_MSG(false,
+ "Getting an initial value suggested for the size of buffer failed.");
+
//Change UID to execute the test correctly
errno = 0;
- struct passwd *p = getpwnam("app");
- if (p == NULL) {
+ char *buffer = new char[bufsize];
+ struct passwd p;
+ struct passwd *result = NULL;
+ int return_value = getpwnam_r("app", &p, buffer, bufsize, &result);
+ delete[] buffer;
+
+ if (return_value != 0 || !result) {
int error = errno;
RUNNER_ASSERT_MSG(false, "Getting app user UID failed: "
- << (error == 0 ? "No error detected" : strerror(error)));
+ << (error ==
+ 0 ? "No error detected" : strerror(error)));
}
- if (setuid(p->pw_uid) != 0) {
+ if (setuid(p.pw_uid) != 0) {
int error = errno;
RUNNER_ASSERT_MSG(false, "Changing to app user's UID failed: "
- << (error == 0 ? "No error detected" : strerror(error)));
+ << (error ==
+ 0 ? "No error detected" : strerror(error)));
}
}
- RUNNER_ASSERT_MSG(WrtUtilMakeDir("/tmp/test2/1", 0055) == false,
- "Creating directory '1' in /temp/test2/ should have failed");
+ RUNNER_ASSERT_MSG(WrtUtilMakeDir("/tmp/test2/1",
+ 0055) == false,
+ "Creating directory '1' in /temp/test2/ should have failed");
//Going back to root UID
if (setuid(0) != 0) {
int error = errno;
LogWarning("Changing back to root UID failed: "
- << (error == 0 ? "No error detected" : strerror(error)));
+ << (error == 0 ? "No error detected" : strerror(error)));
}
-
}
/**
*/
RUNNER_TEST(wrt_utility_WrtUtilRemoveDir) {
RUNNER_ASSERT_MSG(WrtUtilMakeDir("/tmp/test3/", 0755) == true,
- "Could not set up directory for test");
+ "Could not set up directory for test");
std::ofstream file;
file.open("/tmp/test3/example.txt");
file.close();
struct stat tmp;
- RUNNER_ASSERT_MSG(stat("/tmp/test3/example.txt",&tmp) == 0,
- "Couldn't create the test file");
+ RUNNER_ASSERT_MSG(stat("/tmp/test3/example.txt", &tmp) == 0,
+ "Couldn't create the test file");
WrtUtilRemove("/tmp/test3");
if (stat("/tmp/test3", &tmp) != 0) {
- int error=errno;
+ int error = errno;
RUNNER_ASSERT(error == ENOENT);
return;
}
WrtUtilRemove("/tmp/NOT_EXISTING");
RUNNER_ASSERT_MSG(WrtUtilRemove("/tmp/NOT_EXISTING") == false,
- "Removing non existing directory returned success");
+ "Removing non existing directory returned success");
}
+/*
+Name: wrt_utility_WrtUtilFileExists
+Description: tests file existence
+Expected: existing file should be reported as existing
+*/
RUNNER_TEST(wrt_utility_WrtUtilFileExists)
{
std::ofstream file;
RUNNER_ASSERT(WrtUtilFileExists("/tmp/test_file1") == false);
}
+/*
+Name: wrt_utility_WrtUtilDirExists
+Description: tests directory existence
+Expected: existing directory should be reported as existing
+*/
RUNNER_TEST(wrt_utility_WrtUtilDirExists)
{
RUNNER_ASSERT(WrtUtilDirExists("/tmp"));
--- /dev/null
+indent_align_string=true\r
+indent_braces=false\r
+indent_braces_no_func=false\r
+indent_brace_parent=false\r
+indent_namespace=false\r
+indent_extern=false\r
+indent_class=true\r
+indent_class_colon=false\r
+indent_else_if=false\r
+indent_func_call_param=false\r
+indent_func_def_param=false\r
+indent_func_proto_param=false\r
+indent_func_class_param=false\r
+indent_func_ctor_var_param=false\r
+indent_template_param=false\r
+indent_func_param_double=false\r
+indent_relative_single_line_comments=false\r
+indent_col1_comment=true\r
+indent_access_spec_body=false\r
+indent_paren_nl=false\r
+indent_comma_paren=false\r
+indent_bool_paren=false\r
+indent_square_nl=false\r
+indent_preserve_sql=false\r
+indent_align_assign=false\r
+sp_balance_nested_parens=false\r
+align_keep_tabs=false\r
+align_with_tabs=false\r
+align_on_tabstop=false\r
+align_number_left=false\r
+align_func_params=false\r
+align_same_func_call_params=false\r
+align_var_def_colon=false\r
+align_var_def_attribute=false\r
+align_var_def_inline=false\r
+align_right_cmt_mix=false\r
+align_on_operator=false\r
+align_mix_var_proto=false\r
+align_single_line_func=false\r
+align_single_line_brace=false\r
+align_nl_cont=false\r
+align_left_shift=true\r
+nl_collapse_empty_body=true\r
+nl_assign_leave_one_liners=false\r
+nl_class_leave_one_liners=false\r
+nl_enum_leave_one_liners=false\r
+nl_getset_leave_one_liners=false\r
+nl_func_leave_one_liners=false\r
+nl_if_leave_one_liners=false\r
+nl_multi_line_cond=true\r
+nl_multi_line_define=false\r
+nl_before_case=false\r
+nl_after_case=false\r
+nl_after_return=false\r
+nl_after_semicolon=true\r
+nl_after_brace_open=false\r
+nl_after_brace_open_cmt=false\r
+nl_after_vbrace_open=false\r
+nl_after_brace_close=false\r
+nl_define_macro=false\r
+nl_squeeze_ifdef=false\r
+nl_ds_struct_enum_cmt=false\r
+nl_ds_struct_enum_close_brace=false\r
+nl_create_if_one_liner=false\r
+nl_create_for_one_liner=false\r
+nl_create_while_one_liner=false\r
+ls_for_split_full=true\r
+ls_func_split_full=true\r
+nl_after_multiline_comment=false\r
+eat_blanks_after_open_brace=true\r
+eat_blanks_before_close_brace=true\r
+mod_pawn_semicolon=false\r
+mod_full_paren_if_bool=false\r
+mod_remove_extra_semicolon=true\r
+mod_sort_import=false\r
+mod_sort_using=false\r
+mod_sort_include=false\r
+mod_move_case_break=false\r
+mod_remove_empty_return=false\r
+cmt_indent_multi=true\r
+cmt_c_group=false\r
+cmt_c_nl_start=false\r
+cmt_c_nl_end=false\r
+cmt_cpp_group=false\r
+cmt_cpp_nl_start=false\r
+cmt_cpp_nl_end=false\r
+cmt_cpp_to_c=false\r
+cmt_star_cont=true\r
+cmt_multi_check_last=true\r
+cmt_insert_before_preproc=false\r
+pp_indent_at_level=false\r
+pp_region_indent_code=false\r
+pp_if_indent_code=false\r
+pp_define_at_level=false\r
+indent_columns=4\r
+indent_member=4\r
+indent_access_spec=-2\r
+code_width=80\r
+nl_max=2\r
+nl_before_access_spec=2\r
+cmt_width=80\r
+indent_with_tabs=0\r
+sp_arith=force\r
+sp_assign=force\r
+sp_enum_assign=force\r
+sp_pp_concat=remove\r
+sp_pp_stringify=remove\r
+sp_bool=force\r
+sp_compare=force\r
+sp_paren_brace=force\r
+sp_angle_paren=remove\r
+sp_before_sparen=force\r
+sp_inside_sparen=remove\r
+sp_after_sparen=force\r
+sp_sparen_brace=force\r
+sp_before_semi=remove\r
+sp_after_semi_for_empty=remove\r
+sp_before_square=remove\r
+sp_before_squares=remove\r
+sp_inside_square=remove\r
+sp_after_comma=force\r
+sp_before_comma=remove\r
+sp_after_class_colon=force\r
+sp_before_class_colon=force\r
+sp_before_case_colon=remove\r
+sp_inside_braces=add\r
+sp_inside_fparens=remove\r
+sp_inside_fparen=remove\r
+sp_func_call_paren=remove\r
+sp_func_class_paren=remove\r
+sp_else_brace=force\r
+sp_brace_else=force\r
+sp_catch_brace=force\r
+sp_brace_catch=force\r
+sp_try_brace=force\r
+sp_before_dc=remove\r
+sp_after_dc=remove\r
+sp_not=remove\r
+sp_inv=remove\r
+sp_addr=remove\r
+sp_member=remove\r
+sp_deref=remove\r
+sp_sign=remove\r
+sp_incdec=remove\r
+sp_cond_colon=force\r
+sp_cond_question=force\r
+sp_case_label=force\r
+nl_assign_brace=remove\r
+nl_if_brace=remove\r
+nl_brace_else=remove\r
+nl_elseif_brace=remove\r
+nl_else_brace=remove\r
+nl_else_if=remove\r
+nl_try_brace=remove\r
+nl_for_brace=remove\r
+nl_catch_brace=remove\r
+nl_brace_catch=remove\r
+nl_while_brace=remove\r
+nl_do_brace=remove\r
+nl_brace_while=remove\r
+nl_switch_brace=remove\r
+nl_namespace_brace=remove\r
+nl_class_brace=force\r
+nl_fdef_brace=force\r
+pos_class_comma=trail\r
+pos_class_colon=trail\r
+mod_full_brace_do=add\r
+mod_full_brace_for=add\r
+mod_full_brace_if=add\r
+mod_full_brace_while=add\r
--- /dev/null
+uncrustify -c uncrustify.cfg --no-backup `find . -regex "\(.*\.cpp\|.*\.h\|.*\.c\|.*\.cc\)" | grep -v "orm.h\|orm_generator.h\|3rdparty\|examples"`
projects / platform / framework / web / wrt-commons.git / commitdiff