UT/UT_StringArray.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Mark Elendt
 *      Side Effects
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        UT library (C++)
 *
 * COMMENTS:    General purpose reference counting class
 *
 */

#ifndef __UT_StringArray_h__
#define __UT_StringArray_h__

#include "UT_API.h"
#include <string>
#include <vector>
#include "UT_RefArray.h"
#include "UT_String.h"


class UT_API UT_StringArray {
public:
    typedef int (*Comparator)(const UT_String *, const UT_String *s2);

                                 UT_StringArray();
    explicit                     UT_StringArray(const char **src);
                                 UT_StringArray(const UT_StringArray &src);

                                ~UT_StringArray();

    // this merges two string arrays into this and leaving other empty
    void                         merge( UT_StringArray &other );
    int                          append(const char *str);
    int                          insert(const char *str, int idx);
    int                          remove(int idx);
    void                         removeLast();
    void                         clear();

    // Note this DOES set the number of entries.
    void                         resize(int nsize);
    int                          entries() const;
    int                          capacity() const
                                 { return myStrings.capacity(); }

    // Convert from and to a vector of strings.
    void                         fromStdVectorOfStrings(
                                    const std::vector<std::string> &vec);
    void                         toStdVectorOfStrings(
                                    std::vector<std::string> &vec) const;

    const UT_StringArray        &operator=(const UT_StringArray &src);
    UT_String                   &operator()(int idx);
    const UT_String             &operator()(int idx) const;
    UT_String                   &last();
    const UT_String             &last() const;
    bool                         operator==(const UT_StringArray &src) const;
    bool                         operator!=(const UT_StringArray &src) const;

    int                          find(const char *str, unsigned int s=0) const;

    void                         sort(bool forward, bool numbered);

    // We specialize the default case explicitly instead of using default
    // parameters or else someone calling the sort(Comparator) method 
    // can unexpectedly call the wrong sort function if given the wrong
    // comparison function pointer. This way, we can get a compiler error.
    void                         sort() { sort(true, true); }

    // This method allows arbitrary sorting of the array.
    void                         sort(Comparator compare);

    int                          sortedInsert(const char *str,
                                              bool forward = true,
                                              bool numbered = true);
    int                          sortedFind(const char *str,
                                            bool forward = true,
                                            bool numbered = true) const;

    int                          getLongestPrefixLength() const;

    // Join the string array elements together, usng the passed string
    // as a separator between elements, and return the result.
    void                         join(const char *sep, UT_String &result) const;

    // Compute a hash value from the hash for each string in the array.
    // The hash value is order-independent - that is {"Cf", "Of"} will hash
    // to the same value as {"Of", "Cf"}.
    unsigned                     hash() const;

private:
    UT_RefArray<UT_String>       myStrings;
};

#endif

---