#pragma once

#include <unordered_map>
#include <unordered_set>
#include <tuple>
#include <utility>

#include "common.h"
#include "makeUnique.h"

#include "LibLsp/lsp/lsPosition.h"
#include "LibLsp/lsp/textDocument/documentColor.h"

namespace AsymptoteLsp
{
 struct SymbolLit
 {
   std::string name;
   std::vector<std::string> scopes;

   SymbolLit(std::string symName) :
     name(std::move(symName))
   {
   }

   SymbolLit(std::string symName, std::vector<std::string> scope) :
           name(std::move(symName)), scopes(std::move(scope))
   {
   }

   ~SymbolLit() = default;

   SymbolLit(SymbolLit const& sym) :
     name(sym.name), scopes(sym.scopes)
   {
   }

   SymbolLit& operator=(SymbolLit const& sym)
   {
     name = sym.name;
     scopes = sym.scopes;
     return *this;
   }

   SymbolLit(SymbolLit&& sym) noexcept :
     name(std::move(sym.name)), scopes(std::move(sym.scopes))
   {
   }

   SymbolLit& operator=(SymbolLit&& sym) noexcept
   {
     name = std::move(sym.name);
     scopes = std::move(sym.scopes);
     return *this;
   }

   bool operator==(SymbolLit const& other) const
   {
     return name == other.name and scopes == other.scopes;
   }

   bool matchesRaw(std::string const& sym) const
   {
     return name == sym;
   }
 };
} // namespace AsymptoteLsp

namespace std
{
 using AsymptoteLsp::SymbolLit;

 template<>
 struct hash<SymbolLit>
 {
   std::size_t operator()(SymbolLit const& sym) const
   {
     size_t final_hash = 0;
     final_hash ^= hash<std::string>()(sym.name);
     for (auto const& accessor : sym.scopes)
     {
       final_hash = (final_hash << 1) ^ hash<std::string>()(accessor);
     }
     return final_hash;
   }
 };
} // namespace std

namespace AsymptoteLsp
{
 using std::unordered_map;
 struct SymbolContext;

 typedef std::pair<std::string, SymbolContext*> contextedSymbol;
 typedef std::pair<size_t, size_t> posInFile;
 typedef std::pair<std::string, posInFile> filePos;
 typedef std::tuple<std::string, posInFile, posInFile> posRangeInFile;
 typedef std::tuple<SymbolLit, posInFile, posInFile> fullSymPosRangeInFile;


 // NOTE: lsPosition is zero-indexed, while all Asymptote positions (incl this struct) is 1-indexed.
 inline posInFile fromLsPosition(lsPosition const& inPos)
 {
   return std::make_pair(inPos.line + 1, inPos.character + 1);
 }

 inline lsPosition toLsPosition(posInFile const& inPos)
 {
   return lsPosition(inPos.first - 1, inPos.second - 1);
 }

 inline bool posLt(posInFile const& p1, posInFile const& p2)
 {
   return (p1.first < p2.first) or ((p1.first == p2.first) and (p1.second < p2.second));
 }

 std::string getPlainFile();
 bool isVirtualFile(std::string const& filename);

 // filename to positions
 struct positions
 {
   std::unordered_map<std::string, std::vector<posInFile>> pos;

   positions() = default;
   explicit positions(filePos const& positionInFile);
   void add(filePos const& positionInFile);
 };


 struct SymbolInfo
 {
   std::string name;
   optional<std::string> type;
   posInFile pos;

   SymbolInfo() : type(nullopt), pos(1, 1) {}

   SymbolInfo(std::string inName, posInFile position):
     name(std::move(inName)), type(nullopt), pos(std::move(position)) {}

   SymbolInfo(std::string inName, std::string inType, posInFile position):
     name(std::move(inName)), type(std::move(inType)), pos(std::move(position)) {}

   SymbolInfo(SymbolInfo const& symInfo) = default;

   SymbolInfo& operator=(SymbolInfo const& symInfo) = default;

   SymbolInfo(SymbolInfo&& symInfo) noexcept :
           name(std::move(symInfo.name)), type(std::move(symInfo.type)), pos(std::move(symInfo.pos))
   {
   }

   SymbolInfo& operator=(SymbolInfo&& symInfo) noexcept
   {
     name = std::move(symInfo.name);
     type = std::move(symInfo.type);
     pos = std::move(symInfo.pos);
     return *this;
   }

