← Back to branch summary

~ubuntu-branches/ubuntu/precise/kbibtex/precise

« back to all changes in this revision

Viewing changes to src/entry.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Jonathan Patrick Davies
  • Date: 2007-10-28 10:06:45 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20071028100645-jw9oadntiao5oszf
Tags: 0.2-0ubuntu1
* New upstream release.
* Bumped up compat and debhelper versions to 5.
* Added Original-Maintainer as per Ubuntu spec.
* Moved Homepage as per Debian spec.
* Removed from patches:
  - 10-invalid_pure_specifier.dpatch - applied upstream.
  - 11-accented_characters.dpatch - applied upstream.
  - 12-empty_pubmed_search.dpatch - applied upstream.
  - 13-store_search_urls.dpatch - applied upstream.
* Updated 14-xslt_export and use simple-patchsys instead.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/entry.cpp
1
1
/***************************************************************************
2
 
*   Copyright (C) 2004-2006 by Thomas Fischer                             *
 
2
*   Copyright (C) 2004-2007 by Thomas Fischer                             *
3
3
*   fischer@unix-ag.uni-kl.de                                             *
4
4
*                                                                         *
5
5
*   This program is free software; you can redistribute it and/or modify  *
46
46
    Entry::Entry( const QString& entryTypeString, const QString& id ) : Element( ), m_entryTypeString( entryTypeString ), m_id( id )
47
47
    {
48
48
        m_entryType = entryTypeFromString( entryTypeString );
 
49
        if ( m_entryType != etUnknown )
 
50
            m_entryTypeString = entryTypeToString( m_entryType );
49
51
    }
50
52
 
51
53
    Entry::Entry( Entry *other )
61
63
        }
62
64
    }
63
65
 
 
66
    Element* Entry::clone()
 
67
    {
 
68
        return new Entry( this );
 
69
    }
 
70
 
 
71
    QString Entry::text()
 
72
    {
 
73
        QString result = "Id: ";
 
74
        result.append( m_id ).append( "\n" );
 
75
 
 
76
        for ( EntryFields::iterator it = m_fields.begin(); it != m_fields.end(); it++ )
 
77
            result.append(( *it )->value()->text() ).append( "\n" );
 
78
 
 
79
        return result;
 
80
    }
 
81
 
64
82
    void Entry::setEntryType( const EntryType entryType )
65
83
    {
66
84
        m_entryType = entryType;
107
125
    QStringList Entry::urls()
108
126
    {
109
127
        QStringList result;
110
 
        QString fieldNames[] = {"localfile", "pdf", "ps", "postscript", "doi", "url", "howpublished", "ee"};
 
128
        QString fieldNames[] = {"localfile", "pdf", "ps", "postscript", "doi", "url", "howpublished", "ee", "biburl"};
111
129
 
112
 
        for ( int i = 0; i < 8; i++ )
 
130
        for ( unsigned int i = 0; i < sizeof( fieldNames ) / sizeof( fieldNames[0] ); i++ )
113
131
        {
114
132
            EntryField * field = getField( fieldNames[ i ] );
115
 
            if ( ( field && !field->value() ->isEmpty() ) )
 
133
            if (( field && !field->value() ->items.isEmpty() ) )
116
134
            {
117
 
                Value * value = field->value();
118
 
                if ( value->count() == 1 && !value->first() ->isStringKey() )
 
135
                PlainText *plainText = dynamic_cast<PlainText*>( field->value()->items.first() );
 
136
                if ( plainText != NULL )
119
137
                {
120
 
                    QString plain = value->plainString();
 
138
                    QString plain = plainText->text();
121
139
                    int urlPos = plain.find( "\\url{", 0, FALSE );
122
140
                    if ( urlPos > -1 )
123
141
                    {
144
162
        return TRUE;
145
163
    }
146
164
 
147
 
    EntryField* Entry::getField( const EntryField::FieldType fieldType )
 
165
    EntryField* Entry::getField( const EntryField::FieldType fieldType ) const
148
166
    {
149
167
        EntryField * result = NULL;
150
168
 
151
 
        for ( EntryFields::iterator it = m_fields.begin(); ( it != m_fields.end() ) && ( result == NULL ); it++ )
152
 
            if ( ( *it ) ->fieldType() == fieldType ) result = *it;
 
169
        for ( EntryFields::ConstIterator it = m_fields.begin(); ( it != m_fields.end() ) && ( result == NULL ); it++ )
 
170
            if (( *it ) ->fieldType() == fieldType ) result = *it;
153
171
 
154
172
        return result;
155
173
    }
156
174
 
157
 
    EntryField* Entry::getField( const QString & fieldName )
 
175
    EntryField* Entry::getField( const QString & fieldName ) const
158
176
    {
159
177
        EntryField * result = NULL;
160
178
 
161
 
        for ( EntryFields::iterator it = m_fields.begin(); ( it != m_fields.end() ) && ( result == NULL ); it++ )
162
 
            if ( ( *it ) ->fieldTypeName().lower() == fieldName.lower() )
 
179
        for ( EntryFields::ConstIterator it = m_fields.begin(); ( it != m_fields.end() ) && ( result == NULL ); it++ )
 
180
            if (( *it ) ->fieldTypeName().lower() == fieldName.lower() )
163
181
                result = *it;
164
182
 
165
183
        return result;
167
185
 
168
186
    bool Entry::deleteField( const QString & fieldName )
169
187
    {
170
 
        for ( EntryFields::iterator it = m_fields.begin(); it != m_fields.end(); it++ )
171
 
            if ( ( *it ) ->fieldTypeName().lower() == fieldName.lower() )
 
188
        for ( EntryFields::ConstIterator it = m_fields.begin(); it != m_fields.end(); it++ )
 
189
            if (( *it ) ->fieldTypeName().lower() == fieldName.lower() )
172
190
            {
173
191
                delete( *it );
174
 
                m_fields.remove( it );
 
192
                m_fields.remove( *it );
175
193
                return TRUE;
176
194
            }
177
195
 
181
199
    bool Entry::deleteField( const EntryField::FieldType fieldType )
182
200
    {
183
201
        for ( EntryFields::iterator it = m_fields.begin(); it != m_fields.end(); it++ )
184
 
            if ( ( *it ) ->fieldType() == fieldType )
 
202
            if (( *it ) ->fieldType() == fieldType )
185
203
            {
186
204
                delete( *it );
187
205
                m_fields.remove( it );
223
241
            m_fields.append( new EntryField( *it ) );
224
242
    }
225
243
 
 
244
    void Entry::merge( BibTeX::Entry *other )
 
245
    {
 
246
        for ( EntryFields::iterator it = other->m_fields.begin(); it != other->m_fields.end(); it++ )
 
247
        {
 
248
            EntryField *otherField = new EntryField( *it );
 
249
            EntryField::FieldType otherFieldType = otherField->fieldType();
 
250
            QString otherFieldTypeName = otherField->fieldTypeName();
 
251
            EntryField *thisField = otherFieldType != EntryField::ftUnknown ? getField( otherFieldType ) : getField( otherFieldTypeName );
 
252
 
 
253
            if ( thisField != NULL )
 
254
            {
 
255
                otherFieldTypeName.prepend( "OPT" );
 
256
                otherField->setFieldType( EntryField::ftUnknown, otherFieldTypeName );
 
257
            }
 
258
            m_fields.append( otherField );
 
259
        }
 
260
    }
 
261
 
226
262
    QString Entry::entryTypeToString( const EntryType entryType )
227
263
    {
228
264
        switch ( entryType )
273
309
            return etBooklet;
274
310
        else if ( entryTypeStringLower == "collection" )
275
311
            return etCollection;
276
 
        else if ( ( entryTypeStringLower == "electronic" ) || ( entryTypeStringLower == "online" ) || ( entryTypeStringLower == "internet" ) || ( entryTypeStringLower == "webpage" ) )
 
312
        else if (( entryTypeStringLower == "electronic" ) || ( entryTypeStringLower == "online" ) || ( entryTypeStringLower == "internet" ) || ( entryTypeStringLower == "webpage" ) )
277
313
            return etElectronic;
278
314
        else if ( entryTypeStringLower == "inbook" )
279
315
            return etInBook;
280
316
        else if ( entryTypeStringLower == "incollection" )
281
317
            return etInCollection;
282
 
        else if ( ( entryTypeStringLower == "inproceedings" ) || ( entryTypeStringLower == "conference" ) )
 
318
        else if (( entryTypeStringLower == "inproceedings" ) || ( entryTypeStringLower == "conference" ) )
283
319
            return etInProceedings;
284
320
        else if ( entryTypeStringLower == "manual" )
285
321
            return etManual;
322
358
            case EntryField::ftURL:
323
359
            case EntryField::ftLocalFile:
324
360
                return Entry::frsOptional;
325
 
            default: return Entry::frsIgnored;
 
361
            default:
 
362
                return Entry::frsIgnored;
326
363
            }
327
364
        case etBook:
328
365
            switch ( fieldType )
345
382
            case EntryField::ftURL:
346
383
            case EntryField::ftLocalFile:
347
384
                return Entry::frsOptional;
348
 
            default: return Entry::frsIgnored;
 
385
            default:
 
386
                return Entry::frsIgnored;
349
387
            }
350
388
        case etBooklet:
351
389
            switch ( fieldType )
364
402
            case EntryField::ftURL:
365
403
            case EntryField::ftLocalFile:
366
404
                return Entry::frsOptional;
367
 
            default: return Entry::frsIgnored;
 
405
            default:
 
406
                return Entry::frsIgnored;
368
407
            }
369
408
        case etElectronic:
370
409
            switch ( fieldType )
380
419
            case EntryField::ftKey:
381
420
            case EntryField::ftLocalFile:
382
421
                return Entry::frsOptional;
383
 
            default: return Entry::frsIgnored;
 
422
            default:
 
423
                return Entry::frsIgnored;
384
424
            }
385
425
        case etInBook:
386
426
            switch ( fieldType )
406
446
            case EntryField::ftURL:
407
447
            case EntryField::ftLocalFile:
408
448
                return Entry::frsOptional;
409
 
            default: return Entry::frsIgnored;
 
449
            default:
 
450
                return Entry::frsIgnored;
410
451
            }
411
452
        case etInCollection:
412
453
            switch ( fieldType )
432
473
            case EntryField::ftURL:
433
474
            case EntryField::ftLocalFile:
434
475
                return Entry::frsOptional;
435
 
            default: return Entry::frsIgnored;
 
476
            default:
 
477
                return Entry::frsIgnored;
436
478
            }
437
479
        case etInProceedings:
438
480
            switch ( fieldType )
461
503
            case EntryField::ftURL:
462
504
            case EntryField::ftLocalFile:
463
505
                return Entry::frsOptional;
464
 
            default: return Entry::frsIgnored;
 
506
            default:
 
507
                return Entry::frsIgnored;
465
508
            }
466
509
        case etManual:
467
510
            switch ( fieldType )
480
523
            case EntryField::ftURL:
481
524
            case EntryField::ftLocalFile:
482
525
                return Entry::frsOptional;
483
 
            default: return Entry::frsIgnored;
 
526
            default:
 
527
                return Entry::frsIgnored;
484
528
            }
485
529
        case etMastersThesis:
486
530
            switch ( fieldType )
498
542
            case EntryField::ftURL:
499
543
            case EntryField::ftLocalFile:
500
544
                return Entry::frsOptional;
501
 
            default: return Entry::frsIgnored;
 
545
            default:
 
546
                return Entry::frsIgnored;
502
547
            }
503
548
        case etMisc:
504
549
            switch ( fieldType )
514
559
            case EntryField::ftURL:
515
560
            case EntryField::ftLocalFile:
516
561
                return Entry::frsOptional;
517
 
            default: return Entry::frsIgnored;
 
562
            default:
 
563
                return Entry::frsIgnored;
518
564
            }
519
565
        case etPhDThesis:
520
566
            switch ( fieldType )
533
579
            case EntryField::ftURL:
534
580
            case EntryField::ftLocalFile:
535
581
                return Entry::frsOptional;
536
 
            default: return Entry::frsIgnored;
 
582
            default:
 
583
                return Entry::frsIgnored;
537
584
            }
538
585
        case etCollection:
539
586
        case etProceedings:
557
604
            case EntryField::ftURL:
558
605
            case EntryField::ftLocalFile:
559
606
                return Entry::frsOptional;
560
 
            default: return Entry::frsIgnored;
 
607
            default:
 
608
                return Entry::frsIgnored;
561
609
            }
562
610
        case etTechReport:
563
611
            switch ( fieldType )
576
624
            case EntryField::ftKey:
577
625
            case EntryField::ftURL:
578
626
            case EntryField::ftLocalFile:
 
627
            case EntryField::ftISSN:
579
628
                return Entry::frsOptional;
580
 
            default: return Entry::frsIgnored;
 
629
            default:
 
630
                return Entry::frsIgnored;
581
631
            }
582
632
        case etUnpublished:
583
633
            switch ( fieldType )
593
643
            case EntryField::ftURL:
594
644
            case EntryField::ftLocalFile:
595
645
                return Entry::frsOptional;
596
 
            default: return Entry::frsIgnored;
 
646
            default:
 
647
                return Entry::frsIgnored;
597
648
            }
598
649
        default:
599
650
            return Entry::frsOptional;