C++ ParametersMap::isDefined方法代码示例

		void Function::setOutputFormatFromMap(const ParametersMap& pm, const string& defaultFormat)
		{
			if(pm.isDefined(PARAMETER_OUTPUT_FORMAT))
			{
				_outputFormat = pm.get<string>(PARAMETER_OUTPUT_FORMAT);
			}
			else if(pm.isDefined(PARAMETER_OUTPUT_FORMAT_COMPAT))
			{
				_outputFormat = pm.get<string>(PARAMETER_OUTPUT_FORMAT_COMPAT);
			}
			else
			{
				_outputFormat = defaultFormat;
			}

			// Shortcuts
			if(_outputFormat == "json")
			{
				_outputFormat = MimeTypes::JSON;
			}
			if(_outputFormat == "xml")
			{
				_outputFormat = MimeTypes::XML;
			}
			if(_outputFormat == "csv")
			{
				_outputFormat = MimeTypes::CSV;
			}
		}

		void FreeDRTAreaUpdateAction::_setFromParametersMap(const ParametersMap& map)
		{
			if(map.getOptional<RegistryKeyType>(PARAMETER_AREA_ID)) try
			{
				_area = FreeDRTAreaTableSync::GetEditable(map.get<RegistryKeyType>(PARAMETER_AREA_ID), *_env);
			}
			catch (ObjectNotFoundException<FreeDRTArea>&)
			{
				throw ActionException("No such area");
			}
			else
			{
				_area.reset(new FreeDRTArea);
			}

			if(map.isDefined(PARAMETER_NAME))
			{
				_name = map.get<string>(PARAMETER_NAME);
			}

			if(map.isDefined(PARAMETER_CITIES))
			{
				_cities = FreeDRTAreaTableSync::UnserializeCities(map.get<string>(PARAMETER_CITIES), *_env);
			}

			if(map.isDefined(PARAMETER_STOP_AREAS))
			{
				_stopAreas = FreeDRTAreaTableSync::UnserializeStopAreas(map.get<string>(PARAMETER_STOP_AREAS), *_env);
			}

			if(map.getDefault<RegistryKeyType>(PARAMETER_COMMERCIAL_LINE_ID, 0))
			{
				try
				{
					_line = CommercialLineTableSync::GetEditable(map.get<RegistryKeyType>(PARAMETER_COMMERCIAL_LINE_ID), *_env);
				}
				catch (ObjectNotFoundException<CommercialLine>&)
				{
					throw ActionException("No such line");
				}
			}
		}

