int main(void)
{ Attributes attr;
  WORD result;
  
  printf("\f\t\tANSI Terminal Emulation Test\n");
  printf(  "\t\t============================\n\n\n");
  
  setvbuf(stdin, NULL, _IONBF, 0);
  if ((result = GetAttributes(Heliosno(stdout), &attr)) < 0)
   { printf("Failed to get stdout attributes : %lx. Exiting.\n", result);
     exit((int)result);
   }

  printf("Window size : %d rows, %d columns.\n\n", attr.Min, attr.Time);
  rows = attr.Min; cols = attr.Time;
  AddAttribute(&attr, ConsoleRawOutput);
  RemoveAttribute(&attr, ConsolePause);
  RemoveAttribute(&attr, ConsoleEcho);
  
  if ((result = SetAttributes(Heliosno(stdout), &attr)) < 0)
   { printf("Failed to set stdout attributes : %lx. Exiting.\n", result);
     exit((int)result);
   }
   
  if ((result = GetAttributes(Heliosno(stdin), &attr)) < 0)
   { printf("Failed to get stdin attributes : %lx. Exiting.\n", result);
     exit((int)result);
   }

  AddAttribute(&attr, ConsoleRawInput);
  RemoveAttribute(&attr, ConsolePause);
  RemoveAttribute(&attr, ConsoleEcho);
  
  if ((result = SetAttributes(Heliosno(stdin), &attr)) < 0)
   { printf("Failed to set stdin attributes : %lx. Exiting.\n", result);
     exit((int) result);
   }
   
  wait_for_user();
  main_menu();
  printf("\r\n\n\n");
}

static bool EntityExists(const char* Path, u32 SubdirValue)
{
	if (!Exists(Path))
		return false;

	auto MaybeAttributes = GetAttributes(Path);
	if (!MaybeAttributes.has_value())
		return false;

	return (MaybeAttributes.value().Attributes & Attributes::Subdir) == SubdirValue;
}

	BasicTool(
		N_BOOMERANG,
		fBasicSpeed,
		pfLocationRatio,
		fHeadingInDegrees,
		pfDimensions,
		pRasterGraphicName,
		deviceResources)
{
	if (pRasterGraphicName != nullptr)	// Raster graphics
	{
		m_pRenderable = new RasterGraphic(pRasterGraphicName, deviceResources);

#ifdef SHOW_RAW_MASK_ZONES
		m_pRawMask = new VirtualMask(MaskTemplateRepository::GetInstance()->Get(pRasterGraphicName));
#endif // SHOW_RAW_MASK_ZONES

		m_pActualMask = new VirtualMask(MaskTemplateRepository::GetInstance()->Get(pRasterGraphicName));
	}

	list<int> listAttributes;
	// A_LOCATION is part of Space.
	listAttributes.push_back(A_STRENGTH);
	listAttributes.push_back(A_BEING);
	listAttributes.push_back(A_ROTATION);

	m_pAttributes->AddAttributes(&listAttributes);

	int nStrength = 5;
	GetAttributes()->Modify(A_STRENGTH, A_STRENGTH_VALUE, &nStrength);

	bool bState = true;
	GetAttributes()->Modify(A_BEING, A_BEING_VALUE, &bState);

	float fRotation = 0.f;
	GetAttributes()->Modify(A_ROTATION, A_ROTATION_VALUE, &fRotation);

	m_nState = BOOMERANG_AWAY;

	m_fAngle_degrees = 0.0f;
}

bool UGAAbilityBase::CheckAbilityAttributeCost()
{
	for (int32 Idx = 0; Idx < AbilityAttributeCost.Num(); Idx++)
	{
		float ModValue = AbilityAttributeCost[Idx].GetSpecData()->AtributeModifier.Magnitude.GetFloatValue(DefaultContext);
		FGAAttribute Attribute = AbilityAttributeCost[Idx].GetSpecData()->AtributeModifier.Attribute;
		float AttributeVal = GetAttributes()->GetFloatValue(Attribute);
		if (ModValue > AttributeVal)
			return false;
	}
	return true;
}

//---------------------------------------------------------------------------
// get the style attributes of the first character of the text
//
TFontStyles __fastcall TTaeTextAttributes::GetStyle(void)
{
  TCharFormat Format;
  TFontStyles Result;

  GetAttributes(Format);
  if (Format.dwEffects & CFE_BOLD) Result = Result << fsBold;
  if (Format.dwEffects & CFE_ITALIC) Result = Result << fsItalic;
  if (Format.dwEffects & CFE_UNDERLINE) Result = Result << fsUnderline;
  if (Format.dwEffects & CFE_STRIKEOUT) Result = Result << fsStrikeOut;
  return Result;
}

