Leviathan::ScriptModule Class Reference

#include <ScriptModule.h>

Inheritance diagram for Leviathan::ScriptModule:

Public Member Functions
DLLEXPORT	ScriptModule (asIScriptEngine *engine, const std::string &name, int id, const std::string &source)
DLLEXPORT	~ScriptModule ()
DLLEXPORT void	SetAccessMask (AccessFlags access)
	Sets the access mask to be used for this script. More...
DLLEXPORT void	AddAccessRight (AccessFlags newaccess)
	Adds flags to the AccessMask. More...
DLLEXPORT asIScriptModule *	GetModule (Lock &guard)
	Builds the script if applicable. More...
DLLEXPORT asIScriptModule *	GetModule ()
DLLEXPORT std::shared_ptr< ScriptScript >	GetScriptInstance ()
DLLEXPORT std::string	GetName ()
DLLEXPORT void	Release ()
	Releases the internal resources. More...
DLLEXPORT const std::string &	GetModuleName () const
	Gets the name of the internal AngelScript module. More...
DLLEXPORT int	GetID ()
DLLEXPORT const std::string &	GetSource () const
DLLEXPORT const std::string &	GetIncompleteSourceCode ()
DLLEXPORT void	DeleteThisModule ()
DLLEXPORT bool	DoesListenersContainSpecificListener (const std::string &listenername, const std::string *generictype=NULL)
DLLEXPORT void	GetListOfListeners (std::vector< std::shared_ptr< ValidListenerData >> &receiver)
DLLEXPORT std::string	GetListeningFunctionName (const std::string &listenername, const std::string *generictype=NULL)
DLLEXPORT std::string	GetInfoString ()
DLLEXPORT void	SetBuildState (const SCRIPTBUILDSTATE &state)
DLLEXPORT size_t	GetScriptSegmentCount () const
	Gets the number of code segments. More...
DLLEXPORT std::shared_ptr< ScriptSourceFileData >	GetScriptSegment (size_t index) const
	Gets the data associated with a code segment. More...
DLLEXPORT FORCE_INLINE bool	AddScriptSegment (const std::string &file, int line, const std::string &code)
	Adds a new script section. More...
DLLEXPORT bool	AddScriptSegment (std::shared_ptr< ScriptSourceFileData > data)
	The actual implementation of AddScriptSegment. More...
DLLEXPORT bool	AddScriptSegmentFromFile (const std::string &file)
	Adds an entire file as a script segment. More...
DLLEXPORT bool	ReLoadModuleCode ()
	Rebuilds the module and tries to restore data. More...
DLLEXPORT void	SetAsInvalid ()
	Sets the module as invalid to avoid usage. More...
DLLEXPORT void	PrintFunctionsInModule ()
DLLEXPORT bool	OnAddedToBridge (std::shared_ptr< ScriptArgumentsProviderBridge > bridge)
	Call when this module is added to a bridge. More...
Public Member Functions inherited from Leviathan::ThreadSafeGeneric< MutexType >
DLLEXPORT	ThreadSafeGeneric ()
DLLEXPORT	~ThreadSafeGeneric ()
FORCE_INLINE void	VerifyLock (RecursiveLock &guard) const
FORCE_INLINE void	VerifyLock (Lock &lockit) const

Static Public Member Functions
static DLLEXPORT int	ScriptModuleIncludeCallback (const char *include, const char *from, CScriptBuilder *builder, void *userParam)
static DLLEXPORT std::string	ResolvePathToScriptFile (const std::string &inputfilename, const std::string &relativepath, bool checkworkdirrelative=true)
	Finds a path to source file or returns an empty string. More...

Static Public Attributes
static const std::map< std::string, int >	ListenerNameType

Additional Inherited Members
Protected Attributes inherited from Leviathan::ThreadSafeGeneric< MutexType >
MutexType	ObjectsLock

Detailed Description

Definition at line 87 of file ScriptModule.h.

Constructor & Destructor Documentation

ScriptModule()

ScriptModule::ScriptModule	(	asIScriptEngine *	engine,
		const std::string &	name,
		int	id,
		const std::string &	source
	)