void JunctionUpdateAction::_setFromParametersMap(const ParametersMap& map)
{
    if(map.isDefined(PARAMETER_JUNCTION_ID))
    {
        try
        {
            _junction = JunctionTableSync::GetEditable(map.get<RegistryKeyType>(PARAMETER_JUNCTION_ID), *_env);
        }
        catch (ObjectNotFoundException<Junction>&)
        {
            throw ActionException("No such junction");
        }
    }
    else
    {
        _junction = boost::shared_ptr<Junction>(new Junction);
    }

    if(map.isDefined(PARAMETER_FROM_ID))
    {
        try
        {
            _from = StopPointTableSync::GetEditable(map.get<RegistryKeyType>(PARAMETER_FROM_ID), *_env);
        }
        catch(ObjectNotFoundException<StopPoint>&)
        {
            throw ActionException("No such from stop point");
        }
    }

    if(map.isDefined(PARAMETER_TO_ID))
    {
        try
        {
            _to = StopPointTableSync::GetEditable(map.get<RegistryKeyType>(PARAMETER_TO_ID), *_env);
        }
        catch(ObjectNotFoundException<StopPoint>&)
        {
            throw ActionException("No such to stop point");
        }
    }

    if(map.isDefined(PARAMETER_LENGTH))
    {
        _length = map.get<double>(PARAMETER_LENGTH);
    }

    if(map.isDefined(PARAMETER_TIME))
    {
        _duration = minutes(map.get<long>(PARAMETER_TIME));
    }

    if(map.isDefined(PARAMETER_BIDIRECTIONAL))
    {
        _bidirectional = map.getDefault<bool>(PARAMETER_BIDIRECTIONAL);
    }
}

		void ImportFunction::_setFromParametersMap(const ParametersMap& map)
		{
			// Import
			RegistryKeyType importId(map.get<RegistryKeyType>(PARAMETER_IMPORT_ID));
			try
			{
				boost::shared_ptr<const Import> import(ImportTableSync::Get(importId, *_env));
				if(!import->get<DataSource>())
				{
					throw RequestException("The id system of the specified import is not defined.");
				}

				// Log path
				bool outputLogs(map.getDefault<bool>(PARAMETER_OUTPUT_LOGS, false));

				// Min log force
				ImportLogLevel minLogLevel(import->get<MinLogLevel>());
				if(map.isDefined(PARAMETER_MIN_LOG_LEVEL))
				{
					minLogLevel = static_cast<ImportLogLevel>(map.get<int>(PARAMETER_MIN_LOG_LEVEL));
				}

				// Log path force
				string logPath(import->get<LogPath>());
				if(map.isDefined(PARAMETER_LOG_PATH))
				{
					logPath = map.get<string>(PARAMETER_LOG_PATH);
				}
				
				// Logger generation
				if(outputLogs)
				{
					// Importer generation
					_importer = import->getImporter(
						*_env,
						minLogLevel,
						logPath,
						_output,
						_result
					);
				}
				else
				{
					// Importer generation
					_importer = import->getImporter(
						*_env,
						minLogLevel,
						logPath,
						optional<ostream&>(),
						_result
					);
				}

				_importer->setFromParametersMap(map, true);

				_doImport = map.isTrue(PARAMETER_DO_IMPORT);
				_importDone = _importer->beforeParsing();
				_importDone &= _importer->parseFiles();
				_importDone &=_importer->afterParsing();
			}
			catch(ObjectNotFoundException<DataSource> e)
			{
				throw RequestException("Datasource not found");
			}
			catch(Exception e)
			{
				throw RequestException("Load failed : " + e.getMessage());
			}
		}

		void ScenariosListFunction::_setFromParametersMap(const ParametersMap& map)
		{
			_showTemplates = map.get<bool>(PARAMETER_SHOW_TEMPLATES);

			if(_showTemplates)
			{
				optional<RegistryKeyType> id(
					map.getOptional<RegistryKeyType>(PARAMETER_FOLDER_ID)
				);

				if (id)
				{
					try
					{
						_parentFolder = ScenarioFolderTableSync::Get(*id, *_env);
					}
					catch (ObjectNotFoundException<ScenarioFolder>&)
					{
						throw RequestException("Bad folder ID");
					}
				}
			}
			else
			{
				if(map.isDefined(PARAMETER_CURRENTLY_DISPLAYED))
				{
					_showCurrentlyDisplayed = map.get<bool>(PARAMETER_CURRENTLY_DISPLAYED);
				}
				else
				{
					_showCurrentlyDisplayed = optional<bool>();
				}
			}

			// CMS page for the display
			try
			{
				optional<RegistryKeyType> id(map.getOptional<RegistryKeyType>(PARAMETER_CMS_TEMPLATE_ID));
				if(id)
				{
					_cmsTemplate = Env::GetOfficialEnv().get<Webpage>(*id);
				}
			}
			catch (ObjectNotFoundException<Webpage>& e)
			{
				throw RequestException("No such CMS template : "+ e.getMessage());
			}

			// Section in
			if(!map.getDefault<string>(PARAMETER_SECTION_IN).empty())
			{
				try
				{
					_sectionIn = *Env::GetOfficialEnv().get<MessagesSection>(map.get<RegistryKeyType>(PARAMETER_SECTION_IN));
				}
				catch (bad_lexical_cast&)
				{
					throw RequestException("No such section");
				}
				catch(ObjectNotFoundException<MessagesSection>&)
				{
					throw RequestException("No such section");
				}
			}

			// Section out
			if(!map.getDefault<string>(PARAMETER_SECTION_OUT).empty())
			{
				try
				{
					_sectionOut = *Env::GetOfficialEnv().get<MessagesSection>(map.get<RegistryKeyType>(PARAMETER_SECTION_OUT));
				}
				catch (bad_lexical_cast&)
				{
					throw RequestException("No such section");
				}
				catch(ObjectNotFoundException<MessagesSection>&)
				{
					throw RequestException("No such section");
				}
			}

			// Text search
			string textSearch(map.getDefault<string>(PARAMETER_TEXT_SEARCH));
			if(!textSearch.empty())
			{
				_textSearch = textSearch;
			}

			// Archives only
			if(map.isDefined(PARAMETER_ARCHIVES))
			{
				_archivesOnly = map.getDefault<bool>(PARAMETER_ARCHIVES, false);
			}
		}

		void WebPageMenuFunction::_setFromParametersMap(const ParametersMap& map)
		{
			string targetStr(map.getDefault<string>(PARAMETER_ROOT_ID));
			ParametersMap::Trim(targetStr);
			if(!targetStr.empty() && targetStr[0] >= '0' && targetStr[0] <= '9')
			{
				_rootId = map.getOptional<RegistryKeyType>(PARAMETER_ROOT_ID);
				if(_rootId)
				{
					if(decodeTableId(*_rootId) == Webpage::CLASS_NUMBER) try
					{
						_root = Env::GetOfficialEnv().get<Webpage>(*_rootId).get();
					}
					catch (ObjectNotFoundException<Webpage>&)
					{
						throw RequestException("No such root page");
					}
					else if(decodeTableId(*_rootId) == Website::CLASS_NUMBER) try
					{
						_rootSite = Env::GetOfficialEnv().get<Website>(*_rootId).get();
					}
					catch (ObjectNotFoundException<Webpage>&)
					{
						throw RequestException("No such root site");
					}
				}
			}
			else if(!targetStr.empty())
			{	// Page by smart URL
				_root = getSite()->getPageBySmartURL(targetStr);
				if(!_root)
				{
					throw RequestException("No such web page");
				}
				_rootId = _root->getKey();
			}

			_minDepth = map.getDefault<size_t>(PARAMETER_MIN_DEPTH, 1);
			_maxDepth = map.getDefault<size_t>(PARAMETER_MAX_DEPTH, _minDepth);

			// Max number
			_maxNumber = map.getOptional<size_t>(PARAMETER_MAX_NUMBER);

			// CMS output
			if(map.isDefined(PARAMETER_ITEM_PAGE_ID))
			{
				RegistryKeyType pageId(map.get<RegistryKeyType>(PARAMETER_ITEM_PAGE_ID));
				try
				{
					_itemPage = Env::GetOfficialEnv().get<Webpage>(pageId);
				}
				catch(ObjectNotFoundException<Webpage>&)
				{
					throw RequestException("No such page "+ lexical_cast<string>(pageId));
				}
			}
			else if(!map.getDefault<string>(PARAMETER_OUTPUT_FORMAT).empty())
			{
				_outputFormat = map.get<string>(PARAMETER_OUTPUT_FORMAT);
			}
			else
			{
				// Old output (deprecated)
				for(size_t i(_minDepth); i<=_maxDepth; ++i)
				{
					MenuDefinition_ curMenuDefinition;
					curMenuDefinition.beginning = map.getDefault<string>(PARAMETER_BEGINNING + lexical_cast<string>(i));
					curMenuDefinition.ending = map.getDefault<string>(PARAMETER_ENDING + lexical_cast<string>(i));
					if(map.getOptional<string>(PARAMETER_BEGINNING_SELECTED + lexical_cast<string>(i)))
					{
						curMenuDefinition.beginningSelected = map.get<string>(PARAMETER_BEGINNING_SELECTED + lexical_cast<string>(i));
					}
					else
					{
						curMenuDefinition.beginningSelected = curMenuDefinition.beginning;
					}
					if(map.getOptional<string>(PARAMETER_ENDING_SELECTED + lexical_cast<string>(i)))
					{
						curMenuDefinition.endingSelected = map.getDefault<string>(PARAMETER_ENDING_SELECTED + lexical_cast<string>(i));
					}
					else
					{
						curMenuDefinition.endingSelected = curMenuDefinition.ending;
					}
					curMenuDefinition.beginningBeforeSubmenu = map.getDefault<string>(PARAMETER_BEGINNING_BEFORE_SUBMENU + lexical_cast<string>(i));
					curMenuDefinition.endingAfterSubmenu = map.getDefault<string>(PARAMETER_ENDING_AFTER_SUBMENU + lexical_cast<string>(i));
					_menuDefinition[i] = curMenuDefinition;
				}
			}

			// Raw data
			_rawData = map.getDefault<bool>(PARAMETER_RAW_DATA, false);
		}