bool wxXmlNode::HasAttribute(const wxString& attrName) const
{
    wxXmlAttribute *attr = GetAttributes();

    while (attr)
    {
        if (attr->GetName() == attrName) return true;
        attr = attr->GetNext();
    }

    return false;
}

bool wxRichTextBackgroundPage::TransferDataToWindow()
{
    wxRichTextAttr* attr = GetAttributes();
    if (!attr->HasBackgroundColour())
    {
        m_backgroundColourCheckBox->SetValue(false);
        m_backgroundColourSwatch->SetColour(*wxWHITE);
    }
    else
    {
        m_backgroundColourCheckBox->SetValue(true);
        m_backgroundColourSwatch->SetColour(attr->GetBackgroundColour());
    }

    m_useShadow->SetValue(attr->GetTextBoxAttr().GetShadow().IsValid());
    
    wxArrayInt units;
    units.Add(wxTEXT_ATTR_UNITS_PIXELS);
    units.Add(wxTEXT_ATTR_UNITS_TENTHS_MM);
    units.Add(wxTEXT_ATTR_UNITS_HUNDREDTHS_POINT);

    wxArrayInt percentUnits;
    percentUnits.Add(wxTEXT_ATTR_UNITS_PERCENTAGE);

    if (!attr->GetTextBoxAttr().GetShadow().GetOffsetX().IsValid())
        attr->GetTextBoxAttr().GetShadow().GetOffsetX().SetValue(0, wxTEXT_ATTR_UNITS_PIXELS);
    if (!attr->GetTextBoxAttr().GetShadow().GetOffsetY().IsValid())
        attr->GetTextBoxAttr().GetShadow().GetOffsetY().SetValue(0, wxTEXT_ATTR_UNITS_PIXELS);

    wxRichTextFormattingDialog::SetDimensionValue(attr->GetTextBoxAttr().GetShadow().GetOffsetX(), m_offsetX, m_unitsHorizontalOffset, NULL,
        & units);
    wxRichTextFormattingDialog::SetDimensionValue(attr->GetTextBoxAttr().GetShadow().GetOffsetY(), m_offsetY, m_unitsVerticalOffset, NULL,
        & units);
    wxRichTextFormattingDialog::SetDimensionValue(attr->GetTextBoxAttr().GetShadow().GetSpread(), m_spread, m_unitsShadowSpread, m_useShadowSpread,
        & units);
    wxRichTextFormattingDialog::SetDimensionValue(attr->GetTextBoxAttr().GetShadow().GetBlurDistance(), m_blurDistance, m_unitsBlurDistance, m_useBlurDistance,
        & units);
    wxRichTextFormattingDialog::SetDimensionValue(attr->GetTextBoxAttr().GetShadow().GetOpacity(), m_opacity, NULL, m_useShadowOpacity,
        & percentUnits);

    if (!attr->GetTextBoxAttr().GetShadow().HasColour() || !attr->GetTextBoxAttr().GetShadow().IsValid())
    {
        m_shadowColourCheckBox->SetValue(false);
        m_shadowColourSwatch->SetColour(*wxWHITE);
    }
    else
    {
        m_shadowColourCheckBox->SetValue(true);
        m_shadowColourSwatch->SetColour(attr->GetTextBoxAttr().GetShadow().GetColour());
    }

    return true;
}

VError XWinFolder::IsHidden(bool &outIsHidden)
{
	VError err;
	
	DWORD outAttrb;
	err=GetAttributes(&outAttrb);
	if(err==VE_OK)
	{
		outIsHidden= (outAttrb & FILE_ATTRIBUTE_HIDDEN) == FILE_ATTRIBUTE_HIDDEN;
	}
	return err;
}

	int VertexBuffer::GetVertexSize()
	{
		vector<VertexAttribute> attribs = GetAttributes();

		int total_size = 0;
		for(unsigned int i = 0; i < attribs.size(); ++i)
		{
			VertexAttribute attrib = attribs[i];

			if(attrib.type == Float)
				total_size += sizeof(float) * attrib.n_per_vertex;
		}
		return total_size;
	}

bool wxRichTextBackgroundPage::TransferDataFromWindow()
{
    wxRichTextAttr* attr = GetAttributes();
    if (m_backgroundColourCheckBox->GetValue())
    {
        attr->SetBackgroundColour(m_backgroundColourSwatch->GetColour());
    }
    else
    {
        attr->SetFlags(attr->GetFlags() & ~wxTEXT_ATTR_BACKGROUND_COLOUR);
    }
    
    return true;
}

void Context::CopyBaseAttributes(StringHash baseType, StringHash derivedType)
{
    const Vector<AttributeInfo>* baseAttributes = GetAttributes(baseType);
    if (baseAttributes)
    {
        for (unsigned i = 0; i < baseAttributes->Size(); ++i)
        {
            const AttributeInfo& attr = baseAttributes->At(i);
            attributes_[derivedType].Push(attr);
            if (attr.mode_ & AM_NET)
                networkAttributes_[derivedType].Push(attr);
        }
    }
}

