Method suggestedStandardsBuildingTypes

src/model/SpaceType.cpp:334–403

    }

    std::vector<std::string> SpaceType_Impl::suggestedStandardsBuildingTypes() const {
      std::vector<std::string> result;

      const boost::optional<std::string> standardsTemplate = this->standardsTemplate();
      const boost::optional<std::string> standardsBuildingType = this->standardsBuildingType();

      // include values from json if template is already set
      if (standardsTemplate) {
        // Find the possible building_type names that have the template name
        // standardsJSON is an array of hashes (no nested levels)
        for (const auto& v : getStandardsJSON()) {
          const auto thisTemplate = v["template"].asString();
          if (thisTemplate == standardsTemplate.get()) {
            const Json::Value _buildingType = v["building_type"];
            if (_buildingType.isString()) {
              result.emplace_back(_buildingType.asString());
            }
          }
        }
      }

      // include values from model

      boost::optional<Building> building = this->model().getOptionalUniqueModelObject<Building>();
      boost::optional<std::string> buildingStandardsBuildingType;
      if (building) {
        buildingStandardsBuildingType = building->standardsBuildingType();
      }

      for (const SpaceType& other : this->model().getConcreteModelObjects<SpaceType>()) {
        if (other.handle() == this->handle()) {
          continue;
        }
        boost::optional<std::string> otherBuildingType = other.standardsBuildingType();
        if (otherBuildingType) {
          result.emplace_back(*otherBuildingType);
        }
      }

      // remove buildingStandardsBuildingType and standardsBuildingType
      IstringFind finder;
      if (buildingStandardsBuildingType) {
        finder.addTarget(*buildingStandardsBuildingType);
      }
      if (standardsBuildingType) {
        finder.addTarget(*standardsBuildingType);
      }
      auto it = std::remove_if(result.begin(), result.end(), finder);
      result.resize(std::distance(result.begin(), it));

      // sort
      std::sort(result.begin(), result.end(), IstringCompare());

      // make unique
      // DLM: have to sort before calling unique, unique only works on consecutive elements
      it = std::unique(result.begin(), result.end(), IstringEqual());
      result.resize(std::distance(result.begin(), it));