void msPhysicalInterface::declarePhysicalVariable(double* ptr,double value,const msUnit& unit,string id) {
      
        LOGGER_ENTER_FUNCTION_DBG("void msPhysicalInterface::declarePhysicalVariable(double* ptr,double value,const msUnit& unit,string id)", getFullId());
	 
        if(id=="") id = "var_"+output::getString<size_t>(PhysicalVariables.size());
        *ptr = getUnits()->convert(unit,value);
        PhysicalVariables[id] = boost::shared_ptr<msPhysicalVariable>(new msPhysicalVariable(id,ptr,unit));
	LOGGER_EXIT_FUNCTION2("void msPhysicalInterface::declarePhysicalVariable(double* ptr,double value,const msUnit& unit,string id)");
       //PtrOnPhysicalVariables[ptr] =  unit;
    }
 boost::shared_ptr<msTreeMapper> msPhysicalInterface::homogenizeUnits() {
     
     vector<boost::shared_ptr<msPhysicalInterface> > children =
         getChildrenDerivedFrom<msPhysicalInterface>("msPhysicalInterface");
     
     vector<boost::shared_ptr<msPhysicalInterface> >::iterator it;
     
     for( it = children.begin(); it != children.end();++it){
         (*it)->setUnits(getUnits());
     }
     return mySharedPtr();
 }