bool EC_DynamicComponent::ContainSameAttributes(const EC_DynamicComponent &comp) const
{
    AttributeVector myAttributeVector = GetAttributes();
    AttributeVector attributeVector = comp.GetAttributes();
    if(attributeVector.size() != myAttributeVector.size())
        return false;
    if(attributeVector.empty() && myAttributeVector.empty())
        return true;

    std::sort(myAttributeVector.begin(), myAttributeVector.end(), &CmpAttributeByName);
    std::sort(attributeVector.begin(), attributeVector.end(), &CmpAttributeByName);

    AttributeVector::const_iterator iter1 = myAttributeVector.begin();
    AttributeVector::const_iterator iter2 = attributeVector.begin();
    while(iter1 != myAttributeVector.end() && iter2 != attributeVector.end())
    {
        // Compare attribute names and type and if they mach continue iteration if not components aren't exactly the same.
        if((*iter1)->GetNameString() == (*iter2)->GetNameString() &&
           (*iter1)->TypeName() == (*iter2)->TypeName())
        {
            if(iter1 != myAttributeVector.end())
                iter1++;
            if(iter2 != attributeVector.end())
                iter2++;
        }
        else
        {
            return false;
        }
    }
    return true;

    /*// Get both attributes and check if they are holding exact number of attributes.
    AttributeVector myAttributeVector = GetAttributes();
    AttributeVector attributeVector = comp.GetAttributes();
    if(attributeVector.size() != myAttributeVector.size())
        return false;
    
    // Compare that every attribute is same in both components.
    QSet<IAttribute*> myAttributeSet;
    QSet<IAttribute*> attributeSet;
    for(uint i = 0; i < myAttributeSet.size(); i++)
    {
        attributeSet.insert(myAttributeVector[i]);
        myAttributeSet.insert(attributeVector[i]);
    }
    if(attributeSet != myAttributeSet)
        return false;
    return true;*/
}

bool wxRichTextMarginsPage::TransferDataFromWindow()
{
    // Margins
    wxRichTextFormattingDialog::GetDimensionValue(GetAttributes()->GetTextBoxAttr().GetMargins().GetLeft(), m_marginLeft, m_unitsMarginLeft, m_leftMarginCheckbox);
    wxRichTextFormattingDialog::GetDimensionValue(GetAttributes()->GetTextBoxAttr().GetMargins().GetTop(), m_marginTop, m_unitsMarginTop, m_topMarginCheckbox);
    wxRichTextFormattingDialog::GetDimensionValue(GetAttributes()->GetTextBoxAttr().GetMargins().GetRight(), m_marginRight, m_unitsMarginRight, m_rightMarginCheckbox);
    wxRichTextFormattingDialog::GetDimensionValue(GetAttributes()->GetTextBoxAttr().GetMargins().GetBottom(), m_marginBottom, m_unitsMarginBottom, m_bottomMarginCheckbox);

    // Padding
    wxRichTextFormattingDialog::GetDimensionValue(GetAttributes()->GetTextBoxAttr().GetPadding().GetLeft(), m_paddingLeft, m_unitsPaddingLeft, m_leftPaddingCheckbox);
    wxRichTextFormattingDialog::GetDimensionValue(GetAttributes()->GetTextBoxAttr().GetPadding().GetTop(), m_paddingTop, m_unitsPaddingTop, m_topPaddingCheckbox);
    wxRichTextFormattingDialog::GetDimensionValue(GetAttributes()->GetTextBoxAttr().GetPadding().GetRight(), m_paddingRight, m_unitsPaddingRight, m_rightPaddingCheckbox);
    wxRichTextFormattingDialog::GetDimensionValue(GetAttributes()->GetTextBoxAttr().GetPadding().GetBottom(), m_paddingBottom, m_unitsPaddingBottom, m_bottomPaddingCheckbox);

    return true;
}

///////////////////////////////////////////////////////////////////////////////
// finden eines Attributes einer Objektklasse
HRESULT CArcViewAttributes::GetAttribute (INT_PTR lIdent, INT_PTR lMCode, os_string *pAttrName)
{
CArcViewLayerAttributes *pAttrMap = NULL;

	if (S_OK == GetAttributes (lIdent, &pAttrMap)) {
	CArcViewLayerAttributes::iterator it = pAttrMap -> find (lMCode);

		if (it != pAttrMap -> end()) {
			if (NULL != pAttrName)
				*pAttrName = (*it).second.GetName();
			return S_OK;
		}
	}
	return S_FALSE;
}