   virtual ~SymbolInfo() = default;

   bool operator==(SymbolInfo const& sym) const;

   [[nodiscard]]
   virtual std::string signature() const;
 };

 struct FunctionInfo: SymbolInfo
 {
   std::string returnType;
   using typeName = std::pair<std::string, optional<std::string>>;
   std::vector<typeName> arguments;
   optional<typeName> restArgs;

   FunctionInfo(std::string name, posInFile pos, std::string returnTyp):
           SymbolInfo(std::move(name), std::move(pos)),
           returnType(std::move(returnTyp)),
           arguments(), restArgs(nullopt) {}

   ~FunctionInfo() override = default;

   [[nodiscard]]
   std::string signature() const override;

   [[nodiscard]]
   std::string signature(std::vector<std::string> const& scopes) const;
 };


 struct TypeDec
 {
   posInFile position;
   std::string typeName;

   TypeDec(): position(1, 1) {}
   virtual ~TypeDec() = default;

   TypeDec(posInFile pos, std::string typName):
           position(std::move(pos)), typeName(std::move(typName))
   {
   }

   TypeDec(TypeDec const& typDec) = default;
   TypeDec& operator= (TypeDec const& typDec) = default;

   TypeDec(TypeDec&& typDec) noexcept = default;
   TypeDec& operator= (TypeDec&& typDec) = default;

   [[nodiscard]]
   virtual unique_ptr<TypeDec> clone() const
   {
     return make_unique<TypeDec>(*this);
   }
 };

 struct TypedefDec : public TypeDec
 {
   std::string destName;
 };

 struct SymColorInfo
 {
   posInFile rangeBegin;
   posInFile rangeEnd;

   using RGBColor = std::tuple<double, double, double>;
   using RGBAColor = std::tuple<double, double, double, double>;
   void setLastArgPos(posInFile lastArgPos) { lastArgPosition = std::move(lastArgPos); }

   SymColorInfo() = default;
   virtual ~SymColorInfo() = default;
   SymColorInfo(SymColorInfo const& col) = default;
   SymColorInfo& operator=(SymColorInfo const& col) = default;

   SymColorInfo(SymColorInfo&& col) noexcept = default;
   SymColorInfo& operator=(SymColorInfo&& col) noexcept = default;



   [[nodiscard]]
   virtual RGBColor getRGBColor() const = 0;

   [[nodiscard]]
   virtual double getAlpha() const
   {
     return 1;
   }

   [[nodiscard]]
   RGBAColor getRGBAColor() const
   {
     RGBColor c=getRGBColor();
     auto const& red=std::get<0>(c);
     auto const& green=std::get<1>(c);
     auto const& blue=std::get<2>(c);
     return RGBAColor(red,green,blue,getAlpha());
   }

   explicit operator TextDocument::Color() const
   {
     TextDocument::Color col;
     RGBAColor c=getRGBAColor();
     col.red=std::get<0>(c);
     col.green=std::get<1>(c);
     col.blue=std::get<2>(c);
     col.alpha=std::get<3>(c);
     return col;
   }

   [[nodiscard]]
   virtual unique_ptr<SymColorInfo> clone() const = 0;

 public:
   posInFile lastArgPosition;
 };

 struct RGBSymColorInfo : SymColorInfo
 {
   double red, green, blue;

   RGBSymColorInfo(): SymColorInfo(), red(0), green(0), blue(0) {}
   RGBSymColorInfo(double redVal, double greenVal, double blueVal):
     SymColorInfo(),
     red(redVal), green(greenVal), blue(blueVal)
   {
   }

   RGBSymColorInfo(RGBSymColorInfo const& col) = default;
   RGBSymColorInfo& operator=(RGBSymColorInfo const& col) = default;

   [[nodiscard]]
   RGBColor getRGBColor() const override
   {
     return RGBColor(red, green, blue);
   }

   [[nodiscard]]
   unique_ptr<SymColorInfo> clone() const override
   {
     return unique_ptr<SymColorInfo>(new RGBSymColorInfo(*this));
   }
 };

 struct RGBASymColorInfo : RGBSymColorInfo
 {
   double alpha;

   RGBASymColorInfo(): RGBSymColorInfo(), alpha(1) {}
   RGBASymColorInfo(double redVal, double greenVal, double blueVal, double alphaVal):
           RGBSymColorInfo(redVal, greenVal, blueVal), alpha(alphaVal)
   {
   }

