The Big Programming Thread - Page 434

if (x){
     System.out.println("Found");
}

Scanner in = new Scanner (System.in);
int SearchValue = in.nextlnt();
int arr[] = { 1, 2, 3, 4, 5 };

System.out.print("Please input a number: ");

for (int n: arr)
{
    if (n == SearchValue)
    {
        System.out.println("Found");
    }
    else
    {
        System.out.println("Not found");
    }
}

for(NSString *aString in [array reverseObjectEnumerator])
{
      NSLog(@"Value: %@",aString);
}

#include <iostream>
#include <string>
#include <iterator>
#include <regex>
#include <sstream>


class bad_lexical_cast : public std::bad_cast
{
public:
	bad_lexical_cast(const char * _Message = "bad lexical cast") : std::bad_cast(_Message) {}
	bad_lexical_cast(const bad_lexical_cast &other) : std::bad_cast(other.what()) {}
	virtual ~bad_lexical_cast() {}
};
template<typename Target, typename Source>
Target lexical_cast(Source arg)
{
	std::stringstream interpreter;
	Target result;
	if (!(interpreter << arg) ||
		!(interpreter >> result) ||
		!(interpreter >> std::ws).eof())
		throw bad_lexical_cast();
	return result;
}
namespace detail
{
	template<unsigned int Index, typename Param, typename... Args>
	std::string d_format(std::string& msg, Param& t, Args&&... args)
	{
		return d_format<Index + 1>(d_format<Index>(msg, t), args...);
	}
	template<unsigned int Index, typename Param>
	std::string d_format(std::string& msg, Param& t)
	{
		std::stringstream ss;
		ss << '\\' << '{' << Index << '\\' << '}';
		std::regex reg{ std::move(ss.str()) };
		return std::regex_replace(msg, reg, lexical_cast<std::string>(t));
	}
}
template<class... Args>
std::string format(std::string msg, Args&&... args)
{
	return std::move(detail::d_format<0>(msg, args...));
}
int main()
{
	int x = 10;
	int y = 20;
	std::string a{ format("X:{0} Y:{1} Total:{2}, Time:{3}", x, y, x + y, 3.1345995f) };
	std::cout << a << std::endl;
	return 0;
}

class bad_lexical_cast : public std::bad_cast
{
public:
	bad_lexical_cast(const char * _Message = "bad lexical cast") : std::bad_cast(_Message) {}
	bad_lexical_cast(const bad_lexical_cast &other) : std::bad_cast(other.what()) {}
	virtual ~bad_lexical_cast() {}
};

template<typename Target, typename Source>
Target lexical_cast(Source arg)
{
	std::stringstream interpreter;
	Target result;
	if (!(interpreter << arg) ||
		!(interpreter >> result) ||
		!(interpreter >> std::ws).eof())
		throw bad_lexical_cast();
	return result;
}

Target lexical_cast(Source const& arg)

namespace detail
{
	template<unsigned int Index, typename Param, typename... Args>
	std::string d_format(std::string& msg, Param& t, Args&&... args)
	{
		return d_format<Index + 1>(d_format<Index>(msg, t), args...);
	}
	template<unsigned int Index, typename Param>
	std::string d_format(std::string& msg, Param& t)
	{
		std::stringstream ss;
		ss << '\\' << '{' << Index << '\\' << '}';
		std::regex reg{ std::move(ss.str()) };
		return std::regex_replace(msg, reg, lexical_cast<std::string>(t));
	}
}

	template<unsigned int Index, typename Param, typename... Args>
	std::string d_format(std::string const& msg, Param const& t, Args const&... args)

void func(T&&... t){
    some_other_func(t...);
}

void func(T&&... t){
    some_other_func(std::forward<T>(t));
}

template<class... Args>
std::string format(std::string msg, Args&&... args)
{
	return std::move(detail::d_format<0>(msg, args...));
}

#include<boost/regex.hpp>
#include<iostream>
#include<string>
#include<sstream>

struct bad_lexical_cast:std::bad_cast{
	virtual const char* what()const noexcept(true){ return "bad lexical cast"; }
	virtual ~bad_lexical_cast() {}
};

template<typename target_t, typename source_t>
target_t lexical_cast(source_t const& arg){
	std::stringstream interpreter;
	target_t result;
	if((interpreter<<arg)&&(interpreter>>result)&&(interpreter>>std::ws).eof())
		return result;
	throw bad_lexical_cast();
}

namespace guts{
	
	template<unsigned int index,typename... param_T>
	struct format;

	template<unsigned int index,typename param_t>
	struct format<index,param_t>{
		static std::string apply(std::string const& msg,param_t const& param){
			return boost::regex_replace(msg,boost::regex("\\{"+std::to_string(index)+"\\}"),lexical_cast<std::string>(param));
		}
	};

