tools.h

一个非常好的GIS开源新版本

		virtual ~PropertySet() {}

		Variant getProperty(std::string property);
		void setProperty(std::string property, Variant& v);
		void removeProperty(std::string property);

		virtual unsigned long getByteArraySize();
		virtual void loadFromByteArray(const byte* data);
		virtual void storeToByteArray(byte** data, unsigned long& length);

	private:
		std::map<std::string, Variant> m_propertySet;

#ifdef _MSC_VER
		// MSVC's friend function syntax differs slightly from everyone elses:
		// don't seem to need to qualify function name.
		friend std::ostream& operator<<(
			std::ostream& os,
			const Tools::PropertySet& p
		);
#else
		friend std::ostream& Tools::operator<<(
			std::ostream& os,
			const Tools::PropertySet& p
		);
#endif//_MSC_VER
	}; // PropertySet

	std::ostream& operator<<(std::ostream& os, const Tools::PropertySet& p);

	// does not support degenerate intervals.
	class Interval : public IInterval
	{
	public:
		Interval();
		Interval(IntervalType, double, double);
		Interval(double, double);
		Interval(const Interval&);
		virtual IInterval& operator=(const IInterval&);
		virtual Interval& operator=(const Interval&);
		virtual bool operator==(const Interval&) const;
		virtual bool operator!=(const Interval&) const;
		virtual double getLowerBound() const;
		virtual double getUpperBound() const;
		virtual void setBounds(double, double);
		virtual bool intersectsInterval(const IInterval&) const;
		virtual bool intersectsInterval(IntervalType type, double start, double end) const;
		virtual bool containsInterval(const IInterval&) const;
		virtual IntervalType getIntervalType() const;
		virtual ~Interval() {};

		IntervalType m_type;
		double m_low;
		double m_high;
	}; // Interval

	std::ostream& operator<<(std::ostream& os, const Tools::Interval& iv);

	// Code for the Mersenne generator has been kindly contributed by the MassDAL Code Bank:
	// http://www.cs.rutgers.edu/~muthu/massdal-code-index.html
	class Random
	{
	public:
		Random();
		Random(unsigned long seed);
		Random(unsigned long seed, RandomGeneratorType t);
		Random(unsigned long seed, unsigned short xsubi0);
		virtual ~Random();

		long nextUniformLong();
			// returns a uniformly distributed long.
		unsigned long nextUniformUnsignedLong();
			// returns a uniformly distributed unsigned long.
		long nextUniformLong(long low, long high);
			// returns a uniformly distributed long in the range [low, high).
		unsigned long nextUniformUnsignedLong(unsigned long low, unsigned long high);
			// returns a uniformly distributed unsigned long in the range [low, high).
		long long nextUniformLongLong();
			// returns a uniformly distributed long long.
		unsigned long long nextUniformUnsignedLongLong();
			// returns a uniformly distributed unsigned long long.
		long long nextUniformLongLong(long long low, long long high);
			// returns a uniformly distributed unsigned long long in the range [low, high).
		unsigned long long nextUniformUnsignedLongLong(unsigned long long low, unsigned long long high);
			// returns a uniformly distributed unsigned long long in the range [low, high).
		short nextUniformShort();
			// returns a uniformly distributed short.
		unsigned short nextUniformUnsignedShort();
			// returns a uniformly distributed unsigned short.
		double nextUniformDouble();
			// returns a uniformly distributed double in the range [0, 1).
		double nextUniformDouble(double low, double high);
			// returns a uniformly distributed double in the range [low, high).
	
		// these use the inversion method, thus they are extremely slow. Use with caution.
		double nextNormalDouble();
			// returns doubles using a normal distribution with mean 0.0 and std 1.0 (unbounded).
		double nextNormalDouble(double mean, double std);
			// returns doubles using a normal distribution with mean mean and std std (unbounded).

		// these use the inversion method, thus they are extremely slow. Use with caution.
		long nextSkewedLong(long low, long high, Level);
			// returns longs using a Zipf distribution in the range [low, high).
		double nextSkewedDouble(double low, double high, Level);
			// returns doubles using a Zipf distribution in the range [low, high).
		double nextSkewedDouble(Level);
			// returns doubles using a Zipf distribution in the range [0.0, 1.0).

		bool flipCoin();
			// A Bernoulli trial with probability p = 50%.
		bool bernulliTrial(double p);
			// A Bernoulli trial with probability of success p.

		unsigned long getSize() const;
			// Returns the total size of the random number generator (seed size, etc.).

		unsigned long getSeed() const;

	private:
		void initMersenne();
		void initDrand(unsigned short xsubi0);

		enum
		{
			MERS_N = 624,
			MERS_M = 397,
			MERS_R = 31,
			MERS_U = 11,
			MERS_S = 7,
			MERS_T = 15,
			MERS_L = 18,
			MERS_A = 0x9908B0DF,
			MERS_B = 0x9D2C5680,
			MERS_C = 0xEFC60000
		};

		RandomGeneratorType m_type;
		void* m_buffer;
		Architecture m_architecture;
		unsigned long m_seed;
	}; // Random

	class PRGZipf
	{
	public:
		PRGZipf(long min, long max, double s, Tools::Random* pRandom);
		virtual ~PRGZipf();

		long nextLong();

	private:
		void initLookupTable();

		long m_min;
		long m_max;
		double m_s;
		Tools::Random* m_pRandom;
		double* m_pLookupTable;
	}; // PRGZipf

	class PRGFrechet
	{
	public:
		PRGFrechet(double a, double b, Tools::Random* pRandom);
		virtual ~PRGFrechet();

		double nextDouble();

	private:
		double m_alpha;
		double m_beta;
		Tools::Random* m_pRandom;
	}; // PRGFrechet

	class Hash
	{
	public:
		virtual ~Hash();

		virtual void hash(
			const std::string& s,
			byte** out, unsigned long& lout
		) = 0;
		virtual void hash(
			const byte* in, unsigned long lin,
			byte** out, unsigned long& lout
		) = 0;
	}; // Hash

	// Implements the hash functions described in:
	// Wegman and Carter
	// New classes and applications of hash functions, FOCS 1979
	class UniversalHash : public Hash
	{
	public:
		typedef unsigned long value_type;

		UniversalHash(unsigned long k = 2);
		UniversalHash(Tools::Random& r, unsigned long k = 2);
		UniversalHash(unsigned long a, unsigned long b);
		UniversalHash(const UniversalHash& h);
		UniversalHash(const byte* data);
		virtual ~UniversalHash();

		virtual UniversalHash& operator=(const UniversalHash& in);
		virtual bool operator==(const UniversalHash& in) const;

		virtual value_type hash(value_type x) const;
		virtual unsigned long getSize() const;
		virtual void getData(byte** buffer, unsigned long& length) const;

		virtual void hash(
			const std::string& s,
			byte** out, unsigned long& lout
		);
		virtual void hash(
			const byte* in, unsigned long lin,
			byte** out, unsigned long& lout
		);

		static const unsigned long long m_P = 0x1FFFFFFFFFFFFFFFull; // 2^61 - 1

	private:
		unsigned long long* m_a;
		unsigned long m_k;

#ifdef _MSC_VER
		// MSVC's friend function syntax differs slightly from everyone elses
		// don't seem to need to qualify function name.
		friend std::ostream& operator<<(
			std::ostream& os,
			const Tools::UniversalHash& h
		);
#else
		friend std::ostream& Tools::operator<<(
			std::ostream& os,
			const Tools::UniversalHash& h
		);
#endif//_MSC_VER
	}; // UniversalHash

	std::ostream& operator<<(std::ostream& os, const Tools::UniversalHash& h);

	class SHA1Hash : public Hash
	{
	public:
		virtual ~SHA1Hash();

		virtual void hash(
			const std::string& s,
			byte** out, unsigned long& lout
		);
		virtual void hash(
			const byte* in, unsigned long lin,
			byte** out, unsigned long& lout
		);
		virtual void hash(
			std::istream& s,
			byte** out, unsigned long& lout
		);
		virtual std::string hash(const std::string& s);

	public:
		static const unsigned long HashLength = 20;
	}; // SHA1Hash