Definition at line 15 of file ScriptModule.cpp.

                                                                                     :
    Name(name),
    Source(source), ID(id), ScriptBuilder(new CScriptBuilder())
{
    {
        Lock lock(ModuleBuildingMutex);
        ModuleName = std::string(source + "_;" + Convert::ToString<int>(LatestAssigned));
        LatestAssigned++;
    }

    // module will always be started //
    ScriptBuilder->StartNewModule(engine, ModuleName.c_str());

    // setup include resolver //
    ScriptBuilder->SetIncludeCallback(ScriptModuleIncludeCallback, this);

    // Apply the default mask //
    ScriptBuilder->GetModule()->SetAccessMask(AccessMask);

    ListenerDataBuilt = false;
}

~ScriptModule()

ScriptModule::~ScriptModule

(

)

Definition at line 38 of file ScriptModule.cpp.

{}

Member Function Documentation

AddAccessRight()

DLLEXPORT void Leviathan::ScriptModule::AddAccessRight ( AccessFlags  newaccess )

inline

Adds flags to the AccessMask.

See also

SetAccessMask

Definition at line 106 of file ScriptModule.h.

    {
        AccessMask |= newaccess;
    }

AddScriptSegment() [1/2]

DLLEXPORT FORCE_INLINE bool Leviathan::ScriptModule::AddScriptSegment ( const std::string &  file, int  line, const std::string &  code  )

inline

Adds a new script section.

Returns

True when the file is not included already (and it got added), false otherwise

Definition at line 184 of file ScriptModule.h.

    {
        return AddScriptSegment(std::make_shared<ScriptSourceFileData>(file, line, code));
    }

AddScriptSegment() [2/2]

DLLEXPORT bool Leviathan::ScriptModule::AddScriptSegment

(

std::shared_ptr< ScriptSourceFileData >

data

)

The actual implementation of AddScriptSegment.

Definition at line 416 of file ScriptModule.cpp.

{
    GUARD_LOCK();
    // Check is it already there //
    for(size_t i = 0; i < ScriptSourceSegments.size(); i++) {

        if(ScriptSourceSegments[i]->SourceFile == data->SourceFile &&
            (abs(ScriptSourceSegments[i]->StartLine - data->StartLine) <= 2)) {

            return false;
        }
    }

    ScriptSourceSegments.push_back(data);

    // Needs to be built next //
    ScriptState = SCRIPTBUILDSTATE_READYTOBUILD;
    return true;
}

AddScriptSegmentFromFile()

DLLEXPORT bool Leviathan::ScriptModule::AddScriptSegmentFromFile

(

const std::string &

file

)

Adds an entire file as a script segment.

Returns

True when the file is added, false if the file was already added

Definition at line 437 of file ScriptModule.cpp.

{
    GUARD_LOCK();

    std::string expanded;

    try {
        expanded = boost::filesystem::canonical(file).generic_string();
    } catch(const boost::filesystem::filesystem_error&) {
        // Doesn't exist //
        return false;
    }

    // Check is it already there //
    for(size_t i = 0; i < ScriptSourceSegments.size(); i++) {

        if(ScriptSourceSegments[i]->SourceFile == file) {

            return false;
        }
    }

    // Load the source code from the file //
    std::string scriptdata;
    FileSystem::ReadFileEntirely(expanded, scriptdata);

    ScriptSourceSegments.push_back(
        std::make_shared<ScriptSourceFileData>(expanded, 1, scriptdata));

    // Needs to be built next //
    ScriptState = SCRIPTBUILDSTATE_READYTOBUILD;
    return true;
}

DeleteThisModule()

DLLEXPORT void Leviathan::ScriptModule::DeleteThisModule

(

)

Definition at line 188 of file ScriptModule.cpp.

{

    // Tell script interface to unload this //
    ScriptExecutor::Get()->DeleteModule(this);
}

DoesListenersContainSpecificListener()

DLLEXPORT bool Leviathan::ScriptModule::DoesListenersContainSpecificListener	(	const std::string &	listenername,
		const std::string *	generictype = NULL
	)

