Retrieve the list of available room types

@QueryParam(name="roomtype_id", requirements="\d+", default="0", description="Id of the room type")

@param ParamFetcher $paramFetcher
770042
public function getRoomTypeDetailAction(ParamFetcher $paramFetcher)
    {
        $roomtypeId = $paramFetcher->get('roomtype_id');

        if (!$result = $this->getRoomTypeManager()->find($roomtypeId)) {
            return 'ok';
        }

        return $result;

    }
325126
private function isParamFetcherType(\ReflectionParameter $controllerParam)
    {
        $type = $controllerParam->getClass();
        if (null === $type) {
            return false;
        }

        return $type->implementsInterface(ParamFetcherInterface::class);
    }
1047389
public CmsGallerySearchResultList getResult(CmsGallerySearchParameters params) throws CmsException {

        CmsGallerySearchResultList result = null;
        if ((m_cms == null) || (m_index == null)) {
            throw new CmsException(Messages.get().container(Messages.ERR_SEARCH_NOT_INITIALIZED_0));
        }
        result = m_index.gallerySearch(m_cms, params);

        if (result.size() > 0) {

            result.calculatePages(params.getResultPage(), params.getMatchesPerPage());

        } else {
            result = new CmsGallerySearchResultList();
        }

        return result;
    }
915136
public function getFetchOptions( &$humanReadable = null )
    {
        // aid to result fetching debugging
        // get fetch options in a human readable format
        if( func_num_args() ) {
            $humanReadable = [];
            $refl = new \ReflectionClass( __CLASS__ );
            foreach( $refl->getConstants() as $name => $value ) {
                if( $value & $this->fetchOptions and strpos( $name, 'DEFAULT' ) === false ) {
                    $humanReadable[] = $name;
                }
            }
        }
        return $this->fetchOptions;
    }
112521
public final hqlParser.propertyFetch_return propertyFetch() throws RecognitionException {
		hqlParser.propertyFetch_return retval = new hqlParser.propertyFetch_return();
		retval.start = input.LT(1);

		CommonTree root_0 = null;

		Token FETCH118=null;
		Token ALL119=null;
		Token PROPERTIES120=null;

		CommonTree FETCH118_tree=null;
		CommonTree ALL119_tree=null;
		CommonTree PROPERTIES120_tree=null;

		try {
			// hql.g:327:2: ( FETCH ALL ! PROPERTIES !)
			// hql.g:327:4: FETCH ALL ! PROPERTIES !
			{
			root_0 = (CommonTree)adaptor.nil();


			FETCH118=(Token)match(input,FETCH,FOLLOW_FETCH_in_propertyFetch1556);
			FETCH118_tree = (CommonTree)adaptor.create(FETCH118);
			adaptor.addChild(root_0, FETCH118_tree);

			ALL119=(Token)match(input,ALL,FOLLOW_ALL_in_propertyFetch1558);
			PROPERTIES120=(Token)match(input,PROPERTIES,FOLLOW_PROPERTIES_in_propertyFetch1561);
			}

			retval.stop = input.LT(-1);

			retval.tree = (CommonTree)adaptor.rulePostProcessing(root_0);
			adaptor.setTokenBoundaries(retval.tree, retval.start, retval.stop);

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
			retval.tree = (CommonTree)adaptor.errorNode(input, retval.start, input.LT(-1), re);
		}
		finally {
			// do for sure before leaving
		}
		return retval;
	}
1362393
protected function filterCriteria(ParamFetcherInterface $paramFetcher)
    {
        $criteria = $paramFetcher->all();

        unset($criteria['page'], $criteria['count']);

        foreach ($criteria as $key => $value) {
            if (null === $value) {
                unset($criteria[$key]);
            }
        }

        return $criteria;
    }
1088200
function fetchExpandedTypes(sBaseMetaPath, mQueryOptions) {
			if (mQueryOptions && mQueryOptions.$expand) {
				Object.keys(mQueryOptions.$expand).forEach(function (sNavigationPath) {
					var sMetaPath = sBaseMetaPath;

					sNavigationPath.split("/").forEach(function (sSegment) {
						sMetaPath += "/" + sSegment;
						fetchType(sMetaPath);
					});
					fetchExpandedTypes(sMetaPath, mQueryOptions.$expand[sNavigationPath]);
				});
			}
		}