#if HAVE_GETTIMEOFDAY
	class ResourceUsage
	{
	public:
		ResourceUsage();

		void start();
		void stop();
		void reset();

		double getTotalTime();
		double getUserTime();
		double getSystemTime();
		long getPageFaults();
		long getReadIO();
		long getWriteIO();
		long getPeakResidentMemoryUsage();
		long getTotalMemoryUsage();

	private:
		double combineTime(const struct timeval&);
		void addTimeval(struct timeval&, const struct timeval&);
		void subtractTimeval(struct timeval&, const struct timeval&, const struct timeval&);

  		struct rusage m_tmpRU;
  		struct timeval m_tmpTV;
  		struct timeval m_totalTime;
  		struct timeval m_userTime;
  		struct timeval m_systemTime;
  		long m_pageFaults;
  		long m_readIO;
  		long m_writeIO;
  		long m_peakMemory;
  		long m_totalMemory;
  	}; // ResourceUsage
#endif

#if BUILD_CPU_I686
	class CycleCounter
	{
	public:
		CycleCounter();
		void start();
		void stop();
		void reset();
		double getTotalCycles();
		double getCPUMHz();
		double getCyclesPerSecond();

	private:
		unsigned long long m_tmpCycles;
		unsigned long long m_totalCycles;
		bool m_bRunning;

		unsigned long long rdtsc();
	}; // CycleCounter
#endif

	class System
	{
	public:
		static Architecture getArchitecture();
	}; // System

	class SharedLock
	{
	public:
#if HAVE_PTHREAD_H
		SharedLock(pthread_rwlock_t* pLock);
		~SharedLock();

	private:
		pthread_rwlock_t* m_pLock;
#endif
	}; // SharedLock

	class ExclusiveLock
	{
	public:
#if HAVE_PTHREAD_H
		ExclusiveLock(pthread_rwlock_t* pLock);
		~ExclusiveLock();

	private:
		pthread_rwlock_t* m_pLock;
#endif
	}; // ExclusiveLock

	class StringTokenizer
	{
	public:
		StringTokenizer(const std::string& s, const std::string& delimiters = " \t");
		bool hasMoreTokens();
		std::string getNextToken();
		void reset();

	private:
		unsigned long m_index;
		std::vector<std::string> m_token;
	}; // StringTokenizer

	std::string trimLeft(const std::string& source, const std::string& t = " \t");
	std::string trimRight(const std::string& source, const std::string& t = " \t");
	std::string trim(const std::string& source, const std::string& t = " \t");
	char toLower(char c);
	char toUpper(char c);
	std::string toUpperCase(const std::string& s);
	std::string toLowerCase(const std::string& s);

	unsigned long long choose(unsigned long n, unsigned long k);

	void compressRLE(
		unsigned long blockSize,
		byte* in, unsigned long lin,
		byte** out, unsigned long& lout);
	void uncompressRLE(
		unsigned long blockSize,
		byte* in, unsigned long lin,
		byte** out, unsigned long& lout);
}

#include "Point.h"
#include "Region.h"
#include "LineSegment.h"
#include "TemporaryFile.h"

#endif /* __tools_h */