Definition at line 131 of file ScriptModule.cpp.

{
    GUARD_LOCK();
    // find from the map //
    auto itr = _GetIteratorOfListener(guard, listenername, generictype);

    if(itr != FoundListenerFunctions.end()) {

        // it exists //
        return true;
    }
    // no matching listener //
    return false;
}

GetID()

DLLEXPORT int Leviathan::ScriptModule::GetID ( )

inline

Definition at line 136 of file ScriptModule.h.

    {
        return ID;
    }

GetIncompleteSourceCode()

DLLEXPORT const std::string& Leviathan::ScriptModule::GetIncompleteSourceCode ( )

inline

Definition at line 146 of file ScriptModule.h.

    {
        return ObjectFileLoadedScriptCode;
    }

GetInfoString()

DLLEXPORT std::string Leviathan::ScriptModule::GetInfoString

(

)

Definition at line 182 of file ScriptModule.cpp.

{

    return "ScriptModule(" + Convert::ToString(ID) + ") " + Name + ", from: " + Source;
}

GetListeningFunctionName()

DLLEXPORT std::string Leviathan::ScriptModule::GetListeningFunctionName	(	const std::string &	listenername,
		const std::string *	generictype = NULL
	)

Definition at line 164 of file ScriptModule.cpp.

{
    GUARD_LOCK();

    // Call search function and check if it found anything //
    auto itr = _GetIteratorOfListener(guard, listenername, generictype);


    if(itr != FoundListenerFunctions.end()) {
        // Get name from pointer //
        return std::string(itr->second->FuncPtr->GetName());
    }

    // Nothing found //
    return "";
}

GetListOfListeners()

DLLEXPORT void Leviathan::ScriptModule::GetListOfListeners

(

std::vector< std::shared_ptr< ValidListenerData >> &

receiver

)

Definition at line 147 of file ScriptModule.cpp.

{
    GUARD_LOCK();
    // build info if not built //
    if(!ListenerDataBuilt)
        _BuildListenerList(guard);
    // reserve space to be more efficient //
    receiver.reserve(FoundListenerFunctions.size());


    for(auto iter = FoundListenerFunctions.begin(); iter != FoundListenerFunctions.end();
        ++iter) {
        receiver.push_back(iter->second);
    }
}

GetModule() [1/2]

DLLEXPORT asIScriptModule * Leviathan::ScriptModule::GetModule

(

Lock &

guard

)

Builds the script if applicable.

Returns

The associated module or NULL if build fails

Definition at line 79 of file ScriptModule.cpp.

{

    // we need to check build state //
    if(ScriptState == SCRIPTBUILDSTATE_READYTOBUILD) {

        _BuildTheModule(guard);

#ifdef SCRIPTMODULE_LISTENFORFILECHANGES

        _StartMonitoringFiles(guard);

#endif // SCRIPTMODULE_LISTENFORFILECHANGES

        if(ScriptState != SCRIPTBUILDSTATE_BUILT) {

            return NULL;
        }

    } else if(ScriptState == SCRIPTBUILDSTATE_FAILED ||
              ScriptState == SCRIPTBUILDSTATE_DISCARDED) {

        return NULL;
    }

    // Return the saved pointer or fetch the pointer //
    if(!ASModule) {

        // Get module from the engine //
        ASModule = ScriptExecutor::Get()->GetASEngine()->GetModule(
            ModuleName.c_str(), asGM_ONLY_IF_EXISTS);

        if(!ASModule) {

            // The module is invalid //
            LOG_ERROR("ScriptModule: GetModule: module is no longer anywhere "
                      "to be found in the AS engine");

            ScriptState = SCRIPTBUILDSTATE_DISCARDED;
            return NULL;
        }
    }

    return ASModule;
}

GetModule() [2/2]

DLLEXPORT asIScriptModule* Leviathan::ScriptModule::GetModule ( )

inline

Definition at line 115 of file ScriptModule.h.

    {
        GUARD_LOCK();
        return GetModule(guard);
    }

GetModuleName()