1186941
private String getSpecificJoinFetchAnnotation() {
        List<Relation> manyToManyRelations = relation.getToEntity().getManyToMany().getList();
        // we have only on many-to-many ? No problem, move on
        if (manyToManyRelations.size() <= 1) {
            return null;
        }
        // we have many many to many relations ? and one requires eager, then we need to set the fetchmode
        for (Relation relation : manyToManyRelations) {
            if (relation.getFetchTypeGetter() != null && relation.getFetchTypeGetter().getFetch() != null && relation.getFetchTypeGetter().getFetch().isEager()) {
                addImport("org.hibernate.annotations.Fetch");
                addImport("org.hibernate.annotations.FetchMode");
                return "@Fetch(value = FetchMode.SUBSELECT)";
            }
        }
        // no eager requested, move on
        return null;
    }
785612
@Override
    public <T extends ApiGameUser> List<T> in(ApiRoom room, Class<?> clazz) {
        Room sfsRoom = CommandUtil.getSfsRoom(room, extension);
        validateRoom(sfsRoom, room);
        return CommandUtil.getApiGameUserList(sfsRoom.getUserList(), clazz);
    }
1036829
public function typeCorrectedFetchAll()
    {
        if ($this->columnMeta === null) {
            $columnCount = $this->statement->columnCount();
            $this->columnMeta = [];
            for ($i = 0; $i<$columnCount; $i++) {
                $this->columnMeta[$i] = $this->statement->getColumnMeta($i);
            }
        }

        // Re-map fetched data using columnMeta
        return array_map(
            function ($rowArray) {
                $row = [];
                foreach ($this->columnMeta as $i => $meta) {
                    // Coerce any column types that aren't correctly retrieved from the database
                    if (isset($meta['native_type']) && isset(self::$type_mapping[$meta['native_type']])) {
                        settype($rowArray[$i], self::$type_mapping[$meta['native_type']]);
                    }
                    $row[$meta['name']] = $rowArray[$i];
                }
                return $row;
            },
            $this->statement->fetchAll(PDO::FETCH_NUM)
        );
    }
1299541
public function getByFetchStyle($fetchMode)
    {
        if (!isset($this->fetchers[$fetchMode])) {
            if (!isset($this->styleToFetcherMap[$fetchMode])) {
                throw new Exception('Fetch style not supported.');
            }

            $this->fetchers[$fetchMode] = new $this->styleToFetcherMap[$fetchMode]();
        }

        return $this->fetchers[$fetchMode];
    }
942057
public JSONObject getRoomByOffer(String company, String offerId, HashMap<String, String> params) throws JSONException {
        return oClient.get("/messages/v3/" + company + "/rooms/offers/" + offerId, params);
    }
904797
public function fetchAll(FetcherInterface $fetcher, FetchConfig $fetchConfig)
    {
        $fetchStyle = $fetchConfig->getFetchStyle();

        if (!$this->hasRowsForFetchStyle($fetchStyle)) {
            $this->rows[$fetchStyle] = $fetcher->fetchAll($this->rows[CorePDO::FETCH_BOTH], $fetchConfig);
        }

        return $this->rows[$fetchStyle];
    }
734381
public ChatRoomListResult getBatchChatRoomInfo(long... roomIds) throws APIConnectionException, APIRequestException {
        Preconditions.checkArgument(roomIds != null && roomIds.length > 0, "Room ids should not be null");
        JsonArray array = new JsonArray();
        for (long id : roomIds) {
            array.add(new JsonPrimitive(id));
        }
        ResponseWrapper responseWrapper = _httpClient.sendPost(_baseUrl + mChatRoomPath + "/batch", array.toString());
        return ChatRoomListResult.fromResponse(responseWrapper);
    }
357982
public static Fetch createDefaultEntityFetch(EntityType entityType, String languageCode) {
    boolean hasRefAttr = false;
    Fetch fetch = new Fetch();
    for (Attribute attr : entityType.getAtomicAttributes()) {
      Fetch subFetch = createDefaultAttributeFetch(attr, languageCode);
      if (subFetch != null) {
        hasRefAttr = true;
      }
      fetch.field(attr.getName(), subFetch);
    }
    return hasRefAttr ? fetch : null;
  }
756590
private boolean eligibleToFetch(List<String> columnsToSelect, String columnName)
    {
        return (columnsToSelect != null && !columnsToSelect.isEmpty() && columnsToSelect.contains(columnName))
                || (columnsToSelect == null || columnsToSelect.isEmpty());
    }
561880
final protected function setMapForOrderByParam(ParamFetcherInterface $paramFetcher)
    {
        $orderByQueryParam = new QueryParam();
        $orderByQueryParam->map = true;
        $paramFetcher->addParam($orderByQueryParam);

        return $paramFetcher;
    }