   [[nodiscard]]
   double getAlpha() const override
   {
     return alpha;
   }

   [[nodiscard]]
   unique_ptr<SymColorInfo> clone() const override
   {
     return unique_ptr<SymColorInfo>(new RGBASymColorInfo(*this));
   }
 };

 struct StructDecs : public TypeDec
 {
   SymbolContext* ctx;

   StructDecs(): TypeDec(), ctx(nullptr) {}
   ~StructDecs() override = default;

   StructDecs(posInFile pos, std::string typName) :
           TypeDec(std::move(pos), std::move(typName)), ctx(nullptr)
   {
   }

   StructDecs(posInFile pos, std::string typName, SymbolContext* ctx) :
           TypeDec(std::move(pos), std::move(typName)), ctx(ctx)
   {
   }

   [[nodiscard]]
   unique_ptr<TypeDec> clone() const override
   {
     return std::unique_ptr<TypeDec>(new StructDecs(*this));
   }
 };

 struct SymbolMaps
 {
   unordered_map <std::string, SymbolInfo> varDec;
   unordered_map <std::string, std::vector<FunctionInfo>> funDec;
   // can refer to other files
   unordered_map <SymbolLit, positions> varUsage;
   unordered_map <std::string, unique_ptr<TypeDec>> typeDecs;

   // python equivalent of dict[str, list[tuple(pos, sym)]]
   // filename -> list[(position, symbol)]

   std::vector<std::pair<posInFile, SymbolLit>> usageByLines;

   SymbolMaps() = default;
   ~SymbolMaps() = default;

   SymbolMaps(SymbolMaps const& symMap) :
   varDec(symMap.varDec), funDec(symMap.funDec), varUsage(symMap.varUsage), typeDecs(),
   usageByLines(symMap.usageByLines)
   {
     for(auto const& t : symMap.typeDecs)
     {
       auto const& ty=std::get<0>(t);
       auto const& tyDec=std::get<1>(t);
       typeDecs.emplace(ty, tyDec != nullptr ? tyDec->clone() : nullptr);
     }
   }

   SymbolMaps& operator=(SymbolMaps const& symMap)
   {
     varDec = symMap.varDec;
     funDec = symMap.funDec;
     varUsage = symMap.varUsage;
     usageByLines = symMap.usageByLines;

     typeDecs.clear();
     for(auto const& t : symMap.typeDecs)
     {
       auto const& ty=std::get<0>(t);
       auto const& tyDec=std::get<1>(t);
       typeDecs.emplace(ty, tyDec != nullptr ? tyDec->clone() : nullptr);
     }
     return *this;
   }

   SymbolMaps(SymbolMaps&& symMap) noexcept:
           varDec(std::move(symMap.varDec)), funDec(std::move(symMap.funDec)), varUsage(std::move(symMap.varUsage)),
           typeDecs(std::move(symMap.typeDecs)), usageByLines(std::move(symMap.usageByLines))
   {
   }

   SymbolMaps& operator=(SymbolMaps&& symMap) noexcept
   {
     varDec = std::move(symMap.varDec);
     funDec = std::move(symMap.funDec);
     varUsage = std::move(symMap.varUsage);
     usageByLines = std::move(symMap.usageByLines);
     typeDecs = std::move(symMap.typeDecs);

     return *this;
   }

   inline void clear()
   {
     varDec.clear();
     funDec.clear();
     varUsage.clear();
     usageByLines.clear();
     typeDecs.clear();
   }
   optional<fullSymPosRangeInFile> searchSymbol(posInFile const& inputPos);
   FunctionInfo& addFunDef(std::string const& funcName, posInFile const& position, std::string const& returnType);

 private:
   friend ostream& operator<<(std::ostream& os, const SymbolMaps& sym);
 };

 struct ExternalRefs
 {

   // file interactions
   // access -> (file, id)
   // unravel -> id
   // include -> file
   // import = acccess + unravel

   using extRefMap = std::unordered_map<std::string, SymbolContext*>;
   extRefMap extFileRefs;
   std::unordered_map<std::string, std::string> fileIdPair;
   std::unordered_set<std::string> includeVals;
   std::unordered_set<std::string> unraveledVals;
   std::unordered_set<std::string> accessVals;
   std::unordered_map<std::string, std::pair<std::string, std::string>> fromAccessVals;

