samchon::protocol::IHTMLEntity Class Reference

An interface supporting conversion to html. More...

#include <IHTMLEntity.hpp>

Public Member Functions
	IHTMLEntity ()
	Default Constructor. More...
virtual auto	toHTML () const -> std::string=0
	Get an html string represents the Entity. More...

Static Public Member Functions
template<typename T , typename... _Args>
static auto	toTH (const T &val, const _Args &...args) -> std::string
	Get a string represents a <th> tag. More...
template<typename T , typename... _Args>
static auto	toTR (const T &val, const _Args &...args) -> std::string
	Get a string represents a <tr> tag. More...

Detailed Description

An interface supporting conversion to html.

IHTMEntity is an interface supporting conversion method to html tags. The IHTMLEntity is used to documentation or printing data of the entity to web-screen; In C++, documentation is main reason to implementing the IHTMLEntity and in JS, printing on web-screen is main reason.

IHTMLEntity provides abstract method toHTML() and varadic template methods for constituting a table. I'm planning to support lots of utility methods for html tags but I've not exprienced developing the homepage or html service. If you're familiar with the html, please contribute to the IHTMLEntity interface.

Example source

#include <iostream>

#include <samchon/protocol/Entity.hpp>
#include <samchon/protocol/IHTMLEntity.hpp>
#include <samchon/protocol/SharedEntityArray.hpp>

#include <samchon/library/XML.hpp>

#ifdef _WIN64
#   ifdef _DEBUG
#       pragma comment(lib, "x64/Debug/SamchonFramework.lib")
#   else
#       pragma comment(lib, "x64/Release/SamchonFramework.lib")
#   endif
#else
#   ifdef _DEBUG
#       pragma comment(lib, "Debug/SamchonFramework.lib")
#   else
#       pragma comment(lib, "Release/SamchonFramework.lib")
#   endif
#endif

using namespace std;
using namespace samchon::library;
using namespace samchon::protocol;

class Member 
    : public Entity, public virtual IHTMLEntity
{
protected:
    typedef Entity super;

    string id;
    string name;
    int age;
    int grade;

public:
    /* ---------------------------------------------------------------------
        CONSTRUCTORS
    --------------------------------------------------------------------- */
    Member() 
        : super(), IHTMLEntity()
    {
    };
    Member(const string &id, const string &name, int age, int grade)
        : super(), IHTMLEntity()
    {
        this->id = id;
        this->name = name;
        this->age = age;
        this->grade = grade;
    };
    virtual ~Member() = default;

    virtual void construct(shared_ptr<XML> xml) override
    {
        this->id = xml->getProperty("id");
        this->name = xml->getProperty("name");
        this->age = xml->getProperty<int>("age");
        this->grade = xml->getProperty<int>("grade");
    };

    /* ---------------------------------------------------------------------
        GETTERSs
    --------------------------------------------------------------------- */
    virtual auto key() const -> std::string override
    {
        return this->id;
    };

    /* ---------------------------------------------------------------------
        XML EXPORTERS
    --------------------------------------------------------------------- */
    virtual auto TAG() const -> string override
    {
        return "member";
    };
    virtual auto toXML() const -> shared_ptr<XML>
    {
        shared_ptr<XML> &xml = super::toXML();
        xml->setProperty("id", id);
        xml->setProperty("name", name);
        xml->setProperty("age", age);
        xml->setProperty("grade", grade);
        
        return move(xml);
    };
    virtual auto toHTML() const -> string
    {
        return toTR(id, name, age, grade);
    };
};

