/* -*-	Mode:C++; c-basic-offset:8; tab-width:8; indent-tabs-mode:t -*- */

/*

 * Copyright (c) 2005,2006 INRIA

 * All rights reserved.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 as

 * published by the Free Software Foundation;

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

 *

 * Author: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>

 */

#include "simulator.h"

#include "scheduler.h"

#include <math.h>

#include <cassert>

#include <fstream>

#include <list>

#include <vector>

#include <iostream>

#define noTRACE_SIMU 1

#ifdef TRACE_SIMU

#include <iostream>

# define TRACE(x) \

std::cout << "SIMU TRACE " << Simulator::now_s () << " " << x << std::endl;

# define TRACE_S(x) \

std::cout << "SIMU TRACE " << x << std::endl;

#else /* TRACE_SIMU */

# define TRACE(format,...)

# define TRACE_S(format,...)

#endif /* TRACE_SIMU */

namespace ns3 {

class SimulatorPrivate {

public:

	SimulatorPrivate (Scheduler *events);

	~SimulatorPrivate ();

	void enable_log_to (char const *filename);

	bool is_finished (void) const;

	void stop (void);

	void run (void);

private:

	void process_one_event (void);

	Events m_destroy;

	uint64_t m_stop_at;

	bool m_stop;

	Scheduler *m_events;

	uint32_t m_uid;

	uint32_t m_current_uid;

	uint64_t m_current_us;

	std::ofstream m_log;

	std::ifstream m_input_log;

	bool m_log_enable;

};

SimulatorPrivate::SimulatorPrivate (Scheduler *events)

{

	m_stop = false;

	m_stop_at = 0;

	m_events = events;

	m_uid = 0;	

	m_log_enable = false;

	m_current_us = 0;

}

SimulatorPrivate::~SimulatorPrivate ()

{

	while (!m_destroy.empty ()) {

		m_destroy.pop_front ();

		TRACE ("handle destroy " << ev);

	}

	delete m_events;

	m_events = (Scheduler *)0xdeadbeaf;

}

void

SimulatorPrivate::enable_log_to (char const *filename)

{

	m_log.open (filename);

	m_log_enable = true;

}

void

SimulatorPrivate::process_one_event (void)

{

	Scheduler::EventKey next_key = m_events->peek_next_key ();

	m_events->remove_next ();

	TRACE ("handle " << next_ev);

	m_current_us = next_key.m_time;

	m_current_uid = next_key.m_uid;

	if (m_log_enable) {

		m_log << "e "<<next_key.m_uid << " " << next_key.m_time << std::endl;

	}

}

bool 

SimulatorPrivate::is_finished (void) const

{

	return m_events->is_empty ();

}

{

	assert (!m_events->is_empty ());

	Scheduler::EventKey next_key = m_events->peek_next_key ();

}

void

SimulatorPrivate::run (void)

{

	while (!m_events->is_empty () && !m_stop && 

		process_one_event ();

	}

	m_log.close ();

}

void 

SimulatorPrivate::stop (void)

{

	m_stop = true;

}

void 

{

}

{

	if (m_log_enable) {

	}

	m_uid++;

	return m_events->insert (event, key);

}

{

}

void

{

	if (m_log_enable) {

	}

}

{

	}

}

}; // namespace ns3

#include "scheduler-list.h"

#include "scheduler-heap.h"

#include "scheduler-map.h"

namespace ns3 {

SimulatorPrivate *Simulator::m_priv = 0;

Simulator::ListType Simulator::m_list_type = LINKED_LIST;

void Simulator::set_linked_list (void)

{

	m_list_type = LINKED_LIST;

}

void Simulator::set_binary_heap (void)

{

	m_list_type = BINARY_HEAP;

}

void Simulator::set_std_map (void)

{

	m_list_type = STD_MAP;

}

void Simulator::enable_log_to (char const *filename)

{

	get_priv ()->enable_log_to (filename);

}

SimulatorPrivate *

Simulator::get_priv (void)

{

	if (m_priv == 0) {

		Scheduler *events;

		switch (m_list_type) {

		case LINKED_LIST:

			events = new SchedulerList ();

			break;

		case BINARY_HEAP:

			events = new SchedulerHeap ();

			break;

		case STD_MAP:

			events = new SchedulerMap ();

			break;

		default: // not reached

			events = 0;

			assert (false); 

			break;

		}

		m_priv = new SimulatorPrivate (events);

	}

	TRACE_S ("priv " << m_priv);

	return m_priv;

}

void

Simulator::destroy (void)

{

	delete m_priv;

	m_priv = 0;

}

bool 

Simulator::is_finished (void)

{

	return get_priv ()->is_finished ();

}

{

}

void 

Simulator::run (void)

{

	get_priv ()->run ();

}

void 

Simulator::stop (void)

{

	TRACE ("stop");

	get_priv ()->stop ();

}

void 

{

}

{

}

{

}

{

	return get_priv ()->remove (ev);

}

}; // namespace ns3

namespace ns3 {

};