Give the possibility to define some parameters time restriction in a request + A…

…pply time restriction on paramaters (#5768)

Give the possibility to define some parameters time restriction in a request + A…
…pply time restriction on paramaters (#5768)
Benjamin Renard
1 parent c1f5c606
Showing 11 changed files with 252 additions and 111 deletions Show diff stats
config/xsd/request/request.xsd
src/ParamGetImpl/DDServerInterface/ParamGetDDBase.cc
src/ParamGetImpl/DDServerInterface/ParamGetDDBase.hh
src/ParamGetImpl/DDServerInterface/Pusher.hh
src/ParamGetImpl/DDServerInterface/VirtualInstrument.cc
src/ParamGetImpl/DDServerInterface/VirtualInstrument.hh
src/Parameters/ParamOutput.cc
src/Parameters/Parameter.cc
src/Parameters/Parameter.hh
src/Parameters/ParameterManager.hh
src/XMLRequest/XMLRequestParser.cc
@@ -27,6 +27,19 @@
 						</xs:sequence>
 					</xs:complexType>
 				</xs:element>
+
+				<xs:element name="paramsTimeRestrictions" minOccurs="0" maxOccurs="1">
+					<xs:complexType>
+						<xs:sequence>
+							<xs:element name="param" minOccurs="0" maxOccurs="unbounded">
+								<xs:complexType>
+									<xs:attribute name="id" type="xs:string" />
+									<xs:attribute name="restriction" type="xs:int" />
+								</xs:complexType>
+							</xs:element>
+						</xs:sequence>
+					</xs:complexType>
+				</xs:element>
 				<xs:element name="outputs">
 					<xs:complexType>
@@ -55,7 +55,7 @@ namespace AMDA {
                         /// Create ParamData
 			_vi = VirtualInstrumentManager::getInstance()->getVirtualInstrument(
 					_viName);
-			_pusher = _vi->getParamPusher(_parName, _maxDim1Size, _maxDim2Size, _maxDim3Size, _dim3Num, _dim3CutIndex, _minSumIndex, _maxSumIndex);
+			_pusher = _vi->getParamPusher(_parName, _maxDim1Size, _maxDim2Size, _maxDim3Size, _dim3Num, _dim3CutIndex, _minSumIndex, _maxSumIndex, _parameter.getTimeRestriction());
 			//Param info
 			AMDA::Info::ParamInfoSPtr paramInfo = AMDA::Info::ParamMgr::getInstance()->getParamInfoFromId(_parameter.getInfoId(),true);
 			if ((paramInfo != nullptr) && (isnan(_pusher->getFillValue())) && (!isnan(paramInfo->getOriginalFillValue())))
@@ -114,8 +114,8 @@ namespace AMDA {
 				else {
 					do {
 						result += lPacket->data->VarNumber;
-						_pusher->put(lPacket->data.get());
-						updateTimeInParamData(lPacket->time.get());
+						LOG4CXX_DEBUG(gLogger, "put data " << lPacket->data->VarNumber);
+						_pusher->put(lPacket->data.get(), lPacket->time.get());
 						delete lPacket;
 					} while( ( lPacket = _paramFlow->tryGet()));
@@ -144,25 +144,6 @@ namespace AMDA {
 			return result;
 		}
-		void ParamGetDDBase::updateTimeInParamData(DD_data_t* data) {
-			LOG4CXX_DEBUG(gLogger, "updateTimeInParamData data->VarNumber = " << data->VarNumber);
-			//ParamData is created, add data
-			//The capacity must be == at Data
-			double t = 0.;
-			for (int index = 0; index < data->VarNumber; index++) {
-				if (data->type == DD_CHAR) {
-					t = DD_Time2Double((char *) data->Variables[index]);
-				}
-				else if (data->type == DD_DOUBLE) {
-					t = *((double*)data->Variables[index]);
-				}
-				else {
-					BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::ex_msg("Unknown time type"));
-				}
-				_paramData->getTimeList().push_back(t);
-			}
-		}
-
 		void ParamGetDDBase::getDDInfo() {
 			for (InfoRequestList::iterator lIt = _infoRequestList.begin();
 					lIt != _infoRequestList.end(); ++lIt) {
@@ -141,12 +141,6 @@ namespace AMDA {
 		private:
 			/**
-			 * @brief update time in the ParamData
-			 * @details Must be call after createParamData
-			 */
-			void updateTimeInParamData(DD_data_t *data);
-
-			/**
 			 * Create ParamData from getDataTypeInfo.
 			 */
 			void createParamData();
@@ -24,9 +24,9 @@ namespace Base {
 	 * of the corresponding type ( scalar or vector or Tab2D of short or int or float or double or ... type).
 	 */
 	struct Pusher {
-		Pusher (int maxDim1Size=1,int maxDim2Size=1) : _maxDim1Size(maxDim1Size), _maxDim2Size(maxDim2Size), _paramData(NULL), _fillValue(NAN) {}
+		Pusher (int maxDim1Size=1,int maxDim2Size=1) : _maxDim1Size(maxDim1Size), _maxDim2Size(maxDim2Size), _paramData(NULL), _fillValue(NAN), _timeRestriction(NAN) {}
 		virtual ~Pusher() {}
-		virtual void put(DD_data_t *data) = 0;
+		virtual void put(DD_data_t *data, DD_data_t *timeData) = 0;
 		virtual void putNaN() = 0;
 		void setFillValue(double pFillValue) {
 			_fillValue = pFillValue;
@@ -34,11 +34,35 @@ namespace Base {
 		double getFillValue() {
 			return _fillValue;
 		}
+		void setTimeRestriction(double timeRestriction) {
+			_timeRestriction = timeRestriction;
+		}
+		double getTimeRestriction() {
+			return _timeRestriction;
+		}
+
+		double getTimeByIndex(DD_data_t* data, int index) {
+			if (index >= data->VarNumber) {
+				BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::ex_msg("Try to access to a time outside of the available range"));
+			}
+			if (data->type == DD_CHAR) {
+				return DD_Time2Double((char *) data->Variables[index]);
+			}
+			else if (data->type == DD_DOUBLE) {
+				return *((double*)data->Variables[index]);
+			}
+			else {
+				BOOST_THROW_EXCEPTION(AMDA::AMDA_exception() << AMDA::ex_msg("Unknown time type"));
+			}
+			return 0.;
+		}
+
 		int _maxDim1Size; /*!< Used for vector and Tab2D */
 		int _maxDim2Size; /*!< Used for Tab2D */
 		ParamData* _paramData; /*!< return ParamData to a Process*/
 	protected:
 		float _fillValue; /*!< When this value is different of NAN, into the raw data, it is replaced by NAN into ParamData. */
+		double _timeRestriction;
 	};
 }
@@ -85,102 +109,117 @@ public:
 		_paramData = _specParamData = createParamData();
 	}
-	void put(DD_data_t *data) {
+	void put(DD_data_t *data, DD_data_t *timeData) {
 		BaseElemenType **lData = reinterpret_cast<BaseElemenType **>(data->Variables);
 		//ParamData is created, add data
 		_specParamData->getDataList().resize(data->VarNumber);
+		if(_dim3CutIndex == -1 && _minSumIndex != -1 && _maxSumIndex != -1){
+			for (int index = 0; index < data->VarNumber; index++) {
+				double t = getTimeByIndex(timeData, index);
+				_paramData->getTimeList().push_back(t);
-                              if(_dim3CutIndex == -1 && _minSumIndex != -1 && _maxSumIndex != -1){
-                                         for (int index = 0; index < data->VarNumber; index++) {
-			ElemenType elem = ElemenType(_maxDim1Size,_maxDim2Size);
-			elem << NotANumber();
-			for (int dim1Index= 0; dim1Index < data->Dimensions[_dim1Num]; ++dim1Index)
-			{
-				for (int dim2Index= 0; dim2Index < data->Dimensions[_dim2Num]; ++dim2Index)
-				{   
-                                        BaseElemenType cumulatedElement;
-                                        cumulatedElement << NotANumber() ;
-                                                                                         for(int sumIndex=_minSumIndex; sumIndex <= _maxSumIndex; ++sumIndex){
-					int dataIndex = 0;
-					if (_dim3Num >= 0 && _dim3Num < 3 && data->DimNumber == 3) {
-						int curentIndex = (sumIndex >= 0 && sumIndex < data->Dimensions[_dim3Num]) ? sumIndex : 0;
-						if (_dim3Num == 0) {
-							dataIndex = curentIndex*data->Dimensions[_dim1Num]*data->Dimensions[_dim2Num] + dim1Index*data->Dimensions[_dim2Num] + dim2Index;
-						}
-						else if (_dim3Num == 1) {
-							dataIndex = dim1Index*data->Dimensions[_dim2Num]*data->Dimensions[_dim3Num] + curentIndex*data->Dimensions[_dim2Num] + dim2Index;
-						}
-						else {
-							dataIndex = dim1Index*data->Dimensions[_dim2Num]*data->Dimensions[_dim3Num] + dim2Index*data->Dimensions[_dim3Num] + curentIndex;
-						}
+				if ((getTimeRestriction() > 0) && !isnan(getTimeRestriction())) {
+					if (t >= getTimeRestriction()) {
+						putNaN();
+						continue;
 					}
-					else {
-						dataIndex = dim1Index*data->Dimensions[_dim2Num]+dim2Index;
-					}
-					BaseElemenType  baseElem =  lData[index][dataIndex];
-					if (!isnan(_fillValue))
-					{
-						double crt_val = baseElem;
-						bool is_fill_value = isApproximatelyEqual(crt_val, _fillValue);
-						if(is_fill_value)
-							baseElem << NotANumber();
+				}
+
+				ElemenType elem = ElemenType(_maxDim1Size,_maxDim2Size);
+				elem << NotANumber();
+				for (int dim1Index= 0; dim1Index < data->Dimensions[_dim1Num]; ++dim1Index)
+				{
+					for (int dim2Index= 0; dim2Index < data->Dimensions[_dim2Num]; ++dim2Index)
+					{   
+                                        	BaseElemenType cumulatedElement;
+                                        	cumulatedElement << NotANumber() ;
+						for(int sumIndex=_minSumIndex; sumIndex <= _maxSumIndex; ++sumIndex){
+							int dataIndex = 0;
+							if (_dim3Num >= 0 && _dim3Num < 3 && data->DimNumber == 3) {
+								int curentIndex = (sumIndex >= 0 && sumIndex < data->Dimensions[_dim3Num]) ? sumIndex : 0;
+								if (_dim3Num == 0) {
+									dataIndex = curentIndex*data->Dimensions[_dim1Num]*data->Dimensions[_dim2Num] + dim1Index*data->Dimensions[_dim2Num] + dim2Index;
+								}
+								else if (_dim3Num == 1) {
+									dataIndex = dim1Index*data->Dimensions[_dim2Num]*data->Dimensions[_dim3Num] + curentIndex*data->Dimensions[_dim2Num] + dim2Index;
+								}
+								else {
+									dataIndex = dim1Index*data->Dimensions[_dim2Num]*data->Dimensions[_dim3Num] + dim2Index*data->Dimensions[_dim3Num] + curentIndex;
+								}
+							}
+							else {
+								dataIndex = dim1Index*data->Dimensions[_dim2Num]+dim2Index;
+							}
+							BaseElemenType  baseElem =  lData[index][dataIndex];
+							if (!isnan(_fillValue))
+							{
+								double crt_val = baseElem;
+								bool is_fill_value = isApproximatelyEqual(crt_val, _fillValue);
+								if(is_fill_value)
+									baseElem << NotANumber();
+							}
+                                        		if (!isNAN(baseElem)) {
+                                                		if (isNAN(cumulatedElement))
+                                                    			cumulatedElement << ElemNull();
+                                                		cumulatedElement += baseElem;
+                                        		}
+                                 		}
+                                 		elem[dim1Index][dim2Index] = cumulatedElement;
 					}
-                                        if (!isNAN(baseElem)) {
-                                                if (isNAN(cumulatedElement))
-                                                    cumulatedElement << ElemNull();
-                                                cumulatedElement += baseElem;
-                                        }
-                                 }
-                                 elem[dim1Index][dim2Index] = cumulatedElement;
-                                                                                                    }
-					
 				}
-                                                                 _specParamData->getDataList().push_back(elem);
+				_specParamData->getDataList().push_back(elem);
 			}
-                                  
-			
-		
-                              }else{
-                                  for (int index = 0; index < data->VarNumber; index++) {
-			ElemenType elem = ElemenType(_maxDim1Size,_maxDim2Size);
-			elem << NotANumber();
-			for (int dim1Index= 0; dim1Index < data->Dimensions[_dim1Num]; ++dim1Index)
-			{
-				for (int dim2Index= 0; dim2Index < data->Dimensions[_dim2Num]; ++dim2Index)
+		}else{
+			for (int index = 0; index < data->VarNumber; index++) {
+				double t = getTimeByIndex(timeData, index);
+				_paramData->getTimeList().push_back(t);
+
+				if ((getTimeRestriction() > 0) && !isnan(getTimeRestriction())) {
+					if (getTimeByIndex(data, index) >= getTimeRestriction()) {
+						putNaN();
+						continue;
+					}
+				}
+
+				ElemenType elem = ElemenType(_maxDim1Size,_maxDim2Size);
+				elem << NotANumber();
+				for (int dim1Index= 0; dim1Index < data->Dimensions[_dim1Num]; ++dim1Index)
 				{
-					int dataIndex = 0;
-					if (_dim3Num >= 0 && _dim3Num < 3 && data->DimNumber == 3) {
-						int cutIndex = (_dim3CutIndex >= 0 && _dim3CutIndex < data->Dimensions[_dim3Num]) ? _dim3CutIndex : 0;
-						if (_dim3Num == 0) {
-							dataIndex = cutIndex*data->Dimensions[_dim1Num]*data->Dimensions[_dim2Num] + dim1Index*data->Dimensions[_dim2Num] + dim2Index;
-						}
-						else if (_dim3Num == 1) {
-							dataIndex = dim1Index*data->Dimensions[_dim2Num]*data->Dimensions[_dim3Num] + cutIndex*data->Dimensions[_dim2Num] + dim2Index;
+					for (int dim2Index= 0; dim2Index < data->Dimensions[_dim2Num]; ++dim2Index)
+					{
+						int dataIndex = 0;
+						if (_dim3Num >= 0 && _dim3Num < 3 && data->DimNumber == 3) {
+							int cutIndex = (_dim3CutIndex >= 0 && _dim3CutIndex < data->Dimensions[_dim3Num]) ? _dim3CutIndex : 0;
+							if (_dim3Num == 0) {
+								dataIndex = cutIndex*data->Dimensions[_dim1Num]*data->Dimensions[_dim2Num] + dim1Index*data->Dimensions[_dim2Num] + dim2Index;
+							}
+							else if (_dim3Num == 1) {
+								dataIndex = dim1Index*data->Dimensions[_dim2Num]*data->Dimensions[_dim3Num] + cutIndex*data->Dimensions[_dim2Num] + dim2Index;
+							}
+							else {
+								dataIndex = dim1Index*data->Dimensions[_dim2Num]*data->Dimensions[_dim3Num] + dim2Index*data->Dimensions[_dim3Num] + cutIndex;
+							}
 						}
 						else {
-							dataIndex = dim1Index*data->Dimensions[_dim2Num]*data->Dimensions[_dim3Num] + dim2Index*data->Dimensions[_dim3Num] + cutIndex;
+							dataIndex = dim1Index*data->Dimensions[_dim2Num]+dim2Index;
 						}
+						BaseElemenType baseElem = lData[index][dataIndex];
+						if (!isnan(_fillValue))
+						{
+							double crt_val = baseElem;
+							bool is_fill_value = isApproximatelyEqual(crt_val, _fillValue);
+							if(is_fill_value)
+								baseElem << NotANumber();
+						}
+						elem[dim1Index][dim2Index] = baseElem;
 					}
-					else {
-						dataIndex = dim1Index*data->Dimensions[_dim2Num]+dim2Index;
-					}
-					BaseElemenType baseElem = lData[index][dataIndex];
-					if (!isnan(_fillValue))
-					{
-						double crt_val = baseElem;
-						bool is_fill_value = isApproximatelyEqual(crt_val, _fillValue);
-						if(is_fill_value)
-							baseElem << NotANumber();
-					}
-					elem[dim1Index][dim2Index] = baseElem;
 				}
+				_specParamData->getDataList().push_back(elem);
 			}
-			_specParamData->getDataList().push_back(elem);
 		}
-	}
         }
 	void putNaN() {
@@ -231,13 +270,23 @@ public:
 		_paramData = _specParamData = createParamData();
 	}
-	void put(DD_data_t *data) {
+	void put(DD_data_t *data, DD_data_t *timeData) {
 		BaseElemenType **lData = reinterpret_cast<BaseElemenType **>(data->Variables);
 		//ParamData is created, add data
 		_specParamData->getDataList().resize(data->VarNumber);
 		for (int index = 0; index < data->VarNumber; index++) {
+			double t = getTimeByIndex(timeData, index);
+			_paramData->getTimeList().push_back(t);
+
+			if ((getTimeRestriction() > 0) && !isnan(getTimeRestriction())) {
+				if (t >= getTimeRestriction()) {
+					putNaN();
+					continue;
+				}
+			}
+
 			ElemenType elem = ElemenType();
 			elem.resize(_maxDim1Size);
 			elem << NotANumber();
@@ -290,7 +339,7 @@ public:
 		_paramData = _specParamData = createParamData();
 	}
-	void put(DD_data_t *data) {
+	void put(DD_data_t *data, DD_data_t *timeData) {
 		BaseElemenType **lData = reinterpret_cast<BaseElemenType **>(data->Variables);
 		//ParamData is created, add data
@@ -303,6 +352,16 @@ public:
                         BaseElemenType nanElem;
                         nanElem << NotANumber();
 			for (int index = 0; index < data->VarNumber; index++) {
+				double t = getTimeByIndex(timeData, index);
+				_paramData->getTimeList().push_back(t);
+
+				if ((getTimeRestriction() > 0) && !isnan(getTimeRestriction())) {
+					if (t >= getTimeRestriction()) {
+						putNaN();
+						continue;
+					}
+				}
+
 				double crt_val = *lData[index];
 				bool is_fill_value = isApproximatelyEqual(crt_val, _fillValue);
 				if(!is_fill_value) {
@@ -314,6 +373,16 @@ public:
 		}
 		else {
 			for (int index = 0; index < data->VarNumber; index++) {
+				double t = getTimeByIndex(timeData, index);
+				_paramData->getTimeList().push_back(t);
+
+				if ((getTimeRestriction() > 0) && !isnan(getTimeRestriction())) {
+					if (t >= getTimeRestriction()) {
+						putNaN();
+						continue;
+					}
+				}
+
 				_specParamData->getDataList().push_back(*lData[index]);
 			}
@@ -196,7 +196,7 @@ namespace DDServerInterface {
 		}
 		//TODO Replace by DD_Client::getParamType
-		AMDA::Parameters::Base::Pusher* VirtualInstrument::getParamPusher( const std::string& pParName, int maxDim1Size, int maxDim2Size, int maxDim3Size, int dim3Num, int dim3CutIndex, int minSumIndex, int maxSumIndex) {
+		AMDA::Parameters::Base::Pusher* VirtualInstrument::getParamPusher( const std::string& pParName, int maxDim1Size, int maxDim2Size, int maxDim3Size, int dim3Num, int dim3CutIndex, int minSumIndex, int maxSumIndex, double timeRestriction) {
 			AMDA::Parameters::Base::Pusher* lPusher = nullptr;
 			int error = 0;
@@ -340,6 +340,9 @@ namespace DDServerInterface {
 					BOOST_THROW_EXCEPTION(exception() << errno_code(AMDA_TYPE_DATA_UNKNOWN));
 				}
 				lPusher->setFillValue(_fillValue);
+				if (timeRestriction > 0. && !isnan(timeRestriction)) {
+					lPusher->setTimeRestriction(timeRestriction);
+				}
 			} else {
 				LOG4CXX_INFO(gLogger, "VirtualInstrument::getParamPusher( "<< lId <<", " << pParName << ") returns = (" << error << ")");
 				lDDClient.DD_Close(lId);
@@ -83,7 +83,7 @@ public:
 	/**
 	 * @brief Responsible push data into the good container.
 	 */
-	AMDA::Parameters::Base::Pusher* getParamPusher(const std::string& pParName, int maxDim1Size, int maxDim2Size, int maxDim3Size, int dim3Num, int dim3CutIndex, int minSumIndex, int maxSumIndex);
+	AMDA::Parameters::Base::Pusher* getParamPusher(const std::string& pParName, int maxDim1Size, int maxDim2Size, int maxDim3Size, int dim3Num, int dim3CutIndex, int minSumIndex, int maxSumIndex, double timeRestriction);
 	/**
 	 * @return a ParamFlowSPtr on the specified interval.
@@ -46,6 +46,16 @@ void ParamOutput::init(TimeIntervalListSPtr pTimeIntervalList) {
 	}
 	_currentTimeInterval = _timeIntervalList->begin();
+
+	// Update params time restrictions
+	std::map<std::string, double> paramsTimeRestrictions = _parameterManager.getParamsTimeRestrictions();
+	for (std::map<std::string, double>::iterator it = paramsTimeRestrictions.begin(); it != paramsTimeRestrictions.end(); ++it) {
+		ParameterSPtr p = _parameterManager.getParameter(it->first);
+		if (p != nullptr) {
+			p->setTimeRestriction(it->second);
+		}
+	}
+
 	init();
 }
@@ -34,6 +34,7 @@ namespace Parameters {
 		  _timeResolution(0) ,
 		  _gapThreshold(pParamMng.getDefaultGapThreshold()) ,
 		  _referenceParameter(""),
+		  _timeRestriction(NAN),
 		  establishConnectionToDo(true){
   }
@@ -196,6 +196,14 @@ namespace AMDA {
                 return _isTableIndexParam;
             }
+	    void setTimeRestriction(double restriction) {
+		_timeRestriction = restriction;
+	    }
+
+	    double getTimeRestriction() {
+		return _timeRestriction;
+	    }
+
         protected:
             typedef std::map<DataClient *, ParamInterval*> DataClientList;
@@ -270,6 +278,8 @@ namespace AMDA {
             static bool _isTableIndexParam;
+	    double _timeRestriction;
+
         private:
             bool establishConnectionToDo;
         };
@@ -155,6 +155,14 @@ namespace AMDA
 	ParameterSPtr findParamInParameterList(const std::string& paramId);
+	void addParamTimeRestriction(const std::string& paramId, double restriction) {
+		_paramsTimeRestrictions[paramId] = restriction;
+	}
+
+	std::map<std::string, double> getParamsTimeRestrictions() {
+		return _paramsTimeRestrictions;
+	}
+
     protected:
 	/**
 	 * @return The real parameter if the process is empty.
@@ -197,6 +205,11 @@ private:
 	  * @brief default value for the gap threshold of all parameters
 	  */
 	 double _defaultGapThreshold;
+
+	/*
+	 * @bried define some parameters time restrictions
+	 */
+	std::map<std::string, double> _paramsTimeRestrictions;
     };
   } /* namespace Parameters */
@@ -28,6 +28,7 @@
 #include "Catalog.hh"
 #include <boost/filesystem.hpp>
+#include <boost/lexical_cast.hpp>
 // Using namespace
 using namespace log4cxx;
@@ -297,6 +298,43 @@ public:
   }
 };
+class ParamTimeRestrictionNode : public NodeCfg
+{
+public:
+  void proceed(xmlNodePtr pNode,const AMDA::Parameters::CfgContext& pContext) {
+	ParameterManager* lParameterManager =  pContext.get<ParameterManager*>();
+
+	xmlChar* lParamName = xmlGetProp(pNode, (const xmlChar *) "id");
+	std::string paramNameStr;
+	if (lParamName) {
+		paramNameStr = std::string((char*)lParamName);
+		xmlFree(lParamName);
+	}
+	else {
+		ERROR_EXCEPTION( ERROR_MANDATORY_ATTRIBUTE_MISSING << pNode->name << "@id")
+	}
+
+	xmlChar* lRestrictionTime = xmlGetProp(pNode, (const xmlChar *) "restriction");
+	double restrictionTime = NAN;
+	if (lRestrictionTime) {
+		std::string restrictionTimeStr = std::string((char*)lRestrictionTime);
+		xmlFree(lRestrictionTime);
+		try
+		{
+			restrictionTime = boost::lexical_cast<double>(restrictionTimeStr);
+		}
+		catch (boost::bad_lexical_cast &)
+		{
+		}
+	}
+	else {
+		ERROR_EXCEPTION( ERROR_MANDATORY_ATTRIBUTE_MISSING << pNode->name << "@restriction")
+	}
+
+	lParameterManager->addParamTimeRestriction(paramNameStr, restrictionTime);
+  }
+};
+
 XMLRequestParser::XMLRequestParser(const char* pXSDFile) : XMLConfigurator(pXSDFile,false) {
 /*
 	<request>
@@ -310,6 +348,9 @@ XMLRequestParser::XMLRequestParser(const char* pXSDFile) : XMLConfigurator(pXSDF
 	    <timeInterval>0000000100000000</timeInterval>
 	  <interval>
 	  </times>
+	  <paramsTimeRestrictions>
+	    <param id="imf" restriction="1200441599"/>
+	  </paramsTimeRestrictions>
 	  <outputs>
 	  	<download>
 	    	<timeFormat>ISO</timeFormat>
@@ -352,6 +393,12 @@ XMLRequestParser::XMLRequestParser(const char* pXSDFile) : XMLConfigurator(pXSDF
 		}
 	}
 	{
+		// Params time restrictions node
+		NodeGrpCfg* lParamsTimeRestrictionsNode = new NodeGrpCfg();
+		lRequestNode->getChildList()["paramsTimeRestrictions"] = NodeCfgSPtr(lParamsTimeRestrictionsNode);
+		lParamsTimeRestrictionsNode->getChildList()["param"] = NodeCfgSPtr(new ParamTimeRestrictionNode);
+	}
+	{
 		// Output group node
 		NodeGrpCfg* lOutputNode = new NodeGrpCfg();
 		lRequestNode->getChildList()["outputs"] = NodeCfgSPtr(lOutputNode);