Beispiel #3
0
void WeatherPlugin::timeout()
{
    if (!getSocketFactory()->isActive() || m_fetch_id || (*getID() == 0))
        return;
    time_t now;
    time(&now);
    if ((unsigned)now < getTime() + CHECK_INTERVAL)
        return;
	string url = "http://xoap.weather.com/weather/local/";
	url += getID();
	url += "?cc=*&prod=xoap&par=1004517364&key=a29796f587f206b2&unit=";
	url += getUnits() ? "s" : "m";
    m_fetch_id = fetch(url.c_str());
}
// passing in a unit type of 0 returns a count of all units
size_t UnitInfoManager::getUnitTypeCount(int player, sc2::UnitTypeID type, bool completed) const
{
    size_t count = 0;

    for (auto & unit : getUnits(player))
    {
        if ((!type || type == unit.unit_type) && (!completed || unit.build_progress == 1.0f))
        {
            count++;
        }
    }

    return count;
}
Parameter Parameter::getElementParameter()
{
  Parameter element_parameter;
  element_parameter.setType(getArrayElementType());
  element_parameter.setUnits(getUnits());
  if (rangeIsSet())
  {
    element_parameter.setRange(getRangeMin(),getRangeMax());
  }
  if (subsetIsSet())
  {
    element_parameter.setSubset(getSubset());
  }
  return element_parameter;
}
Beispiel #6
0
ossimProjection* ossimFgdcXmlDoc::getProjection()
{
   if ( m_projection.valid() )
   {
      return m_projection.get();
   }
   
   ossimDrect rect = getBoundingBox();
   ossimString projName (getProjCsn());
   
   if (!projName.empty())
   {
      m_projection = ossimEpsgProjectionFactory::instance()->createProjection(projName);
      
      if ( m_projection.valid() )
      {
         ossimDpt gsd(fabs(getXRes()), fabs(getYRes()));
         ossimMapProjection* mapProj = dynamic_cast<ossimMapProjection*>(m_projection.get());
         if (mapProj)
         {
            if (mapProj->isGeographic())
            {
               ossimGpt tie(rect.ul().lat, rect.ul().lon);
               mapProj->setUlTiePoints(tie);
               mapProj->setDecimalDegreesPerPixel(gsd);
            }
            else
            {
               ossimDpt tie(rect.ul().x, rect.ul().y);
               if (getUnits().upcase() == "FEET")
               {
                  gsd = gsd * METER_PER_FOOT;
                  tie = tie * METER_PER_FOOT;
               }
               mapProj->setUlTiePoints(tie);
               mapProj->setMetersPerPixel(gsd);
            }
         }
      }
   }
   return m_projection.get();
}
void WeatherPlugin::timeout()
{
    if (!getSocketFactory()->isActive() || !isDone() || (*getID() == 0))
        return;
    time_t now = time(NULL);
    if ((unsigned)now < getTime() + CHECK1_INTERVAL)
        return;
    m_bForecast = false;
    if ((unsigned)now >= getForecastTime() + CHECK2_INTERVAL)
        m_bForecast = true;
    string url = "http://xoap.weather.com/weather/local/";
    url += getID();
    url += "?cc=*&prod=xoap&par=1004517364&key=a29796f587f206b2&unit=";
    url += getUnits() ? "s" : "m";
    if (m_bForecast && getForecast()){
        url += "&dayf=";
        url += number(getForecast());
    }
    fetch(url.c_str());
}
Beispiel #8
0
void TimelineIndicator::mouseDrag (const MouseEvent& ev)
{
    if (! dragable())
        return;

    Rectangle<int> r (getBoundsInParent());

    dragger.dragComponent (this, ev, nullptr);
    int snap = shouldSnap ? timeline()->pixelSnap (getBoundsInParent().getX())
                          : getBoundsInParent().getX();

    setBounds (r); // reset it back to normal

    if (snap != lastSnap || ! shouldSnap)
    {
        setBounds (snap, 0, 1, timeline()->getHeight());
        pos.setValue (getUnits());
        lastSnap = snap;
    }
}
void CtrlInfo::show(FILE *f) const
{
    if (getType() == Numeric)
    {
        fprintf(f, "CtrlInfo: Numeric\n");
        fprintf(f, "Display : %g ... %g\n", getDisplayLow(), getDisplayHigh());
        fprintf(f, "Alarm   : %g ... %g\n", getLowAlarm(), getHighAlarm());
        fprintf(f, "Warning : %g ... %g\n", getLowWarning(), getHighWarning());
        fprintf(f, "Prec    : %ld '%s'\n", (long)getPrecision(), getUnits());
    }
    else if (getType() == Enumerated)
    {
        fprintf(f, "CtrlInfo: Enumerated\n");
        fprintf(f, "States:\n");
        size_t i, len;
        for (i=0; i<getNumStates(); ++i)
        {
            fprintf(f, "\tstate='%s'\n", getState(i, len));
        }
    }
    else
        fprintf(f, "CtrlInfo: Unknown\n");
}
monitoringDataType LH_HWiNFOData::getType()
{
    return getType(getUnits());
}
void DragoonManager::executeMicro(const UnitVector & targets, BWAPI::Position regroup) 
{
	const UnitVector & dragoons = getUnits();

	// figure out targets
	UnitVector dragoonTargets;
	for (size_t i(0); i<targets.size(); i++) 
	{
		// conditions for targeting
		if (targets[i]->isVisible()) 
		{
			dragoonTargets.push_back(targets[i]);
		}
	}

	// for each zealot
	BOOST_FOREACH(BWAPI::Unit * dragoon, dragoons)
	{
		if (DRAW_UALBERTABOT_DEBUG) BWAPI::Broodwar->drawLineMap(dragoon->getPosition().x(), dragoon->getPosition().y(), 
			dragoon->getTargetPosition().x(), dragoon->getTargetPosition().y(), BWAPI::Colors::White);

		// regroup if we have to regroup and we're not near an enemy
		if (order.type == order.Attack && regroup != BWAPI::Position(0,0))// && !unitNearEnemy(dragoon))
		{
			if (DRAW_UALBERTABOT_DEBUG) BWAPI::Broodwar->drawCircleMap(dragoon->getPosition().x(), dragoon->getPosition().y(), 3, BWAPI::Colors::Orange, true);

			// if the zealot is outside the regroup area
			if (dragoon->getDistance(regroup) > 100)
			{
				// regroup it
				smartMove(dragoon, regroup);
			}
			else
			{
				smartAttackMove(dragoon, dragoon->getPosition());
			}
		}
		// otherwise this unit is not regrouping
		else
		{
			// if the order is to attack or defend
			if (order.type == order.Attack || order.type == order.Defend) {

				// if there are targets
				if (!dragoonTargets.empty())
				{
					// find the best target for this zealot
					BWAPI::Unit * target = getTarget(dragoon, dragoonTargets);
					// attack it
					smartAttackUnit(dragoon, target);
				}
				// if there are no targets
				else
				{
					// if we're not near the order position
					if (dragoon->getDistance(order.position) > 100)
					{
						// move to it
						smartAttackMove(dragoon, order.position);
					}
				}
			}
		}
	}
}
void Parameter::writeApi(Response & response,
  bool write_name_only,
  bool is_property,
  bool write_firmware,
  bool write_instance_details)
{
  if (response.error())
  {
    return;
  }

  const ConstantString & name = getName();
  if (write_name_only)
  {
    response.write(name);
    return;
  }

  response.beginObject();

  response.write(constants::name_constant_string,name);

  if (write_firmware)
  {
    const ConstantString & firmware_name = getFirmwareName();
    response.write(constants::firmware_constant_string,firmware_name);
  }

  JsonStream::JsonTypes type = getType();
  if (write_instance_details)
  {
    switch (type)
    {
      case JsonStream::LONG_TYPE:
      {
        response.write(constants::type_constant_string,JsonStream::LONG_TYPE);
        if (subsetIsSet())
        {
          response.writeKey(constants::subset_constant_string);
          response.write(getSubset(),JsonStream::LONG_TYPE);
        }
        if (rangeIsSet())
        {
          long min = getRangeMin().l;
          long max = getRangeMax().l;
          response.write(constants::min_constant_string,min);
          response.write(constants::max_constant_string,max);
        }
        break;
      }
      case JsonStream::DOUBLE_TYPE:
      {
        response.write(constants::type_constant_string,JsonStream::DOUBLE_TYPE);
        if (rangeIsSet())
        {
          double min = getRangeMin().d;
          double max = getRangeMax().d;
          response.write(constants::min_constant_string,min);
          response.write(constants::max_constant_string,max);
        }
        break;
      }
      case JsonStream::BOOL_TYPE:
      {
        response.write(constants::type_constant_string,JsonStream::BOOL_TYPE);
        break;
      }
      case JsonStream::NULL_TYPE:
      {
        break;
      }
      case JsonStream::STRING_TYPE:
      {
        response.write(constants::type_constant_string,JsonStream::STRING_TYPE);
        if (subsetIsSet())
        {
          response.writeKey(constants::subset_constant_string);
          response.write(getSubset(),JsonStream::STRING_TYPE);
        }
        break;
      }
      case JsonStream::OBJECT_TYPE:
      {
        response.write(constants::type_constant_string,JsonStream::OBJECT_TYPE);
        break;
      }
      case JsonStream::ARRAY_TYPE:
      {
        response.write(constants::type_constant_string,JsonStream::ARRAY_TYPE);
        JsonStream::JsonTypes array_element_type = getArrayElementType();
        switch (array_element_type)
        {
          case JsonStream::LONG_TYPE:
          {
            response.write(constants::array_element_type_constant_string,JsonStream::LONG_TYPE);
            if (subsetIsSet())
            {
              response.writeKey(constants::array_element_subset_constant_string);
              response.write(getSubset(),JsonStream::LONG_TYPE);
            }
            if (rangeIsSet())
            {
              long min = getRangeMin().l;
              long max = getRangeMax().l;
              response.write(constants::array_element_min_constant_string,min);
              response.write(constants::array_element_max_constant_string,max);
            }
            break;
          }
          case JsonStream::DOUBLE_TYPE:
          {
            response.write(constants::array_element_type_constant_string,JsonStream::DOUBLE_TYPE);
            if (rangeIsSet())
            {
              double min = getRangeMin().d;
              double max = getRangeMax().d;
              response.write(constants::array_element_min_constant_string,min);
              response.write(constants::array_element_max_constant_string,max);
            }
            break;
          }
          case JsonStream::BOOL_TYPE:
          {
            response.write(constants::array_element_type_constant_string,JsonStream::BOOL_TYPE);
            break;
          }
          case JsonStream::NULL_TYPE:
          {
            break;
          }
          case JsonStream::STRING_TYPE:
          {
            response.write(constants::array_element_type_constant_string,JsonStream::STRING_TYPE);
            if (subsetIsSet())
            {
              response.writeKey(constants::array_element_subset_constant_string);
              response.write(getSubset(),JsonStream::STRING_TYPE);
            }
            break;
          }
          case JsonStream::OBJECT_TYPE:
          {
            response.write(constants::array_element_type_constant_string,JsonStream::OBJECT_TYPE);
            break;
          }
          case JsonStream::ARRAY_TYPE:
          {
            response.write(constants::array_element_type_constant_string,JsonStream::ARRAY_TYPE);
            break;
          }
          case JsonStream::ANY_TYPE:
          {
            response.write(constants::array_element_type_constant_string,JsonStream::ANY_TYPE);
            break;
          }
        }
        if (arrayLengthRangeIsSet() && !is_property)
        {
          size_t array_length_min = getArrayLengthMin();
          size_t array_length_max = getArrayLengthMax();
          response.write(constants::array_length_min_constant_string,array_length_min);
          response.write(constants::array_length_max_constant_string,array_length_max);
        }
        break;
      }
      case JsonStream::ANY_TYPE:
      {
        response.write(constants::type_constant_string,JsonStream::ANY_TYPE);
        break;
      }
    }
  }
  else
  {
    response.write(constants::type_constant_string,type);
    if (type == JsonStream::ARRAY_TYPE)
    {
      JsonStream::JsonTypes array_element_type = getArrayElementType();
      response.write(constants::array_element_type_constant_string,array_element_type);
    }
  }

  if (write_instance_details)
  {
    const ConstantString & units = getUnits();
    if (units.length() != 0)
    {
      response.write(constants::units_constant_string,units);
    }
  }

  if (!is_property)
  {
    response.endObject();
  }
}
Beispiel #13
0
void RangedManager::executeMicro(const UnitVector & targets) 
{
	const UnitVector & rangedUnits = getUnits();

	// figure out targets
	UnitVector rangedUnitTargets;
	for (size_t i(0); i<targets.size(); i++) 
	{
		// conditions for targeting
		if (targets[i]->isVisible()) 
		{
			rangedUnitTargets.push_back(targets[i]);
		}
	}

	// for each zealot
	BOOST_FOREACH(BWAPI::Unit * rangedUnit, rangedUnits)
	{
		// train sub units such as scarabs or interceptors
		//trainSubUnits(rangedUnit);

		// if the order is to attack or defend
		if (order.type == order.Attack || order.type == order.Defend || order.type == order.Tanks || order.type == order.Vultures || order.type == order.Goliaths || order.type == order.Marines) {

			// if there are targets
			if (!rangedUnitTargets.empty())
			{
				// find the best target for this zealot
				BWAPI::Unit * target = getTarget(rangedUnit, rangedUnitTargets);

				// attack it
				if (!rangedUnit->getType() == BWAPI::UnitTypes::Terran_Siege_Tank_Tank_Mode) {
					kiteTarget(rangedUnit, target);
				}
				else {
					smartPositionAndDefend(rangedUnit,order.position);
				}
			}
			// if there are no targets
			else
			{
				// if we're not in range of the position
				if (rangedUnit->getDistance(order.position) > rangedUnit->getInitialType().groundWeapon().maxRange())
				{
					//unsiege tanks if they're sieged
					if (rangedUnit->getType() == BWAPI::UnitTypes::Terran_Siege_Tank_Siege_Mode) {
						rangedUnit->unsiege();
					}
					// move to it
					if (! (order.type == order.Defend)) {
						smartAttackMove(rangedUnit, order.position);
					}
					else {
						smartPositionAndDefend(rangedUnit,order.position);
					}
				}
				//else if we're in range and we're supposed to s
				else if (rangedUnit->getType() == BWAPI::UnitTypes::Terran_Siege_Tank_Tank_Mode) {
					rangedUnit->siege();
				}
			}
		}

		if (Options::Debug::DRAW_UALBERTABOT_DEBUG) 
		{
			BWAPI::Broodwar->drawLineMap(rangedUnit->getPosition().x(), rangedUnit->getPosition().y(), 
				rangedUnit->getTargetPosition().x(), rangedUnit->getTargetPosition().y(), Options::Debug::COLOR_LINE_TARGET);
		}
	}
}
Beispiel #14
0
// Draws a timescale (physical). Note this can fail if the span is short
// enough which can happen when we find no events.
QString VisWidget::drawTimescale(QPainter * painter, unsigned long long start,
                              unsigned long long span, int margin)
{
    // Draw the scale bar
    int lineHeight = rect().height() - (timescaleHeight - 1);
    painter->setPen(QPen(Qt::black, 1, Qt::SolidLine));
    painter->drawLine(margin, lineHeight, rect().width() - margin, lineHeight);

    if (!visProcessed)
        return "";

    painter->setFont(QFont("Helvetica", 10));
    QFontMetrics font_metrics = this->fontMetrics();

    // Figure out the units and number of ticks ( may handle units later )
    QLocale systemlocale = QLocale::system();
    QString text = systemlocale.toString(start);
    int textWidth = font_metrics.width(text) * 1.4;

    // We can't have more than this and fit text
    int max_ticks = floor((rect().width() - 2*margin) / 1.0 / textWidth);

    int y = lineHeight + timescaleTickHeight + font_metrics.xHeight() + 4;

    // We want a round number
    unsigned long long tick_span = span / max_ticks; // Not round
    int power = floor(log10(tick_span)); // How many zeros
    unsigned long long roundfactor = std::max(1.0, pow(10, power));
    tick_span = (tick_span / roundfactor) * roundfactor; // Now round
    if (tick_span < 1)
        tick_span = 1;

    // Now we must find the first number after startTime divisible by
    // the tick_span. We don't want to just find the same roundness
    // because then panning doesn't work.
    unsigned long long tick = (tick_span - start % tick_span) + start;

    // TODO: MAKE THIS PART OPTIONAL
    QString seconds = getUnits(trace->units);
    int tick_divisor = 1;
    unsigned long long tick_base = 0;
    if (!options->absoluteTime)
    {
        tick_base = tick - tick_span;
        int span_unit = (int) floor(log10(tick_span));
        tick_divisor = pow(3 * floor(span_unit / 3), 10);
        if (!tick_divisor)
            tick_divisor = 1;
        seconds = systemlocale.toString(tick_base
                                        / pow((double) trace->units, 10),
                                        'f', trace->units - span_unit)
                                        + "s + "
                                        + getUnits(trace->units
                                                   - 3 * floor(span_unit / 3))
                                        + ":";
    }


    // And now we draw
    while (tick < start + span)
    {
        int x = margin + round((tick - start) / 1.0 / span
                               * (rect().width() - 2*margin));
        painter->drawLine(x, lineHeight, x, lineHeight + timescaleTickHeight);
        text = systemlocale.toString((tick - tick_base) / tick_divisor);
        textWidth = font_metrics.width(text) / 3;
        painter->drawText(x - textWidth, y, text);

        tick += tick_span;
    }
    return seconds;
}
Beispiel #15
0
bool ossimAuxXmlSupportData::initializeProjection( const ossimXmlDocument xdoc,
                                                   const std::string& wkt, 
                                                   ossimProjection* proj ) const
{
   bool result = false;

   ossimRefPtr<ossimMapProjection> mapProj = dynamic_cast<ossimMapProjection*>( proj );
   if ( mapProj.valid() )
   {
      // Find the tie and scale.
      ossimString path = "/PAMDataset/Metadata/MDI";
      std::vector<ossimRefPtr<ossimXmlNode> > xnodes;
      xdoc.findNodes(path, xnodes);
      if ( xnodes.size() )
      {
         ossimDpt tie;
         ossimDpt scale;
         tie.makeNan();
         scale.makeNan();
         
         for ( ossim_uint32 i = 0; i < xnodes.size(); ++i )
         {
            if ( xnodes[i].valid() )
            {
               ossimString value;
               ossimString attrName = "key";
               
               ossimRefPtr<ossimXmlAttribute> attr = xnodes[i]->findAttribute( attrName );
               if ( attr.valid() )
               {
                  if (attr->getValue() == "IMAGE__XY_ORIGIN" )
                  {
                     value = xnodes[i]->getText();
                     if ( value.size() )
                     {
                        // Split it:
                        std::vector<ossimString> list;
                        value.split( list, ossimString(","), true );
                        if ( list.size() == 2 )
                        {
                           if ( list[0].size() )
                           {
                              tie.x = list[0].toFloat64();
                           }
                           if ( list[1].size() )
                           {
                              tie.y = list[1].toFloat64();
                           }
                        }
                     }
                  }
                  else if (attr->getValue() == "IMAGE__X_RESOLUTION" )
                  {
                     value = xnodes[i]->getText();
                     if ( value.size() )
                     {
                        scale.x = value.toFloat64();
                     }
                  }
                  else if (attr->getValue() == "IMAGE__Y_RESOLUTION" )
                  {
                     value = xnodes[i]->getText();
                     if ( value.size() )
                     {
                        scale.y = value.toFloat64();
                     }
                  }
               }
               
            } // Matches: if ( xnodes[i].valid() )
            
         } // Matches: for ( ossim_uint32 i = 0; i < xnodes.size(); ++i )

         if ( !tie.hasNans() && !scale.hasNans() )
         {
            if ( mapProj->isGeographic() )
            {
               // Assuming tie and scale in decimal degrees:
               mapProj->setDecimalDegreesPerPixel( scale );
               ossimGpt gpt(tie.y, tie.x, 0.0);
               mapProj->setUlTiePoints( ossimGpt( gpt ) );
               result = true;
            }
            else
            {
               // Get the units:
               ossimUnitType units = getUnits( wkt );

               // Convert to meters:
               result = true;
               if ( units != OSSIM_METERS )
               {
                  if ( units == OSSIM_FEET )
                  {
                     tie.x = tie.x * MTRS_PER_FT;
                     tie.y = tie.y * MTRS_PER_FT;
                     scale.x = scale.x * MTRS_PER_FT;
                     scale.y = scale.y * MTRS_PER_FT;                     
                  }
                  else if ( units == OSSIM_US_SURVEY_FEET)
                  {
                     tie.x = tie.x * US_METERS_PER_FT;
                     tie.y = tie.y * US_METERS_PER_FT;
                     scale.x = scale.x * OSSIM_US_SURVEY_FEET;
                     scale.y = scale.y * OSSIM_US_SURVEY_FEET;
                  }
                  else
                  {
                     ossimNotify(ossimNotifyLevel_WARN)
                        << "ossimAuxXmlSupportData::initializeProjection WARNING: "
                        << "Unhandled unit type: " << units << std::endl;
                     result = false;
                  }
               }

               if ( result )
               {
                  mapProj->setMetersPerPixel( scale );
                  mapProj->setUlTiePoints( tie );
               }
            }
         }
         
      } // Matches: if ( xnodes.size() ) 
   }

   return result;
   
} // ossimAuxXmlSupportData::initializeProjection
Beispiel #16
0
void RangedManager::executeMicro(const UnitVector & targets) 
{
	const UnitVector & rangedUnits = getUnits();

	// figure out targets
	UnitVector rangedUnitTargets;
	for (size_t i(0); i<targets.size(); i++) 
	{
		// conditions for targeting
		if (targets[i]->isVisible()) 
		{
			rangedUnitTargets.push_back(targets[i]);
		}
	}

	// for each zealot
	BOOST_FOREACH(BWAPI::Unit * rangedUnit, rangedUnits)
	{
		// train sub units such as scarabs or interceptors
		//trainSubUnits(rangedUnit);

		// if the order is to attack or defend
		if (order.type == order.Attack || order.type == order.Defend) {

			// if there are targets
			if (!rangedUnitTargets.empty())
			{
				

				// find the best target for this zealot
				BWAPI::Unit * target = getTarget(rangedUnit, rangedUnitTargets);

				/*
				if ( rangedUnit->getType().groundWeapon().maxRange() < target->getDistance(rangedUnit))
				{
					if(rangedUnit->getType() == BWAPI::UnitTypes::Zerg_Lurker)
					{
					//BWAPI::Broodwar->printf("############# Lurker in distance: %d ###############",  rangedUnit->getID());
					LurkerBurrow(rangedUnit);
					}
				}
				*/

				// attack it
				kiteTarget(rangedUnit, target);
			}
			// if there are no targets
			else
			{


				// if we're not near the order position
				if (rangedUnit->getDistance(order.position) > 100)
				{
					// move to it
					smartAttackMove(rangedUnit, order.position);
				}
			}
		}

		if (Options::Debug::DRAW_UALBERTABOT_DEBUG) 
		{
			BWAPI::Broodwar->drawLineMap(rangedUnit->getPosition().x(), rangedUnit->getPosition().y(), 
				rangedUnit->getTargetPosition().x(), rangedUnit->getTargetPosition().y(), Options::Debug::COLOR_LINE_TARGET);
		}
	}
}
Beispiel #17
0
bool CUnitValidator::validate()
{
  mVariableUnits = mProvidedVariableUnits;

  if (mTree.getType() == CEvaluationTree::MassAction)
    {
      std::vector< CValidatedUnit >::iterator it = mVariableUnits.begin();
      std::vector< CValidatedUnit >::iterator end = mVariableUnits.end();

      CValidatedUnit & k1 = *it++;
      k1 = mTargetUnit;

      for (; it != end && !(*it == CBaseUnit::undefined); ++it)
        {
          it->buildExpression();
          k1 = k1 * it->exponentiate(-1.0);
        }

      k1.buildExpression();

      if (it == end) return k1.conflict();

      CValidatedUnit & k2 = *it++;
      k2 = mTargetUnit;

      for (; it != end; ++it)
        {
          it->buildExpression();
          k2 = k2 * it->exponentiate(-1.0);
        }

      k2.buildExpression();

      if (it == end) return k1.conflict() || k2.conflict();
    }

  CVector< C_FLOAT64 > CurrentValues;

  if (mApplyIntitialValue)
    {
      CurrentValues = mMathContainer.getValues();
      mMathContainer.applyInitialValues();
    }

  mObjectUnits.clear();
  mNodeUnits.clear();

  do
    {
      getUnits();
    }
  while (setUnits());

  bool conflict = false;

  std::map < CEvaluationNode * , CValidatedUnit >::const_iterator itMap = mNodeUnits.begin();
  std::map < CEvaluationNode * , CValidatedUnit >::const_iterator endMap = mNodeUnits.end();

  for (; itMap != endMap && !conflict; ++itMap)
    if (itMap->second.conflict())
      {
        conflict = true;
      }

  std::map < CObjectInterface *, CValidatedUnit >::iterator itObject = mObjectUnits.begin();
  std::map < CObjectInterface *, CValidatedUnit >::iterator endObject = mObjectUnits.end();

  for (; itObject != endObject; ++itObject)
    {
      itObject->second.buildExpression();

      if (itObject->second.conflict())
        {
          conflict = true;
        }
    }

  std::vector< CValidatedUnit >::iterator it = mVariableUnits.begin();
  std::vector< CValidatedUnit >::iterator end = mVariableUnits.end();

  for (; it != end; ++it)
    {
      it->buildExpression();

      if (it->conflict())
        {
          conflict = true;
        }
    }

  std::map < CEvaluationNode * , CValidatedUnit >::iterator found = mNodeUnits.find(const_cast< CEvaluationNode * >(mTree.getRoot()));

  if (found != mNodeUnits.end())
    {
      found->second.setConflict(conflict);
    }

  if (mApplyIntitialValue)
    {
      mMathContainer.setValues(CurrentValues);
    }

  return !conflict;
}
    void msPhysicalInterface::setUnits(boost::shared_ptr<msUnitsManager> units){
        
        LOGGER_ENTER_FUNCTION_DBG("void msPhysicalInterface::setUnits(boost::shared_ptr<msUnitsManager> units)", getFullId());
        msUnitsManager old;
        old.set( Units->getExpression() );
        
        msTreeMapper::update<msUnitsManager>( Units , units);
        units->addObjectUsingMe( boost::static_pointer_cast<msPhysicalInterface>( mySharedPtr() ) );
	LOGGER_WRITE(msLogger::DEBUG, "Number of objects using the units: " + output::getString<size_t>(getUnits()->LinkedObjects.size()));
        updateUnits(old,*units);
	
	LOGGER_EXIT_FUNCTION2("void msPhysicalInterface::setUnits(boost::shared_ptr<msUnitsManager> units)");        
    }
