ExprType.h

Go to the documentation of this file.

/*
 Copyright Disney Enterprises, Inc.  All rights reserved.

 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License
 and the following modification to it: Section 6 Trademarks.
 deleted and replaced with:

 6. Trademarks. This License does not grant permission to use the
 trade names, trademarks, service marks, or product names of the
 Licensor and its affiliates, except as required for reproducing
 the content of the NOTICE file.

 You may obtain a copy of the License at
 http://www.apache.org/licenses/LICENSE-2.0
*/
#ifndef ExprType_h
#define ExprType_h

#include <vector>
#include <string>
#include <map>
#include <cassert>
#include <sstream>

#pragma push_macro("None")
#undef None

namespace SeExpr2 {
class ExprType {
  public:
    enum Type {
        tERROR = 0,  
        tFP,         
        tSTRING,     
        tNONE
    };  

    enum Lifetime {
        ltERROR = 0,  
        ltVARYING,    
        ltUNIFORM,    
        ltCONSTANT    
    };

    ExprType() : _type(tERROR), _n(1), _lifetime(ltERROR) {}

    ExprType(Type type, int n, Lifetime lifetime) : _type(type), _n(n), _lifetime(lifetime) {
        assert(_n >= 1);
        assert(_type == tFP || _n == 1);
    }

    ExprType(const ExprType& other) : _type(other.type()), _n(other.dim()), _lifetime(other.lifetime()) {
        assert(_n >= 1);
        assert(_type == tFP || _n == 1);
    }

    bool operator!=(const ExprType& other) const { return !(*this == other); }

    bool operator==(const ExprType& other) const {
        return (type() == other.type() && dim() == other.dim() && lifetime() == other.lifetime());
    }


    // TODO: "None" is bad name, /usr/include/X11/X.h potentially text replaces it.
    ExprType& None() {
        _type = tNONE;
        _n = 1;
        return *this;
    }
    ExprType& FP(int d) {
        _type = tFP;
        _n = d;
        return *this;
    }
    ExprType& String() {
        _type = tSTRING;
        _n = 1;
        return *this;
    }
    ExprType& Error() {
        _type = tERROR;
        _n = 1;
        return *this;
    }


    ExprType& Constant() {
        _lifetime = ltCONSTANT;
        return *this;
    }
    ExprType& Uniform() {
        _lifetime = ltUNIFORM;
        return *this;
    }
    ExprType& Varying() {
        _lifetime = ltVARYING;
        return *this;
    }
    ExprType& LifeError() {
        _lifetime = ltERROR;
        return *this;
    }


    ExprType& setLifetime(const ExprType& a) {
        _lifetime = a.lifetime();
        return *this;
    }

    ExprType& setLifetime(const ExprType& a, const ExprType& b) {
        a.lifetime() < b.lifetime() ? setLifetime(a) : setLifetime(b);
        return *this;
    }

    ExprType& setLifetime(const ExprType& a, const ExprType& b, const ExprType& c) {
        setLifetime(a, b);
        setLifetime(*this, c);
        return *this;
    }

    //####################################################################

    // accessors
    Type type() const { return _type; }
    int dim() const { return _n; }
    Lifetime lifetime() const { return _lifetime; }

    bool isFP() const { return _type == tFP; }
    bool isFP(int d) const { return _type == tFP && _n == d; }
    bool isValue() const { return _type == tFP || _type == tSTRING; }
    bool isValid() const { return !isError() && !isLifetimeError(); }
    bool isError() const { return type() == tERROR; }
    bool isString() const { return type() == tSTRING; }
    bool isNone() const { return type() == tNONE; }

    static bool valuesCompatible(const ExprType& a, const ExprType& b) {
        return (a.isString() && b.isString()) ||
               (a._type == tFP && b._type == tFP && (a._n == 1 || b._n == 1 || a._n == b._n));
    }



    // lifetime matchers
    bool isLifetimeConstant() const { return lifetime() == ltCONSTANT; }
    bool isLifetimeUniform() const { return lifetime() == ltUNIFORM; }
    bool isLifetimeVarying() const { return lifetime() == ltVARYING; }
    bool isLifetimeError() const { return lifetime() == ltERROR; }

    bool isLifeCompatible(const ExprType& o) const { return o.lifetime() >= lifetime(); }

    std::string toString() const {
        std::stringstream ss;

        if (isLifetimeConstant())
            ss << "constant ";
        else if (isLifetimeUniform())
            ss << "uniform ";
        else if (isLifetimeVarying())
            ss << "varying ";
        else if (isLifetimeError())
            ss << "lifetime_error ";
        else
            ss << "Invalid_Lifetime ";

        if (isError())
            ss << "Error";
        else if (isFP(1))
            ss << "Float";
        else if (isFP())
            ss << "Float[" << dim() << "]";
        else if (isString())
            ss << "String";
        else if (isNone())
            ss << "None";
        else
            ss << "Invalid_Type";
        return ss.str();
    }

  private:
    Type _type;
    int _n;
    Lifetime _lifetime;
};

inline ExprType TypeVec(int n){
    return ExprType().FP(n).Varying();
}

} // namespace

#pragma pop_macro("None")

#endif