gittpl.h

/*
 * Name: filter.m4
 *
 * Description:
 *     DOXYGEN Input file filter for DRAMA source files.
 *
 *     This file must be complatible with both Solaris and GNU m4.  All
 *     unused macros are deleted and this comment must end up as a C/C++
 *     compatible comment which is not picked up by DOXYGEN.
 * 
 * Synopsis:
 *    DCF(func)  => Produces a link to a DRAMA C source file func.html 
 *                   in ../routines.
 *     DDL(link,text) => Produce a link to ../link.html, specified link text.
 *
 * Language: m4 macro. 
 *
 * Author: Tony Farrell, AAO.
 *
 * "@(#) $Id$"
 *
 * History:
 *     10-Nov-2004 - TJF - Original Version.
 */
 
 
 
#ifndef GITTEMPLSINC
#define GITTEMPLSINC
/*
 *  Copyright (c) Anglo-Australian Telescope Board, 1995.
 *   Not to be used for commercial purposes without AATB permission.
 *  
 *     @(#) $Id$
 *
 *  Template versions of the Git C++ interfaces - within the GitTpl namespace.
 *
 *      This file now uses DOXYGEN comments to generate the C++ web pages.
 *      m4 macros of the form @htmlonly <a href="../routines/function.html">function()</a>@endhtmlonly are used in the comments
 *      to refer to DRAMA C function documentation (see DramaHtml/Makefile,
 *      DramaHtml/doxygen.config and DramaHtml/filter.m4 for detials)
 *
 */
 
#include "Git.h"
#include <string>
#include <limits.h>
 
namespace GitTpl {
class EnumLookupClass {
 public:
    virtual unsigned int GetMaxValue() const = 0;
    virtual const char  ** GetStringArray() const = 0;
    virtual ~EnumLookupClass() {}
};
 
template <typename LookupClass, typename EnumType> DPUBLICCLASS Enum : public Git {
 private:
    EnumType value;  // The underlying value and the only memory used by the class.
    LookupClass lookupObject; // allows us to invoke the methods of this class.
 
    // Set the value of the object from an int.  If out of range, set to
    // GetMaxValue + 1.
    void SetValue(const unsigned int i) {
        if (i > lookupObject.GetMaxValue()) 
            value = InvalidValue();
        else
            value = (EnumType)i;            
    }
    EnumType InvalidValue() const {
        return (EnumType)(lookupObject.GetMaxValue()+1);
    }
 protected:
 public:
    Enum() {
        value = InvalidValue();
    }
    Enum(EnumType InitialValue) : value(InitialValue) {}
 
    Enum(const SdsId& Id,
             const char * const Name,
             const int Position,
             StatusType *status,
             const char *Default=0,
             const int Flags = Git::Upper|Git::Abbrev) {
        value = InvalidValue();
        Get(Id, Name, Position, status, Default, Flags);
    }
                      
    void Get(const SdsId& Id,
             const char * const Name,
             const int Position,
             StatusType *status,
             const char *Default=0,
             const int Flags = Git::Upper|Git::Abbrev|Git::KeepErr)    {
        char string[100];
        int index;
        GitArgGetS((SdsIdType)Id,Name,Position,
                   lookupObject.GetStringArray(),
                   Default,
                   Flags,sizeof(string),string,&index,status);
        SetValue(index);
    };
    operator EnumType() const {
        return value;
    }
    operator const char *() const {
        return lookupObject.GetStringArray()[int(value)];
    }
    virtual ~Enum() {};
 
};
 
 
 
template <long int MinVal, 
          long int MaxVal,
          long int DefaultVal=0> DPUBLICCLASS Real : public GitReal {
 private:
    // Return the range we need.
    virtual const double * Range() { 
        static const double range[] = { MinVal, MaxVal };
        return range;        
    }
 public:
 
    Real(const double def = (double)DefaultVal) : GitReal(def) { }
 
    Real (      /*Constructor with automatic Get        */
        const SdsId& Id,
        const char * const Name,
        const int Position,
        StatusType * const status,
        const double  Default = (double)DefaultVal,
        const int Flags = Git::KeepErr) : GitReal(Default) {
            GitReal::Get(Id,Name,Position,status,Default,Flags);
        }
};
 
template <long int MinVal=LONG_MIN, 
          long int MaxVal=LONG_MAX, 
          long int DefaultVal=0> DPUBLICCLASS Int : public GitInt {
 private:
    // Return the range we need.
    virtual const long int * Range() { 
        static const long int range[] = { MinVal, MaxVal };
        return range;        
    }
 public:
 
    Int(const long def = DefaultVal) : GitInt(def) { }
 
    Int (       /*Constructor with automatic Get        */
        const SdsId& Id,
        const char * const Name,
        const int Position,
        StatusType * const status,
        const long  Default = DefaultVal,
        const int Flags = Git::KeepErr) : GitInt(Default) {
            GitInt::Get(Id,Name,Position,status,Default,Flags);
        }
};
 
class String : public std::string {
 
 private:
    static const unsigned DefaultStringLength = 100;
 
 public:
    String() : std::string() {}
    String(const std::string & str) : std::string(str) {}
    String(const std::string & str, size_type pos, size_type n=std::string::npos) :
        std::string(str, pos, n) {}
    String(const char * s) : std::string(s) {}
    String(const char * s, size_type n) : std::string(s,n) {}
    String(size_type n, char c) : std::string(n,c) {}
    template<class InputIterator>
        String(InputIterator beg, InputIterator end) : std::string(beg,end){}
 
    String( const SdsId& Id,
            const char * const Name,
            const int Position,
            StatusType * const status,
            const char *  Default = 0,
            const int Flags = Git::KeepErr) {
        this->Get(Id, Name, Position, status, Default, Flags);
    }
 
 
    String& operator=(const std::string &str) {
        this->std::string::operator=(str);
        return *this;
    }
    String& operator=(const String &str) {
        this->std::string::operator=(std::string(str));
        return *this;
    }
    String& operator=(const char *s) {
        this->std::string::operator=(s);
        return *this;
    }
    String& operator=(char c) {
        this->std::string::operator=(c);
        return *this;
    }
    /*
     * source of this function is in gitcpp.C.
     */
    void Get (const SdsId& Id,
              const char * const Name,
              const int Position,
              StatusType * const status,
              const char *  Default = 0,
              const int Flags = Git::KeepErr);
}; /* String */
 
 
} /* namespace Git */
#endif  /* define GITNEWINC */