std::string Inversion::toString() const
{
  return getUnits().second + " to " + getUnits().first + " converter";
}
void WraithManagerExt::executeMicro(const UnitVector & targets)
{
	const UnitVector & selectedUnits = getUnits();
	_noTurretTargetsNo = 0;

	// figure out targets
	UnitVector selectedUnitTargets;
	for (size_t i(0); i<targets.size(); i++)
	{
		// conditions for targeting
		if (targets[i]->isVisible())
		{
			selectedUnitTargets.push_back(targets[i]);

			if (!isTurret(targets[i]))
			{
				_noTurretTargetsNo++;
			}

		}
	}

	setAverageEnemyPosition(selectedUnitTargets);

	// For each unit
	BOOST_FOREACH(BWAPI::Unit * selectedUnit, selectedUnits)
	{
		// Adjust cloak to the situation
		manageCloak(selectedUnit, selectedUnitTargets);

		// if the order is to attack or defend
		if (order.type == order.Attack || order.type == order.Defend)
		{
			// if there are targets
			if (!selectedUnitTargets.empty())
			{
				// find the best target for this unit
				BWAPI::Unit * target = getTarget(selectedUnit, selectedUnitTargets);

				// attack it				
				kiteTarget(selectedUnit, target);

			}
			// if there are no targets
			else
			{
				// if we're not near the order position
				if (selectedUnit->getDistance(order.position) > 100)
				{
					// move to it	

					// Border movement
					BWAPI::Position movePosition;
					if (order.type == SquadOrder::Attack
						&& (StrategyManager::Instance().getCurrentStrategy() == StrategyManager::Instance().TerranWraithRush1Port))
					{
						movePosition = UnitManagerExt::Instance().getMovePosition(selectedUnit);
					}
					else
					{
						movePosition = order.position;
					}
					// eof Border movement
					if (!movePosition.isValid())
					{
						movePosition.makeValid();
					}

					smartAttackMove(selectedUnit, movePosition);
				}
			}
		}

		if (Options::Debug::DRAW_UALBERTABOT_DEBUG)
		{
			BWAPI::Broodwar->drawLineMap(selectedUnit->getPosition().x(), selectedUnit->getPosition().y(),
				selectedUnit->getTargetPosition().x(), selectedUnit->getTargetPosition().y(), Options::Debug::COLOR_LINE_TARGET);
		}
	}
int ocs_build_answer(AAAMessage *ccr, AAAMessage *cca, int result_code, int granted_units, int final_unit) {
	AAA_AVP *avp;
	AAA_AVP_LIST granted_list, mscc_list, final_list;
	char x[4];
	str granted_group, mscc_group, final_group;
	int service, group, used;
	
	if (!ccr) return 0;
   	if (!cca) return 0;

	// Set some basic data: Application-ID, CCR-Type, CCR-Request-Number
	set_4bytes(x, IMS_Ro);
	ocs_add_avp(cca, x, 4, AVP_Acct_Application_Id, AAA_AVP_FLAG_MANDATORY, 0, AVP_DUPLICATE_DATA, __FUNCTION__);
	
	avp = cdpb.AAAFindMatchingAVP(ccr,0,AVP_IMS_CCR_Type,0,0);
	ocs_add_avp(cca, avp->data.s, avp->data.len, AVP_IMS_CCR_Type, AAA_AVP_FLAG_MANDATORY, 0, AVP_DUPLICATE_DATA, __FUNCTION__);

	avp = cdpb.AAAFindMatchingAVP(ccr,0,AVP_CC_Request_Number,0,0);
	ocs_add_avp(cca, avp->data.s, avp->data.len,AVP_CC_Request_Number, AAA_AVP_FLAG_MANDATORY, 0, AVP_DUPLICATE_DATA, __FUNCTION__);
	
	// Result-Code:
	set_4bytes(x, result_code);
	ocs_add_avp(cca, x, 4, AVP_Result_Code, AAA_AVP_FLAG_MANDATORY, 0, AVP_DUPLICATE_DATA, __FUNCTION__);

	if (result_code == DIAMETER_SUCCESS) {
		granted_list.head = 0;
		granted_list.tail = 0;
		final_list.head = 0;
		final_list.tail = 0;
		mscc_list.head = 0;
		mscc_list.tail = 0;

		getUnits(ccr, &used, &service, &group);
	
		set_4bytes(x, group);
		ocs_add_avp_list(&mscc_list, x, 4, AVP_Rating_Group, AAA_AVP_FLAG_MANDATORY, 0, AVP_DUPLICATE_DATA, __FUNCTION__);

		set_4bytes(x, service);
		ocs_add_avp_list(&mscc_list, x, 4, AVP_Service_Identifier, AAA_AVP_FLAG_MANDATORY, 0, AVP_DUPLICATE_DATA, __FUNCTION__);

		if (granted_units > 0) {
			set_4bytes(x, granted_units);
			ocs_add_avp_list(&granted_list, x, 4, AVP_CC_Time, AAA_AVP_FLAG_MANDATORY, 0, AVP_DUPLICATE_DATA, __FUNCTION__);
			granted_group = cdpb.AAAGroupAVPS(granted_list);
			cdpb.AAAFreeAVPList(&granted_list);
			ocs_add_avp_list(&mscc_list, granted_group.s, granted_group.len, AVP_Granted_Service_Unit, AAA_AVP_FLAG_MANDATORY, 0, AVP_FREE_DATA, __FUNCTION__);
		}

		// Result-Code:
		set_4bytes(x, result_code);
		ocs_add_avp_list(&mscc_list, x, 4, AVP_Result_Code, AAA_AVP_FLAG_MANDATORY, 0, AVP_DUPLICATE_DATA, __FUNCTION__);

		set_4bytes(x, 86400);
		ocs_add_avp_list(&mscc_list, x, 4, AVP_Validity_Time, AAA_AVP_FLAG_MANDATORY, 0, AVP_DUPLICATE_DATA, __FUNCTION__);


		if (final_unit > 0) {
			set_4bytes(x, 0);
			ocs_add_avp_list(&final_list, x, 4, AVP_Final_Unit_Action, AAA_AVP_FLAG_MANDATORY, 0, AVP_DUPLICATE_DATA, __FUNCTION__);
			final_group = cdpb.AAAGroupAVPS(final_list);
			cdpb.AAAFreeAVPList(&final_list);
			ocs_add_avp_list(&mscc_list, final_group.s, final_group.len, AVP_Final_Unit_Indication, AAA_AVP_FLAG_MANDATORY, 0, AVP_FREE_DATA, __FUNCTION__);
		}


		mscc_group = cdpb.AAAGroupAVPS(mscc_list);
		cdpb.AAAFreeAVPList(&mscc_list);

		return ocs_add_avp(cca, mscc_group.s, mscc_group.len, AVP_Multiple_Services_Credit_Control, AAA_AVP_FLAG_MANDATORY, 0, AVP_FREE_DATA, __FUNCTION__);
	}
	return 1;
}
void VultureManagerExt::executeMicro(const UnitVector & targets)
{
	const UnitVector & selectedUnits = getUnits();


	// figure out targets
	UnitVector selectedUnitTargets;
	UnitVector nearbyTargets;
	for (size_t i(0); i<targets.size(); i++)
	{
		// conditions for targeting
		if (targets[i]->isVisible()
			&& !targets[i]->getType().isFlyer())
		{
			selectedUnitTargets.push_back(targets[i]);
		}
	}

	//setAverageEnemyPosition(selectedUnitTargets);

	// For each unit
	BOOST_FOREACH(BWAPI::Unit * selectedUnit, selectedUnits)
	{
		// Avg enemy pos
		for (size_t i(0); i<targets.size(); i++)
		{
			// conditions for targeting
			if (targets[i]->isVisible()
				&& !targets[i]->getType().isFlyer())
			{
				if (targets[i]->getDistance(selectedUnit) < 500)
				{
					nearbyTargets.push_back(targets[i]);
				}
			}
		}

		if (!nearbyTargets.empty())
		{
			setAverageEnemyPosition(nearbyTargets);
		}
		else
		{
			setAverageEnemyPosition(selectedUnitTargets);
		}

		// eof avg eveeny pos
		// if the order is to attack or defend
		if ((StrategyManager::Instance().getCurrentStrategy() == StrategyManager::Instance().TerranWraithRush1Port)
			&& !isAttack())
		{
			executeTerranWraithRush1Port(selectedUnit, selectedUnitTargets);
		}
		else if (order.type == order.Attack || order.type == order.Defend)
		{
			// if there are targets
			if (!selectedUnitTargets.empty())
			{
				// find the best target for this Marine
				BWAPI::Unit * target = getTarget(selectedUnit, selectedUnitTargets);

				// attack it		
				kiteTarget(selectedUnit, target);


			}
			// if there are no targets
			else
			{
				// if we're not near the order position
				if (selectedUnit->getDistance(order.position) > 100)
				{
					// move to it
					smartAttackMove(selectedUnit, order.position);
				}
			}
		}

		if (Options::Debug::DRAW_UALBERTABOT_DEBUG)
		{
			BWAPI::Broodwar->drawLineMap(selectedUnit->getPosition().x(), selectedUnit->getPosition().y(),
				selectedUnit->getTargetPosition().x(), selectedUnit->getTargetPosition().y(), Options::Debug::COLOR_LINE_TARGET);
		}
	}

}