example/0000700000175300010010000000000011125151363011651 5ustar clownなしexample/example_adjust.cpp0000700000175300010010000000424311035502656015375 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_adjust.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Thu 18 Oct 2007 17:18:00 JST */ /* ------------------------------------------------------------------------- */ #include #include #include "clx/salgorithm.h" int main(int argc, char* argv[]) { std::string s = "Hello, world!"; std::cout << "ljust: " << clx::ljust_copy(s, 30, '*') << std::endl; std::cout << "rjust: " << clx::rjust_copy(s, 30, '*') << std::endl; std::cout << "center: " << clx::center_copy(s, 30, '*') << std::endl; return 0; } example/example_argument.cpp0000700000175300010010000000610011035657162015722 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_argument.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Thu 17 Aug 2006 02:06:00 JST */ /* ------------------------------------------------------------------------- */ #include #include "clx/argument.h" int main(int argc, char* argv[]) { /* * 解析するcmdlineのBNF記法 * []* (['-'[]+] | ['-'+ []*])* */ clx::argument p; p.assign(argc, argv); int x, y, z; std::cout << "head paramters" << std::endl; std::cout << "------------------------------" << std::endl;; for (size_t i = 0; i < p.head().size(); i++) std::cout << p.head().at(i) << std::endl; std::cout << std::endl; /* * に対応するへアクセスする場合． * 第一引数には，を指定する．カンマ(',')区切りで複数のを指定する * ことが可能で，最初にヒットしたに対応するの値を格納する． * * 第三引数は，に対応するのリストのうち，何番目のを * 格納するか指定する．省略時には，0番目のが格納される． */ p("s,space", x)('y', y, 2); std::cout << "s,space: " << x << std::endl; std::cout << "y[2]: " << y << std::endl; std::cout << std::endl; /* * '-'に続く文字列は，それぞれが一つの引数として扱われるため， * p.exist("abc")ではなく，p.exist("b")の条件文と一致する． */ if (p.exist("abc")) std::cout << "the abc parameter exists." << std::endl; if (p.exist('b')) std::cout << "the b parameter exists." << std::endl; return 0; } example/example_base64.cpp0000700000175300010010000000533111057221551015162 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_base64.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Sat 30 Aug 2008 21:31:00 JST */ /* ------------------------------------------------------------------------- */ #include #include #include "clx/base64.h" int main(int argc, char* argv[]) { // 入力ストリームからデータを受け取る場合 std::istreambuf_iterator input(std::cin); std::istreambuf_iterator last; std::string code; std::insert_iterator ss(code, code.begin()); clx::base64::encode(input, last, ss); std::cout << "from std::cin" << std::endl; std::cout << "encode: " << code << std::endl; std::cout << "decode: "; std::ostreambuf_iterator output(std::cout); clx::base64::decode(code.begin(), code.end(), output); std::cout << std::endl; std::cout << std::endl; // 文字列からデータを受け取る場合 std::string src = "Hello, world!"; code = clx::base64::encode(src); std::cout << "from std::string" << std::endl; std::cout << "encode: " << code << std::endl; std::cout << "decode: " << clx::base64::decode(code) << std::endl; return 0; } example/example_case_conv.cpp0000700000175300010010000000420511035505456016042 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_case_conv.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Thu 18 Oct 2007 17:54:00 JST */ /* ------------------------------------------------------------------------- */ #include #include #include "clx/salgorithm.h" int main(int argc, char* argv[]) { std::string s = "hello, world!"; std::cout << "original: " << s << std::endl; std::cout << "upcase: " << clx::upcase_copy(s) << std::endl; std::cout << "capitalize: " << clx::capitalize_copy(s) << std::endl; return 0; } example/example_code_convert.cpp0000700000175300010010000000575311073660242016562 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_code_convert.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Fri 29 Aug 2008 02:17:00 JST */ /* ------------------------------------------------------------------------- */ #ifndef CLX_USE_WCHAR #define CLX_USE_WCHAR #endif // CLX_USE_WCHAR #include #include #include "clx/code_convert.h" int main(int argc, char* argv[]) { try { std::cout.imbue(std::locale("japanese")); std::wcout.imbue(std::locale("japanese")); // char -> wchar_t std::string s = "はろーわーるど"; std::wstring wcvt = clx::code_convert(s, std::locale("japanese")); std::wcout << L"char -> wchar_t" << std::endl; std::wcout << L"-----" << std::endl; std::cout << "original: " << s << " (" << s.size() << ")" << std::endl; std::wcout << L"convert: " << wcvt << L" (" << wcvt.size() << L")" << std::endl; std::wcout << std::endl; // wchar_t -> char std::wstring ws = L"ハローワールド"; std::string cvt = clx::code_convert(ws, std::locale("japanese")); std::cout << "wchar_t -> char" << std::endl; std::cout << "-----" << std::endl; std::wcout << L"original: " << ws << L" (" << ws.size() << L")" << std::endl; std::cout << "convert: " << cvt << " (" << cvt.size() << ")" << std::endl; } catch (std::runtime_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } return 0; } example/example_condition.cpp0000700000175300010010000001117711050612262016065 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_condition.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Wed 13 Aug 2008 11:53:00 JST */ /* ------------------------------------------------------------------------- */ #include #include #include #include #include "clx/thread.h" /* ------------------------------------------------------------------------- */ // trivial_queue /* ------------------------------------------------------------------------- */ template class trivial_queue { public: typedef Type value_type; trivial_queue() : list_(), mutex_(), not_empty_() {} virtual ~trivial_queue() {} void enqueue(const value_type& x) { clx::mutex::scoped_lock lock(mutex_); std::cout << "PSH: " << x << " (rest " << list_.size() << ")" << std::endl; list_.push_back(x); not_empty_.notify_one(); } value_type dequeue() { clx::mutex::scoped_lock lock(mutex_); while (list_.empty()) { std::cout << "empty buffer" << std::endl; not_empty_.wait(lock); } value_type tmp = list_.front(); std::cout << "POP: " << tmp << " (rest " << list_.size() << ")" << std::endl; list_.pop_front(); return tmp; } void reset() { clx::mutex::scoped_lock lock(mutex_); list_.clear(); } private: std::list list_; clx::mutex mutex_; clx::condition not_empty_; }; trivial_queue data_; clx::once_flag once_ = CLX_ONCE_INIT; /* ------------------------------------------------------------------------- */ // init_data /* ------------------------------------------------------------------------- */ void init_data() { std::cout << "reset data queue" << std::endl; data_.reset(); } /* ------------------------------------------------------------------------- */ // send_something /* ------------------------------------------------------------------------- */ void send_something() { for (int i = 0; i < 10; i++) { clx::call_once(once_, init_data); // call_once test std::stringstream ss; ss << "element[" << i << "]"; data_.enqueue(ss.str()); } } /* ------------------------------------------------------------------------- */ // recv_something /* ------------------------------------------------------------------------- */ void recv_something() { std::string s; for (int i = 0; i < 10; i++) { clx::call_once(once_, init_data); // call_once test s = data_.dequeue(); } } /* ------------------------------------------------------------------------- */ // main /* ------------------------------------------------------------------------- */ int main(int argc, char* argv[]) { clx::thread enq_th[2]; clx::thread deq_th[2]; // 第2引数がtrueの場合は，detach属性（joinで後処理を行う必要がない） for (size_t i = 0; i < 2; i++) enq_th[i].start(send_something, true); for (size_t i = 0; i < 2; i++) deq_th[i].start(recv_something, true); /* * detach属性の場合，作成したスレッドが仕事を終える前にメインスレッドが * 終了する可能性があるので，clx::exit(0)で待つ． */ clx::exit(0); } example/example_constrained_value.cpp0000700000175300010010000000540311034301236017575 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_constrained_value.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Mon 07 Jul 2008 10:56:00 JST */ /* ------------------------------------------------------------------------- */ #include #include "clx/constrained_value.h" int main(int argc, char* argv[]) { clx::constrained_value > x; clx::constrained_value > y; clx::constrained_value > z; try { std::cout << "1st example." << std::endl; x = 32; std::cout << "x = " << x << std::endl; y = 8; std::cout << "y = " << y << std::endl; y += x + 51 - (2 * 4); std::cout << "y = " << y << std::endl; } catch (std::range_error& e) { std::cerr << "exception: " << e.what() << std::endl; } std::cout << std::endl; try { std::cout << "2nd example." << std::endl; x = 32; std::cout << "x = " << x << std::endl; z = 8; std::cout << "z = " << z << std::endl; z += z.value() + 51 - (2 * 4); std::cout << "z = " << z << std::endl; } catch (std::range_error& e) { std::cerr << "exception: " << e.what() << std::endl; } return 0; } example/example_cstring.cpp0000700000175300010010000000462611075277150015563 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_cstring.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Wed 15 Oct 2008 14:23:00 JST */ /* ------------------------------------------------------------------------- */ #include #include "clx/cstring.h" int main(int argc, char* argv[]) { char s1[256] = "Hello, world!"; char s2[256] = "Hello, world."; char s3[256] = "3.1415926"; std::cout << "string: " << s1 << std::endl; if (clx::strcmp(s1, s2) == 0) std::cout << "strcmp: match" << std::endl; else std::cout << "strcmp: unmatch" << std::endl; std::cout << "strlen: " << clx::strlen(s1) << std::endl; clx::strcat(s1, s2); std::cout << "strcat: " << s1 << std::endl; char* last = NULL; double pi = clx::strtod(s3, &last); std::cout << "strtod: " << pi << std::endl; return 0; } example/example_date_time.cpp0000700000175300010010000000473511057307673016052 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_date_time.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Fri 02 Nov 2007 23:03:00 JST */ /* ------------------------------------------------------------------------- */ #include #include "clx/format.h" #include "clx/time.h" int main(int argc, char* argv[]) { std::string fmt = "%a %d %b %Y %H:%M:%S JST"; /* * 現在時刻の取得． * デフォルトコンストラクタは，現在時刻でdate_timeクラスを初期化する． */ clx::date_time now; std::cout << now.to_string(fmt) << std::endl; // 現在時刻から5年3ヶ月後の時刻を取得． clx::date_time t1 = now + clx::years(5) + clx::months(3); std::cout << "5 years 3 months passed from now ... "; std::cout << t1.to_string(fmt) << std::endl; std::cout << clx::format("%d days have passed since %d/01/01") % now.totaldays() % now.year() << std::endl; return 0; } example/example_format.cpp0000700000175300010010000000530511075302467015375 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_format.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Thu 07 Apr 2006 03:09:00 JST */ /* ------------------------------------------------------------------------- */ #include #include #include #include "clx/format.h" int main(int argc, char* argv[]) { double pi = 3.141592684; std::string hello = "Hello, world. This is a test program"; std::string test = "Output pi with two kinds of format"; std::string fmt = "%s.\n%s: %#+10.7f, %.5e."; std::cout << "Output by using formatter class." << std::endl; std::cout << "---" << std::endl; std::cout << clx::format(fmt) % hello % test % pi % pi << std::endl; std::cout << std::endl; // compared with the printf() function printf("Output by using printf function\n"); printf("---\n"); printf(fmt.c_str(), hello.c_str(), test.c_str(), pi, pi); printf("\n\n"); std::cout << "Test of str() function" << std::endl; std::cout << "---" << std::endl; std::string dest = clx::str(clx::format(fmt) % hello % test % pi % pi); std::cout << dest << std::endl; return 0; } example/example_ftp.cpp0000700000175300010010000000654611125000072014665 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_smtp.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Wed 22 Oct 2008 15:11:00 JST */ /* ------------------------------------------------------------------------- */ #include #include #include #include "clx/ftp.h" int main(int argc, char* argv[]) { if (argc < 4) { std::cerr << "usage " << argv[0] << " host id pass" << std::endl; std::exit(-1); } try { clx::ftp session(argv[1], 21); // 各種コマンドのテスト session.login(argv[2], argv[3]); session.status(); session.system(); session.command("HELP"); session.cd("/public_html"); session.pwd(); session.mkdir("tmp"); session.rmdir("tmp"); /* * list(), retrieve(), store() はデータコネクションを使用する． * データコネクションを用いるメソッドは，最後の引数に * アクティブ接続 (clx::ftp::active) かパッシブ接続 (clx::ftp::passive) * を指定する．尚，省略時はパッシブ接続． */ session.list("/public_html"); session.retrieve("/public_html/index.html", "./result.txt", clx::ftp::binary); session.store("./example_ftp.cpp", "/public_html/example_ftp.cpp"); session.remove("/public_html/example_ftp.cpp"); session.finish(); // print message log clx::ftp::response_array::reverse_iterator pos; for (pos = session.responses().rbegin(); pos != session.responses().rend(); ++pos) { std::cout << pos->second << std::endl; std::cout << std::endl; } } catch (clx::ftp_error& e) { std::cerr << e.code() << ": " << e.what() << std::endl; std::exit(-1); } catch (clx::socket_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } catch (std::runtime_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } return 0; } example/example_hmac_md5.cpp0000700000175300010010000000763711125150511015557 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_hmac_md5.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Fri 26 Dec 2008 21:42:00 JST */ /* ------------------------------------------------------------------------- */ #include #include "clx/hmac.h" #include "clx/md5.h" int main(int argc, char* argv[]) { // test_case = 1 char key1[17]; char dat1[9] = "Hi There"; for (size_t i = 0; i < sizeof(key1) - 1; ++i) key1[i] = 0x0b; std::cout << "case 1: " << clx::hmac(key1, sizeof(key1) - 1, dat1, sizeof(dat1) - 1).to_string() << std::endl; // test_case = 2 char key2[5] = "Jefe"; char dat2[29] = "what do ya want for nothing?"; std::cout << "case 2: " << clx::hmac(key2, sizeof(key2) - 1, dat2, sizeof(dat2) - 1).to_string() << std::endl; // test_cast = 3 char key3[17]; char dat3[51]; for (size_t i = 0; i < sizeof(key3) - 1; ++i) key3[i] = 0xaa; for (size_t i = 0; i < sizeof(dat3) - 1; ++i) dat3[i] = 0xdd; std::cout << "case 3: " << clx::hmac(key3, sizeof(key3) - 1, dat3, sizeof(dat3) - 1).to_string() << std::endl; // test_cast = 4 char key4[26]; char dat4[51]; for (size_t i = 0; i < sizeof(key4) - 1; ++i) key4[i] = i + 1; for (size_t i = 0; i < sizeof(dat4) - 1; ++i) dat4[i] = 0xcd; std::cout << "case 4: " << clx::hmac(key4, sizeof(key4) - 1, dat4, sizeof(dat4) - 1).to_string() << std::endl; // test_cast = 5 char key5[17]; char dat5[21] = "Test With Truncation"; for (size_t i = 0; i < sizeof(key5) - 1; ++i) key5[i] = 0x0c; std::cout << "case 5: " << clx::hmac(key5, sizeof(key5) - 1, dat5, sizeof(dat5) - 1).to_string() << std::endl; // test_case = 6 char key6[81]; char dat6[55] = "Test Using Larger Than Block-Size Key - Hash Key First"; for (size_t i = 0; i < sizeof(key6) - 1; ++i) key6[i] = 0xaa; std::cout << "case 6: " << clx::hmac(key6, sizeof(key6) - 1, dat6, sizeof(dat6) - 1).to_string() << std::endl; // test_case = 7 char key7[81]; char dat7[74] = "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data"; for (size_t i = 0; i < sizeof(key7) - 1; ++i) key7[i] = 0xaa; std::cout << "case 7: " << clx::hmac(key7, sizeof(key7) - 1, dat7, sizeof(dat7) - 1).to_string() << std::endl; return 0; } example/example_hmac_sha1.cpp0000700000175300010010000000765011125150530015722 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_hmac_sha1.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Fri 26 Dec 2008 21:42:00 JST */ /* ------------------------------------------------------------------------- */ #include #include "clx/hmac.h" #include "clx/sha1.h" int main(int argc, char* argv[]) { // test_case = 1 char key1[21]; char dat1[9] = "Hi There"; for (size_t i = 0; i < sizeof(key1) - 1; ++i) key1[i] = 0x0b; std::cout << "case 1: " << clx::hmac(key1, sizeof(key1) - 1, dat1, sizeof(dat1) - 1).to_string() << std::endl; // test_case = 2 char key2[5] = "Jefe"; char dat2[29] = "what do ya want for nothing?"; std::cout << "case 2: " << clx::hmac(key2, sizeof(key2) - 1, dat2, sizeof(dat2) - 1).to_string() << std::endl; // test_cast = 3 char key3[21]; char dat3[51]; for (size_t i = 0; i < sizeof(key3) - 1; ++i) key3[i] = 0xaa; for (size_t i = 0; i < sizeof(dat3) - 1; ++i) dat3[i] = 0xdd; std::cout << "case 3: " << clx::hmac(key3, sizeof(key3) - 1, dat3, sizeof(dat3) - 1).to_string() << std::endl; // test_cast = 4 char key4[26]; char dat4[51]; for (size_t i = 0; i < sizeof(key4) - 1; ++i) key4[i] = i + 1; for (size_t i = 0; i < sizeof(dat4) - 1; ++i) dat4[i] = 0xcd; std::cout << "case 4: " << clx::hmac(key4, sizeof(key4) - 1, dat4, sizeof(dat4) - 1).to_string() << std::endl; // test_cast = 5 char key5[21]; char dat5[21] = "Test With Truncation"; for (size_t i = 0; i < sizeof(key5) - 1; ++i) key5[i] = 0x0c; std::cout << "case 5: " << clx::hmac(key5, sizeof(key5) - 1, dat5, sizeof(dat5) - 1).to_string() << std::endl; // test_case = 6 char key6[81]; char dat6[55] = "Test Using Larger Than Block-Size Key - Hash Key First"; for (size_t i = 0; i < sizeof(key6) - 1; ++i) key6[i] = 0xaa; std::cout << "case 6: " << clx::hmac(key6, sizeof(key6) - 1, dat6, sizeof(dat6) - 1).to_string() << std::endl; // test_case = 7 char key7[81]; char dat7[74] = "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data"; for (size_t i = 0; i < sizeof(key7) - 1; ++i) key7[i] = 0xaa; std::cout << "case 7: " << clx::hmac(key7, sizeof(key7) - 1, dat7, sizeof(dat7) - 1).to_string() << std::endl; return 0; } example/example_html.cpp0000700000175300010010000000414111055553016015042 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_html.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Wed 13 Aug 2008 14:16:00 JST */ /* ------------------------------------------------------------------------- */ #include #include #include "clx/html.h" int main(int argc, char* argv[]) { std::ostreambuf_iterator result(std::cout); std::istreambuf_iterator input(std::cin); std::istreambuf_iterator last; clx::html::escape(input, last, result); return 0; } example/example_http.cpp0000700000175300010010000000545711101067032015056 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_http.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Mon 24 Aug 2008 05:24:10 JST */ /* ------------------------------------------------------------------------- */ #include #include "clx/http.h" #include "clx/uri.h" int main(int argc, char* argv[]) { if (argc < 3) return -1; try { clx::http session(clx::uri::encode(argv[1]), 80); session.get(clx::uri::encode(argv[2])); std::cout << "code: " << session.code() << std::endl; std::cout << std::endl; std::cout << "head" << std::endl; std::cout << "--" << std::endl; for (clx::http::head_iterator pos = session.head().begin(); pos != session.head().end(); pos++) { std::cout << pos->first << ": " << pos->second << std::endl; } std::cout << std::endl; std::cout << "body" << std::endl; std::cout << "--" << std::endl; std::cout << session.body() << std::endl; } catch (clx::socket_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } catch (clx::sockaddress_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } catch (std::runtime_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } return 0; } example/example_https.cpp0000700000175300010010000000547211101066724015245 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_https_verify.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Wed 22 Oct 2008 14:57:10 JST */ /* ------------------------------------------------------------------------- */ #include #include "clx/https.h" #include "clx/uri.h" int main(int argc, char* argv[]) { if (argc < 3) return -1; try { clx::https session(clx::uri::encode(argv[1]), 443); session.get(clx::uri::encode(argv[2])); std::cout << "code: " << session.code() << std::endl; std::cout << std::endl; std::cout << "head" << std::endl; std::cout << "--" << std::endl; for (clx::http::head_iterator pos = session.head().begin(); pos != session.head().end(); pos++) { std::cout << pos->first << ": " << pos->second << std::endl; } std::cout << std::endl; std::cout << "body" << std::endl; std::cout << "--" << std::endl; std::cout << session.body() << std::endl; } catch (clx::socket_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } catch (clx::sockaddress_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } catch (std::runtime_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } return 0; } example/example_https_verify.cpp0000700000175300010010000000576711101475507016643 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_https_verify.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Wed 22 Oct 2008 14:57:10 JST */ /* ------------------------------------------------------------------------- */ #include #include "clx/https.h" #include "clx/uri.h" int main(int argc, char* argv[]) { if (argc < 3) return -1; try { clx::https session; try { session.verify_locations("ca-bundle.crt"); session.start(clx::uri::encode(argv[1]), 443); } catch (clx::verify_error& e) { std::cerr << e.what() << std::endl; // std::exit(-1); } session.get(clx::uri::encode(argv[2])); std::cout << "code: " << session.code() << std::endl; std::cout << std::endl; std::cout << "head" << std::endl; std::cout << "--" << std::endl; for (clx::http::head_iterator pos = session.head().begin(); pos != session.head().end(); pos++) { std::cout << pos->first << ": " << pos->second << std::endl; } std::cout << std::endl; std::cout << "body" << std::endl; std::cout << "--" << std::endl; std::cout << session.body() << std::endl; } catch (clx::socket_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } catch (clx::sockaddress_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } catch (std::runtime_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } return 0; } example/example_icmp.cpp0000700000175300010010000001001711043014462015017 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_icmp.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Sun 27 Jul 2008 12:12:03 JST */ /* ------------------------------------------------------------------------- */ #include #include #include #include #include "clx/icmp.h" #include "clx/timer.h" #include "clx/argument.h" #include "clx/format.h" int main(int argc, char* argv[]) { clx::argument arg(argc, argv); if (arg.head().empty()) { std::cerr << "usage " << argv[0] << " hostname [-l data_bytes]" << std::endl; return -1; } /* bufは送受信兼用バッファ． * -send()メソッド: payload + ICMPヘッダ長 * -recv()メソッド: payload + IPヘッダ長 + ICMPヘッダ長 * 以上を考慮して大きめに領域を確保する． */ clx::icmp::packet_header hdr; int payload = 56; arg("l,length", payload); int packetsize = payload + hdr.icmp_size(); int buffsize = packetsize + 1024; std::auto_ptr buf(new char[buffsize]); try { clx::icmp::socket s(arg.head().at(0)); std::cout << clx::format("ICMP ECHO %s (%s): %d data bytes") % arg.head().at(0) % s.to().ipaddr() % payload << std::endl; int seq = 0; while (1) { std::memset(buf.get(), 'a', packetsize); // sending ICMP echo request hdr.reset(); hdr.icmp()->type = ICMP_ECHO_REQUEST; hdr.icmp()->sequence = seq; std::memcpy(buf.get(), (char*)hdr.icmp(), hdr.icmp_size()); s.send(buf.get(), packetsize); clx::timer t; // receiving ICMP echo packet std::memset(buf.get(), 0, buffsize); int len = s.recv(buf.get(), buffsize); if (len < 0) return -1; double recv = t.total_elapsed(); // print information hdr = buf.get(); if (hdr.icmp()->type == ICMP_ECHO_REPLY) { std::cout << clx::format("%d bytes from %s: icmp_seq=%d ttl=%d time=%d ms") % len % s.from().ipaddr() % static_cast(hdr.icmp()->sequence) % static_cast(hdr.ip()->ttl) % static_cast(recv * 1000) << std::endl; seq = hdr.icmp()->sequence + 1; } else { std::cerr << clx::format("received ICMP packet (type: %d) from %s") % static_cast(hdr.icmp()->type) % s.from().ipaddr() << std::endl; } clx::sleep(1.0); } } catch (clx::socket_error& e) { std::cerr << e.what() << std::endl; return -1; } catch (clx::sockaddress_error& e) { std::cerr << e.what() << std::endl; return -1; } return 0; } example/example_ini.cpp0000700000175300010010000000517311075735652014675 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_ini.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Wed 28 Mar 2007 16:14:09 JST */ /* ------------------------------------------------------------------------- */ #include #include "clx/ini.h" int main(int argc, char* argv[]) { if (argc < 2) std::exit(-1); try { clx::ini ini(argv[1]); ini.insert("hoge"); ini["hoge"]["fuga"] = "foo"; for (clx::ini::iterator p = ini.begin(); p != ini.end(); p++) { std::cout << "***" << p->first << "***" << std::endl; for (clx::ini::sub_iterator q = p->second.begin(); q != p->second.end(); q++) { std::cout << '<' << q->first << "><" << q->second << '>' << std::endl; } } if (ini.exist("Settings", "AnonymousRecipient")) std::cout << "found!" << std::endl; } catch (clx::syntax_error& e) { std::cerr << argv[1] << ':' << e.line() << ": error: " << e.what() << std::endl; std::exit(-1); } catch (std::runtime_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } return 0; } example/example_ioftime.cpp0000700000175300010010000000513611060130667015536 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_ioftime.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Fri 02 Nov 2007 23:18:23 JST */ /* ------------------------------------------------------------------------- */ #include #include #include "clx/date_time.h" int main(int argc, char* argv[]) { std::string str = "Sat 17 Mar 2007 19:56:19 JST"; std::string infmt = "%a %d %b %Y %H:%M:%S JST"; std::cout << "Input string: " << str << std::endl; std::cout << "Input format: " << infmt << std::endl; std::cout << std::endl; // 文字列strをinfmtにしたがって解析する． clx::date_time input; input.from_string(str, infmt); /* * 時刻をoutfmtのフォーマットで出力する． * iftime::data()は，date_timeクラスの形で解析した時刻を返す． * oftimeには，C標準のstruct tm，time_tを引数に指定することも可能． */ std::string outfmt = "%x %X"; std::cout << "Output format: " << outfmt << std::endl; std::cout << "Result: " << input.to_string(outfmt) << std::endl; return 0; } example/example_json.cpp0000700000175300010010000000646011075125316015055 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_json.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Fri 29 Aug 2008 01:28:00 JST */ /* ------------------------------------------------------------------------- */ // ワイド文字関連のCLXライブラリを使用するために必要 #ifndef CLX_USE_WCHAR #define CLX_USE_WCHAR #endif #include #include #include "clx/http.h" #include "clx/uri.h" #include "clx/code_convert.h" #include "clx/json.h" int main(int argc, char* argv[]) { if (argc < 3) std::exit(-1); clx::http session(clx::uri::encode(argv[1])); if (!session.get(clx::uri::encode(argv[2]))) { std::cerr << "failed to get response" << std::endl; std::exit(-1); } /* * parse a hatena bookmark entry. * はてなのJSONは()で括られているので，その部分は除外． */ std::wstring body = clx::code_convert(session.body()); clx::wjson hateb(body.begin() + 1, body.end() - 1); std::wcout.imbue(std::locale("japanese")); for (clx::wjson::iterator pos = hateb.begin(); pos != hateb.end(); pos++) { std::wcout << pos->first << L": " << pos->second << std::endl; } std::wcout << std::endl; // parse and print the detail of "bookmarks" clx::wjson_array bk(hateb[L"bookmarks"]); if (bk.empty()) return 0; std::wcout << L"bookmarks have " << bk.objects().size() << L" object, " << bk.strings().size() << L" string" << std::endl; std::wcout << L"-----" << std::endl; for (size_t i = 0; i < bk.objects().size(); i++) { std::wcout << L"object " << i << L":" << std::endl; for (clx::wjson::iterator pos = bk.object(i).begin(); pos != bk.object(i).end(); pos++) { std::wcout << L"\t" << pos->first << L": " << pos->second << std::endl; } } return 0; } example/example_lexical_cast.cpp0000700000175300010010000000533611054626612016542 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_lexical_cast.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Fri 11 Jul 2008 08:33:00 JST */ /* ------------------------------------------------------------------------- */ #include #include #include "clx/lexical_cast.h" int main(int argc, char* argv[]) { std::string s1 = "326"; std::string s2 = "0xf2a"; std::string serr = "nonum"; try { int a = clx::lexical_cast(s1, std::ios::oct); int b = clx::lexical_cast(s2, std::ios::showbase); std::cout << "str " << s1 << ", val " << a << std::endl; std::cout << "str " << s2 << ", val " << b << std::endl; std::string s3 = clx::lexical_cast(a, std::ios::hex); std::cout << "val " << a << ", str " << s3 << std::endl; std::string s4 = clx::lexical_cast(s3); std::cout << "str1 " << s3 << ", str2 " << s4 << std::endl; int c = clx::lexical_cast(serr); std::cout << "str " << serr << ", val " << c << std::endl; } catch (clx::bad_lexical_cast e) { std::cerr << "exeption: " << e.what() << std::endl; std::exit(-1); } return 0; } example/example_localhost.cpp0000700000175300010010000000442511124614234016070 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_localhost.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Thu 25 Dec 2008 14:22:00 JST */ /* ------------------------------------------------------------------------- */ #include #include "clx/resolver.h" int main(int argc, char* argv[]) { /* * clx::localhost(socket_int s); * clx::localhost(Socket& s); * clx::localhost(); * * 現在，通信を行っている（connect の完了している）ソケットが存在 * する場合は，そのソケットを用いてローカルホストの IP アドレスを * 取得する．通信を行っているソケットが存在しない場合は，引数なし * で localhost を呼び出す． */ std::cout << clx::localhost() << std::endl; return 0; } example/example_md5.cpp0000700000175300010010000000573711057124222014572 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_md5.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Tue 02 Sep 2008 11:41:00 JST */ /* ------------------------------------------------------------------------- */ #include #include #include "clx/md5.h" int main(int argc, char* argv[]) { std::string s1 = ""; std::string s2 = "a"; std::string s3 = "abc"; std::string s4 = "message digest"; std::string s5 = "abcdefghijklmnopqrstuvwxyz"; std::string s6 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"; clx::md5 md; std::cout << "str: " << s1 << std::endl; std::cout << "md5: " << md.encode(s1).to_string() << std::endl; std::cout << std::endl; std::cout << "str: " << s2 << std::endl; std::cout << "md5: " << md.encode(s2).to_string() << std::endl; std::cout << std::endl; std::cout << "str: " << s3 << std::endl; std::cout << "md5: " << md.encode(s3).to_string() << std::endl; std::cout << std::endl; std::cout << "str: " << s4 << std::endl; std::cout << "md5: " << md.encode(s4).to_string() << std::endl; std::cout << std::endl; std::cout << "str: " << s5 << std::endl; std::cout << "md5: " << md.encode(s5).to_string() << std::endl; std::cout << std::endl; std::cout << "str: " << s6 << std::endl; std::cout << "md5: " << md.encode(s6).to_string() << std::endl; std::cout << std::endl; return 0; } example/example_percentile.cpp0000700000175300010010000000415311035552414016232 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_percentile.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Fri 02 Nov 2007 21:56:00 JST */ /* ------------------------------------------------------------------------- */ #include #include #include "clx/quantile.h" int main(int argc, char* argv[]) { std::istream_iterator input(std::cin); std::istream_iterator last; double val = clx::percentile(input, last, 95); std::cout << 95 << "% percentile: " << val << std::endl; return 0; } example/example_pop3.cpp0000700000175300010010000000576411124535557015002 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_pop3.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Sun 26 Oct 2008 21:59:00 JST */ /* ------------------------------------------------------------------------- */ #include #include #include "clx/pop3.h" int main(int argc, char* argv[]) { if (argc < 4) { std::cerr << "usage " << argv[0] << " host id pass" << std::endl; std::exit(-1); } try { clx::pop3 session(argv[1], 110); // APOP が使用できるなら APOP 認証を用いる． session.login(argv[2], argv[3], session.apop_support()); std::cout << "status: " << session.status() << std::endl; // LIST コマンド clx::pop3::list_type list = session.list(); std::cout << "mail list" << std::endl; std::cout << "-----" << std::endl; for (size_t i = 0; i < list.size(); ++i) { std::cout << list[i] << std::endl; } std::cout << "-----" << std::endl; // TOP コマンド std::cout << "top [1]" << std::endl; std::cout << "-----" << std::endl; std::cout << session.top(1, 3) << std::endl; std::cout << "-----" << std::endl; session.finish(); } catch (clx::pop3_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } catch (clx::socket_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } catch (std::runtime_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } return 0; } example/example_pop3s.cpp0000700000175300010010000000565211101476475015157 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_pop3s.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Sun 26 Oct 2008 21:59:00 JST */ /* ------------------------------------------------------------------------- */ #include #include #include "clx/pop3s.h" int main(int argc, char* argv[]) { if (argc < 4) std::exit(-1); try { clx::pop3s session(argv[1], 995); // APOP が使用できるなら APOP 認証を用いる． session.login(argv[2], argv[3], session.apop_support()); std::cout << "status: " << session.status() << std::endl; // LIST コマンド clx::pop3s::list_type list = session.list(); std::cout << "mail list" << std::endl; std::cout << "-----" << std::endl; for (size_t i = 0; i < list.size(); ++i) { std::cout << list[i] << std::endl; } std::cout << "-----" << std::endl; // TOP コマンド std::cout << "top [1]" << std::endl; std::cout << "-----" << std::endl; std::cout << session.top(1, 0) << std::endl; std::cout << "-----" << std::endl; session.finish(); } catch (clx::pop3_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } catch (clx::socket_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } catch (std::runtime_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } return 0; } example/example_random.cpp0000700000175300010010000000452511075301251015356 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_random.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Thu 09 Oct 2008 07:38:00 JST */ /* ------------------------------------------------------------------------- */ #include #include "clx/random.h" #include "clx/format.h" int main(int argc, char* argv[]) { clx::random rand1; printf("1000 outputs of clx::random\n"); for (int i = 0; i < 1000; ++i) { std::cout << clx::format("%10u ") % rand1(); if (i % 5 == 4) std::cout << std::endl; } printf("1000 outputs of clx::random\n"); clx::random rand2; for (int i = 0; i < 1000; ++i) { std::cout << clx::format("%10.8f ") % rand2(); if (i % 5 == 4) std::cout << std::endl; } return 0; } example/example_remove.cpp0000700000175300010010000000421211035506376015377 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_remove.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Thu 18 Oct 2007 18:38:00 JST */ /* ------------------------------------------------------------------------- */ #include #include #include "clx/salgorithm.h" int main(int argc, char* argv[]) { std::string s = "Hello, woooooooooorld!"; std::cout << "original: " << s << std::endl; std::cout << "unique: " << clx::unique_copy(s) << std::endl; std::cout << "squeeze: " << clx::squeeze_copy(s, 'o') << std::endl; return 0; } example/example_replace.cpp0000700000175300010010000000440211035507606015513 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_replace.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Mon 22 Oct 2007 17:22:00 JST */ /* ------------------------------------------------------------------------- */ #include #include #include "clx/salgorithm.h" int main(int argc, char* argv[]) { std::string s = "apple apple apple apple apple"; std::cout << "original: " << s << std::endl; std::cout << "replace from apple to orange" << std::endl; std::cout << "replace (4th): " << clx::replace_copy(s, "apple", "orange", 4) << std::endl; std::cout << "replace_all: " << clx::replace_all_copy(s, "apple", "orange") << std::endl; return 0; } example/example_resolver.cpp0000700000175300010010000000517511035570516015751 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_resolver.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Mon 20 Feb 2006 12:45:00 JST */ /* ------------------------------------------------------------------------- */ #include #include "clx/resolver.h" int main(int argc , char *argv[]) { if (argc < 2) return -1; clx::resolver addr; if (!addr.lookup(argv[1])) { std::cerr << "Cannot find " << argv[1] << ": Non-existent domain" << std::endl; return -1; } std::cout << "Name: " << addr.hostname() << std::endl; // print addresses if (!addr.addresses().empty()) std::cout << "Address: " << inet_ntoa(addr.addresses().at(0)); for (size_t i = 1; i < addr.addresses().size(); i++) { std::cout << ", " << inet_ntoa(addr.addresses().at(i)); } std::cout << std::endl; // print aliaseses if (!addr.aliases().empty()) std::cout << "Alias: " << addr.aliases().at(0); for (size_t i = 1; i < addr.aliases().size(); i++) { std::cout << ", " << addr.aliases().at(i); } std::cout << std::endl; return 0; } example/example_scanner.cpp0000700000175300010010000000516011035655572015541 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_scanner.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Fri 31 Mar 2006 13:13:00 JST */ /* ------------------------------------------------------------------------- */ #include #include #include "clx/scanner.h" #include "clx/lexical_cast.h" class my_assign { public: template void operator()(const std::string& s, ValueT& dest) { dest = clx::lexical_cast(s) + 1000; } }; int main(int argc, char* argv[]) { std::string fmt = "%s/%s/%s %s:%s:%s"; std::string s = "2006/03/31 13:00:30"; int year, mon, day, hour, min, sec; // scan from string clx::scanner(s, fmt) % year % mon % day % hour % min % sec; std::cout << "Today is " << day << ' ' << mon << ", " << year << std::endl; hour = 0; min = 0; sec = 0; // scan from cin std::cout << "Date: "; clx::scanner(std::cin, fmt)(5, sec)(4, min)(3, hour, my_assign()); std::cout << "Now, it is " << hour << ':' << min << ':' << sec << std::endl; return 0; } example/example_sha1.cpp0000700000175300010010000000561211077305755014747 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_sha1.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Tue 02 Sep 2008 11:41:00 JST */ /* ------------------------------------------------------------------------- */ #include #include #include "clx/sha1.h" int main(int argc, char* argv[]) { std::string s1 = "abc"; std::string s2 = "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"; std::string s3 = "a"; std::string s4 = "0123456701234567012345670123456701234567012345670123456701234567"; clx::sha1 hash; std::cout << "str: " << s1 << std::endl; std::cout << "sha1: " << hash.encode(s1).to_string() << std::endl; std::cout << std::endl; std::cout << "str: " << s2 << std::endl; std::cout << "sha1: " << hash.encode(s2).to_string() << std::endl; std::cout << std::endl; std::cout << "str: " << s3 << std::endl; hash.reset(); for (int i = 0; i < 1000000; i++) { hash.update(s3.c_str(), s3.size()); } hash.finish(); std::cout << "sha1: " << hash.to_string() << std::endl; std::cout << std::endl; std::cout << "str: " << s4 << std::endl; hash.reset(); for (int i = 0; i < 10; i++) { hash.update(s4.c_str(), s4.size()); } hash.finish(); std::cout << "sha1: " << hash.to_string() << std::endl; std::cout << std::endl; return 0; } example/example_smtp.cpp0000700000175300010010000000733411125004637015066 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_smtp.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Wed 22 Oct 2008 15:11:00 JST */ /* ------------------------------------------------------------------------- */ #include #include #include #include "clx/smtp.h" #include "clx/date_time.h" int main(int argc, char* argv[]) { if (argc < 6) { std::cerr << "usage " << argv[0] << " host id pass from to" << std::endl; std::exit(-1); } try { clx::smtp session(argv[1], 25); /* * 第3引数でSMTP-AUTH の方法を指定する． * - clx::smtp_auth::plain * - clx::smtp_auth::login * - clx::smtp_auth::cram_md5 * * clx::smtp_auth::none を指定すると SMTP-AUTH は行わずに EHLO パケット * を送信するのみ．clx::smtp_auth::best を指定すると， * cram_md5 -> plain -> login の順番でサーバがサポートしているかどうか * 調べ，最初にサポートしていた方式で認証を行う．いずれにも対応していない * 場合は，clx::smtp_auth::none を指定した場合と同じ． * * 第3引数の省略時は，clx::smtp_auth::best． */ session.login(argv[2], argv[3]); std::string from(argv[4]); std::string to(argv[5]); // create a sample message std::stringstream msg; clx::date_time now; msg << "Date: " << now.to_string("%a, %d %b %Y %H:%M:%S +0900") << "\r\n"; msg << "From: " << from << "\r\n"; msg << "To: " << to << "\r\n"; msg << "Subject: SMTP test mail\r\n"; msg << "\r\n"; msg << "This ia test mail for clx::smtp class.\r\n"; msg << ".\r\n"; session.mail(from, to, msg.str()); session.finish(); // print message log clx::smtp::response_array::reverse_iterator pos; for (pos = session.responses().rbegin(); pos != session.responses().rend(); ++pos) { std::cout << pos->second << std::endl; std::cout << std::endl; } } catch (clx::smtp_error& e) { std::cerr << e.code() << ": " << e.what() << std::endl; std::exit(-1); } catch (clx::socket_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } catch (std::runtime_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } return 0; } example/example_smtps.cpp0000700000175300010010000000615311102002502015227 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_smtps.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Wed 22 Oct 2008 15:11:00 JST */ /* ------------------------------------------------------------------------- */ #include #include #include #include "clx/smtps.h" #include "clx/date_time.h" int main(int argc, char* argv[]) { if (argc < 6) { std::cerr << "usage " << argv[0] << " host id pass from to" << std::endl; std::exit(-1); } try { clx::smtps session(argv[1], 465); session.login(argv[2], argv[3]); std::string from(argv[3]); std::string to(argv[4]); // create a sample message std::stringstream msg; clx::date_time now; msg << "Date: " << now.to_string("%a, %d %b %Y %H:%M:%S +0900") << "\r\n"; msg << "From: " << from << "\r\n"; msg << "To: " << to << "\r\n"; msg << "Subject: SMTP test mail\r\n"; msg << "\r\n"; msg << "This ia test mail for clx::smtp class.\r\n"; msg << ".\r\n"; session.mail(from, to, msg.str()); session.finish(); // print message log for (size_t i = 0; i < session.responses().size(); i++) { std::cout << session.response(i).first << ": " << session.response(i).second << std::endl; } } catch (clx::smtp_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } catch (clx::socket_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } catch (std::runtime_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } return 0; } example/example_smtp_list.cpp0000700000175300010010000001250311107064773016122 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_smtp.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Fri 14 Nov 2008 02:55:00 JST */ /* ------------------------------------------------------------------------- */ #include #include #include #include #include "clx/smtp.h" #include "clx/date_time.h" /* ------------------------------------------------------------------------- */ /* * sendmail * * From, To, Cc, Bcc, Subject, および本文を登録しておき，メール送信時 * に整形して送信するためのクラス． */ /* ------------------------------------------------------------------------- */ enum { mailto = 0, mailcc, mailbcc }; class sendmail { public: typedef char char_type; typedef std::basic_string string_type; typedef std::list mailing_list; sendmail() : to_(), cc_(), bcc_(), from_(), subject_(), message_() {} virtual ~sendmail() {} sendmail& add(const string_type& addr, int type = mailto) { switch (type) { case mailto: to_.push_back(addr); break; case mailcc: cc_.push_back(addr); break; case mailbcc: bcc_.push_back(addr); break; default: break; } return *this; } sendmail& from(const string_type& addr) { from_ = addr; return *this; } sendmail& subject(const string_type& s) { subject_ = s; return *this; } sendmail& message(const string_type& s) { message_ = s; return *this; } template void operator()(OutputStream& sout) { std::basic_stringstream ss; clx::date_time now; ss << "Date: " << now.to_string("%a, %d %b %Y %H:%M:%S +0900") << "\r\n"; ss << "From: " << from_ << "\r\n"; if (!to_.empty()) { ss << "To: "; this->xmake(ss, to_); } if (!cc_.empty()) { ss << "Cc: "; this->xmake(ss, cc_); } if (!bcc_.empty()) { ss << "Bcc: "; this->xmake(ss, bcc_); } ss << "Subject: " << subject_ << "\r\n"; ss << "\r\n"; ss << message_ << "\r\n"; ss << ".\r\n"; sout << ss.str(); } private: mailing_list to_; mailing_list cc_; mailing_list bcc_; string_type from_; string_type subject_; string_type message_; template void xmake(OutputStream& sout, const MailingList& lst) { if (lst.size() == 1) sout << lst.front() << "\r\n"; else { for (typename MailingList::const_iterator pos = lst.begin(); pos != lst.end(); ++pos) { sout << *pos << ", "; } sout << "\r\n"; } } }; /* ------------------------------------------------------------------------- */ /* * main * * Subject と本文は決めうち．Cc は From に指定されたアドレスを指定する． */ /* ------------------------------------------------------------------------- */ int main(int argc, char* argv[]) { if (argc < 6) { std::cerr << "usage " << argv[0] << " host id pass from to" << std::endl; std::exit(-1); } std::string from(argv[4]); std::string to(argv[5]); sendmail f; f.from(from); f.add(to, mailto); f.add(from, mailcc); f.subject(std::string("SMTP test mail")); f.message(std::string("This is a test mail for clx::smtp class.")); try { clx::smtp session(argv[1], 25); session.login(argv[2], argv[3]); std::list lst; lst.push_back(to); // To lst.push_back(from); // Cc session.mail(from, lst, f); session.finish(); } catch (clx::smtp_error& e) { std::cerr << e.code() << ": " << e.what() << std::endl; std::exit(-1); } catch (clx::socket_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } catch (std::runtime_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } return 0; } example/example_sockbuf.cpp0000700000175300010010000000514211057471611015536 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_sockbuf.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Wed 03 Sep 2008 20:22:00 JST */ /* ------------------------------------------------------------------------- */ #include #include #include #include #include "clx/tcp.h" int main(int argc, char* argv[]) { if (argc < 3) return -1; try { clx::tcp::socket s(argv[1], 80); // sockbuf と iostream を用いて sockstream を生成する方法． clx::tcp::sockbuf sbuf(s, 2048); std::iostream ss(&sbuf); std::stringstream query; query << "GET /" << argv[2] << " HTTP/1.1\r\n"; query << "Host: " << argv[1] << "\r\n"; query << "\r\n"; ss << query.str() << std::flush; std::string buf; while (std::getline(ss, buf)) std::cout << buf << std::endl; } catch (clx::socket_error& e) { std::cerr << e.what() << std::endl; return -1; } catch (clx::sockaddress_error& e) { std::cerr << e.what() << std::endl; return -1; } return 0; } example/example_sockmanager_recv.cpp0000700000175300010010000000775511101076547017426 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_sockmanager_recv.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Mon 14 Jul 2008 07:19:10 JST */ /* ------------------------------------------------------------------------- */ #include #include #include "clx/tcp.h" #include "clx/sockhandler.h" /* ------------------------------------------------------------------------- */ // chat_service /* ------------------------------------------------------------------------- */ class chat_service { public: typedef clx::tcp::sockstream socket_type; chat_service(socket_int s) : accid_(s) {} template bool operator()(SockT* s, SockManager& sm) { socket_type* ss = dynamic_cast(s); std::string ipaddr = ss->address().ipaddr(); int port = ss->address().port(); std::string buf; if (!std::getline(*ss, buf)) { std::cout << ipaddr << ':' << port << ": connection was closed" << std::endl; ss->close(); return false; } /* * 接続されている全クライアントに受信したメッセージを * message (xxx.xxx.xxx.xxx:port) * という形で送信する．ただし，sockmanager には接続確立用の * ソケットも登録されてあるため，そのソケットには送らないように * 注意する．コンストラクタで接続確立用のソケットのソケット番号 * を知らせてもらっている (accid_) ので，その値を基に判断する． */ buf += " (" + ipaddr + ":" + clx::lexical_cast(port) + ")"; for (typename SockManager::iterator pos = sm.begin(); pos != sm.end(); pos++) { if (sm.socket(pos)->socket() == accid_) continue; socket_type* os = dynamic_cast(sm.socket(pos)); *os << buf << std::endl; } return true; } private: socket_int accid_; // acceptorのソケット番号 }; /* ------------------------------------------------------------------------- */ // main /* ------------------------------------------------------------------------- */ int main(int argc, char* argv[]) { typedef clx::tcp::accept_handler handler_type; try { clx::tcp::sockmanager s; int port = clx::tcp::port(argv[1]); s.add(new clx::tcp::acceptor(port), handler_type()); s.start(); } catch (clx::socket_error& e) { std::cerr << e.what() << std::endl; return -1; } catch (clx::sockaddress_error& e) { std::cerr << e.what() << std::endl; return -1; } return 0; } example/example_sockmanager_send.cpp0000700000175300010010000000733611115470545017414 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_sockmanager_send.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Mon 14 Jul 2008 07:19:10 JST */ /* ------------------------------------------------------------------------- */ #include #include #include #include "clx/tcp.h" /* ------------------------------------------------------------------------- */ // send_msg /* ------------------------------------------------------------------------- */ bool send_msg(clx::tcp::rawsocket* s, clx::tcp::sockmanager& sm) { // read string from std::cin std::string buf; if (!std::getline(std::cin, buf)) { sm.stop(); return false; } // write string to the socket for (clx::tcp::sockmanager::iterator pos = sm.begin(); pos != sm.end(); pos++) { if (sm.socket(pos)->socket() == s->socket()) continue; clx::tcp::sockstream* ss = dynamic_cast(sm.socket(pos)); *ss << buf << std::endl; } return true; } /* ------------------------------------------------------------------------- */ // recv_msg /* ------------------------------------------------------------------------- */ bool recv_msg(clx::tcp::rawsocket* s, clx::tcp::sockmanager& sm) { clx::tcp::sockstream* ss = dynamic_cast(s); std::string buf; if (!std::getline(*ss, buf)) { ss->close(); return false; } std::cout << buf << std::endl; return true; } /* ------------------------------------------------------------------------- */ // main /* ------------------------------------------------------------------------- */ int main(int argc, char* argv[]) { if (argc < 2) { std::cerr << "usage: " << argv[0] << " host" << std::endl; return -1; } try { clx::tcp::sockmanager sm; int port = clx::tcp::port(argv[2]); sm.add(new clx::tcp::sockstream(argv[1], port), recv_msg); sm.add(new clx::tcp::rawsocket(0), send_msg); // for std::cin sm.start(); } catch (clx::socket_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } catch (clx::sockaddress_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } return 0; } example/example_sockstream.cpp0000700000175300010010000000475211100552225016251 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_sockstream.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Wed 28 Mar 2007 16:35:23 JST */ /* ------------------------------------------------------------------------- */ #include #include #include #include #include "clx/tcp.h" int main(int argc, char* argv[]) { if (argc < 3) return -1; try { clx::tcp::sockstream ss(argv[1], 80); std::stringstream query; query << "GET /" << argv[2] << " HTTP/1.1\r\n"; query << "Host: " << argv[1] << "\r\n"; query << "\r\n"; ss << query.str() << std::flush; std::string buf; while (std::getline(ss, buf)) std::cout << buf << std::endl; } catch (clx::socket_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } catch (clx::sockaddress_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } return 0; } example/example_split.cpp0000700000175300010010000000475311035510636015241 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_split.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Mon 22 Oct 2007 17:22:00 JST */ /* ------------------------------------------------------------------------- */ #include #include #include #include "clx/salgorithm.h" int main(int argc, char* argv[]) { std::string s = "apple orange,strawberry pineapple,,,"; std::cout << "original: " << s << std::endl; /* * スペース，タブ文字，コンマを区切り文字として分割する． * ただし，空のトークンは認めない（無視する）． */ std::cout << "split: "; std::vector tok; clx::split_if(s, tok, clx::is_any_of(" \t,")); for (unsigned int i = 0; i < tok.size(); i++) { std::cout << '<' << tok.at(i) << "> "; } std::cout << std::endl; std::string result; clx::join(tok, result, "="); std::cout << "join: " << result << std::endl; return 0; } example/example_ssl.cpp0000700000175300010010000000511511077542047014707 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_ssl.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Wed 22 Oct 2008 15:11:00 JST */ /* ------------------------------------------------------------------------- */ #include #include #include #include "clx/ssl.h" #include "clx/cstring.h" int main(int argc, char* argv[]) { if (argc < 3) std::exit(-1); try { clx::ssl::sockstream ss(argv[1], 443); std::stringstream query; query << "GET /" << argv[2] << " HTTP/1.1\r\n"; query << "Host: " << argv[1] << "\r\n"; query << "\r\n"; ss << query.str() << std::flush; std::string buf; while (std::getline(ss, buf)) std::cout << buf << std::endl; } catch (clx::socket_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } catch (clx::sockaddress_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } catch (std::runtime_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } return 0; } example/example_sslmanager_recv.cpp0000700000175300010010000001210311104637661017252 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_sockmanager_recv.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Mon 14 Jul 2008 07:19:10 JST */ /* ------------------------------------------------------------------------- */ #include #include #include "clx/ssl.h" /* ----------------------------------------------------------------- */ // accept_handler /* ----------------------------------------------------------------- */ template class accept_handler { public: typedef Socket socket_type; typedef clx::ssl::acceptor acceptor_type; typedef Service service_handler; explicit accept_handler(const std::string& pub, const std::string& priv) : public_(pub), private_(priv) {} explicit accept_handler(const char* pub, const char* priv) : public_(pub), private_(priv) {} virtual ~accept_handler() throw() {} template bool operator()(T* s, SockManager& sm) { acceptor_type* server = dynamic_cast(s); socket_type* client = new socket_type(server->accept(public_, private_)); if (client == NULL) throw std::bad_alloc(); sm.add(client, service_handler(server->socket())); return true; } private: std::string public_; std::string private_; }; /* ------------------------------------------------------------------------- */ // chat_service /* ------------------------------------------------------------------------- */ class chat_service { public: typedef clx::ssl::sockstream socket_type; chat_service(socket_int s) : accid_(s) {} template bool operator()(SockT* s, SockManager& sm) { socket_type* ss = dynamic_cast(s); std::string ipaddr = ss->address().ipaddr(); int port = ss->address().port(); std::string buf; if (!std::getline(*ss, buf)) { std::cout << ipaddr << ':' << port << ": connection was closed" << std::endl; ss->close(); return false; } /* * 接続されている全クライアントに受信したメッセージを * message (xxx.xxx.xxx.xxx:port) * という形で送信する．ただし，sockmanager には接続確立用の * ソケットも登録されてあるため，そのソケットには送らないように * 注意する．コンストラクタで接続確立用のソケットのソケット番号 * を知らせてもらっている (accid_) ので，その値を基に判断する． */ buf += " (" + ipaddr + ":" + clx::lexical_cast(port) + ")"; for (typename SockManager::iterator pos = sm.begin(); pos != sm.end(); pos++) { if (sm.socket(pos)->socket() == accid_) continue; socket_type* os = dynamic_cast(sm.socket(pos)); *os << buf << std::endl; } return true; } private: socket_int accid_; // acceptorのソケット番号 }; /* ------------------------------------------------------------------------- */ // main /* ------------------------------------------------------------------------- */ int main(int argc, char* argv[]) { typedef accept_handler handler_type; try { clx::ssl::sockmanager s; int port = clx::ssl::port(argv[1]); s.add(new clx::ssl::acceptor(port), handler_type("public.key", "private.key")); s.start(); } catch (clx::socket_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } catch (clx::sockaddress_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } catch (std::runtime_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } return 0; } example/example_sslmanager_send.cpp0000700000175300010010000000747411105021716017250 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_sslmanager_send.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Thu 06 Nov 2008 21:44:10 JST */ /* ------------------------------------------------------------------------- */ #include #include #include #include "clx/ssl.h" /* ------------------------------------------------------------------------- */ // send_msg /* ------------------------------------------------------------------------- */ bool send_msg(clx::ssl::rawsocket* s, clx::ssl::sockmanager& sm) { // read string from std::cin std::string buf; if (!std::getline(std::cin, buf)) { sm.stop(); return false; } // write string to the socket for (clx::ssl::sockmanager::iterator pos = sm.begin(); pos != sm.end(); pos++) { if (sm.socket(pos)->socket() == s->socket()) continue; clx::ssl::sockstream* ss = dynamic_cast(sm.socket(pos)); *ss << buf << std::endl; } return true; } /* ------------------------------------------------------------------------- */ // recv_msg /* ------------------------------------------------------------------------- */ bool recv_msg(clx::ssl::rawsocket* s, clx::ssl::sockmanager& sm) { clx::ssl::sockstream* ss = dynamic_cast(s); std::string buf; if (!std::getline(*ss, buf)) { ss->close(); return false; } std::cout << buf << std::endl; return true; } /* ------------------------------------------------------------------------- */ // main /* ------------------------------------------------------------------------- */ int main(int argc, char* argv[]) { if (argc < 2) { std::cerr << "usage: " << argv[0] << " host" << std::endl; return -1; } try { clx::ssl::sockmanager sm; int port = clx::ssl::port(argv[2]); sm.add(new clx::ssl::sockstream(argv[1], port), recv_msg); sm.add(new clx::ssl::rawsocket(0), send_msg); // for std::cin sm.start(); } catch (clx::socket_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } catch (clx::sockaddress_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } catch (std::runtime_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } return 0; } example/example_ssl_client.cpp0000700000175300010010000000502711077740427016251 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_ssl_client.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Wed 22 Oct 2008 14:56:09 JST */ /* ------------------------------------------------------------------------- */ #include #include #include #include #include "clx/ssl.h" #include "clx/lexical_cast.h" int main(int argc, char* argv[]) { if (argc < 3) return -1; try { clx::ssl::socket s; s.connect(argv[1], clx::lexical_cast(argv[2])); clx::ssl::sockstream tcps(s); while (1) { std::string buf; std::cin >> buf; if (std::cin.eof()) break; tcps << buf; } } catch (clx::socket_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } catch (clx::sockaddress_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } catch (std::runtime_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } return 0; } example/example_ssl_server.cpp0000700000175300010010000000574011077732652016304 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_ssl_server.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Wed 22 Oct 2008 14:50:03 JST */ /* ------------------------------------------------------------------------- */ #include #include #include "clx/ssl.h" int recv(clx::ssl::socket& sock); int main(int argc, char* argv[]) { if (argc < 2) return -1; try { clx::ssl::acceptor s(clx::lexical_cast(argv[1])); while (1) { clx::ssl::socket clt = s.accept("public.key", "private.key"); std::cout << clt.address().ipaddr() << ':' << clt.address().port() << " Connection was established" << std::endl; if (recv(clt) == -1) break; else { std::cout << clt.address().ipaddr() << ':' << clt.address().port() << " Connection was closed" << std::endl; clt.close(); } } } catch (clx::socket_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } catch (clx::sockaddress_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } catch (std::runtime_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } return 0; } int recv(clx::ssl::socket& sock) { clx::ssl::sockstream ss(sock); std::string msg; while (1) { std::string buf; ss >> buf; if (buf.empty()) break; msg += buf; } std::cout << "Receive messages: " << msg << std::endl; return 0; } example/example_stats.cpp0000700000175300010010000000473511035552010015234 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_stats.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Fri 02 Nov 2007 21:20:00 JST */ /* ------------------------------------------------------------------------- */ #include #include #include "clx/stats.h" int main(int argc, char* argv[]) { // 標準入力から読み込む std::istream_iterator input(std::cin); std::istream_iterator last; std::vector v; std::copy(input, last, std::inserter(v, v.begin())); std::cout << "sample: " << v.size() << std::endl; std::cout << "mean: " << clx::mean(v.begin(), v.end()) << std::endl; std::cout << "stddev: " << clx::stddev(v.begin(), v.end()) << std::endl; std::pair ci = clx::confidence_interval(v.begin(), v.end(), 2.06); std::cout << "95% confidence interval: [" << ci.first << ',' << ci.second << ']' << std::endl; return 0; } example/example_strftokenizer.cpp0000700000175300010010000000506711054627772017031 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_strftokenizer.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Tue 21 Feb 2006 23:34:00 JST */ /* ------------------------------------------------------------------------- */ #include #include "clx/tokenizer.h" int main(int argc, char* argv[]) { std::string s = "23:30:25.030254 IP 192.168.1.2.100 > 192.168.1.3.200: . ack 12 win 256 "; std::string fmt = "%s:%s:%s.%s IP %s > %s: %s ack %s win %s <%s>"; /* * memo: * clx::strftokenizer tok(clx::format_separator(fmt)); * と記述すると，下の行のtok.assign(s)，tok.size()でコンパイルエラーになる． * 原因が分からないので保留． * gcc version 3.4.4 (cygming special) */ clx::format_separator f(fmt); clx::strftokenizer tok(f); tok.assign(s); std::cout << "Member: " << tok.size() << std::endl; for (unsigned int i = 0; i < tok.size(); i++) { std::cout << '<' << tok[i] << "> "; } std::cout << std::endl; return 0; } example/example_strip.cpp0000700000175300010010000000454611035512076015247 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_strip.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Mon 22 Oct 2007 17:22:00 JST */ /* ------------------------------------------------------------------------- */ #include #include #include "clx/salgorithm.h" int main(int argc, char* argv[]) { std::string s = "*****Hello, world!*****"; std::cout << "original: " << s << std::endl; std::cout << "strip: " << clx::strip_copy_if(s, clx::is_any_of("*")) << std::endl; std::cout << "lstrip: " << clx::lstrip_copy_if(s, clx::is_any_of("*")) << std::endl; std::cout << "rstrip: " << clx::rstrip_copy_if(s, clx::is_any_of("*")) << std::endl; std::cout << "chop: " << clx::chop_copy_if(s, clx::is_any_of("*")) << std::endl; return 0; } example/example_table.cpp0000700000175300010010000000453311043241452015165 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_table.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Mon 20 Feb 2006 04:10:00 JST */ /* ------------------------------------------------------------------------- */ #include #include #include "clx/table.h" #include "clx/tokenizer.h" int main(int argc, char* argv[]) { clx::char_separator sep(','); // 分割方法を決めるためのポリシークラス clx::table v(std::cin, clx::create_tokenizer(sep)); for (size_t i = 0; i < v.size(); i++) { double sum = 0.0; for (size_t j = 0; j < v[i].size(); j++) sum += v[i][j]; std::cout << "line " << i + 1 << ": num " << v[i].size() << ", sum " << sum << ", average " << sum / v[i].size() << std::endl; } return 0; } example/example_tcp_client.cpp0000700000175300010010000000464311101074032016215 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_tcp_client.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Wed 28 Mar 2007 16:14:09 JST */ /* ------------------------------------------------------------------------- */ #include #include #include #include #include "clx/tcp.h" int main(int argc, char* argv[]) { if (argc < 3) std::exit(-1); try { clx::tcp::socket s; s.connect(argv[1], clx::tcp::port(argv[2])); clx::tcp::sockstream tcps(s); while (1) { std::string buf; std::cin >> buf; if (std::cin.eof()) break; tcps << buf; } s.close(); } catch (clx::socket_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } catch (clx::sockaddress_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } return 0; } example/example_tcp_server.cpp0000700000175300010010000000555611101074262016256 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_tcp_server.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Wed 09 Jul 2008 12:23:03 JST */ /* ------------------------------------------------------------------------- */ #include #include #include "clx/tcp.h" int recv(clx::tcp::socket sock); int main(int argc, char* argv[]) { if (argc < 2) std::exit(-1); try { clx::tcp::acceptor s(clx::tcp::port(argv[1])); while (1) { clx::tcp::socket clt = s.accept(); std::cout << clt.address().ipaddr() << ':' << clt.address().port() << " Connection was established" << std::endl; if (recv(clt) == -1) break; else { std::cout << clt.address().ipaddr() << ':' << clt.address().port() << " Connection was closed" << std::endl; clt.close(); } } s.close(); } catch (clx::socket_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } catch (clx::sockaddress_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } return 0; } int recv(clx::tcp::socket sock) { clx::tcp::sockstream ss(sock); std::string msg; while (1) { std::string buf; ss >> buf; if (buf.empty()) break; msg += buf; } std::cout << "Receive messages: " << msg << std::endl; return 0; } example/example_thread.cpp0000700000175300010010000000505011077251207015346 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_thread.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Wed 13 Aug 2008 13:00:04 JST */ /* ------------------------------------------------------------------------- */ #include #include "clx/thread.h" clx::mutex m_; class exfunctor { public: exfunctor() : c_('a') {} explicit exfunctor(char c) : c_(c) {} virtual ~exfunctor() {} void operator()() { for (int i = 0; i < 10; i++) { clx::mutex::scoped_lock lk(m_); for (int j = 0; j < i+5; j++) std::cout << c_ << std::flush; std::cout << '\n' << std::flush; } } private: char c_; }; int main(int argc, char* argv[]) { try { clx::thread t1(exfunctor('A')); clx::thread t2(exfunctor('B')); t1.join(); t2.join(); } catch (clx::system_error &e) { std::cerr << e.what() << std::endl; std::exit(-1); } std::cout << std::endl; std::cout << "end of main thread" << std::endl; return 0; } example/example_timer.cpp0000700000175300010010000000477511035656164015241 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_timer.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Thu 07 Sep 2006 00:15:00 JST */ /* ------------------------------------------------------------------------- */ #include #include "clx/timer.h" int heavy_func(int x) { return x <= 0 ? 1 : heavy_func(x - 1) + heavy_func(x - 1); } int main(int argc, char* argv[]) { clx::timer t; std::cout << "precision: " << t.precision() << " sec." << std::endl; std::cout << "start heavy_func(28)" << std::endl; heavy_func(28); std::cout << "total: " << t.total_elapsed() << " sec." << std::endl; std::cout << "latest: " << t.update() << " sec." << std::endl; std::cout << std::endl; std::cout << "start heavy_func(25)" << std::endl; heavy_func(25); std::cout << "total: " << t.total_elapsed() << " sec." << std::endl; std::cout << "latest: " << t.elapsed() << " sec." << std::endl; return 0; } example/example_tokenizer.cpp0000700000175300010010000000414411054627734016123 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_tokenizer.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Mon 20 Feb 2006 03:05:00 JST */ /* ------------------------------------------------------------------------- */ #include #include #include "clx/tokenizer.h" int main(int argc, char* argv[]) { std::string s = "This is, a test"; clx::tokenizer tok(s); for (unsigned int i = 0; i < tok.size(); i++) { std::cout << '<' << tok.at(i) << "> "; } std::cout << std::endl; return 0; } example/example_tokenmap.cpp0000700000175300010010000000521311075140163015712 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_tokenmap.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Wed 07 Jun 2006 21:09:00 JST */ /* ------------------------------------------------------------------------- */ #include #include #include #include "clx/tokenmap.h" typedef clx::basic_tokenmap > date_map; int main(int argc, char* argv[]) { std::string dateset = "ymdHMS"; std::string infmt = "%04y/%02m/%02d %2H:%02M:%02S"; std::string sdate = "2006/06/06 17:27:00"; std::cout << "Input format: " << infmt << std::endl; std::cout << "Sample: " << sdate << std::endl; // analyze time string. clx::format_separator f(infmt, dateset); date_map m(f); m.assign(sdate); // print time with output format. std::cout << std::endl; std::cout << "Result" << std::endl; std::cout << "--------------------" << std::endl; for (date_map::const_iterator p = m.begin(); p != m.end(); p++) { std::cout << "map[" << p->first << "] = " << p->second << std::endl; } return 0; } example/example_udp_recv.cpp0000700000175300010010000000426611101076370015710 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_udp_recv.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Sun 13 Jul 2008 13:37:00 JST */ /* ------------------------------------------------------------------------- */ #include #include #include "clx/udp.h" int main(int argc, char* argv[]) { if (argc < 2) std::exit(-1); clx::udp::socket s(clx::udp::port(argv[1])); clx::udp::sockstream ss(s); std::string buf; while (std::getline(ss, buf)) { std::cout << buf << " (from " << ss.from().ipaddr() << ':' << ss.from().port() << ')' << std::endl; } return 0; } example/example_udp_send.cpp0000700000175300010010000000415511101076330015673 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_udp_send.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Thu 07 Sep 2006 00:15:00 JST */ /* ------------------------------------------------------------------------- */ #include #include #include #include "clx/udp.h" int main(int argc, char* argv[]) { if (argc < 3) std::exit(-1); clx::udp::sockstream s(argv[1], clx::udp::port(argv[2])); std::string buf; while (std::getline(std::cin, buf)) { s << buf << std::endl; } return 0; } example/example_unit.cpp0000700000175300010010000000515411057715060015063 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_unit.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Thu 04 Sep 2008 17:10:00 JST */ /* ------------------------------------------------------------------------- */ #include #include "clx/unit.h" int main(int argc, char* argv[]) { std::cout << clx::nano(1) << ", "; std::cout << clx::micro(1) << ", "; std::cout << clx::milli(1) << ", "; std::cout << clx::kilo(1) << ", "; std::cout << clx::mega(1) << ", "; std::cout << clx::giga(1) << std::endl; std::cout << "2M + 34k = " << clx::mega(2) + clx::kilo(34) << std::endl; // 時間単位の入力値の合計を秒単位で出力 typedef clx::unit<3600> hour; hour sum; for (int i = 0; i < 10; i++) sum += i; std::cout << sum.value() << " hours -> " << sum << " seconds" << std::endl; // 分->時間単位への変換 typedef clx::unit<60> minute; minute minutes(1440); hour test = clx::unit_cast(minutes); std::cout << minutes.value() << " minutes -> " << test.value() << " hours" << std::endl; return 0; } example/example_uri.cpp0000700000175300010010000000434511050626076014705 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_uri.h * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Thu 14 Aug 2008 03:22:00 JST */ /* ------------------------------------------------------------------------- */ #include #include #include "clx/uri.h" #include "clx/html.h" int main(int argc, char* argv[]) { if (argc < 2) return -1; std::string src(argv[1]); std::string dest = clx::uri::encode(src); std::cout << "encode: " << dest << std::endl; std::cout << "decode: " << clx::uri::decode(dest) << std::endl; std::cout << "escape+encode: " << clx::uri::encode(clx::html::escape(src)) << std::endl; return 0; } example/example_wcstring.cpp0000700000175300010010000000506011075305025015734 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_wcstring.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Wed 15 Oct 2008 14:23:00 JST */ /* ------------------------------------------------------------------------- */ #ifndef CLX_USE_WCHAR #define CLX_USE_WCHAR #endif #include #include "clx/cstring.h" int main(int argc, char* argv[]) { std::wcout.imbue(std::locale("japanese")); wchar_t s1[256] = L"こんにちは、こんにちは。"; wchar_t s2[256] = L"こんにちは！こんにちは！"; wchar_t s3[256] = L"3.1415926"; std::wcout << L"string: " << s1 << std::endl; if (clx::strcmp(s1, s2) == 0) std::wcout << L"strcmp: match" << std::endl; else std::wcout << L"strcmp: unmatch" << std::endl; std::wcout << L"strlen: " << clx::strlen(s1) << std::endl; clx::strcat(s1, s2); std::wcout << L"strcat: " << s1 << std::endl; wchar_t* last = NULL; double pi = clx::strtod(s3, &last); std::wcout << L"strtod: " << pi << std::endl; return 0; } example/example_wsse.cpp0000700000175300010010000000551411073233005015055 0ustar clownなし/* ------------------------------------------------------------------------- */ /* * example_wsse.cpp * * Copyright (c) 2004 - 2008, clown. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * * - Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * - Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * - No names of its contributors may be used to endorse or promote * products derived from this software without specific prior written * permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Last-modified: Tue 02 Sep 2008 11:41:00 JST */ /* ------------------------------------------------------------------------- */ #include #include "clx/http.h" #include "clx/uri.h" #include "clx/wsse.h" int main(int argc, char* argv[]) { if (argc < 5) { std::cerr << "usage " << argv[0] << " domain path user_id password" << std::endl; std::exit(-1); } try { clx::http session(clx::uri::encode(argv[1])); std::map heads; heads["X-WSSE"] = clx::wsse(argv[3], argv[4]); session.get(clx::uri::encode(argv[2]), heads); std::cout << "code: " << session.code() << std::endl; std::cout << std::endl; std::cout << "head" << std::endl; std::cout << "--" << std::endl; for (clx::http::head_iterator pos = session.head().begin(); pos != session.head().end(); pos++) { std::cout << pos->first << ": " << pos->second << std::endl; } std::cout << std::endl; std::cout << "body" << std::endl; std::cout << "--" << std::endl; std::cout << session.body() << std::endl; } catch (clx::socket_error& e) { std::cerr << e.what() << std::endl; std::exit(-1); } return 0; }