inotify_event_copy Class Reference

smart copy class for inotify_event. More...

Collaboration diagram for inotify_event_copy:

Public Member Functions
	inotify_event_copy (const inotify_event_wrapper *aEvent)
	~inotify_event_copy ()
clock_type::time_point	timeStamp () const
const inotify_event_wrapper *	getEvent () const

Static Public Member Functions
static void	doCopyLeftovers ()
static inotify_event_copy *	getStaleSingles ()
	get the next old inotify_event. More...
static void	forget (inotify_event_copy *what)
	deletes a copy. More...
static inotify_event_copy *	getPartner (const inotify_event_wrapper *event, clock_type::time_point then)
	get partner of a half rename event. More...

Protected Member Functions
void	doCopyIfNeeded ()
	make a real copy of this inotify_event. More...

Static Protected Member Functions
static std::map< uint32_t, inotify_event_copy > &	getRenameEvents ()
	return a map which contains the inotify_event_copys More...
static bool	cmp (const inotify_event_copy *lhs, const inotify_event_copy *rhs)
	function to order inotify_event_copys by time More...
static std::multiset< inotify_event_copy *, decltype(cmp) * > &	getSingleEvents ()
	return a multiset containing single inotify_event_copys ordered by time More...

Protected Attributes
std::remove_reference< decltype(getSingleEvents())>::type::iterator	singleEventIterator
	iterator into the multiset containing the single events More...
const inotify_event_wrapper *	event
	pointer to the event, either the original or a copy More...
clock_type::time_point	then
	the time the event was recorded More...
bool	isCopy
	true if it's a copy. We can't use singleEventIterator as this might be getSingleEvents().end() after erasing it. More...

Detailed Description

smart copy class for inotify_event.

This is needed only for matching the two halves of rename event pairs! This class holds a pointer to an inotify_event_wrapper. Normally this is in the current buffer returned by the last read() from the inotify object. If a rename-event pair is not completely inside one buffer a real copy has to be made and processing of the pair can then happen in the next buffer.

Definition at line 177 of file inotify_watch.cpp.

Constructor & Destructor Documentation

inotify_event_copy()

inotify_event_copy::inotify_event_copy ( const inotify_event_wrapper *  aEvent )

inline

Definition at line 211 of file inotify_watch.cpp.

                                                           :
        singleEventIterator(getSingleEvents().end()), event(aEvent), isCopy(false) {
    }

~inotify_event_copy()

inotify_event_copy::~inotify_event_copy ( )

inline

Definition at line 214 of file inotify_watch.cpp.

                          {
        if (isCopy) {
            free(reinterpret_cast<void*>(const_cast<inotify_event_wrapper*>(event)));
        }
    }

References event, and isCopy.

Member Function Documentation

cmp()

static bool inotify_event_copy::cmp ( const inotify_event_copy *  lhs, const inotify_event_copy *  rhs  )

inlinestaticprotected

function to order inotify_event_copys by time

Definition at line 185 of file inotify_watch.cpp.

                                                                                  {
        return lhs->then < rhs->then;
    }

References then.

Referenced by getSingleEvents().

Here is the caller graph for this function:

doCopyIfNeeded()

void inotify_event_copy::doCopyIfNeeded ( )

inlineprotected

make a real copy of this inotify_event.

Definition at line 199 of file inotify_watch.cpp.

                          {
        if (!isCopy) {
            auto theEvent = getEvent();
            void* newEvent = malloc(theEvent->size());
            memcpy(newEvent, theEvent, theEvent->size());
            event = reinterpret_cast<inotify_event_wrapper*>(newEvent);
            isCopy = true;
            singleEventIterator = getSingleEvents().emplace(this);
        }
    }

References getEvent(), getSingleEvents(), isCopy, and singleEventIterator.

Here is the call graph for this function:

doCopyLeftovers()

static void inotify_event_copy::doCopyLeftovers ( )

inlinestatic

Definition at line 226 of file inotify_watch.cpp.

                                  {
        for (auto& it : getRenameEvents()) {
            it.second.doCopyIfNeeded();
        }
    }

References getRenameEvents().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

forget()

static void inotify_event_copy::forget ( inotify_event_copy *  what )

inlinestatic

deletes a copy.

It will remove it from both the singles set as well as from the map, and call (indirectlly, through the erase in the map) the destructor. Is static with a parameter instead of a normal member, because that would destroy it's own this in the erase from the map.