   ExternalRefs() = default;
   virtual ~ExternalRefs() = default;

   ExternalRefs(ExternalRefs const& exRef) = default;
   ExternalRefs& operator=(ExternalRefs const& exRef) = default;

//  ExternalRefs(ExternalRefs&& exRef) noexcept = default;
//  ExternalRefs& operator=(ExternalRefs&& exRef) noexcept = default;

   void clear()
   {
     extFileRefs.clear();
     fileIdPair.clear();
     includeVals.clear();
     unraveledVals.clear();
     accessVals.clear();
     fromAccessVals.clear();
   }

   bool addEmptyExtRef(std::string const& fileName)
   {
     auto success=std::get<1>(extFileRefs.emplace(fileName, nullptr));
     return success;
   }

   bool addAccessVal(std::string const& symbol)
   {
     auto success=std::get<1>(accessVals.emplace(symbol));
     return success;
   }

   bool addUnravelVal(std::string const& symbol)
   {
     auto success=std::get<1>(unraveledVals.emplace(symbol));
     return success;
   }

   bool addFromAccessVal(std::string const& fileName, std::string const& symbolSrc, std::string const& symbolDest)
   {
     auto success=std::get<1>(fromAccessVals.emplace(symbolDest, make_pair(symbolSrc, fileName)));
     return success;
   }
 };


 struct SymbolContext
 {
   optional<std::string> fileLoc;
   posInFile contextLoc;
   SymbolContext* parent;
   SymbolMaps symMap;

   // file interactions
   // access -> (file, id)
   // unravel -> id
   // include -> file
   // import = acccess + unravel

   ExternalRefs extRefs;

   std::vector<std::unique_ptr<SymColorInfo>> colorInformation;
   std::vector<std::unique_ptr<SymbolContext>> subContexts;

   SymbolContext():
     parent(nullptr)
   {
   }

   virtual ~SymbolContext() = default;

   explicit SymbolContext(posInFile loc);
   explicit SymbolContext(posInFile loc, std::string filename);

   SymbolContext(posInFile loc, SymbolContext* contextParent):
     fileLoc(nullopt), contextLoc(std::move(loc)), parent(contextParent)
   {
   }

   template<typename T=SymbolContext, typename=std::enable_if<std::is_base_of<SymbolContext, T>::value>>
   T* newContext(posInFile const& loc)
   {
     subContexts.emplace_back(make_unique<T>(loc, this));
     return static_cast<T*>(subContexts.back().get());
   }

   template<typename T=TypeDec, typename=std::enable_if<std::is_base_of<TypeDec, T>::value>>
   T* newTypeDec(std::string const& tyName, posInFile const& loc)
   {
     auto s=symMap.typeDecs.emplace(tyName, make_unique<T>(loc, tyName));
     auto it=std::get<0>(s);
     auto succ=std::get<1>(s);
     return succ ? static_cast<T*>(it->second.get()) : static_cast<T*>(nullptr);
   }

   SymbolContext(SymbolContext const& symCtx) :
     fileLoc(symCtx.fileLoc), contextLoc(symCtx.contextLoc),
     parent(symCtx.parent), symMap(symCtx.symMap),
     extRefs(symCtx.extRefs)
   {
     for (auto& ctx : symCtx.subContexts)
     {
       subContexts.push_back(make_unique<SymbolContext>(*ctx));
     }

     for (auto& col : symCtx.colorInformation)
     {
       colorInformation.emplace_back(col != nullptr ? col->clone() : nullptr);
     }
   }

   SymbolContext& operator= (SymbolContext const& symCtx)
   {
     fileLoc = symCtx.fileLoc;
     contextLoc = symCtx.contextLoc;
     parent = symCtx.parent;
     symMap = symCtx.symMap;
     extRefs = symCtx.extRefs;

     subContexts.clear();
     for (auto& ctx : symCtx.subContexts)
     {
       subContexts.push_back(make_unique<SymbolContext>(*ctx));
     }

     colorInformation.clear();
     for (auto& col : symCtx.colorInformation)
     {
       colorInformation.emplace_back(col != nullptr ? col->clone() : nullptr);
     }

     return *this;
   }

   SymbolContext(SymbolContext&& symCtx) noexcept :
           fileLoc(std::move(symCtx.fileLoc)), contextLoc(std::move(symCtx.contextLoc)),
           parent(symCtx.parent), symMap(std::move(symCtx.symMap)),
           extRefs(std::move(symCtx.extRefs)),
           colorInformation(std::move(symCtx.colorInformation)), subContexts(std::move(symCtx.subContexts))
   {
   }

