void FieldSelectionPanel::AddField(CItemData::FieldType ft, bool selected, bool mandatory)
{
  wxCHECK_RET(!mandatory || selected, wxT("A mandatory field must also be pre-selected"));

  const wxString fieldName(towxstring(CItemData::FieldName(ft)));

  if (FindField(ft, selected? m_lbSelected: m_lbAvailable) != wxNOT_FOUND) {
    wxLogDebug(wxT("%ls already in %ls list, not adding it again"),
                    fieldName,
                    selected? wxT("selected"): wxT("available"));
    return;
  }

  //if the field is already in another listbox, just move it
  const int index = FindField(ft, selected? m_lbAvailable: m_lbSelected);
  if (index != wxNOT_FOUND) {
    wxLogDebug(wxT("%ls already in %ls list, moving it to %ls"),
                    fieldName,
                    selected? wxT("available"): wxT("selected"),
                    selected? wxT("selected"): wxT("available"));
    MoveItem(index, selected? m_lbAvailable: m_lbSelected, selected? m_lbSelected: m_lbAvailable);
    return;
  }

  //else, add it
  wxString title(fieldName);
  if (mandatory)
    title += _(" [Mandatory Field]");

  FieldData *data = new FieldData(mandatory, ft);

  wxListBox* lb = selected? m_lbSelected: m_lbAvailable;
  lb->Append(title, data);
}

	IFieldPtr  CFields::GetField(const CommonLib::CString& name) const
	{
		int nIndex = FindField(name);
		if(nIndex == -1)
			return IFieldPtr();
		return GetField(nIndex);
	}

	GField* GFieldsImpl::GetField(const char* szName)
	{
		int nIndex = FindField(szName);
		if(nIndex<0)
			return NULL;
		return m_fields[nIndex];
	}

int
GetFieldOrdering(FieldList  list,
		 int	    *order)
{
    FieldSpec	*field;
    long	ord;

    field = FindField(list, "fieldOrder");

    if (field == NULL)
	ord = TYPE_ORDER;
    else if (field->occurrence != GLOBAL
	     || field->rank != 0
	     || field->data == NULL
	     || !LongVal(field->data, field->type, &ord)
	     || ord != FIELD_ORDER && ord != TYPE_ORDER)
    {
	DebugMsg(1, "Bad field \"fieldOrder\".");
	return FALSE;
    }

    if (order != NULL)
	*order = ord;

    return TRUE;
}

bool CRuleStruct::AddField(CRuleVariable* pField)
{
	if(FindField(pField->m_oName.GetStr()))
		return false;
	m_oFields.Insert((uint32)(-1), pField);
	m_bImplemented = false;
	return true;
}

/**
 * If any changes have been made to this component,
 * they are now applied to the schematic component
 */
void BOM_TABLE_COMPONENT::ApplyFieldChanges()
{
    for( auto& unit : Units )
    {
        auto cmp = unit.GetComp();

        if( !cmp )
            continue;

        // Iterate over each column
        SCH_FIELD* field;

        for( auto& column : m_columnList->Columns )
        {
            if( column && HasValueChanged( column ) )
            {
                wxString value = GetFieldValue( column->Id() );

                switch( column->Id() )
                {
                // Ignore read-only fields
                case BOM_COL_ID_REFERENCE:
                case BOM_COL_ID_QUANTITY:
                    continue;

                // Special field considerations
                case BOM_COL_ID_FOOTPRINT:
                    field = cmp->GetField( FOOTPRINT );
                    break;

                case BOM_COL_ID_VALUE:
                    field = cmp->GetField( VALUE );
                    break;
                case BOM_COL_ID_DATASHEET:
                    field = cmp->GetField( DATASHEET );
                    break;

                default:
                    // Find the field by name (but ignore default fields)
                    field = cmp->FindField( column->Title(), false );
                    break;
                }

                // New field needs to be added?
                if( !field && !value.IsEmpty() )
                {
                    SCH_FIELD newField( wxPoint( 0, 0 ), -1, cmp, column->Title() );
                    field = cmp->AddField( newField );
                }

                if( field )
                {
                    field->SetText( value );
                }
            }
        }
    }
}