DLLEXPORT const std::string & Leviathan::ScriptModule::GetModuleName

(

)

const

Gets the name of the internal AngelScript module.

Definition at line 471 of file ScriptModule.cpp.

{
    return ModuleName;
}

GetName()

DLLEXPORT std::string Leviathan::ScriptModule::GetName ( )

inline

Definition at line 124 of file ScriptModule.h.

    {
        return Name;
    }

GetScriptInstance()

DLLEXPORT std::shared_ptr< ScriptScript > Leviathan::ScriptModule::GetScriptInstance

(

)

Definition at line 125 of file ScriptModule.cpp.

{

    return std::make_shared<ScriptScript>(ID, ScriptExecutor::Get()->GetModule(ID));
}

GetScriptSegment()

DLLEXPORT std::shared_ptr< ScriptSourceFileData > Leviathan::ScriptModule::GetScriptSegment

(

size_t

index

)

const

Gets the data associated with a code segment.

Parameters

index

The index of the segment in the vector, use GetScriptSegmentCount to get max index

Returns

The segments data or NULL

Definition at line 407 of file ScriptModule.cpp.

{
    if(index >= ScriptSourceSegments.size())
        return NULL;

    return ScriptSourceSegments[index];
}

GetScriptSegmentCount()

DLLEXPORT size_t Leviathan::ScriptModule::GetScriptSegmentCount

(

)

const

Gets the number of code segments.

See also

GetScriptSegment

Definition at line 402 of file ScriptModule.cpp.

{
    return ScriptSourceSegments.size();
}

GetSource()

DLLEXPORT const std::string& Leviathan::ScriptModule::GetSource ( ) const

inline

Definition at line 141 of file ScriptModule.h.

    {
        return Source;
    }

OnAddedToBridge()

DLLEXPORT bool Leviathan::ScriptModule::OnAddedToBridge

(

std::shared_ptr< ScriptArgumentsProviderBridge >

bridge

)

Call when this module is added to a bridge.

Returns

True when this is not in a bridge and it is added, false if this is removed from the bridge

Definition at line 770 of file ScriptModule.cpp.

{
    LEVIATHAN_ASSERT(this == bridge->GetModule(), "OnAddedToBridge it's not ours!");

    if(ArgsBridge) {

        return false;
    }

    ArgsBridge = bridge;
    return true;
}

PrintFunctionsInModule()

DLLEXPORT void Leviathan::ScriptModule::PrintFunctionsInModule

(

)

Definition at line 348 of file ScriptModule.cpp.

{
    GUARD_LOCK();

    // list consoles' global variables //
    Logger::Get()->Info(Name + " instance functions: ");

    // List the user functions in the module
    asIScriptModule* mod = GetModule(guard);

    const asUINT FuncCount = mod->GetFunctionCount();

    for(asUINT n = 0; n < FuncCount; n++) {
        // get function //
        asIScriptFunction* func = mod->GetFunctionByIndex(n);
        // print the function //
        Logger::Get()->Write(
            std::string("> ") + func->GetName() + "(" + func->GetDeclaration() + ")");
    }

    Logger::Get()->Write("[END]");
}

Release()

DLLEXPORT void Leviathan::ScriptModule::Release

(

)

Releases the internal resources.

Definition at line 40 of file ScriptModule.cpp.

{
    GUARD_LOCK();

    // Leave from the bridge //
    if(ArgsBridge)
        ArgsBridge->LeaveModule();


#ifdef SCRIPTMODULE_LISTENFORFILECHANGES

    _StopFileMonitoring(guard);

#endif // SCRIPTMODULE_LISTENFORFILECHANGES

    // We'll need to destroy the module from the engine //
    ASModule = NULL;
    ScriptExecutor::Get()->GetASEngine()->DiscardModule(ModuleName.c_str());

    // And then delete the builder //
    SAFE_DELETE(ScriptBuilder);
    ListenerDataBuilt = false;
}

ReLoadModuleCode()

DLLEXPORT bool Leviathan::ScriptModule::ReLoadModuleCode

(

)

Rebuilds the module and tries to restore data.

