reference.h

Go to the documentation of this file.

#ifndef REFERENCE_H
#define REFERENCE_H
#pragma once
/***************************************************************************
 *   Copyright (C) 2007-2013 Mike Kinghan, imk@burroingroingjoing.com      *
 *   All rights reserved.                                                  *
 *                                                                         *
 *   Contributed originally by Mike Kinghan, imk@burroingroingjoing.com    *
 *                                                                         *
 *   Redistribution and use in source and binary forms, with or without    *
 *   modification, are permitted provided that the following conditions    *
 *   are met:                                                              *
 *                                                                         *
 *   Redistributions of source code must retain the above copyright        *
 *   notice, this list of conditions and the following disclaimer.         *
 *                                                                         *
 *   Redistributions in binary form must reproduce the above copyright     *
 *   notice, this list of conditions and the following disclaimer in the   *
 *   documentation and/or other materials provided with the distribution.  *
 *                                                                         *
 *   Neither the name of Mike Kinghan nor the names of its contributors    *
 *   may be used to endorse or promote products derived from this software *
 *   without specific prior written permission.                            *
 *                                                                         *
 *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS   *
 *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT     *
 *   LIMITED TO, THE IMPLIED WARRANTIES OF  MERCHANTABILITY AND FITNESS    *
 *   FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE        *
 *   COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,   *
 *   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,  *
 *   BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS *
 *   OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED    *
 *   AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,*
 *   OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF *
 *   THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH  *
 *   DAMAGE.                                                               *
 *                                                                         *
 **************************************************************************/

#include "prohibit.h"
#include "symbol.h"
#include "argument_list.h"
#include "reference_cache.h"
#include <string>


struct reference
{
        using insert_result = reference_cache::insert_result;

        explicit
        reference(symbol::locator loc, reference const * invoker = nullptr)
        :       _referee(loc),
                _args(_referee->parameters()),
                _invoker(invoker),
                _key(_referee.id() + _args.str()){}


        reference(
                symbol::locator loc,
                argument_list const & args,
                reference const * invoker = nullptr)
        :       _referee(loc),_args(args),
                _invoker(invoker),
                _key(_referee.id() + _args.str()){
                        _referee->set_invoked();
                }


        template<class CharSeq>
        reference(
                symbol::locator loc,
                chewer<CharSeq> & chew,
                reference const * invoker = nullptr)
        :       _referee(loc),_args(chew),
                _invoker(invoker),_key(_referee.id() + _args.str()) {
        static_assert(traits::is_random_access_char_sequence<CharSeq>::value,
            ">:[");
                _referee->set_invoked();
        }

        virtual ~reference() = default;

        bool operator==(reference const & other) const {
                return _referee.id() == other._referee.id() &&
                        _args == other._args;
        }

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

        symbol::locator const & callee() const {
                return _referee;
        }
        symbol::locator callee() {
                return _referee;
        }

        std::string const & id() const {
                return _referee.id();
        }

        argument_list const & args() const {
                return _args;
        }
        argument_list & args() {
                return _args;
        }

        virtual std::string const & invocation() const {
                return _key;
        }

        std::string const & expansion() {
                return lookup().first->second.expansion();
        }

        evaluation const & eval() {
                return lookup().first->second.eval();
        }

        bool reported() {
                return lookup().first->second.reported();
        }

        bool complete() {
                return lookup().first->second.complete();
        }

        void report() {
                if (reportable()) {
                        do_report();
                }
        }

protected:

        bool explain() const {
                return _referee->configured() && explaining();
        }

        bool explaining() const;

        bool reportable() const;

        void do_report();


        reference_cache::iterator lower_bound() const {
                return reference_cache::lower_bound(_key);
        }

        reference_cache::insert_result lookup();

        reference_cache::value_type digest();

        reference_cache::entry expand(bool explain);

        evaluation validate() const;

        symbol::locator _referee;
        argument_list _args;
        reference const * _invoker;
        std::string _key;
};

#endif //EOF