static FieldSpec *
AddCommandLine(FieldList    *list,
	       char	    *line)
{
    FieldSpec	*field;


    if (line == NULL)
	return NULL;

    field = FindField(*list, "commandLine");

    if (field == NULL)
    {
	field = NewFieldSpec(ECHAR, 1);
	if (field == NULL)
	{
	    DebugMsg(1, "AddCommandLine: Couldn't create field spec.");
	    return NULL;
	}

	field->dim[0] = strlen(line);
	field->name = savestring("commandLine");
	field->occurrence = GLOBAL;

	if (!AddField(list, field))
	{
	    DebugMsg(1, "AddCommandLine: Couldn't add field spec.");
	    return NULL;
	}
    }
    else			/* field != NULL */
    {
	if (field->occurrence != GLOBAL)
	{
	    DebugMsg(1, "AddCommandLine: non-GLOBAL field \'commandLine\".");
	    return NULL;
	}

	field->type = ECHAR;
	field->rank = 1;
	field->dim = (long *) ((field->dim == NULL)
				? malloc(sizeof(long))
				: realloc(field->dim, sizeof(long)));

	if (field->dim == NULL)
	{
	    DebugMsg(1, "AddCommandLine: couldn't (re)allocate dimension.");
	    return NULL;
	}

	field->dim[0] = 1 + strlen(line);
    }

    field->data = line;

    return field;
}

   bool 
      MimeHeader::FieldExists(const char *pszFieldName) const
   {
      vector<MimeField>::iterator iter = FindField(pszFieldName);
      if (iter == m_listFields.end())
         return false;

      return true;
   }

int
SetFieldOrdering(FieldList  *list,
		 int	    order)
{
    FieldSpec	*field;

    if (*list == NULL)
    {
	DebugMsg(1, "SetFieldOrdering: NULL field list.");
	return FALSE;
    }

    field = FindField(*list, "fieldOrder");

    if (field == NULL)
    {
	if (order == TYPE_ORDER)
	    return TRUE;

	field = NewFieldSpec(SHORT, 0);
	if (field == NULL)
	{
	    DebugMsg(1, "SetFieldOrdering: Couldn't create field spec.");
	    return FALSE;
	}

	field->name = StrDup("fieldOrder");
	field->occurrence = GLOBAL;
	if (!AddField(list, field))
	{
	    DebugMsg(1, "SetFieldOrdering: Couldn't add field spec.");
	    return FALSE;
	}
    }
    else    /* field != NULL */
    {
	if (field->occurrence != GLOBAL)
	{
	    DebugMsg(1, "SetFieldOrdering: non-GLOBAL field \"fieldOrder\".");
	    return FALSE;
	}
	field->type = SHORT;
	field->rank = 0;
    }

    field->data = ((field->data == NULL)
		   ? malloc(sizeof(short))
		   : realloc(field->data, sizeof(short)));
    if (field->data == NULL)
    {
	DebugMsg(1, "SetFieldOrdering: couldn't (re)allocate data.");
	return FALSE;
    }

    *(short *) field->data = order;
    return TRUE;
}

            BinaryObjectImpl BinaryObjectImpl::GetField(const char* name) const
            {
                CheckIdResolver();

                int32_t fieldId = idRslvr->GetFieldId(GetTypeId(), name);
                int32_t pos = FindField(fieldId);

                return FromMemory(*mem, pos, metaMgr);
            }

TDC_ATTRIBUTE CTDLImportOutlookObjectsDlg::GetFieldMapping(const CTDCCsvColumnMapping& aMapping, OUTLOOK_FIELDTYPE nFieldType)
{
	int nField = FindField(aMapping, nFieldType);

	if (nField != -1)
		return aMapping[nField].nTDCAttrib;

	// else
	return TDCA_NONE;
}

