← Back to branch summary

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

« back to all changes in this revision

Viewing changes to src/value.h

  • 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/value.h
20
20
#ifndef BIBTEXVALUE_H
21
21
#define BIBTEXVALUE_H
22
22
 
23
 
#include <qobject.h>
24
23
#include <qvaluelist.h>
25
24
 
 
25
class QStringList;
 
26
 
26
27
namespace BibTeX
27
28
{
28
 
    class ValueItem
 
29
    class ValueTextInterface
29
30
    {
30
31
    public:
31
 
        ValueItem( const QString& text, bool isStringKey );
32
 
        ValueItem( ValueItem *other );
33
 
 
34
 
        QString text() const;
35
 
        bool isStringKey() const;
36
 
        void setText( const QString &text );
37
 
        void setIsStringKey( bool isStringKey );
38
 
 
39
 
        bool containsPattern( const QString & pattern, bool caseSensitive ) const;
40
 
 
41
 
    protected:
 
32
        ValueTextInterface( const ValueTextInterface* other );
 
33
        ValueTextInterface( const QString& text );
 
34
        virtual ~ValueTextInterface() {};
 
35
 
 
36
        virtual void setText( const QString& text );
 
37
        virtual QString text() const;
 
38
        QString simplifiedText() const;
 
39
        virtual void replace( const QString &before, const QString &after );
 
40
        virtual bool containsPattern( const QString &pattern, bool caseSensitive );
 
41
 
 
42
    private:
42
43
        QString m_text;
43
 
        bool m_isStringKey;
44
 
    };
45
 
 
46
 
    class Value
47
 
    {
48
 
    public:
49
 
        Value( );
50
 
        Value( const Value* other );
51
 
        virtual ~Value( );
52
 
 
53
 
        virtual void add( ValueItem* valueItem );
54
 
        virtual void clear();
55
 
        BibTeX::ValueItem *first();
56
 
 
57
 
        bool isEmpty() const;
58
 
        int count() const;
59
 
        virtual bool containsPattern( const QString & pattern, bool caseSensitive ) const;
60
 
 
61
 
        static bool checkIsStringKey( const QString &text );
62
 
 
63
 
        QValueList<ValueItem*>::const_iterator begin() const;
64
 
        QValueList<ValueItem*>::const_iterator end() const;
65
 
 
66
 
        QString plainString() const;
67
 
        QString debugString() const;
 
44
    };
 
45
 
 
46
    class ValueItem: public ValueTextInterface
 
47
    {
 
48
    public:
 
49
        ValueItem( const QString& text );
 
50
 
 
51
        virtual ValueItem *clone()
 
52
        {
 
53
            return NULL;
 
54
        };
 
55
    };
 
56
 
 
57
    class Keyword: public ValueTextInterface
 
58
    {
 
59
    public:
 
60
        Keyword( Keyword *other );
 
61
        Keyword( const QString& text );
 
62
 
 
63
        Keyword *clone();
 
64
    };
 
65
 
 
66
    class KeywordContainer: public ValueItem
 
67
    {
 
68
    public:
 
69
        KeywordContainer();
 
70
        KeywordContainer( const QString& text );
 
71
        KeywordContainer( KeywordContainer *other );
 
72
        KeywordContainer( const QStringList& list );
 
73
 
 
74
        ValueItem *clone();
 
75
        void setList( const QStringList& list );
 
76
        void append( const QString& text );
 
77
        void remove( const QString& text );
 
78
        void setText( const QString& text );
 
79
        QString text() const;
 
80
        void replace( const QString &before, const QString &after );
 
81
 
 
82
        QValueList<Keyword*> keywords;
 
83
    };
 
84
 
 
85
    class Person: public ValueTextInterface
 
86
    {
 
87
    public:
 
88
        Person( const QString& text, bool firstNameFirst = FALSE );
 
89
        Person( const QString& firstName, const QString& lastName, bool firstNameFirst = FALSE );
 
90
 
 
91
        Person *clone();
 
92
        void setText( const QString& text );
 
93
        QString text() const;
 
94
 
 
95
        QString firstName();
 
96
        QString lastName();
68
97
 
69
98
    protected:
70
 
        QValueList<ValueItem*> m_valueItems;
71
 
    };
72
 
 
73
 
    class Person
74
 
    {
75
 
    public:
76
 
        Person( const QString& text );
77
 
        Person( const QString& firstName, const QString& lastName );
78
 
        Person( const Person* other );
79
 
 
80
 
        void setText( const QString &text );
81
 
        QString text() const;
82
 
        QString lastName() const;
83
 
        QString firstName() const;
84
 
 
85
 
        bool containsPattern( const QString & pattern, bool caseSensitive ) const;
86
 
 
87
 
    private:
 
99
        QString m_firstName;
88
100
        QString m_lastName;
89
 
        QString m_firstName;
90
 
 
91
 
        void parseText( const QString& text );
92
 
    };
93
 
 
94
 
    class ValuePersons: public Value
95
 
    {
96
 
    public:
97
 
        ValuePersons( );
98
 
        ValuePersons( const BibTeX::ValuePersons* other );
99
 
        ~ValuePersons();
100
 
 
101
 
        void add ( ValueItem* valueItem );
102
 
        void clear();
103
 
        bool containsPattern( const QString & pattern, bool caseSensitive ) const;
104
 
 
105
 
        QValueList<Person*> persons() const;
106
 
 
107
 
    private:
108
 
        QValueList<Person*> m_persons;
109
 
    };
110
 
 
 
101
        bool m_firstNameFirst;
 
102
 
 
103
        bool splitName( const QString& text, QStringList& segments );
 
104
    };
 
105
 
 
106
    class PersonContainer: public ValueItem
 
107
    {
 
108
    public:
 
109
        PersonContainer( bool firstNameFirst = FALSE );
 
110
        PersonContainer( const QString& text, bool firstNameFirst = FALSE );
 
111
 
 
112
        ValueItem *clone();
 
113
        void setText( const QString& text );
 
114
        QString text() const;
 
115
        void replace( const QString &before, const QString &after );
 
116
 
 
117
        QValueList<Person*> persons;
 
118
 
 
119
    private:
 
120
        bool m_firstNameFirst;
 
121
    };
 
122
 
 
123
    class MacroKey: public ValueItem
 
124
    {
 
125
    private:
 
126
        bool m_isValid;
 
127
        bool isValidInternal();
 
128
 
 
129
    public:
 
130
        MacroKey( const QString& text );
 
131
 
 
132
        ValueItem *clone();
 
133
 
 
134
        void setText( const QString& text );
 
135
        bool isValid();
 
136
    };
 
137
 
 
138
    class PlainText: public ValueItem
 
139
    {
 
140
    public:
 
141
        PlainText( const QString& text );
 
142
 
 
143
        ValueItem *clone();
 
144
    };
 
145
 
 
146
    class Value: public ValueTextInterface
 
147
    {
 
148
    public:
 
149
        Value();
 
150
        Value( const Value *other );
 
151
        Value( const QString& text );
 
152
 
 
153
        void setText( const QString& text );
 
154
        QString text() const;
 
155
        void replace( const QString &before, const QString &after );
 
156
 
 
157
        QValueList<ValueItem*> items;
 
158
    };
111
159
}
112
160
 
113
161
#endif