   SymbolContext& operator= (SymbolContext&& symCtx) noexcept
   {
     fileLoc = std::move(symCtx.fileLoc);
     contextLoc = std::move(symCtx.contextLoc);
     parent = symCtx.parent;
     symMap = std::move(symCtx.symMap);
     extRefs = std::move(symCtx.extRefs);
     colorInformation = std::move(symCtx.colorInformation);
     subContexts = std::move(symCtx.subContexts);
     return *this;
   }

   // [file, start, end]
   virtual std::pair<optional<fullSymPosRangeInFile>, SymbolContext*> searchSymbol(posInFile const& inputPos);



   // declarations
   optional<posRangeInFile> searchVarDecl(std::string const& symbol)
   {
     return searchVarDecl(symbol, nullopt);
   }
   virtual optional<posRangeInFile> searchVarDecl(std::string const& symbol,
                                                  optional<posInFile> const& position);
   virtual optional<posRangeInFile> searchVarDeclFull(std::string const& symbol,
                                                      optional<posInFile> const& position=nullopt);
   virtual SymbolInfo const* searchVarRaw(std::string const& symbol) const;

   std::list<posRangeInFile> searchFuncDecls(std::string const& symbol);
   virtual std::list<posRangeInFile> searchFuncDecls(
           std::string const& symbol, optional<posInFile> const& position);
   std::list<posRangeInFile> searchFuncDeclsFull(std::string const& symbol,
                                               optional<posInFile> const& position=nullopt);

   // variable signatures
   optional<std::string> searchVarSignatureFull(std::string const& symbol);
   virtual std::list<std::string> searchFuncSignature(std::string const& symbol);
   virtual std::list<std::string> searchFuncSignatureFull(std::string const& symbol);

   optional<std::string> searchLitSignature(SymbolLit const& symbol);
   std::list<std::string> searchLitFuncSignature(SymbolLit const& symbol);

   optional<posRangeInFile> searchLitPosition(
           SymbolLit const& symbol, optional<posInFile> const& position=nullopt);
   std::list<posRangeInFile> searchLitFuncPositions(
           SymbolLit const& symbol, optional<posInFile> const& position=nullopt);

   virtual std::list<ExternalRefs::extRefMap::iterator> getEmptyRefs();

   optional<std::string> getFileName() const;

   SymbolContext* getParent()
   {
     return parent == nullptr ? this : parent->getParent();
   }

   bool addEmptyExtRef(std::string const& fileName)
   {
     return extRefs.addEmptyExtRef(fileName);
   }

   void reset(std::string const& newFile)
   {
     fileLoc = newFile;
     contextLoc = std::make_pair(1,1);
     clear();
   }

   void clear()
   {
     parent = nullptr;
     symMap.clear();
     extRefs.clear();
     clearColorInformation();
     subContexts.clear();
   }

   void clearColorInformation()
   {
     colorInformation.clear();
   }


   void addRGBColor(
           std::tuple<double, double, double> const& c,
           posInFile const& posBegin,
           posInFile const& lastArgs)
   {
     auto const& red=std::get<0>(c);
     auto const& green=std::get<1>(c);
     auto const& blue=std::get<2>(c);
     colorInformation.emplace_back(make_unique<RGBSymColorInfo>(red,green,blue));
     auto const& ptr=colorInformation.back();
     ptr->rangeBegin = posBegin;
     ptr->setLastArgPos(lastArgs);
   }

   void addRGBAColor(
           std::tuple<double, double, double, double> const& c,
           posInFile const& posBegin,
           posInFile const& lastArgs)
   {
     auto const& red=std::get<0>(c);
     auto const& green=std::get<1>(c);
     auto const& blue=std::get<2>(c);
     auto const& alpha=std::get<3>(c);
     colorInformation.emplace_back(make_unique<RGBASymColorInfo>(red,green,blue,alpha));
     auto const& ptr=colorInformation.back();
     ptr->rangeBegin = posBegin;
     ptr->setLastArgPos(lastArgs);
   }

 protected:
   using SymCtxSet = std::unordered_set<SymbolContext*>;

   // search var full