class MemberArray
    : public SharedEntityArray<Member>,
    public virtual IHTMLEntity
{
protected:
    typedef SharedEntityArray<Member> super;

    string application;
    int department;
    Member *chief;

public:
    /* ---------------------------------------------------------------------
        CONSTRUCTORS
    --------------------------------------------------------------------- */
    MemberArray()
        : super(), IHTMLEntity()
    {
        this->chief = nullptr;
    };
    virtual ~MemberArray() = default;

    // You don't need to consider children(Member) objects
    // Just concentrate on constructing MemberArray's own member variables
    virtual void construct(shared_ptr<XML> xml) override
    {
        super::construct(xml);

        this->application = xml->getProperty("application");
        this->department = xml->getProperty<int>("department");

        if(xml->hasProperty("chief") == true && this->has( xml->getProperty("chief") ) == true)
            this->chief = this->get( xml->getProperty("cheif") ).get();
    };

protected:
    //FACTORY METHOD FOR MEMBER
    virtual auto createChild(shared_ptr<XML> = nullptr) -> Member* override
    {
        return new Member();
    };

    /* ---------------------------------------------------------------------
        XML EXPORTERS
    --------------------------------------------------------------------- */
public:
    virtual auto TAG() const -> string override
    {
        return "memberArray";
    };
    virtual auto CHILD_TAG() const -> string override
    {
        return "member";
    };

    // You don't need to consider children(Member) objects
    // Just concentrate on expressing MemberArray's own member variables
    virtual auto toXML() const -> shared_ptr<XML>
    {
        shared_ptr<XML> &xml = super::toXML();
        xml->setProperty("application", application);
        xml->setProperty("department", department);
        
        if(chief != nullptr)
            xml->setProperty("cheif", chief->key());

        return move(xml);
    };
    virtual auto toHTML() const -> string
    {
        string html = "<table>\n";
        html += toTH("ID", "Name", "Age", "Grade") + "\n";

        for (size_t i = 0; i < 2; i++)
            html += at(i)->toHTML() + "\n";

        html += "</table>";
        return move(html);
    };
};

void main()
{
    string str = string("") +
        "<memberArray application='framework' department='7' cheif='samchon'>\n" +
        "   <member id='samchon' name='Jeongho Nam' age='27' grade='5' />" +
        "   <member id='submaster' name='No Name' age='100' grade='4' />" +
        "   <member id='john' name='John Doe' age='33' grade='2' />" +
        "   <member id='bad_man' name='Bad Man' age='44' grade='-1' />" +
        "   <member id='guest' name='Guest' age='0' grade='0' />" +
        "</memberArray>";
    shared_ptr<XML> xml(new XML(str));

    MemberArray memberArray;
    memberArray.construct(xml);

    memberArray.emplace_back(new Member("freshman", "A fresh man", 20, 2));
    memberArray.emplace_back(new Member("senior", "A senior", 70, 2));

    cout << memberArray.toXML()->toString() << endl << endl;
    cout << memberArray.toHTML() << endl;
    system("pause");
}

Result of the example

Author

Jeongho Nam http://samchon.org

Definition at line 41 of file IHTMLEntity.hpp.

Constructor & Destructor Documentation

IHTMLEntity::IHTMLEntity

(

)

Default Constructor.

Definition at line 9 of file IHTMLEntity.cpp.

References samchon::WeakString::str().

Here is the call graph for this function:

Member Function Documentation

template<typename T , typename... _Args>

static auto samchon::protocol::IHTMLEntity::toTH ( const T &  val, const _Args &...  args  ) -> std::string

inlinestatic

Get a string represents a <th> tag.

Template Parameters

_Ty	Type of an argument to be contained with a <td> tag.
_Args	Left varadic template arguments' type

Returns a string represents a title columns with <th> tag by varadic template method.

Supported parameters: that can converted to string

• number
  • (unsigned) short
  • (unsigned) long
  • (unsigned) long long
  • (unsigned) int
  • float
  • double
  • long double
• string
  • std::string
  • WeakString

Parameters

val	An element to be contained with <td> a tag.
args	Left argument to be contained with <td> tags.

Returns

A string of <th> tag represents title columns.

Definition at line 89 of file IHTMLEntity.hpp.

template<typename T , typename... _Args>

static auto samchon::protocol::IHTMLEntity::toTR ( const T &  val, const _Args &...  args  ) -> std::string

inlinestatic

Get a string represents a <tr> tag.

Template Parameters

_Ty	Type of an argument to be contained with a <tr> tag.
_Args	Left varadic template arguments' type

Returns a string represents a data columns of a row with <tr> tag by varadic template method.

Supported parameters: that can converted to string

• number
  • (unsigned) short
  • (unsigned) long
  • (unsigned) long long
  • (unsigned) int
  • float
  • double
  • long double
• string
  • std::string
  • WeakString

Parameters

val	An element to be contained with <tr> a tag.
args	Left argument to be contained with <tr> tags.

Returns

A string of <th> tag represents data columns of a row.

Definition at line 142 of file IHTMLEntity.hpp.

virtual auto samchon::protocol::IHTMLEntity::toHTML ( ) const -> std::string

pure virtual

Get an html string represents the Entity.

Returns

A string represents the Entity by html tags.

---

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

• D:/OneDrive/Project/Samchon/framework/cpp/samchon/protocol/IHTMLEntity.hpp
• D:/OneDrive/Project/Samchon/framework/cpp/samchon/protocol/IHTMLEntity.cpp