type.h

Go to the documentation of this file.

// -*- mode: C++; c-file-style: "stroustrup"; c-basic-offset: 4; indent-tabs-mode: nil; -*-

/* libutap - Uppaal Timed Automata Parser.
   Copyright (C) 2002-2006 Uppsala University and Aalborg University.
   
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public License
   as published by the Free Software Foundation; either version 2.1 of
   the License, or (at your option) any later version.

   This library is distributed in the hope that it will be useful, but
   WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
   USA
*/

#ifndef UTAP_TYPE_HH
#define UTAP_TYPE_HH

#include "utap/common.h"
#include "utap/position.h"

#include <cinttypes>
#include <string>
#include <memory> // shared_ptr

namespace UTAP
{
    class expression_t;
    class frame_t;
    class symbol_t;

    class type_t
    {
    private:
        struct child_t;
        struct type_data;
        std::shared_ptr<type_data> data;

        explicit type_t(Constants::kind_t kind,
                        const position_t &pos, size_t size);
    public:
        type_t(){};

        type_t(const type_t &);

        ~type_t(){};

        const type_t &operator = (const type_t &);

        bool operator == (const type_t &) const;

        bool operator != (const type_t &) const;

        Constants::kind_t getKind() const;

        position_t getPosition() const;

        size_t size() const;

        bool operator < (const type_t &) const;

        const type_t operator[](uint32_t) const;

        const type_t get(uint32_t) const;        

        const std::string &getLabel(uint32_t) const;

        expression_t getExpression() const;

        type_t getArraySize() const;

        type_t getSub() const;

        type_t getSub(size_t) const;

        size_t getRecordSize() const;
        
        std::string getRecordLabel(size_t i) const;

        int32_t findIndexOf(const std::string&) const;

        std::pair<expression_t, expression_t> getRange() const;

        std::string toString() const;

        std::string toDeclarationString() const;

        bool isRange() const { return is(Constants::RANGE); }

        bool isInteger() const { return is(Constants::INT); }

        bool isBoolean() const { return is(Constants::BOOL); }
        
        bool isFunction() const { return is(Constants::FUNCTION); }

        bool isProcess() const { return is(Constants::PROCESS); }

        bool isProcessSet() const { return is(Constants::PROCESSSET); }

        bool isLocation() const { return is(Constants::LOCATION); }

        bool isInstanceLine() const { return is(Constants::INSTANCELINE); }

        bool isBranchpoint() const { return is(Constants::BRANCHPOINT); }

        bool isChannel() const { return is(Constants::CHANNEL); }

        bool isArray() const { return is(Constants::ARRAY); }

        bool isScalar() const { return is(Constants::SCALAR); }

        bool isClock() const { return is(Constants::CLOCK); }

        bool isRecord() const { return is(Constants::RECORD); }
        
        bool isDiff() const { return is(Constants::DIFF); }

        bool isVoid() const { return is(Constants::VOID_TYPE); }
        
        bool isCost() const { return is(Constants::COST); }

        bool isDouble() const { return is(Constants::DOUBLE); }

        bool isIntegral() const;

        bool isInvariant() const;

        bool isGuard() const;

#ifdef ENABLE_PROB

        bool isProbability() const;
#endif

        bool isConstraint() const;

        bool isFormula() const;

        type_t strip() const;

        type_t stripArray() const;

        bool isPrefix() const;

        bool isConstant() const;

        bool isNonConstant() const;

        bool is(Constants::kind_t kind) const;

        bool unknown() const;

        type_t rename(const std::string& from, const std::string& to) const;

        type_t subst(symbol_t symbol, expression_t expr) const;
        type_t createPrefix(Constants::kind_t kind, position_t = position_t()) const;

        type_t createLabel(const std::string&, position_t = position_t()) const;

        type_t createPosition(position_t = position_t()) const;

        static type_t createRange(type_t, expression_t, expression_t,
                                  position_t = position_t());

        static type_t createPrimitive(Constants::kind_t,
                                      position_t = position_t());

        static type_t createArray(type_t sub, type_t size, position_t = position_t());

        static type_t createTypeDef(const std::string&, type_t,
                                    position_t = position_t());

        static type_t createProcess(frame_t, position_t = position_t());

        static type_t createProcessSet(type_t instance, position_t = position_t());

        static type_t createRecord(const std::vector<type_t> &,
                                   const std::vector<std::string> &,
                                   position_t = position_t());

        static type_t createFunction(type_t,
                                     const std::vector<type_t> &,
                                     const std::vector<std::string> &,
                                     position_t = position_t());

        static type_t createInstance(frame_t, position_t = position_t());
        static type_t createLscInstance(frame_t, position_t = position_t());
    };
}

std::ostream &operator << (std::ostream &o, UTAP::type_t t);

#endif