   template<
           typename TArg,
           template<typename...> class TMapTraverse=std::unordered_map,
           template<typename...> class TContainerArg=std::unordered_set
   >
   using SymbolArgContainer = TMapTraverse<std::string, TContainerArg<TArg>>;

   template<
           typename TArg,
           template<typename...> class TMapTraverse=std::unordered_map,
           template<typename...> class TContainerArg=std::unordered_set,
           template<typename...> class TArgContainer=std::unordered_set
   >
   using FnCreateSymbolArgContainer =
   std::function<SymbolArgContainer<TArg, TMapTraverse, TContainerArg>(SymbolContext*, TArgContainer<TArg> const&)>;

   template<typename TArg>
   SymbolArgContainer<TArg> defaultCreateTraverse(std::unordered_set<TArg> const& searchSet)
   {
     SymbolArgContainer<TArg> retVal;
     for (auto const& traverseVal : createTraverseSet())
     {
       retVal.emplace(traverseVal, searchSet);
     }
     return retVal;
   }

   SymbolArgContainer<std::string> fromDeclCreateTraverse(std::unordered_set<std::string> const& symbols)
   {
     // base
     SymbolArgContainer<std::string> base=defaultCreateTraverse(symbols);

     for (auto const& sym : symbols)
     {
       auto aliasSearch = extRefs.fromAccessVals.find(sym);
       if (aliasSearch != extRefs.fromAccessVals.end())
       {
         // there's an alias to dest -> [src, ctx].
         auto const& src=std::get<0>(aliasSearch->second);
         auto const& fileName=std::get<1>(aliasSearch->second);

         auto baseTrav = base.find(fileName);
         if (baseTrav == base.end())
         {
           base.emplace(fileName, std::unordered_set<std::string> { src });
         }
         else
         {
           baseTrav->second.emplace(src);
         }
       }
     }

     return base;
   }

   FnCreateSymbolArgContainer<std::string> const fnFromDeclCreateTrav =
           std::mem_fn(&SymbolContext::fromDeclCreateTraverse);

   template<typename TRet, typename TArg, typename TFn>
   optional<TRet> _searchVarFull(
           TArg init, TFn const& fnLocalPredicate,
           FnCreateSymbolArgContainer<TArg> const& fnCreateTraverse=
                   std::mem_fn(&SymbolContext::defaultCreateTraverse<TArg>))
   {
     std::unordered_set<SymbolContext*> searched;
     std::unordered_set<TArg> initSet { init };
     return _searchVarFull<TRet, TArg, TFn, TFn>(
             searched, initSet, fnLocalPredicate, fnLocalPredicate, fnCreateTraverse);
   }

   template<typename TRet, typename TArg, typename TFn, typename TFn2>
   optional<TRet> _searchVarFull(
           std::unordered_set<SymbolContext*>& searched,
           std::unordered_set<TArg> const& searchArgs,
           TFn const& fnLocalPredicate, TFn2 const& fnLocalPredicateFirst,
           FnCreateSymbolArgContainer<TArg> const& fnCreateTraverse)
   {
     auto p=searched.emplace(getParent());
     auto const& notSearched=std::get<1>(p);
     if (not notSearched)
     {
       // a loop in the search path. Stop now.
       return nullopt;
     }

     // local search first
     for (TArg const& arg : searchArgs)
     {
       optional<TRet> returnVal=fnLocalPredicateFirst(this, arg);
       if (returnVal.has_value())
       {
         return returnVal;
       }
     }

     return searchVarExt<TRet, TArg, TFn>(searched, searchArgs, fnLocalPredicate, fnCreateTraverse);
   }

   template<typename TRet, typename TArg, typename TFn>
   optional<TRet> searchVarExt(
           std::unordered_set<SymbolContext*>& searched,
           std::unordered_set<TArg> const& searchArgs,
           TFn const& fnLocalPredicate,
           FnCreateSymbolArgContainer<TArg> const& fnCreateTraverse)
   {
     using travType = std::pair<std::string, std::unordered_set<TArg>>;
     for (travType const travArg : fnCreateTraverse(this, searchArgs))
     {
       std::string const traverseVal = travArg.first;
       std::unordered_set<TArg> const argSet = travArg.second;
       if (traverseVal == getFileName())
       {
         continue;
       }

       if (SymbolContext* ref=getExternalRef(traverseVal))
       {
         optional<TRet> returnValF = ref->_searchVarFull<TRet, TArg, TFn, TFn>(
                 searched, argSet,
                 fnLocalPredicate, fnLocalPredicate,
                 fnCreateTraverse);
         if (returnValF.has_value())
         {
           return returnValF;
         }
       }
     }
     return nullopt;
   }