Not all data can be restored (things changing types, application owned handles etc...)

Definition at line 483 of file ScriptModule.cpp.

{
    GUARD_LOCK();

    // The module must be still valid //
    if(ScriptState == SCRIPTBUILDSTATE_DISCARDED ||
        (!GetModule() && ScriptState != SCRIPTBUILDSTATE_FAILED))
        return false;


    Logger::Get()->Info("Reloading " + GetInfoString());

    if(ArgsBridge) {

        // Do a OnRelease event call //
        const std::string& listenername =
            CallableObject::GetListenerNameFromType(EVENT_TYPE_RELEASE);

        // check does the script contain right listeners //
        if(DoesListenersContainSpecificListener(listenername)) {

            // Get the parameters //
            auto sargs = ArgsBridge->GetProvider()->GetParametersForRelease();
            // sargs.Parameters need to be somehow translated to the new style
            DEBUG_BREAK;
            sargs->SetEntrypoint(GetListeningFunctionName(listenername));

            // Run the script //
            auto result = ScriptExecutor::Get()->RunScript<void>(shared_from_this(), *sargs);

            if(result.Result != SCRIPT_RUN_RESULT::Success) {

                LOG_ERROR("ScriptModule: failed to run auto release, skipping reload");
                return false;
            } else {

                Logger::Get()->Info("ScriptModule: ran auto release");
            }
        }
    }


    // Store the old values //
    // CSerializer backup;
    // backup.Store(ASModule);

    // Discard the old module //
    ASModule = NULL;
    if(GetModule())
        ScriptExecutor::Get()->GetASEngine()->DiscardModule(ModuleName.c_str());

    // The builder must be created again //
    SAFE_DELETE(ScriptBuilder);

    // Setup the new builder //
    ScriptBuilder = new CScriptBuilder();

    asIScriptEngine* engine = ScriptExecutor::Get()->GetASEngine();

    // Add 'R' to the module name to mark reload //
    ModuleName += "R";

    ScriptBuilder->StartNewModule(engine, ModuleName.c_str());
    ScriptBuilder->SetIncludeCallback(ScriptModuleIncludeCallback, this);
    ListenerDataBuilt = false;

    // Build the module //
    _BuildTheModule(guard);

    if(ScriptState != SCRIPTBUILDSTATE_BUILT || !GetModule()) {

        // Failed to build //
        return false;
    }

    // Restore the data //
    // backup.Restore(GetModule());

    // Logger::Get()->Info("Successfully restored "+GetInfoStd::String());

    if(ArgsBridge) {

        // Do a OnRelease event call //
        const std::string& listenername =
            CallableObject::GetListenerNameFromType(EVENT_TYPE_INIT);

        // check does the script contain right listeners //
        if(DoesListenersContainSpecificListener(listenername)) {

            // Get the parameters //
            auto sargs = ArgsBridge->GetProvider()->GetParametersForInit();
            // sargs.Parameters need to be somehow translated to the new style
            DEBUG_BREAK;
            sargs->SetEntrypoint(GetListeningFunctionName(listenername));


            // Run the script //
            auto result = ScriptExecutor::Get()->RunScript<void>(shared_from_this(), *sargs);

            if(result.Result != SCRIPT_RUN_RESULT::Success) {

                LOG_ERROR("ScriptModule: failed to run auto init after restore");
                // We don't want to signal failure as we have already overwritten our old stuff
            } else {

                Logger::Get()->Info("ScriptModule: ran auto init after restore");
            }
        }
    }

    // Succeeded //
    return true;
}

ResolvePathToScriptFile()

DLLEXPORT std::string ScriptModule::ResolvePathToScriptFile ( const std::string &  inputfilename, const std::string &  relativepath, bool  checkworkdirrelative = true  )

static

Finds a path to source file or returns an empty string.

Definition at line 784 of file ScriptModule.cpp.

