forked from lthn/blockchain
Merge branch 'wallet_sync' into predevelop
This commit is contained in:
cryptozoidberg
commit
e43be6a0b4
43 changed files with 840 additions and 4220 deletions
|
|
@ -1,56 +0,0 @@
|
|||
/** tutorial_pba_0.cpp
|
||||
*
|
||||
* (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
|
||||
*
|
||||
* Use, modification and distribution is subject to the Boost Software
|
||||
* License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* The intent of this program is to serve as a tutorial for
|
||||
* users of the portable binary archive in the framework of
|
||||
* the Boost/Serialization library.
|
||||
*
|
||||
* This quick start example shows how to store some variables
|
||||
* of basic types (bool, integer, floating point numbers, STL string)
|
||||
* using the portable binary archive format associated to a
|
||||
* standard output file stream.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <string>
|
||||
#include <fstream>
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/archive/portable_binary_oarchive.hpp>
|
||||
|
||||
int main (void)
|
||||
{
|
||||
// The name for the example data file :
|
||||
std::string filename = "pba_0.data";
|
||||
|
||||
// Some variables of various primitive types :
|
||||
bool b = true;
|
||||
char c = 'B';
|
||||
uint32_t answer = 42;
|
||||
float computing_time = 7.5e6;
|
||||
double e = 2.71828182845905;
|
||||
std::string slogan = "DON'T PANIC";
|
||||
|
||||
// Open an output file stream in binary mode :
|
||||
std::ofstream fout (filename.c_str (), std::ios_base::binary);
|
||||
|
||||
{
|
||||
// Create an output portable binary archive attached to the output file :
|
||||
boost::archive::portable_binary_oarchive opba (fout);
|
||||
|
||||
// Store (serializing) variables :
|
||||
opba & b & c & answer & computing_time & e & slogan;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// end of tutorial_pba_0.cpp
|
||||
|
|
@ -1,68 +0,0 @@
|
|||
/** tutorial_pba_1.cpp
|
||||
*
|
||||
* (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
|
||||
*
|
||||
* Use, modification and distribution is subject to the Boost Software
|
||||
* License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* The intent of this program is to serve as a tutorial for
|
||||
* users of the portable binary archive in the framework of
|
||||
* the Boost/Serialization package.
|
||||
*
|
||||
* This quick start example shows how to load some variables
|
||||
* of basic types (bool, integer, floating point numbers, STL string)
|
||||
* using the portable binary archive format associated to a
|
||||
* standard input file stream.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <fstream>
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/archive/portable_binary_iarchive.hpp>
|
||||
|
||||
int main (void)
|
||||
{
|
||||
using namespace std;
|
||||
|
||||
// The name for the example data file :
|
||||
string filename = "pba_0.data";
|
||||
|
||||
// Some variables of various types :
|
||||
bool b;
|
||||
char c;
|
||||
uint32_t answer;
|
||||
float computing_time;
|
||||
double e;
|
||||
string slogan;
|
||||
|
||||
// Open an input file stream in binary mode :
|
||||
ifstream fin (filename.c_str (), ios_base::binary);
|
||||
|
||||
{
|
||||
// Create an input portable binary archive attached to the input file :
|
||||
boost::archive::portable_binary_iarchive ipba (fin);
|
||||
|
||||
// Loading (de-serializing) variables using the same
|
||||
// order than for serialization (see tutorial_pba_0.cpp) :
|
||||
ipba & b & c & answer & computing_time & e & slogan;
|
||||
}
|
||||
|
||||
cout.precision (15);
|
||||
cout << "Variable 'b' is : " << b << " " << "(bool)" << endl;
|
||||
cout << "Variable 'c' is : '" << c << "' " << " " << "(char)" << endl;
|
||||
cout << "Variable 'answer' is : " << answer << " " << "(unsigned 32-bit integer)" << endl;
|
||||
cout << "Variable 'computing_time' is : " << computing_time << " " << "(single precision 32-bit float)" << endl;
|
||||
cout << "Variable 'e' is : " << e << " " << "(double precision 64-bit float)" << endl;
|
||||
cout << "Variable 'slogan' is : \"" << slogan << "\" " << "(std::string)" << endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// end of tutorial_pba_1.cpp
|
||||
|
|
@ -1,162 +0,0 @@
|
|||
/** tutorial_pba_10.cpp
|
||||
*
|
||||
* (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
|
||||
*
|
||||
* Use, modification and distribution is subject to the Boost Software
|
||||
* License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* The intent of this program is to serve as a tutorial for
|
||||
* users of the portable binary archive in the framework of
|
||||
* the Boost/Serialization library.
|
||||
*
|
||||
* This example shows how use PBAs combined with on-the-fly
|
||||
* compressed I/O streams.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <string>
|
||||
#include <fstream>
|
||||
#include <limits>
|
||||
#include <vector>
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/archive/portable_binary_oarchive.hpp>
|
||||
#include <boost/archive/portable_binary_iarchive.hpp>
|
||||
#include <boost/iostreams/filtering_stream.hpp>
|
||||
#include <boost/iostreams/filter/gzip.hpp>
|
||||
#include <boost/serialization/access.hpp>
|
||||
#include <boost/serialization/vector.hpp>
|
||||
|
||||
using namespace std;
|
||||
|
||||
class data_type
|
||||
{
|
||||
private:
|
||||
friend class boost::serialization::access;
|
||||
template<class Archive>
|
||||
void serialize (Archive & ar, const unsigned int version);
|
||||
public:
|
||||
void print (ostream & out, const string & title) const;
|
||||
public:
|
||||
vector<double> values;
|
||||
data_type ();
|
||||
};
|
||||
|
||||
data_type::data_type () : values ()
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
void data_type::print (ostream & out, const string & title) const
|
||||
{
|
||||
out << endl;
|
||||
out << title << " :" << endl;
|
||||
for (int i = 0; i < this->values.size (); ++i)
|
||||
{
|
||||
out.precision (16);
|
||||
out.width (18);
|
||||
out << this->values [i] << ' ' ;
|
||||
if ((i%4) == 3) clog << endl;
|
||||
}
|
||||
out << endl;
|
||||
return;
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
void data_type::serialize (Archive & ar, const unsigned int version)
|
||||
{
|
||||
ar & values;
|
||||
return;
|
||||
}
|
||||
|
||||
void do_gzipped_out (void)
|
||||
{
|
||||
// The name for the output data file :
|
||||
string filename = "pba_10.data.gz";
|
||||
|
||||
// A data structure to be stored :
|
||||
data_type my_data;
|
||||
|
||||
// Fill the vector with arbitrary (possibly non-finite) values :
|
||||
size_t dim = 1000;
|
||||
my_data.values.reserve (dim);
|
||||
for (int i = 0; i < dim; ++i)
|
||||
{
|
||||
double val = (i + 1) * (1.0 + 3 * numeric_limits<double>::epsilon ());
|
||||
if (i == 4) val = numeric_limits<double>::quiet_NaN ();
|
||||
if (i == 23) val = numeric_limits<double>::infinity ();
|
||||
if (i == 73) val = -numeric_limits<double>::infinity ();
|
||||
if (i == 90) val = 0.0;
|
||||
my_data.values.push_back (val);
|
||||
}
|
||||
|
||||
// Print:
|
||||
my_data.print (clog, "Stored data");
|
||||
|
||||
// Create an output filtering stream :
|
||||
boost::iostreams::filtering_ostream zout;
|
||||
zout.push (boost::iostreams::gzip_compressor ());
|
||||
|
||||
// Open an output file stream in binary mode :
|
||||
ofstream fout (filename.c_str (), ios_base::binary);
|
||||
zout.push (fout);
|
||||
|
||||
// Save to PBA :
|
||||
{
|
||||
// Create an output portable binary archive attached to the output file :
|
||||
boost::archive::portable_binary_oarchive opba (zout);
|
||||
|
||||
// Store (serializing) the data :
|
||||
opba & my_data;
|
||||
}
|
||||
|
||||
// Clean termination of the streams :
|
||||
zout.flush ();
|
||||
zout.reset ();
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
void do_gzipped_in (void)
|
||||
{
|
||||
// The name for the input data file :
|
||||
string filename = "pba_10.data.gz";
|
||||
|
||||
// A data structure to be loaded :
|
||||
data_type my_data;
|
||||
|
||||
// Create an input filtering stream :
|
||||
boost::iostreams::filtering_istream zin;
|
||||
zin.push (boost::iostreams::gzip_decompressor ());
|
||||
|
||||
// Open an input file stream in binary mode :
|
||||
ifstream fin (filename.c_str (), ios_base::binary);
|
||||
zin.push (fin);
|
||||
|
||||
// Load from PBA :
|
||||
{
|
||||
// Create an input portable binary archive attached to the input file :
|
||||
boost::archive::portable_binary_iarchive ipba (zin);
|
||||
|
||||
// Load (deserializing) the data :
|
||||
ipba & my_data;
|
||||
}
|
||||
|
||||
// Print:
|
||||
my_data.print (clog, "Loaded data");
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
int main (void)
|
||||
{
|
||||
do_gzipped_out ();
|
||||
do_gzipped_in ();
|
||||
return 0;
|
||||
}
|
||||
|
||||
// end of tutorial_pba_10.cpp
|
||||
|
|
@ -1,198 +0,0 @@
|
|||
/** tutorial_pba_10b.cpp
|
||||
*
|
||||
* (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
|
||||
*
|
||||
* Use, modification and distribution is subject to the Boost Software
|
||||
* License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* The intent of this program is to serve as a tutorial for
|
||||
* users of the portable binary archive in the framework of
|
||||
* the Boost/Serialization library.
|
||||
*
|
||||
* This example shows how use PBAs combined with on-the-fly
|
||||
* compressed I/O streams.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <string>
|
||||
#include <fstream>
|
||||
#include <limits>
|
||||
#include <vector>
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/archive/portable_binary_oarchive.hpp>
|
||||
#include <boost/archive/portable_binary_iarchive.hpp>
|
||||
#include <boost/archive/xml_oarchive.hpp>
|
||||
#include <boost/iostreams/filtering_stream.hpp>
|
||||
#include <boost/iostreams/filter/gzip.hpp>
|
||||
#include <boost/serialization/access.hpp>
|
||||
#include <boost/serialization/vector.hpp>
|
||||
#include <boost/serialization/nvp.hpp>
|
||||
#include <boost/serialization/version.hpp>
|
||||
|
||||
using namespace std;
|
||||
|
||||
class data_type
|
||||
{
|
||||
private:
|
||||
friend class boost::serialization::access;
|
||||
template<class Archive>
|
||||
void serialize (Archive & ar, const unsigned int version);
|
||||
public:
|
||||
void print (ostream & out, const string & title) const;
|
||||
public:
|
||||
vector<double> values;
|
||||
data_type ();
|
||||
};
|
||||
|
||||
//BOOST_CLASS_VERSION(data_type, 7)
|
||||
|
||||
data_type::data_type () : values ()
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
void data_type::print (ostream & out, const string & title) const
|
||||
{
|
||||
out << endl;
|
||||
out << title << " :" << endl;
|
||||
for (int i = 0; i < this->values.size (); ++i)
|
||||
{
|
||||
out.precision (16);
|
||||
out.width (18);
|
||||
out << this->values [i] << ' ' ;
|
||||
if ((i%4) == 3) clog << endl;
|
||||
}
|
||||
out << endl;
|
||||
return;
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
void data_type::serialize (Archive & ar, const unsigned int version)
|
||||
{
|
||||
ar & BOOST_SERIALIZATION_NVP (values);
|
||||
return;
|
||||
}
|
||||
|
||||
class data_type2
|
||||
{
|
||||
private:
|
||||
friend class boost::serialization::access;
|
||||
template<class Archive>
|
||||
void serialize (Archive & ar, const unsigned int version);
|
||||
public:
|
||||
double value;
|
||||
data_type2 ();
|
||||
};
|
||||
|
||||
BOOST_CLASS_VERSION(data_type2, 99)
|
||||
|
||||
data_type2::data_type2 () : value (666.666)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
void data_type2::serialize (Archive & ar, const unsigned int version)
|
||||
{
|
||||
ar & BOOST_SERIALIZATION_NVP (value);
|
||||
return;
|
||||
}
|
||||
|
||||
class data_type3
|
||||
{
|
||||
private:
|
||||
friend class boost::serialization::access;
|
||||
template<class Archive>
|
||||
void serialize (Archive & ar, const unsigned int version);
|
||||
public:
|
||||
vector<data_type2> values;
|
||||
data_type3 ();
|
||||
};
|
||||
|
||||
BOOST_CLASS_VERSION(data_type3, 33)
|
||||
|
||||
data_type3::data_type3 ()
|
||||
{
|
||||
{
|
||||
data_type2 d;
|
||||
d.value = 6.66;
|
||||
values.push_back (d);
|
||||
}
|
||||
{
|
||||
data_type2 d;
|
||||
d.value = 66.66;
|
||||
values.push_back (d);
|
||||
}
|
||||
{
|
||||
data_type2 d;
|
||||
d.value = 666.66;
|
||||
values.push_back (d);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
void data_type3::serialize (Archive & ar, const unsigned int version)
|
||||
{
|
||||
ar & BOOST_SERIALIZATION_NVP (values);
|
||||
return;
|
||||
}
|
||||
|
||||
/********************/
|
||||
|
||||
void do_xml_out (void)
|
||||
{
|
||||
// The name for the output data file :
|
||||
string filename = "pba_10.xml";
|
||||
|
||||
// A data structure to be stored :
|
||||
data_type my_data;
|
||||
|
||||
// Fill the vector with arbitrary (possibly non-finite) values :
|
||||
size_t dim = 6;
|
||||
my_data.values.reserve (dim);
|
||||
for (int i = 0; i < dim; ++i)
|
||||
{
|
||||
double val = (i + 1) * (1.0 + 3 * numeric_limits<double>::epsilon ());
|
||||
if (i == 4) val = numeric_limits<double>::quiet_NaN ();
|
||||
if (i == 7) val = numeric_limits<double>::infinity ();
|
||||
if (i == 9) val = -numeric_limits<double>::infinity ();
|
||||
if (i == 13) val = 0.0;
|
||||
my_data.values.push_back (val);
|
||||
}
|
||||
|
||||
// Print:
|
||||
my_data.print (clog, "Stored data");
|
||||
|
||||
data_type2 my_data2;
|
||||
data_type3 my_data3;
|
||||
|
||||
// Open an output file stream in binary mode :
|
||||
ofstream fout (filename.c_str ());
|
||||
|
||||
// Save to PBA :
|
||||
{
|
||||
// Create an output XML archive attached to the output file :
|
||||
boost::archive::xml_oarchive oxa (fout);
|
||||
|
||||
// Store (serializing) the data :
|
||||
oxa & BOOST_SERIALIZATION_NVP(my_data);
|
||||
oxa & BOOST_SERIALIZATION_NVP(my_data2);
|
||||
oxa & BOOST_SERIALIZATION_NVP(my_data3);
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
int main (void)
|
||||
{
|
||||
do_xml_out ();
|
||||
return 0;
|
||||
}
|
||||
|
||||
// end of tutorial_pba_10b.cpp
|
||||
|
|
@ -1,187 +0,0 @@
|
|||
/** tutorial_pba_11.cpp
|
||||
*
|
||||
* (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
|
||||
*
|
||||
* Use, modification and distribution is subject to the Boost Software
|
||||
* License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* The intent of this program is to serve as a tutorial for
|
||||
* users of the portable binary archive in the framework of
|
||||
* the Boost/Serialization library.
|
||||
*
|
||||
* This example program compares the times needed to serialize
|
||||
* and deserialize some large amount of data using PBA and
|
||||
* text archives.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <string>
|
||||
#include <fstream>
|
||||
#include <vector>
|
||||
|
||||
#include <boost/archive/portable_binary_oarchive.hpp>
|
||||
#include <boost/archive/portable_binary_iarchive.hpp>
|
||||
#include <boost/archive/text_oarchive.hpp>
|
||||
#include <boost/archive/text_iarchive.hpp>
|
||||
#include <boost/serialization/access.hpp>
|
||||
#include <boost/serialization/vector.hpp>
|
||||
#include <boost/random/mersenne_twister.hpp>
|
||||
#include <boost/random/uniform_real_distribution.hpp>
|
||||
#include <boost/timer.hpp>
|
||||
|
||||
using namespace std;
|
||||
|
||||
class data_type
|
||||
{
|
||||
private:
|
||||
friend class boost::serialization::access;
|
||||
template<class Archive>
|
||||
void serialize (Archive & ar, const unsigned int version);
|
||||
public:
|
||||
void print (ostream & out, const string & title) const;
|
||||
public:
|
||||
vector<double> values;
|
||||
data_type ();
|
||||
};
|
||||
|
||||
data_type::data_type () : values ()
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
void data_type::print (ostream & out, const string & title) const
|
||||
{
|
||||
out << endl;
|
||||
out << title << " :" << endl;
|
||||
bool skip = false;
|
||||
for (int i = 0; i < this->values.size (); ++i)
|
||||
{
|
||||
if ((i >= 12) && (i < (int) this->values.size () - 8))
|
||||
{
|
||||
if (! skip) out << " ..." << endl;
|
||||
skip = true;
|
||||
continue;
|
||||
}
|
||||
out.precision (16);
|
||||
out.width (18);
|
||||
out << this->values [i] << ' ' ;
|
||||
if ((i%4) == 3) clog << endl;
|
||||
}
|
||||
out << endl;
|
||||
return;
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
void data_type::serialize (Archive & ar, const unsigned int version)
|
||||
{
|
||||
ar & values;
|
||||
return;
|
||||
}
|
||||
|
||||
double do_pba_out (const data_type & a_data)
|
||||
{
|
||||
string filename = "pba_11.data";
|
||||
ofstream fout (filename.c_str (), ios_base::binary);
|
||||
boost::timer io_timer;
|
||||
{
|
||||
boost::archive::portable_binary_oarchive opba (fout);
|
||||
opba & a_data;
|
||||
}
|
||||
return io_timer.elapsed ();
|
||||
}
|
||||
|
||||
double do_pba_in (data_type & a_data)
|
||||
{
|
||||
string filename = "pba_11.data";
|
||||
ifstream fin (filename.c_str (), ios_base::binary);
|
||||
boost::timer io_timer;
|
||||
{
|
||||
boost::archive::portable_binary_iarchive ipba (fin);
|
||||
ipba & a_data;
|
||||
}
|
||||
return io_timer.elapsed ();
|
||||
}
|
||||
|
||||
double do_text_out (const data_type & a_data)
|
||||
{
|
||||
string filename = "pba_11.txt";
|
||||
ofstream fout (filename.c_str ());
|
||||
boost::timer io_timer;
|
||||
{
|
||||
boost::archive::text_oarchive ota (fout);
|
||||
ota & a_data;
|
||||
}
|
||||
return io_timer.elapsed ();
|
||||
}
|
||||
|
||||
double do_text_in (data_type & a_data)
|
||||
{
|
||||
string filename = "pba_11.txt";
|
||||
ifstream fin (filename.c_str ());
|
||||
boost::timer io_timer;
|
||||
{
|
||||
boost::archive::text_iarchive ita (fin);
|
||||
ita & a_data;
|
||||
}
|
||||
return io_timer.elapsed ();
|
||||
}
|
||||
|
||||
int main (void)
|
||||
{
|
||||
double elapsed_time_pba_out;
|
||||
double elapsed_time_text_out;
|
||||
double elapsed_time_pba_in;
|
||||
double elapsed_time_text_in;
|
||||
data_type my_data; // A data structure to be stored then loaded.
|
||||
|
||||
{
|
||||
// Fill the vector with random values :
|
||||
size_t dim = 10000000;
|
||||
my_data.values.reserve (dim);
|
||||
boost::random::mt19937 rng;
|
||||
boost::random::uniform_real_distribution<> flat (0.0, 100.0);
|
||||
for (int i = 0; i < dim; ++i)
|
||||
{
|
||||
double val = flat (rng);
|
||||
my_data.values.push_back (val);
|
||||
}
|
||||
my_data.print (clog, "Stored data in PBA and text archive");
|
||||
}
|
||||
|
||||
{
|
||||
// Store in PBA :
|
||||
elapsed_time_pba_out = do_pba_out (my_data);
|
||||
}
|
||||
|
||||
{
|
||||
// Store in text archive :
|
||||
elapsed_time_text_out = do_text_out (my_data);
|
||||
}
|
||||
|
||||
{
|
||||
my_data.values.clear ();
|
||||
// Load from PBA :
|
||||
elapsed_time_pba_in = do_pba_in (my_data);
|
||||
my_data.print (clog, "Loaded data from PBA");
|
||||
}
|
||||
|
||||
{
|
||||
my_data.values.clear ();
|
||||
// Load from text archive :
|
||||
elapsed_time_text_in = do_text_in (my_data);
|
||||
my_data.print (clog, "Loaded data from text archive");
|
||||
}
|
||||
|
||||
clog << "PBA store I/O elapsed time : " << elapsed_time_pba_out << " (second)" << endl;
|
||||
clog << "Text store I/O elapsed time : " << elapsed_time_text_out << " (second)" << endl;
|
||||
clog << "PBA load I/O elapsed time : " << elapsed_time_pba_in << " (second)" << endl;
|
||||
clog << "Text load I/O elapsed time : " << elapsed_time_text_in << " (second)" << endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// end of tutorial_pba_11.cpp
|
||||
|
|
@ -1,105 +0,0 @@
|
|||
/** tutorial_pba_2.cpp
|
||||
*
|
||||
* (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
|
||||
*
|
||||
* Use, modification and distribution is subject to the Boost Software
|
||||
* License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* The intent of this program is to serve as a tutorial for
|
||||
* users of the portable binary archive in the framework of
|
||||
* the Boost/Serialization library.
|
||||
*
|
||||
* This sample program shows how to use a portable binary archive
|
||||
* to store/load floating point numbers including non-finite and
|
||||
* special (denormalized) values.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <string>
|
||||
#include <fstream>
|
||||
#include <limits>
|
||||
|
||||
#include <boost/archive/portable_binary_oarchive.hpp>
|
||||
#include <boost/archive/portable_binary_iarchive.hpp>
|
||||
|
||||
int main (void)
|
||||
{
|
||||
using namespace std;
|
||||
|
||||
// The name for the example data file :
|
||||
string filename = "pba_2.data";
|
||||
|
||||
{
|
||||
// A normal single precision floating point number :
|
||||
float pi = 3.14159265;
|
||||
|
||||
// Single precision zeroed floating point number :
|
||||
float zero = 0.0;
|
||||
|
||||
// A denormalized single precision floating point number :
|
||||
float tiny = 1.e-40;
|
||||
|
||||
// A single precision floating point number with `+Infinity' value :
|
||||
float plus_infinity = numeric_limits<float>::infinity ();
|
||||
|
||||
// A single precision floating point number with `-Infinity' value :
|
||||
float minus_infinity = -numeric_limits<float>::infinity ();
|
||||
|
||||
// A single precision `Not-a-Number' (NaN):
|
||||
float nan = numeric_limits<float>::quiet_NaN ();
|
||||
|
||||
// Open an output file stream in binary mode :
|
||||
ofstream fout (filename.c_str (), ios_base::binary);
|
||||
|
||||
{
|
||||
// Create an output portable binary archive attached to the output file :
|
||||
boost::archive::portable_binary_oarchive opba (fout);
|
||||
|
||||
// Store (serialize) variables :
|
||||
opba & pi & zero & tiny & plus_infinity & minus_infinity & nan;
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
// Single precision floating point numbers to be loaded :
|
||||
float x[6];
|
||||
|
||||
// Open an input file stream in binary mode :
|
||||
ifstream fin (filename.c_str (), ios_base::binary);
|
||||
|
||||
{
|
||||
// Create an input portable binary archive attached to the input file :
|
||||
boost::archive::portable_binary_iarchive ipba (fin);
|
||||
|
||||
// Load (de-serialize) variables using the same
|
||||
// order than for serialization :
|
||||
for (int i = 0; i < 6; ++i)
|
||||
{
|
||||
ipba & x[i];
|
||||
}
|
||||
}
|
||||
|
||||
// Print :
|
||||
for (int i = 0; i < 6; ++i)
|
||||
{
|
||||
cout.precision (8);
|
||||
cout << "Loaded x[" << i << "] = " << x[i];
|
||||
switch (fp::fpclassify(x[i]))
|
||||
{
|
||||
case FP_NAN: cout << " (NaN)"; break;
|
||||
case FP_INFINITE: cout << " (infinite)"; break;
|
||||
case FP_SUBNORMAL: cout << " (denormalized)"; break;
|
||||
case FP_NORMAL: cout << " (normalized)"; break;
|
||||
}
|
||||
cout << endl;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// end of tutorial_pba_2.cpp
|
||||
|
|
@ -1,70 +0,0 @@
|
|||
/** tutorial_pba_3.cpp
|
||||
*
|
||||
* (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
|
||||
*
|
||||
* Use, modification and distribution is subject to the Boost Software
|
||||
* License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* The intent of this program is to serve as a tutorial for
|
||||
* users of the portable binary archive in the framework of
|
||||
* the Boost/Serialization library.
|
||||
*
|
||||
* This sample program shows how to use a portable binary archive
|
||||
* and prevent the serialization of non-finite floating numbers.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <string>
|
||||
#include <fstream>
|
||||
#include <limits>
|
||||
|
||||
#include <boost/archive/portable_binary_oarchive.hpp>
|
||||
|
||||
int main (void)
|
||||
{
|
||||
using namespace std;
|
||||
|
||||
// The name for the example data file :
|
||||
string filename = "pba_3.data";
|
||||
|
||||
try
|
||||
{
|
||||
// An array of single precision floating numbers:
|
||||
float x[5];
|
||||
x[0] = 3.14159; // Pi
|
||||
x[1] = 6.022e22; // Avogadro constant
|
||||
x[2] = 1.6e-19; // Electron charge magnitude
|
||||
x[3] = 1.e-40; // A tiny (denormalized) value
|
||||
x[4] = numeric_limits<float>::infinity (); // This will fail while serializing...
|
||||
|
||||
// Open an output file stream in binary mode :
|
||||
ofstream fout (filename.c_str (), ios_base::binary);
|
||||
|
||||
{
|
||||
// Create an output portable binary archive attached to the output file,
|
||||
// using the special 'boost::archive::no_infnan' flag :
|
||||
boost::archive::portable_binary_oarchive opba (fout, boost::archive::no_infnan);
|
||||
|
||||
// Store (serialize) variables :
|
||||
for (int i = 0; i < 5; ++i)
|
||||
{
|
||||
clog << "Serializing value : " << x[i] << " ... ";
|
||||
opba & x[i];
|
||||
clog << "Ok !" << endl;
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (exception & x)
|
||||
{
|
||||
cerr << "ERROR: " << x.what () << endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// end of tutorial_pba_3.cpp
|
||||
|
|
@ -1,105 +0,0 @@
|
|||
/** tutorial_pba_4.cpp
|
||||
*
|
||||
* (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
|
||||
*
|
||||
* Use, modification and distribution is subject to the Boost Software
|
||||
* License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* The intent of this program is to serve as a tutorial for
|
||||
* users of the portable binary archive in the framework of
|
||||
* the Boost/Serialization library.
|
||||
*
|
||||
* This sample program shows how to use a portable binary archive
|
||||
* to store/load integer numbers of various sizes using the Boost
|
||||
* portable integer typedefs.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <string>
|
||||
#include <fstream>
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/archive/portable_binary_oarchive.hpp>
|
||||
#include <boost/archive/portable_binary_iarchive.hpp>
|
||||
|
||||
int main (void)
|
||||
{
|
||||
using namespace std;
|
||||
|
||||
// The name for the example data file :
|
||||
string filename = "pba_4.data";
|
||||
|
||||
{
|
||||
// Some integer numbers :
|
||||
bool t = true;
|
||||
char c = 'c';
|
||||
unsigned char u = 'u';
|
||||
int8_t b = -3; // char
|
||||
uint8_t B = +6; // unsigned char
|
||||
int16_t s = -16;
|
||||
uint16_t S = +32;
|
||||
int32_t l = -128;
|
||||
uint32_t L = +127;
|
||||
int64_t ll = -1024;
|
||||
uint64_t LL = +2048;
|
||||
|
||||
// Open an output file stream in binary mode :
|
||||
ofstream fout (filename.c_str (), ios_base::binary);
|
||||
|
||||
{
|
||||
// Create an output portable binary archive attached to the output file :
|
||||
boost::archive::portable_binary_oarchive opba (fout);
|
||||
|
||||
// Store (serialize) variables :
|
||||
opba & t & c & u & b & B & s & S & l & L & ll & LL;
|
||||
}
|
||||
}
|
||||
|
||||
{
|
||||
// Single precision floating numbers to be loaded :
|
||||
// Some integer numbers :
|
||||
bool t;
|
||||
char c;
|
||||
unsigned char u;
|
||||
int8_t b;
|
||||
uint8_t B;
|
||||
int16_t s;
|
||||
uint16_t S;
|
||||
int32_t l;
|
||||
uint32_t L;
|
||||
int64_t ll;
|
||||
uint64_t LL;
|
||||
|
||||
// Open an input file stream in binary mode :
|
||||
ifstream fin (filename.c_str (), ios_base::binary);
|
||||
|
||||
{
|
||||
// Create an input portable binary archive attached to the input file :
|
||||
boost::archive::portable_binary_iarchive ipba (fin);
|
||||
|
||||
// Load (de-serialize) variables using the same
|
||||
// order than for serialization :
|
||||
ipba & t & c & u & b & B & s & S & l & L & ll & LL;
|
||||
}
|
||||
|
||||
clog << "t = " << t << " (bool)" << endl;
|
||||
clog << "c = '" << c << "' (char)" << endl;
|
||||
clog << "u = '" << u << "' (unsigned char)" << endl;
|
||||
clog << "b = " << (int) b << " (int8_t)" << endl;
|
||||
clog << "B = " << (int) B << " (uint8_t)" << endl;
|
||||
clog << "s = " << s << " (int16_t)" << endl;
|
||||
clog << "S = " << S << " (uint16_t)" << endl;
|
||||
clog << "l = " << l << " (int32_t)" << endl;
|
||||
clog << "L = " << L << " (uint32_t)" << endl;
|
||||
clog << "ll = " << ll << " (int64_t)" << endl;
|
||||
clog << "LL = " << LL << " (uint64_t)" << endl;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// end of tutorial_pba_4.cpp
|
||||
|
|
@ -1,111 +0,0 @@
|
|||
/** tutorial_pba_5.cpp
|
||||
*
|
||||
* (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
|
||||
*
|
||||
* Use, modification and distribution is subject to the Boost Software
|
||||
* License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* The intent of this program is to serve as a tutorial for
|
||||
* users of the portable binary archive in the framework of
|
||||
* the Boost/Serialization library.
|
||||
*
|
||||
* This sample program shows how to use a portable binary archive
|
||||
* to store/load data in a memory buffer.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include <boost/iostreams/stream.hpp>
|
||||
#include <boost/iostreams/device/back_inserter.hpp>
|
||||
#include <boost/iostreams/device/array.hpp>
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/archive/portable_binary_oarchive.hpp>
|
||||
#include <boost/archive/portable_binary_iarchive.hpp>
|
||||
|
||||
int main (void)
|
||||
{
|
||||
using namespace std;
|
||||
|
||||
// The memory buffer is implemented using a STL vector :
|
||||
typedef std::vector<char> buffer_type;
|
||||
buffer_type buffer;
|
||||
|
||||
{
|
||||
// Some data to be stored :
|
||||
bool t = true;
|
||||
char c = 'c';
|
||||
int16_t s = +16;
|
||||
int32_t l = -128;
|
||||
int64_t ll = +10000000000;
|
||||
float pi = 3.14159;
|
||||
double nan = numeric_limits<double>::quiet_NaN ();
|
||||
string hello = "World !";
|
||||
|
||||
buffer.reserve (1024); // pre-allocate some memory
|
||||
|
||||
// The output stream interface to the buffer :
|
||||
boost::iostreams::stream<boost::iostreams::back_insert_device<buffer_type> > output_stream (buffer);
|
||||
|
||||
{
|
||||
// Create an output portable binary archive attached to the output file :
|
||||
boost::archive::portable_binary_oarchive opba (output_stream);
|
||||
|
||||
// Store (serialize) variables :
|
||||
opba & t & c & s & l & ll & pi & nan & hello;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
clog << "Buffer content is " << buffer.size () << " bytes : " << endl << " ";
|
||||
for (int i = 0; i < buffer.size (); ++i)
|
||||
{
|
||||
clog << (int) ((unsigned char) buffer[i]) << ' ';
|
||||
if ((i + 1) % 20 == 0) clog << endl << " ";
|
||||
}
|
||||
clog << endl;
|
||||
|
||||
{
|
||||
// Some data to be loaded :
|
||||
bool t;
|
||||
char c;
|
||||
int16_t s;
|
||||
int32_t l;
|
||||
int64_t ll;
|
||||
float pi;
|
||||
double nan;
|
||||
string hello;
|
||||
|
||||
// The input stream interface to the buffer :
|
||||
boost::iostreams::stream<boost::iostreams::array_source> input_stream (&buffer[0],
|
||||
buffer.size ());
|
||||
|
||||
{
|
||||
// Create an input portable binary archive attached to the input file :
|
||||
boost::archive::portable_binary_iarchive ipba (input_stream);
|
||||
|
||||
// Load (de-serialize) variables :
|
||||
ipba & t & c & s & l & ll & pi & nan & hello;
|
||||
}
|
||||
|
||||
clog << "Loaded values from the buffer are: " << endl;
|
||||
clog << " t = " << t << " (bool)" << endl;
|
||||
clog << " c = '" << c << "' (char)" << endl;
|
||||
clog << " s = " << s << " (int16_t)" << endl;
|
||||
clog << " l = " << l << " (int32_t)" << endl;
|
||||
clog << " ll = " << ll << " (int64_t)" << endl;
|
||||
clog << " pi = " << pi << " (float)" << endl;
|
||||
clog << " nan = " << nan << " (double)" << endl;
|
||||
clog << " hello = \"" << hello << "\" (std::string)" << endl;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// end of tutorial_pba_5.cpp
|
||||
|
|
@ -1,112 +0,0 @@
|
|||
/** tutorial_pba_6.cpp
|
||||
*
|
||||
* (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
|
||||
*
|
||||
* Use, modification and distribution is subject to the Boost Software
|
||||
* License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* The intent of this program is to serve as a tutorial for
|
||||
* users of the portable binary archive in the framework of
|
||||
* the Boost/Serialization library.
|
||||
*
|
||||
* This sample program shows how to use a portable binary archive
|
||||
* associated to a memory buffer to copy a non-copyable object.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <sstream>
|
||||
#include <vector>
|
||||
|
||||
#include <boost/utility.hpp>
|
||||
#include <boost/iostreams/stream.hpp>
|
||||
#include <boost/iostreams/device/back_inserter.hpp>
|
||||
#include <boost/iostreams/device/array.hpp>
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/archive/portable_binary_oarchive.hpp>
|
||||
#include <boost/archive/portable_binary_iarchive.hpp>
|
||||
|
||||
using namespace std;
|
||||
|
||||
/* A foo noncopyable class */
|
||||
struct foo : boost::noncopyable
|
||||
{
|
||||
uint32_t status;
|
||||
double value;
|
||||
double special;
|
||||
|
||||
string to_string () const
|
||||
{
|
||||
ostringstream sout;
|
||||
sout << "foo={status=" << status << "; value=" << value << "; special=" << special<< "}";
|
||||
return sout.str();
|
||||
}
|
||||
|
||||
template<class Archive>
|
||||
void serialize (Archive & ar, const unsigned int version)
|
||||
{
|
||||
ar & status;
|
||||
ar & value;
|
||||
ar & special;
|
||||
return;
|
||||
}
|
||||
|
||||
};
|
||||
|
||||
// A templatized copy function for Boost/Serialization equipped classes.
|
||||
// Here we use PBAs associated to a memory buffer :
|
||||
template <class Serializable>
|
||||
void copy (const Serializable & source, Serializable & target)
|
||||
{
|
||||
namespace io = boost::iostreams;
|
||||
namespace ba = boost::archive;
|
||||
if (&source == &target) return; // self-copy guard
|
||||
typedef std::vector<char> buffer_type;
|
||||
buffer_type buffer;
|
||||
buffer.reserve (1024);
|
||||
{
|
||||
io::stream<io::back_insert_device<buffer_type> > output_stream (buffer);
|
||||
ba::portable_binary_oarchive opba (output_stream);
|
||||
opba & source;
|
||||
}
|
||||
{
|
||||
io::stream<io::array_source> input_stream (&buffer[0], buffer.size ());
|
||||
ba::portable_binary_iarchive ipba (input_stream);
|
||||
ipba & target;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
int main (void)
|
||||
{
|
||||
// Some instance of the 'foo' class :
|
||||
foo dummy;
|
||||
dummy.status = 1;
|
||||
dummy.value = 3.14159;
|
||||
dummy.special = numeric_limits<double>::quiet_NaN ();
|
||||
clog << "dummy is : " << dummy.to_string () << endl;
|
||||
|
||||
// Another instance of the 'foo' class :
|
||||
foo clone;
|
||||
|
||||
/* The following instruction is forbidden because foo
|
||||
inherits 'boost::noncopyable' :
|
||||
|
||||
clone = dummy; // this ends in a compilation error.
|
||||
|
||||
*/
|
||||
|
||||
// Anyway, we can use this workaround :
|
||||
copy (dummy, clone);
|
||||
clog << "clone is : " << clone.to_string () << endl;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
// end of tutorial_pba_6.cpp
|
||||
|
|
@ -1,54 +0,0 @@
|
|||
/** tutorial_pba_7.cpp
|
||||
*
|
||||
* (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
|
||||
*
|
||||
* Use, modification and distribution is subject to the Boost Software
|
||||
* License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* The intent of this program is to serve as a tutorial for
|
||||
* users of the portable binary archive in the framework of
|
||||
* the Boost/Serialization library.
|
||||
*
|
||||
* This example shows how the default behaviour of standard
|
||||
* I/O streams does not support the read/write operations of
|
||||
* non-finite floating point values in a portable way.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
#include <sstream>
|
||||
#include <limits>
|
||||
|
||||
using namespace std;
|
||||
|
||||
int main (void)
|
||||
{
|
||||
{
|
||||
float x = numeric_limits<float>::infinity ();
|
||||
double y = numeric_limits<double>::quiet_NaN ();
|
||||
cout.precision (8);
|
||||
cout << "x = " << x << endl;
|
||||
cout.precision (16);
|
||||
cout << "y = " << y << endl;
|
||||
}
|
||||
|
||||
{
|
||||
string input ("inf nan");
|
||||
istringstream iss (input);
|
||||
float x;
|
||||
double y;
|
||||
iss >> x >> y;
|
||||
if (! iss)
|
||||
{
|
||||
cerr << "Cannot read 'x' or 'y' : non finite values are not supported !" << endl;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
// end of tutorial_pba_7.cpp
|
||||
|
|
@ -1,118 +0,0 @@
|
|||
/** tutorial_pba_8.cpp
|
||||
*
|
||||
* (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
|
||||
*
|
||||
* Use, modification and distribution is subject to the Boost Software
|
||||
* License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* The intent of this program is to serve as a tutorial for
|
||||
* users of the portable binary archive in the framework of
|
||||
* the Boost/Serialization library.
|
||||
*
|
||||
* This example shows how to store some variables
|
||||
* of basic types (bool, integer, floating point numbers, STL string)
|
||||
* using the text or XML archive format associated to a
|
||||
* standard output file stream supporting portable non-finite
|
||||
* floating point values.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <string>
|
||||
#include <fstream>
|
||||
#include <limits>
|
||||
#include <locale>
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/archive/xml_oarchive.hpp>
|
||||
#include <boost/archive/text_oarchive.hpp>
|
||||
#include <boost/serialization/nvp.hpp>
|
||||
#include <boost/archive/codecvt_null.hpp>
|
||||
#include <boost/math/special_functions/nonfinite_num_facets.hpp>
|
||||
|
||||
using namespace std;
|
||||
|
||||
void do_text_out (void)
|
||||
{
|
||||
// The name for the example data text file :
|
||||
string filename = "pba_8.txt";
|
||||
|
||||
// Some variables of various primitive types :
|
||||
bool b = true;
|
||||
char c = 'B';
|
||||
uint32_t answer = 42;
|
||||
float value = numeric_limits<float>::infinity ();
|
||||
double precision = numeric_limits<double>::quiet_NaN ();
|
||||
string question = "What makes you think she's a witch?";
|
||||
|
||||
// Open an output file stream :
|
||||
ofstream fout (filename.c_str ());
|
||||
|
||||
// Prepare the output file stream for inf/NaN support :
|
||||
locale default_locale (locale::classic (),
|
||||
new boost::archive::codecvt_null<char>);
|
||||
locale infnan_locale (default_locale,
|
||||
new boost::math::nonfinite_num_put<char>);
|
||||
fout.imbue (infnan_locale);
|
||||
|
||||
{
|
||||
// Create an output text archive attached to the output file :
|
||||
boost::archive::text_oarchive ota (fout, boost::archive::no_codecvt);
|
||||
|
||||
// Store (serializing) variables :
|
||||
ota & b & c & answer & value & precision & question;
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
void do_xml_out (void)
|
||||
{
|
||||
// The name for the example data XML file :
|
||||
string filename = "pba_8.xml";
|
||||
|
||||
// Some variables of various primitive types :
|
||||
bool b = true;
|
||||
char c = 'B';
|
||||
uint32_t answer = 42;
|
||||
float value = numeric_limits<float>::infinity ();
|
||||
double precision = numeric_limits<double>::quiet_NaN ();
|
||||
string question = "What makes you think she's a witch?";
|
||||
|
||||
// Open an output file stream :
|
||||
ofstream fout (filename.c_str ());
|
||||
|
||||
// Prepare the output file stream for inf/NaN support :
|
||||
locale default_locale (locale::classic (),
|
||||
new boost::archive::codecvt_null<char>);
|
||||
locale infnan_locale (default_locale,
|
||||
new boost::math::nonfinite_num_put<char>);
|
||||
fout.imbue (infnan_locale);
|
||||
|
||||
{
|
||||
// Create an output text archive attached to the output file :
|
||||
boost::archive::xml_oarchive oxa (fout, boost::archive::no_codecvt);
|
||||
|
||||
// Store (serializing) variables :
|
||||
oxa & BOOST_SERIALIZATION_NVP(b)
|
||||
& BOOST_SERIALIZATION_NVP(c)
|
||||
& BOOST_SERIALIZATION_NVP(answer)
|
||||
& BOOST_SERIALIZATION_NVP(value)
|
||||
& BOOST_SERIALIZATION_NVP(precision)
|
||||
& BOOST_SERIALIZATION_NVP(question);
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
int main (void)
|
||||
{
|
||||
do_text_out ();
|
||||
do_xml_out ();
|
||||
return 0;
|
||||
}
|
||||
|
||||
// end of tutorial_pba_8.cpp
|
||||
|
|
@ -1,134 +0,0 @@
|
|||
/** tutorial_pba_9.cpp
|
||||
*
|
||||
* (C) Copyright 2011 François Mauger, Christian Pfligersdorffer
|
||||
*
|
||||
* Use, modification and distribution is subject to the Boost Software
|
||||
* License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
* http://www.boost.org/LICENSE_1_0.txt)
|
||||
*
|
||||
*/
|
||||
|
||||
/**
|
||||
* The intent of this program is to serve as a tutorial for
|
||||
* users of the portable binary archive in the framework of
|
||||
* the Boost/Serialization library.
|
||||
*
|
||||
* This example shows how to load some variables of basic
|
||||
* types (bool, char, integer, floating point numbers, STL string)
|
||||
* using the text or XML archive format associated to a
|
||||
* standard file input stream supporting portable non-finite
|
||||
* floating point values.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <string>
|
||||
#include <fstream>
|
||||
#include <limits>
|
||||
#include <locale>
|
||||
|
||||
#include <boost/cstdint.hpp>
|
||||
#include <boost/archive/xml_iarchive.hpp>
|
||||
#include <boost/archive/text_iarchive.hpp>
|
||||
#include <boost/serialization/nvp.hpp>
|
||||
#include <boost/scoped_ptr.hpp>
|
||||
#include <boost/archive/codecvt_null.hpp>
|
||||
#include <boost/math/special_functions/nonfinite_num_facets.hpp>
|
||||
|
||||
using namespace std;
|
||||
|
||||
void do_text_in (void)
|
||||
{
|
||||
// The name for the example data text file :
|
||||
string filename = "pba_8.txt";
|
||||
// Some variables of various primitive types :
|
||||
bool b;
|
||||
char c;
|
||||
uint32_t answer;
|
||||
float value;
|
||||
double precision;
|
||||
string question;
|
||||
|
||||
// Open an input file stream :
|
||||
ifstream fin (filename.c_str ());
|
||||
|
||||
// Prepare the input file stream for inf/NaN support :
|
||||
locale default_locale (locale::classic (),
|
||||
new boost::archive::codecvt_null<char>);
|
||||
locale infnan_locale (default_locale,
|
||||
new boost::math::nonfinite_num_get<char>);
|
||||
fin.imbue (infnan_locale);
|
||||
|
||||
{
|
||||
// Create an input text archive attached to the input file :
|
||||
boost::archive::text_iarchive ita (fin, boost::archive::no_codecvt);
|
||||
|
||||
// Store (serializing) variables :
|
||||
ita & b & c & answer & value & precision & question;
|
||||
}
|
||||
|
||||
clog << "Loaded values from text archive are: " << endl;
|
||||
clog << " b = " << b << endl;
|
||||
clog << " c = '" << c << "'" << endl;
|
||||
clog << " answer = " << answer << endl;
|
||||
clog << " value = " << value << endl;
|
||||
clog << " precision = " << precision << endl;
|
||||
clog << " question = \"" << question << "\"" << endl;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
void do_xml_in (void)
|
||||
{
|
||||
// The name for the example data text file :
|
||||
string filename = "pba_8.xml";
|
||||
|
||||
// Some variables of various primitive types :
|
||||
bool b;
|
||||
char c;
|
||||
uint32_t answer;
|
||||
float value;
|
||||
double precision;
|
||||
string question;
|
||||
|
||||
// Open an input file stream :
|
||||
ifstream fin (filename.c_str ());
|
||||
|
||||
// Prepare the input file stream for inf/NaN support :
|
||||
locale default_locale (locale::classic (),
|
||||
new boost::archive::codecvt_null<char>);
|
||||
locale infnan_locale (default_locale,
|
||||
new boost::math::nonfinite_num_get<char>);
|
||||
fin.imbue (infnan_locale);
|
||||
|
||||
{
|
||||
// Create an output text archive attached to the output file :
|
||||
boost::archive::xml_iarchive ixa (fin, boost::archive::no_codecvt);
|
||||
|
||||
// Store (serializing) variables :
|
||||
ixa & BOOST_SERIALIZATION_NVP(b)
|
||||
& BOOST_SERIALIZATION_NVP(c)
|
||||
& BOOST_SERIALIZATION_NVP(answer)
|
||||
& BOOST_SERIALIZATION_NVP(value)
|
||||
& BOOST_SERIALIZATION_NVP(precision)
|
||||
& BOOST_SERIALIZATION_NVP(question);
|
||||
}
|
||||
|
||||
clog << "Loaded values from XML archive are: " << endl;
|
||||
clog << " b = " << b << endl;
|
||||
clog << " c = '" << c << "'" << endl;
|
||||
clog << " answer = " << answer << endl;
|
||||
clog << " value = " << value << endl;
|
||||
clog << " precision = " << precision << endl;
|
||||
clog << " question = \"" << question << "\"" << endl;
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
int main (void)
|
||||
{
|
||||
do_text_in ();
|
||||
do_xml_in ();
|
||||
return 0;
|
||||
}
|
||||
|
||||
// end of tutorial_pba_9.cpp
|
||||
Binary file not shown.
|
Before Width: | Height: | Size: 6.2 KiB |
Binary file not shown.
|
Before Width: | Height: | Size: 1.3 KiB |
|
|
@ -1,151 +0,0 @@
|
|||
/*!
|
||||
* jQuery JavaScript Library v1.4
|
||||
* http://jquery.com/
|
||||
*
|
||||
* Copyright 2010, John Resig
|
||||
* Dual licensed under the MIT or GPL Version 2 licenses.
|
||||
* http://docs.jquery.com/License
|
||||
*
|
||||
* Includes Sizzle.js
|
||||
* http://sizzlejs.com/
|
||||
* Copyright 2010, The Dojo Foundation
|
||||
* Released under the MIT, BSD, and GPL Licenses.
|
||||
*
|
||||
* Date: Wed Jan 13 15:23:05 2010 -0500
|
||||
*/
|
||||
(function(A,w){function oa(){if(!c.isReady){try{s.documentElement.doScroll("left")}catch(a){setTimeout(oa,1);return}c.ready()}}function La(a,b){b.src?c.ajax({url:b.src,async:false,dataType:"script"}):c.globalEval(b.text||b.textContent||b.innerHTML||"");b.parentNode&&b.parentNode.removeChild(b)}function $(a,b,d,f,e,i){var j=a.length;if(typeof b==="object"){for(var o in b)$(a,o,b[o],f,e,d);return a}if(d!==w){f=!i&&f&&c.isFunction(d);for(o=0;o<j;o++)e(a[o],b,f?d.call(a[o],o,e(a[o],b)):d,i);return a}return j?
|
||||
e(a[0],b):null}function K(){return(new Date).getTime()}function aa(){return false}function ba(){return true}function pa(a,b,d){d[0].type=a;return c.event.handle.apply(b,d)}function qa(a){var b=true,d=[],f=[],e=arguments,i,j,o,p,n,t=c.extend({},c.data(this,"events").live);for(p in t){j=t[p];if(j.live===a.type||j.altLive&&c.inArray(a.type,j.altLive)>-1){i=j.data;i.beforeFilter&&i.beforeFilter[a.type]&&!i.beforeFilter[a.type](a)||f.push(j.selector)}else delete t[p]}i=c(a.target).closest(f,a.currentTarget);
|
||||
n=0;for(l=i.length;n<l;n++)for(p in t){j=t[p];o=i[n].elem;f=null;if(i[n].selector===j.selector){if(j.live==="mouseenter"||j.live==="mouseleave")f=c(a.relatedTarget).closest(j.selector)[0];if(!f||f!==o)d.push({elem:o,fn:j})}}n=0;for(l=d.length;n<l;n++){i=d[n];a.currentTarget=i.elem;a.data=i.fn.data;if(i.fn.apply(i.elem,e)===false){b=false;break}}return b}function ra(a,b){return["live",a,b.replace(/\./g,"`").replace(/ /g,"&")].join(".")}function sa(a){return!a||!a.parentNode||a.parentNode.nodeType===
|
||||
11}function ta(a,b){var d=0;b.each(function(){if(this.nodeName===(a[d]&&a[d].nodeName)){var f=c.data(a[d++]),e=c.data(this,f);if(f=f&&f.events){delete e.handle;e.events={};for(var i in f)for(var j in f[i])c.event.add(this,i,f[i][j],f[i][j].data)}}})}function ua(a,b,d){var f,e,i;if(a.length===1&&typeof a[0]==="string"&&a[0].length<512&&a[0].indexOf("<option")<0){e=true;if(i=c.fragments[a[0]])if(i!==1)f=i}if(!f){b=b&&b[0]?b[0].ownerDocument||b[0]:s;f=b.createDocumentFragment();c.clean(a,b,f,d)}if(e)c.fragments[a[0]]=
|
||||
i?f:1;return{fragment:f,cacheable:e}}function T(a){for(var b=0,d,f;(d=a[b])!=null;b++)if(!c.noData[d.nodeName.toLowerCase()]&&(f=d[H]))delete c.cache[f]}function L(a,b){var d={};c.each(va.concat.apply([],va.slice(0,b)),function(){d[this]=a});return d}function wa(a){return"scrollTo"in a&&a.document?a:a.nodeType===9?a.defaultView||a.parentWindow:false}var c=function(a,b){return new c.fn.init(a,b)},Ma=A.jQuery,Na=A.$,s=A.document,U,Oa=/^[^<]*(<[\w\W]+>)[^>]*$|^#([\w-]+)$/,Pa=/^.[^:#\[\.,]*$/,Qa=/\S/,
|
||||
Ra=/^(\s|\u00A0)+|(\s|\u00A0)+$/g,Sa=/^<(\w+)\s*\/?>(?:<\/\1>)?$/,P=navigator.userAgent,xa=false,Q=[],M,ca=Object.prototype.toString,da=Object.prototype.hasOwnProperty,ea=Array.prototype.push,R=Array.prototype.slice,V=Array.prototype.indexOf;c.fn=c.prototype={init:function(a,b){var d,f;if(!a)return this;if(a.nodeType){this.context=this[0]=a;this.length=1;return this}if(typeof a==="string")if((d=Oa.exec(a))&&(d[1]||!b))if(d[1]){f=b?b.ownerDocument||b:s;if(a=Sa.exec(a))if(c.isPlainObject(b)){a=[s.createElement(a[1])];
|
||||
c.fn.attr.call(a,b,true)}else a=[f.createElement(a[1])];else{a=ua([d[1]],[f]);a=(a.cacheable?a.fragment.cloneNode(true):a.fragment).childNodes}}else{if(b=s.getElementById(d[2])){if(b.id!==d[2])return U.find(a);this.length=1;this[0]=b}this.context=s;this.selector=a;return this}else if(!b&&/^\w+$/.test(a)){this.selector=a;this.context=s;a=s.getElementsByTagName(a)}else return!b||b.jquery?(b||U).find(a):c(b).find(a);else if(c.isFunction(a))return U.ready(a);if(a.selector!==w){this.selector=a.selector;
|
||||
this.context=a.context}return c.isArray(a)?this.setArray(a):c.makeArray(a,this)},selector:"",jquery:"1.4",length:0,size:function(){return this.length},toArray:function(){return R.call(this,0)},get:function(a){return a==null?this.toArray():a<0?this.slice(a)[0]:this[a]},pushStack:function(a,b,d){a=c(a||null);a.prevObject=this;a.context=this.context;if(b==="find")a.selector=this.selector+(this.selector?" ":"")+d;else if(b)a.selector=this.selector+"."+b+"("+d+")";return a},setArray:function(a){this.length=
|
||||
0;ea.apply(this,a);return this},each:function(a,b){return c.each(this,a,b)},ready:function(a){c.bindReady();if(c.isReady)a.call(s,c);else Q&&Q.push(a);return this},eq:function(a){return a===-1?this.slice(a):this.slice(a,+a+1)},first:function(){return this.eq(0)},last:function(){return this.eq(-1)},slice:function(){return this.pushStack(R.apply(this,arguments),"slice",R.call(arguments).join(","))},map:function(a){return this.pushStack(c.map(this,function(b,d){return a.call(b,d,b)}))},end:function(){return this.prevObject||
|
||||
c(null)},push:ea,sort:[].sort,splice:[].splice};c.fn.init.prototype=c.fn;c.extend=c.fn.extend=function(){var a=arguments[0]||{},b=1,d=arguments.length,f=false,e,i,j,o;if(typeof a==="boolean"){f=a;a=arguments[1]||{};b=2}if(typeof a!=="object"&&!c.isFunction(a))a={};if(d===b){a=this;--b}for(;b<d;b++)if((e=arguments[b])!=null)for(i in e){j=a[i];o=e[i];if(a!==o)if(f&&o&&(c.isPlainObject(o)||c.isArray(o))){j=j&&(c.isPlainObject(j)||c.isArray(j))?j:c.isArray(o)?[]:{};a[i]=c.extend(f,j,o)}else if(o!==w)a[i]=
|
||||
o}return a};c.extend({noConflict:function(a){A.$=Na;if(a)A.jQuery=Ma;return c},isReady:false,ready:function(){if(!c.isReady){if(!s.body)return setTimeout(c.ready,13);c.isReady=true;if(Q){for(var a,b=0;a=Q[b++];)a.call(s,c);Q=null}c.fn.triggerHandler&&c(s).triggerHandler("ready")}},bindReady:function(){if(!xa){xa=true;if(s.readyState==="complete")return c.ready();if(s.addEventListener){s.addEventListener("DOMContentLoaded",M,false);A.addEventListener("load",c.ready,false)}else if(s.attachEvent){s.attachEvent("onreadystatechange",
|
||||
M);A.attachEvent("onload",c.ready);var a=false;try{a=A.frameElement==null}catch(b){}s.documentElement.doScroll&&a&&oa()}}},isFunction:function(a){return ca.call(a)==="[object Function]"},isArray:function(a){return ca.call(a)==="[object Array]"},isPlainObject:function(a){if(!a||ca.call(a)!=="[object Object]"||a.nodeType||a.setInterval)return false;if(a.constructor&&!da.call(a,"constructor")&&!da.call(a.constructor.prototype,"isPrototypeOf"))return false;var b;for(b in a);return b===w||da.call(a,b)},
|
||||
isEmptyObject:function(a){for(var b in a)return false;return true},noop:function(){},globalEval:function(a){if(a&&Qa.test(a)){var b=s.getElementsByTagName("head")[0]||s.documentElement,d=s.createElement("script");d.type="text/javascript";if(c.support.scriptEval)d.appendChild(s.createTextNode(a));else d.text=a;b.insertBefore(d,b.firstChild);b.removeChild(d)}},nodeName:function(a,b){return a.nodeName&&a.nodeName.toUpperCase()===b.toUpperCase()},each:function(a,b,d){var f,e=0,i=a.length,j=i===w||c.isFunction(a);
|
||||
if(d)if(j)for(f in a){if(b.apply(a[f],d)===false)break}else for(;e<i;){if(b.apply(a[e++],d)===false)break}else if(j)for(f in a){if(b.call(a[f],f,a[f])===false)break}else for(d=a[0];e<i&&b.call(d,e,d)!==false;d=a[++e]);return a},trim:function(a){return(a||"").replace(Ra,"")},makeArray:function(a,b){b=b||[];if(a!=null)a.length==null||typeof a==="string"||c.isFunction(a)||typeof a!=="function"&&a.setInterval?ea.call(b,a):c.merge(b,a);return b},inArray:function(a,b){if(b.indexOf)return b.indexOf(a);for(var d=
|
||||
0,f=b.length;d<f;d++)if(b[d]===a)return d;return-1},merge:function(a,b){var d=a.length,f=0;if(typeof b.length==="number")for(var e=b.length;f<e;f++)a[d++]=b[f];else for(;b[f]!==w;)a[d++]=b[f++];a.length=d;return a},grep:function(a,b,d){for(var f=[],e=0,i=a.length;e<i;e++)!d!==!b(a[e],e)&&f.push(a[e]);return f},map:function(a,b,d){for(var f=[],e,i=0,j=a.length;i<j;i++){e=b(a[i],i,d);if(e!=null)f[f.length]=e}return f.concat.apply([],f)},guid:1,proxy:function(a,b,d){if(arguments.length===2)if(typeof b===
|
||||
"string"){d=a;a=d[b];b=w}else if(b&&!c.isFunction(b)){d=b;b=w}if(!b&&a)b=function(){return a.apply(d||this,arguments)};if(a)b.guid=a.guid=a.guid||b.guid||c.guid++;return b},uaMatch:function(a){var b={browser:""};a=a.toLowerCase();if(/webkit/.test(a))b={browser:"webkit",version:/webkit[\/ ]([\w.]+)/};else if(/opera/.test(a))b={browser:"opera",version:/version/.test(a)?/version[\/ ]([\w.]+)/:/opera[\/ ]([\w.]+)/};else if(/msie/.test(a))b={browser:"msie",version:/msie ([\w.]+)/};else if(/mozilla/.test(a)&&
|
||||
!/compatible/.test(a))b={browser:"mozilla",version:/rv:([\w.]+)/};b.version=(b.version&&b.version.exec(a)||[0,"0"])[1];return b},browser:{}});P=c.uaMatch(P);if(P.browser){c.browser[P.browser]=true;c.browser.version=P.version}if(c.browser.webkit)c.browser.safari=true;if(V)c.inArray=function(a,b){return V.call(b,a)};U=c(s);if(s.addEventListener)M=function(){s.removeEventListener("DOMContentLoaded",M,false);c.ready()};else if(s.attachEvent)M=function(){if(s.readyState==="complete"){s.detachEvent("onreadystatechange",
|
||||
M);c.ready()}};if(V)c.inArray=function(a,b){return V.call(b,a)};(function(){c.support={};var a=s.documentElement,b=s.createElement("script"),d=s.createElement("div"),f="script"+K();d.style.display="none";d.innerHTML=" <link/><table></table><a href='/a' style='color:red;float:left;opacity:.55;'>a</a><input type='checkbox'/>";var e=d.getElementsByTagName("*"),i=d.getElementsByTagName("a")[0];if(!(!e||!e.length||!i)){c.support={leadingWhitespace:d.firstChild.nodeType===3,tbody:!d.getElementsByTagName("tbody").length,
|
||||
htmlSerialize:!!d.getElementsByTagName("link").length,style:/red/.test(i.getAttribute("style")),hrefNormalized:i.getAttribute("href")==="/a",opacity:/^0.55$/.test(i.style.opacity),cssFloat:!!i.style.cssFloat,checkOn:d.getElementsByTagName("input")[0].value==="on",optSelected:s.createElement("select").appendChild(s.createElement("option")).selected,scriptEval:false,noCloneEvent:true,boxModel:null};b.type="text/javascript";try{b.appendChild(s.createTextNode("window."+f+"=1;"))}catch(j){}a.insertBefore(b,
|
||||
a.firstChild);if(A[f]){c.support.scriptEval=true;delete A[f]}a.removeChild(b);if(d.attachEvent&&d.fireEvent){d.attachEvent("onclick",function o(){c.support.noCloneEvent=false;d.detachEvent("onclick",o)});d.cloneNode(true).fireEvent("onclick")}c(function(){var o=s.createElement("div");o.style.width=o.style.paddingLeft="1px";s.body.appendChild(o);c.boxModel=c.support.boxModel=o.offsetWidth===2;s.body.removeChild(o).style.display="none"});a=function(o){var p=s.createElement("div");o="on"+o;var n=o in
|
||||
p;if(!n){p.setAttribute(o,"return;");n=typeof p[o]==="function"}return n};c.support.submitBubbles=a("submit");c.support.changeBubbles=a("change");a=b=d=e=i=null}})();c.props={"for":"htmlFor","class":"className",readonly:"readOnly",maxlength:"maxLength",cellspacing:"cellSpacing",rowspan:"rowSpan",colspan:"colSpan",tabindex:"tabIndex",usemap:"useMap",frameborder:"frameBorder"};var H="jQuery"+K(),Ta=0,ya={},Ua={};c.extend({cache:{},expando:H,noData:{embed:true,object:true,applet:true},data:function(a,
|
||||
b,d){if(!(a.nodeName&&c.noData[a.nodeName.toLowerCase()])){a=a==A?ya:a;var f=a[H],e=c.cache;if(!b&&!f)return null;f||(f=++Ta);if(typeof b==="object"){a[H]=f;e=e[f]=c.extend(true,{},b)}else e=e[f]?e[f]:typeof d==="undefined"?Ua:(e[f]={});if(d!==w){a[H]=f;e[b]=d}return typeof b==="string"?e[b]:e}},removeData:function(a,b){if(!(a.nodeName&&c.noData[a.nodeName.toLowerCase()])){a=a==A?ya:a;var d=a[H],f=c.cache,e=f[d];if(b){if(e){delete e[b];c.isEmptyObject(e)&&c.removeData(a)}}else{try{delete a[H]}catch(i){a.removeAttribute&&
|
||||
a.removeAttribute(H)}delete f[d]}}}});c.fn.extend({data:function(a,b){if(typeof a==="undefined"&&this.length)return c.data(this[0]);else if(typeof a==="object")return this.each(function(){c.data(this,a)});var d=a.split(".");d[1]=d[1]?"."+d[1]:"";if(b===w){var f=this.triggerHandler("getData"+d[1]+"!",[d[0]]);if(f===w&&this.length)f=c.data(this[0],a);return f===w&&d[1]?this.data(d[0]):f}else return this.trigger("setData"+d[1]+"!",[d[0],b]).each(function(){c.data(this,a,b)})},removeData:function(a){return this.each(function(){c.removeData(this,
|
||||
a)})}});c.extend({queue:function(a,b,d){if(a){b=(b||"fx")+"queue";var f=c.data(a,b);if(!d)return f||[];if(!f||c.isArray(d))f=c.data(a,b,c.makeArray(d));else f.push(d);return f}},dequeue:function(a,b){b=b||"fx";var d=c.queue(a,b),f=d.shift();if(f==="inprogress")f=d.shift();if(f){b==="fx"&&d.unshift("inprogress");f.call(a,function(){c.dequeue(a,b)})}}});c.fn.extend({queue:function(a,b){if(typeof a!=="string"){b=a;a="fx"}if(b===w)return c.queue(this[0],a);return this.each(function(){var d=c.queue(this,
|
||||
a,b);a==="fx"&&d[0]!=="inprogress"&&c.dequeue(this,a)})},dequeue:function(a){return this.each(function(){c.dequeue(this,a)})},delay:function(a,b){a=c.fx?c.fx.speeds[a]||a:a;b=b||"fx";return this.queue(b,function(){var d=this;setTimeout(function(){c.dequeue(d,b)},a)})},clearQueue:function(a){return this.queue(a||"fx",[])}});var za=/[\n\t]/g,fa=/\s+/,Va=/\r/g,Wa=/href|src|style/,Xa=/(button|input)/i,Ya=/(button|input|object|select|textarea)/i,Za=/^(a|area)$/i,Aa=/radio|checkbox/;c.fn.extend({attr:function(a,
|
||||
b){return $(this,a,b,true,c.attr)},removeAttr:function(a){return this.each(function(){c.attr(this,a,"");this.nodeType===1&&this.removeAttribute(a)})},addClass:function(a){if(c.isFunction(a))return this.each(function(p){var n=c(this);n.addClass(a.call(this,p,n.attr("class")))});if(a&&typeof a==="string")for(var b=(a||"").split(fa),d=0,f=this.length;d<f;d++){var e=this[d];if(e.nodeType===1)if(e.className)for(var i=" "+e.className+" ",j=0,o=b.length;j<o;j++){if(i.indexOf(" "+b[j]+" ")<0)e.className+=
|
||||
" "+b[j]}else e.className=a}return this},removeClass:function(a){if(c.isFunction(a))return this.each(function(p){var n=c(this);n.removeClass(a.call(this,p,n.attr("class")))});if(a&&typeof a==="string"||a===w)for(var b=(a||"").split(fa),d=0,f=this.length;d<f;d++){var e=this[d];if(e.nodeType===1&&e.className)if(a){for(var i=(" "+e.className+" ").replace(za," "),j=0,o=b.length;j<o;j++)i=i.replace(" "+b[j]+" "," ");e.className=i.substring(1,i.length-1)}else e.className=""}return this},toggleClass:function(a,
|
||||
b){var d=typeof a,f=typeof b==="boolean";if(c.isFunction(a))return this.each(function(e){var i=c(this);i.toggleClass(a.call(this,e,i.attr("class"),b),b)});return this.each(function(){if(d==="string")for(var e,i=0,j=c(this),o=b,p=a.split(fa);e=p[i++];){o=f?o:!j.hasClass(e);j[o?"addClass":"removeClass"](e)}else if(d==="undefined"||d==="boolean"){this.className&&c.data(this,"__className__",this.className);this.className=this.className||a===false?"":c.data(this,"__className__")||""}})},hasClass:function(a){a=
|
||||
" "+a+" ";for(var b=0,d=this.length;b<d;b++)if((" "+this[b].className+" ").replace(za," ").indexOf(a)>-1)return true;return false},val:function(a){if(a===w){var b=this[0];if(b){if(c.nodeName(b,"option"))return(b.attributes.value||{}).specified?b.value:b.text;if(c.nodeName(b,"select")){var d=b.selectedIndex,f=[],e=b.options;b=b.type==="select-one";if(d<0)return null;var i=b?d:0;for(d=b?d+1:e.length;i<d;i++){var j=e[i];if(j.selected){a=c(j).val();if(b)return a;f.push(a)}}return f}if(Aa.test(b.type)&&
|
||||
!c.support.checkOn)return b.getAttribute("value")===null?"on":b.value;return(b.value||"").replace(Va,"")}return w}var o=c.isFunction(a);return this.each(function(p){var n=c(this),t=a;if(this.nodeType===1){if(o)t=a.call(this,p,n.val());if(typeof t==="number")t+="";if(c.isArray(t)&&Aa.test(this.type))this.checked=c.inArray(n.val(),t)>=0;else if(c.nodeName(this,"select")){var z=c.makeArray(t);c("option",this).each(function(){this.selected=c.inArray(c(this).val(),z)>=0});if(!z.length)this.selectedIndex=
|
||||
-1}else this.value=t}})}});c.extend({attrFn:{val:true,css:true,html:true,text:true,data:true,width:true,height:true,offset:true},attr:function(a,b,d,f){if(!a||a.nodeType===3||a.nodeType===8)return w;if(f&&b in c.attrFn)return c(a)[b](d);f=a.nodeType!==1||!c.isXMLDoc(a);var e=d!==w;b=f&&c.props[b]||b;if(a.nodeType===1){var i=Wa.test(b);if(b in a&&f&&!i){if(e){if(b==="type"&&Xa.test(a.nodeName)&&a.parentNode)throw"type property can't be changed";a[b]=d}if(c.nodeName(a,"form")&&a.getAttributeNode(b))return a.getAttributeNode(b).nodeValue;
|
||||
if(b==="tabIndex")return(b=a.getAttributeNode("tabIndex"))&&b.specified?b.value:Ya.test(a.nodeName)||Za.test(a.nodeName)&&a.href?0:w;return a[b]}if(!c.support.style&&f&&b==="style"){if(e)a.style.cssText=""+d;return a.style.cssText}e&&a.setAttribute(b,""+d);a=!c.support.hrefNormalized&&f&&i?a.getAttribute(b,2):a.getAttribute(b);return a===null?w:a}return c.style(a,b,d)}});var $a=function(a){return a.replace(/[^\w\s\.\|`]/g,function(b){return"\\"+b})};c.event={add:function(a,b,d,f){if(!(a.nodeType===
|
||||
3||a.nodeType===8)){if(a.setInterval&&a!==A&&!a.frameElement)a=A;if(!d.guid)d.guid=c.guid++;if(f!==w){d=c.proxy(d);d.data=f}var e=c.data(a,"events")||c.data(a,"events",{}),i=c.data(a,"handle"),j;if(!i){j=function(){return typeof c!=="undefined"&&!c.event.triggered?c.event.handle.apply(j.elem,arguments):w};i=c.data(a,"handle",j)}if(i){i.elem=a;b=b.split(/\s+/);for(var o,p=0;o=b[p++];){var n=o.split(".");o=n.shift();d.type=n.slice(0).sort().join(".");var t=e[o],z=this.special[o]||{};if(!t){t=e[o]={};
|
||||
if(!z.setup||z.setup.call(a,f,n,d)===false)if(a.addEventListener)a.addEventListener(o,i,false);else a.attachEvent&&a.attachEvent("on"+o,i)}if(z.add)if((n=z.add.call(a,d,f,n,t))&&c.isFunction(n)){n.guid=n.guid||d.guid;d=n}t[d.guid]=d;this.global[o]=true}a=null}}},global:{},remove:function(a,b,d){if(!(a.nodeType===3||a.nodeType===8)){var f=c.data(a,"events"),e,i,j;if(f){if(b===w||typeof b==="string"&&b.charAt(0)===".")for(i in f)this.remove(a,i+(b||""));else{if(b.type){d=b.handler;b=b.type}b=b.split(/\s+/);
|
||||
for(var o=0;i=b[o++];){var p=i.split(".");i=p.shift();var n=!p.length,t=c.map(p.slice(0).sort(),$a);t=new RegExp("(^|\\.)"+t.join("\\.(?:.*\\.)?")+"(\\.|$)");var z=this.special[i]||{};if(f[i]){if(d){j=f[i][d.guid];delete f[i][d.guid]}else for(var B in f[i])if(n||t.test(f[i][B].type))delete f[i][B];z.remove&&z.remove.call(a,p,j);for(e in f[i])break;if(!e){if(!z.teardown||z.teardown.call(a,p)===false)if(a.removeEventListener)a.removeEventListener(i,c.data(a,"handle"),false);else a.detachEvent&&a.detachEvent("on"+
|
||||
i,c.data(a,"handle"));e=null;delete f[i]}}}}for(e in f)break;if(!e){if(B=c.data(a,"handle"))B.elem=null;c.removeData(a,"events");c.removeData(a,"handle")}}}},trigger:function(a,b,d,f){var e=a.type||a;if(!f){a=typeof a==="object"?a[H]?a:c.extend(c.Event(e),a):c.Event(e);if(e.indexOf("!")>=0){a.type=e=e.slice(0,-1);a.exclusive=true}if(!d){a.stopPropagation();this.global[e]&&c.each(c.cache,function(){this.events&&this.events[e]&&c.event.trigger(a,b,this.handle.elem)})}if(!d||d.nodeType===3||d.nodeType===
|
||||
8)return w;a.result=w;a.target=d;b=c.makeArray(b);b.unshift(a)}a.currentTarget=d;var i=c.data(d,"handle");i&&i.apply(d,b);var j,o;try{if(!(d&&d.nodeName&&c.noData[d.nodeName.toLowerCase()])){j=d[e];o=d["on"+e]}}catch(p){}i=c.nodeName(d,"a")&&e==="click";if(!f&&j&&!a.isDefaultPrevented()&&!i){this.triggered=true;try{d[e]()}catch(n){}}else if(o&&d["on"+e].apply(d,b)===false)a.result=false;this.triggered=false;if(!a.isPropagationStopped())(d=d.parentNode||d.ownerDocument)&&c.event.trigger(a,b,d,true)},
|
||||
handle:function(a){var b,d;a=arguments[0]=c.event.fix(a||A.event);a.currentTarget=this;d=a.type.split(".");a.type=d.shift();b=!d.length&&!a.exclusive;var f=new RegExp("(^|\\.)"+d.slice(0).sort().join("\\.(?:.*\\.)?")+"(\\.|$)");d=(c.data(this,"events")||{})[a.type];for(var e in d){var i=d[e];if(b||f.test(i.type)){a.handler=i;a.data=i.data;i=i.apply(this,arguments);if(i!==w){a.result=i;if(i===false){a.preventDefault();a.stopPropagation()}}if(a.isImmediatePropagationStopped())break}}return a.result},
|
||||
props:"altKey attrChange attrName bubbles button cancelable charCode clientX clientY ctrlKey currentTarget data detail eventPhase fromElement handler keyCode layerX layerY metaKey newValue offsetX offsetY originalTarget pageX pageY prevValue relatedNode relatedTarget screenX screenY shiftKey srcElement target toElement view wheelDelta which".split(" "),fix:function(a){if(a[H])return a;var b=a;a=c.Event(b);for(var d=this.props.length,f;d;){f=this.props[--d];a[f]=b[f]}if(!a.target)a.target=a.srcElement||
|
||||
s;if(a.target.nodeType===3)a.target=a.target.parentNode;if(!a.relatedTarget&&a.fromElement)a.relatedTarget=a.fromElement===a.target?a.toElement:a.fromElement;if(a.pageX==null&&a.clientX!=null){b=s.documentElement;d=s.body;a.pageX=a.clientX+(b&&b.scrollLeft||d&&d.scrollLeft||0)-(b&&b.clientLeft||d&&d.clientLeft||0);a.pageY=a.clientY+(b&&b.scrollTop||d&&d.scrollTop||0)-(b&&b.clientTop||d&&d.clientTop||0)}if(!a.which&&(a.charCode||a.charCode===0?a.charCode:a.keyCode))a.which=a.charCode||a.keyCode;if(!a.metaKey&&
|
||||
a.ctrlKey)a.metaKey=a.ctrlKey;if(!a.which&&a.button!==w)a.which=a.button&1?1:a.button&2?3:a.button&4?2:0;return a},guid:1E8,proxy:c.proxy,special:{ready:{setup:c.bindReady,teardown:c.noop},live:{add:function(a,b){c.extend(a,b||{});a.guid+=b.selector+b.live;c.event.add(this,b.live,qa,b)},remove:function(a){if(a.length){var b=0,d=new RegExp("(^|\\.)"+a[0]+"(\\.|$)");c.each(c.data(this,"events").live||{},function(){d.test(this.type)&&b++});b<1&&c.event.remove(this,a[0],qa)}},special:{}},beforeunload:{setup:function(a,
|
||||
b,d){if(this.setInterval)this.onbeforeunload=d;return false},teardown:function(a,b){if(this.onbeforeunload===b)this.onbeforeunload=null}}}};c.Event=function(a){if(!this.preventDefault)return new c.Event(a);if(a&&a.type){this.originalEvent=a;this.type=a.type}else this.type=a;this.timeStamp=K();this[H]=true};c.Event.prototype={preventDefault:function(){this.isDefaultPrevented=ba;var a=this.originalEvent;if(a){a.preventDefault&&a.preventDefault();a.returnValue=false}},stopPropagation:function(){this.isPropagationStopped=
|
||||
ba;var a=this.originalEvent;if(a){a.stopPropagation&&a.stopPropagation();a.cancelBubble=true}},stopImmediatePropagation:function(){this.isImmediatePropagationStopped=ba;this.stopPropagation()},isDefaultPrevented:aa,isPropagationStopped:aa,isImmediatePropagationStopped:aa};var Ba=function(a){for(var b=a.relatedTarget;b&&b!==this;)try{b=b.parentNode}catch(d){break}if(b!==this){a.type=a.data;c.event.handle.apply(this,arguments)}},Ca=function(a){a.type=a.data;c.event.handle.apply(this,arguments)};c.each({mouseenter:"mouseover",
|
||||
mouseleave:"mouseout"},function(a,b){c.event.special[a]={setup:function(d){c.event.add(this,b,d&&d.selector?Ca:Ba,a)},teardown:function(d){c.event.remove(this,b,d&&d.selector?Ca:Ba)}}});if(!c.support.submitBubbles)c.event.special.submit={setup:function(a,b,d){if(this.nodeName.toLowerCase()!=="form"){c.event.add(this,"click.specialSubmit."+d.guid,function(f){var e=f.target,i=e.type;if((i==="submit"||i==="image")&&c(e).closest("form").length)return pa("submit",this,arguments)});c.event.add(this,"keypress.specialSubmit."+
|
||||
d.guid,function(f){var e=f.target,i=e.type;if((i==="text"||i==="password")&&c(e).closest("form").length&&f.keyCode===13)return pa("submit",this,arguments)})}else return false},remove:function(a,b){c.event.remove(this,"click.specialSubmit"+(b?"."+b.guid:""));c.event.remove(this,"keypress.specialSubmit"+(b?"."+b.guid:""))}};if(!c.support.changeBubbles){var ga=/textarea|input|select/i;function Da(a){var b=a.type,d=a.value;if(b==="radio"||b==="checkbox")d=a.checked;else if(b==="select-multiple")d=a.selectedIndex>
|
||||
-1?c.map(a.options,function(f){return f.selected}).join("-"):"";else if(a.nodeName.toLowerCase()==="select")d=a.selectedIndex;return d}function ha(a,b){var d=a.target,f,e;if(!(!ga.test(d.nodeName)||d.readOnly)){f=c.data(d,"_change_data");e=Da(d);if(e!==f){if(a.type!=="focusout"||d.type!=="radio")c.data(d,"_change_data",e);if(d.type!=="select"&&(f!=null||e)){a.type="change";return c.event.trigger(a,b,this)}}}}c.event.special.change={filters:{focusout:ha,click:function(a){var b=a.target,d=b.type;if(d===
|
||||
"radio"||d==="checkbox"||b.nodeName.toLowerCase()==="select")return ha.call(this,a)},keydown:function(a){var b=a.target,d=b.type;if(a.keyCode===13&&b.nodeName.toLowerCase()!=="textarea"||a.keyCode===32&&(d==="checkbox"||d==="radio")||d==="select-multiple")return ha.call(this,a)},beforeactivate:function(a){a=a.target;a.nodeName.toLowerCase()==="input"&&a.type==="radio"&&c.data(a,"_change_data",Da(a))}},setup:function(a,b,d){for(var f in W)c.event.add(this,f+".specialChange."+d.guid,W[f]);return ga.test(this.nodeName)},
|
||||
remove:function(a,b){for(var d in W)c.event.remove(this,d+".specialChange"+(b?"."+b.guid:""),W[d]);return ga.test(this.nodeName)}};var W=c.event.special.change.filters}s.addEventListener&&c.each({focus:"focusin",blur:"focusout"},function(a,b){function d(f){f=c.event.fix(f);f.type=b;return c.event.handle.call(this,f)}c.event.special[b]={setup:function(){this.addEventListener(a,d,true)},teardown:function(){this.removeEventListener(a,d,true)}}});c.each(["bind","one"],function(a,b){c.fn[b]=function(d,
|
||||
f,e){if(typeof d==="object"){for(var i in d)this[b](i,f,d[i],e);return this}if(c.isFunction(f)){thisObject=e;e=f;f=w}var j=b==="one"?c.proxy(e,function(o){c(this).unbind(o,j);return e.apply(this,arguments)}):e;return d==="unload"&&b!=="one"?this.one(d,f,e,thisObject):this.each(function(){c.event.add(this,d,j,f)})}});c.fn.extend({unbind:function(a,b){if(typeof a==="object"&&!a.preventDefault){for(var d in a)this.unbind(d,a[d]);return this}return this.each(function(){c.event.remove(this,a,b)})},trigger:function(a,
|
||||
b){return this.each(function(){c.event.trigger(a,b,this)})},triggerHandler:function(a,b){if(this[0]){a=c.Event(a);a.preventDefault();a.stopPropagation();c.event.trigger(a,b,this[0]);return a.result}},toggle:function(a){for(var b=arguments,d=1;d<b.length;)c.proxy(a,b[d++]);return this.click(c.proxy(a,function(f){var e=(c.data(this,"lastToggle"+a.guid)||0)%d;c.data(this,"lastToggle"+a.guid,e+1);f.preventDefault();return b[e].apply(this,arguments)||false}))},hover:function(a,b){return this.mouseenter(a).mouseleave(b||
|
||||
a)},live:function(a,b,d){if(c.isFunction(b)){d=b;b=w}c(this.context).bind(ra(a,this.selector),{data:b,selector:this.selector,live:a},d);return this},die:function(a,b){c(this.context).unbind(ra(a,this.selector),b?{guid:b.guid+this.selector+a}:null);return this}});c.each("blur focus focusin focusout load resize scroll unload click dblclick mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave change select submit keydown keypress keyup error".split(" "),function(a,b){c.fn[b]=function(d){return d?
|
||||
this.bind(b,d):this.trigger(b)};if(c.attrFn)c.attrFn[b]=true});A.attachEvent&&!A.addEventListener&&A.attachEvent("onunload",function(){for(var a in c.cache)if(c.cache[a].handle)try{c.event.remove(c.cache[a].handle.elem)}catch(b){}});(function(){function a(g){for(var h="",k,m=0;g[m];m++){k=g[m];if(k.nodeType===3||k.nodeType===4)h+=k.nodeValue;else if(k.nodeType!==8)h+=a(k.childNodes)}return h}function b(g,h,k,m,r,q){r=0;for(var v=m.length;r<v;r++){var u=m[r];if(u){u=u[g];for(var y=false;u;){if(u.sizcache===
|
||||
k){y=m[u.sizset];break}if(u.nodeType===1&&!q){u.sizcache=k;u.sizset=r}if(u.nodeName.toLowerCase()===h){y=u;break}u=u[g]}m[r]=y}}}function d(g,h,k,m,r,q){r=0;for(var v=m.length;r<v;r++){var u=m[r];if(u){u=u[g];for(var y=false;u;){if(u.sizcache===k){y=m[u.sizset];break}if(u.nodeType===1){if(!q){u.sizcache=k;u.sizset=r}if(typeof h!=="string"){if(u===h){y=true;break}}else if(p.filter(h,[u]).length>0){y=u;break}}u=u[g]}m[r]=y}}}var f=/((?:\((?:\([^()]+\)|[^()]+)+\)|\[(?:\[[^[\]]*\]|['"][^'"]*['"]|[^[\]'"]+)+\]|\\.|[^ >+~,(\[\\]+)+|[>+~])(\s*,\s*)?((?:.|\r|\n)*)/g,
|
||||
e=0,i=Object.prototype.toString,j=false,o=true;[0,0].sort(function(){o=false;return 0});var p=function(g,h,k,m){k=k||[];var r=h=h||s;if(h.nodeType!==1&&h.nodeType!==9)return[];if(!g||typeof g!=="string")return k;for(var q=[],v,u,y,S,I=true,N=x(h),J=g;(f.exec(""),v=f.exec(J))!==null;){J=v[3];q.push(v[1]);if(v[2]){S=v[3];break}}if(q.length>1&&t.exec(g))if(q.length===2&&n.relative[q[0]])u=ia(q[0]+q[1],h);else for(u=n.relative[q[0]]?[h]:p(q.shift(),h);q.length;){g=q.shift();if(n.relative[g])g+=q.shift();
|
||||
u=ia(g,u)}else{if(!m&&q.length>1&&h.nodeType===9&&!N&&n.match.ID.test(q[0])&&!n.match.ID.test(q[q.length-1])){v=p.find(q.shift(),h,N);h=v.expr?p.filter(v.expr,v.set)[0]:v.set[0]}if(h){v=m?{expr:q.pop(),set:B(m)}:p.find(q.pop(),q.length===1&&(q[0]==="~"||q[0]==="+")&&h.parentNode?h.parentNode:h,N);u=v.expr?p.filter(v.expr,v.set):v.set;if(q.length>0)y=B(u);else I=false;for(;q.length;){var E=q.pop();v=E;if(n.relative[E])v=q.pop();else E="";if(v==null)v=h;n.relative[E](y,v,N)}}else y=[]}y||(y=u);if(!y)throw"Syntax error, unrecognized expression: "+
|
||||
(E||g);if(i.call(y)==="[object Array]")if(I)if(h&&h.nodeType===1)for(g=0;y[g]!=null;g++){if(y[g]&&(y[g]===true||y[g].nodeType===1&&F(h,y[g])))k.push(u[g])}else for(g=0;y[g]!=null;g++)y[g]&&y[g].nodeType===1&&k.push(u[g]);else k.push.apply(k,y);else B(y,k);if(S){p(S,r,k,m);p.uniqueSort(k)}return k};p.uniqueSort=function(g){if(D){j=o;g.sort(D);if(j)for(var h=1;h<g.length;h++)g[h]===g[h-1]&&g.splice(h--,1)}return g};p.matches=function(g,h){return p(g,null,null,h)};p.find=function(g,h,k){var m,r;if(!g)return[];
|
||||
for(var q=0,v=n.order.length;q<v;q++){var u=n.order[q];if(r=n.leftMatch[u].exec(g)){var y=r[1];r.splice(1,1);if(y.substr(y.length-1)!=="\\"){r[1]=(r[1]||"").replace(/\\/g,"");m=n.find[u](r,h,k);if(m!=null){g=g.replace(n.match[u],"");break}}}}m||(m=h.getElementsByTagName("*"));return{set:m,expr:g}};p.filter=function(g,h,k,m){for(var r=g,q=[],v=h,u,y,S=h&&h[0]&&x(h[0]);g&&h.length;){for(var I in n.filter)if((u=n.leftMatch[I].exec(g))!=null&&u[2]){var N=n.filter[I],J,E;E=u[1];y=false;u.splice(1,1);if(E.substr(E.length-
|
||||
1)!=="\\"){if(v===q)q=[];if(n.preFilter[I])if(u=n.preFilter[I](u,v,k,q,m,S)){if(u===true)continue}else y=J=true;if(u)for(var X=0;(E=v[X])!=null;X++)if(E){J=N(E,u,X,v);var Ea=m^!!J;if(k&&J!=null)if(Ea)y=true;else v[X]=false;else if(Ea){q.push(E);y=true}}if(J!==w){k||(v=q);g=g.replace(n.match[I],"");if(!y)return[];break}}}if(g===r)if(y==null)throw"Syntax error, unrecognized expression: "+g;else break;r=g}return v};var n=p.selectors={order:["ID","NAME","TAG"],match:{ID:/#((?:[\w\u00c0-\uFFFF-]|\\.)+)/,
|
||||
CLASS:/\.((?:[\w\u00c0-\uFFFF-]|\\.)+)/,NAME:/\[name=['"]*((?:[\w\u00c0-\uFFFF-]|\\.)+)['"]*\]/,ATTR:/\[\s*((?:[\w\u00c0-\uFFFF-]|\\.)+)\s*(?:(\S?=)\s*(['"]*)(.*?)\3|)\s*\]/,TAG:/^((?:[\w\u00c0-\uFFFF\*-]|\\.)+)/,CHILD:/:(only|nth|last|first)-child(?:\((even|odd|[\dn+-]*)\))?/,POS:/:(nth|eq|gt|lt|first|last|even|odd)(?:\((\d*)\))?(?=[^-]|$)/,PSEUDO:/:((?:[\w\u00c0-\uFFFF-]|\\.)+)(?:\((['"]?)((?:\([^\)]+\)|[^\(\)]*)+)\2\))?/},leftMatch:{},attrMap:{"class":"className","for":"htmlFor"},attrHandle:{href:function(g){return g.getAttribute("href")}},
|
||||
relative:{"+":function(g,h){var k=typeof h==="string",m=k&&!/\W/.test(h);k=k&&!m;if(m)h=h.toLowerCase();m=0;for(var r=g.length,q;m<r;m++)if(q=g[m]){for(;(q=q.previousSibling)&&q.nodeType!==1;);g[m]=k||q&&q.nodeName.toLowerCase()===h?q||false:q===h}k&&p.filter(h,g,true)},">":function(g,h){var k=typeof h==="string";if(k&&!/\W/.test(h)){h=h.toLowerCase();for(var m=0,r=g.length;m<r;m++){var q=g[m];if(q){k=q.parentNode;g[m]=k.nodeName.toLowerCase()===h?k:false}}}else{m=0;for(r=g.length;m<r;m++)if(q=g[m])g[m]=
|
||||
k?q.parentNode:q.parentNode===h;k&&p.filter(h,g,true)}},"":function(g,h,k){var m=e++,r=d;if(typeof h==="string"&&!/\W/.test(h)){var q=h=h.toLowerCase();r=b}r("parentNode",h,m,g,q,k)},"~":function(g,h,k){var m=e++,r=d;if(typeof h==="string"&&!/\W/.test(h)){var q=h=h.toLowerCase();r=b}r("previousSibling",h,m,g,q,k)}},find:{ID:function(g,h,k){if(typeof h.getElementById!=="undefined"&&!k)return(g=h.getElementById(g[1]))?[g]:[]},NAME:function(g,h){if(typeof h.getElementsByName!=="undefined"){var k=[];
|
||||
h=h.getElementsByName(g[1]);for(var m=0,r=h.length;m<r;m++)h[m].getAttribute("name")===g[1]&&k.push(h[m]);return k.length===0?null:k}},TAG:function(g,h){return h.getElementsByTagName(g[1])}},preFilter:{CLASS:function(g,h,k,m,r,q){g=" "+g[1].replace(/\\/g,"")+" ";if(q)return g;q=0;for(var v;(v=h[q])!=null;q++)if(v)if(r^(v.className&&(" "+v.className+" ").replace(/[\t\n]/g," ").indexOf(g)>=0))k||m.push(v);else if(k)h[q]=false;return false},ID:function(g){return g[1].replace(/\\/g,"")},TAG:function(g){return g[1].toLowerCase()},
|
||||
CHILD:function(g){if(g[1]==="nth"){var h=/(-?)(\d*)n((?:\+|-)?\d*)/.exec(g[2]==="even"&&"2n"||g[2]==="odd"&&"2n+1"||!/\D/.test(g[2])&&"0n+"+g[2]||g[2]);g[2]=h[1]+(h[2]||1)-0;g[3]=h[3]-0}g[0]=e++;return g},ATTR:function(g,h,k,m,r,q){h=g[1].replace(/\\/g,"");if(!q&&n.attrMap[h])g[1]=n.attrMap[h];if(g[2]==="~=")g[4]=" "+g[4]+" ";return g},PSEUDO:function(g,h,k,m,r){if(g[1]==="not")if((f.exec(g[3])||"").length>1||/^\w/.test(g[3]))g[3]=p(g[3],null,null,h);else{g=p.filter(g[3],h,k,true^r);k||m.push.apply(m,
|
||||
g);return false}else if(n.match.POS.test(g[0])||n.match.CHILD.test(g[0]))return true;return g},POS:function(g){g.unshift(true);return g}},filters:{enabled:function(g){return g.disabled===false&&g.type!=="hidden"},disabled:function(g){return g.disabled===true},checked:function(g){return g.checked===true},selected:function(g){return g.selected===true},parent:function(g){return!!g.firstChild},empty:function(g){return!g.firstChild},has:function(g,h,k){return!!p(k[3],g).length},header:function(g){return/h\d/i.test(g.nodeName)},
|
||||
text:function(g){return"text"===g.type},radio:function(g){return"radio"===g.type},checkbox:function(g){return"checkbox"===g.type},file:function(g){return"file"===g.type},password:function(g){return"password"===g.type},submit:function(g){return"submit"===g.type},image:function(g){return"image"===g.type},reset:function(g){return"reset"===g.type},button:function(g){return"button"===g.type||g.nodeName.toLowerCase()==="button"},input:function(g){return/input|select|textarea|button/i.test(g.nodeName)}},
|
||||
setFilters:{first:function(g,h){return h===0},last:function(g,h,k,m){return h===m.length-1},even:function(g,h){return h%2===0},odd:function(g,h){return h%2===1},lt:function(g,h,k){return h<k[3]-0},gt:function(g,h,k){return h>k[3]-0},nth:function(g,h,k){return k[3]-0===h},eq:function(g,h,k){return k[3]-0===h}},filter:{PSEUDO:function(g,h,k,m){var r=h[1],q=n.filters[r];if(q)return q(g,k,h,m);else if(r==="contains")return(g.textContent||g.innerText||a([g])||"").indexOf(h[3])>=0;else if(r==="not"){h=
|
||||
h[3];k=0;for(m=h.length;k<m;k++)if(h[k]===g)return false;return true}else throw"Syntax error, unrecognized expression: "+r;},CHILD:function(g,h){var k=h[1],m=g;switch(k){case "only":case "first":for(;m=m.previousSibling;)if(m.nodeType===1)return false;if(k==="first")return true;m=g;case "last":for(;m=m.nextSibling;)if(m.nodeType===1)return false;return true;case "nth":k=h[2];var r=h[3];if(k===1&&r===0)return true;h=h[0];var q=g.parentNode;if(q&&(q.sizcache!==h||!g.nodeIndex)){var v=0;for(m=q.firstChild;m;m=
|
||||
m.nextSibling)if(m.nodeType===1)m.nodeIndex=++v;q.sizcache=h}g=g.nodeIndex-r;return k===0?g===0:g%k===0&&g/k>=0}},ID:function(g,h){return g.nodeType===1&&g.getAttribute("id")===h},TAG:function(g,h){return h==="*"&&g.nodeType===1||g.nodeName.toLowerCase()===h},CLASS:function(g,h){return(" "+(g.className||g.getAttribute("class"))+" ").indexOf(h)>-1},ATTR:function(g,h){var k=h[1];g=n.attrHandle[k]?n.attrHandle[k](g):g[k]!=null?g[k]:g.getAttribute(k);k=g+"";var m=h[2];h=h[4];return g==null?m==="!=":m===
|
||||
"="?k===h:m==="*="?k.indexOf(h)>=0:m==="~="?(" "+k+" ").indexOf(h)>=0:!h?k&&g!==false:m==="!="?k!==h:m==="^="?k.indexOf(h)===0:m==="$="?k.substr(k.length-h.length)===h:m==="|="?k===h||k.substr(0,h.length+1)===h+"-":false},POS:function(g,h,k,m){var r=n.setFilters[h[2]];if(r)return r(g,k,h,m)}}},t=n.match.POS;for(var z in n.match){n.match[z]=new RegExp(n.match[z].source+/(?![^\[]*\])(?![^\(]*\))/.source);n.leftMatch[z]=new RegExp(/(^(?:.|\r|\n)*?)/.source+n.match[z].source.replace(/\\(\d+)/g,function(g,
|
||||
h){return"\\"+(h-0+1)}))}var B=function(g,h){g=Array.prototype.slice.call(g,0);if(h){h.push.apply(h,g);return h}return g};try{Array.prototype.slice.call(s.documentElement.childNodes,0)}catch(C){B=function(g,h){h=h||[];if(i.call(g)==="[object Array]")Array.prototype.push.apply(h,g);else if(typeof g.length==="number")for(var k=0,m=g.length;k<m;k++)h.push(g[k]);else for(k=0;g[k];k++)h.push(g[k]);return h}}var D;if(s.documentElement.compareDocumentPosition)D=function(g,h){if(!g.compareDocumentPosition||
|
||||
!h.compareDocumentPosition){if(g==h)j=true;return g.compareDocumentPosition?-1:1}g=g.compareDocumentPosition(h)&4?-1:g===h?0:1;if(g===0)j=true;return g};else if("sourceIndex"in s.documentElement)D=function(g,h){if(!g.sourceIndex||!h.sourceIndex){if(g==h)j=true;return g.sourceIndex?-1:1}g=g.sourceIndex-h.sourceIndex;if(g===0)j=true;return g};else if(s.createRange)D=function(g,h){if(!g.ownerDocument||!h.ownerDocument){if(g==h)j=true;return g.ownerDocument?-1:1}var k=g.ownerDocument.createRange(),m=
|
||||
h.ownerDocument.createRange();k.setStart(g,0);k.setEnd(g,0);m.setStart(h,0);m.setEnd(h,0);g=k.compareBoundaryPoints(Range.START_TO_END,m);if(g===0)j=true;return g};(function(){var g=s.createElement("div"),h="script"+(new Date).getTime();g.innerHTML="<a name='"+h+"'/>";var k=s.documentElement;k.insertBefore(g,k.firstChild);if(s.getElementById(h)){n.find.ID=function(m,r,q){if(typeof r.getElementById!=="undefined"&&!q)return(r=r.getElementById(m[1]))?r.id===m[1]||typeof r.getAttributeNode!=="undefined"&&
|
||||
r.getAttributeNode("id").nodeValue===m[1]?[r]:w:[]};n.filter.ID=function(m,r){var q=typeof m.getAttributeNode!=="undefined"&&m.getAttributeNode("id");return m.nodeType===1&&q&&q.nodeValue===r}}k.removeChild(g);k=g=null})();(function(){var g=s.createElement("div");g.appendChild(s.createComment(""));if(g.getElementsByTagName("*").length>0)n.find.TAG=function(h,k){k=k.getElementsByTagName(h[1]);if(h[1]==="*"){h=[];for(var m=0;k[m];m++)k[m].nodeType===1&&h.push(k[m]);k=h}return k};g.innerHTML="<a href='#'></a>";
|
||||
if(g.firstChild&&typeof g.firstChild.getAttribute!=="undefined"&&g.firstChild.getAttribute("href")!=="#")n.attrHandle.href=function(h){return h.getAttribute("href",2)};g=null})();s.querySelectorAll&&function(){var g=p,h=s.createElement("div");h.innerHTML="<p class='TEST'></p>";if(!(h.querySelectorAll&&h.querySelectorAll(".TEST").length===0)){p=function(m,r,q,v){r=r||s;if(!v&&r.nodeType===9&&!x(r))try{return B(r.querySelectorAll(m),q)}catch(u){}return g(m,r,q,v)};for(var k in g)p[k]=g[k];h=null}}();
|
||||
(function(){var g=s.createElement("div");g.innerHTML="<div class='test e'></div><div class='test'></div>";if(!(!g.getElementsByClassName||g.getElementsByClassName("e").length===0)){g.lastChild.className="e";if(g.getElementsByClassName("e").length!==1){n.order.splice(1,0,"CLASS");n.find.CLASS=function(h,k,m){if(typeof k.getElementsByClassName!=="undefined"&&!m)return k.getElementsByClassName(h[1])};g=null}}})();var F=s.compareDocumentPosition?function(g,h){return g.compareDocumentPosition(h)&16}:function(g,
|
||||
h){return g!==h&&(g.contains?g.contains(h):true)},x=function(g){return(g=(g?g.ownerDocument||g:0).documentElement)?g.nodeName!=="HTML":false},ia=function(g,h){var k=[],m="",r;for(h=h.nodeType?[h]:h;r=n.match.PSEUDO.exec(g);){m+=r[0];g=g.replace(n.match.PSEUDO,"")}g=n.relative[g]?g+"*":g;r=0;for(var q=h.length;r<q;r++)p(g,h[r],k);return p.filter(m,k)};c.find=p;c.expr=p.selectors;c.expr[":"]=c.expr.filters;c.unique=p.uniqueSort;c.getText=a;c.isXMLDoc=x;c.contains=F})();var ab=/Until$/,bb=/^(?:parents|prevUntil|prevAll)/,
|
||||
cb=/,/;R=Array.prototype.slice;var Fa=function(a,b,d){if(c.isFunction(b))return c.grep(a,function(e,i){return!!b.call(e,i,e)===d});else if(b.nodeType)return c.grep(a,function(e){return e===b===d});else if(typeof b==="string"){var f=c.grep(a,function(e){return e.nodeType===1});if(Pa.test(b))return c.filter(b,f,!d);else b=c.filter(b,a)}return c.grep(a,function(e){return c.inArray(e,b)>=0===d})};c.fn.extend({find:function(a){for(var b=this.pushStack("","find",a),d=0,f=0,e=this.length;f<e;f++){d=b.length;
|
||||
c.find(a,this[f],b);if(f>0)for(var i=d;i<b.length;i++)for(var j=0;j<d;j++)if(b[j]===b[i]){b.splice(i--,1);break}}return b},has:function(a){var b=c(a);return this.filter(function(){for(var d=0,f=b.length;d<f;d++)if(c.contains(this,b[d]))return true})},not:function(a){return this.pushStack(Fa(this,a,false),"not",a)},filter:function(a){return this.pushStack(Fa(this,a,true),"filter",a)},is:function(a){return!!a&&c.filter(a,this).length>0},closest:function(a,b){if(c.isArray(a)){var d=[],f=this[0],e,i=
|
||||
{},j;if(f&&a.length){e=0;for(var o=a.length;e<o;e++){j=a[e];i[j]||(i[j]=c.expr.match.POS.test(j)?c(j,b||this.context):j)}for(;f&&f.ownerDocument&&f!==b;){for(j in i){e=i[j];if(e.jquery?e.index(f)>-1:c(f).is(e)){d.push({selector:j,elem:f});delete i[j]}}f=f.parentNode}}return d}var p=c.expr.match.POS.test(a)?c(a,b||this.context):null;return this.map(function(n,t){for(;t&&t.ownerDocument&&t!==b;){if(p?p.index(t)>-1:c(t).is(a))return t;t=t.parentNode}return null})},index:function(a){if(!a||typeof a===
|
||||
"string")return c.inArray(this[0],a?c(a):this.parent().children());return c.inArray(a.jquery?a[0]:a,this)},add:function(a,b){a=typeof a==="string"?c(a,b||this.context):c.makeArray(a);b=c.merge(this.get(),a);return this.pushStack(sa(a[0])||sa(b[0])?b:c.unique(b))},andSelf:function(){return this.add(this.prevObject)}});c.each({parent:function(a){return(a=a.parentNode)&&a.nodeType!==11?a:null},parents:function(a){return c.dir(a,"parentNode")},parentsUntil:function(a,b,d){return c.dir(a,"parentNode",
|
||||
d)},next:function(a){return c.nth(a,2,"nextSibling")},prev:function(a){return c.nth(a,2,"previousSibling")},nextAll:function(a){return c.dir(a,"nextSibling")},prevAll:function(a){return c.dir(a,"previousSibling")},nextUntil:function(a,b,d){return c.dir(a,"nextSibling",d)},prevUntil:function(a,b,d){return c.dir(a,"previousSibling",d)},siblings:function(a){return c.sibling(a.parentNode.firstChild,a)},children:function(a){return c.sibling(a.firstChild)},contents:function(a){return c.nodeName(a,"iframe")?
|
||||
a.contentDocument||a.contentWindow.document:c.makeArray(a.childNodes)}},function(a,b){c.fn[a]=function(d,f){var e=c.map(this,b,d);ab.test(a)||(f=d);if(f&&typeof f==="string")e=c.filter(f,e);e=this.length>1?c.unique(e):e;if((this.length>1||cb.test(f))&&bb.test(a))e=e.reverse();return this.pushStack(e,a,R.call(arguments).join(","))}});c.extend({filter:function(a,b,d){if(d)a=":not("+a+")";return c.find.matches(a,b)},dir:function(a,b,d){var f=[];for(a=a[b];a&&a.nodeType!==9&&(d===w||!c(a).is(d));){a.nodeType===
|
||||
1&&f.push(a);a=a[b]}return f},nth:function(a,b,d){b=b||1;for(var f=0;a;a=a[d])if(a.nodeType===1&&++f===b)break;return a},sibling:function(a,b){for(var d=[];a;a=a.nextSibling)a.nodeType===1&&a!==b&&d.push(a);return d}});var Ga=/ jQuery\d+="(?:\d+|null)"/g,Y=/^\s+/,db=/(<([\w:]+)[^>]*?)\/>/g,eb=/^(?:area|br|col|embed|hr|img|input|link|meta|param)$/i,Ha=/<([\w:]+)/,fb=/<tbody/i,gb=/<|&\w+;/,hb=function(a,b,d){return eb.test(d)?a:b+"></"+d+">"},G={option:[1,"<select multiple='multiple'>","</select>"],
|
||||
legend:[1,"<fieldset>","</fieldset>"],thead:[1,"<table>","</table>"],tr:[2,"<table><tbody>","</tbody></table>"],td:[3,"<table><tbody><tr>","</tr></tbody></table>"],col:[2,"<table><tbody></tbody><colgroup>","</colgroup></table>"],area:[1,"<map>","</map>"],_default:[0,"",""]};G.optgroup=G.option;G.tbody=G.tfoot=G.colgroup=G.caption=G.thead;G.th=G.td;if(!c.support.htmlSerialize)G._default=[1,"div<div>","</div>"];c.fn.extend({text:function(a){if(c.isFunction(a))return this.each(function(b){var d=c(this);
|
||||
return d.text(a.call(this,b,d.text()))});if(typeof a!=="object"&&a!==w)return this.empty().append((this[0]&&this[0].ownerDocument||s).createTextNode(a));return c.getText(this)},wrapAll:function(a){if(c.isFunction(a))return this.each(function(d){c(this).wrapAll(a.call(this,d))});if(this[0]){var b=c(a,this[0].ownerDocument).eq(0).clone(true);this[0].parentNode&&b.insertBefore(this[0]);b.map(function(){for(var d=this;d.firstChild&&d.firstChild.nodeType===1;)d=d.firstChild;return d}).append(this)}return this},
|
||||
wrapInner:function(a){return this.each(function(){var b=c(this),d=b.contents();d.length?d.wrapAll(a):b.append(a)})},wrap:function(a){return this.each(function(){c(this).wrapAll(a)})},unwrap:function(){return this.parent().each(function(){c.nodeName(this,"body")||c(this).replaceWith(this.childNodes)}).end()},append:function(){return this.domManip(arguments,true,function(a){this.nodeType===1&&this.appendChild(a)})},prepend:function(){return this.domManip(arguments,true,function(a){this.nodeType===1&&
|
||||
this.insertBefore(a,this.firstChild)})},before:function(){if(this[0]&&this[0].parentNode)return this.domManip(arguments,false,function(b){this.parentNode.insertBefore(b,this)});else if(arguments.length){var a=c(arguments[0]);a.push.apply(a,this.toArray());return this.pushStack(a,"before",arguments)}},after:function(){if(this[0]&&this[0].parentNode)return this.domManip(arguments,false,function(b){this.parentNode.insertBefore(b,this.nextSibling)});else if(arguments.length){var a=this.pushStack(this,
|
||||
"after",arguments);a.push.apply(a,c(arguments[0]).toArray());return a}},clone:function(a){var b=this.map(function(){if(!c.support.noCloneEvent&&!c.isXMLDoc(this)){var d=this.outerHTML,f=this.ownerDocument;if(!d){d=f.createElement("div");d.appendChild(this.cloneNode(true));d=d.innerHTML}return c.clean([d.replace(Ga,"").replace(Y,"")],f)[0]}else return this.cloneNode(true)});if(a===true){ta(this,b);ta(this.find("*"),b.find("*"))}return b},html:function(a){if(a===w)return this[0]&&this[0].nodeType===
|
||||
1?this[0].innerHTML.replace(Ga,""):null;else if(typeof a==="string"&&!/<script/i.test(a)&&(c.support.leadingWhitespace||!Y.test(a))&&!G[(Ha.exec(a)||["",""])[1].toLowerCase()])try{for(var b=0,d=this.length;b<d;b++)if(this[b].nodeType===1){T(this[b].getElementsByTagName("*"));this[b].innerHTML=a}}catch(f){this.empty().append(a)}else c.isFunction(a)?this.each(function(e){var i=c(this),j=i.html();i.empty().append(function(){return a.call(this,e,j)})}):this.empty().append(a);return this},replaceWith:function(a){if(this[0]&&
|
||||
this[0].parentNode){c.isFunction(a)||(a=c(a).detach());return this.each(function(){var b=this.nextSibling,d=this.parentNode;c(this).remove();b?c(b).before(a):c(d).append(a)})}else return this.pushStack(c(c.isFunction(a)?a():a),"replaceWith",a)},detach:function(a){return this.remove(a,true)},domManip:function(a,b,d){function f(t){return c.nodeName(t,"table")?t.getElementsByTagName("tbody")[0]||t.appendChild(t.ownerDocument.createElement("tbody")):t}var e,i,j=a[0],o=[];if(c.isFunction(j))return this.each(function(t){var z=
|
||||
c(this);a[0]=j.call(this,t,b?z.html():w);return z.domManip(a,b,d)});if(this[0]){e=a[0]&&a[0].parentNode&&a[0].parentNode.nodeType===11?{fragment:a[0].parentNode}:ua(a,this,o);if(i=e.fragment.firstChild){b=b&&c.nodeName(i,"tr");for(var p=0,n=this.length;p<n;p++)d.call(b?f(this[p],i):this[p],e.cacheable||this.length>1||p>0?e.fragment.cloneNode(true):e.fragment)}o&&c.each(o,La)}return this}});c.fragments={};c.each({appendTo:"append",prependTo:"prepend",insertBefore:"before",insertAfter:"after",replaceAll:"replaceWith"},
|
||||
function(a,b){c.fn[a]=function(d){var f=[];d=c(d);for(var e=0,i=d.length;e<i;e++){var j=(e>0?this.clone(true):this).get();c.fn[b].apply(c(d[e]),j);f=f.concat(j)}return this.pushStack(f,a,d.selector)}});c.each({remove:function(a,b){if(!a||c.filter(a,[this]).length){if(!b&&this.nodeType===1){T(this.getElementsByTagName("*"));T([this])}this.parentNode&&this.parentNode.removeChild(this)}},empty:function(){for(this.nodeType===1&&T(this.getElementsByTagName("*"));this.firstChild;)this.removeChild(this.firstChild)}},
|
||||
function(a,b){c.fn[a]=function(){return this.each(b,arguments)}});c.extend({clean:function(a,b,d,f){b=b||s;if(typeof b.createElement==="undefined")b=b.ownerDocument||b[0]&&b[0].ownerDocument||s;var e=[];c.each(a,function(i,j){if(typeof j==="number")j+="";if(j){if(typeof j==="string"&&!gb.test(j))j=b.createTextNode(j);else if(typeof j==="string"){j=j.replace(db,hb);var o=(Ha.exec(j)||["",""])[1].toLowerCase(),p=G[o]||G._default,n=p[0];i=b.createElement("div");for(i.innerHTML=p[1]+j+p[2];n--;)i=i.lastChild;
|
||||
if(!c.support.tbody){n=fb.test(j);o=o==="table"&&!n?i.firstChild&&i.firstChild.childNodes:p[1]==="<table>"&&!n?i.childNodes:[];for(p=o.length-1;p>=0;--p)c.nodeName(o[p],"tbody")&&!o[p].childNodes.length&&o[p].parentNode.removeChild(o[p])}!c.support.leadingWhitespace&&Y.test(j)&&i.insertBefore(b.createTextNode(Y.exec(j)[0]),i.firstChild);j=c.makeArray(i.childNodes)}if(j.nodeType)e.push(j);else e=c.merge(e,j)}});if(d)for(a=0;e[a];a++)if(f&&c.nodeName(e[a],"script")&&(!e[a].type||e[a].type.toLowerCase()===
|
||||
"text/javascript"))f.push(e[a].parentNode?e[a].parentNode.removeChild(e[a]):e[a]);else{e[a].nodeType===1&&e.splice.apply(e,[a+1,0].concat(c.makeArray(e[a].getElementsByTagName("script"))));d.appendChild(e[a])}return e}});var ib=/z-?index|font-?weight|opacity|zoom|line-?height/i,Ia=/alpha\([^)]*\)/,Ja=/opacity=([^)]*)/,ja=/float/i,ka=/-([a-z])/ig,jb=/([A-Z])/g,kb=/^-?\d+(?:px)?$/i,lb=/^-?\d/,mb={position:"absolute",visibility:"hidden",display:"block"},nb=["Left","Right"],ob=["Top","Bottom"],pb=s.defaultView&&
|
||||
s.defaultView.getComputedStyle,Ka=c.support.cssFloat?"cssFloat":"styleFloat",la=function(a,b){return b.toUpperCase()};c.fn.css=function(a,b){return $(this,a,b,true,function(d,f,e){if(e===w)return c.curCSS(d,f);if(typeof e==="number"&&!ib.test(f))e+="px";c.style(d,f,e)})};c.extend({style:function(a,b,d){if(!a||a.nodeType===3||a.nodeType===8)return w;if((b==="width"||b==="height")&&parseFloat(d)<0)d=w;var f=a.style||a,e=d!==w;if(!c.support.opacity&&b==="opacity"){if(e){f.zoom=1;b=parseInt(d,10)+""===
|
||||
"NaN"?"":"alpha(opacity="+d*100+")";a=f.filter||c.curCSS(a,"filter")||"";f.filter=Ia.test(a)?a.replace(Ia,b):b}return f.filter&&f.filter.indexOf("opacity=")>=0?parseFloat(Ja.exec(f.filter)[1])/100+"":""}if(ja.test(b))b=Ka;b=b.replace(ka,la);if(e)f[b]=d;return f[b]},css:function(a,b,d,f){if(b==="width"||b==="height"){var e,i=b==="width"?nb:ob;function j(){e=b==="width"?a.offsetWidth:a.offsetHeight;f!=="border"&&c.each(i,function(){f||(e-=parseFloat(c.curCSS(a,"padding"+this,true))||0);if(f==="margin")e+=
|
||||
parseFloat(c.curCSS(a,"margin"+this,true))||0;else e-=parseFloat(c.curCSS(a,"border"+this+"Width",true))||0})}a.offsetWidth!==0?j():c.swap(a,mb,j);return Math.max(0,Math.round(e))}return c.curCSS(a,b,d)},curCSS:function(a,b,d){var f,e=a.style;if(!c.support.opacity&&b==="opacity"&&a.currentStyle){f=Ja.test(a.currentStyle.filter||"")?parseFloat(RegExp.$1)/100+"":"";return f===""?"1":f}if(ja.test(b))b=Ka;if(!d&&e&&e[b])f=e[b];else if(pb){if(ja.test(b))b="float";b=b.replace(jb,"-$1").toLowerCase();e=
|
||||
a.ownerDocument.defaultView;if(!e)return null;if(a=e.getComputedStyle(a,null))f=a.getPropertyValue(b);if(b==="opacity"&&f==="")f="1"}else if(a.currentStyle){d=b.replace(ka,la);f=a.currentStyle[b]||a.currentStyle[d];if(!kb.test(f)&&lb.test(f)){b=e.left;var i=a.runtimeStyle.left;a.runtimeStyle.left=a.currentStyle.left;e.left=d==="fontSize"?"1em":f||0;f=e.pixelLeft+"px";e.left=b;a.runtimeStyle.left=i}}return f},swap:function(a,b,d){var f={};for(var e in b){f[e]=a.style[e];a.style[e]=b[e]}d.call(a);for(e in b)a.style[e]=
|
||||
f[e]}});if(c.expr&&c.expr.filters){c.expr.filters.hidden=function(a){var b=a.offsetWidth,d=a.offsetHeight,f=a.nodeName.toLowerCase()==="tr";return b===0&&d===0&&!f?true:b>0&&d>0&&!f?false:c.curCSS(a,"display")==="none"};c.expr.filters.visible=function(a){return!c.expr.filters.hidden(a)}}var qb=K(),rb=/<script(.|\s)*?\/script>/gi,sb=/select|textarea/i,tb=/color|date|datetime|email|hidden|month|number|password|range|search|tel|text|time|url|week/i,O=/=\?(&|$)/,ma=/\?/,ub=/(\?|&)_=.*?(&|$)/,vb=/^(\w+:)?\/\/([^\/?#]+)/,
|
||||
wb=/%20/g;c.fn.extend({_load:c.fn.load,load:function(a,b,d){if(typeof a!=="string")return this._load(a);else if(!this.length)return this;var f=a.indexOf(" ");if(f>=0){var e=a.slice(f,a.length);a=a.slice(0,f)}f="GET";if(b)if(c.isFunction(b)){d=b;b=null}else if(typeof b==="object"){b=c.param(b,c.ajaxSettings.traditional);f="POST"}c.ajax({url:a,type:f,dataType:"html",data:b,context:this,complete:function(i,j){if(j==="success"||j==="notmodified")this.html(e?c("<div />").append(i.responseText.replace(rb,
|
||||
"")).find(e):i.responseText);d&&this.each(d,[i.responseText,j,i])}});return this},serialize:function(){return c.param(this.serializeArray())},serializeArray:function(){return this.map(function(){return this.elements?c.makeArray(this.elements):this}).filter(function(){return this.name&&!this.disabled&&(this.checked||sb.test(this.nodeName)||tb.test(this.type))}).map(function(a,b){a=c(this).val();return a==null?null:c.isArray(a)?c.map(a,function(d){return{name:b.name,value:d}}):{name:b.name,value:a}}).get()}});
|
||||
c.each("ajaxStart ajaxStop ajaxComplete ajaxError ajaxSuccess ajaxSend".split(" "),function(a,b){c.fn[b]=function(d){return this.bind(b,d)}});c.extend({get:function(a,b,d,f){if(c.isFunction(b)){f=f||d;d=b;b=null}return c.ajax({type:"GET",url:a,data:b,success:d,dataType:f})},getScript:function(a,b){return c.get(a,null,b,"script")},getJSON:function(a,b,d){return c.get(a,b,d,"json")},post:function(a,b,d,f){if(c.isFunction(b)){f=f||d;d=b;b={}}return c.ajax({type:"POST",url:a,data:b,success:d,dataType:f})},
|
||||
ajaxSetup:function(a){c.extend(c.ajaxSettings,a)},ajaxSettings:{url:location.href,global:true,type:"GET",contentType:"application/x-www-form-urlencoded",processData:true,async:true,xhr:A.XMLHttpRequest&&(A.location.protocol!=="file:"||!A.ActiveXObject)?function(){return new A.XMLHttpRequest}:function(){try{return new A.ActiveXObject("Microsoft.XMLHTTP")}catch(a){}},accepts:{xml:"application/xml, text/xml",html:"text/html",script:"text/javascript, application/javascript",json:"application/json, text/javascript",
|
||||
text:"text/plain",_default:"*/*"}},lastModified:{},etag:{},ajax:function(a){function b(){e.success&&e.success.call(p,o,j,x);e.global&&f("ajaxSuccess",[x,e])}function d(){e.complete&&e.complete.call(p,x,j);e.global&&f("ajaxComplete",[x,e]);e.global&&!--c.active&&c.event.trigger("ajaxStop")}function f(r,q){(e.context?c(e.context):c.event).trigger(r,q)}var e=c.extend(true,{},c.ajaxSettings,a),i,j,o,p=e.context||e,n=e.type.toUpperCase();if(e.data&&e.processData&&typeof e.data!=="string")e.data=c.param(e.data,
|
||||
e.traditional);if(e.dataType==="jsonp"){if(n==="GET")O.test(e.url)||(e.url+=(ma.test(e.url)?"&":"?")+(e.jsonp||"callback")+"=?");else if(!e.data||!O.test(e.data))e.data=(e.data?e.data+"&":"")+(e.jsonp||"callback")+"=?";e.dataType="json"}if(e.dataType==="json"&&(e.data&&O.test(e.data)||O.test(e.url))){i=e.jsonpCallback||"jsonp"+qb++;if(e.data)e.data=(e.data+"").replace(O,"="+i+"$1");e.url=e.url.replace(O,"="+i+"$1");e.dataType="script";A[i]=A[i]||function(r){o=r;b();d();A[i]=w;try{delete A[i]}catch(q){}B&&
|
||||
B.removeChild(C)}}if(e.dataType==="script"&&e.cache===null)e.cache=false;if(e.cache===false&&n==="GET"){var t=K(),z=e.url.replace(ub,"$1_="+t+"$2");e.url=z+(z===e.url?(ma.test(e.url)?"&":"?")+"_="+t:"")}if(e.data&&n==="GET")e.url+=(ma.test(e.url)?"&":"?")+e.data;e.global&&!c.active++&&c.event.trigger("ajaxStart");t=(t=vb.exec(e.url))&&(t[1]&&t[1]!==location.protocol||t[2]!==location.host);if(e.dataType==="script"&&n==="GET"&&t){var B=s.getElementsByTagName("head")[0]||s.documentElement,C=s.createElement("script");
|
||||
C.src=e.url;if(e.scriptCharset)C.charset=e.scriptCharset;if(!i){var D=false;C.onload=C.onreadystatechange=function(){if(!D&&(!this.readyState||this.readyState==="loaded"||this.readyState==="complete")){D=true;b();d();C.onload=C.onreadystatechange=null;B&&C.parentNode&&B.removeChild(C)}}}B.insertBefore(C,B.firstChild);return w}var F=false,x=e.xhr();if(x){e.username?x.open(n,e.url,e.async,e.username,e.password):x.open(n,e.url,e.async);try{if(e.data||a&&a.contentType)x.setRequestHeader("Content-Type",
|
||||
e.contentType);if(e.ifModified){c.lastModified[e.url]&&x.setRequestHeader("If-Modified-Since",c.lastModified[e.url]);c.etag[e.url]&&x.setRequestHeader("If-None-Match",c.etag[e.url])}t||x.setRequestHeader("X-Requested-With","XMLHttpRequest");x.setRequestHeader("Accept",e.dataType&&e.accepts[e.dataType]?e.accepts[e.dataType]+", */*":e.accepts._default)}catch(ia){}if(e.beforeSend&&e.beforeSend.call(p,x,e)===false){e.global&&!--c.active&&c.event.trigger("ajaxStop");x.abort();return false}e.global&&f("ajaxSend",
|
||||
[x,e]);var g=x.onreadystatechange=function(r){if(!x||x.readyState===0){F||d();F=true;if(x)x.onreadystatechange=c.noop}else if(!F&&x&&(x.readyState===4||r==="timeout")){F=true;x.onreadystatechange=c.noop;j=r==="timeout"?"timeout":!c.httpSuccess(x)?"error":e.ifModified&&c.httpNotModified(x,e.url)?"notmodified":"success";if(j==="success")try{o=c.httpData(x,e.dataType,e)}catch(q){j="parsererror"}if(j==="success"||j==="notmodified")i||b();else c.handleError(e,x,j);d();r==="timeout"&&x.abort();if(e.async)x=
|
||||
null}};try{var h=x.abort;x.abort=function(){if(x){h.call(x);if(x)x.readyState=0}g()}}catch(k){}e.async&&e.timeout>0&&setTimeout(function(){x&&!F&&g("timeout")},e.timeout);try{x.send(n==="POST"||n==="PUT"||n==="DELETE"?e.data:null)}catch(m){c.handleError(e,x,null,m);d()}e.async||g();return x}},handleError:function(a,b,d,f){if(a.error)a.error.call(a.context||A,b,d,f);if(a.global)(a.context?c(a.context):c.event).trigger("ajaxError",[b,a,f])},active:0,httpSuccess:function(a){try{return!a.status&&location.protocol===
|
||||
"file:"||a.status>=200&&a.status<300||a.status===304||a.status===1223||a.status===0}catch(b){}return false},httpNotModified:function(a,b){var d=a.getResponseHeader("Last-Modified"),f=a.getResponseHeader("Etag");if(d)c.lastModified[b]=d;if(f)c.etag[b]=f;return a.status===304||a.status===0},httpData:function(a,b,d){var f=a.getResponseHeader("content-type")||"",e=b==="xml"||!b&&f.indexOf("xml")>=0;a=e?a.responseXML:a.responseText;if(e&&a.documentElement.nodeName==="parsererror")throw"parsererror";if(d&&
|
||||
d.dataFilter)a=d.dataFilter(a,b);if(typeof a==="string")if(b==="json"||!b&&f.indexOf("json")>=0)if(/^[\],:{}\s]*$/.test(a.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g,"@").replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g,"]").replace(/(?:^|:|,)(?:\s*\[)+/g,"")))a=A.JSON&&A.JSON.parse?A.JSON.parse(a):(new Function("return "+a))();else throw"Invalid JSON: "+a;else if(b==="script"||!b&&f.indexOf("javascript")>=0)c.globalEval(a);return a},param:function(a,b){function d(e,i){i=
|
||||
c.isFunction(i)?i():i;f[f.length]=encodeURIComponent(e)+"="+encodeURIComponent(i)}var f=[];if(b===w)b=c.ajaxSettings.traditional;c.isArray(a)||a.jquery?c.each(a,function(){d(this.name,this.value)}):c.each(a,function e(i,j){if(c.isArray(j))c.each(j,function(o,p){b?d(i,p):e(i+"["+(typeof p==="object"||c.isArray(p)?o:"")+"]",p)});else!b&&j!=null&&typeof j==="object"?c.each(j,function(o,p){e(i+"["+o+"]",p)}):d(i,j)});return f.join("&").replace(wb,"+")}});var na={},xb=/toggle|show|hide/,yb=/^([+-]=)?([\d+-.]+)(.*)$/,
|
||||
Z,va=[["height","marginTop","marginBottom","paddingTop","paddingBottom"],["width","marginLeft","marginRight","paddingLeft","paddingRight"],["opacity"]];c.fn.extend({show:function(a,b){if(a!=null)return this.animate(L("show",3),a,b);else{a=0;for(b=this.length;a<b;a++){var d=c.data(this[a],"olddisplay");this[a].style.display=d||"";if(c.css(this[a],"display")==="none"){d=this[a].nodeName;var f;if(na[d])f=na[d];else{var e=c("<"+d+" />").appendTo("body");f=e.css("display");if(f==="none")f="block";e.remove();
|
||||
na[d]=f}c.data(this[a],"olddisplay",f)}}a=0;for(b=this.length;a<b;a++)this[a].style.display=c.data(this[a],"olddisplay")||"";return this}},hide:function(a,b){if(a!=null)return this.animate(L("hide",3),a,b);else{a=0;for(b=this.length;a<b;a++){var d=c.data(this[a],"olddisplay");!d&&d!=="none"&&c.data(this[a],"olddisplay",c.css(this[a],"display"))}a=0;for(b=this.length;a<b;a++)this[a].style.display="none";return this}},_toggle:c.fn.toggle,toggle:function(a,b){var d=typeof a==="boolean";if(c.isFunction(a)&&
|
||||
c.isFunction(b))this._toggle.apply(this,arguments);else a==null||d?this.each(function(){var f=d?a:c(this).is(":hidden");c(this)[f?"show":"hide"]()}):this.animate(L("toggle",3),a,b);return this},fadeTo:function(a,b,d){return this.filter(":hidden").css("opacity",0).show().end().animate({opacity:b},a,d)},animate:function(a,b,d,f){var e=c.speed(b,d,f);if(c.isEmptyObject(a))return this.each(e.complete);return this[e.queue===false?"each":"queue"](function(){var i=c.extend({},e),j,o=this.nodeType===1&&c(this).is(":hidden"),
|
||||
p=this;for(j in a){var n=j.replace(ka,la);if(j!==n){a[n]=a[j];delete a[j];j=n}if(a[j]==="hide"&&o||a[j]==="show"&&!o)return i.complete.call(this);if((j==="height"||j==="width")&&this.style){i.display=c.css(this,"display");i.overflow=this.style.overflow}if(c.isArray(a[j])){(i.specialEasing=i.specialEasing||{})[j]=a[j][1];a[j]=a[j][0]}}if(i.overflow!=null)this.style.overflow="hidden";i.curAnim=c.extend({},a);c.each(a,function(t,z){var B=new c.fx(p,i,t);if(xb.test(z))B[z==="toggle"?o?"show":"hide":z](a);
|
||||
else{var C=yb.exec(z),D=B.cur(true)||0;if(C){z=parseFloat(C[2]);var F=C[3]||"px";if(F!=="px"){p.style[t]=(z||1)+F;D=(z||1)/B.cur(true)*D;p.style[t]=D+F}if(C[1])z=(C[1]==="-="?-1:1)*z+D;B.custom(D,z,F)}else B.custom(D,z,"")}});return true})},stop:function(a,b){var d=c.timers;a&&this.queue([]);this.each(function(){for(var f=d.length-1;f>=0;f--)if(d[f].elem===this){b&&d[f](true);d.splice(f,1)}});b||this.dequeue();return this}});c.each({slideDown:L("show",1),slideUp:L("hide",1),slideToggle:L("toggle",
|
||||
1),fadeIn:{opacity:"show"},fadeOut:{opacity:"hide"}},function(a,b){c.fn[a]=function(d,f){return this.animate(b,d,f)}});c.extend({speed:function(a,b,d){var f=a&&typeof a==="object"?a:{complete:d||!d&&b||c.isFunction(a)&&a,duration:a,easing:d&&b||b&&!c.isFunction(b)&&b};f.duration=c.fx.off?0:typeof f.duration==="number"?f.duration:c.fx.speeds[f.duration]||c.fx.speeds._default;f.old=f.complete;f.complete=function(){f.queue!==false&&c(this).dequeue();c.isFunction(f.old)&&f.old.call(this)};return f},easing:{linear:function(a,
|
||||
b,d,f){return d+f*a},swing:function(a,b,d,f){return(-Math.cos(a*Math.PI)/2+0.5)*f+d}},timers:[],fx:function(a,b,d){this.options=b;this.elem=a;this.prop=d;if(!b.orig)b.orig={}}});c.fx.prototype={update:function(){this.options.step&&this.options.step.call(this.elem,this.now,this);(c.fx.step[this.prop]||c.fx.step._default)(this);if((this.prop==="height"||this.prop==="width")&&this.elem.style)this.elem.style.display="block"},cur:function(a){if(this.elem[this.prop]!=null&&(!this.elem.style||this.elem.style[this.prop]==
|
||||
null))return this.elem[this.prop];return(a=parseFloat(c.css(this.elem,this.prop,a)))&&a>-10000?a:parseFloat(c.curCSS(this.elem,this.prop))||0},custom:function(a,b,d){function f(i){return e.step(i)}this.startTime=K();this.start=a;this.end=b;this.unit=d||this.unit||"px";this.now=this.start;this.pos=this.state=0;var e=this;f.elem=this.elem;if(f()&&c.timers.push(f)&&!Z)Z=setInterval(c.fx.tick,13)},show:function(){this.options.orig[this.prop]=c.style(this.elem,this.prop);this.options.show=true;this.custom(this.prop===
|
||||
"width"||this.prop==="height"?1:0,this.cur());c(this.elem).show()},hide:function(){this.options.orig[this.prop]=c.style(this.elem,this.prop);this.options.hide=true;this.custom(this.cur(),0)},step:function(a){var b=K(),d=true;if(a||b>=this.options.duration+this.startTime){this.now=this.end;this.pos=this.state=1;this.update();this.options.curAnim[this.prop]=true;for(var f in this.options.curAnim)if(this.options.curAnim[f]!==true)d=false;if(d){if(this.options.display!=null){this.elem.style.overflow=
|
||||
this.options.overflow;a=c.data(this.elem,"olddisplay");this.elem.style.display=a?a:this.options.display;if(c.css(this.elem,"display")==="none")this.elem.style.display="block"}this.options.hide&&c(this.elem).hide();if(this.options.hide||this.options.show)for(var e in this.options.curAnim)c.style(this.elem,e,this.options.orig[e]);this.options.complete.call(this.elem)}return false}else{e=b-this.startTime;this.state=e/this.options.duration;a=this.options.easing||(c.easing.swing?"swing":"linear");this.pos=
|
||||
c.easing[this.options.specialEasing&&this.options.specialEasing[this.prop]||a](this.state,e,0,1,this.options.duration);this.now=this.start+(this.end-this.start)*this.pos;this.update()}return true}};c.extend(c.fx,{tick:function(){for(var a=c.timers,b=0;b<a.length;b++)a[b]()||a.splice(b--,1);a.length||c.fx.stop()},stop:function(){clearInterval(Z);Z=null},speeds:{slow:600,fast:200,_default:400},step:{opacity:function(a){c.style(a.elem,"opacity",a.now)},_default:function(a){if(a.elem.style&&a.elem.style[a.prop]!=
|
||||
null)a.elem.style[a.prop]=(a.prop==="width"||a.prop==="height"?Math.max(0,a.now):a.now)+a.unit;else a.elem[a.prop]=a.now}}});if(c.expr&&c.expr.filters)c.expr.filters.animated=function(a){return c.grep(c.timers,function(b){return a===b.elem}).length};c.fn.offset="getBoundingClientRect"in s.documentElement?function(a){var b=this[0];if(!b||!b.ownerDocument)return null;if(a)return this.each(function(e){c.offset.setOffset(this,a,e)});if(b===b.ownerDocument.body)return c.offset.bodyOffset(b);var d=b.getBoundingClientRect(),
|
||||
f=b.ownerDocument;b=f.body;f=f.documentElement;return{top:d.top+(self.pageYOffset||c.support.boxModel&&f.scrollTop||b.scrollTop)-(f.clientTop||b.clientTop||0),left:d.left+(self.pageXOffset||c.support.boxModel&&f.scrollLeft||b.scrollLeft)-(f.clientLeft||b.clientLeft||0)}}:function(a){var b=this[0];if(!b||!b.ownerDocument)return null;if(a)return this.each(function(t){c.offset.setOffset(this,a,t)});if(b===b.ownerDocument.body)return c.offset.bodyOffset(b);c.offset.initialize();var d=b.offsetParent,f=
|
||||
b,e=b.ownerDocument,i,j=e.documentElement,o=e.body;f=(e=e.defaultView)?e.getComputedStyle(b,null):b.currentStyle;for(var p=b.offsetTop,n=b.offsetLeft;(b=b.parentNode)&&b!==o&&b!==j;){if(c.offset.supportsFixedPosition&&f.position==="fixed")break;i=e?e.getComputedStyle(b,null):b.currentStyle;p-=b.scrollTop;n-=b.scrollLeft;if(b===d){p+=b.offsetTop;n+=b.offsetLeft;if(c.offset.doesNotAddBorder&&!(c.offset.doesAddBorderForTableAndCells&&/^t(able|d|h)$/i.test(b.nodeName))){p+=parseFloat(i.borderTopWidth)||
|
||||
0;n+=parseFloat(i.borderLeftWidth)||0}f=d;d=b.offsetParent}if(c.offset.subtractsBorderForOverflowNotVisible&&i.overflow!=="visible"){p+=parseFloat(i.borderTopWidth)||0;n+=parseFloat(i.borderLeftWidth)||0}f=i}if(f.position==="relative"||f.position==="static"){p+=o.offsetTop;n+=o.offsetLeft}if(c.offset.supportsFixedPosition&&f.position==="fixed"){p+=Math.max(j.scrollTop,o.scrollTop);n+=Math.max(j.scrollLeft,o.scrollLeft)}return{top:p,left:n}};c.offset={initialize:function(){var a=s.body,b=s.createElement("div"),
|
||||
d,f,e,i=parseFloat(c.curCSS(a,"marginTop",true))||0;c.extend(b.style,{position:"absolute",top:0,left:0,margin:0,border:0,width:"1px",height:"1px",visibility:"hidden"});b.innerHTML="<div style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;'><div></div></div><table style='position:absolute;top:0;left:0;margin:0;border:5px solid #000;padding:0;width:1px;height:1px;' cellpadding='0' cellspacing='0'><tr><td></td></tr></table>";a.insertBefore(b,a.firstChild);
|
||||
d=b.firstChild;f=d.firstChild;e=d.nextSibling.firstChild.firstChild;this.doesNotAddBorder=f.offsetTop!==5;this.doesAddBorderForTableAndCells=e.offsetTop===5;f.style.position="fixed";f.style.top="20px";this.supportsFixedPosition=f.offsetTop===20||f.offsetTop===15;f.style.position=f.style.top="";d.style.overflow="hidden";d.style.position="relative";this.subtractsBorderForOverflowNotVisible=f.offsetTop===-5;this.doesNotIncludeMarginInBodyOffset=a.offsetTop!==i;a.removeChild(b);c.offset.initialize=c.noop},
|
||||
bodyOffset:function(a){var b=a.offsetTop,d=a.offsetLeft;c.offset.initialize();if(c.offset.doesNotIncludeMarginInBodyOffset){b+=parseFloat(c.curCSS(a,"marginTop",true))||0;d+=parseFloat(c.curCSS(a,"marginLeft",true))||0}return{top:b,left:d}},setOffset:function(a,b,d){if(/static/.test(c.curCSS(a,"position")))a.style.position="relative";var f=c(a),e=f.offset(),i=parseInt(c.curCSS(a,"top",true),10)||0,j=parseInt(c.curCSS(a,"left",true),10)||0;if(c.isFunction(b))b=b.call(a,d,e);d={top:b.top-e.top+i,left:b.left-
|
||||
e.left+j};"using"in b?b.using.call(a,d):f.css(d)}};c.fn.extend({position:function(){if(!this[0])return null;var a=this[0],b=this.offsetParent(),d=this.offset(),f=/^body|html$/i.test(b[0].nodeName)?{top:0,left:0}:b.offset();d.top-=parseFloat(c.curCSS(a,"marginTop",true))||0;d.left-=parseFloat(c.curCSS(a,"marginLeft",true))||0;f.top+=parseFloat(c.curCSS(b[0],"borderTopWidth",true))||0;f.left+=parseFloat(c.curCSS(b[0],"borderLeftWidth",true))||0;return{top:d.top-f.top,left:d.left-f.left}},offsetParent:function(){return this.map(function(){for(var a=
|
||||
this.offsetParent||s.body;a&&!/^body|html$/i.test(a.nodeName)&&c.css(a,"position")==="static";)a=a.offsetParent;return a})}});c.each(["Left","Top"],function(a,b){var d="scroll"+b;c.fn[d]=function(f){var e=this[0],i;if(!e)return null;if(f!==w)return this.each(function(){if(i=wa(this))i.scrollTo(!a?f:c(i).scrollLeft(),a?f:c(i).scrollTop());else this[d]=f});else return(i=wa(e))?"pageXOffset"in i?i[a?"pageYOffset":"pageXOffset"]:c.support.boxModel&&i.document.documentElement[d]||i.document.body[d]:e[d]}});
|
||||
c.each(["Height","Width"],function(a,b){var d=b.toLowerCase();c.fn["inner"+b]=function(){return this[0]?c.css(this[0],d,false,"padding"):null};c.fn["outer"+b]=function(f){return this[0]?c.css(this[0],d,false,f?"margin":"border"):null};c.fn[d]=function(f){var e=this[0];if(!e)return f==null?null:this;return"scrollTo"in e&&e.document?e.document.compatMode==="CSS1Compat"&&e.document.documentElement["client"+b]||e.document.body["client"+b]:e.nodeType===9?Math.max(e.documentElement["client"+b],e.body["scroll"+
|
||||
b],e.documentElement["scroll"+b],e.body["offset"+b],e.documentElement["offset"+b]):f===w?c.css(e,d):this.css(d,typeof f==="string"?f:f+"px")}});A.jQuery=A.$=c})(window);
|
||||
|
|
@ -1,39 +0,0 @@
|
|||
/*=============================================================================
|
||||
Copyright 2002 William E. Kempf
|
||||
Distributed under the Boost Software License, Version 1.0. (See accompany-
|
||||
ing file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
=============================================================================*/
|
||||
|
||||
H1
|
||||
{
|
||||
FONT-SIZE: 200%;
|
||||
COLOR: #00008B;
|
||||
}
|
||||
H2
|
||||
{
|
||||
FONT-SIZE: 150%;
|
||||
}
|
||||
H3
|
||||
{
|
||||
FONT-SIZE: 125%;
|
||||
}
|
||||
H4
|
||||
{
|
||||
FONT-SIZE: 108%;
|
||||
}
|
||||
/*
|
||||
BODY
|
||||
{
|
||||
FONT-SIZE: 100%;
|
||||
BACKGROUND-COLOR: #ffffff;
|
||||
COLOR: #000000;
|
||||
}
|
||||
*/
|
||||
/*
|
||||
PRE
|
||||
{
|
||||
MARGIN-LEFT: 2em;
|
||||
FONT-FAMILY: Courier,
|
||||
monospace;
|
||||
}
|
||||
*/
|
||||
|
|
@ -1,92 +0,0 @@
|
|||
|
||||
body
|
||||
{
|
||||
font-size: 12pt;
|
||||
}
|
||||
|
||||
pre
|
||||
{
|
||||
border-right: gray 1pt solid;
|
||||
border-top: gray 1pt solid;
|
||||
border-left: gray 1pt solid;
|
||||
border-bottom: gray 1pt solid;
|
||||
margin-left: 0pt;
|
||||
background-color: #EEEEEE;
|
||||
font-size: smaller;
|
||||
}
|
||||
|
||||
.button
|
||||
{
|
||||
color : black;
|
||||
background-color : #FFFFFF;
|
||||
border-radius: 0px;
|
||||
border: outset 3px #d6d6d6;
|
||||
text-decoration : none;
|
||||
outline:none;
|
||||
}
|
||||
|
||||
.fs
|
||||
{
|
||||
font-family: courier;
|
||||
font-size: 11pt;
|
||||
font-weight: bold;
|
||||
color: maroon;
|
||||
}
|
||||
|
||||
.code_string
|
||||
{
|
||||
font-family: courier;
|
||||
font-size: 11pt;
|
||||
font-weight: bold;
|
||||
color: #bc8f8f;
|
||||
}
|
||||
|
||||
.code
|
||||
{
|
||||
/*
|
||||
top: 0;
|
||||
border-style: inset;
|
||||
margin-top: 5pt;
|
||||
margin-bottom: 5pt;
|
||||
margin-left: 5pt;
|
||||
margin-right: 5pt;
|
||||
border-width: 2px 2px 2px 2px ;
|
||||
*/
|
||||
font-family: courier;
|
||||
font-size: 11pt;
|
||||
font-weight: bold;
|
||||
color: #228b22;
|
||||
}
|
||||
|
||||
.byte
|
||||
{
|
||||
border-right: gray 1pt solid;
|
||||
border-top: gray 1pt solid;
|
||||
border-left: gray 1pt solid;
|
||||
border-bottom: gray 1pt solid;
|
||||
margin-left: 2pt;
|
||||
margin-right: 2pt;
|
||||
font-family: courier;
|
||||
font-size: 11pt;
|
||||
font-weight: bold;
|
||||
color: #000000;
|
||||
background-color: #eeeeee;
|
||||
}
|
||||
|
||||
#pre
|
||||
{
|
||||
border-right: gray 1pt solid;
|
||||
border-top: gray 1pt solid;
|
||||
border-left: gray 1pt solid;
|
||||
border-bottom: gray 1pt solid;
|
||||
margin-left: 1pt;
|
||||
margin-right: 1pt;
|
||||
background-color: #EEEEEE;
|
||||
}
|
||||
|
||||
/*
|
||||
(C) Copyright 2011 François Mauger.
|
||||
Use, modification and distribution is subject to the Boost Software
|
||||
License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
|
||||
http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -84,6 +84,12 @@ namespace epee
|
|||
return res;
|
||||
}
|
||||
//-------------------------------------------------------------------------------------------------------------------
|
||||
|
||||
|
||||
#pragma pack(push, 1)
|
||||
template<class first_t, class second_t>
|
||||
struct pod_pair
|
||||
{
|
||||
first_t first;
|
||||
second_t second;
|
||||
};
|
||||
#pragma pack(pop)
|
||||
}
|
||||
|
|
@ -603,6 +603,14 @@ POP_GCC_WARNINGS
|
|||
s = *(t_pod_type*)bin_buff.data();
|
||||
return true;
|
||||
}
|
||||
//----------------------------------------------------------------------------
|
||||
template<class t_pod_type>
|
||||
t_pod_type hex_to_pod(const std::string& hex_str)
|
||||
{
|
||||
t_pod_type p = AUTO_VAL_INIT(p);
|
||||
hex_to_pod(hex_str, p);
|
||||
return p;
|
||||
}
|
||||
//----------------------------------------------------------------------------
|
||||
inline std::string get_extension(const std::string& str)
|
||||
{
|
||||
|
|
|
|||
32
src/common/atomics_boost_serialization.h
Normal file
32
src/common/atomics_boost_serialization.h
Normal file
|
|
@ -0,0 +1,32 @@
|
|||
// Copyright (c) 2014-2018 Zano Project
|
||||
// Distributed under the MIT/X11 software license, see the accompanying
|
||||
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <atomic>
|
||||
|
||||
namespace boost
|
||||
{
|
||||
namespace serialization
|
||||
{
|
||||
template <class Archive, class value_t>
|
||||
inline void save(Archive &a, const std::atomic<value_t> &x, const boost::serialization::version_type ver)
|
||||
{
|
||||
a << x.load();
|
||||
}
|
||||
|
||||
template <class Archive, class value_t>
|
||||
inline void load(Archive &a, std::atomic<value_t> &x, const boost::serialization::version_type ver)
|
||||
{
|
||||
value_t s = AUTO_VAL_INIT(s);
|
||||
a >> s;
|
||||
x.store(s);
|
||||
}
|
||||
template <class Archive, class value_t>
|
||||
inline void serialize(Archive &a, std::atomic<value_t> &x, const boost::serialization::version_type ver)
|
||||
{
|
||||
split_free(a, x, ver);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -71,6 +71,7 @@ using namespace currency;
|
|||
#define BLOCK_POS_STRICT_SEQUENCE_LIMIT 20
|
||||
|
||||
|
||||
|
||||
DISABLE_VS_WARNINGS(4267)
|
||||
|
||||
namespace
|
||||
|
|
@ -109,7 +110,8 @@ blockchain_storage::blockchain_storage(tx_memory_pool& tx_pool) :m_db(nullptr, m
|
|||
m_is_reorganize_in_process(false),
|
||||
m_deinit_is_done(false),
|
||||
m_cached_next_pow_difficulty(0),
|
||||
m_cached_next_pos_difficulty(0)
|
||||
m_cached_next_pos_difficulty(0),
|
||||
m_blockchain_launch_timestamp(0)
|
||||
|
||||
|
||||
{
|
||||
|
|
@ -2939,6 +2941,90 @@ bool blockchain_storage::find_blockchain_supplement(const std::list<crypto::hash
|
|||
return true;
|
||||
}
|
||||
//------------------------------------------------------------------
|
||||
uint64_t blockchain_storage::get_blockchain_launch_timestamp()const
|
||||
{
|
||||
if (m_blockchain_launch_timestamp)
|
||||
return m_blockchain_launch_timestamp;
|
||||
|
||||
if (m_db_blocks.size() > 2)
|
||||
{
|
||||
m_blockchain_launch_timestamp = m_db_blocks[1]->bl.timestamp;
|
||||
}
|
||||
return m_blockchain_launch_timestamp;
|
||||
}
|
||||
//------------------------------------------------------------------
|
||||
bool blockchain_storage::get_est_height_from_date(uint64_t date, uint64_t& res_h)const
|
||||
{
|
||||
CRITICAL_REGION_LOCAL(m_read_lock);
|
||||
#define GET_EST_HEIGHT_FROM_DATE_THRESHOLD 1440
|
||||
|
||||
if (date < get_blockchain_launch_timestamp())
|
||||
{
|
||||
res_h = 0;
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
uint64_t calculated_estimated_height = (date - get_blockchain_launch_timestamp()) / DIFFICULTY_TOTAL_TARGET;
|
||||
|
||||
if (date > m_db_blocks[m_db_blocks.size() - 1]->bl.timestamp)
|
||||
{
|
||||
//that suspicious but also could be(in case someone just created wallet offline in
|
||||
//console and then got it synchronyzing and last block had a little timestamp shift)
|
||||
//let's just return 1 day behind for safety reasons.
|
||||
if (m_db_blocks.size() > 1440)
|
||||
{
|
||||
res_h = m_db_blocks.size() - 1440;
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
//likely impossible, but just in case
|
||||
res_h = 0;
|
||||
}
|
||||
|
||||
}
|
||||
if (calculated_estimated_height > m_db_blocks.size() - 1)
|
||||
calculated_estimated_height = m_db_blocks.size() - 1;
|
||||
|
||||
//goal is to get timestamp in window in between 1day+1hour and 1 hour before target(1 hour is just to be sure that
|
||||
//we didn't miss actual wallet start because of timestamp and difficulty fluctuations)
|
||||
uint64_t low_boundary = date - 90000; //1 day + 1 hour
|
||||
uint64_t aim = date - 46800;
|
||||
uint64_t high_boundary = date - 3600; //1 hour
|
||||
|
||||
uint64_t iteration_coun = 0;
|
||||
while (true)
|
||||
{
|
||||
iteration_coun++;
|
||||
uint64_t correction = 0;
|
||||
uint64_t ts = m_db_blocks[calculated_estimated_height]->bl.timestamp;
|
||||
if (ts > high_boundary)
|
||||
{
|
||||
//we moved too much forward
|
||||
uint64_t offset = (ts - aim) / DIFFICULTY_TOTAL_TARGET;
|
||||
if (offset > calculated_estimated_height)
|
||||
{
|
||||
res_h = 0;
|
||||
break;
|
||||
}
|
||||
calculated_estimated_height -= offset;
|
||||
}
|
||||
else if (ts < low_boundary)
|
||||
{
|
||||
//we too much in past
|
||||
calculated_estimated_height += (aim - ts) / DIFFICULTY_TOTAL_TARGET;
|
||||
}
|
||||
else
|
||||
{
|
||||
res_h = calculated_estimated_height;
|
||||
break;
|
||||
}
|
||||
}
|
||||
LOG_PRINT_L0("[get_est_height_from_date] returned " << calculated_estimated_height << " with " << iteration_coun << " iterations");
|
||||
return true;
|
||||
}
|
||||
//------------------------------------------------------------------
|
||||
bool blockchain_storage::find_blockchain_supplement(const std::list<crypto::hash>& qblock_ids, std::list<std::pair<block, std::list<transaction> > >& blocks, uint64_t& total_height, uint64_t& start_height, size_t max_count)const
|
||||
{
|
||||
CRITICAL_REGION_LOCAL(m_read_lock);
|
||||
|
|
@ -2958,11 +3044,13 @@ bool blockchain_storage::find_blockchain_supplement(const std::list<crypto::hash
|
|||
return true;
|
||||
}
|
||||
//------------------------------------------------------------------
|
||||
bool blockchain_storage::find_blockchain_supplement(const std::list<crypto::hash>& qblock_ids, blocks_direct_container& blocks, uint64_t& total_height, uint64_t& start_height, size_t max_count)const
|
||||
bool blockchain_storage::find_blockchain_supplement(const std::list<crypto::hash>& qblock_ids, blocks_direct_container& blocks, uint64_t& total_height, uint64_t& start_height, size_t max_count, uint64_t minimum_height)const
|
||||
{
|
||||
CRITICAL_REGION_LOCAL(m_read_lock);
|
||||
if (!find_blockchain_supplement(qblock_ids, start_height))
|
||||
return false;
|
||||
if (minimum_height > start_height)
|
||||
start_height = minimum_height;
|
||||
|
||||
total_height = get_current_blockchain_size();
|
||||
size_t count = 0;
|
||||
|
|
|
|||
|
|
@ -255,7 +255,7 @@ namespace currency
|
|||
bool find_blockchain_supplement(const std::list<crypto::hash>& qblock_ids, NOTIFY_RESPONSE_CHAIN_ENTRY::request& resp)const;
|
||||
bool find_blockchain_supplement(const std::list<crypto::hash>& qblock_ids, uint64_t& starter_offset)const;
|
||||
bool find_blockchain_supplement(const std::list<crypto::hash>& qblock_ids, std::list<std::pair<block, std::list<transaction> > >& blocks, uint64_t& total_height, uint64_t& start_height, size_t max_count)const;
|
||||
bool find_blockchain_supplement(const std::list<crypto::hash>& qblock_ids, blocks_direct_container& blocks, uint64_t& total_height, uint64_t& start_height, size_t max_count)const;
|
||||
bool find_blockchain_supplement(const std::list<crypto::hash>& qblock_ids, blocks_direct_container& blocks, uint64_t& total_height, uint64_t& start_height, size_t max_count, uint64_t minimum_height = 0)const;
|
||||
//bool find_blockchain_supplement(const std::list<crypto::hash>& qblock_ids, std::list<std::pair<block, std::list<transaction> > >& blocks, uint64_t& total_height, uint64_t& start_height, size_t max_count)const;
|
||||
bool handle_get_objects(NOTIFY_REQUEST_GET_OBJECTS::request& arg, NOTIFY_RESPONSE_GET_OBJECTS::request& rsp)const;
|
||||
bool handle_get_objects(const COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::request& req, COMMAND_RPC_GET_RANDOM_OUTPUTS_FOR_AMOUNTS::response& res)const;
|
||||
|
|
@ -421,7 +421,7 @@ namespace currency
|
|||
|
||||
template<class archive_t>
|
||||
void serialize(archive_t & ar, const unsigned int version);
|
||||
|
||||
bool get_est_height_from_date(uint64_t date, uint64_t& res_h)const;
|
||||
|
||||
|
||||
//debug functions
|
||||
|
|
@ -535,7 +535,7 @@ namespace currency
|
|||
mutable uint64_t m_current_fee_median_effective_index;
|
||||
bool m_is_reorganize_in_process;
|
||||
mutable std::atomic<bool> m_deinit_is_done;
|
||||
|
||||
mutable uint64_t m_blockchain_launch_timestamp;
|
||||
|
||||
bool init_tx_fee_median();
|
||||
bool update_tx_fee_median();
|
||||
|
|
@ -616,6 +616,7 @@ namespace currency
|
|||
void pop_block_from_per_block_increments(uint64_t height_);
|
||||
void calculate_local_gindex_lookup_table_for_height(uint64_t split_height, std::map<uint64_t, uint64_t>& increments) const;
|
||||
void do_erase_altblock(alt_chain_container::iterator it);
|
||||
uint64_t get_blockchain_launch_timestamp()const;
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -51,6 +51,8 @@ namespace currency
|
|||
const static crypto::signature null_sig = AUTO_VAL_INIT(null_sig);
|
||||
const static crypto::key_derivation null_derivation = AUTO_VAL_INIT(null_derivation);
|
||||
|
||||
const static crypto::hash gdefault_genesis = epee::string_tools::hex_to_pod<crypto::hash>("CC608F59F8080E2FBFE3C8C80EB6E6A953D47CF2D6AEBD345BADA3A1CAB99852");
|
||||
|
||||
typedef std::string payment_id_t;
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -215,7 +215,8 @@
|
|||
#define BC_OFFERS_CURRENCY_MARKET_FILENAME "market.bin"
|
||||
|
||||
|
||||
#define WALLET_FILE_SERIALIZATION_VERSION (CURRENCY_FORMATION_VERSION+65)
|
||||
#define WALLET_FILE_SERIALIZATION_VERSION (CURRENCY_FORMATION_VERSION+66)
|
||||
|
||||
|
||||
#define CURRENT_MEMPOOL_ARCHIVE_VER (CURRENCY_FORMATION_VERSION+31)
|
||||
|
||||
|
|
@ -232,6 +233,7 @@
|
|||
#endif
|
||||
|
||||
|
||||
|
||||
static_assert(CURRENCY_MINER_TX_MAX_OUTS <= CURRENCY_TX_MAX_ALLOWED_OUTS, "Miner tx must obey normal tx max outs limit");
|
||||
static_assert(PREMINE_AMOUNT / WALLET_MAX_ALLOWED_OUTPUT_AMOUNT < CURRENCY_MINER_TX_MAX_OUTS, "Premine can't be divided into reasonable number of outs");
|
||||
|
||||
|
|
|
|||
|
|
@ -272,7 +272,7 @@ namespace currency
|
|||
}
|
||||
|
||||
blockchain_storage::blocks_direct_container bs;
|
||||
if(!m_core.get_blockchain_storage().find_blockchain_supplement(req.block_ids, bs, res.current_height, res.start_height, COMMAND_RPC_GET_BLOCKS_FAST_MAX_COUNT))
|
||||
if(!m_core.get_blockchain_storage().find_blockchain_supplement(req.block_ids, bs, res.current_height, res.start_height, COMMAND_RPC_GET_BLOCKS_FAST_MAX_COUNT, req.minimum_height))
|
||||
{
|
||||
res.status = CORE_RPC_STATUS_FAILED;
|
||||
return false;
|
||||
|
|
@ -288,7 +288,7 @@ namespace currency
|
|||
res.status = CORE_RPC_STATUS_OK;
|
||||
return true;
|
||||
}
|
||||
//------------------------------------------------------------------------------------------------------------------------------
|
||||
//------------------------------------------------------------------------------------------------------------------------------
|
||||
bool core_rpc_server::on_get_blocks(const COMMAND_RPC_GET_BLOCKS_FAST::request& req, COMMAND_RPC_GET_BLOCKS_FAST::response& res, connection_context& cntx)
|
||||
{
|
||||
CHECK_CORE_READY();
|
||||
|
|
@ -1263,6 +1263,17 @@ namespace currency
|
|||
return true;
|
||||
}
|
||||
//------------------------------------------------------------------------------------------------------------------------------
|
||||
bool core_rpc_server::on_get_est_height_from_date(const COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE::request& req, COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE::response& res, connection_context& cntx)
|
||||
{
|
||||
bool r = m_core.get_blockchain_storage().get_est_height_from_date(req.timestamp, res.h);
|
||||
|
||||
if (r)
|
||||
res.status = CORE_RPC_STATUS_OK;
|
||||
else
|
||||
res.status = CORE_RPC_STATUS_NOT_FOUND;
|
||||
return true;
|
||||
}
|
||||
//------------------------------------------------------------------------------------------------------------------------------
|
||||
bool core_rpc_server::on_alias_by_address(const COMMAND_RPC_GET_ALIASES_BY_ADDRESS::request& req, COMMAND_RPC_GET_ALIASES_BY_ADDRESS::response& res, epee::json_rpc::error& error_resp, connection_context& cntx)
|
||||
{
|
||||
account_public_address addr = AUTO_VAL_INIT(addr);
|
||||
|
|
|
|||
|
|
@ -39,6 +39,7 @@ namespace currency
|
|||
bool init(const boost::program_options::variables_map& vm);
|
||||
|
||||
bool on_get_blocks_direct(const COMMAND_RPC_GET_BLOCKS_DIRECT::request& req, COMMAND_RPC_GET_BLOCKS_DIRECT::response& res, connection_context& cntx);
|
||||
|
||||
|
||||
bool on_get_height(const COMMAND_RPC_GET_HEIGHT::request& req, COMMAND_RPC_GET_HEIGHT::response& res, connection_context& cntx);
|
||||
bool on_get_blocks(const COMMAND_RPC_GET_BLOCKS_FAST::request& req, COMMAND_RPC_GET_BLOCKS_FAST::response& res, connection_context& cntx);
|
||||
|
|
@ -88,6 +89,8 @@ namespace currency
|
|||
bool on_get_main_block_details(const COMMAND_RPC_GET_BLOCK_DETAILS::request& req, COMMAND_RPC_GET_BLOCK_DETAILS::response& res, epee::json_rpc::error& error_resp, connection_context& cntx);
|
||||
bool on_get_alt_block_details(const COMMAND_RPC_GET_BLOCK_DETAILS::request& req, COMMAND_RPC_GET_BLOCK_DETAILS::response& res, epee::json_rpc::error& error_resp, connection_context& cntx);
|
||||
bool on_get_alt_blocks_details(const COMMAND_RPC_GET_ALT_BLOCKS_DETAILS::request& req, COMMAND_RPC_GET_ALT_BLOCKS_DETAILS::response& res, connection_context& cntx);
|
||||
bool on_get_est_height_from_date(const COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE::request& req, COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE::response& res, connection_context& cntx);
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -133,6 +136,7 @@ namespace currency
|
|||
MAP_JON_RPC_WE("get_alias_details", on_get_alias_details, COMMAND_RPC_GET_ALIAS_DETAILS)
|
||||
MAP_JON_RPC_WE("get_alias_by_address", on_alias_by_address, COMMAND_RPC_GET_ALIASES_BY_ADDRESS)
|
||||
MAP_JON_RPC_WE("get_alias_reward", on_get_alias_reward, COMMAND_RPC_GET_ALIAS_REWARD)
|
||||
MAP_JON_RPC ("get_est_height_from_date", on_get_est_height_from_date, COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE)
|
||||
//block explorer api
|
||||
MAP_JON_RPC ("get_blocks_details", on_rpc_get_blocks_details, COMMAND_RPC_GET_BLOCKS_DETAILS)
|
||||
MAP_JON_RPC_WE("get_tx_details", on_get_tx_details, COMMAND_RPC_GET_TX_DETAILS)
|
||||
|
|
|
|||
|
|
@ -115,9 +115,11 @@ namespace currency
|
|||
|
||||
struct request
|
||||
{
|
||||
uint64_t minimum_height;
|
||||
std::list<crypto::hash> block_ids; //*first 10 blocks id goes sequential, next goes in pow(2,n) offset, like 2, 4, 8, 16, 32, 64 and so on, and the last one is always genesis block */
|
||||
|
||||
BEGIN_KV_SERIALIZE_MAP()
|
||||
KV_SERIALIZE(minimum_height)
|
||||
KV_SERIALIZE_CONTAINER_POD_AS_BLOB(block_ids)
|
||||
END_KV_SERIALIZE_MAP()
|
||||
};
|
||||
|
|
@ -141,8 +143,6 @@ namespace currency
|
|||
typedef COMMAND_RPC_GET_BLOCKS_FAST_T<block_complete_entry> COMMAND_RPC_GET_BLOCKS_FAST;
|
||||
typedef COMMAND_RPC_GET_BLOCKS_FAST_T<block_direct_data_entry> COMMAND_RPC_GET_BLOCKS_DIRECT;
|
||||
|
||||
|
||||
|
||||
//-----------------------------------------------
|
||||
struct COMMAND_RPC_GET_TRANSACTIONS
|
||||
{
|
||||
|
|
@ -169,6 +169,30 @@ namespace currency
|
|||
END_KV_SERIALIZE_MAP()
|
||||
};
|
||||
};
|
||||
|
||||
//-----------------------------------------------
|
||||
struct COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE
|
||||
{
|
||||
struct request
|
||||
{
|
||||
uint64_t timestamp;
|
||||
|
||||
BEGIN_KV_SERIALIZE_MAP()
|
||||
KV_SERIALIZE(timestamp)
|
||||
END_KV_SERIALIZE_MAP()
|
||||
};
|
||||
|
||||
struct response
|
||||
{
|
||||
uint64_t h;
|
||||
std::string status;
|
||||
|
||||
BEGIN_KV_SERIALIZE_MAP()
|
||||
KV_SERIALIZE(h)
|
||||
KV_SERIALIZE(status)
|
||||
END_KV_SERIALIZE_MAP()
|
||||
};
|
||||
};
|
||||
//-----------------------------------------------
|
||||
struct COMMAND_RPC_GET_TX_POOL
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1116,7 +1116,7 @@ bool simple_wallet::show_blockchain_height(const std::vector<std::string>& args)
|
|||
bool simple_wallet::show_wallet_bcheight(const std::vector<std::string>& args)
|
||||
{
|
||||
|
||||
uint64_t bc_height = m_wallet->get_blockchain_current_height();
|
||||
uint64_t bc_height = m_wallet->get_blockchain_current_size();
|
||||
success_msg_writer() << bc_height;
|
||||
return true;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -50,6 +50,11 @@ namespace tools
|
|||
return r;
|
||||
}
|
||||
//------------------------------------------------------------------------------------------------------------------------------
|
||||
bool default_http_core_proxy::call_COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE(const currency::COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE::request& rqt, currency::COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE::response& rsp)
|
||||
{
|
||||
return invoke_http_json_rpc_update_is_disconnect("get_est_height_from_date", rqt, rsp);
|
||||
}
|
||||
//------------------------------------------------------------------------------------------------------------------------------
|
||||
bool default_http_core_proxy::call_COMMAND_RPC_GET_INFO(const currency::COMMAND_RPC_GET_INFO::request& req, currency::COMMAND_RPC_GET_INFO::response& res)
|
||||
{
|
||||
return invoke_http_json_remote_command2_update_is_disconnect("/getinfo", req, res);
|
||||
|
|
|
|||
|
|
@ -28,6 +28,7 @@ namespace tools
|
|||
bool call_COMMAND_RPC_GET_TX_GLOBAL_OUTPUTS_INDEXES(const currency::COMMAND_RPC_GET_TX_GLOBAL_OUTPUTS_INDEXES::request& rqt, currency::COMMAND_RPC_GET_TX_GLOBAL_OUTPUTS_INDEXES::response& rsp) override;
|
||||
bool call_COMMAND_RPC_GET_BLOCKS_FAST(const currency::COMMAND_RPC_GET_BLOCKS_FAST::request& rqt, currency::COMMAND_RPC_GET_BLOCKS_FAST::response& rsp) override;
|
||||
bool call_COMMAND_RPC_GET_BLOCKS_DIRECT(const currency::COMMAND_RPC_GET_BLOCKS_DIRECT::request& rqt, currency::COMMAND_RPC_GET_BLOCKS_DIRECT::response& rsp) override;
|
||||
bool call_COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE(const currency::COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE::request& rqt, currency::COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE::response& rsp) override;
|
||||
bool call_COMMAND_RPC_GET_INFO(const currency::COMMAND_RPC_GET_INFO::request& rqt, currency::COMMAND_RPC_GET_INFO::response& rsp) override;
|
||||
bool call_COMMAND_RPC_GET_TX_POOL(const currency::COMMAND_RPC_GET_TX_POOL::request& rqt, currency::COMMAND_RPC_GET_TX_POOL::response& rsp) override;
|
||||
bool call_COMMAND_RPC_GET_ALIASES_BY_ADDRESS(const currency::COMMAND_RPC_GET_ALIASES_BY_ADDRESS::request& rqt, currency::COMMAND_RPC_GET_ALIASES_BY_ADDRESS::response& rsp) override;
|
||||
|
|
|
|||
|
|
@ -33,6 +33,10 @@ namespace tools
|
|||
{
|
||||
return m_rpc.on_get_blocks_direct(rqt, rsp, m_cntxt_stub);
|
||||
}
|
||||
bool call_COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE(const currency::COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE::request& rqt, currency::COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE::response& rsp) override
|
||||
{
|
||||
return m_rpc.on_get_est_height_from_date(rqt, rsp, m_cntxt_stub);
|
||||
}
|
||||
//------------------------------------------------------------------------------------------------------------------------------
|
||||
bool call_COMMAND_RPC_GET_INFO(const currency::COMMAND_RPC_GET_INFO::request& req, currency::COMMAND_RPC_GET_INFO::response& res) override
|
||||
{
|
||||
|
|
|
|||
|
|
@ -22,6 +22,7 @@ namespace tools
|
|||
virtual bool call_COMMAND_RPC_GET_TX_GLOBAL_OUTPUTS_INDEXES(const currency::COMMAND_RPC_GET_TX_GLOBAL_OUTPUTS_INDEXES::request& rqt, currency::COMMAND_RPC_GET_TX_GLOBAL_OUTPUTS_INDEXES::response& rsp){ return false; }
|
||||
virtual bool call_COMMAND_RPC_GET_BLOCKS_FAST(const currency::COMMAND_RPC_GET_BLOCKS_FAST::request& rqt, currency::COMMAND_RPC_GET_BLOCKS_FAST::response& rsp){ return false; }
|
||||
virtual bool call_COMMAND_RPC_GET_BLOCKS_DIRECT(const currency::COMMAND_RPC_GET_BLOCKS_DIRECT::request& rqt, currency::COMMAND_RPC_GET_BLOCKS_DIRECT::response& rsp) { return false; }
|
||||
virtual bool call_COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE(const currency::COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE::request& rqt, currency::COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE::response& rsp) { return false; }
|
||||
virtual bool call_COMMAND_RPC_GET_INFO(const currency::COMMAND_RPC_GET_INFO::request& rqt, currency::COMMAND_RPC_GET_INFO::response& rsp){ return false; }
|
||||
virtual bool call_COMMAND_RPC_GET_TX_POOL(const currency::COMMAND_RPC_GET_TX_POOL::request& rqt, currency::COMMAND_RPC_GET_TX_POOL::response& rsp){ return false; }
|
||||
virtual bool call_COMMAND_RPC_GET_ALIASES_BY_ADDRESS(const currency::COMMAND_RPC_GET_ALIASES_BY_ADDRESS::request& rqt, currency::COMMAND_RPC_GET_ALIASES_BY_ADDRESS::response& rsp){ return false; }
|
||||
|
|
|
|||
|
|
@ -1070,8 +1070,8 @@ void wallet2::process_unconfirmed(const currency::transaction& tx, std::vector<s
|
|||
void wallet2::process_new_blockchain_entry(const currency::block& b, const currency::block_direct_data_entry& bche, const crypto::hash& bl_id, uint64_t height)
|
||||
{
|
||||
//handle transactions from new block
|
||||
THROW_IF_TRUE_WALLET_EX(height != m_blockchain.size(), error::wallet_internal_error,
|
||||
"current_index=" + std::to_string(height) + ", m_blockchain.size()=" + std::to_string(m_blockchain.size()));
|
||||
THROW_IF_TRUE_WALLET_EX(height != get_blockchain_current_size(), error::wallet_internal_error,
|
||||
"current_index=" + std::to_string(height) + ", get_blockchain_current_height()=" + std::to_string(get_blockchain_current_size()));
|
||||
|
||||
//optimization: seeking only for blocks that are not older then the wallet creation time plus 1 day. 1 day is for possible user incorrect time setup
|
||||
if (b.timestamp + 60 * 60 * 24 > m_account.get_createtime())
|
||||
|
|
@ -1091,8 +1091,7 @@ void wallet2::process_new_blockchain_entry(const currency::block& b, const curre
|
|||
{
|
||||
WLT_LOG_L3( "Skipped block by timestamp, height: " << height << ", block time " << b.timestamp << ", account time " << m_account.get_createtime());
|
||||
}
|
||||
m_blockchain.push_back(bl_id);
|
||||
++m_local_bc_height;
|
||||
m_chain.push_new_block_id(bl_id, height); //m_blockchain.push_back(bl_id);
|
||||
m_last_bc_timestamp = b.timestamp;
|
||||
if (!is_pos_block(b))
|
||||
m_last_pow_block_h = height;
|
||||
|
|
@ -1100,32 +1099,54 @@ void wallet2::process_new_blockchain_entry(const currency::block& b, const curre
|
|||
m_wcallback->on_new_block(height, b);
|
||||
}
|
||||
//----------------------------------------------------------------------------------------------------
|
||||
void wallet2::get_short_chain_history(std::list<crypto::hash>& ids)
|
||||
|
||||
//----------------------------------------------------------------------------------------------------
|
||||
// void wallet2::get_short_chain_history(std::list<crypto::hash>& ids)
|
||||
// {
|
||||
// ids.clear();
|
||||
// size_t i = 0;
|
||||
// size_t current_multiplier = 1;
|
||||
// size_t sz = get_blockchain_current_height();
|
||||
// if(!sz)
|
||||
// return;
|
||||
// size_t current_back_offset = 1;
|
||||
// bool genesis_included = false;
|
||||
// while(current_back_offset < sz)
|
||||
// {
|
||||
// ids.push_back(m_blockchain[sz-current_back_offset]);
|
||||
// if(sz-current_back_offset == 0)
|
||||
// genesis_included = true;
|
||||
// if(i < 10)
|
||||
// {
|
||||
// ++current_back_offset;
|
||||
// }else
|
||||
// {
|
||||
// current_back_offset += current_multiplier *= 2;
|
||||
// }
|
||||
// ++i;
|
||||
// }
|
||||
// if(!genesis_included)
|
||||
// ids.push_back(m_blockchain[0]);
|
||||
// }
|
||||
|
||||
//----------------------------------------------------------------------------------------------------
|
||||
void wallet2::set_minimum_height(uint64_t h)
|
||||
{
|
||||
ids.clear();
|
||||
size_t i = 0;
|
||||
size_t current_multiplier = 1;
|
||||
size_t sz = m_blockchain.size();
|
||||
if(!sz)
|
||||
return;
|
||||
size_t current_back_offset = 1;
|
||||
bool genesis_included = false;
|
||||
while(current_back_offset < sz)
|
||||
{
|
||||
ids.push_back(m_blockchain[sz-current_back_offset]);
|
||||
if(sz-current_back_offset == 0)
|
||||
genesis_included = true;
|
||||
if(i < 10)
|
||||
{
|
||||
++current_back_offset;
|
||||
}else
|
||||
{
|
||||
current_back_offset += current_multiplier *= 2;
|
||||
}
|
||||
++i;
|
||||
}
|
||||
if(!genesis_included)
|
||||
ids.push_back(m_blockchain[0]);
|
||||
m_minimum_height = h;
|
||||
}
|
||||
//----------------------------------------------------------------------------------------------------
|
||||
uint64_t wallet2::get_wallet_minimum_height()
|
||||
{
|
||||
if (m_minimum_height)
|
||||
return m_minimum_height;
|
||||
|
||||
currency::COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE::request req = AUTO_VAL_INIT(req);
|
||||
currency::COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE::response res = AUTO_VAL_INIT(res);
|
||||
req.timestamp = m_account.get_createtime();
|
||||
bool r = m_core_proxy->call_COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE(req, res);
|
||||
THROW_IF_FALSE_WALLET_EX(r, error::no_connection_to_daemon, "call_COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE");
|
||||
WLT_THROW_IF_FALSE_WALLET_INT_ERR_EX(res.status == CORE_RPC_STATUS_OK, "FAILED TO CALL COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE");
|
||||
return res.h;
|
||||
}
|
||||
//----------------------------------------------------------------------------------------------------
|
||||
void wallet2::pull_blocks(size_t& blocks_added, std::atomic<bool>& stop)
|
||||
|
|
@ -1133,7 +1154,9 @@ void wallet2::pull_blocks(size_t& blocks_added, std::atomic<bool>& stop)
|
|||
blocks_added = 0;
|
||||
currency::COMMAND_RPC_GET_BLOCKS_DIRECT::request req = AUTO_VAL_INIT(req);
|
||||
currency::COMMAND_RPC_GET_BLOCKS_DIRECT::response res = AUTO_VAL_INIT(res);
|
||||
get_short_chain_history(req.block_ids);
|
||||
|
||||
req.minimum_height = get_wallet_minimum_height();
|
||||
m_chain.get_short_chain_history(req.block_ids);
|
||||
bool r = m_core_proxy->call_COMMAND_RPC_GET_BLOCKS_DIRECT(req, res);
|
||||
if (!r)
|
||||
throw error::no_connection_to_daemon(LOCATION_STR, "getblocks.bin");
|
||||
|
|
@ -1154,9 +1177,9 @@ void wallet2::pull_blocks(size_t& blocks_added, std::atomic<bool>& stop)
|
|||
r = string_tools::parse_tpod_from_hex_string(gbd_res.blocks.back().id, new_genesis_id);
|
||||
THROW_IF_TRUE_WALLET_EX(!r, error::no_connection_to_daemon, "get_blocks_details");
|
||||
reset_all();
|
||||
m_blockchain.push_back(new_genesis_id);
|
||||
m_chain.set_genesis(new_genesis_id);
|
||||
WLT_LOG_MAGENTA("New genesis set for wallet: " << new_genesis_id, LOG_LEVEL_0);
|
||||
get_short_chain_history(req.block_ids);
|
||||
m_chain.get_short_chain_history(req.block_ids);
|
||||
//req.block_ids.push_back(new_genesis_id);
|
||||
bool r = m_core_proxy->call_COMMAND_RPC_GET_BLOCKS_DIRECT(req, res);
|
||||
THROW_IF_TRUE_WALLET_EX(!r, error::no_connection_to_daemon, "getblocks.bin");
|
||||
|
|
@ -1168,59 +1191,94 @@ void wallet2::pull_blocks(size_t& blocks_added, std::atomic<bool>& stop)
|
|||
return;
|
||||
}
|
||||
THROW_IF_TRUE_WALLET_EX(res.status != CORE_RPC_STATUS_OK, error::get_blocks_error, res.status);
|
||||
THROW_IF_TRUE_WALLET_EX(m_blockchain.size() && m_blockchain.size() <= res.start_height, error::wallet_internal_error,
|
||||
THROW_IF_TRUE_WALLET_EX(get_blockchain_current_size() && get_blockchain_current_size() <= res.start_height, error::wallet_internal_error,
|
||||
"wrong daemon response: m_start_height=" + std::to_string(res.start_height) +
|
||||
" not less than local blockchain size=" + std::to_string(m_blockchain.size()));
|
||||
" not less than local blockchain size=" + std::to_string(get_blockchain_current_size()));
|
||||
|
||||
handle_pulled_blocks(blocks_added, stop, res);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------------------------------
|
||||
void wallet2::handle_pulled_blocks(size_t& blocks_added, std::atomic<bool>& stop,
|
||||
currency::COMMAND_RPC_GET_BLOCKS_DIRECT::response& res)
|
||||
{
|
||||
size_t current_index = res.start_height;
|
||||
|
||||
if (res.start_height == 0 && m_blockchain.size() == 1 && !res.blocks.empty())
|
||||
bool been_matched_block = false;
|
||||
if (res.start_height == 0 && get_blockchain_current_size() == 1 && !res.blocks.empty())
|
||||
{
|
||||
const currency::block& genesis = res.blocks.front().block_ptr->bl;
|
||||
THROW_IF_TRUE_WALLET_EX(get_block_height(genesis) != 0, error::wallet_internal_error, "first block expected to be genesis");
|
||||
process_genesis_if_needed(genesis);
|
||||
res.blocks.pop_front();
|
||||
++current_index;
|
||||
been_matched_block = true;
|
||||
}
|
||||
|
||||
uint64_t last_matched_index = 0;
|
||||
for(const auto& bl_entry: res.blocks)
|
||||
{
|
||||
if (stop)
|
||||
break;
|
||||
|
||||
const currency::block& bl = bl_entry.block_ptr->bl;
|
||||
uint64_t height = get_block_height(bl);
|
||||
uint64_t processed_blocks_count = get_blockchain_current_size();
|
||||
|
||||
//TODO: get_block_hash is slow
|
||||
crypto::hash bl_id = get_block_hash(bl);
|
||||
|
||||
if (current_index >= m_blockchain.size())
|
||||
{
|
||||
process_new_blockchain_entry(bl, bl_entry, bl_id, current_index);
|
||||
++blocks_added;
|
||||
if (height > processed_blocks_count)
|
||||
{//internal error:
|
||||
WLT_THROW_IF_FALSE_WALLET_INT_ERR_EX(false,
|
||||
"height{" << height <<"} > processed_blocks_count{" << processed_blocks_count << "}");
|
||||
}
|
||||
else if(bl_id != m_blockchain[current_index])
|
||||
else if (height == processed_blocks_count)
|
||||
{
|
||||
//split detected here !!!
|
||||
THROW_IF_TRUE_WALLET_EX(current_index == res.start_height, error::wallet_internal_error,
|
||||
"wrong daemon response: split starts from the first block in response " + string_tools::pod_to_hex(bl_id) +
|
||||
" (height " + std::to_string(res.start_height) + "), local block id at this height: " +
|
||||
string_tools::pod_to_hex(m_blockchain[current_index]));
|
||||
//regular block handling
|
||||
//self check
|
||||
WLT_THROW_IF_FALSE_WALLET_INT_ERR_EX(been_matched_block,
|
||||
"internal error: been_matched_block == false on process_new_blockchain_entry, bl_id" << bl_id << "h=" << height
|
||||
<< " (start_height=" + std::to_string(res.start_height) + ")");
|
||||
|
||||
detach_blockchain(current_index);
|
||||
process_new_blockchain_entry(bl, bl_entry, bl_id, current_index);
|
||||
++blocks_added;
|
||||
}
|
||||
else
|
||||
{
|
||||
WLT_LOG_L2("Block " << bl_id << " @ " << current_index << " is already in wallet's blockchain");
|
||||
{
|
||||
//checking if we need reorganize (might be just first matched block)
|
||||
bool block_found = false;
|
||||
bool block_matched = false;
|
||||
bool full_reset_needed = false;
|
||||
m_chain.check_if_block_matched(height, bl_id, block_found, block_matched, full_reset_needed);
|
||||
if (block_found && block_matched)
|
||||
{
|
||||
//block matched in that number
|
||||
last_matched_index = height;
|
||||
been_matched_block = true;
|
||||
WLT_LOG_L2("Block " << bl_id << " @ " << height << " is already in wallet's blockchain");
|
||||
}
|
||||
else
|
||||
{
|
||||
//this should happen ONLY after block been matched, if not then is internal error
|
||||
if (full_reset_needed)
|
||||
{
|
||||
last_matched_index = 0;
|
||||
been_matched_block = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
WLT_THROW_IF_FALSE_WALLET_INT_ERR_EX(been_matched_block,
|
||||
"unmatched block while never been mathced block");
|
||||
}
|
||||
//TODO: take into account date of wallet creation
|
||||
//reorganize
|
||||
detach_blockchain(last_matched_index+1);
|
||||
process_new_blockchain_entry(bl, bl_entry, bl_id, height);
|
||||
++blocks_added;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
++current_index;
|
||||
if (res.current_height > m_height_of_start_sync)
|
||||
{
|
||||
|
|
@ -1233,7 +1291,7 @@ void wallet2::handle_pulled_blocks(size_t& blocks_added, std::atomic<bool>& stop
|
|||
}
|
||||
}
|
||||
|
||||
WLT_LOG_L1("[PULL BLOCKS] " << res.start_height << " --> " << m_blockchain.size());
|
||||
WLT_LOG_L1("[PULL BLOCKS] " << res.start_height << " --> " << get_blockchain_current_size());
|
||||
}
|
||||
//----------------------------------------------------------------------------------------------------
|
||||
uint64_t wallet2::get_sync_progress()
|
||||
|
|
@ -1610,7 +1668,7 @@ void wallet2::refresh(size_t & blocks_fetched, bool& received_money, std::atomic
|
|||
size_t added_blocks = 0;
|
||||
size_t try_count = 0;
|
||||
crypto::hash last_tx_hash_id = m_transfers.size() ? get_transaction_hash(m_transfers.back().m_ptx_wallet_info->m_tx) : null_hash;
|
||||
m_height_of_start_sync = m_blockchain.size();
|
||||
m_height_of_start_sync = get_blockchain_current_size();
|
||||
m_last_sync_percent = 0;
|
||||
while (!stop.load(std::memory_order_relaxed))
|
||||
{
|
||||
|
|
@ -1718,15 +1776,25 @@ bool wallet2::refresh(size_t & blocks_fetched, bool& received_money, bool& ok, s
|
|||
}
|
||||
return ok;
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------------------------------
|
||||
void wallet2::detach_blockchain(uint64_t height)
|
||||
uint64_t wallet2::detach_from_block_ids(uint64_t including_height)
|
||||
{
|
||||
WLT_LOG_L0("Detaching blockchain on height " << height);
|
||||
//calculate number of erased blocks
|
||||
uint64_t blocks_detached = get_blockchain_current_size() - including_height;
|
||||
//id at height should be kept, the rest - erased
|
||||
m_chain.detach(including_height);
|
||||
return blocks_detached;
|
||||
}
|
||||
//----------------------------------------------------------------------------------------------------
|
||||
void wallet2::detach_blockchain(uint64_t including_height)
|
||||
{
|
||||
WLT_LOG_L0("Detaching blockchain on height " << including_height);
|
||||
size_t transfers_detached = 0;
|
||||
|
||||
// rollback incoming transfers from detaching subchain
|
||||
{
|
||||
auto it = std::find_if(m_transfers.begin(), m_transfers.end(), [&](const transfer_details& td){return td.m_ptx_wallet_info->m_block_height >= height; });
|
||||
auto it = std::find_if(m_transfers.begin(), m_transfers.end(), [&](const transfer_details& td){return td.m_ptx_wallet_info->m_block_height >= including_height; });
|
||||
if (it != m_transfers.end())
|
||||
{
|
||||
size_t i_start = it - m_transfers.begin();
|
||||
|
|
@ -1735,7 +1803,7 @@ void wallet2::detach_blockchain(uint64_t height)
|
|||
{
|
||||
auto it_ki = m_key_images.find(m_transfers[i].m_key_image);
|
||||
WLT_THROW_IF_FALSE_WALLET_INT_ERR_EX(it_ki != m_key_images.end(), "key image " << m_transfers[i].m_key_image << " not found");
|
||||
WLT_THROW_IF_FALSE_WALLET_INT_ERR_EX(m_transfers[i].m_ptx_wallet_info->m_block_height >= height, "transfer #" << i << " block height is less than " << height);
|
||||
WLT_THROW_IF_FALSE_WALLET_INT_ERR_EX(m_transfers[i].m_ptx_wallet_info->m_block_height >= including_height, "transfer #" << i << " block height is less than " << including_height);
|
||||
m_key_images.erase(it_ki);
|
||||
++transfers_detached;
|
||||
}
|
||||
|
|
@ -1743,9 +1811,7 @@ void wallet2::detach_blockchain(uint64_t height)
|
|||
}
|
||||
}
|
||||
|
||||
size_t blocks_detached = m_blockchain.end() - (m_blockchain.begin()+height);
|
||||
m_blockchain.erase(m_blockchain.begin()+height, m_blockchain.end());
|
||||
m_local_bc_height -= blocks_detached;
|
||||
size_t blocks_detached = detach_from_block_ids(including_height);
|
||||
|
||||
//rollback spends
|
||||
// do not clear spent flag in spent transfers as corresponding txs are most likely in the pool
|
||||
|
|
@ -1753,7 +1819,7 @@ void wallet2::detach_blockchain(uint64_t height)
|
|||
for (size_t i = 0, sz = m_transfers.size(); i < sz; ++i)
|
||||
{
|
||||
auto& tr = m_transfers[i];
|
||||
if (tr.m_spent_height >= height)
|
||||
if (tr.m_spent_height >= including_height)
|
||||
{
|
||||
WLT_LOG_BLUE("Transfer [" << i << "] spent height: " << tr.m_spent_height << " -> 0, reason: detaching blockchain", LOG_LEVEL_1);
|
||||
tr.m_spent_height = 0;
|
||||
|
|
@ -1764,7 +1830,7 @@ void wallet2::detach_blockchain(uint64_t height)
|
|||
auto tr_hist_it = m_transfer_history.rend();
|
||||
for (auto it = m_transfer_history.rbegin(); it != m_transfer_history.rend(); it++)
|
||||
{
|
||||
if (it->height < height)
|
||||
if (it->height < including_height)
|
||||
break;
|
||||
tr_hist_it = it; // note that tr_hist_it->height >= height
|
||||
}
|
||||
|
|
@ -1794,13 +1860,13 @@ void wallet2::detach_blockchain(uint64_t height)
|
|||
//rollback payments
|
||||
for (auto it = m_payments.begin(); it != m_payments.end(); )
|
||||
{
|
||||
if(height <= it->second.m_block_height)
|
||||
if(including_height <= it->second.m_block_height)
|
||||
it = m_payments.erase(it);
|
||||
else
|
||||
++it;
|
||||
}
|
||||
|
||||
WLT_LOG_L0("Detached blockchain on height " << height << ", transfers detached " << transfers_detached << ", blocks detached " << blocks_detached);
|
||||
WLT_LOG_L0("Detached blockchain on height " << including_height << ", transfers detached " << transfers_detached << ", blocks detached " << blocks_detached);
|
||||
}
|
||||
//----------------------------------------------------------------------------------------------------
|
||||
bool wallet2::deinit()
|
||||
|
|
@ -1812,15 +1878,17 @@ bool wallet2::deinit()
|
|||
bool wallet2::clear()
|
||||
{
|
||||
reset_all();
|
||||
currency::block b;
|
||||
currency::generate_genesis_block(b);
|
||||
m_blockchain.push_back(get_block_hash(b));
|
||||
//currency::block b;
|
||||
//currency::generate_genesis_block(b);
|
||||
m_chain.clear();
|
||||
//m_blockchain.push_back(get_block_hash(b));
|
||||
return true;
|
||||
}
|
||||
//----------------------------------------------------------------------------------------------------
|
||||
bool wallet2::reset_all()
|
||||
{
|
||||
m_blockchain.clear();
|
||||
//m_blockchain.clear();
|
||||
m_chain.clear();
|
||||
m_transfers.clear();
|
||||
m_key_images.clear();
|
||||
// m_pending_key_images is not cleared intentionally
|
||||
|
|
@ -1833,7 +1901,7 @@ bool wallet2::reset_all()
|
|||
m_transfer_history.clear();
|
||||
//m_account = AUTO_VAL_INIT(m_account);
|
||||
|
||||
m_local_bc_height = 1;
|
||||
//m_local_bc_size = 1; //including genesis
|
||||
m_last_bc_timestamp = 0;
|
||||
m_height_of_start_sync = 0;
|
||||
m_last_sync_percent = 0;
|
||||
|
|
@ -2075,7 +2143,6 @@ void wallet2::load(const std::wstring& wallet_, const std::string& password)
|
|||
{
|
||||
reset_history();
|
||||
}
|
||||
m_local_bc_height = m_blockchain.size();
|
||||
THROW_IF_TRUE_WALLET_EX(need_to_resync, error::wallet_load_notice_wallet_restored, epee::string_encoding::convert_to_ansii(m_wallet_file));
|
||||
|
||||
WLT_LOG_L0("Loaded wallet file" << (m_watch_only ? " (WATCH ONLY) " : " ") << string_encoding::convert_to_ansii(m_wallet_file) << " with public address: " << m_account.get_public_address_str());
|
||||
|
|
@ -2623,7 +2690,7 @@ bool wallet2::is_transfer_okay_for_pos(const transfer_details& tr, uint64_t& sta
|
|||
return false;
|
||||
|
||||
//prevent staking of after-last-pow-coins
|
||||
if (m_blockchain.size() - tr.m_ptx_wallet_info->m_block_height <= m_core_runtime_config.min_coinstake_age)
|
||||
if (get_blockchain_current_size() - tr.m_ptx_wallet_info->m_block_height <= m_core_runtime_config.min_coinstake_age)
|
||||
return false;
|
||||
|
||||
if (tr.m_ptx_wallet_info->m_block_height > m_last_pow_block_h)
|
||||
|
|
@ -2808,9 +2875,7 @@ bool wallet2::reset_history()
|
|||
std::string pass = m_password;
|
||||
std::wstring file_path = m_wallet_file;
|
||||
account_base acc_tmp = m_account;
|
||||
crypto::hash genesis_hash = m_blockchain[0];
|
||||
clear();
|
||||
m_blockchain[0] = genesis_hash;
|
||||
m_account = acc_tmp;
|
||||
m_password = pass;
|
||||
prepare_file_names(file_path);
|
||||
|
|
@ -2945,20 +3010,20 @@ bool wallet2::is_transfer_unlocked(const transfer_details& td, bool for_pos_mini
|
|||
if (td.m_flags&WALLET_TRANSFER_DETAIL_FLAG_BLOCKED)
|
||||
return false;
|
||||
|
||||
if (td.m_ptx_wallet_info->m_block_height + WALLET_DEFAULT_TX_SPENDABLE_AGE > m_blockchain.size())
|
||||
if (td.m_ptx_wallet_info->m_block_height + WALLET_DEFAULT_TX_SPENDABLE_AGE > get_blockchain_current_size())
|
||||
return false;
|
||||
|
||||
|
||||
|
||||
uint64_t unlock_time = get_tx_unlock_time(td.m_ptx_wallet_info->m_tx, td.m_internal_output_index);
|
||||
if (for_pos_mining && m_blockchain.size() > m_core_runtime_config.hard_fork_01_starts_after_height)
|
||||
if (for_pos_mining && get_blockchain_current_size() > m_core_runtime_config.hard_fork_01_starts_after_height)
|
||||
{
|
||||
//allowed of staking locked coins with
|
||||
stake_lock_time = unlock_time;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (!currency::is_tx_spendtime_unlocked(unlock_time, m_blockchain.size(), m_core_runtime_config.get_core_time()))
|
||||
if (!currency::is_tx_spendtime_unlocked(unlock_time, get_blockchain_current_size(), m_core_runtime_config.get_core_time()))
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
|
|
@ -4047,27 +4112,27 @@ void wallet2::process_genesis_if_needed(const currency::block& genesis)
|
|||
if (!m_transfers.empty() || !m_key_images.empty())
|
||||
return;
|
||||
|
||||
THROW_IF_TRUE_WALLET_EX(m_blockchain.size() > 1, error::wallet_internal_error, "Can't change wallet genesis block once the blockchain has been populated");
|
||||
THROW_IF_TRUE_WALLET_EX(get_blockchain_current_size() > 1, error::wallet_internal_error, "Can't change wallet genesis block once the blockchain has been populated");
|
||||
|
||||
crypto::hash genesis_hash = get_block_hash(genesis);
|
||||
if (m_blockchain.size() == 1 && m_blockchain[0] != genesis_hash)
|
||||
WLT_LOG_L0("Changing genesis block for wallet " << m_account.get_public_address_str() << ":" << ENDL << " " << m_blockchain[0] << " -> " << genesis_hash);
|
||||
if (get_blockchain_current_size() == 1 && m_chain.get_genesis() != genesis_hash)
|
||||
WLT_LOG_L0("Changing genesis block for wallet " << m_account.get_public_address_str() << ":" << ENDL << " " << m_chain.get_genesis() << " -> " << genesis_hash);
|
||||
|
||||
m_blockchain.clear();
|
||||
//m_blockchain.clear();
|
||||
|
||||
m_blockchain.push_back(genesis_hash);
|
||||
m_local_bc_height = 1;
|
||||
//m_blockchain.push_back(genesis_hash);
|
||||
m_chain.set_genesis(genesis_hash);
|
||||
m_last_bc_timestamp = genesis.timestamp;
|
||||
|
||||
WLT_LOG_L2("Processing genesis block: " << genesis_hash);
|
||||
process_new_transaction(genesis.miner_tx, 0, genesis);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------------------------------
|
||||
void wallet2::set_genesis(const crypto::hash& genesis_hash)
|
||||
{
|
||||
THROW_IF_TRUE_WALLET_EX(m_blockchain.size() != 1, error::wallet_internal_error, "Can't change wallet genesis hash once the blockchain has been populated");
|
||||
WLT_LOG_L0("Changing genesis hash for wallet " << m_account.get_public_address_str() << ":" << ENDL << " " << m_blockchain[0] << " -> " << genesis_hash);
|
||||
m_blockchain[0] = genesis_hash;
|
||||
THROW_IF_TRUE_WALLET_EX(get_blockchain_current_size() != 1, error::wallet_internal_error, "Can't change wallet genesis hash once the blockchain has been populated");
|
||||
WLT_LOG_L0("Changing genesis hash for wallet " << m_account.get_public_address_str() << ":" << ENDL << " " << m_chain.get_genesis() << " -> " << genesis_hash);
|
||||
m_chain.set_genesis(genesis_hash);
|
||||
}
|
||||
//----------------------------------------------------------------------------------------------------
|
||||
void wallet2::print_tx_sent_message(const currency::transaction& tx, const std::string& description, uint64_t fee /* = UINT64_MAX */)
|
||||
|
|
|
|||
|
|
@ -14,6 +14,7 @@
|
|||
#include <boost/serialization/shared_ptr.hpp>
|
||||
#include <atomic>
|
||||
|
||||
|
||||
#include "include_base_utils.h"
|
||||
#include "profile_tools.h"
|
||||
#include "sync_locked_object.h"
|
||||
|
|
@ -26,6 +27,7 @@
|
|||
#include "wallet_public_structs_defs.h"
|
||||
#include "currency_core/currency_format_utils.h"
|
||||
#include "common/unordered_containers_boost_serialization.h"
|
||||
#include "common/atomics_boost_serialization.h"
|
||||
#include "storages/portable_storage_template_helper.h"
|
||||
#include "crypto/chacha8.h"
|
||||
#include "crypto/hash.h"
|
||||
|
|
@ -37,6 +39,7 @@
|
|||
#include "currency_core/bc_offers_serialization.h"
|
||||
#include "currency_core/bc_escrow_service.h"
|
||||
#include "common/pod_array_file_container.h"
|
||||
#include "wallet_chain_shortener.h"
|
||||
|
||||
|
||||
#define WALLET_DEFAULT_TX_SPENDABLE_AGE 10
|
||||
|
|
@ -44,6 +47,7 @@
|
|||
|
||||
#define WALLET_DEFAULT_POS_MINT_PACKING_SIZE 100
|
||||
|
||||
|
||||
#undef LOG_DEFAULT_CHANNEL
|
||||
#define LOG_DEFAULT_CHANNEL "wallet"
|
||||
|
||||
|
|
@ -314,6 +318,7 @@ namespace tools
|
|||
m_do_rise_transfer(false),
|
||||
m_watch_only(false),
|
||||
m_last_pow_block_h(0),
|
||||
m_minimum_height(0),
|
||||
m_pos_mint_packing_size(WALLET_DEFAULT_POS_MINT_PACKING_SIZE)
|
||||
{};
|
||||
public:
|
||||
|
|
@ -328,6 +333,7 @@ namespace tools
|
|||
m_log_prefix("???"),
|
||||
m_watch_only(false),
|
||||
m_last_pow_block_h(0),
|
||||
m_minimum_height(0),
|
||||
m_pos_mint_packing_size(WALLET_DEFAULT_POS_MINT_PACKING_SIZE)
|
||||
{
|
||||
m_core_runtime_config = currency::get_default_core_runtime_config();
|
||||
|
|
@ -495,6 +501,7 @@ namespace tools
|
|||
|
||||
bool set_core_proxy(const std::shared_ptr<i_core_proxy>& proxy);
|
||||
void set_pos_mint_packing_size(uint64_t new_size);
|
||||
void set_minimum_height(uint64_t h);
|
||||
std::shared_ptr<i_core_proxy> get_core_proxy();
|
||||
uint64_t balance() const;
|
||||
uint64_t balance(uint64_t& unloked, uint64_t& awaiting_in, uint64_t& awaiting_out, uint64_t& mined) const;
|
||||
|
|
@ -632,9 +639,11 @@ namespace tools
|
|||
uint64_t fee, size_t& outs_total, uint64_t& amount_total, size_t& outs_swept, currency::transaction* p_result_tx = nullptr, std::string* p_filename_or_unsigned_tx_blob_str = nullptr);
|
||||
|
||||
bool get_transfer_address(const std::string& adr_str, currency::account_public_address& addr, std::string& payment_id);
|
||||
uint64_t get_blockchain_current_height() const { return m_blockchain.size(); }
|
||||
inline uint64_t get_blockchain_current_size() const {
|
||||
return m_chain.get_blockchain_current_size();
|
||||
}
|
||||
|
||||
uint64_t get_top_block_height() const { return m_blockchain.empty() ? 0 : m_blockchain.size() - 1; }
|
||||
uint64_t get_top_block_height() const { return m_chain.get_top_block_height(); }
|
||||
|
||||
template <class t_archive>
|
||||
inline void serialize(t_archive &a, const unsigned int ver)
|
||||
|
|
@ -667,8 +676,23 @@ namespace tools
|
|||
return;
|
||||
}
|
||||
}
|
||||
//convert from old version
|
||||
if (ver < CURRENCY_FORMATION_VERSION + 65)
|
||||
{
|
||||
//TODO: export from a & m_blockchain;
|
||||
}
|
||||
else
|
||||
{
|
||||
a & m_chain;
|
||||
// a & m_local_bc_size;
|
||||
// a & m_genesis;
|
||||
// a & m_last_10_blocks;
|
||||
// a & m_last_144_blocks_every_10;
|
||||
// a & m_last_144_blocks_every_100;
|
||||
// a & m_last_144_blocks_every_1000;
|
||||
}
|
||||
|
||||
|
||||
a & m_blockchain;
|
||||
a & m_transfers;
|
||||
a & m_multisig_transfers;
|
||||
a & m_key_images;
|
||||
|
|
@ -696,7 +720,7 @@ namespace tools
|
|||
//for unit tests
|
||||
friend class ::test_generator;
|
||||
|
||||
//next functions in public area only because of test_generator
|
||||
//next functions in public area only becausce of test_generator
|
||||
//TODO: Need refactoring - remove it back to private zone
|
||||
void set_genesis(const crypto::hash& genesis_hash);
|
||||
bool prepare_and_sign_pos_block(currency::block& b,
|
||||
|
|
@ -761,8 +785,7 @@ private:
|
|||
void remove_transfer_from_expiration_list(uint64_t transfer_index);
|
||||
void load_keys(const std::string& keys_file_name, const std::string& password);
|
||||
void process_new_transaction(const currency::transaction& tx, uint64_t height, const currency::block& b);
|
||||
void detach_blockchain(uint64_t height);
|
||||
void get_short_chain_history(std::list<crypto::hash>& ids);
|
||||
void detach_blockchain(uint64_t including_height);
|
||||
bool extract_offers_from_transfer_entry(size_t i, std::unordered_map<crypto::hash, bc_services::offer_details_ex>& offers_local);
|
||||
bool select_my_offers(std::list<bc_services::offer_details_ex>& offers);
|
||||
bool clear();
|
||||
|
|
@ -875,6 +898,12 @@ private:
|
|||
bool generate_packing_transaction_if_needed(currency::transaction& tx, uint64_t fake_outputs_number);
|
||||
bool store_unsigned_tx_to_file_and_reserve_transfers(const finalize_tx_param& ftp, const std::string& filename, std::string* p_unsigned_tx_blob_str = nullptr);
|
||||
void check_and_throw_if_self_directed_tx_with_payment_id_requested(const construct_tx_param& ctp);
|
||||
void push_new_block_id(const crypto::hash& id, uint64_t height);
|
||||
bool lookup_item_around(uint64_t i, std::pair<uint64_t, crypto::hash>& result);
|
||||
//void get_short_chain_history(std::list<crypto::hash>& ids);
|
||||
//void check_if_block_matched(uint64_t i, const crypto::hash& id, bool& block_found, bool& block_matched, bool& full_reset_needed);
|
||||
uint64_t detach_from_block_ids(uint64_t height);
|
||||
uint64_t get_wallet_minimum_height();
|
||||
|
||||
currency::account_base m_account;
|
||||
bool m_watch_only;
|
||||
|
|
@ -882,8 +911,15 @@ private:
|
|||
std::wstring m_wallet_file;
|
||||
std::wstring m_pending_ki_file;
|
||||
std::string m_password;
|
||||
std::vector<crypto::hash> m_blockchain;
|
||||
std::atomic<uint64_t> m_local_bc_height; //temporary workaround
|
||||
//std::vector<crypto::hash> m_blockchain;
|
||||
// crypto::hash m_genesis;
|
||||
// std::map<uint64_t, crypto::hash> m_last_10_blocks;
|
||||
// std::map<uint64_t, crypto::hash> m_last_144_blocks_every_10; //1 day
|
||||
// std::map<uint64_t, crypto::hash> m_last_144_blocks_every_100; //10 days
|
||||
// std::map<uint64_t, crypto::hash> m_last_144_blocks_every_1000; //100 days
|
||||
uint64_t m_minimum_height;
|
||||
|
||||
//std::atomic<uint64_t> m_local_bc_size; //temporary workaround
|
||||
std::atomic<uint64_t> m_last_bc_timestamp;
|
||||
bool m_do_rise_transfer;
|
||||
uint64_t m_pos_mint_packing_size;
|
||||
|
|
@ -910,6 +946,7 @@ private:
|
|||
uint64_t m_last_pow_block_h;
|
||||
currency::core_runtime_config m_core_runtime_config;
|
||||
escrow_contracts_container m_contracts;
|
||||
wallet_chain_shortener m_chain;
|
||||
std::list<expiration_entry_info> m_money_expirations;
|
||||
//optimization for big wallets and batch tx
|
||||
|
||||
|
|
|
|||
292
src/wallet/wallet_chain_shortener.cpp
Normal file
292
src/wallet/wallet_chain_shortener.cpp
Normal file
|
|
@ -0,0 +1,292 @@
|
|||
// Copyright (c) 2014-2019 Zano Project
|
||||
// Copyright (c) 2014-2018 The Louisdor Project
|
||||
// Copyright (c) 2012-2013 The Cryptonote developers
|
||||
// Distributed under the MIT/X11 software license, see the accompanying
|
||||
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
|
||||
#include "wallet_chain_shortener.h"
|
||||
#include "wallet_errors.h"
|
||||
|
||||
#define WALLET_EVERYBLOCK_SIZE 20
|
||||
#define WALLET_EVERY_10_BLOCKS_SIZE 144
|
||||
#define WALLET_EVERY_100_BLOCKS_SIZE 144
|
||||
#define WALLET_EVERY_1000_BLOCKS_SIZE 144
|
||||
|
||||
static void exception_handler(){}
|
||||
|
||||
|
||||
wallet_chain_shortener::wallet_chain_shortener(): m_genesis(currency::gdefault_genesis)
|
||||
{
|
||||
m_local_bc_size = 1;
|
||||
}
|
||||
void wallet_chain_shortener::clear()
|
||||
{
|
||||
m_local_bc_size = 1;
|
||||
m_last_20_blocks.clear();
|
||||
m_last_144_blocks_every_10.clear();
|
||||
m_last_144_blocks_every_100.clear();
|
||||
m_last_144_blocks_every_1000.clear();
|
||||
|
||||
}
|
||||
//----------------------------------------------------------------------------------------------------
|
||||
uint64_t wallet_chain_shortener::get_blockchain_current_size() const
|
||||
{
|
||||
return m_local_bc_size;
|
||||
}
|
||||
//----------------------------------------------------------------------------------------------------
|
||||
uint64_t wallet_chain_shortener::get_top_block_height() const
|
||||
{
|
||||
return m_local_bc_size - 1;
|
||||
}
|
||||
//----------------------------------------------------------------------------------------------------
|
||||
void wallet_chain_shortener::set_genesis(const crypto::hash& id)
|
||||
{
|
||||
m_genesis = id;
|
||||
m_local_bc_size = 1;
|
||||
}
|
||||
//----------------------------------------------------------------------------------------------------
|
||||
const crypto::hash& wallet_chain_shortener::get_genesis()
|
||||
{
|
||||
return m_genesis;
|
||||
}
|
||||
//----------------------------------------------------------------------------------------------------
|
||||
void wallet_chain_shortener::push_new_block_id(const crypto::hash& id, uint64_t height)
|
||||
{
|
||||
if (height == 0)
|
||||
{
|
||||
m_genesis = id;
|
||||
m_local_bc_size = 1;
|
||||
return;
|
||||
}
|
||||
|
||||
//primary 10
|
||||
//self check
|
||||
if (!m_last_20_blocks.empty())
|
||||
{
|
||||
THROW_IF_FALSE_WALLET_INT_ERR_EX(get_blockchain_current_size() == height, "Inernal error: get_blockchain_current_height(){" << get_blockchain_current_size() << "} == height{" << height << "} is not equal");
|
||||
}
|
||||
|
||||
m_local_bc_size++;
|
||||
m_last_20_blocks[height] = id;
|
||||
if (m_last_20_blocks.size() > WALLET_EVERYBLOCK_SIZE)
|
||||
{
|
||||
m_last_20_blocks.erase(m_last_20_blocks.begin());
|
||||
}
|
||||
|
||||
//every 10-th
|
||||
if (height % 10 == 0)
|
||||
{
|
||||
//self check
|
||||
if (!m_last_144_blocks_every_10.empty())
|
||||
{
|
||||
THROW_IF_FALSE_WALLET_INT_ERR_EX((--m_last_144_blocks_every_10.end())->first + 10 == height, "Inernal error: (--m_last_144_blocks_every_10.end())->first + 10{" << (--m_last_144_blocks_every_10.end())->first + 10 << "} == height{" << height << "} is not equal");
|
||||
}
|
||||
m_last_144_blocks_every_10[height] = id;
|
||||
if (m_last_144_blocks_every_10.size() > WALLET_EVERY_10_BLOCKS_SIZE)
|
||||
{
|
||||
m_last_144_blocks_every_10.erase(m_last_144_blocks_every_10.begin());
|
||||
}
|
||||
}
|
||||
//every 100-th
|
||||
if (height % 100 == 0)
|
||||
{
|
||||
//self check
|
||||
if (!m_last_144_blocks_every_100.empty())
|
||||
{
|
||||
THROW_IF_FALSE_WALLET_INT_ERR_EX((--m_last_144_blocks_every_100.end())->first + 100 == height, "Inernal error: (--m_last_144_blocks_every_100.end())->first + 100{" << (--m_last_144_blocks_every_100.end())->first + 100 << "} == height{" << height << "} is not equal");
|
||||
}
|
||||
m_last_144_blocks_every_100[height] = id;
|
||||
if (m_last_144_blocks_every_100.size() > WALLET_EVERY_100_BLOCKS_SIZE)
|
||||
{
|
||||
m_last_144_blocks_every_100.erase(m_last_144_blocks_every_100.begin());
|
||||
}
|
||||
}
|
||||
//every 1000-th
|
||||
//every 100-th
|
||||
if (height % 1000 == 0)
|
||||
{
|
||||
//self check
|
||||
if (!m_last_144_blocks_every_1000.empty())
|
||||
{
|
||||
THROW_IF_FALSE_WALLET_INT_ERR_EX((--m_last_144_blocks_every_1000.end())->first + 1000 == height, "Inernal error: (--m_last_144_blocks_every_1000.end())->first + 1000{" << (--m_last_144_blocks_every_1000.end())->first + 1000 << "} == height{" << height << "} is not equal");
|
||||
}
|
||||
m_last_144_blocks_every_1000[height] = id;
|
||||
if (m_last_144_blocks_every_1000.size() > WALLET_EVERY_1000_BLOCKS_SIZE)
|
||||
{
|
||||
m_last_144_blocks_every_1000.erase(m_last_144_blocks_every_1000.begin());
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
//----------------------------------------------------------------------------------------------------
|
||||
void wallet_chain_shortener::get_short_chain_history(std::list<crypto::hash>& ids)const
|
||||
{
|
||||
ids.clear();
|
||||
uint64_t i = 0;
|
||||
uint64_t sz = get_blockchain_current_size();
|
||||
if (!sz)
|
||||
return;
|
||||
|
||||
//first put last 10
|
||||
uint64_t count = 0;
|
||||
for (auto it = m_last_20_blocks.rbegin(); it != m_last_20_blocks.rend() && count != 10; it++)
|
||||
{
|
||||
ids.push_back(it->second);
|
||||
i = it->first;
|
||||
count++;
|
||||
}
|
||||
|
||||
uint64_t current_back_offset = ids.size()+1;
|
||||
//self check
|
||||
THROW_IF_FALSE_WALLET_INT_ERR_EX(current_back_offset == sz - i + 1 || !count, "Inernal error: current_back_offset{" << current_back_offset << "} == sz-i{" << sz << " - " << i << "} is not equal");
|
||||
|
||||
uint64_t current_offset_distance = 1;
|
||||
while (current_back_offset < sz)
|
||||
{
|
||||
uint64_t get_item_around = sz - current_back_offset;
|
||||
std::pair<uint64_t, crypto::hash> item = AUTO_VAL_INIT(item);
|
||||
if (!lookup_item_around(get_item_around, item))
|
||||
break;
|
||||
|
||||
//readjust item current_back_offset
|
||||
current_back_offset = sz - item.first;
|
||||
|
||||
ids.push_back(item.second);
|
||||
current_offset_distance *= 2;
|
||||
current_back_offset += current_offset_distance;
|
||||
}
|
||||
ids.push_back(m_genesis);
|
||||
}
|
||||
//----------------------------------------------------------------------------------------------------
|
||||
bool wallet_chain_shortener::lookup_item_around(uint64_t i, std::pair<uint64_t, crypto::hash>& result)const
|
||||
{
|
||||
//in which container we are looking for?
|
||||
uint64_t devider = 0;
|
||||
const std::map<uint64_t, crypto::hash>* pcontainer;
|
||||
if (m_last_20_blocks.size() && i >= m_last_20_blocks.begin()->first)
|
||||
{
|
||||
devider = 1;
|
||||
pcontainer = &m_last_20_blocks;
|
||||
}
|
||||
else if (m_last_144_blocks_every_10.size() && i >= m_last_144_blocks_every_10.begin()->first)
|
||||
{
|
||||
devider = 10;
|
||||
pcontainer = &m_last_144_blocks_every_10;
|
||||
}
|
||||
else if (m_last_144_blocks_every_100.size() && i >= m_last_144_blocks_every_100.begin()->first)
|
||||
{
|
||||
devider = 100;
|
||||
pcontainer = &m_last_144_blocks_every_100;
|
||||
}
|
||||
else if (m_last_144_blocks_every_1000.size() && i >= m_last_144_blocks_every_1000.begin()->first)
|
||||
{
|
||||
devider = 1000;
|
||||
pcontainer = &m_last_144_blocks_every_1000;
|
||||
}
|
||||
else
|
||||
return false;
|
||||
|
||||
//look in every 10'th
|
||||
i = i - i % devider;
|
||||
auto it = pcontainer->find(i);
|
||||
//self check
|
||||
THROW_IF_FALSE_WALLET_INT_ERR_EX(it != pcontainer->end(),
|
||||
"Inernal error: index " << i << " not found for devider " << devider
|
||||
<< " pcontainer={" << pcontainer->begin()->first << ":" << (--pcontainer->end())->first << "}");
|
||||
result = *it;
|
||||
return true;
|
||||
}
|
||||
//----------------------------------------------------------------------------------------------------
|
||||
void wallet_chain_shortener::check_if_block_matched(uint64_t i, const crypto::hash& id, bool& block_found, bool& block_matched, bool& full_reset_needed)const
|
||||
{
|
||||
if (i == 0)
|
||||
{
|
||||
//check genesis
|
||||
if (m_local_bc_size > 0)
|
||||
{
|
||||
block_found = true;
|
||||
block_matched = id == m_genesis;
|
||||
if (!block_matched) {
|
||||
full_reset_needed = true;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
block_found = false;
|
||||
block_matched = false;
|
||||
full_reset_needed = true;
|
||||
}
|
||||
return;
|
||||
}
|
||||
if (!m_last_20_blocks.empty() && i > m_last_20_blocks.begin()->first)
|
||||
{
|
||||
//must be in short sequence (m_last_20_blocks)
|
||||
//self check
|
||||
THROW_IF_FALSE_WALLET_INT_ERR_EX((--m_last_20_blocks.end())->first >= i,
|
||||
"Inernal error: index " << i << " is not located in expected range of m_last_20_blocks={"
|
||||
<< m_last_20_blocks.begin()->first << ":" << (--m_last_20_blocks.end())->first << "}");
|
||||
|
||||
auto it = m_last_20_blocks.find(i);
|
||||
THROW_IF_FALSE_WALLET_INT_ERR_EX(it != m_last_20_blocks.end(),
|
||||
"Inernal error: filde to find index " << i << " in m_last_20_blocks={"
|
||||
<< m_last_20_blocks.begin()->first << ":" << (--m_last_20_blocks.end())->first << "}");
|
||||
|
||||
block_found = true;
|
||||
if (id == it->second)
|
||||
block_matched = true;
|
||||
else
|
||||
block_matched = false;
|
||||
}
|
||||
else
|
||||
{
|
||||
//lazy lookup
|
||||
std::pair<uint64_t, crypto::hash> result = AUTO_VAL_INIT(result);
|
||||
bool r = lookup_item_around(i, result);
|
||||
if (!r)
|
||||
{
|
||||
LOG_PRINT_L0("Wallet is getting fully resynced due to lookup_item_around failed at " << i);
|
||||
block_matched = block_found = false;
|
||||
full_reset_needed = true;
|
||||
return;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (result.first == i)
|
||||
{
|
||||
block_found = true;
|
||||
if (result.second == id)
|
||||
{
|
||||
block_matched = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
block_matched = false;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
block_found = false;
|
||||
block_matched = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
//----------------------------------------------------------------------------------------------------
|
||||
void clean_map_from_items_above(std::map<uint64_t, crypto::hash>& container, uint64_t height)
|
||||
{
|
||||
while (container.size() && (--container.end())->first >= height)
|
||||
{
|
||||
container.erase(--container.end());
|
||||
}
|
||||
}
|
||||
//----------------------------------------------------------------------------------------------------
|
||||
void wallet_chain_shortener::detach(uint64_t including_height)
|
||||
{
|
||||
clean_map_from_items_above(m_last_20_blocks, including_height);
|
||||
clean_map_from_items_above(m_last_144_blocks_every_10, including_height);
|
||||
clean_map_from_items_above(m_last_144_blocks_every_100, including_height);
|
||||
clean_map_from_items_above(m_last_144_blocks_every_1000, including_height);
|
||||
m_local_bc_size = including_height;
|
||||
}
|
||||
57
src/wallet/wallet_chain_shortener.h
Normal file
57
src/wallet/wallet_chain_shortener.h
Normal file
|
|
@ -0,0 +1,57 @@
|
|||
// Copyright (c) 2014-2018 Zano Project
|
||||
// Distributed under the MIT/X11 software license, see the accompanying
|
||||
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
|
||||
#pragma once
|
||||
#pragma once
|
||||
#include <memory>
|
||||
#include <boost/serialization/list.hpp>
|
||||
#include <boost/serialization/vector.hpp>
|
||||
#include <boost/serialization/deque.hpp>
|
||||
#include <boost/serialization/singleton.hpp>
|
||||
#include <boost/serialization/extended_type_info.hpp>
|
||||
#include <boost/serialization/shared_ptr.hpp>
|
||||
#include <atomic>
|
||||
#include <map>
|
||||
|
||||
#include "crypto/crypto.h"
|
||||
|
||||
#include "include_base_utils.h"
|
||||
#include "crypto/crypto.h"
|
||||
|
||||
|
||||
class wallet_chain_shortener
|
||||
{
|
||||
public:
|
||||
wallet_chain_shortener();
|
||||
void push_new_block_id(const crypto::hash& id, uint64_t height);
|
||||
uint64_t get_top_block_height() const;
|
||||
uint64_t get_blockchain_current_size() const;
|
||||
void get_short_chain_history(std::list<crypto::hash>& ids)const;
|
||||
bool lookup_item_around(uint64_t i, std::pair<uint64_t, crypto::hash>& result)const;
|
||||
void check_if_block_matched(uint64_t i, const crypto::hash& id, bool& block_found, bool& block_matched, bool& full_reset_needed) const;
|
||||
void detach(uint64_t including_height);
|
||||
void clear();
|
||||
void set_genesis(const crypto::hash& id);
|
||||
const crypto::hash& get_genesis();
|
||||
template <class t_archive>
|
||||
inline void serialize(t_archive &a, const unsigned int ver)
|
||||
{
|
||||
a & m_local_bc_size;
|
||||
a & m_genesis;
|
||||
a & m_last_20_blocks;
|
||||
a & m_last_144_blocks_every_10;
|
||||
a & m_last_144_blocks_every_100;
|
||||
a & m_last_144_blocks_every_1000;
|
||||
}
|
||||
|
||||
//debug functions
|
||||
|
||||
private:
|
||||
std::atomic<uint64_t> m_local_bc_size; //temporary workaround
|
||||
crypto::hash m_genesis;
|
||||
std::map<uint64_t, crypto::hash> m_last_20_blocks;
|
||||
std::map<uint64_t, crypto::hash> m_last_144_blocks_every_10; //1 day
|
||||
std::map<uint64_t, crypto::hash> m_last_144_blocks_every_100; //10 days
|
||||
std::map<uint64_t, crypto::hash> m_last_144_blocks_every_1000; //100 days
|
||||
};
|
||||
|
|
@ -841,6 +841,7 @@ std::string wallets_manager::generate_wallet(const std::wstring& path, const std
|
|||
try
|
||||
{
|
||||
w->generate(path, password);
|
||||
w->set_minimum_height(m_last_daemon_height);
|
||||
owr.seed = w->get_account().get_restore_braindata();
|
||||
}
|
||||
catch (const tools::error::file_exists&)
|
||||
|
|
@ -1187,7 +1188,7 @@ std::string wallets_manager::transfer(size_t wallet_id, const view::transfer_par
|
|||
if (tp.lock_time > CURRENCY_MAX_BLOCK_NUMBER)
|
||||
unlock_time = tp.lock_time;
|
||||
else
|
||||
unlock_time = w->get()->get_blockchain_current_height() + tp.lock_time;
|
||||
unlock_time = w->get()->get_blockchain_current_size() + tp.lock_time;
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -923,6 +923,10 @@ bool test_generator::refresh_test_wallet(const std::vector<test_event_entry>& ev
|
|||
std::atomic<bool> atomic_false = ATOMIC_VAR_INIT(false);
|
||||
bool r = w->refresh(blocks_fetched, received_money, ok, atomic_false);
|
||||
CHECK_AND_ASSERT_MES(r, false, "test wallet refersh failed");
|
||||
if (expected_blocks_to_be_fetched != blocks_fetched)
|
||||
{
|
||||
std::cout << "dd";
|
||||
}
|
||||
CHECK_AND_ASSERT_MES(expected_blocks_to_be_fetched == std::numeric_limits<size_t>::max() || expected_blocks_to_be_fetched == blocks_fetched, false, "test wallet refresh fetched " << blocks_fetched << ", expected: " << expected_blocks_to_be_fetched);
|
||||
|
||||
bool has_aliases;
|
||||
|
|
|
|||
|
|
@ -56,8 +56,25 @@ bool wallet_test_core_proxy::call_COMMAND_RPC_GET_TX_GLOBAL_OUTPUTS_INDEXES(cons
|
|||
|
||||
bool wallet_test_core_proxy::call_COMMAND_RPC_GET_BLOCKS_FAST(const currency::COMMAND_RPC_GET_BLOCKS_FAST::request& rqt, currency::COMMAND_RPC_GET_BLOCKS_FAST::response& rsp)
|
||||
{
|
||||
rsp.current_height = 0;
|
||||
//might be not best way to do it.
|
||||
std::unordered_map<crypto::hash, uint64_t> blocks_map;
|
||||
for (uint64_t i = 0; i != m_blocks.size(); i++)
|
||||
{
|
||||
blocks_map[currency::get_block_hash(m_blocks[i]->b)] = i;
|
||||
}
|
||||
|
||||
rsp.start_height = 0;
|
||||
//find out where we supposed to start refresh
|
||||
for (auto id : rqt.block_ids)
|
||||
{
|
||||
auto it = blocks_map.find(id);
|
||||
if (it == blocks_map.end())
|
||||
continue;
|
||||
rsp.start_height = it->second;
|
||||
break;
|
||||
}
|
||||
|
||||
rsp.current_height = m_blocks.size();
|
||||
rsp.status = CORE_RPC_STATUS_OK;
|
||||
if (!m_first_call)
|
||||
{
|
||||
|
|
@ -65,20 +82,21 @@ bool wallet_test_core_proxy::call_COMMAND_RPC_GET_BLOCKS_FAST(const currency::CO
|
|||
return true; // respond with empty blocks on second call to gracefully stop wallet refreshing
|
||||
}
|
||||
m_first_call = false;
|
||||
for (auto b : m_blocks)
|
||||
for (size_t i = rsp.start_height; i != m_blocks.size(); i++)
|
||||
{
|
||||
auto b = m_blocks[i];
|
||||
currency::block_complete_entry bce = AUTO_VAL_INIT(bce);
|
||||
for (auto tx : b->m_transactions)
|
||||
bce.txs.push_back(tx_to_blob(tx));
|
||||
bce.block = block_to_blob(b->b);
|
||||
rsp.blocks.push_back(bce);
|
||||
}
|
||||
rsp.current_height = m_blocks.size() - 1;
|
||||
rsp.current_height = m_blocks.size();
|
||||
return true;
|
||||
}
|
||||
bool wallet_test_core_proxy::call_COMMAND_RPC_GET_BLOCKS_DIRECT(const currency::COMMAND_RPC_GET_BLOCKS_DIRECT::request& rqt, currency::COMMAND_RPC_GET_BLOCKS_DIRECT::response& rsp)
|
||||
{
|
||||
currency::COMMAND_RPC_GET_BLOCKS_FAST::request req;
|
||||
currency::COMMAND_RPC_GET_BLOCKS_FAST::request req = AUTO_VAL_INIT(req);
|
||||
req.block_ids = rqt.block_ids;
|
||||
currency::COMMAND_RPC_GET_BLOCKS_FAST::response res = AUTO_VAL_INIT(res);
|
||||
bool r = this->call_COMMAND_RPC_GET_BLOCKS_FAST(req, res);
|
||||
|
|
@ -93,6 +111,13 @@ bool wallet_test_core_proxy::call_COMMAND_RPC_GET_BLOCKS_DIRECT(const currency::
|
|||
|
||||
}
|
||||
|
||||
bool wallet_test_core_proxy::call_COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE(const currency::COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE::request& rqt, currency::COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE::response& rsp)
|
||||
{
|
||||
rsp.h = 0;
|
||||
rsp.status = CORE_RPC_STATUS_OK;
|
||||
return true;
|
||||
}
|
||||
|
||||
bool wallet_test_core_proxy::call_COMMAND_RPC_GET_INFO(const currency::COMMAND_RPC_GET_INFO::request& rqt, currency::COMMAND_RPC_GET_INFO::response& rsp)
|
||||
{
|
||||
rsp.synchronized_connections_count = 1;
|
||||
|
|
|
|||
|
|
@ -19,6 +19,7 @@ struct wallet_test_core_proxy : public tools::i_core_proxy
|
|||
virtual bool call_COMMAND_RPC_GET_TX_GLOBAL_OUTPUTS_INDEXES(const currency::COMMAND_RPC_GET_TX_GLOBAL_OUTPUTS_INDEXES::request& rqt, currency::COMMAND_RPC_GET_TX_GLOBAL_OUTPUTS_INDEXES::response& rsp) override;
|
||||
virtual bool call_COMMAND_RPC_GET_BLOCKS_FAST(const currency::COMMAND_RPC_GET_BLOCKS_FAST::request& rqt, currency::COMMAND_RPC_GET_BLOCKS_FAST::response& rsp) override;
|
||||
virtual bool call_COMMAND_RPC_GET_BLOCKS_DIRECT(const currency::COMMAND_RPC_GET_BLOCKS_DIRECT::request& rqt, currency::COMMAND_RPC_GET_BLOCKS_DIRECT::response& rsp) override;
|
||||
virtual bool call_COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE(const currency::COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE::request& rqt, currency::COMMAND_RPC_GET_EST_HEIGHT_FROM_DATE::response& rsp) override;
|
||||
virtual bool call_COMMAND_RPC_GET_INFO(const currency::COMMAND_RPC_GET_INFO::request& rqt, currency::COMMAND_RPC_GET_INFO::response& rsp) override;
|
||||
virtual bool call_COMMAND_RPC_SEND_RAW_TX(const currency::COMMAND_RPC_SEND_RAW_TX::request& rqt, currency::COMMAND_RPC_SEND_RAW_TX::response& rsp) override;
|
||||
virtual bool call_COMMAND_RPC_GET_TX_POOL(const currency::COMMAND_RPC_GET_TX_POOL::request& rqt, currency::COMMAND_RPC_GET_TX_POOL::response& rsp) override;
|
||||
|
|
|
|||
59
tests/unit_tests/wallet_chain_shortener_test.cpp
Normal file
59
tests/unit_tests/wallet_chain_shortener_test.cpp
Normal file
|
|
@ -0,0 +1,59 @@
|
|||
// Copyright (c) 2019 Zano Project
|
||||
// Distributed under the MIT/X11 software license, see the accompanying
|
||||
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
|
||||
#include <algorithm>
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
#include "wallet/wallet_chain_shortener.h"
|
||||
|
||||
TEST(wallet_chain_shortener, wallet_chain_shortener)
|
||||
{
|
||||
uint64_t counter = 0;
|
||||
wallet_chain_shortener ws;
|
||||
|
||||
for (counter = 1; counter != 1000000; counter++)
|
||||
{
|
||||
crypto::hash id_ = AUTO_VAL_INIT(id_);
|
||||
*((uint64_t*)&id_) = counter;
|
||||
|
||||
ws.push_new_block_id(id_, counter);
|
||||
}
|
||||
|
||||
std::list<crypto::hash> short_chain1;
|
||||
ws.get_short_chain_history(short_chain1);
|
||||
for(auto& id: short_chain1)
|
||||
{
|
||||
LOG_PRINT_L0("{" << *((uint64_t*)&id) << "}{" << counter - *((uint64_t*)&id) << "}" << ENDL);
|
||||
}
|
||||
|
||||
|
||||
ws.detach(counter - 10000);
|
||||
std::list<crypto::hash> short_chain2;
|
||||
ws.get_short_chain_history(short_chain2);
|
||||
for (auto& id : short_chain2)
|
||||
{
|
||||
LOG_PRINT_L0("{" << *((uint64_t*)&id) << "}{" << counter - *((uint64_t*)&id) << "}" << ENDL);
|
||||
}
|
||||
|
||||
for (counter = counter - 10000 + 1; counter != 1000000; counter++)
|
||||
{
|
||||
crypto::hash id_ = AUTO_VAL_INIT(id_);
|
||||
*((uint64_t*)&id_) = counter;
|
||||
|
||||
ws.push_new_block_id(id_, counter);
|
||||
}
|
||||
|
||||
std::list<crypto::hash> short_chain3;
|
||||
ws.get_short_chain_history(short_chain3);
|
||||
for (auto& id : short_chain3)
|
||||
{
|
||||
LOG_PRINT_L0("{" << *((uint64_t*)&id) << "}{" << counter - *((uint64_t*)&id) << "}" << ENDL);
|
||||
}
|
||||
|
||||
LOG_PRINT_L0("Finished");
|
||||
|
||||
ASSERT_EQ(short_chain3.size(), short_chain1.size());
|
||||
ASSERT_EQ(short_chain3, short_chain1);
|
||||
|
||||
}
|
||||
|
||||
Loading…
Add table
Reference in a new issue