Leviathan::ObjectFileTemplateDefinition Class Reference

Class that represents a template definition. More...

#include <ObjectFile.h>

Public Member Functions
DLLEXPORT	ObjectFileTemplateDefinition (const std::string &name, std::vector< std::unique_ptr< std::string >> &parameters, std::shared_ptr< ObjectFileObject > obj)
	Creates a ObjectFileTemplateDefinition. More...
DLLEXPORT const std::string &	GetName () const
	Gets the name of this template. More...
DLLEXPORT std::unique_ptr< ObjectFileTemplateObject >	CreateInstanceFromThis (const ObjectFileTemplateInstance &instanceargs, LErrorReporter *reporterror=nullptr)
	Creates an instance from this template. More...
DLLEXPORT std::string	Serialize () const

Static Public Member Functions
static DLLEXPORT std::shared_ptr< ObjectFileTemplateDefinition >	CreateFromObject (const std::string &name, std::shared_ptr< ObjectFileObject > obj, std::vector< std::unique_ptr< std::string >> &templateargs)
	Creates a ObjectFileTemplateDefinition from an ObjectFileObject and a parameter list. More...

Protected Member Functions
void	ReplaceStringWithTemplateArguments (std::string &target, const std::vector< std::unique_ptr< std::string >> &args)
std::string	ReplaceStringTemplateArguments (const std::string &target, const std::vector< std::unique_ptr< std::string >> &args)

Protected Attributes
std::string	Name
	Name of this template. More...
std::vector< std::unique_ptr< std::string > >	Parameters
	Template parameter definitions. More...
std::shared_ptr< ObjectFileObject >	RepresentingObject
	The object from which the instances are created. More...

Detailed Description

Class that represents a template definition.

Todo:

Potentially allow changing the definition to update instantiations

Make this more robust and nice and reduce the bloat in the implementation

Definition at line 310 of file ObjectFile.h.

Constructor & Destructor Documentation

ObjectFileTemplateDefinition()

DLLEXPORT Leviathan::ObjectFileTemplateDefinition::ObjectFileTemplateDefinition	(	const std::string &	name,
		std::vector< std::unique_ptr< std::string >> &	parameters,
		std::shared_ptr< ObjectFileObject >	obj
	)

Creates a ObjectFileTemplateDefinition.

Warning

CreateFromObject might change in the future so please don't use this function directly

Definition at line 512 of file ObjectFile.cpp.

                                                                                    :
    Name(name), Parameters(move(parameters)), RepresentingObject(obj) {

}

Member Function Documentation

CreateFromObject()

DLLEXPORT std::shared_ptr< ObjectFileTemplateDefinition > Leviathan::ObjectFileTemplateDefinition::CreateFromObject ( const std::string &  name, std::shared_ptr< ObjectFileObject >  obj, std::vector< std::unique_ptr< std::string >> &  templateargs  )

static

Creates a ObjectFileTemplateDefinition from an ObjectFileObject and a parameter list.

Parameters

obj	The object from which to construct the template, the pointer will be deleted by this

Definition at line 523 of file ObjectFile.cpp.

                                                                                      {
    // This could be changed to a function that tears down the object and creates mess
    // of templating objects
    auto resultobj = make_shared<ObjectFileTemplateDefinition>(name, templateargs, obj);

    return resultobj;
}

CreateInstanceFromThis()

DLLEXPORT std::unique_ptr< Leviathan::ObjectFileTemplateObject > ObjectFileTemplateDefinition::CreateInstanceFromThis	(	const ObjectFileTemplateInstance &	instanceargs,
		LErrorReporter *	reporterror = nullptr
	)

Creates an instance from this template.

Todo:

Refactor this function to be smaller

Allow objects to use the special defined values in the ObjectFileProcessor

