{
}
- SSMRESULT onQueryEngineEvent(IN int cqid, IN IDataReader *pResult)
+ SSMRESULT onQueryEngineEvent(int cqid, IDataReader *pResult)
{
SSMRESULT res = SSM_E_FAIL;
m_mtxListener.unlock();
}
- void addListener(IN int cqid, IN IQueryEngineEvent *pEngineEvent)
+ void addListener(int cqid, IQueryEngineEvent *pEngineEvent)
{
m_mapListener[cqid] = pEngineEvent;
}
- void removeListener(IN int cqid)
+ void removeListener(int cqid)
{
m_mapListener.erase(cqid);
}
return res;
}
-SSMRESULT OIC::RegisterQuery(IN std::string queryString, IN IQueryEngineEvent *listener,
- IN int &cqid)
+SSMRESULT OIC::RegisterQuery(std::string queryString, IQueryEngineEvent *listener,
+ int &cqid)
{
SSMRESULT res = SSM_E_FAIL;
return res;
}
-SSMRESULT OIC::UnregisterQuery(IN int cqid)
+SSMRESULT OIC::UnregisterQuery(int cqid)
{
SSMRESULT res = SSM_E_FAIL;
* @exception
* @see
*/
- virtual SSMRESULT getSoftSensorList(OUT std::vector<ISSMResource *> *pSoftSensorList) = 0 ;
+ virtual SSMRESULT getSoftSensorList(std::vector<ISSMResource *> *pSoftSensorList) = 0 ;
/**
* @fn getPrimitiveSensorList
* @exception
* @see
*/
- virtual SSMRESULT getPrimitiveSensorList(OUT std::vector<ISSMResource *> *pPrimitiveSensorList) = 0
+ virtual SSMRESULT getPrimitiveSensorList(std::vector<ISSMResource *> *pPrimitiveSensorList) = 0
;
/**
* @exception
* @see
*/
- virtual SSMRESULT initRepository(IN std::string name, IN std::string type,
- IN std::string pathSoftSensors, IN std::string pathDescription) = 0;
+ virtual SSMRESULT initRepository(std::string name, std::string type,
+ std::string pathSoftSensors, std::string pathDescription) = 0;
- virtual SSMRESULT registerResourceFinderEvent(IN IResourceEvent *pResourceEvent) = 0;
+ virtual SSMRESULT registerResourceFinderEvent(IResourceEvent *pResourceEvent) = 0;
virtual SSMRESULT startResourceFinder() = 0;
virtual SSMRESULT stopResourceFinder() = 0;
- virtual SSMRESULT onResourceFound(IN ISSMResource *pSensor) = 0;
- virtual SSMRESULT onResourceLost(IN ISSMResource *pSensor) = 0;
+ virtual SSMRESULT onResourceFound(ISSMResource *pSensor) = 0;
+ virtual SSMRESULT onResourceLost(ISSMResource *pSensor) = 0;
- virtual SSMRESULT startObserveResource(IN ISSMResource *pSensor, IN IEvent *pEvent) = 0;
- virtual SSMRESULT stopObserveResource(IN ISSMResource *pSensor) = 0;
+ virtual SSMRESULT startObserveResource(ISSMResource *pSensor, IEvent *pEvent) = 0;
+ virtual SSMRESULT stopObserveResource(ISSMResource *pSensor) = 0;
- virtual SSMRESULT loadSoftSensor(IN std::string softSensorName, IN ICtxDelegate *pDelegate,
- OUT void **hSoftSensor) = 0;
- virtual SSMRESULT unloadSoftSensor(IN void *hSoftSensor) = 0;
+ virtual SSMRESULT loadSoftSensor(std::string softSensorName, ICtxDelegate *pDelegate,
+ void **hSoftSensor) = 0;
+ virtual SSMRESULT unloadSoftSensor(void *hSoftSensor) = 0;
};
struct ModelProperty
* @exception
* @see
*/
- virtual SSMRESULT onWatchModelData(IN int triggerId, IN int dataId) = 0;
+ virtual SSMRESULT onWatchModelData(int triggerId, int dataId) = 0;
};
static const OID OID_IEvaluationEngine = { 0x5a59a9f3, 0x7506, 0x4a3a, { 0xb9, 0x34, 0xcb, 0x51, 0xd, 0xb4, 0xed, 0x53 } };
* @exception
* @see
*/
- virtual SSMRESULT createModel(IN int parentModelId, IN const char *newModelName,
- IN ModelPropertyVec *pModelDescs, OUT int *pModelId) = 0;
- //virtual SSMRESULT GetModelSchema(IN int modelId, OUT ModelPropertyVec *pModelProperties) = 0;
+ virtual SSMRESULT createModel(int parentModelId, const char *newModelName,
+ ModelPropertyVec *pModelDescs, int *pModelId) = 0;
+ //virtual SSMRESULT GetModelSchema(int modelId, ModelPropertyVec *pModelProperties) = 0;
/**
* @fn addModelData
* @exception
* @see
*/
- virtual SSMRESULT addModelData(IN int modelId, IN int parentModelId, IN int parentDataId,
- IN ModelPropertyVec *pModelValues, OUT int *pDataId) = 0;
+ virtual SSMRESULT addModelData(int modelId, int parentModelId, int parentDataId,
+ ModelPropertyVec *pModelValues, int *pDataId) = 0;
/**
* @fn updateModelData
* @exception
* @see
*/
- virtual SSMRESULT updateModelData(IN int modelId, IN int dataId,
- IN ModelPropertyVec *pModelValues) = 0;
+ virtual SSMRESULT updateModelData(int modelId, int dataId,
+ ModelPropertyVec *pModelValues) = 0;
- //virtual SSMRESULT DeleteModel(IN int modelId) = 0;
+ //virtual SSMRESULT DeleteModel(int modelId) = 0;
/**
* @fn deleteModelData
* @exception
* @see
*/
- virtual SSMRESULT deleteModelData(IN int modelId, IN int dataId) = 0;
+ virtual SSMRESULT deleteModelData(int modelId, int dataId) = 0;
- //virtual SSMRESULT GetModelId(IN const char *modelName, OUT int *pModelId) = 0;
+ //virtual SSMRESULT GetModelId(const char *modelName, int *pModelId) = 0;
/**
* @fn getModelData
* @exception
* @see
*/
- virtual SSMRESULT getModelData(IN int modelId, IN int dataId,
- OUT ModelPropertyVec *pModelProperties) = 0;
+ virtual SSMRESULT getModelData(int modelId, int dataId,
+ ModelPropertyVec *pModelProperties) = 0;
/**
* @fn getModelDataSet
* @exception
* @see
*/
- virtual SSMRESULT getModelDataSet(IN int modelId, IN int startIndex, IN int count,
- OUT std::vector<ModelPropertyVec> *pDataSet, OUT int *pLastIndex) = 0;
+ virtual SSMRESULT getModelDataSet(int modelId, int startIndex, int count,
+ std::vector<ModelPropertyVec> *pDataSet, int *pLastIndex) = 0;
/**
* @fn getConditionedModelData
* @exception
* @see
*/
- virtual SSMRESULT getConditionedModelData(IN int modelId, IN ModelConditionVec *pModelConditions,
- OUT IntVec *pDataIds) = 0;
+ virtual SSMRESULT getConditionedModelData(int modelId, ModelConditionVec *pModelConditions,
+ IntVec *pDataIds) = 0;
/**
* @fn watchModelData
* @exception
* @see
*/
- virtual SSMRESULT watchModelData(IN int modelId, IN ModelConditionVec *pModelConditions,
- IN IEvaluationEngineEvent *pEvaluationEngineEvent, OUT int *pTriggerId) = 0;
+ virtual SSMRESULT watchModelData(int modelId, ModelConditionVec *pModelConditions,
+ IEvaluationEngineEvent *pEvaluationEngineEvent, int *pTriggerId) = 0;
/**
* @fn dropWatchModelData
* @exception
* @see
*/
- virtual SSMRESULT dropWatchModelData(IN int triggerId) = 0;
+ virtual SSMRESULT dropWatchModelData(int triggerId) = 0;
/**
* @fn getParentDataId
* @exception
* @see
*/
- virtual SSMRESULT getParentDataId(IN int modelId, IN int dataId, IN int parentModelId,
- OUT int *pParentDataId) = 0;
+ virtual SSMRESULT getParentDataId(int modelId, int dataId, int parentModelId,
+ int *pParentDataId) = 0;
/**
* @fn getChildDataId
* @exception
* @see
*/
- virtual SSMRESULT getChildDataId(IN int modelId, IN int dataId, IN int childModelId,
- OUT IntVec *pChildDataIds) = 0;
+ virtual SSMRESULT getChildDataId(int modelId, int dataId, int childModelId,
+ IntVec *pChildDataIds) = 0;
//For decision tree
- //virtual SSMRESULT GetPathToRoot(IN int currentModelId, OUT IntVec *pPath) = 0;
- //virtual SSMRESULT GetModelHierarchy(IN int rootModelId, OUT StringVec *pPath) = 0;
- //virtual SSMRESULT GetDataHierarchy(IN int rootModelId, IN int dataId, OUT StringVec *pPath) = 0;
+ //virtual SSMRESULT GetPathToRoot(int currentModelId, IntVec *pPath) = 0;
+ //virtual SSMRESULT GetModelHierarchy(int rootModelId, StringVec *pPath) = 0;
+ //virtual SSMRESULT GetDataHierarchy(int rootModelId, int dataId, StringVec *pPath) = 0;
};
/**
* @exception
* @see
*/
- virtual SSMRESULT onConditionedModelTriggered(IN int triggerId) = 0;
+ virtual SSMRESULT onConditionedModelTriggered(int triggerId) = 0;
virtual ~IConditionedModelEvent() {};
};
* @exception
* @see
*/
- virtual SSMRESULT getBaseContextModel(OUT IContextModel **ppBaseContextModel) = 0;
+ virtual SSMRESULT getBaseContextModel(IContextModel **ppBaseContextModel) = 0;
/**
* @fn registerConditionedModelEvent
* @exception
* @see
*/
- virtual SSMRESULT registerConditionedModelEvent(IN IConditionedModelEvent *pConditionedModelEvent) =
+ virtual SSMRESULT registerConditionedModelEvent(IConditionedModelEvent *pConditionedModelEvent) =
0;
/**
* @exception
* @see
*/
- virtual SSMRESULT activateTrigger(OUT int *pTriggerId) = 0;
+ virtual SSMRESULT activateTrigger(int *pTriggerId) = 0;
/**
* @fn deactivateTrigger
* @exception
* @see
*/
- virtual SSMRESULT getAffectedData(OUT IntVec *pDataIds) = 0;
+ virtual SSMRESULT getAffectedData(IntVec *pDataIds) = 0;
/**
* @fn getWatchCondition
* @exception
* @see
*/
- virtual SSMRESULT getWatchCondition(OUT ModelConditionVec *pModelConditions) = 0;
+ virtual SSMRESULT getWatchCondition(ModelConditionVec *pModelConditions) = 0;
};
static const OID OID_IConditionedQueryResult = { 0x4a24e85b, 0x8903, 0x4cf5, { 0x88, 0x7b, 0x65, 0xc2, 0xc3, 0x9e, 0x42, 0xfd } };
* @exception
* @see
*/
- virtual SSMRESULT getConditionedContextModel(IN unsigned int conditionedModelIndex,
- OUT IConditionedModel **ppConditionedModel) = 0;
+ virtual SSMRESULT getConditionedContextModel(unsigned int conditionedModelIndex,
+ IConditionedModel **ppConditionedModel) = 0;
};
/**
* @exception
* @see
*/
- virtual SSMRESULT onConditionedQueryEvent(IN int userTriggerId,
- IN IConditionedQueryResult *pConditionedQueryResult) = 0;
+ virtual SSMRESULT onConditionedQueryEvent(int userTriggerId,
+ IConditionedQueryResult *pConditionedQueryResult) = 0;
virtual ~IConditionedQueryEvent() {};
};
* @exception
* @see
*/
- virtual SSMRESULT registerConditionedModel(IN IConditionedModel *pConditionedModel) = 0;
+ virtual SSMRESULT registerConditionedModel(IConditionedModel *pConditionedModel) = 0;
/**
* @fn activateTriggers
* @exception
* @see
*/
- virtual SSMRESULT activateTriggers(IN int userTriggerId) = 0;
+ virtual SSMRESULT activateTriggers(int userTriggerId) = 0;
/**
* @fn deactivateTriggers
* @exception
* @see
*/
- virtual SSMRESULT getConditionedQueryResult(OUT IConditionedQueryResult **ppConditionedQueryResult)
+ virtual SSMRESULT getConditionedQueryResult(IConditionedQueryResult **ppConditionedQueryResult)
= 0;
/**
* @exception
* @see
*/
- virtual SSMRESULT getParentDataId(IN int dataId, IN IContextModel *pParentModel,
- OUT int *pParentDataId) = 0;
+ virtual SSMRESULT getParentDataId(int dataId, IContextModel *pParentModel,
+ int *pParentDataId) = 0;
/**
* @fn getChildDataId
* @exception
* @see
*/
- virtual SSMRESULT getChildDataId(IN int dataId, IN IContextModel *pChildModel,
- OUT IntVec *pPath) = 0;
+ virtual SSMRESULT getChildDataId(int dataId, IContextModel *pChildModel,
+ IntVec *pPath) = 0;
/**
* @fn activate
* @exception
* @see
*/
- virtual SSMRESULT activate(IN ActivationType activationType, IN int targetDeviceDataId) = 0;
+ virtual SSMRESULT activate(ActivationType activationType, int targetDeviceDataId) = 0;
/**
* @fn deactivate
* @exception
* @see
*/
- virtual SSMRESULT deactivate(IN ActivationType activationType, IN int targetDeviceDataId) = 0;
- //virtual SSMRESULT GetModelSchema(OUT ModelPropertyVec *pModelProperties) = 0;
+ virtual SSMRESULT deactivate(ActivationType activationType, int targetDeviceDataId) = 0;
+ //virtual SSMRESULT GetModelSchema(ModelPropertyVec *pModelProperties) = 0;
/**
* @fn addModelData
* @exception
* @see
*/
- virtual SSMRESULT addModelData(IN int parentDataId, IN ModelPropertyVec *pData,
- OUT int *pDataId) = 0;
+ virtual SSMRESULT addModelData(int parentDataId, ModelPropertyVec *pData,
+ int *pDataId) = 0;
/**
* @fn updateModelData
* @exception
* @see
*/
- virtual SSMRESULT updateModelData(IN int dataId, IN ModelPropertyVec *pData) = 0;
+ virtual SSMRESULT updateModelData(int dataId, ModelPropertyVec *pData) = 0;
/**
* @fn deleteModelData
* @exception
* @see
*/
- virtual SSMRESULT deleteModelData(IN int dataId) = 0;
+ virtual SSMRESULT deleteModelData(int dataId) = 0;
/**
* @fn getModelData
* @exception
* @see
*/
- virtual SSMRESULT getModelData(IN int dataId, OUT ModelPropertyVec *pData) = 0;
+ virtual SSMRESULT getModelData(int dataId, ModelPropertyVec *pData) = 0;
/**
* @fn getModelDataSet
* @exception
* @see
*/
- virtual SSMRESULT getModelDataSet(IN int startIndex, IN int count,
- OUT std::vector<ModelPropertyVec> *pDataSet, OUT int *pLastIndex) = 0;
+ virtual SSMRESULT getModelDataSet(int startIndex, int count,
+ std::vector<ModelPropertyVec> *pDataSet, int *pLastIndex) = 0;
/**
* @fn createConditionedModel
* @exception
* @see
*/
- virtual SSMRESULT createConditionedModel(IN ModelConditionVec *pModelConditionVec,
- OUT IConditionedModel **ppConditionedModel) = 0;
+ virtual SSMRESULT createConditionedModel(ModelConditionVec *pModelConditionVec,
+ IConditionedModel **ppConditionedModel) = 0;
//virtual SSMRESULT CleanUpModelData() = 0;
/**
* @exception
* @see
*/
- virtual SSMRESULT onModelStatusChange(IN IContextModel::Status newStatus,
- IN ISSMResource *pSSMResource, IN IContextModel *pModel) = 0;
+ virtual SSMRESULT onModelStatusChange(IContextModel::Status newStatus,
+ ISSMResource *pSSMResource, IContextModel *pModel) = 0;
virtual ~IContextModelEvent() {}
};
* @exception
* @see
*/
- virtual SSMRESULT onQueryContextModel(IN std::string modelName,
- OUT IContextModel **ppContextModel) = 0;
+ virtual SSMRESULT onQueryContextModel(std::string modelName,
+ IContextModel **ppContextModel) = 0;
virtual ~IContextModelAccessor() {}
};
* @exception
* @see
*/
- virtual SSMRESULT registerContextModelAccessor(IN IContextModelAccessor *pContextModelAccessor) = 0;
+ virtual SSMRESULT registerContextModelAccessor(IContextModelAccessor *pContextModelAccessor) = 0;
/**
* @fn getContextData
* @exception
* @see
*/
- virtual SSMRESULT getContextData(IN std::string modelName, IN int startIndex, IN int count,
- OUT std::vector<ContextData> *data, OUT int *pLastIndex) = 0;
+ virtual SSMRESULT getContextData(std::string modelName, int startIndex, int count,
+ std::vector<ContextData> *data, int *pLastIndex) = 0;
};
typedef std::vector<std::pair<std::string, ModelConditionVec> > QueryCondition;
* @exception
* @see
*/
- virtual SSMRESULT getContextModel(IN std:: string modelName,
- OUT IContextModel **ppContextModel) = 0;
+ virtual SSMRESULT getContextModel(std:: string modelName,
+ IContextModel **ppContextModel) = 0;
/**
* @fn createConditionedQuery
* @exception
* @see
*/
- virtual SSMRESULT createConditionedQuery(IN IContextModel::ActivationType activationType,
- IN QueryCondition *pQueryCondition,
- IN IConditionedQueryEvent *pEvent, OUT IConditionedQuery **ppConditionedQuery) = 0;
+ virtual SSMRESULT createConditionedQuery(IContextModel::ActivationType activationType,
+ QueryCondition *pQueryCondition,
+ IConditionedQueryEvent *pEvent, IConditionedQuery **ppConditionedQuery) = 0;
};
static const OID OID_IQueryEngineInternal = { 0x6eabf1a9, 0xe884, 0x4562, { 0x8b, 0x90, 0x1e, 0xe8, 0xba, 0xbf, 0xbe, 0x1a } };
class IResourceFinderEvent
{
public:
- virtual SSMRESULT onResourceFound(IN ISSMResource *pSensor) = 0;
- virtual SSMRESULT onResourceLost(IN ISSMResource *pSensor) = 0;
+ virtual SSMRESULT onResourceFound(ISSMResource *pSensor) = 0;
+ virtual SSMRESULT onResourceLost(ISSMResource *pSensor) = 0;
virtual ~IResourceFinderEvent() {}
};
class IResourceFinder : public IBase
{
public:
- virtual SSMRESULT registerResourceFinderEvent(IN IResourceFinderEvent *pEvent) = 0;
+ virtual SSMRESULT registerResourceFinderEvent(IResourceFinderEvent *pEvent) = 0;
virtual SSMRESULT startResourceFinder() = 0;
virtual SSMRESULT stopResourceFinder() = 0;
- virtual SSMRESULT startObserveResource(IN ISSMResource *pSensor, IN IEvent *pEvent) = 0;
- virtual SSMRESULT stopObserveResource(IN ISSMResource *pSensor) = 0;
+ virtual SSMRESULT startObserveResource(ISSMResource *pSensor, IEvent *pEvent) = 0;
+ virtual SSMRESULT stopObserveResource(ISSMResource *pSensor) = 0;
};
/**
* @exception
* @see
*/
- virtual SSMRESULT initializeCore(IN std::string xmlDescription) = 0;
+ virtual SSMRESULT initializeCore(std::string xmlDescription) = 0;
/**
* @fn startCore
* @exception
* @see
*/
- virtual SSMRESULT terminateCore(IN bool factoryResetFlag) = 0;
+ virtual SSMRESULT terminateCore(bool factoryResetFlag) = 0;
/**
* @fn createQueryEngine
* @exception
* @see
*/
- virtual SSMRESULT createQueryEngine(OUT IQueryEngine **ppQueryEngine) = 0;
+ virtual SSMRESULT createQueryEngine(IQueryEngine **ppQueryEngine) = 0;
/**
* @fn releaseQueryEngine
* @exception
* @see
*/
- virtual unsigned long releaseQueryEngine(IN IQueryEngine *pQueryEngine) = 0;
+ virtual unsigned long releaseQueryEngine(IQueryEngine *pQueryEngine) = 0;
/**
* @fn getInstalledModelList
* @exception
* @see
*/
- virtual SSMRESULT getInstalledModelList(OUT std::vector<ISSMResource *> *pList) = 0;
+ virtual SSMRESULT getInstalledModelList(std::vector<ISSMResource *> *pList) = 0;
};
#endif
* @exception
* @see
*/
- virtual SSMRESULT queryInterface(IN const OID &interfaceID, OUT IBase **ppObject) = 0;
+ virtual SSMRESULT queryInterface(const OID &interfaceID, IBase **ppObject) = 0;
/**
* @fn addRef
* @see
*/
template <class T>
-SSMRESULT CreateNewObject(IN const OID &objectID, OUT IBase **ppObject)
+SSMRESULT CreateNewObject(const OID &objectID, IBase **ppObject)
{
SSMRESULT res = SSM_E_OUTOFMEMORY;
* @exception
* @see
*/
-INTERFACE_DECLSPEC SSMRESULT CreateInstance(IN const OID &objectID, OUT IBase **ppObject);
+INTERFACE_DECLSPEC SSMRESULT CreateInstance(const OID &objectID, IBase **ppObject);
/**
* @fn createGlobalInstance
* @exception
* @see
*/
-INTERFACE_DECLSPEC SSMRESULT CreateGlobalInstance(IN const OID &objectID, OUT IBase **ppObject);
+INTERFACE_DECLSPEC SSMRESULT CreateGlobalInstance(const OID &objectID, IBase **ppObject);
INTERFACE_DECLSPEC SSMRESULT CreateGlobalInstanceRepo();
}
}
-SSMRESULT CThreadPool::createWorkerThread(OUT IWorkerThread **ppWorkerThread)
+SSMRESULT CThreadPool::createWorkerThread(IWorkerThread **ppWorkerThread)
{
SSMRESULT res = SSM_E_FAIL;
class IThreadPool : public IBase
{
public:
- virtual SSMRESULT createWorkerThread(OUT IWorkerThread **ppWorkerThread) = 0;
+ virtual SSMRESULT createWorkerThread(IWorkerThread **ppWorkerThread) = 0;
virtual SSMRESULT destroyThreadPool() = 0;
};
return SSM_E_NOINTERFACE;
}
- SSMRESULT createWorkerThread(OUT IWorkerThread **ppWorkerThread);
+ SSMRESULT createWorkerThread(IWorkerThread **ppWorkerThread);
SSMRESULT destroyThreadPool();
};
condition = ModelCondition::PREDICATE_EQ;
}
-std::vector<std::string> CCQLParser::tokenize(IN const std::string &input)
+std::vector<std::string> CCQLParser::tokenize(const std::string &input)
{
std::vector<std::string> temp;
temp.push_back(",");
return tokens_temp;
}
-bool CCQLParser::parse(IN std::string input, OUT Token *root)
+bool CCQLParser::parse(std::string input, Token *root)
{
std::vector<std::string> tokens = tokenize(input);
bool flag;//get,sub,if
return true;
}
-std::string CCQLParser::tolower(IN std::string str)
+std::string CCQLParser::tolower(std::string str)
{
for (unsigned int i = 0 ; i < str.size() ; i++)
{
return str;
}
-std::vector<std::string> CCQLParser::getTokens(IN const std::string &str,
- IN const std::string &delimiters)
+std::vector<std::string> CCQLParser::getTokens(const std::string &str,
+ const std::string &delimiters)
{
std::string::size_type lastPos = str.find_first_not_of(delimiters, 0);
std::string::size_type pos = str.find_first_of(delimiters, lastPos);
return tokens;
}
-void CCQLParser::check_index(IN std::string input, OUT Token *token)
+void CCQLParser::check_index(std::string input, Token *token)
{
std::vector<std::string> tokens = getTokens(input, "[");
}
}
-bool CCQLParser::split(IN std::string input, IN Token *root, bool flag, IN std::string arg1,
- IN std::string arg2)
+bool CCQLParser::split(std::string input, Token *root, bool flag, std::string arg1,
+ std::string arg2)
{
std::vector<std::string> tokens = getTokens(input, ".");
Token *temp_token = root;
return true;
}
-int CCQLParser::check_number(IN std::string &str)
+int CCQLParser::check_number(std::string &str)
{
int flag = 0; // 0 text /1 integer /2 real
int dotCount = 0;
return flag;
}
-std::string CCQLParser::check_Predicate(IN std::string input)
+std::string CCQLParser::check_Predicate(std::string input)
{
std::string temp = "";
for (unsigned int i = 0 ; i < input.size() ; i++)
return temp;
}
-bool CCQLParser::check_grammer(IN Token *token)
+bool CCQLParser::check_grammer(Token *token)
{
if (token->child_token.size() == 1 && tolower(token->child_token.at(0).name) == "get")
{
* @exception
* @see
*/
- bool parse(IN std::string input, OUT Token *root);
+ bool parse(std::string input, Token *root);
/**
* @fn tolower
* @exception
* @see
*/
- static std::string tolower(IN std::string str);
+ static std::string tolower(std::string str);
/**
* @fn check_Query_grammer
* @exception
* @see
*/
- bool check_grammer(IN Token *token);
+ bool check_grammer(Token *token);
private:
/**
* @exception
* @see
*/
- std::vector<std::string> tokenize(IN const std::string &input);
+ std::vector<std::string> tokenize(const std::string &input);
/**
* @fn getTokens
* @exception
* @see
*/
- static std::vector<std::string> getTokens(IN const std::string &str,
- IN const std::string &delimiters = " ");
+ static std::vector<std::string> getTokens(const std::string &str,
+ const std::string &delimiters = " ");
/**
* @fn check_index
* @exception
* @see
*/
- void check_index(IN std::string input, OUT Token *token);
+ void check_index(std::string input, Token *token);
/**
* @fn split
* @exception
* @see
*/
- bool split(IN std::string input, IN Token *root, IN bool flag, IN std::string arg1 = "",
- IN std::string arg2 = "");
+ bool split(std::string input, Token *root, bool flag, std::string arg1 = "",
+ std::string arg2 = "");
/**
* @fn check_number
* @exception
* @see
*/
- int check_number(IN std::string &str);
+ int check_number(std::string &str);
/**
* @fn check_Predicate
* @exception
* @see
*/
- std::string check_Predicate(IN std::string input);
+ std::string check_Predicate(std::string input);
};
#endif /*_CQLParser_H_*/
m_triggerId = -1;
}
-SSMRESULT CConditionedModel::create(IN IContextModel *pBaseModel,
- IN ModelConditionVec *pModelConditions)
+SSMRESULT CConditionedModel::create(IContextModel *pBaseModel,
+ ModelConditionVec *pModelConditions)
{
m_watchCondition = *pModelConditions;
return pBaseModel->queryInterface(OID_IContextModel, (IBase **)&m_pBaseModel);
}
-SSMRESULT CConditionedModel::getBaseContextModel(OUT IContextModel **ppBaseContextModel)
+SSMRESULT CConditionedModel::getBaseContextModel(IContextModel **ppBaseContextModel)
{
SSMRESULT res = SSM_E_FAIL;
return res;
}
-SSMRESULT CConditionedModel::registerConditionedModelEvent(IN IConditionedModelEvent
+SSMRESULT CConditionedModel::registerConditionedModelEvent(IConditionedModelEvent
*pConditionedModelEvent)
{
m_pConditionedModelEvent = pConditionedModelEvent;
return SSM_S_OK;
}
-SSMRESULT CConditionedModel::onWatchModelData(IN int triggerId, IN int dataId)
+SSMRESULT CConditionedModel::onWatchModelData(int triggerId, int dataId)
{
SSMRESULT res = SSM_E_FAIL;
return res;
}
-SSMRESULT CConditionedModel::activateTrigger(OUT int *pTriggerId)
+SSMRESULT CConditionedModel::activateTrigger(int *pTriggerId)
{
SSMRESULT res = SSM_E_FAIL;
return ret;
}
-SSMRESULT CConditionedModel::getAffectedData(OUT IntVec *pDataIds)
+SSMRESULT CConditionedModel::getAffectedData(IntVec *pDataIds)
{
SSMRESULT res = SSM_E_FAIL;
return res;
}
-SSMRESULT CConditionedModel::getWatchCondition(OUT ModelConditionVec *pModelConditions)
+SSMRESULT CConditionedModel::getWatchCondition(ModelConditionVec *pModelConditions)
{
*pModelConditions = m_watchCondition;
return SSM_S_OK;
* @exception
* @see
*/
- SSMRESULT create(IN IContextModel *pBaseModel, IN ModelConditionVec *pModelConditions);
+ SSMRESULT create(IContextModel *pBaseModel, ModelConditionVec *pModelConditions);
/**
* @fn onWatchModelData
* @exception
* @see
*/
- SSMRESULT onWatchModelData(IN int triggerId, IN int dataId);
+ SSMRESULT onWatchModelData(int triggerId, int dataId);
SSMRESULT queryInterface(const OID &objectID, IBase **ppObject)
{
* @exception
* @see
*/
- SSMRESULT getBaseContextModel(OUT IContextModel **ppBaseContextModel);
+ SSMRESULT getBaseContextModel(IContextModel **ppBaseContextModel);
/**
* @fn registerConditionedModelEvent
* @exception
* @see
*/
- SSMRESULT registerConditionedModelEvent(IN IConditionedModelEvent *pConditionedModelEvent);
+ SSMRESULT registerConditionedModelEvent(IConditionedModelEvent *pConditionedModelEvent);
/**
* @fn activateTrigger
* @exception
* @see
*/
- SSMRESULT activateTrigger(OUT int *pTriggerId);
+ SSMRESULT activateTrigger(int *pTriggerId);
/**
* @fn deactivateTrigger
* @exception
* @see
*/
- SSMRESULT getAffectedData(OUT IntVec *pDataIds);
+ SSMRESULT getAffectedData(IntVec *pDataIds);
/**
* @fn getWatchCondition
* @exception
* @see
*/
- SSMRESULT getWatchCondition(OUT ModelConditionVec *pModelConditions);
+ SSMRESULT getWatchCondition(ModelConditionVec *pModelConditions);
};
#endif
}
}
-SSMRESULT CConditionedQuery::create(IN IContextModel::ActivationType activationType,
- IN int totalConditionsCount)
+SSMRESULT CConditionedQuery::create(IContextModel::ActivationType activationType,
+ int totalConditionsCount)
{
m_activationType = activationType;
m_untrackedConditionsCount = totalConditionsCount;
return SSM_S_OK;
}
-SSMRESULT CConditionedQuery::registerQueryConditionEvent(IN IConditionedQueryEvent
+SSMRESULT CConditionedQuery::registerQueryConditionEvent(IConditionedQueryEvent
*pConditionedQueryEvent)
{
m_conditionedQueryEvent = pConditionedQueryEvent;
return SSM_S_OK;
}
-SSMRESULT CConditionedQuery::onConditionedModelTriggered(IN int triggerId)
+SSMRESULT CConditionedQuery::onConditionedModelTriggered(int triggerId)
{
SSMRESULT res = SSM_E_FAIL;
int evaluatedConditions = m_conditionedModels.size();
return res;
}
-void CConditionedQuery::onExecute(IN void *pArg)
+void CConditionedQuery::onExecute(void *pArg)
{
if (m_conditionedQueryEvent)
{
}
}
-void CConditionedQuery::onTerminate(IN void *pArg)
+void CConditionedQuery::onTerminate(void *pArg)
{
IConditionedQueryResult *pResult = (IConditionedQueryResult *)pArg;
SAFE_RELEASE(pResult);
}
-SSMRESULT CConditionedQuery::registerConditionedModel(IN IConditionedModel *pConditionedModel)
+SSMRESULT CConditionedQuery::registerConditionedModel(IConditionedModel *pConditionedModel)
{
SSMRESULT res = SSM_E_FAIL;
IContextModel *pContextModel = NULL;
return res;
}
-SSMRESULT CConditionedQuery::activateTriggers(IN int userTriggerId)
+SSMRESULT CConditionedQuery::activateTriggers(int userTriggerId)
{
SSMRESULT res = SSM_E_FAIL;
int triggerId = 0;
return res;
}
-SSMRESULT CConditionedQuery::getConditionedQueryResult(OUT IConditionedQueryResult
+SSMRESULT CConditionedQuery::getConditionedQueryResult(IConditionedQueryResult
**ppConditionedQueryResult)
{
SSMRESULT res = SSM_E_FAIL;
* @exception
* @see
*/
- SSMRESULT create(IN IContextModel::ActivationType activationType, IN int totalConditionsCount);
+ SSMRESULT create(IContextModel::ActivationType activationType, int totalConditionsCount);
/**
* @fn registerQueryConditionEvent
* @exception
* @see
*/
- SSMRESULT registerQueryConditionEvent(IN IConditionedQueryEvent *pConditionedQueryEvent);
+ SSMRESULT registerQueryConditionEvent(IConditionedQueryEvent *pConditionedQueryEvent);
/**
* @fn onConditionedModelTriggered
* @exception
* @see
*/
- SSMRESULT onConditionedModelTriggered(IN int triggerId);
+ SSMRESULT onConditionedModelTriggered(int triggerId);
- void onExecute(IN void *pArg);
+ void onExecute(void *pArg);
- void onTerminate(IN void *pArg);
+ void onTerminate(void *pArg);
SSMRESULT queryInterface(const OID &objectID, IBase **ppObject)
{
* @exception
* @see
*/
- SSMRESULT registerConditionedModel(IN IConditionedModel *pConditionedModel);
+ SSMRESULT registerConditionedModel(IConditionedModel *pConditionedModel);
/**
* @fn activateTriggers
* @exception
* @see
*/
- SSMRESULT activateTriggers(IN int userTriggerId);
+ SSMRESULT activateTriggers(int userTriggerId);
/**
* @fn deactivateTriggers
* @exception
* @see
*/
- SSMRESULT getConditionedQueryResult(OUT IConditionedQueryResult **ppConditionedQueryResult);
+ SSMRESULT getConditionedQueryResult(IConditionedQueryResult **ppConditionedQueryResult);
/**
* @fn hasAllConditionedModels
}
}
-SSMRESULT CConditionedQueryResult::addConditionedModel(IN IConditionedModel *pConditionedModel)
+SSMRESULT CConditionedQueryResult::addConditionedModel(IConditionedModel *pConditionedModel)
{
pConditionedModel->addRef();
m_conditionedModels.push_back(pConditionedModel);
return m_conditionedModels.size();
}
-SSMRESULT CConditionedQueryResult::getConditionedContextModel(IN unsigned int conditionedModelIndex,
- OUT IConditionedModel **ppConditionedModel)
+SSMRESULT CConditionedQueryResult::getConditionedContextModel(unsigned int conditionedModelIndex,
+ IConditionedModel **ppConditionedModel)
{
if (conditionedModelIndex > m_conditionedModels.size() - 1)
{
* @exception
* @see
*/
- SSMRESULT addConditionedModel(IN IConditionedModel *pConditionedModel);
+ SSMRESULT addConditionedModel(IConditionedModel *pConditionedModel);
SSMRESULT queryInterface(const OID &objectID, IBase **ppObject)
{
* @exception
* @see
*/
- SSMRESULT getConditionedContextModel(IN unsigned int conditionedModelIndex,
- OUT IConditionedModel **ppConditionedModel);
+ SSMRESULT getConditionedContextModel(unsigned int conditionedModelIndex,
+ IConditionedModel **ppConditionedModel);
};
#endif
return;
}
-void CContextModel::registerSSMResource(IN ActivationType activationType, IN int targetDeviceDataId,
- IN ISSMResource *pSSMResource)
+void CContextModel::registerSSMResource(ActivationType activationType, int targetDeviceDataId,
+ ISSMResource *pSSMResource)
{
intptr_t *pData = NULL;
m_mtxActivationCount.unlock();
}
-void CContextModel::unregisterSSMResource(IN ActivationType activationType,
- IN int targetDeviceDataId, IN ISSMResource *pSSMResource)
+void CContextModel::unregisterSSMResource(ActivationType activationType,
+ int targetDeviceDataId, ISSMResource *pSSMResource)
{
intptr_t *pData = NULL;
m_mtxActivationCount.unlock();
}
-SSMRESULT CContextModel::create(IN ConstructionType constructionType,
- IN IContextModel *pParentModel, IN std::string modelName, IN ModelPropertyVec *pModelProperties)
+SSMRESULT CContextModel::create(ConstructionType constructionType,
+ IContextModel *pParentModel, std::string modelName, ModelPropertyVec *pModelProperties)
{
SSMRESULT res = SSM_E_FAIL;
int modelId = 1;
return res;
}
-SSMRESULT CContextModel::registerContextModelEvent(IN IContextModelEvent *pContextModelEvent)
+SSMRESULT CContextModel::registerContextModelEvent(IContextModelEvent *pContextModelEvent)
{
m_pContextModelEvent = pContextModelEvent;
return SSM_S_OK;
}
-void CContextModel::onExecute(IN void *pArg)
+void CContextModel::onExecute(void *pArg)
{
intptr_t *pData = (intptr_t *)pArg;
}
}
-void CContextModel::onTerminate(IN void *pArg)
+void CContextModel::onTerminate(void *pArg)
{
intptr_t *pData = (intptr_t *)pArg;
SAFE_ARRAY_DELETE(pData);
}
//TODO: called when new data arrived
-int CContextModel::onEvent(IN std::string deviceID, IN TypeofEvent callType,
- IN std::vector<ContextData> ctxData)
+int CContextModel::onEvent(std::string deviceID, TypeofEvent callType,
+ std::vector<ContextData> ctxData)
{
SSMRESULT res = SSM_E_FAIL;
int dataId = 0;
return m_constructionType;
}
-SSMRESULT CContextModel::getParentDataId(IN int dataId, IN IContextModel *pParentModel,
- OUT int *pParentDataId)
+SSMRESULT CContextModel::getParentDataId(int dataId, IContextModel *pParentModel,
+ int *pParentDataId)
{
return m_pEvaluationEngine->getParentDataId(m_modelId, dataId, pParentModel->getModelId(),
pParentDataId);
}
-SSMRESULT CContextModel::getChildDataId(IN int dataId, IN IContextModel *pChildModel,
- OUT IntVec *pChildDataIds)
+SSMRESULT CContextModel::getChildDataId(int dataId, IContextModel *pChildModel,
+ IntVec *pChildDataIds)
{
return m_pEvaluationEngine->getChildDataId(m_modelId, dataId, pChildModel->getModelId(),
pChildDataIds);
}
-SSMRESULT CContextModel::activate(IN ActivationType activationType, IN int targetDeviceDataId)
+SSMRESULT CContextModel::activate(ActivationType activationType, int targetDeviceDataId)
{
if (targetDeviceDataId < 0 && activationType == ACTIVATION_TYPE_SUBSCRIBE)
{
return SSM_S_OK;
}
-SSMRESULT CContextModel::deactivate(IN ActivationType activationType, IN int targetDeviceDataId)
+SSMRESULT CContextModel::deactivate(ActivationType activationType, int targetDeviceDataId)
{
if (targetDeviceDataId < 0 && activationType == ACTIVATION_TYPE_SUBSCRIBE)
{
return SSM_S_OK;
}
/*
-SSMRESULT CContextModel::GetModelSchema(OUT ModelPropertyVec *pModelProperties)
+SSMRESULT CContextModel::GetModelSchema(ModelPropertyVec *pModelProperties)
{
return m_pEvaluationEngine->GetModelSchema(m_ModelId, pModelProperties);
}
*/
-SSMRESULT CContextModel::addModelData(IN int parentDataId, IN ModelPropertyVec *pData,
- OUT int *pDataId)
+SSMRESULT CContextModel::addModelData(int parentDataId, ModelPropertyVec *pData,
+ int *pDataId)
{
return m_pEvaluationEngine->addModelData(m_modelId, m_pParentModel->getModelId(), parentDataId,
pData, pDataId);
}
-SSMRESULT CContextModel::updateModelData(IN int dataId, IN ModelPropertyVec *pData)
+SSMRESULT CContextModel::updateModelData(int dataId, ModelPropertyVec *pData)
{
return m_pEvaluationEngine->updateModelData(m_modelId, dataId, pData);
}
-SSMRESULT CContextModel::deleteModelData(IN int dataId)
+SSMRESULT CContextModel::deleteModelData(int dataId)
{
return m_pEvaluationEngine->deleteModelData(m_modelId, dataId);
}
-SSMRESULT CContextModel::getModelData(IN int dataId, OUT ModelPropertyVec *pData)
+SSMRESULT CContextModel::getModelData(int dataId, ModelPropertyVec *pData)
{
SSMRESULT res = SSM_E_FAIL;
int i = 0;
return res;
}
-SSMRESULT CContextModel::getModelDataSet(IN int startIndex, IN int count,
- OUT std::vector<ModelPropertyVec> *pDataSet, OUT int *pLastIndex)
+SSMRESULT CContextModel::getModelDataSet(int startIndex, int count,
+ std::vector<ModelPropertyVec> *pDataSet, int *pLastIndex)
{
SSMRESULT res = SSM_E_FAIL;
int i;
return res;
}
-SSMRESULT CContextModel::createConditionedModel(IN ModelConditionVec *pModelConditionVec,
- OUT IConditionedModel **ppConditionedModel)
+SSMRESULT CContextModel::createConditionedModel(ModelConditionVec *pModelConditionVec,
+ IConditionedModel **ppConditionedModel)
{
SSMRESULT res = SSM_E_FAIL;
CObject<CConditionedModel> *pConditionedModel;
*/
//Called new install or re install
-void CContextModel::addSSMResourceAndDeviceDataId(IN std::string deviceId, IN int deviceDataId,
- IN ISSMResource *pSSMResource)
+void CContextModel::addSSMResourceAndDeviceDataId(std::string deviceId, int deviceDataId,
+ ISSMResource *pSSMResource)
{
if (deviceDataId == 1)
{
std::string m_secLifeTime;
- void registerSSMResource(IN ActivationType activationType, IN int targetDeviceDataId,
- IN ISSMResource *pSSMResource);
+ void registerSSMResource(ActivationType activationType, int targetDeviceDataId,
+ ISSMResource *pSSMResource);
- void unregisterSSMResource(IN ActivationType activationType, IN int targetDeviceDataId,
- IN ISSMResource *pSSMResource);
+ void unregisterSSMResource(ActivationType activationType, int targetDeviceDataId,
+ ISSMResource *pSSMResource);
public:
SSMRESULT finalConstruct();
* @exception
* @see
*/
- SSMRESULT create(IN ConstructionType constructionType, IN IContextModel *pParentModel,
- IN std::string modelName, IN ModelPropertyVec *pModelProperties);
+ SSMRESULT create(ConstructionType constructionType, IContextModel *pParentModel,
+ std::string modelName, ModelPropertyVec *pModelProperties);
/**
* @fn registerContextModelEvent
* @exception
* @see
*/
- SSMRESULT registerContextModelEvent(IN IContextModelEvent *pContextModelEvent);
+ SSMRESULT registerContextModelEvent(IContextModelEvent *pContextModelEvent);
- void onExecute(IN void *pArg);
+ void onExecute(void *pArg);
- void onTerminate(IN void *pArg);
+ void onTerminate(void *pArg);
/**
* @fn onEvent
* @exception
* @see
*/
- int onEvent(IN std::string deviceID, IN TypeofEvent callType, IN std::vector<ContextData> ctxData);
+ int onEvent(std::string deviceID, TypeofEvent callType, std::vector<ContextData> ctxData);
SSMRESULT queryInterface(const OID &objectID, IBase **ppObject)
{
* @exception
* @see
*/
- SSMRESULT getParentDataId(IN int dataId, IN IContextModel *pParentModel, OUT int *pParentDataId);
+ SSMRESULT getParentDataId(int dataId, IContextModel *pParentModel, int *pParentDataId);
/**
* @fn getChildDataId
* @exception
* @see
*/
- SSMRESULT getChildDataId(IN int dataId, IN IContextModel *pChildModel, OUT IntVec *pChildDataIds);
+ SSMRESULT getChildDataId(int dataId, IContextModel *pChildModel, IntVec *pChildDataIds);
/**
* @fn activate
* @exception
* @see
*/
- SSMRESULT activate(IN ActivationType activationType, IN int targetDeviceDataId);
+ SSMRESULT activate(ActivationType activationType, int targetDeviceDataId);
/**
* @fn deactivate
* @exception
* @see
*/
- SSMRESULT deactivate(IN ActivationType activationType, IN int targetDeviceDataId);
+ SSMRESULT deactivate(ActivationType activationType, int targetDeviceDataId);
- //SSMRESULT GetModelSchema(OUT ModelPropertyVec *pModelProperties);
+ //SSMRESULT GetModelSchema(ModelPropertyVec *pModelProperties);
/**
* @fn addModelData
* @exception
* @see
*/
- SSMRESULT addModelData(IN int parentDataId, IN ModelPropertyVec *pData, OUT int *pDataId);
+ SSMRESULT addModelData(int parentDataId, ModelPropertyVec *pData, int *pDataId);
/**
* @fn updateModelData
* @exception
* @see
*/
- SSMRESULT updateModelData(IN int dataId, IN ModelPropertyVec *pData);
+ SSMRESULT updateModelData(int dataId, ModelPropertyVec *pData);
/**
* @fn deleteModelData
* @exception
* @see
*/
- SSMRESULT deleteModelData(IN int dataId);
+ SSMRESULT deleteModelData(int dataId);
/**
* @fn getModelData
* @exception
* @see
*/
- SSMRESULT getModelData(IN int dataId, OUT ModelPropertyVec *pData);
+ SSMRESULT getModelData(int dataId, ModelPropertyVec *pData);
/**
* @fn getModelDataSet
* @exception
* @see
*/
- SSMRESULT getModelDataSet(IN int startIndex, IN int count,
- OUT std::vector<ModelPropertyVec> *pDataSet, OUT int *pLastIndex);
+ SSMRESULT getModelDataSet(int startIndex, int count,
+ std::vector<ModelPropertyVec> *pDataSet, int *pLastIndex);
/**
* @fn createConditionedModel
* @exception
* @see
*/
- SSMRESULT createConditionedModel(IN ModelConditionVec *pModelConditionVec,
- OUT IConditionedModel **ppConditionedModel);
+ SSMRESULT createConditionedModel(ModelConditionVec *pModelConditionVec,
+ IConditionedModel **ppConditionedModel);
//SSMRESULT CleanUpModelData();
* @exception
* @see
*/
- void addSSMResourceAndDeviceDataId(IN std::string deviceId, IN int deviceDataId,
- IN ISSMResource *pSSMResource);
+ void addSSMResourceAndDeviceDataId(std::string deviceId, int deviceDataId,
+ ISSMResource *pSSMResource);
/**
* @fn SetLifeTime
{
}
-SSMRESULT CContextQuery::initialize(IN Token &input_root)
+SSMRESULT CContextQuery::initialize(Token &input_root)
{
m_root = input_root;
return CreateGlobalInstance(OID_IPropagationEngine, (IBase **)&m_pPropagationEngine);
}
-std::string CContextQuery::search_last_modelName(IN Token *temp)
+std::string CContextQuery::search_last_modelName(Token *temp)
{
while (true)
{
}
}
-void CContextQuery::integrate_result(OUT std::vector<result_model> *result, IN int modelId,
- IN std::vector<int> *dataid, IN std::string modelName)
+void CContextQuery::integrate_result(std::vector<result_model> *result, int modelId,
+ std::vector<int> *dataid, std::string modelName)
{
bool flag = false;
-void CContextQuery::return_contextName(OUT std::vector<std::string> *contextName)
+void CContextQuery::return_contextName(std::vector<std::string> *contextName)
{
int k = m_root.child_token.at(0).child_token.size();
}
}
-void CContextQuery::return_modelID(OUT std::vector<int> *vector_int)
+void CContextQuery::return_modelID(std::vector<int> *vector_int)
{
int k = m_root.child_token.at(0).child_token.size();
}
}
-void CContextQuery::make_QueryCondition(OUT QueryCondition *result)
+void CContextQuery::make_QueryCondition(QueryCondition *result)
{
if (m_root.child_token.size() < 2)
* @exception
* @see
*/
- SSMRESULT initialize(IN Token &input_root);
+ SSMRESULT initialize(Token &input_root);
/**
* @fn integrate_result
* @exception
* @see
*/
- void integrate_result(OUT std::vector<result_model> *result, IN int modelId,
- IN std::vector<int> *dataid, IN std::string modelName);
+ void integrate_result(std::vector<result_model> *result, int modelId,
+ std::vector<int> *dataid, std::string modelName);
/**
* @fn return_contextName
* @exception
* @see
*/
- void return_contextName(OUT std::vector<std::string> *contextName);
+ void return_contextName(std::vector<std::string> *contextName);
/**
* @fn check_result_model
* @exception
* @see
*/
- void return_modelID(OUT std::vector<int> *vector_int);
+ void return_modelID(std::vector<int> *vector_int);
/**
* @fn make_QueryCondition
* @exception
* @see
*/
- void make_QueryCondition(OUT QueryCondition *result);
+ void make_QueryCondition(QueryCondition *result);
private:
/**
* @exception
* @see
*/
- std::string search_last_modelName(IN Token *temp);
+ std::string search_last_modelName(Token *temp);
Token m_root;
CObjectPtr<IPropagationEngine> m_pPropagationEngine;
}
}
-SSMRESULT CDataReader::addModelData(IN std::string modelName,
- IN std::vector<CModelData *> *pModelData)
+SSMRESULT CDataReader::addModelData(std::string modelName,
+ std::vector<CModelData *> *pModelData)
{
m_modelDataList[modelName] = *pModelData;
return SSM_S_OK;
}
-SSMRESULT CDataReader::getAffectedModels(OUT std::vector<std::string> *pAffectedModels)
+SSMRESULT CDataReader::getAffectedModels(std::vector<std::string> *pAffectedModels)
{
for (std::map<std::string, std::vector<CModelData *> >::iterator itorModel =
m_modelDataList.begin();
return SSM_S_OK;
}
-SSMRESULT CDataReader::getModelDataCount(IN std::string modelName, OUT int *pDataCount)
+SSMRESULT CDataReader::getModelDataCount(std::string modelName, int *pDataCount)
{
std::map<std::string, std::vector<CModelData *> >::iterator itor;
return SSM_S_OK;
}
-SSMRESULT CDataReader::getModelData(IN std::string modelName, IN int dataIndex,
- OUT IModelData **ppModelData)
+SSMRESULT CDataReader::getModelData(std::string modelName, int dataIndex,
+ IModelData **ppModelData)
{
std::map<std::string, std::vector<CModelData *> >::iterator itor;
* @exception
* @see
*/
- SSMRESULT addModelData(IN std::string modelName, IN std::vector<CModelData *> *pModelData);
+ SSMRESULT addModelData(std::string modelName, std::vector<CModelData *> *pModelData);
/**
* @fn getAffectedModels
* @exception
* @see
*/
- SSMRESULT getAffectedModels(OUT std::vector<std::string> *pAffectedModels);
+ SSMRESULT getAffectedModels(std::vector<std::string> *pAffectedModels);
/**
* @fn getModelDataCount
* @exception
* @see
*/
- SSMRESULT getModelDataCount(IN std::string modelName, OUT int *pDataCount);
+ SSMRESULT getModelDataCount(std::string modelName, int *pDataCount);
/**
* @fn getModelData
* @exception
* @see
*/
- SSMRESULT getModelData(IN std::string modelName, IN int dataIndex, OUT IModelData **ppModelData);
+ SSMRESULT getModelData(std::string modelName, int dataIndex, IModelData **ppModelData);
};
#endif
terminateEngine();
}
-SSMRESULT CEvaluationEngine::executeSQL_NoReturn(IN std::string strSQL)
+SSMRESULT CEvaluationEngine::executeSQL_NoReturn(std::string strSQL)
{
SSMRESULT res = SSM_E_FAIL;
sqlite3_stmt *stmt = NULL;
return res;
}
-SSMRESULT CEvaluationEngine::executeSQL_IntReturn(IN std::string strSQL, OUT int *pResult)
+SSMRESULT CEvaluationEngine::executeSQL_IntReturn(std::string strSQL, int *pResult)
{
SSMRESULT res = SSM_E_FAIL;
sqlite3_stmt *stmt = NULL;
return res;
}
-void CEvaluationEngine::onSQLTrigger(IN sqlite3_context *context, IN int argc,
- IN sqlite3_value **argv)
+void CEvaluationEngine::onSQLTrigger(sqlite3_context *context, int argc,
+ sqlite3_value **argv)
{
CEvaluationEngine *pEvaluationEngine = (CEvaluationEngine *)sqlite3_value_int64(argv[0]);
pEvaluationEngine->onWatcherTriggered(sqlite3_value_int(argv[1]), sqlite3_value_int(argv[2]));
}
-void CEvaluationEngine::onExecute(IN void *pArg)
+void CEvaluationEngine::onExecute(void *pArg)
{
std::map<int, IEvaluationEngineEvent *>::iterator itor;
intptr_t *pData = (intptr_t *)pArg;
m_mtxTriggerId.unlock();
}
-void CEvaluationEngine::onTerminate(IN void *pArg)
+void CEvaluationEngine::onTerminate(void *pArg)
{
intptr_t *pData = (intptr_t *)pArg;
SAFE_ARRAY_DELETE(pData);
}
-SSMRESULT CEvaluationEngine::onWatcherTriggered(IN int triggerId, IN int dataId)
+SSMRESULT CEvaluationEngine::onWatcherTriggered(int triggerId, int dataId)
{
intptr_t *pData = new intptr_t[2];
pData[0] = triggerId;
return;
}
-SSMRESULT CEvaluationEngine::createModel(IN int parentModelId, IN const char *newModelName,
- IN ModelPropertyVec *pModelDescs, OUT int *pModelId)
+SSMRESULT CEvaluationEngine::createModel(int parentModelId, const char *newModelName,
+ ModelPropertyVec *pModelDescs, int *pModelId)
{
SSMRESULT res = SSM_E_FAIL;
std::stringstream sstream;
return res;
}
-SSMRESULT CEvaluationEngine::addModelData(IN int modelId, IN int parentModelId, IN int parentDataId,
- IN ModelPropertyVec *pModelValues, OUT int *pDataId)
+SSMRESULT CEvaluationEngine::addModelData(int modelId, int parentModelId, int parentDataId,
+ ModelPropertyVec *pModelValues, int *pDataId)
{
SSMRESULT res = SSM_E_FAIL;
std::stringstream sstream;
return res;
}
-SSMRESULT CEvaluationEngine::updateModelData(IN int modelId, IN int dataId,
- IN ModelPropertyVec *pModelValues)
+SSMRESULT CEvaluationEngine::updateModelData(int modelId, int dataId,
+ ModelPropertyVec *pModelValues)
{
SSMRESULT res = SSM_E_FAIL;
std::stringstream sstream;
return res;
}
/*
-SSMRESULT CEvaluationEngine::DeleteModel(IN int modelId)
+SSMRESULT CEvaluationEngine::DeleteModel(int modelId)
{
SSMRESULT res = SSM_E_FAIL;
std::stringstream sstream;
return res;
}
*/
-SSMRESULT CEvaluationEngine::deleteModelData(IN int modelId, IN int dataId)
+SSMRESULT CEvaluationEngine::deleteModelData(int modelId, int dataId)
{
SSMRESULT res = SSM_E_FAIL;
std::stringstream sstream;
return res;
}
-SSMRESULT CEvaluationEngine::getModelDataSet(IN int modelId, IN int startIndex, IN int count,
- OUT std::vector<ModelPropertyVec> *pDataSet, OUT int *pLastIndex)
+SSMRESULT CEvaluationEngine::getModelDataSet(int modelId, int startIndex, int count,
+ std::vector<ModelPropertyVec> *pDataSet, int *pLastIndex)
{
SSMRESULT res = SSM_E_FAIL;
std::stringstream sstream;
return res;
}
-SSMRESULT CEvaluationEngine::getModelData(IN int modelId, IN int dataId,
- OUT ModelPropertyVec *pModelProperties)
+SSMRESULT CEvaluationEngine::getModelData(int modelId, int dataId,
+ ModelPropertyVec *pModelProperties)
{
SSMRESULT res = SSM_E_FAIL;
std::stringstream sstream;
return res;
}
/*
-SSMRESULT CEvaluationEngine::GetModelSchema(IN int modelId, OUT ModelPropertyVec *pModelProperties)
+SSMRESULT CEvaluationEngine::GetModelSchema(int modelId, ModelPropertyVec *pModelProperties)
{
SSMRESULT res = SSM_E_FAIL;
std::stringstream sstream;
return res;
}
*/
-SSMRESULT CEvaluationEngine::getConditionedModelData(IN int modelId,
- IN ModelConditionVec *pModelConditions, OUT IntVec *pDataIds)
+SSMRESULT CEvaluationEngine::getConditionedModelData(int modelId,
+ ModelConditionVec *pModelConditions, IntVec *pDataIds)
{
SSMRESULT res = SSM_E_FAIL;
std::stringstream sstream;
return res;
}
-SSMRESULT CEvaluationEngine::watchModelData(IN int modelId, IN ModelConditionVec *pModelConditions,
- IN IEvaluationEngineEvent *pEvaluationEngineEvent, OUT int *pTriggerId)
+SSMRESULT CEvaluationEngine::watchModelData(int modelId, ModelConditionVec *pModelConditions,
+ IEvaluationEngineEvent *pEvaluationEngineEvent, int *pTriggerId)
{
SSMRESULT res = SSM_E_FAIL;
std::stringstream sstream;
return res;
}
-SSMRESULT CEvaluationEngine::dropWatchModelData(IN int triggerId)
+SSMRESULT CEvaluationEngine::dropWatchModelData(int triggerId)
{
SSMRESULT res = SSM_E_FAIL;
std::stringstream sstream;
return res;
}
-SSMRESULT CEvaluationEngine::getParentDataId(IN int modelId, IN int dataId, IN int parentModelId,
- OUT int *pParentDataId)
+SSMRESULT CEvaluationEngine::getParentDataId(int modelId, int dataId, int parentModelId,
+ int *pParentDataId)
{
SSMRESULT res = SSM_E_FAIL;
std::stringstream sstream;
return res;
}
-SSMRESULT CEvaluationEngine::getChildDataId(IN int modelId, IN int dataId, IN int ChildModelId,
- OUT IntVec *pChildDataIds)
+SSMRESULT CEvaluationEngine::getChildDataId(int modelId, int dataId, int ChildModelId,
+ IntVec *pChildDataIds)
{
SSMRESULT res = SSM_E_FAIL;
std::stringstream sstream;
return res;
}
/*
-SSMRESULT CEvaluationEngine::GetPathToRoot(IN int currentModelId, OUT IntVec *pPath)
+SSMRESULT CEvaluationEngine::GetPathToRoot(int currentModelId, IntVec *pPath)
{
SSMRESULT res = SSM_E_FAIL;
std::stringstream sstream;
return res;
}
-SSMRESULT CEvaluationEngine::GetModelId(IN const char *modelName, OUT int *pModelId)
+SSMRESULT CEvaluationEngine::GetModelId(const char *modelName, int *pModelId)
{
SSMRESULT res = SSM_E_FAIL;
std::stringstream sstream;
return res;
}
-SSMRESULT CEvaluationEngine::GetModelHierarchy(IN int rootModelId, OUT StringVec *pPath)
+SSMRESULT CEvaluationEngine::GetModelHierarchy(int rootModelId, StringVec *pPath)
{
SSMRESULT res = SSM_E_FAIL;
std::stringstream sstream;
return res;
}
-SSMRESULT CEvaluationEngine::GetDataHierarchy(IN int rootModelId, IN int dataId, OUT StringVec *pPath)
+SSMRESULT CEvaluationEngine::GetDataHierarchy(int rootModelId, int dataId, StringVec *pPath)
{
SSMRESULT res = SSM_E_FAIL;
std::stringstream sstream;
CSimpleMutex m_mtxDataRelation;
CObjectPtr<ITasker> m_pTasker;
- SSMRESULT executeSQL_NoReturn(IN std::string strSQL);
+ SSMRESULT executeSQL_NoReturn(std::string strSQL);
- SSMRESULT executeSQL_IntReturn(IN std::string strSQL, OUT int *pResult);
+ SSMRESULT executeSQL_IntReturn(std::string strSQL, int *pResult);
- static void onSQLTrigger(IN sqlite3_context *context, IN int argc, IN sqlite3_value **argv);
+ static void onSQLTrigger(sqlite3_context *context, int argc, sqlite3_value **argv);
SSMRESULT initializeEngine();
void finalRelease();
- void onExecute(IN void *pArg);
+ void onExecute(void *pArg);
- void onTerminate(IN void *pArg);
+ void onTerminate(void *pArg);
/**
* @fn onWatcherTriggered
* @exception
* @see
*/
- SSMRESULT onWatcherTriggered(IN int triggerId, IN int dataId);
+ SSMRESULT onWatcherTriggered(int triggerId, int dataId);
SSMRESULT queryInterface(const OID &objectID, IBase **ppObject)
{
* @exception
* @see
*/
- SSMRESULT createModel(IN int parentModelId, IN const char *newModelName,
- IN ModelPropertyVec *pModelDescs, OUT int *pModelId);
+ SSMRESULT createModel(int parentModelId, const char *newModelName,
+ ModelPropertyVec *pModelDescs, int *pModelId);
/**
* @fn addModelData
* @exception
* @see
*/
- SSMRESULT addModelData(IN int modelId, IN int parentModelId, IN int parentDataId,
- IN ModelPropertyVec *pModelValues, OUT int *pDataId);
+ SSMRESULT addModelData(int modelId, int parentModelId, int parentDataId,
+ ModelPropertyVec *pModelValues, int *pDataId);
/**
* @fn updateModelData
* @exception
* @see
*/
- SSMRESULT updateModelData(IN int modelId, IN int dataId, IN ModelPropertyVec *pModelValues);
+ SSMRESULT updateModelData(int modelId, int dataId, ModelPropertyVec *pModelValues);
- //SSMRESULT DeleteModel(IN int modelId);
+ //SSMRESULT DeleteModel(int modelId);
/**
* @fn deleteModelData
* @exception
* @see
*/
- SSMRESULT deleteModelData(IN int modelId, IN int dataId);
+ SSMRESULT deleteModelData(int modelId, int dataId);
/**
* @fn getModelData
* @exception
* @see
*/
- SSMRESULT getModelData(IN int modelId, IN int dataId, OUT ModelPropertyVec *pModelProperties);
+ SSMRESULT getModelData(int modelId, int dataId, ModelPropertyVec *pModelProperties);
/**
* @fn getModelDataSet
* @exception
* @see
*/
- SSMRESULT getModelDataSet(IN int modelId, IN int startIndex, IN int count,
- OUT std::vector<ModelPropertyVec> *pDataSet, OUT int *pLastIndex);
+ SSMRESULT getModelDataSet(int modelId, int startIndex, int count,
+ std::vector<ModelPropertyVec> *pDataSet, int *pLastIndex);
- //SSMRESULT GetModelSchema(IN int modelId, OUT ModelPropertyVec *pModelProperties);
+ //SSMRESULT GetModelSchema(int modelId, ModelPropertyVec *pModelProperties);
/**
* @fn getConditionedModelData
* @exception
* @see
*/
- SSMRESULT getConditionedModelData(IN int modelId, IN ModelConditionVec *pModelConditions,
- OUT IntVec *pDataIds);
+ SSMRESULT getConditionedModelData(int modelId, ModelConditionVec *pModelConditions,
+ IntVec *pDataIds);
/**
* @fn watchModelData
* @exception
* @see
*/
- SSMRESULT watchModelData(IN int modelId, IN ModelConditionVec *pModelConditions,
- IN IEvaluationEngineEvent *pEvaluationEngineEvent, OUT int *pTriggerId);
+ SSMRESULT watchModelData(int modelId, ModelConditionVec *pModelConditions,
+ IEvaluationEngineEvent *pEvaluationEngineEvent, int *pTriggerId);
/**
* @fn dropWatchModelData
* @exception
* @see
*/
- SSMRESULT dropWatchModelData(IN int triggerId);
+ SSMRESULT dropWatchModelData(int triggerId);
/**
* @fn getParentDataId
* @exception
* @see
*/
- SSMRESULT getParentDataId(IN int modelId, IN int dataId, IN int parentModelId,
- OUT int *pParentDataId);
+ SSMRESULT getParentDataId(int modelId, int dataId, int parentModelId,
+ int *pParentDataId);
/**
* @fn getChildDataId
* @exception
* @see
*/
- SSMRESULT getChildDataId(IN int modelId, IN int dataId, IN int childModelId,
- OUT IntVec *pChildDataIds);
+ SSMRESULT getChildDataId(int modelId, int dataId, int childModelId,
+ IntVec *pChildDataIds);
- //SSMRESULT GetPathToRoot(IN int currentModelId, OUT IntVec *pPath);
+ //SSMRESULT GetPathToRoot(int currentModelId, IntVec *pPath);
- //SSMRESULT GetModelId(IN const char *modelName, OUT int *pModelId);
+ //SSMRESULT GetModelId(const char *modelName, int *pModelId);
- //SSMRESULT GetModelHierarchy(IN int rootModelId, OUT StringVec *pPath);
+ //SSMRESULT GetModelHierarchy(int rootModelId, StringVec *pPath);
- //SSMRESULT GetDataHierarchy(IN int rootModelId, IN int dataId, OUT StringVec *pPath);
+ //SSMRESULT GetDataHierarchy(int rootModelId, int dataId, StringVec *pPath);
};
#endif
}
-void CModelData::setDataId(IN int dataId)
+void CModelData::setDataId(int dataId)
{
m_dataId = dataId;
}
-void CModelData::addModelData(IN std::string propertyName, IN std::string propertyValue)
+void CModelData::addModelData(std::string propertyName, std::string propertyValue)
{
m_properties[propertyName] = propertyValue;
}
return m_properties.size();
}
-std::string CModelData::getPropertyName(IN int propertyIndex)
+std::string CModelData::getPropertyName(int propertyIndex)
{
std::map<std::string, std::string>::iterator idxProperty = m_properties.begin();
for (int i = 0; i < propertyIndex; i++)
return idxProperty->first;
}
-std::string CModelData::getPropertyValue(IN int propertyIndex)
+std::string CModelData::getPropertyValue(int propertyIndex)
{
std::map<std::string, std::string>::iterator idxProperty = m_properties.begin();
for (int i = 0; i < propertyIndex; i++)
return idxProperty->second;
}
-std::string CModelData::getPropertyValueByName(IN std::string propertyName)
+std::string CModelData::getPropertyValueByName(std::string propertyName)
{
return m_properties[propertyName];
}
* @exception
* @see
*/
- void setDataId(IN int dataId);
+ void setDataId(int dataId);
/**
* @fn addModelData
* @exception
* @see
*/
- void addModelData(IN std::string propertyName, IN std::string propertyValue);
+ void addModelData(std::string propertyName, std::string propertyValue);
/**
* @fn getDataId
* @exception
* @see
*/
- std::string getPropertyName(IN int propertyIndex);
+ std::string getPropertyName(int propertyIndex);
/**
* @fn getPropertyValue
* @exception
* @see
*/
- std::string getPropertyValue(IN int propertyIndex);
+ std::string getPropertyValue(int propertyIndex);
/**
* @fn getPropertyValueByName
* @exception
* @see
*/
- std::string getPropertyValueByName(IN std::string propertyName);
+ std::string getPropertyValueByName(std::string propertyName);
};
#endif
}
}
-SSMRESULT CPropagationEngine::findContextModel(IN std::string modelName,
- OUT IContextModel **ppContextModel)
+SSMRESULT CPropagationEngine::findContextModel(std::string modelName,
+ IContextModel **ppContextModel)
{
SSMRESULT res = SSM_S_FALSE;
std::map<std::string, IContextModel *>::iterator idxContextModel;
return res;
}
-SSMRESULT CPropagationEngine::registerCondition(IN IContextModel *pContextModel,
- IN ModelConditionVec *pConditions, IN IConditionedQuery *pConditionedQuery)
+SSMRESULT CPropagationEngine::registerCondition(IContextModel *pContextModel,
+ ModelConditionVec *pConditions, IConditionedQuery *pConditionedQuery)
{
SSMRESULT res = SSM_E_FAIL;
IConditionedModel *pConditionedModel = NULL;
return res;
}
-SSMRESULT CPropagationEngine::registerVirtualCondition(IN std::string virtualContextModelName,
- IN ModelConditionVec *pConditions, IN IConditionedQuery *pConditionedQuery)
+SSMRESULT CPropagationEngine::registerVirtualCondition(std::string virtualContextModelName,
+ ModelConditionVec *pConditions, IConditionedQuery *pConditionedQuery)
{
pConditionedQuery->addRef();
m_mtxLookUpList.lock();
return SSM_S_OK;
}
-SSMRESULT CPropagationEngine::propagateNewModel(IN std::string newModelName,
- IN IContextModel *pContextModel)
+SSMRESULT CPropagationEngine::propagateNewModel(std::string newModelName,
+ IContextModel *pContextModel)
{
SSMRESULT res = SSM_E_FAIL;
VirtualModelMap::iterator itorVModels;
}
//Install new resource and update Device table
-SSMRESULT CPropagationEngine::installContextModelFromISSMResource(IN ISSMResource *pSSMResource)
+SSMRESULT CPropagationEngine::installContextModelFromISSMResource(ISSMResource *pSSMResource)
{
SSMRESULT res = SSM_E_FAIL;
return res;
}
-SSMRESULT CPropagationEngine::updateDeviceInfo(IN ISSMResource *pSSMResource, OUT int *deviceId)
+SSMRESULT CPropagationEngine::updateDeviceInfo(ISSMResource *pSSMResource, int *deviceId)
{
SSMRESULT res = SSM_E_FAIL;
return res;
}
-SSMRESULT CPropagationEngine::installContextModel(IN IContextModel *pParentModel,
- IN IContextModel::ConstructionType constructionType, IN const char *modelName,
- IN ModelPropertyVec *pModelDescs, OUT IContextModel **ppContextModel)
+SSMRESULT CPropagationEngine::installContextModel(IContextModel *pParentModel,
+ IContextModel::ConstructionType constructionType, const char *modelName,
+ ModelPropertyVec *pModelDescs, IContextModel **ppContextModel)
{
SSMRESULT res = SSM_E_FAIL;
CObject<CContextModel> *pNewModel;
return res;
}
-void CPropagationEngine::onExecute(IN void *pArg)
+void CPropagationEngine::onExecute(void *pArg)
{
SSMRESULT res = SSM_E_FAIL;
;
}
-void CPropagationEngine::onTerminate(IN void *pArg)
+void CPropagationEngine::onTerminate(void *pArg)
{
intptr_t *pMessage = (intptr_t *)pArg;
delete[] pMessage;
}
-int CPropagationEngine::onResourceEvent(IN RESOURCE_EVENT_TYPE eventType,
- IN ISSMResource *pSSMResource, IN std::string info)
+int CPropagationEngine::onResourceEvent(RESOURCE_EVENT_TYPE eventType,
+ ISSMResource *pSSMResource, std::string info)
{
intptr_t *pMessage = new intptr_t [2];
return;
}
-SSMRESULT CPropagationEngine::getContextModel(IN std:: string modelName,
- OUT IContextModel **ppContextModel)
+SSMRESULT CPropagationEngine::getContextModel(std:: string modelName,
+ IContextModel **ppContextModel)
{
SSMRESULT res = SSM_E_FAIL;
return res == SSM_S_OK ? SSM_S_OK : SSM_E_FAIL;
}
-SSMRESULT CPropagationEngine::createConditionedQuery(IN IContextModel::ActivationType
- activationType, IN QueryCondition *pQueryCondition, IN IConditionedQueryEvent *pEvent,
- OUT IConditionedQuery **ppConditionedQuery)
+SSMRESULT CPropagationEngine::createConditionedQuery(IContextModel::ActivationType
+ activationType, QueryCondition *pQueryCondition, IConditionedQueryEvent *pEvent,
+ IConditionedQuery **ppConditionedQuery)
{
SSMRESULT res = SSM_E_FAIL;
CObject<CConditionedQuery> *pConditionedQuery;
return res;
}
-SSMRESULT CPropagationEngine::onModelStatusChange(IN IContextModel::Status newStatus,
- IN ISSMResource *pSSMResource, IN IContextModel *pModel)
+SSMRESULT CPropagationEngine::onModelStatusChange(IContextModel::Status newStatus,
+ ISSMResource *pSSMResource, IContextModel *pModel)
{
switch (newStatus)
{
return SSM_S_OK;
}
-SSMRESULT CPropagationEngine::onQueryContextModel(IN std::string modelName,
- OUT IContextModel **ppContextModel)
+SSMRESULT CPropagationEngine::onQueryContextModel(std::string modelName,
+ IContextModel **ppContextModel)
{
std::map<std::string, IContextModel *>::iterator itorContextModel;
std::map<std::string, int> m_searchedSensorDataId;
- SSMRESULT findContextModel(IN std::string modelName, OUT IContextModel **ppContextModel);
+ SSMRESULT findContextModel(std::string modelName, IContextModel **ppContextModel);
- SSMRESULT registerCondition(IN IContextModel *pContextModel, IN ModelConditionVec *pConditions,
- IN IConditionedQuery *pConditionedQuery);
+ SSMRESULT registerCondition(IContextModel *pContextModel, ModelConditionVec *pConditions,
+ IConditionedQuery *pConditionedQuery);
- SSMRESULT registerVirtualCondition(IN std::string virtualContextModelName,
- IN ModelConditionVec *pConditions, IN IConditionedQuery *pConditionedQuery);
+ SSMRESULT registerVirtualCondition(std::string virtualContextModelName,
+ ModelConditionVec *pConditions, IConditionedQuery *pConditionedQuery);
- SSMRESULT propagateNewModel(IN std::string newModelName, IN IContextModel *pContextModel);
+ SSMRESULT propagateNewModel(std::string newModelName, IContextModel *pContextModel);
SSMRESULT addResourceFromGetList();
//TODO: Install Context model from SSMResource
SSMRESULT installCurrentSensors();
- SSMRESULT installContextModelFromISSMResource(IN ISSMResource *pSSMResource);
+ SSMRESULT installContextModelFromISSMResource(ISSMResource *pSSMResource);
- SSMRESULT installContextModel(IN IContextModel *pParentModel,
- IN IContextModel::ConstructionType constructionType,
- IN const char *modelName, IN ModelPropertyVec *pModelDescs, OUT IContextModel **ppContextModel);
+ SSMRESULT installContextModel(IContextModel *pParentModel,
+ IContextModel::ConstructionType constructionType,
+ const char *modelName, ModelPropertyVec *pModelDescs, IContextModel **ppContextModel);
SSMRESULT recoverEngineFromDatabase();
void terminateEngine();
- SSMRESULT updateDeviceInfo(IN ISSMResource *pSSMResource, OUT int *deviceId);
+ SSMRESULT updateDeviceInfo(ISSMResource *pSSMResource, int *deviceId);
public:
SSMRESULT finalConstruct();
void finalRelease();
- void onExecute(IN void *pArg);
+ void onExecute(void *pArg);
- void onTerminate(IN void *pArg);
+ void onTerminate(void *pArg);
/**
* @fn onResourceEvent
* @exception
* @see
*/
- int onResourceEvent(IN RESOURCE_EVENT_TYPE eventType, IN ISSMResource *pSSMResource,
- IN std::string info);
+ int onResourceEvent(RESOURCE_EVENT_TYPE eventType, ISSMResource *pSSMResource,
+ std::string info);
SSMRESULT queryInterface(const OID &objectID, IBase **ppObject)
{
* @exception
* @see
*/
- SSMRESULT getContextModel(IN std::string modelName, OUT IContextModel **ppContextModel);
+ SSMRESULT getContextModel(std::string modelName, IContextModel **ppContextModel);
/**
* @fn createConditionedQuery
* @exception
* @see
*/
- SSMRESULT createConditionedQuery(IN IContextModel::ActivationType activationType,
- IN QueryCondition *pQueryCondition,
- IN IConditionedQueryEvent *pEvent, OUT IConditionedQuery **ppConditionedQuery);
+ SSMRESULT createConditionedQuery(IContextModel::ActivationType activationType,
+ QueryCondition *pQueryCondition,
+ IConditionedQueryEvent *pEvent, IConditionedQuery **ppConditionedQuery);
/**
* @fn onModelStatusChange
* @exception
* @see
*/
- SSMRESULT onModelStatusChange(IN IContextModel::Status newStatus, IN ISSMResource *pSSMResource,
- IN IContextModel *pModel);
+ SSMRESULT onModelStatusChange(IContextModel::Status newStatus, ISSMResource *pSSMResource,
+ IContextModel *pModel);
/**
* @fn onQueryContextModel
* @exception
* @see
*/
- SSMRESULT onQueryContextModel(IN std::string modelName, OUT IContextModel **ppContextModel);
+ SSMRESULT onQueryContextModel(std::string modelName, IContextModel **ppContextModel);
};
#endif
m_mtxQueries.unlock();
}
-SSMRESULT CQueryEngine::processQueryResult(IN int userTriggerId,
- IN std::vector<result_model> *result)
+SSMRESULT CQueryEngine::processQueryResult(int userTriggerId,
+ std::vector<result_model> *result)
{
SSMRESULT res = SSM_E_FAIL;
ModelPropertyVec modelData;
return res;
}
-SSMRESULT CQueryEngine::validateQueryResult(IN IConditionedQueryResult *pConditionedQueryResult,
- OUT std::vector<result_model> *resultData)
+SSMRESULT CQueryEngine::validateQueryResult(IConditionedQueryResult *pConditionedQueryResult,
+ std::vector<result_model> *resultData)
{
SSMRESULT res = SSM_E_FAIL;
IContextModel *pContextModel = NULL;
return res;
}
-SSMRESULT CQueryEngine::onConditionedQueryEvent(IN int userTriggerId,
- IN IConditionedQueryResult *pConditionedQueryResult)
+SSMRESULT CQueryEngine::onConditionedQueryEvent(int userTriggerId,
+ IConditionedQueryResult *pConditionedQueryResult)
{
SSMRESULT res = SSM_E_FAIL;
std::vector<result_model> result;
SAFE_ARRAY_DELETE(pData);
}
-SSMRESULT CQueryEngine::executeContextQuery(IN std::string contextQuery, OUT int *cqid)
+SSMRESULT CQueryEngine::executeContextQuery(std::string contextQuery, int *cqid)
{
SSMRESULT res = SSM_E_FAIL;
IConditionedQuery *pConditionedQuery = NULL;
}
//TODO: Registration with multiple instance support
-SSMRESULT CQueryEngine::registerQueryEvent(IN IQueryEngineEvent *pQueryEngineEvent)
+SSMRESULT CQueryEngine::registerQueryEvent(IQueryEngineEvent *pQueryEngineEvent)
{
m_pQueryEngineEvent = pQueryEngineEvent;
return SSM_S_OK;
}
-SSMRESULT CQueryEngine::unregisterQueryEvent(IN IQueryEngineEvent *pQueryEngineEvent)
+SSMRESULT CQueryEngine::unregisterQueryEvent(IQueryEngineEvent *pQueryEngineEvent)
{
if (m_pQueryEngineEvent == pQueryEngineEvent)
{
return SSM_E_FAIL;
}
-SSMRESULT CQueryEngine::killContextQuery(IN int cqid)
+SSMRESULT CQueryEngine::killContextQuery(int cqid)
{
SSMRESULT res = SSM_E_FAIL;
CObjectPtr<ITasker> m_pTasker;
private:
- SSMRESULT processQueryResult(IN int userTriggerId, IN std::vector<result_model> *result);
- SSMRESULT validateQueryResult(IN IConditionedQueryResult *pConditionedQueryResult,
- OUT std::vector<result_model> *resultData);
+ SSMRESULT processQueryResult(int userTriggerId, std::vector<result_model> *result);
+ SSMRESULT validateQueryResult(IConditionedQueryResult *pConditionedQueryResult,
+ std::vector<result_model> *resultData);
public:
enum EventType {EVENT_TYPE_INNER, EVENT_TYPE_OUTER};
* @exception
* @see
*/
- SSMRESULT onConditionedQueryEvent(IN int userTriggerId,
- IN IConditionedQueryResult *pConditionedQueryResult);
+ SSMRESULT onConditionedQueryEvent(int userTriggerId,
+ IConditionedQueryResult *pConditionedQueryResult);
SSMRESULT queryInterface(const OID &objectID, IBase **ppObject)
{
* @exception
* @see
*/
- SSMRESULT executeContextQuery(IN std::string contextQuery, OUT int *cqid);
+ SSMRESULT executeContextQuery(std::string contextQuery, int *cqid);
//TODO: Registration with multiple instance support
/**
* @exception
* @see
*/
- SSMRESULT registerQueryEvent(IN IQueryEngineEvent *pQueryEngineEvent);
+ SSMRESULT registerQueryEvent(IQueryEngineEvent *pQueryEngineEvent);
/**
* @exception
* @see
*/
- SSMRESULT unregisterQueryEvent(IN IQueryEngineEvent *pQueryEngineEvent);
+ SSMRESULT unregisterQueryEvent(IQueryEngineEvent *pQueryEngineEvent);
/**
* @fn killContextQuery
* @exception
* @see
*/
- SSMRESULT killContextQuery(IN int cqid);
+ SSMRESULT killContextQuery(int cqid);
};
#endif /*_QueryEngine_H_*/
static ISoftSensorManager *g_pSoftSensorManager = NULL;
-SSMRESULT CreateQueryEngine(OUT IQueryEngine **ppQueryEngine)
+SSMRESULT CreateQueryEngine(IQueryEngine **ppQueryEngine)
{
SSMRESULT res = SSM_E_FAIL;
return res;
}
-unsigned long ReleaseQueryEngine(IN IQueryEngine *pQueryEngine)
+unsigned long ReleaseQueryEngine(IQueryEngine *pQueryEngine)
{
if (pQueryEngine == NULL)
{
return g_pSoftSensorManager->releaseQueryEngine(pQueryEngine);
}
-SSMRESULT InitializeSSMCore(IN std::string xmlDescription)
+SSMRESULT InitializeSSMCore(std::string xmlDescription)
{
SSMRESULT res = SSM_E_FAIL;
return msg;
}
-SSMRESULT GetInstalledModelList(OUT std::vector<ISSMResource *> *pList)
+SSMRESULT GetInstalledModelList(std::vector<ISSMResource *> *pList)
{
SSMRESULT res = SSM_E_FAIL;
* @exception
* @see
*/
- virtual SSMRESULT executeContextQuery(IN std::string contextQuery, OUT int *cqid) = 0;
+ virtual SSMRESULT executeContextQuery(std::string contextQuery, int *cqid) = 0;
/**
* @fn registerQueryEvent
* @exception
* @see
*/
- virtual SSMRESULT registerQueryEvent(IN IQueryEngineEvent *pQueryEngineEvent) = 0;
+ virtual SSMRESULT registerQueryEvent(IQueryEngineEvent *pQueryEngineEvent) = 0;
/**
* @fn unregisterQueryEvent
* @exception
* @see
*/
- virtual SSMRESULT unregisterQueryEvent(IN IQueryEngineEvent *pQueryEngineEvent) = 0;
+ virtual SSMRESULT unregisterQueryEvent(IQueryEngineEvent *pQueryEngineEvent) = 0;
/**
* @fn killContextQuery
* @exception
* @see
*/
- virtual SSMRESULT killContextQuery(IN int cqid) = 0;
+ virtual SSMRESULT killContextQuery(int cqid) = 0;
protected:
virtual ~IQueryEngine() {};
};
* @exception
* @see
*/
-INTERFACE_DECLSPEC SSMRESULT CreateQueryEngine(OUT IQueryEngine **ppQueryEngine);
+INTERFACE_DECLSPEC SSMRESULT CreateQueryEngine(IQueryEngine **ppQueryEngine);
/**
* @fn ReleaseQueryEngine
* @exception
* @see
*/
-INTERFACE_DECLSPEC unsigned long ReleaseQueryEngine(IN IQueryEngine *pQueryEngine);
+INTERFACE_DECLSPEC unsigned long ReleaseQueryEngine(IQueryEngine *pQueryEngine);
/**
* @exception
* @see
*/
-INTERFACE_DECLSPEC SSMRESULT InitializeSSMCore(IN std::string xmlDescription);
+INTERFACE_DECLSPEC SSMRESULT InitializeSSMCore(std::string xmlDescription);
/**
* @fn StartSSMCore
* @exception
* @see
*/
-INTERFACE_DECLSPEC SSMRESULT TerminateSSMCore(IN bool factoryResetFlag = false);
+INTERFACE_DECLSPEC SSMRESULT TerminateSSMCore(bool factoryResetFlag = false);
/**
* @fn GetErrorMessage
* @exception
* @see
*/
-INTERFACE_DECLSPEC const char *GetSSMError(IN SSMRESULT res);
+INTERFACE_DECLSPEC const char *GetSSMError(SSMRESULT res);
/**
* @fn GetInstalledModelList
* @exception
* @see
*/
-INTERFACE_DECLSPEC SSMRESULT GetInstalledModelList(OUT std::vector<ISSMResource *> *pList);
+INTERFACE_DECLSPEC SSMRESULT GetInstalledModelList(std::vector<ISSMResource *> *pList);
#ifdef __cplusplus
}
m_objQueryEngineEvent = objQueryEngineEvent;
}
- SSMRESULT onQueryEngineEvent(IN int cqid, IN IDataReader *pResult)
+ SSMRESULT onQueryEngineEvent(int cqid, IDataReader *pResult)
{
JNIEnv *env;
g_JVM->GetEnv((void **) &env, JNI_VERSION_1_6);
m_hSSMResource = resourceHandle;
}
- SSMRESULT onQueryEngineEvent(IN int cqid, IN IDataReader *pResult)
+ SSMRESULT onQueryEngineEvent(int cqid, IDataReader *pResult)
{
int dataCount = 0;
IModelData *pModelData = NULL;
{
}
-SSMRESULT CSoftSensorManager::initializeCore(IN std::string xmlDescription)
+SSMRESULT CSoftSensorManager::initializeCore(std::string xmlDescription)
{
SSMRESULT res = SSM_E_FAIL;
rapidxml::xml_document<> xmlDoc;
return SSM_S_OK;
}
-SSMRESULT CSoftSensorManager::createQueryEngine(OUT IQueryEngine **ppQueryEngine)
+SSMRESULT CSoftSensorManager::createQueryEngine(IQueryEngine **ppQueryEngine)
{
SSMRESULT res = SSM_E_FAIL;
IQueryEngineInternal *pQueryEngineInternal = NULL;
return res;
}
-unsigned long CSoftSensorManager::releaseQueryEngine(IN IQueryEngine *pQueryEngine)
+unsigned long CSoftSensorManager::releaseQueryEngine(IQueryEngine *pQueryEngine)
{
IQueryEngineInternal *pQueryEngineInternal = NULL;
pQueryEngineInternal = (IQueryEngineInternal *)(CQueryEngine *)pQueryEngine;
return pQueryEngineInternal->release();
}
-SSMRESULT CSoftSensorManager::getInstalledModelList(OUT std::vector<ISSMResource *> *pList)
+SSMRESULT CSoftSensorManager::getInstalledModelList(std::vector<ISSMResource *> *pList)
{
m_pSensingEngine->getList(pList);
std::map<OID, IBase *> *g_globalInstance = NULL;
IThreadPool *g_pThreadPool = NULL;
-SSMRESULT CreateGlobalInstance(IN const OID &objectID, OUT IBase **ppvObject)
+SSMRESULT CreateGlobalInstance(const OID &objectID, IBase **ppvObject)
{
SSMRESULT res = SSM_E_NOINTERFACE;
return res;
}
-SSMRESULT CreateInstance(IN const OID &objectID, OUT IBase **ppObject)
+SSMRESULT CreateInstance(const OID &objectID, IBase **ppObject)
{
SSMRESULT res = SSM_E_NOINTERFACE;
* @exception
* @see
*/
- SSMRESULT initializeCore(IN std::string xmlDescription);
+ SSMRESULT initializeCore(std::string xmlDescription);
/**
* @fn startCore
* @exception
* @see
*/
- SSMRESULT terminateCore(IN bool factoryResetFlag);
+ SSMRESULT terminateCore(bool factoryResetFlag);
/**
* @fn createQueryEngine
* @exception
* @see
*/
- SSMRESULT createQueryEngine(OUT IQueryEngine **ppQueryEngine);
+ SSMRESULT createQueryEngine(IQueryEngine **ppQueryEngine);
/**
* @fn releaseQueryEngine
* @exception
* @see
*/
- unsigned long releaseQueryEngine(IN IQueryEngine *pQueryEngine);
+ unsigned long releaseQueryEngine(IQueryEngine *pQueryEngine);
/**
* @fn getInstalledModelList
* @exception
* @see
*/
- SSMRESULT getInstalledModelList(OUT std::vector<ISSMResource *> *pList);
+ SSMRESULT getInstalledModelList(std::vector<ISSMResource *> *pList);
};
#endif
m_pContextModelAccessor = NULL;
}
-SSMRESULT CContextDataReader::registerContextModelAccessor(IN IContextModelAccessor
+SSMRESULT CContextDataReader::registerContextModelAccessor(IContextModelAccessor
*pContextModelAccessor)
{
m_pContextModelAccessor = pContextModelAccessor;
return SSM_S_OK;
}
-SSMRESULT CContextDataReader::getContextData(IN std::string modelName, IN int startIndex,
- IN int count, OUT std::vector<ContextData> *data, OUT int *pLastIndex)
+SSMRESULT CContextDataReader::getContextData(std::string modelName, int startIndex,
+ int count, std::vector<ContextData> *data, int *pLastIndex)
{
SSMRESULT res = SSM_E_FAIL;
std::vector<ModelPropertyVec> modelDataSet;
* @exception
* @see
*/
- SSMRESULT registerContextModelAccessor(IN IContextModelAccessor *pContextModelAccessor);
+ SSMRESULT registerContextModelAccessor(IContextModelAccessor *pContextModelAccessor);
/**
* @fn getContextData
* @exception
* @see
*/
- SSMRESULT getContextData(IN std::string modelName, IN int startIndex, IN int count,
- OUT std::vector<ContextData> *data, OUT int *pLastIndex);
+ SSMRESULT getContextData(std::string modelName, int startIndex, int count,
+ std::vector<ContextData> *data, int *pLastIndex);
};
#endif
}
}
-void CContextExecutor::onExecute(IN void *pArg)
+void CContextExecutor::onExecute(void *pArg)
{
intptr_t *pMessage = (intptr_t *)pArg;
}
}
-void CContextExecutor::onTerminate(IN void *pArg)
+void CContextExecutor::onTerminate(void *pArg)
{
intptr_t *pMessage = (intptr_t *)pArg;
* @exception
* @see
*/
- void registerCallback(IN ICtxEvent *pEvent);
+ void registerCallback(ICtxEvent *pEvent);
/**
* @fn addOutput
* @exception
* @see
*/
- void addOutput(IN std::vector<ContextData> contextData);
+ void addOutput(std::vector<ContextData> contextData);
/**
* @fn getDataFromDatabase
* @exception
* @see
*/
- void getDataFromDatabase(IN std::string modelName, IN int startIndex, IN int count,
- OUT std::vector<ContextData> *data, OUT int *pLastIndex);
+ void getDataFromDatabase(std::string modelName, int startIndex, int count,
+ std::vector<ContextData> *data, int *pLastIndex);
/**
* @fn onEvent
* @exception
* @see
*/
- int onEvent(IN std::string deviceID, IN TypeofEvent callType, IN std::vector<ContextData> ctxData);
+ int onEvent(std::string deviceID, TypeofEvent callType, std::vector<ContextData> ctxData);
/**
* @fn registerContext
* @exception
* @see
*/
- void registerContext(IN TypeofEvent callType, IN ISSMResource *pSSMResouce, IN IEvent *pEvent);
+ void registerContext(TypeofEvent callType, ISSMResource *pSSMResouce, IEvent *pEvent);
/**
* @fn unregisterContext
* @exception
* @see
*/
- void unregisterContext(IN TypeofEvent callType, IN ISSMResource *pSSMResource, IN IEvent *pEvent);
+ void unregisterContext(TypeofEvent callType, ISSMResource *pSSMResource, IEvent *pEvent);
void onExecute(void *pArg);
void onTerminate(void *pArg);
- int onResourceEvent(IN RESOURCE_EVENT_TYPE eventType, IN ISSMResource *pSSMResource,
- IN std::string info);
+ int onResourceEvent(RESOURCE_EVENT_TYPE eventType, ISSMResource *pSSMResource,
+ std::string info);
private:
- SSMRESULT findString(IN std::vector<ISSMResource *> *sList, IN const std::string str,
- OUT ISSMResource **ppResource);
+ SSMRESULT findString(std::vector<ISSMResource *> *sList, const std::string str,
+ ISSMResource **ppResource);
std::map<std::string, std::vector<ContextData> > getPreparedContextList(
- IN std::string primitiveSensor);
- void runLogic(IN std::vector<ContextData> inputData, IN std::string softSensor);
+ std::string primitiveSensor);
+ void runLogic(std::vector<ContextData> inputData, std::string softSensor);
};
#endif
return res;
}
-SSMRESULT CContextRepository::registerResourceFinderEvent(IN IResourceEvent *pResourceEvent)
+SSMRESULT CContextRepository::registerResourceFinderEvent(IResourceEvent *pResourceEvent)
{
m_resourceEvents.push_back(pResourceEvent);
return SSM_S_OK;
{
}
-SSMRESULT CContextRepository::initRepository(IN std::string name, IN std::string type,
- IN std::string pathSoftSensors, IN std::string pathDescription)
+SSMRESULT CContextRepository::initRepository(std::string name, std::string type,
+ std::string pathSoftSensors, std::string pathDescription)
{
SSMRESULT res = SSM_E_FAIL;
return res;
}
-SSMRESULT CContextRepository::getSoftSensorList(OUT std::vector<ISSMResource *> *pSoftSensorList)
+SSMRESULT CContextRepository::getSoftSensorList(std::vector<ISSMResource *> *pSoftSensorList)
{
for (size_t i = 0; i < m_lstSoftSensor.size(); i++)
{
return SSM_S_OK;
}
-SSMRESULT CContextRepository::getPrimitiveSensorList(OUT std::vector<ISSMResource *>
+SSMRESULT CContextRepository::getPrimitiveSensorList(std::vector<ISSMResource *>
*pPrimitiveSensorList)
{
for (size_t i = 0; i < m_lstPrimitiveSensor.size(); i++)
return SSM_S_OK;
}
-SSMRESULT CContextRepository::onResourceFound(IN ISSMResource *pSensor)
+SSMRESULT CContextRepository::onResourceFound(ISSMResource *pSensor)
{
m_lstPrimitiveSensor.push_back(pSensor);
return SSM_S_OK;
}
-SSMRESULT CContextRepository::onResourceLost(IN ISSMResource *pSensor)
+SSMRESULT CContextRepository::onResourceLost(ISSMResource *pSensor)
{
std::vector<ISSMResource *>::iterator itor;
itor = std::find(m_lstPrimitiveSensor.begin(), m_lstPrimitiveSensor.end(), pSensor);
return SSM_E_FAIL;
}
-SSMRESULT CContextRepository::startObserveResource(IN ISSMResource *pSensor, IN IEvent *pEvent)
+SSMRESULT CContextRepository::startObserveResource(ISSMResource *pSensor, IEvent *pEvent)
{
return m_resourceFinder->startObserveResource(pSensor, pEvent);
}
-SSMRESULT CContextRepository::stopObserveResource(IN ISSMResource *pSensor)
+SSMRESULT CContextRepository::stopObserveResource(ISSMResource *pSensor)
{
return m_resourceFinder->stopObserveResource(pSensor);
}
std::stringstream sstream;
SSMRESULT res = SSM_E_FAIL;
- typedef void(*InitContext)(IN ICtxDelegate *);
+ typedef void(*InitContext)(ICtxDelegate *);
InitContext InitializeContextFunction = NULL;
// load dll(so)
* @exception
* @see
*/
- SSMRESULT initRepository(IN std::string name, IN std::string type, IN std::string pathSoftSensors,
- IN std::string pathDescription);
+ SSMRESULT initRepository(std::string name, std::string type, std::string pathSoftSensors,
+ std::string pathDescription);
/**
* @fn getSoftSensorList
* @exception
* @see
*/
- SSMRESULT getSoftSensorList(OUT std::vector<ISSMResource *> *pSoftSensorList);
+ SSMRESULT getSoftSensorList(std::vector<ISSMResource *> *pSoftSensorList);
/**
* @fn getPrimitiveSensorList
* @exception
* @see
*/
- SSMRESULT getPrimitiveSensorList(OUT std::vector<ISSMResource *> *pPrimitiveSensorList);
+ SSMRESULT getPrimitiveSensorList(std::vector<ISSMResource *> *pPrimitiveSensorList);
- SSMRESULT registerResourceFinderEvent(IN IResourceEvent *pResourceEvent);
+ SSMRESULT registerResourceFinderEvent(IResourceEvent *pResourceEvent);
SSMRESULT startResourceFinder();
SSMRESULT stopResourceFinder();
- SSMRESULT onResourceFound(IN ISSMResource *pSensor);
- SSMRESULT onResourceLost(IN ISSMResource *pSensor);
+ SSMRESULT onResourceFound(ISSMResource *pSensor);
+ SSMRESULT onResourceLost(ISSMResource *pSensor);
- SSMRESULT startObserveResource(IN ISSMResource *pSensor, IN IEvent *pEvent);
- SSMRESULT stopObserveResource(IN ISSMResource *pSensor);
+ SSMRESULT startObserveResource(ISSMResource *pSensor, IEvent *pEvent);
+ SSMRESULT stopObserveResource(ISSMResource *pSensor);
- SSMRESULT loadSoftSensor(IN std::string softSensorName, IN ICtxDelegate *pDelegate,
- OUT void **hSoftSensor);
- SSMRESULT unloadSoftSensor(IN void *hSoftSensor);
+ SSMRESULT loadSoftSensor(std::string softSensorName, ICtxDelegate *pDelegate,
+ void **hSoftSensor);
+ SSMRESULT unloadSoftSensor(void *hSoftSensor);
private:
- SSMRESULT makeSSMResourceListForDictionaryData(IN std::vector<DictionaryData> dataList,
- OUT std::vector<ISSMResource *> *pList) ;
- SSMRESULT loadXMLFromFile(IN std::string descriptionFilePath,
- IN std::vector<DictionaryData> *dataList);
- SSMRESULT loadXMLFromString(IN char *xmlData, IN std::vector<DictionaryData> *dataList);
- SSMRESULT getCurrentPath(OUT std::string *path);
+ SSMRESULT makeSSMResourceListForDictionaryData(std::vector<DictionaryData> dataList,
+ std::vector<ISSMResource *> *pList) ;
+ SSMRESULT loadXMLFromFile(std::string descriptionFilePath,
+ std::vector<DictionaryData> *dataList);
+ SSMRESULT loadXMLFromString(char *xmlData, std::vector<DictionaryData> *dataList);
+ SSMRESULT getCurrentPath(std::string *path);
};
#endif
{
}
-SSMRESULT CResourceFinder::registerResourceFinderEvent(IN IResourceFinderEvent *pEvent)
+SSMRESULT CResourceFinder::registerResourceFinderEvent(IResourceFinderEvent *pEvent)
{
m_pResourceFinderEvent = pEvent;
return SSM_S_OK;
return res;
}
-SSMRESULT CResourceFinder::startObserveResource(IN ISSMResource *pSensor, IN IEvent *pEvent)
+SSMRESULT CResourceFinder::startObserveResource(ISSMResource *pSensor, IEvent *pEvent)
{
return m_mapResourceHandler[pSensor->name]->startObserve(pEvent);
}
-SSMRESULT CResourceFinder::stopObserveResource(IN ISSMResource *pSensor)
+SSMRESULT CResourceFinder::stopObserveResource(ISSMResource *pSensor)
{
return m_mapResourceHandler[pSensor->name]->stopObserve();
}
-void CResourceFinder::onExecute(IN void *pArg)
+void CResourceFinder::onExecute(void *pArg)
{
SSMRESULT res = SSM_E_FAIL;
OCStackResult ret = OC_STACK_ERROR;
;
}
-void CResourceFinder::onTerminate(IN void *pArg)
+void CResourceFinder::onTerminate(void *pArg)
{
std::shared_ptr< OC::OCResource > *pResource = NULL;
intptr_t *pMessage = (intptr_t *)pArg;
SSMRESULT finalConstruct();
void finalRelease();
- SSMRESULT registerResourceFinderEvent(IN IResourceFinderEvent *pEvent);
+ SSMRESULT registerResourceFinderEvent(IResourceFinderEvent *pEvent);
void onResourceFound(std::shared_ptr< OC::OCResource > resource);
void presenceHandler(OCStackResult result, const unsigned int nonce,
const std::string &hostAddress);
SSMRESULT startResourceFinder();
SSMRESULT stopResourceFinder();
- SSMRESULT startObserveResource(IN ISSMResource *pSensor, IN IEvent *pEvent);
- SSMRESULT stopObserveResource(IN ISSMResource *pSensor);
+ SSMRESULT startObserveResource(ISSMResource *pSensor, IEvent *pEvent);
+ SSMRESULT stopObserveResource(ISSMResource *pSensor);
- void onExecute(IN void *pArg);
- void onTerminate(IN void *pArg);
+ void onExecute(void *pArg);
+ void onTerminate(void *pArg);
private:
class OICResourceHandler
}
SSMRESULT initHandler(std::shared_ptr< OC::OCResource > resource,
- IN IThreadClient *pThreadClient)
+ IThreadClient *pThreadClient)
{
SSMRESULT res = SSM_E_FAIL;
* @exception
* @see
*/
- SSMRESULT registerContext(IN TypeofEvent callType, IN ISSMResource *pSSMResource,
- IN IEvent *pEvent);
+ SSMRESULT registerContext(TypeofEvent callType, ISSMResource *pSSMResource,
+ IEvent *pEvent);
/**
* @fn unregisterContext
* @exception
* @see
*/
- SSMRESULT unregisterContext(IN TypeofEvent callType, IN ISSMResource *pSSMResource,
- IN IEvent *pEvent);
+ SSMRESULT unregisterContext(TypeofEvent callType, ISSMResource *pSSMResource,
+ IEvent *pEvent);
/**
* @fn getList
* @exception
* @see
*/
- SSMRESULT getList(OUT std::vector<ISSMResource *> *pList);
+ SSMRESULT getList(std::vector<ISSMResource *> *pList);
/**
* @fn onEvent
* @exception
* @see
*/
- int onEvent(IN std::string name, IN TypeofEvent callType, IN std::vector<ContextData> ctxData);
+ int onEvent(std::string name, TypeofEvent callType, std::vector<ContextData> ctxData);
};
#endif
\ No newline at end of file
projects / platform / upstream / iotivity.git / commitdiff