Definition at line 254 of file inotify_watch.cpp.

                                                 {
        if (what->singleEventIterator != getSingleEvents().end()) {
            getSingleEvents().erase(what->singleEventIterator);
        }
 
        getRenameEvents().erase(what->getEvent()->cookie());
    }

References inotify_event_wrapper::cookie(), getEvent(), getRenameEvents(), getSingleEvents(), and singleEventIterator.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

getEvent()

const inotify_event_wrapper* inotify_event_copy::getEvent ( ) const

inline

Definition at line 222 of file inotify_watch.cpp.

                                                  {
        return event;
    }

References event.

Referenced by doCopyIfNeeded(), and forget().

Here is the caller graph for this function:

getPartner()

static inotify_event_copy* inotify_event_copy::getPartner ( const inotify_event_wrapper *  event, clock_type::time_point  then  )

inlinestatic

get partner of a half rename event.

If the other half of the rename event is already known a pointer to it is returned. If not a copy of this event is emplaced into the half rename event map and a nullptr is returned.

Definition at line 267 of file inotify_watch.cpp.

                                                                     {
        auto result = getRenameEvents().emplace(event->cookie(), event);
 
        if (result.second) {
            result.first->second.then = then;
            return nullptr;
        } else {
            return &(result.first->second);
        }
    }

References inotify_event_wrapper::cookie(), event, getRenameEvents(), and then.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

getRenameEvents()

static std::map<uint32_t, inotify_event_copy>& inotify_event_copy::getRenameEvents ( )

inlinestaticprotected

return a map which contains the inotify_event_copys

Definition at line 180 of file inotify_watch.cpp.

                                                                   {
        static std::remove_reference<decltype(getRenameEvents())>::type renameEvents;
        return renameEvents;
    }

Referenced by doCopyLeftovers(), forget(), and getPartner().

Here is the caller graph for this function:

getSingleEvents()

static std::multiset<inotify_event_copy*, decltype(cmp)*>& inotify_event_copy::getSingleEvents ( )

inlinestaticprotected

return a multiset containing single inotify_event_copys ordered by time

Definition at line 189 of file inotify_watch.cpp.

                                                                               {
        static std::remove_reference<decltype(getSingleEvents())>::type singleEvents(&cmp);
        return singleEvents;
    }

References cmp().

Referenced by doCopyIfNeeded(), forget(), and getStaleSingles().

Here is the call graph for this function:

Here is the caller graph for this function:

getStaleSingles()

static inotify_event_copy* inotify_event_copy::getStaleSingles ( )

inlinestatic

get the next old inotify_event.

return a pointer to the next old (>5s) half of a rename event the parameter then is set to the time of the event. If no old event is found a nullptr is returned;

Definition at line 237 of file inotify_watch.cpp.

                                                 {
        auto it = getSingleEvents().begin();
 
        if (it != getSingleEvents().end() &&
                (*it)->then < clock_type::now() - std::chrono::seconds(5)) {
            auto retval = *it;
            return retval;
        }
 
        return nullptr;
    }

References getSingleEvents().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

timeStamp()

clock_type::time_point inotify_event_copy::timeStamp ( ) const

inline

< returns time of the event

Definition at line 219 of file inotify_watch.cpp.

                                           {
        return then;   
    }

References then.

Member Data Documentation

event

const inotify_event_wrapper* inotify_event_copy::event

protected

pointer to the event, either the original or a copy

Definition at line 194 of file inotify_watch.cpp.

Referenced by getEvent(), getPartner(), and ~inotify_event_copy().

isCopy

bool inotify_event_copy::isCopy

protected

true if it's a copy. We can't use singleEventIterator as this might be getSingleEvents().end() after erasing it.

Definition at line 196 of file inotify_watch.cpp.

Referenced by doCopyIfNeeded(), and ~inotify_event_copy().

singleEventIterator

std::remove_reference<decltype(getSingleEvents())>::type::iterator inotify_event_copy::singleEventIterator

protected

iterator into the multiset containing the single events

Definition at line 193 of file inotify_watch.cpp.

Referenced by doCopyIfNeeded(), and forget().

then

clock_type::time_point inotify_event_copy::then

protected

the time the event was recorded

Definition at line 195 of file inotify_watch.cpp.

Referenced by cmp(), getPartner(), and timeStamp().

---

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

• src/inotify_watch.cpp (v0.19-24-g0617ca1 with changes)