   // search all var full

   template<typename TRet, typename TArg, typename TFn>
   std::list<TRet> _searchAllVarFull(
           TArg init,
           TFn const& fnLocalPredicate,
           FnCreateSymbolArgContainer<TArg> const& fnCreateTraverse=
                   std::mem_fn(&SymbolContext::defaultCreateTraverse<TArg>))
   {
     std::unordered_set<SymbolContext*> searched;
     std::unordered_set<TArg> initSet { init };
     return _searchAllVarFull<TRet, TArg, TFn, TFn>(
             searched, initSet, fnLocalPredicate, fnLocalPredicate, fnCreateTraverse);
   }

   template<typename TRet, typename TArg, typename TFn, typename TFn2>
   std::list<TRet> _searchAllVarFull(
           std::unordered_set<SymbolContext*>& searched,
           std::unordered_set<TArg> const& searchArgs,
           TFn const& fnLocalPredicate, TFn2 const& fnLocalPredicateFirst,
           FnCreateSymbolArgContainer<TArg> const& fnCreateTraverse)
   {
     auto p=searched.emplace(getParent());
     auto const& notSearched=std::get<1>(p);
     if (not notSearched)
     {
       // a loop in the search path. Stop now.
       return std::list<TRet>();
     }

     std::list<TRet> returnVal;
     // local search first
     for (TArg const& arg : searchArgs)
     {
       returnVal.splice(returnVal.end(), fnLocalPredicateFirst(this, arg));
     }
     returnVal.splice(returnVal.end(), searchAllVarExt<TRet, TArg, TFn>(
             searched, searchArgs, fnLocalPredicate, fnCreateTraverse));
     return returnVal;
   }

   template<typename TRet, typename TArg, typename TFn>
   std::list<TRet> searchAllVarExt(
           std::unordered_set<SymbolContext*>& searched,
           std::unordered_set<TArg> const& searchArgs,
           TFn const& fnLocalPredicate,
           FnCreateSymbolArgContainer<TArg> const& fnCreateTraverse)
   {
     using travType = std::pair<std::string, std::unordered_set<TArg>>;
     std::list<TRet> finalList;
     for (travType const travArg : fnCreateTraverse(this, searchArgs))
     {
       std::string const traverseVal = travArg.first;
       std::unordered_set<TArg> const argSet = travArg.second;
       if (traverseVal == getFileName())
       {
         continue;
       }

       if (SymbolContext* ref=getExternalRef(traverseVal))
       {
         auto returnValF=ref->_searchAllVarFull<TRet, TArg, TFn, TFn>(
                 searched, argSet,
                 fnLocalPredicate, fnLocalPredicate,
                 fnCreateTraverse);

         finalList.splice(finalList.end(), std::move(returnValF));
       }
     }
     return finalList;
   }

   virtual optional<SymbolContext*> searchStructContext(std::string const& tyVal) const;
   SymbolContext* searchStructCtxFull(std::string const&);

   optional<SymbolContext*> searchAccessDecls(std::string const&);
   virtual std::pair<SymbolContext*, bool> searchLitContext(SymbolLit const& symbol);

   virtual std::unordered_set<std::string> createTraverseSet();

   virtual SymbolContext* getExternalRef(std::string const&);
   std::list<std::string> searchFuncUnravelStruct(std::string const& symbol);

   SymbolInfo* searchVarUnravelStructRaw(std::string const& symbol);
   SymbolInfo* searchVarUnravelStructRaw(std::string const& symbol, optional<posInFile> const& position);

   void addPlainFile();
 };

 struct AddDeclContexts: SymbolContext
 {
   unordered_map <std::string, SymbolInfo> additionalDecs;
   AddDeclContexts(): SymbolContext() {}

   explicit AddDeclContexts(posInFile loc):
     SymbolContext(loc) {}

   AddDeclContexts(posInFile loc, SymbolContext* contextParent):
     SymbolContext(loc, contextParent) {}

   ~AddDeclContexts() override = default;
   optional<posRangeInFile> searchVarDecl(std::string const& symbol, optional<posInFile> const& position) override;
   SymbolInfo const* searchVarRaw(std::string const& symbol) const override;
 };
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.