	template<unsigned int index,typename param_t,typename... param_T>
	struct format<index,param_t,param_T...>{
		static std::string apply(std::string const& msg,param_t const& param,param_T const&... params){
			return format<index+1,param_T...>::apply(format<index,param_t>::apply(msg,param),params...);
		}
	};

}

template<class... param_T>
std::string format(std::string const& msg,param_T const&... params){
	return guts::format<0,param_T...>::apply(msg,params...);
}

int main(){
	try{
		int x=10;
		int y=20;
		std::string a{format("X:{0} Y:{1} Total:{2}, Time:{3}", x, y, x + y, 3.1345995f)};
		std::cout<<a<<std::endl;
	}catch(bad_lexical_cast const& e){
		std::cout<<e.what()<<std::endl;
	}
	return 0;
}

std::string a{format("X:{0} Y:{1} Total:{2}, Time:{3}", x, newb_t(), x + y, 3.1345995f)};

g++ -c -O3 -std=c++0x -I. -Wfatal-errors  test.cpp
test.cpp: In instantiation of ‘target_t lexical_cast(const source_t&) [with target_t = std::basic_string<char>; source_t = newb_t]’:
test.cpp:42:115:   required from ‘static std::string guts::format<index, param_t>::apply(const string&, const param_t&) [with unsigned int index = 1u; param_t = newb_t; std::string = std::basic_string<char>]’
test.cpp:50:83:   required from ‘static std::string guts::format<index, param_t, param_T ...>::apply(const string&, const param_t&, const param_T& ...) [with unsigned int index = 1u; param_t = newb_t; param_T = {int, float}; std::string = std::basic_string<char>]’
test.cpp:50:94:   required from ‘static std::string guts::format<index, param_t, param_T ...>::apply(const string&, const param_t&, const param_T& ...) [with unsigned int index = 0u; param_t = int; param_T = {newb_t, int, float}; std::string = std::basic_string<char>]’
test.cpp:58:56:   required from ‘std::string format(const string&, const param_T& ...) [with param_T = {int, newb_t, int, float}; std::string = std::basic_string<char>]’
test.cpp:67:89:   required from here
test.cpp:16:17: error: cannot bind ‘std::basic_ostream<char>’ lvalue to ‘std::basic_ostream<char>&&’
  if((interpreter<<arg)&&(interpreter>>result)&&(interpreter>>std::ws).eof())
                 ^
compilation terminated due to -Wfatal-errors.

	
template<class param_t,class enable=void>
struct to_string{
	static_assert(sizeof(param_t)==0,"to_string trait not implemented for param_t!");
};

template<class numeric_t>
struct to_string<numeric_t,typename std::enable_if<std::is_arithmetic<numeric_t>::value>::type>{
	static std::string apply(numeric_t value){
		return std::to_string(value);
	}
};

specializations for string (just pass it through) etc...

g++ -c -O3 -std=c++0x -I. -Wfatal-errors  test.cpp
test.cpp: In instantiation of ‘struct guts::to_string<newb_t, void>’:
test.cpp:43:115:   required from ‘static std::string guts::format<index, param_t>::apply(const string&, const param_t&) [with unsigned int index = 1u; param_t = newb_t; std::string = std::basic_string<char>]’
test.cpp:50:83:   required from ‘static std::string guts::format<index, param_t, param_T ...>::apply(const string&, const param_t&, const param_T& ...) [with unsigned int index = 1u; param_t = newb_t; param_T = {int, float}; std::string = std::basic_string<char>]’
test.cpp:50:94:   required from ‘static std::string guts::format<index, param_t, param_T ...>::apply(const string&, const param_t&, const param_T& ...) [with unsigned int index = 0u; param_t = int; param_T = {newb_t, int, float}; std::string = std::basic_string<char>]’
test.cpp:58:56:   required from ‘std::string format(const string&, const param_T& ...) [with param_T = {int, newb_t, int, float}; std::string = std::basic_string<char>]’
test.cpp:67:89:   required from here
test.cpp:26:3: error: static assertion failed: to_string trait not implemented for param_t!
   static_assert(sizeof(param_t)==0,"to_string trait not implemented for param_t!");

   public Timer() {
      this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
      this.setTitle("Test Sound Clip");
      this.setSize(300, 200);
      this.setVisible(true);

      try {
         // Open an audio input stream.
      String urlLocation = System.getProperty("user.home") + "\\workspace\\GraemeTimer\\src\\htogether.mid";
      System.out.println(urlLocation);
         URL url = this.getClass().getClassLoader().getResource(urlLocation);
         System.out.println(url);
         AudioInputStream audioIn = AudioSystem.getAudioInputStream(url);
         // Get a sound clip resource.
         Clip clip = AudioSystem.getClip();
         // Open audio clip and load samples from the audio input stream.
         clip.open(audioIn);
         clip.start();
      } 
      catch (UnsupportedAudioFileException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      } catch (LineUnavailableException e) {
         e.printStackTrace();
      }
   }