/*
  @method CreateSparse
  @discussion Create a SparseMatrix, based
  on the XML attributes. The object is returned by value.
  @throws KII_invalid_argument
  @param matElement pointer to Matrix XML element
  @result The SparseMatrix object.
*/
SparseMatrix MatrixFactory::CreateSparse(TiXmlElement* matElement)
{
  string type;
  string init;
  int rows, columns;
  FLOAT multiplier;
  TiXmlHandle matHandle(matElement);

  GetAttributes(matElement, type, init, rows, columns, multiplier);

#ifdef MDEBUG
  cerr << "Creating SparseMatrix with attributes: " << type << ", " << init
       << ", " << rows << "X" << columns << ", " << multiplier << endl;
#endif

  if (type == "diag") {
    if (init == "none") {          // a string of values is present & passed
      TiXmlText* valuesNode = matHandle.FirstChild().Text();
      if (valuesNode == NULL)
	throw KII_invalid_argument("Contents not specified for Sparese Matrix with init='none'.");
      const char* values = valuesNode->Value();
#ifdef MDEBUG
      cerr << "\tData present for initialization: " << values << endl;
#endif
      return SparseMatrix(rows, columns, multiplier, values);
    } else if (init == "const") {   // No string of values or XML row data
      if (multiplier == 0.0)
	return SparseMatrix(rows, columns);
      else
	throw KII_invalid_argument("A sparse matrix can only be initialized to zero with const XML init");
    } else
      throw KII_invalid_argument("Invalid init for sparse matrix");
  } else if (type == "sparse") {
    if (init == "none")             // a sequence of row data nodes is present & passed
      return SparseMatrix(rows, columns, multiplier, matElement);
    else if (init == "const") {     // No row data
      if (multiplier == 0.0)
	return SparseMatrix(rows, columns);
      else
	throw KII_invalid_argument("A sparse matrix can only be initialized to zero with const XML init");
    } else
      throw KII_invalid_argument("A sparse matrix can only be initialized to zero with const XML init");
  }

  // If we get here, then something is really wrong
  throw KII_invalid_argument("Invalid type specified for sparse matrix.");

}

// Main
int main () {

	char opentag[MAX_BUF];

	Init();

	// get the first tag name manually
	Match('<');
	strncpy(opentag, tag(), MAX_BUF);
	GetAttributes();
	if (Look == '/'){
		Match('/');
		Match('>');
	} else {
		Match('>');
		xml(opentag);
	}
}

bool wxXmlNode::GetAttribute(const wxString& attrName, wxString *value) const
{
    wxCHECK_MSG( value, false, "value argument must not be NULL" );

    wxXmlAttribute *attr = GetAttributes();

    while (attr)
    {
        if (attr->GetName() == attrName)
        {
            *value = attr->GetValue();
            return true;
        }
        attr = attr->GetNext();
    }

    return false;
}

/// Transfer data from/to window
bool wxRichTextTabsPage::TransferDataFromWindow()
{
    wxPanel::TransferDataFromWindow();

    wxRichTextAttr* attr = GetAttributes();

    if (m_tabsPresent)
    {
        wxArrayInt tabs;
        size_t i;
        for (i = 0; i < m_tabListCtrl->GetCount(); i++)
        {
            tabs.Add(wxAtoi(m_tabListCtrl->GetString(i)));
        }
        attr->SetTabs(tabs);
    }
    return true;
}

std::vector<int>* Observation::GetCollidingAttributes(Observation *t_observation)
{
	std::vector<int>* returnedValue;
	int observationCount = GetAttributes().size();
	if (observationCount != t_observation->GetAttributes().size())
		return returnedValue;

	//sprawdzenie decyzji
	if ((this->GetAttributes())[observationCount - 1] == (t_observation->GetAttributes())[observationCount - 1])
		return returnedValue;

	for (int i = 0; i < observationCount; i++)
	{
		if ((this->GetAttributes())[i] == (t_observation->GetAttributes())[i])
			returnedValue->push_back(i);
	}

	return returnedValue;
}

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
void CPosModulesSettings::CopyAttributesL( const CPosModulesSettings& aSource )
	{
	CPosModuleIdList* list = aSource.GetInstalledListLC();
	for (int i = 0; i < list->Count(); ++i) 
		{
		TUid moduleId = (*list)[i];
		TPosModuleAttributes attrSource, attrTarget;
		aSource.GetAttributes( moduleId, attrSource );
		TInt err = GetAttributes( moduleId, attrTarget );
		if ( !err )
			{
			attrTarget.iAvailable = attrSource.iAvailable;
			attrTarget.iCost = attrSource.iCost;
			// visibility not copied
			SetAttributesL( moduleId, attrTarget );
			}
		}
	CleanupStack::PopAndDestroy( list );
	}