Prefixes are added for consistency for exposed headers as a part of API.
Change-Id: Ia968888331f27210e2c8ec00f3859ddadf3e2844
Signed-off-by: coderhyme <jhyo.kim@samsung.com>
Reviewed-on: https://gerrit.iotivity.org/gerrit/1892
Tested-by: jenkins-iotivity <jenkins-iotivity@opendaylight.org>
Reviewed-by: Uze Choi <uzchoi@samsung.com>
/**
* @file
*
- * This file contains BundleInfo class, which provides APIs related to Bundle information.
+ * This file contains RCSBundleInfo class, which provides APIs related to Bundle information.
*/
#ifndef BUNDLEINFO_H_
{
/**
- * @class BundleInfo
+ * @class RCSBundleInfo
* @brief This class provides APIs for creating, getting and setting the Bundle Information
*
*/
- class BundleInfo
+ class RCSBundleInfo
{
public:
- BundleInfo();
- virtual ~BundleInfo();
+ RCSBundleInfo();
+ virtual ~RCSBundleInfo();
/**
* API for setting the Id of the bundle
/**
* API for creating new bundle information
*
- * @return BundleInfo - BundleInfo pointer.
+ * @return RCSBundleInfo - RCSBundleInfo pointer.
*
*/
- static BundleInfo *build();
+ static RCSBundleInfo *build();
protected:
std::string m_ID, m_path, m_version;
};
#include <map>
#include <list>
-#include "BundleInfo.h"
+#include "RCSBundleInfo.h"
namespace OIC
{
* @return list<BundleInfo*> -List of BundleInfo pointer each associated with a bundle
*
*/
- virtual std::list<BundleInfo *> listBundles() = 0;
+ virtual std::list<RCSBundleInfo *> listBundles() = 0;
/**
* API for starting the bundle.
*
######################################################################
# Source files and Targets
######################################################################
-res_container_src = ['src/BaseActivator.cpp','src/BundleActivator.cpp','src/BundleInfo.cpp',
+res_container_src = ['src/BaseActivator.cpp','src/BundleActivator.cpp','src/RCSBundleInfo.cpp',
'src/BundleInfoInternal.cpp', 'src/BundleResource.cpp', 'src/Configuration.cpp', 'src/JavaBundleResource.cpp', 'src/ProtocolBridgeResource.cpp',
'src/ProtocolBridgeConnector.cpp', 'src/ResourceContainer.cpp', 'src/ResourceContainerBundleAPI.cpp', 'src/ResourceContainerImpl.cpp',
'src/SoftSensorResource.cpp']
#include <string.h>
#include <fstream>
-#include "BundleInfo.h"
+#include "RCSBundleInfo.h"
#include "Configuration.h"
#include "NotificationReceiver.h"
#include "BundleResource.h"
#define BUNDLEINFOINTERNAL_H_
#include <string>
-#include "BundleInfo.h"
+#include "RCSBundleInfo.h"
#include "ResourceContainerBundleAPI.h"
#if (JAVA_SUPPORT)
typedef void resourceCreator_t(resourceInfo resourceInfo);
typedef void resourceDestroyer_t(BundleResource *pBundleResource);
- class BundleInfoInternal: public BundleInfo
+ class BundleInfoInternal: public RCSBundleInfo
{
public:
BundleInfoInternal();
- BundleInfoInternal(BundleInfo *info);
+ BundleInfoInternal(RCSBundleInfo *info);
virtual ~BundleInfoInternal();
void setID(const std::string &id);
const std::string &getID();
void setResourceDestroyer(resourceDestroyer_t *);
resourceDestroyer_t *getResourceDestroyer();
- void setBundleInfo(BundleInfo *bundleInfo);
+ void setBundleInfo(RCSBundleInfo *bundleInfo);
void setBundleHandle(void *);
void *getBundleHandle();
-#include "ResourceContainer.h"
+#include "RCSResourceContainer.h"
#include "ResourceContainerBundleAPI.h"
#include "BundleInfoInternal.h"
// methods from ResourceContainer
void startContainer(const std::string &configFile);
void stopContainer();
- void activateBundle(BundleInfo *bundleInfo);
- void deactivateBundle(BundleInfo *bundleInfo);
+ void activateBundle(RCSBundleInfo *bundleInfo);
+ void deactivateBundle(RCSBundleInfo *bundleInfo);
void activateBundle(const std::string &bundleId);
void deactivateBundle(const std::string &bundleId);
- void registerBundle(BundleInfo *bundleinfo);
- void unregisterBundle(BundleInfo *bundleinfo);
+ void registerBundle(RCSBundleInfo *bundleinfo);
+ void unregisterBundle(RCSBundleInfo *bundleinfo);
void unregisterBundleSo(const std::string &id);
std::map<string, string> params);
void removeBundle(const std::string &bundleId);
- std::list<BundleInfo *> listBundles();
+ std::list<RCSBundleInfo *> listBundles();
void addResourceConfig(const std::string &bundleId, const std::string &resourceUri, std::map<string, string> params);
void removeResourceConfig(const std::string &bundleId, const std::string &resourceUri);
void deactivateSoBundle(const std::string &bundleId);
void addSoBundleResource(const std::string &bundleId, resourceInfo newResourceInfo);
void removeSoBundleResource(const std::string &bundleId, const std::string &resourceUri);
- void registerSoBundle(BundleInfo *bundleInfo);
+ void registerSoBundle(RCSBundleInfo *bundleInfo);
#if(JAVA_SUPPORT)
map<string, JavaVM *> m_bundleVM;
- void registerJavaBundle(BundleInfo *bundleInfo);
+ void registerJavaBundle(RCSBundleInfo *bundleInfo);
void activateJavaBundle(string bundleId);
void deactivateJavaBundle(string bundleId);
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
#include "BundleActivator.h"
-#include "ResourceContainer.h"
+#include "RCSResourceContainer.h"
using namespace OIC::Service;
}
#endif
- void BundleInfoInternal::setBundleInfo(BundleInfo *bundleInfo)
+ void BundleInfoInternal::setBundleInfo(RCSBundleInfo *bundleInfo)
{
m_ID = bundleInfo->getID();
m_path = bundleInfo->getPath();
//
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-#include "ResourceContainer.h"
-#include "BundleInfo.h"
+#include "RCSResourceContainer.h"
+#include "RCSBundleInfo.h"
#include "oc_logger.hpp"
#include <iostream>
std::map<string, string> bundleParams;
container->addBundle("oic.bundle.hueSample", "", "libHueBundle.so", bundleParams);
- std::list<BundleInfo *> bundles = container->listBundles();
- std::list<BundleInfo *>::iterator bundleIt;
+ std::list<RCSBundleInfo *> bundles = container->listBundles();
+ std::list<RCSBundleInfo *>::iterator bundleIt;
cout << "\t>>> bundle list size : " << bundles.size() << endl;
for (bundleIt = bundles.begin(); bundleIt != bundles.end(); bundleIt++)
//
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-#include "BundleInfo.h"
+#include "RCSBundleInfo.h"
#include "BundleInfoInternal.h"
namespace OIC
{
namespace Service
{
- BundleInfo::BundleInfo()
+ RCSBundleInfo::RCSBundleInfo()
{
}
- BundleInfo::~BundleInfo()
+ RCSBundleInfo::~RCSBundleInfo()
{
}
- BundleInfo *BundleInfo::build()
+ RCSBundleInfo *RCSBundleInfo::build()
{
BundleInfoInternal *newBundleInfo = new BundleInfoInternal();
return newBundleInfo;
//
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
-#include "ResourceContainer.h"
+#include "RCSResourceContainer.h"
#include "ResourceContainerImpl.h"
namespace OIC{
#include "ResourceContainerImpl.h"
#include "BundleActivator.h"
-#include "ResourceContainer.h"
+#include "RCSResourceContainer.h"
#include "BundleInfoInternal.h"
#include "logger.h"
#include "oc_logger.hpp"
for (unsigned int i = 0; i < bundles.size(); i++)
{
- BundleInfo *bundleInfo = BundleInfo::build();
+ RCSBundleInfo *bundleInfo = RCSBundleInfo::build();
bundleInfo->setPath(bundles[i]["path"]);
bundleInfo->setVersion(bundles[i]["version"]);
bundleInfo->setID(bundles[i]["id"]);
delete m_config;
}
- void ResourceContainerImpl::activateBundle(BundleInfo *bundleInfo)
+ void ResourceContainerImpl::activateBundle(RCSBundleInfo *bundleInfo)
{
BundleInfoInternal *bundleInfoInternal = (BundleInfoInternal *) bundleInfo;
}
}
- void ResourceContainerImpl::deactivateBundle(BundleInfo *bundleInfo)
+ void ResourceContainerImpl::deactivateBundle(RCSBundleInfo *bundleInfo)
{
if (((BundleInfoInternal *) bundleInfo)->isActivated())
{
}
// loads the bundle
- void ResourceContainerImpl::registerBundle(BundleInfo *bundleInfo)
+ void ResourceContainerImpl::registerBundle(RCSBundleInfo *bundleInfo)
{
info_logger() << "Registering bundle: " << bundleInfo->getPath() << endl;
}
}
- void ResourceContainerImpl::unregisterBundle(BundleInfo *bundleInfo)
+ void ResourceContainerImpl::unregisterBundle(RCSBundleInfo *bundleInfo)
{
BundleInfoInternal *bundleInfoInternal = (BundleInfoInternal *) bundleInfo;
if (bundleInfoInternal->isLoaded() && !bundleInfoInternal->isActivated())
else
{
- BundleInfo *bundleInfo = BundleInfo::build();
+ RCSBundleInfo *bundleInfo = RCSBundleInfo::build();
bundleInfo->setID(bundleId);
bundleInfo->setPath(bundlePath);
if (params.find("activator") != params.end())
}
}
- std::list< BundleInfo * > ResourceContainerImpl::listBundles()
+ std::list< RCSBundleInfo * > ResourceContainerImpl::listBundles()
{
- std::list< BundleInfo * > ret;
+ std::list< RCSBundleInfo * > ret;
for (std::map< std::string, BundleInfoInternal * >::iterator it = m_bundles.begin();
it != m_bundles.end(); ++it)
{
{
- BundleInfo *bundleInfo = BundleInfo::build();
- ((BundleInfoInternal *) bundleInfo)->setBundleInfo((BundleInfo *) it->second);
+ RCSBundleInfo *bundleInfo = RCSBundleInfo::build();
+ ((BundleInfoInternal *) bundleInfo)->setBundleInfo((RCSBundleInfo *) it->second);
ret.push_back(it->second);
}
}
}
- void ResourceContainerImpl::registerSoBundle(BundleInfo *bundleInfo)
+ void ResourceContainerImpl::registerSoBundle(RCSBundleInfo *bundleInfo)
{
char *error;
return m_bundleVM[bundleId];
}
- void ResourceContainerImpl::registerJavaBundle(BundleInfo *bundleInfo)
+ void ResourceContainerImpl::registerJavaBundle(RCSBundleInfo *bundleInfo)
{
info_logger() << "Registering Java bundle " << bundleInfo->getID() << endl;
JavaVM *jvm;
#include "Configuration.h"
#include "BundleActivator.h"
#include "BundleResource.h"
-#include "ResourceContainer.h"
+#include "RCSResourceContainer.h"
#include "ResourceContainerBundleAPI.h"
#include "ResourceContainerImpl.h"
TEST_F(ResourceContainerTest, AddNewSoBundleToContainer)
{
std::map<string, string> bundleParams;
- std::list<BundleInfo *> bundles;
+ std::list<RCSBundleInfo *> bundles;
bundles = m_pResourceContainer->listBundles();
m_pResourceContainer->addBundle("oic.bundle.test", "", "libTestBundle.so", bundleParams);
TEST_F(ResourceContainerTest, RemoveSoBundleFromContainer)
{
std::map<string, string> bundleParams;
- std::list<BundleInfo *> bundles;
+ std::list<RCSBundleInfo *> bundles;
bundles = m_pResourceContainer->listBundles();
m_pResourceContainer->removeBundle("oic.bundle.test");
TEST_F(ResourceContainerTest, AddBundleAlreadyRegistered)
{
std::map<string, string> bundleParams;
- std::list<BundleInfo *> bundles;
+ std::list<RCSBundleInfo *> bundles;
m_pResourceContainer->addBundle("oic.bundle.test", "", "libTestBundle.so", bundleParams);
bundles = m_pResourceContainer->listBundles();
public:
MockRepository mocks;
ResourceContainerImpl *m_pResourceContainer;
- BundleInfo *m_pBundleInfo;
+ RCSBundleInfo *m_pBundleInfo;
protected:
void SetUp()
{
TestWithMock::SetUp();
m_pResourceContainer = ResourceContainerImpl::getImplInstance();
- m_pBundleInfo = BundleInfo::build();
+ m_pBundleInfo = RCSBundleInfo::build();
}
};