Definition at line 557 of file ObjectFile.cpp.

                                                                                   {
    // First make sure that template counts match, return NULL otherwise //
    if (Parameters.size() != instanceargs.Arguments.size()) {

        return NULL;
    }


    // Make sure these are not templated //
    std::string newname = RepresentingObject->GetName();
    std::string newtype = RepresentingObject->GetTypeName();

    std::vector<std::unique_ptr<std::string>> newprefixes;

    ReplaceStringWithTemplateArguments(newname, instanceargs.Arguments);


    ReplaceStringWithTemplateArguments(newtype, instanceargs.Arguments);

    for (size_t i = 0; i < RepresentingObject->GetPrefixesCount(); i++) {

        unique_ptr<std::string> newprefix(new std::string(RepresentingObject->GetPrefix(i)));

        ReplaceStringWithTemplateArguments(*newprefix, instanceargs.Arguments);

        newprefixes.push_back(std::move(newprefix));
    }


    // We somehow need to detect all places that might have the template parameters and
    // change them
    unique_ptr<ObjectFileTemplateObject> internalobj(new ObjectFileTemplateObject(newname,
        newtype, std::move(newprefixes)));

    // Do the contents the same way //
    for (size_t i = 0; i < RepresentingObject->GetListCount(); i++) {

        // Copy the data from the list replacing all the templates with values //
        ObjectFileList* curlist = RepresentingObject->GetList(i);

        std::string actlistname = curlist->GetName();

        ReplaceStringWithTemplateArguments(actlistname, instanceargs.Arguments);

        unique_ptr<ObjectFileList> listobj(new ObjectFileListProper(actlistname));

        const std::vector<shared_ptr<NamedVariableList>>& vallist =
            *curlist->GetVariables().GetVec();

        // Add the values replacing template arguments //
        for (size_t a = 0; a < vallist.size(); a++) {

            // First check the name //
            std::string newvarlistname = vallist[a]->GetName();

            ReplaceStringWithTemplateArguments(newvarlistname, instanceargs.Arguments);

            vector<VariableBlock*> newvaluesforthing;
            newvaluesforthing.reserve(vallist[a]->GetVariableCount());

            // Try to replace values that are strings //
            for (size_t b = 0; b < vallist[a]->GetVariableCount(); b++) {

                VariableBlock* processblock = vallist[a]->GetValueDirect(b);

                auto typval = processblock->GetBlock()->Type;

                // Non-string types don't need replacing //
                if (typval != DATABLOCK_TYPE_STRING && typval != DATABLOCK_TYPE_WSTRING) {

                    newvaluesforthing.push_back(new
                        VariableBlock(processblock->GetBlock()->AllocateNewFromThis()));

                } else {

                    // Try replacing stuff //
                    std::string valstring;

                    if (!processblock->ConvertAndAssingToVariable<std::string>(valstring)) {

                        DEBUG_BREAK;
                    }

                    // Try to replace //
                    ReplaceStringWithTemplateArguments(valstring, instanceargs.Arguments);

                    // Parse the result into a variable block //
                    try {

                        unique_ptr<VariableBlock> tmpblock(new VariableBlock(valstring, NULL));

                        newvaluesforthing.push_back(tmpblock.release());

                    }
                    catch (const InvalidArgument &e) {

                        if (reporterror) {

                            reporterror->Warning("ObjectFileTemplates: a templated list has an "
                                "invalid value to parse, using empty string instead:");
                            e.Print(reporterror);
                        }

                        newvaluesforthing.push_back(new VariableBlock(new StringBlock(
                            new std::string())));
                        continue;
                    }
                }
            }

            // Add the variable list //
            listobj->AddVariable(shared_ptr<NamedVariableList>(new
                NamedVariableList(newvarlistname, newvaluesforthing)));
        }

        // Add the list to the new object //
        internalobj->AddVariableList(std::move(listobj));

    }

    // Process the text blocks //
    for (size_t i = 0; i < RepresentingObject->GetTextBlockCount(); i++) {

        // Copy the data from the list replacing all the templates with values //
        ObjectFileTextBlock* curblock = RepresentingObject->GetTextBlock(i);

        std::string actblockname = curblock->GetName();

        ReplaceStringWithTemplateArguments(actblockname, instanceargs.Arguments);

        unique_ptr<ObjectFileTextBlock> textblock(new ObjectFileTextBlockProper(actblockname));

        // Replace all the lines //


        for (size_t a = 0; a < curblock->GetLineCount(); a++) {

            std::string curline = curblock->GetLine(a);

            ReplaceStringWithTemplateArguments(curline, instanceargs.Arguments);

            textblock->AddTextLine(curline);
        }

        // Add to the object //
        internalobj->AddTextBlock(std::move(textblock));
    }

    // Process the script source //


    // Only the first segment should be used //
#ifdef LEVIATHAN_USING_ANGELSCRIPT
    auto scrptwrap = RepresentingObject->GetScript();
    if (scrptwrap) {

        auto scrptmodule = scrptwrap->GetModuleSafe();

        if (scrptmodule && scrptmodule->GetScriptSegmentCount() > 0) {

            // We can try to specialize the code //
            auto onlysegment = scrptmodule->GetScriptSegment(0);

            const string& resultingsource = *onlysegment->SourceCode;

            const string& newsource = ReplaceStringTemplateArguments(resultingsource,
                instanceargs.Arguments);

            std::string newname = scrptmodule->GetName();

            ReplaceStringWithTemplateArguments(newname, instanceargs.Arguments);

            shared_ptr<ScriptScript> newscript(new
                ScriptScript(ScriptExecutor::Get()->CreateNewModule(newname,
                    scrptmodule->GetSource())));

            // Add the new script to the object //
            shared_ptr<ScriptSourceFileData> newsourcesegment(new
                ScriptSourceFileData(onlysegment->SourceFile, onlysegment->StartLine, newsource));

            auto newmod = newscript->GetModuleSafe();

            newmod->AddScriptSegment(newsourcesegment);
            newmod->SetBuildState(SCRIPTBUILDSTATE_READYTOBUILD);

            internalobj->AddScriptScript(newscript);
        }
    }
#endif // LEVIATHAN_USING_ANGELSCRIPT

    // Return the object //
    return internalobj;
}