{
    // The canonical calls here are probably not needed as the as
    // script builder makes all paths absolute

    // Check first relative, absolute, and then search //
    const auto asRelative = boost::filesystem::path(relativepath) / inputfilename;
    if(boost::filesystem::is_regular_file(asRelative)) {
        return boost::filesystem::canonical(asRelative).generic_string();

    } else if(checkworkdirrelative && boost::filesystem::is_regular_file(inputfilename)) {

        return boost::filesystem::canonical(inputfilename).generic_string();

    } else {

        // This returns an empty string for us //
        std::string searched = FileSystem::Get()->SearchForFile(FILEGROUP_SCRIPT,
            StringOperations::RemoveExtension<std::string>(inputfilename),
            StringOperations::GetExtension<std::string>(inputfilename), false);

        if(searched.empty())
            return searched;

        return boost::filesystem::canonical(searched).generic_string();
    }
}

ScriptModuleIncludeCallback()

DLLEXPORT int Leviathan::ScriptModule::ScriptModuleIncludeCallback ( const char *  include, const char *  from, CScriptBuilder *  builder, void *  userParam  )

static

Definition at line 371 of file ScriptModule.cpp.

{
    std::string file(include);
    std::string infile(from);

    ScriptModule* module = reinterpret_cast<ScriptModule*>(userParam);
    // The module has to be locked during this call

    // Resolve it to an usable path //
    const auto resolved = ResolvePathToScriptFile(file, infile);

    if(resolved.empty() || !boost::filesystem::exists(resolved)) {

        Logger::Get()->Error("ScriptModule: IncludeCallback: couldn't resolve include "
                             "(even with full search), file: " +
                             file + " included in: " + infile + ", while compiling " +
                             module->GetInfoString());

        // Including failed
        return -1;
    }

#ifdef SCRIPTMODULE_LISTENFORFILECHANGES

    module->_AddFileToMonitorIfNotAlready(resolved);
#endif // SCRIPTMODULE_LISTENFORFILECHANGES

    return builder->AddSectionFromFile(resolved.c_str());
}

SetAccessMask()

DLLEXPORT void Leviathan::ScriptModule::SetAccessMask ( AccessFlags  access )

inline

Sets the access mask to be used for this script.

This only takes effect before building the module

Definition at line 99 of file ScriptModule.h.

    {
        AccessMask = access;
    }

SetAsInvalid()

DLLEXPORT void Leviathan::ScriptModule::SetAsInvalid

(

)

Sets the module as invalid to avoid usage.

Definition at line 476 of file ScriptModule.cpp.

{
    GUARD_LOCK();

    ScriptState = SCRIPTBUILDSTATE_DISCARDED;
}

SetBuildState()

DLLEXPORT void Leviathan::ScriptModule::SetBuildState ( const SCRIPTBUILDSTATE &  state )

inline

Definition at line 165 of file ScriptModule.h.

    {
        ScriptState = state;
    }

Member Data Documentation

ListenerNameType

const std::map< std::string, int > Leviathan::ScriptModule::ListenerNameType

static

Initial value:

= {
    {LISTENERNAME_ONSHOW, LISTENERVALUE_ONSHOW}, {LISTENERNAME_ONHIDE, LISTENERVALUE_ONHIDE},
    {LISTENERNAME_ONLISTENUPDATE, LISTENERVALUE_ONSHOW},
    {LISTENERNAME_ONCLICK, LISTENERVALUE_ONCLICK},
    {LISTENERNAME_ONVALUECHANGE, LISTENERVALUE_ONVALUECHANGE},
    {LISTENERNAME_ONINIT, LISTENERVALUE_ONINIT},
    {LISTENERNAME_ONRELEASE, LISTENERVALUE_ONRELEASE},
    {LISTENERNAME_ONSUBMIT, LISTENERVALUE_ONSUBMIT},
    {LISTENERNAME_ONTICK, LISTENERVALUE_ONTICK},
    {LISTENERNAME_ONCLOSECLICKED, LISTENERVALUE_ONCLOSECLICKED},
    {LISTENERNAME_LISTSELECTIONACCEPTED, LISTENERVALUE_LISTSELECTIONACCEPTED}}

Definition at line 212 of file ScriptModule.h.

---

The documentation for this class was generated from the following files:

• ScriptModule.h
• ScriptModule.cpp