//------------------------------------------------------------------------------------------------------------	
void CPerfTestContact::SetTextFieldL(TFieldType aFieldType,const TDesC& aText)
	{
	CContactItemFieldSet& fields = iContactItem->CardFields();
	TInt fieldIndex = 0;

	fieldIndex = FindField( aFieldType );

	if ( fieldIndex > KErrNotFound )
		{
		CContactItemField& field = fields[ fieldIndex ];
		ASSERT(field.StorageType()==KStorageTypeText);
		STATIC_CAST(CContactTextField*,field.Storage())->SetText(aText.AllocL());
		}

/* Parse rule comment with dynamic fields */
char* ParseRuleComment(Eventinfo *lf) {
    static char final[OS_COMMENT_MAX + 1] = { '\0' };
    char orig[OS_COMMENT_MAX + 1] = { '\0' };
    const char *field;
    char *str;
    char *var;
    char *end;
    char *tok;
    size_t n = 0;
    size_t z;

    strncpy(orig, lf->generated_rule->comment, OS_COMMENT_MAX);

    for (str = orig; (tok = strstr(str, "$(")); str = end) {
        *tok = '\0';
        var = tok + 2;

        if (n + (z = strlen(str)) >= OS_COMMENT_MAX)
            return strdup(lf->generated_rule->comment);

        strncpy(&final[n], str, z);
        n += z;

        if (!(end = strchr(var, ')'))) {
            *tok = '$';
            str = tok;
            break;
        }

        *(end++) = '\0';

        if ((field = FindField(lf, var))) {
            if (n + (z = strlen(field)) >= OS_COMMENT_MAX)
                return strdup(lf->generated_rule->comment);

            strncpy(&final[n], field, z);
            n += z;
        } else {
            *tok = '$';

            if (n + (z = strlen(tok)) + 1 >= OS_COMMENT_MAX)
                return strdup(lf->generated_rule->comment);

            strncpy(&final[n], tok, z);
            n += z;
            final[n++] = ')';
        }
    }

bool iDBF::GetStrDataArray(const wxString& fieldname, charPtr* dt) 
{
	int rows = NumOfRecords;
	int fld = FindField(fieldname);
	if (fld < 0 || fld > NumOfFields-1 || Field[fld]->Type != 'C') 
		return false;
	
	for ( int xIndex = 0; xIndex < rows; ++xIndex) 
	{
		while (Pos() != fld) Read();
		int len = Field[fld]->Width;
		char* result = new char[len+1];
		Read(result, len);
		dt[xIndex] = result;
	}
	
	return true;
}

bool iDBF::GetDblDataArray(const wxString& fieldname, double* dt) 
{
	LOG_MSG("Entering iDBF::GetDblDataArray");
	
	int rows = NumOfRecords;
	int fld = FindField(fieldname);
	if (fld < 0 || fld > NumOfFields-1) 
		return 0;
	
	pos =0;
	record=0;
	//ReOpen();  //MMM this must be a hack, temporarily disable and eventually remove it!
	
	if (Field[fld]->Type == 'F')
	{
		
		for ( int xIndex = 0; xIndex < rows; ++xIndex) 
		{
			while (Pos() != fld) Read();
			int len = Field[fld]->Width;
			char* result = new char[len+1];
			Read(result, len);
			//dt[xIndex] = atof(result);
			wxString::Format("%s", result).ToCDouble(&dt[xIndex]);
			delete [] result;
			result = NULL;
		}
		
	}
	else
	{
		for ( int xIndex = 0; xIndex < rows; ++xIndex) 
		{
			while (Pos() != fld) Read();
			double result;
			Read(result);
			dt[xIndex] = result;
		}
	}
	
	LOG_MSG("Exiting iDBF::GetDblDataArray");
	return 1;
}

FieldSpec *
FindField(FieldList list,	/* field list */
	  char      *name)	/* full name of field */
{
    char	*prefix;	/* first component of name */
    char	*tail;		/* rest of name after prefix */
    FieldSpec	*ancestor;	/* parent of named field spec
				   (or parent of parent ...). */
    FieldSpec	*field;		/* named field spec */

    /* Check for bad or empty arguments. */

    if (list == NULL || *list == NULL || name == NULL)
	return NULL;

    /* Parse name. */

    tail = strchr(name, DOT);

    /* Handle simple case immediately or complex case by
       recursion. */

    if (tail == NULL)		/* Just one component. */
	return GetField(list, name);
    else			/* Multi-component name. */
    {
	tail++;			/* Skip over dot. */

	prefix = FirstComponent(name);
	if (prefix == NULL)
	    return NULL;

	ancestor = GetField(list, prefix);
	if (ancestor == NULL)	/* Search failed. */
	    field = NULL;
	else			/* Descend into subfields. */
	    field = FindField(ancestor->subfields, tail);

	free(prefix);
	return field;
    }
}

// ----------------------------------------------------------------------------
// GetFieldData, for EVPbkFieldStorageTypeBinary
// ----------------------------------------------------------------------------
EXPORT_C TPtrC8 CContactMatcher::GetFieldDataBinaryL(
    const MVPbkStoreContact& aContact,
    const MVPbkFieldType& aFType ) const
    {
    TPtrC8 ret(KNullDesC8);
    const MVPbkStoreContactField* field = FindField( aContact, aFType);
    if (field)
        {
        const MVPbkContactFieldData& fdata = field->FieldData();
        if (fdata.DataType() == EVPbkFieldStorageTypeBinary)
            {
            const MVPbkContactFieldBinaryData& fdata2 =
                MVPbkContactFieldBinaryData::Cast( fdata );
            ret.Set( fdata2.BinaryData() );
            }
        else
            {
            User::Leave( KErrArgument );
            }
        }
    return ret;
    }

	bool FindField(bson_iterator *itIn, bson_iterator *itOut, const String &fieldname, bool recursive)
	{
		bool found = false;
		while(!found && bson_iterator_next(itIn))
		{
			String itKey = String(bson_iterator_key(itIn));
			if(fieldname == itKey)
			{
				*itOut = *itIn;
				found = true;
			}
			else if(    (recursive && (BSON_OBJECT == bson_iterator_type(itIn)))
                    ||  (recursive && (BSON_ARRAY == bson_iterator_type(itIn))))
			{
				bson_iterator subIt;
				bson_iterator_subiterator(itIn, &subIt);

				found = FindField(&subIt, itOut, fieldname, recursive);
			}
		}

		return found;
	}

// ----------------------------------------------------------------------------
// GetFieldData, for EVPbkFieldStorageTypeDateTime
// ----------------------------------------------------------------------------
EXPORT_C TTime CContactMatcher::GetFieldDataDateTimeL(
    const MVPbkStoreContact& aContact,
    const MVPbkFieldType& aFType ) const
    {
    //               YYYYMMDD:HHMMSS.MMMMMM
    _LIT(KNullTime, "11110000:010101.00000");
    TTime ret(KNullTime);
    const MVPbkStoreContactField* field = FindField( aContact, aFType);
    if (field)
        {
        const MVPbkContactFieldData& fdata = field->FieldData();
        if (fdata.DataType() == EVPbkFieldStorageTypeDateTime)
            {
            const MVPbkContactFieldDateTimeData& fdata2 =
                MVPbkContactFieldDateTimeData::Cast( fdata );
            ret = fdata2.DateTime();
            }
        else
            {
            User::Leave( KErrArgument );
            }
        }
    return ret;
    }

DwFieldBody& DwHeaders::FieldBody(const DwString& aFieldName)
{
    assert(aFieldName != "");
    // First, search for field
    DwField* field = FindField(aFieldName);
    // If the field is not found, create the field and its field body
    if (field == 0) {
        field = DwField::NewField("", this);
        field->SetFieldNameStr(aFieldName);
        DwFieldBody* fieldBody = DwField::CreateFieldBody(aFieldName,
            "", field);
        field->SetFieldBody(fieldBody);
        AddField(field);
    }
    // Get the field body
    DwFieldBody* fieldBody = field->FieldBody();
    // If it does not exist, create it
    if (fieldBody == 0) {
        fieldBody = DwField::CreateFieldBody(aFieldName, "", field);
        field->SetFieldBody(fieldBody);
        SetModified();
    }
    return *fieldBody;
}