GetName()

DLLEXPORT const string & Leviathan::ObjectFileTemplateDefinition::GetName

(

)

const

Gets the name of this template.

Definition at line 518 of file ObjectFile.cpp.

                                                                             {
    return Name;
}

ReplaceStringTemplateArguments()

std::string Leviathan::ObjectFileTemplateDefinition::ReplaceStringTemplateArguments ( const std::string &  target, const std::vector< std::unique_ptr< std::string >> &  args  )

protected

Definition at line 764 of file ObjectFile.cpp.

                                                                     {

    LEVIATHAN_ASSERT(Parameters.size() == args.size(), "ReplaceStringTemplateArguments arguments size mismatch");

    string result;

    if (Parameters.size() == 0)
        return target;

    result = StringOperations::Replace<string>(target, *Parameters[0], *args[0]);

    // Look for strings matching our parameters //
    for (size_t i = 1; i < Parameters.size(); i++) {

        result = StringOperations::Replace<string>(result, *Parameters[i], *args[i]);
    }

    return result;
}

ReplaceStringWithTemplateArguments()

void Leviathan::ObjectFileTemplateDefinition::ReplaceStringWithTemplateArguments ( std::string &  target, const std::vector< std::unique_ptr< std::string >> &  args  )

protected

Definition at line 752 of file ObjectFile.cpp.

                                                                        {
    
    LEVIATHAN_ASSERT(Parameters.size() == args.size(), "ReplaceStringWithTemplateArguments arguments size mismatch");

    // Look for strings matching our parameters //
    for (size_t i = 0; i < Parameters.size(); i++) {

        target = StringOperations::Replace<std::string>(target, *Parameters[i], *args[i]);
    }
}

Serialize()

DLLEXPORT std::string Leviathan::ObjectFileTemplateDefinition::Serialize

(

)

const

Returns

A string representation of this object

Definition at line 532 of file ObjectFile.cpp.

                                                                           {

    std::string result = "template<";

    bool first = true;

    // Parameter names for the template //
    for (const auto& paramstr : Parameters) {

        if (!first)
            result += ", ";

        result += *paramstr;
        first = false;
    }

    result += "> " + Name + ": \n";

    // The object associated with the template //
    result += RepresentingObject->Serialize(4);

    return result;

}

Member Data Documentation

Name

std::string Leviathan::ObjectFileTemplateDefinition::Name

protected

Name of this template.

Definition at line 350 of file ObjectFile.h.

Parameters

std::vector<std::unique_ptr<std::string> > Leviathan::ObjectFileTemplateDefinition::Parameters

protected

Template parameter definitions.

Definition at line 353 of file ObjectFile.h.

RepresentingObject

std::shared_ptr<ObjectFileObject> Leviathan::ObjectFileTemplateDefinition::RepresentingObject

protected

The object from which the instances are created.

Definition at line 356 of file ObjectFile.h.

---

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

• ObjectFile.h
• ObjectFile.cpp