AAX_CString.h

Go to the documentation of this file.

/*================================================================================================*/
/*
 *
 *  Copyright 2013 by Avid Technology, Inc.
 *  All rights reserved.
 *  
 *  CONFIDENTIAL: This document contains confidential information.  Do not 
 *  read or examine this document unless you are an Avid Technology employee
 *  or have signed a non-disclosure agreement with Avid Technology which protects
 *  the confidentiality of this document.  DO NOT DISCLOSE ANY INFORMATION 
 *  CONTAINED IN THIS DOCUMENT TO ANY THIRD-PARTY WITHOUT THE PRIOR WRITTEN CONSENT 
 *  OF Avid Technolgy, INC.
 *
 */

/*================================================================================================*/


#ifndef AAX_CSTRING_H
#define AAX_CSTRING_H

#include "AAX_IString.h"
#include <string>


class AAX_CString : public AAX_IString
{
public:
    static const uint32_t   kInvalidIndex = static_cast<uint32_t>(-1);
    static const uint32_t   kMaxStringLength = static_cast<uint32_t>(-2);

    // AAX_IString Virtual Overrides
    virtual uint32_t        Length() const;
    virtual uint32_t        MaxLength() const;
    virtual const char *    Get ()  const;
    virtual void            Set ( const char * iString );       
    virtual AAX_IString &   operator=(const AAX_IString & iOther);
    virtual AAX_IString &   operator=(const char * iString);
    
    AAX_CString();
    
    AAX_CString(const char* str);
    
    explicit AAX_CString(const std::string& str);
    
    AAX_CString(const AAX_CString& other);

    AAX_CString(const AAX_IString& other);


    std::string&        StdString();
    
    const std::string&  StdString() const;

    AAX_CString&    operator=(const AAX_CString& other);
    
    AAX_CString &   operator=(const std::string& other);
            
    friend std::ostream& operator<< (std::ostream& os, const AAX_CString& str);

    friend std::istream& operator>> (std::istream& os, AAX_CString& str);

    
    // String Formatting Functions
    void            Clear();
    bool            Empty() const;
    AAX_CString&    Erase(uint32_t pos, uint32_t n);
    AAX_CString&    Append(const AAX_CString& str);
    AAX_CString&    Append(const char* str);
    AAX_CString&    AppendNumber(double number, int32_t precision);
    AAX_CString&    AppendNumber(int32_t number);
    AAX_CString&    Insert(uint32_t pos, const AAX_CString& str);
    AAX_CString&    Insert(uint32_t pos, const char* str);
    AAX_CString&    InsertNumber(uint32_t pos, double number, int32_t precision);
    AAX_CString&    InsertNumber(uint32_t pos, int32_t number);
    AAX_CString&    Replace(uint32_t pos, uint32_t n, const AAX_CString& str);
    AAX_CString&    Replace(uint32_t pos, uint32_t n, const char* str);
    uint32_t        FindFirst(const AAX_CString& findStr) const;
    uint32_t        FindFirst(const char* findStr) const;
    uint32_t        FindFirst(char findChar) const;
    uint32_t        FindLast(const AAX_CString& findStr) const;
    uint32_t        FindLast(const char* findStr) const;
    uint32_t        FindLast(char findChar) const;  
    const char*     CString()   const;
    bool            ToDouble(double* oValue)    const;
    bool            ToInteger(int32_t* oValue)  const;
    void            SubString(uint32_t pos, uint32_t n, AAX_IString* outputStr) const;
    
    // Operator Overrides
    bool            operator==(const AAX_CString& other) const;
    bool            operator==(const char* otherStr) const;
    bool            operator==(const std::string& otherStr) const;      //beware of STL variations between binaries.
    bool            operator!=(const AAX_CString& other) const;
    bool            operator!=(const char* otherStr) const;
    bool            operator!=(const std::string& otherStr) const;      //beware of STL variations between binaries.
    bool            operator<(const AAX_CString& other) const;
    bool            operator>(const AAX_CString& other) const;
    const char&     operator[](uint32_t index) const;
    char&           operator[](uint32_t index);
    AAX_CString&    operator+=(const AAX_CString& str);
    AAX_CString&    operator+=(const char* str);

protected:
    std::string     mString;
};



#endif //AAX_CSTRING_H