// test that when new type of order is set, others are disabled
TEST_F(IdfFixture,ObjectOrderBase_OrderSetters) {
  ObjectOrderBase orderer;

  IddObjectTypeVector order;
  order.push_back(openstudio::IddObjectType::Lights);
  order.push_back(openstudio::IddObjectType::Zone);
  order.push_back(openstudio::IddObjectType::RunPeriod);
  order.push_back(openstudio::IddObjectType::Building);

  orderer.setIddOrder(order);
  EXPECT_FALSE(orderer.orderByIddEnum());
  EXPECT_TRUE(orderer.less(openstudio::IddObjectType::Lights,openstudio::IddObjectType::Building));

  orderer.setOrderByIddEnum();
  EXPECT_TRUE(orderer.orderByIddEnum());
  EXPECT_FALSE(orderer.iddOrder());
  EXPECT_TRUE(orderer.less(openstudio::IddObjectType::Building,openstudio::IddObjectType::Lights));

  orderer.setDirectOrder();
  EXPECT_FALSE(orderer.orderByIddEnum());
  EXPECT_FALSE(orderer.iddOrder());
}
TEST_F(IdfFixture,WorkspaceObjectOrder_ByIddObjectType) {
  Workspace workspace(IdfFixture::epIdfFile,openstudio::StrictnessLevel::Draft);
  WorkspaceObjectVector objectsInOriginalOrder = workspace.objects(true);

  WorkspaceObjectOrder wsOrder = workspace.order();
  IddObjectTypeVector orderByType;
  IntSet enumValues = IddObjectType::getValues();
  for (int val : enumValues) {
    orderByType.push_back(IddObjectType(val));
  }
  wsOrder.setIddOrder(orderByType);
  WorkspaceObjectVector objectsInNewOrder = workspace.objects(true);
  EXPECT_EQ(objectsInOriginalOrder.size(),objectsInNewOrder.size());
  EXPECT_FALSE(objectsInOriginalOrder == objectsInNewOrder);

  // expect Materials before Constructions
  OptionalWorkspaceObject oMaterial;
  OptionalWorkspaceObject oConstruction;
  for (const WorkspaceObject& object : objectsInNewOrder) {
    if (!oMaterial && (object.iddObject().type() == IddObjectType::Material)) {
      oMaterial = object;
      EXPECT_FALSE(oConstruction);
      OptionalUnsigned oIndex = wsOrder.indexInOrder(object.handle());
      EXPECT_FALSE(oIndex);
    }
    if (!oConstruction && (object.iddObject().type() == IddObjectType::Construction)) {
      oConstruction = object;
    }
    if (oMaterial && oConstruction) { break; }
  }

  // change to Constructions before Materials
  wsOrder.move(IddObjectType::Construction,IddObjectType::Material);
  objectsInNewOrder = workspace.objects(true);
  oMaterial = boost::none;
  oConstruction = boost::none;
  for (const WorkspaceObject& object : objectsInNewOrder) {
    if (!oMaterial && (object.iddObject().type() == IddObjectType::Material)) {
      oMaterial = object;
    }
    if (!oConstruction && (object.iddObject().type() == IddObjectType::Construction)) {
      oConstruction = object;
      EXPECT_FALSE(oMaterial);
    }
    if (oMaterial && oConstruction) { break; }
  }

}
TEST_F(IdfFixture,ObjectOrderBase_ManipulateIddObjectTypeOrder) {
  IddObjectTypeVector order;
  order.push_back(openstudio::IddObjectType::Lights);    // 0
  order.push_back(openstudio::IddObjectType::Zone);      // 1
  order.push_back(openstudio::IddObjectType::RunPeriod); // 2
  order.push_back(openstudio::IddObjectType::Building);  // 3

  ObjectOrderBase orderer(order);
  bool success;

  // push_back
  success = orderer.push_back(openstudio::IddObjectType::Schedule_Compact); // 4
  EXPECT_TRUE(success);
  EXPECT_EQ(static_cast<unsigned>(4),*(orderer.indexInOrder(openstudio::IddObjectType::Schedule_Compact)));
  EXPECT_EQ(static_cast<unsigned>(5),*(orderer.indexInOrder(openstudio::IddObjectType::Schedule_Day_Hourly)));
  EXPECT_TRUE(orderer.less(openstudio::IddObjectType::Schedule_Compact,
                           openstudio::IddObjectType::DesignSpecification_OutdoorAir));
  EXPECT_FALSE(orderer.less(openstudio::IddObjectType::DesignSpecification_OutdoorAir,
                            openstudio::IddObjectType::Schedule_Day_Hourly));

  // insert behind IddObjectType
  success = orderer.insert(openstudio::IddObjectType::Ceiling_Adiabatic,IddObjectType(IddObjectType::Building));
  EXPECT_TRUE(success);
  EXPECT_EQ(static_cast<unsigned>(3),*(orderer.indexInOrder(openstudio::IddObjectType::Ceiling_Adiabatic)));
  success = orderer.insert(IddObjectType::Daylighting_Controls,
                           IddObjectType(IddObjectType::AirflowNetwork_Distribution_Node));
  EXPECT_TRUE(success);
  EXPECT_EQ(orderer.iddOrder()->size() - 1,
            *(orderer.indexInOrder(openstudio::IddObjectType::Daylighting_Controls)));

  // insert at index
  success = orderer.insert(openstudio::IddObjectType::ThermalStorage_ChilledWater_Mixed,2);
  EXPECT_TRUE(success);
  EXPECT_EQ(static_cast<unsigned>(2),
            *(orderer.indexInOrder(openstudio::IddObjectType::ThermalStorage_ChilledWater_Mixed)));
  success = orderer.insert(openstudio::IddObjectType::Refrigeration_CompressorList,37891);
  EXPECT_TRUE(success);
  EXPECT_EQ(orderer.iddOrder()->size() - 1,
            *(orderer.indexInOrder(openstudio::IddObjectType::Refrigeration_CompressorList)));

  // move before IddObjectType
  unsigned n = orderer.iddOrder()->size();
  success = orderer.move(openstudio::IddObjectType::Refrigeration_CompressorList,
                         IddObjectType(IddObjectType::Lights));
  EXPECT_TRUE(success);
  EXPECT_EQ(static_cast<unsigned>(0),
            *(orderer.indexInOrder(openstudio::IddObjectType::Refrigeration_CompressorList)));
  success = orderer.move(openstudio::IddObjectType::ElectricLoadCenter_Generators,
                         IddObjectType(IddObjectType::Building));
  EXPECT_FALSE(success);
  success = orderer.move(openstudio::IddObjectType::Building,
                         IddObjectType(IddObjectType::ElectricLoadCenter_Generators));
  EXPECT_TRUE(success);
  EXPECT_EQ(orderer.iddOrder()->size() - 1,
            *(orderer.indexInOrder(openstudio::IddObjectType::Building)));
  EXPECT_EQ(n,orderer.iddOrder()->size());

  // move to index
  success = orderer.move(openstudio::IddObjectType::Building,0);
  EXPECT_TRUE(success);
  EXPECT_EQ(static_cast<unsigned>(0),
            *(orderer.indexInOrder(openstudio::IddObjectType::Building)));
  success = orderer.move(openstudio::IddObjectType::RunPeriod,18601);
  EXPECT_TRUE(success);
  EXPECT_EQ(orderer.iddOrder()->size() - 1,
            *(orderer.indexInOrder(openstudio::IddObjectType::RunPeriod)));
  success = orderer.move(openstudio::IddObjectType::ZoneControl_Humidistat,0);
  EXPECT_FALSE(success);
  EXPECT_EQ(n,orderer.iddOrder()->size());

  // swap
  unsigned i = *(orderer.indexInOrder(openstudio::IddObjectType::Lights));
  unsigned j = *(orderer.indexInOrder(openstudio::IddObjectType::Refrigeration_CompressorList));
  success = orderer.swap(openstudio::IddObjectType::Lights,
                         openstudio::IddObjectType::Refrigeration_CompressorList);
  EXPECT_TRUE(success);
  EXPECT_EQ(i,*(orderer.indexInOrder(openstudio::IddObjectType::Refrigeration_CompressorList)));
  EXPECT_EQ(j,*(orderer.indexInOrder(openstudio::IddObjectType::Lights)));
  EXPECT_EQ(n,orderer.iddOrder()->size());

  // erase
  success = orderer.erase(openstudio::IddObjectType::Refrigeration_CompressorList);
  EXPECT_TRUE(success);
  EXPECT_EQ(orderer.iddOrder()->size(),
            *(orderer.indexInOrder(openstudio::IddObjectType::Refrigeration_CompressorList)));
  success = orderer.erase(openstudio::IddObjectType::Refrigeration_CompressorList);
  EXPECT_FALSE(success);
  EXPECT_TRUE(orderer.iddOrder()->size() < n);
}
Beispiel #4
0
 std::vector<IddObjectType> RunPeriod_Impl::allowableChildTypes() const {
   IddObjectTypeVector result;
   result.push_back(SkyTemperature::iddObjectType());
   return result;
 }
 std::vector<IddObjectType> SimulationControl_Impl::allowableChildTypes() const {
   IddObjectTypeVector result;
   result.push_back(ConvergenceLimits::iddObjectType());
   result.push_back(HeatBalanceAlgorithm::iddObjectType());
   result.push_back(InsideSurfaceConvectionAlgorithm::iddObjectType());
   result.push_back(OutsideSurfaceConvectionAlgorithm::iddObjectType());
   result.push_back(RunPeriod::iddObjectType());
   result.push_back(ShadowCalculation::iddObjectType());
   result.push_back(SizingParameters::iddObjectType());
   result.push_back(Timestep::iddObjectType());
   result.push_back(ZoneAirContaminantBalance::iddObjectType());
   result.push_back(ZoneAirHeatBalanceAlgorithm::iddObjectType());
   result.push_back(ZoneCapacitanceMultiplierResearchSpecial::iddObjectType());
   return result;
 }
 std::vector<IddObjectType> ConstructionBase_Impl::allowableChildTypes() const {
   IddObjectTypeVector result;
   result.push_back(StandardsInformationConstruction::iddObjectType());
   return result;
 }